resilient 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 822421a58f373992d96937a055b287a2f633ef1b
-  data.tar.gz: 6e29f01491cce3b1244998c9dc38758db56bc58d
+  metadata.gz: 4d96ef8b25a0a297da28e4c1f718ab826350a23d
+  data.tar.gz: 8bdf3b03abfedbcf9cd6531a7aad4cd2b3313a18
 SHA512:
-  metadata.gz: d6952a74ffed454c5c1909991db5dfd056dfb5f26932bc1537776cee363dcc55cbeff6b549da1ac112f124437032b92d24c071e516a9702bc72bd747187a3522
-  data.tar.gz: 9d1edae9fb8f13856fc988af0b257a7d2d2e184a04068e5dc1f054d945666c49cbe934ee5ff23e8a983ed074b27f527f5258bdcfced828ef420434bfd5669d8b
+  metadata.gz: 067674abbd47f23741bcc38ca4c99e0ddbcfb187d4e25b84e04841e0055a34ada9e368350868de7fc5363f811e8a20631fcd7d5e13c490918b86242c3f9154f5
+  data.tar.gz: 90c8672939280363a2da23664a4ebadf5e413ce40cf08b38130e00bea1923ac5971c126f2bba5b9c4417e639f16b89e9c92d1b2289e97af3662074e1719c549f

data/.travis.yml

@@ -1,4 +1,7 @@
 language: ruby
 rvm:
+  - 2.0.0
   - 2.1.4
+  - 2.2.3
 before_install: gem install bundler -v 1.10.6
+script: script/test

data/README.md

@@ -1,6 +1,8 @@
 # Resilient
 
-Some tools for resilient in ruby.
+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...
+
+Nothing asynchronous or thread safe yet either.
 
 ## Installation
 
@@ -25,13 +27,13 @@ require "resilient/circuit_breaker"
 
 # default config for circuit
 circuit_breaker = Resilient::CircuitBreaker.new
-if circuit_breaker.request_allowed?
+if circuit_breaker.allow_request?
   begin
     # do something expensive
     circuit_breaker.mark_success
   rescue => boom
-    # do fallback
     circuit_breaker.mark_failure
+    # do fallback
   end
 else
   # do fallback
@@ -41,7 +43,7 @@ end
 customize config of circuit:
 
 ```ruby
-config = Resilient::CircuitBreaker::RollingConfig.new({
+config = Resilient::CircuitBreaker::Config.new({
   # at what percentage of errors should we open the circuit
   error_threshold_percentage: 50,
   # do not try request again for 5 seconds
@@ -56,7 +58,7 @@ circuit_breaker = Resilient::CircuitBreaker.new(config: config)
 force the circuit to be always open:
 
 ```ruby
-config = Resilient::CircuitBreaker::RollingConfig.new(force_open: true)
+config = Resilient::CircuitBreaker::Config.new(force_open: true)
 circuit_breaker = Resilient::CircuitBreaker.new(config: config)
 # etc etc etc
 ```
@@ -64,7 +66,7 @@ circuit_breaker = Resilient::CircuitBreaker.new(config: config)
 force the circuit to be always closed:
 
 ```ruby
-config = Resilient::CircuitBreaker::RollingConfig.new(force_closed: true)
+config = Resilient::CircuitBreaker::Config.new(force_closed: true)
 circuit_breaker = Resilient::CircuitBreaker.new(config: config)
 # etc etc etc
 ```
@@ -72,7 +74,7 @@ circuit_breaker = Resilient::CircuitBreaker.new(config: config)
 customize rolling window to be 10 buckets of 1 second each (10 seconds in all):
 
 ```ruby
-metrics = Resilient::CircuitBreaker::RollingMetrics.new({
+metrics = Resilient::CircuitBreaker::Metrics.new({
   number_of_buckets: 10,
   bucket_size_in_seconds: 1,
 })

data/examples/basic.rb

@@ -0,0 +1,81 @@
+# setting up load path
+require "pathname"
+root_path = Pathname(__FILE__).dirname.join("..").expand_path
+lib_path  = root_path.join("lib")
+$:.unshift(lib_path)
+
+# requiring stuff for this example
+require "pp"
+require "resilient/circuit_breaker"
+
+config = Resilient::CircuitBreaker::Config.new({
+  sleep_window_seconds: 1,
+  request_volume_threshold: 10,
+  error_threshold_percentage: 25,
+})
+circuit_breaker = Resilient::CircuitBreaker.new(config: config)
+
+# success
+if circuit_breaker.allow_request?
+  begin
+    puts "do expensive thing"
+    circuit_breaker.mark_success
+  rescue => boom
+    # won't get here in this example
+    circuit_breaker.mark_failure
+  end
+else
+  raise "will not get here"
+end
+
+# failure
+if circuit_breaker.allow_request?
+  begin
+    raise
+  rescue => boom
+    circuit_breaker.mark_failure
+    puts "failed slow, do fallback"
+  end
+else
+  raise "will not get here"
+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
+end
+
+# fail fast
+if circuit_breaker.allow_request?
+  raise "will not get here"
+else
+  puts "failed fast, do fallback"
+end
+
+now = Time.now
+
+while Time.now - now < 3
+  if circuit_breaker.allow_request?
+    puts "doing a single attempt as we've failed fast for sleep_window_seconds"
+    break
+  else
+    puts "failed fast, do fallback"
+  end
+  sleep rand(0.1)
+end
+
+if circuit_breaker.allow_request?
+  raise "will not get here"
+else
+  puts "request denied because single request has not been marked success yet"
+end
+
+puts "marking single request as success"
+circuit_breaker.mark_success
+
+if circuit_breaker.allow_request?
+  puts "circuit reset and back closed now, allowing requests"
+else
+  raise "will not get here"
+end

data/examples/long_running.rb

@@ -0,0 +1,42 @@
+# setting up load path
+require "pathname"
+root_path = Pathname(__FILE__).dirname.join("..").expand_path
+lib_path  = root_path.join("lib")
+$:.unshift(lib_path)
+
+# requiring stuff for this example
+require "pp"
+require "resilient/circuit_breaker"
+
+config = Resilient::CircuitBreaker::Config.new({
+  sleep_window_seconds: 5,
+  request_volume_threshold: 20,
+  error_threshold_percentage: 10,
+  number_of_buckets: 10,
+  bucket_size_in_seconds: 1,
+})
+circuit_breaker = Resilient::CircuitBreaker.new(config: config)
+
+iterations = 0
+loop do
+  if circuit_breaker.allow_request?
+    begin
+      puts "request allowed"
+      raise if rand(100) < 10
+      puts "request succeeded"
+      circuit_breaker.mark_success
+    rescue => boom
+      puts "request failed"
+      circuit_breaker.mark_failure
+    end
+  else
+    puts "request denied"
+  end
+  puts "\n"
+  sleep 0.1
+  iterations += 1
+
+  if iterations % 10 == 0
+    p successes: circuit_breaker.metrics.successes, failures: circuit_breaker.metrics.failures, error_percentage: circuit_breaker.metrics.error_percentage, buckets: circuit_breaker.metrics.buckets.length
+  end
+end

data/lib/resilient/circuit_breaker.rb

@@ -1,5 +1,5 @@
-require "resilient/circuit_breaker/rolling_metrics"
-require "resilient/circuit_breaker/rolling_config"
+require "resilient/circuit_breaker/metrics"
+require "resilient/circuit_breaker/config"
 
 module Resilient
   class CircuitBreaker
@@ -8,14 +8,14 @@ module Resilient
     attr_reader :open
     attr_reader :opened_or_last_checked_at_epoch
 
-    def initialize(open: false, config: RollingConfig.new, metrics: RollingMetrics.new)
+    def initialize(open: false, config: Config.new, metrics: Metrics.new)
       @open = open
       @opened_or_last_checked_at_epoch = 0
       @config = config
       @metrics = if metrics
         metrics
       else
-        RollingMetrics.new({
+        Metrics.new({
           number_of_buckets: config.number_of_buckets,
           bucket_size_in_seconds: config.bucket_size_in_seconds,
         })
@@ -23,32 +23,74 @@ module Resilient
     end
 
     def allow_request?
-      return false if @config.force_open
-      return true if @config.force_closed
-
-      closed? || allow_single_request?
+      default_payload = {
+        force_open: false,
+        force_closed: false,
+      }
+
+      instrument("resilient.circuit_breaker.allow_request", default_payload) { |payload|
+        result = if payload[:force_open] = @config.force_open
+          false
+        else
+          if payload[:force_closed] = @config.force_closed
+            # we still want to simulate normal behavior/metrics like open, allow
+            # single request, etc. so it is possible to test config in
+            # production without impact
+            if payload[:open] = open?
+              payload[:allow_single_request] = allow_single_request?
+            end
+
+            true
+          else
+            if !(payload[:open] = open?)
+              true
+            else
+              payload[:allow_single_request] = allow_single_request?
+            end
+          end
+        end
+
+        payload[:result] = result
+      }
     end
 
     def mark_success
-      close_circuit if @open
+      default_payload = {
+        closed_the_circuit: false,
+      }
+
+      instrument("resilient.circuit_breaker.mark_success", default_payload) { |payload|
+        if @open
+          payload[:closed_the_circuit] = true
+          close_circuit
+        else
+          @metrics.mark_success
+        end
+        nil
+      }
     end
 
     def mark_failure
-      @metrics.mark_failure
+      instrument("resilient.circuit_breaker.mark_failure") { |payload|
+        @metrics.mark_failure
+        nil
+      }
     end
 
     def reset
-      @open = false
-      @opened_or_last_checked_at_epoch = 0
-      @metrics.reset
-      nil
+      instrument("resilient.circuit_breaker.reset") { |payload|
+        @open = false
+        @opened_or_last_checked_at_epoch = 0
+        @metrics.reset
+        nil
+      }
     end
 
     private
 
     def open_circuit
-      @open = true
       @opened_or_last_checked_at_epoch = Time.now.to_i
+      @open = true
     end
 
     def close_circuit
@@ -71,6 +113,7 @@ module Resilient
       return false if under_error_threshold_percentage?
 
       open_circuit
+      true
     end
 
     def closed?
@@ -78,15 +121,18 @@ module Resilient
     end
 
     def allow_single_request?
-      try_next_request_at = @opened_or_last_checked_at_epoch + @config.sleep_window_seconds
       now = Time.now.to_i
 
-      if @open && now > try_next_request_at
-        @opened_or_last_checked_at_epoch = now + @config.sleep_window_seconds
+      if @open && now > (@opened_or_last_checked_at_epoch + @config.sleep_window_seconds)
+        @opened_or_last_checked_at_epoch = now
         true
       else
         false
       end
     end
+
+    def instrument(name, payload = {}, &block)
+      config.instrumenter.instrument(name, payload, &block)
+    end
   end
 end

data/lib/resilient/circuit_breaker/{rolling_config.rb → config.rb}

@@ -1,17 +1,21 @@
+require "resilient/instrumenters/noop"
+
 module Resilient
   class CircuitBreaker
-    class RollingConfig
-      attr_reader :error_threshold_percentage
-      attr_reader :sleep_window_seconds
-      attr_reader :request_volume_threshold
+    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)

data/lib/resilient/circuit_breaker/metrics.rb

@@ -0,0 +1,164 @@
+require "resilient/circuit_breaker/metrics/storage/memory"
+
+module Resilient
+  class CircuitBreaker
+    class Metrics
+      attr_reader :number_of_buckets
+      attr_reader :bucket_size_in_seconds
+      attr_reader :buckets
+      attr_reader :storage
+
+      StorageSuccessKeys = [
+        :successes,
+      ].freeze
+
+      StorageFailureKeys = [
+        :failures,
+      ].freeze
+
+      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))
+        @storage = options.fetch(:storage) { Storage::Memory.new }
+        @buckets = []
+      end
+
+      def mark_success
+        @storage.increment(current_bucket, StorageSuccessKeys)
+        prune_buckets
+        nil
+      end
+
+      def mark_failure
+        @storage.increment(current_bucket, StorageFailureKeys)
+        prune_buckets
+        nil
+      end
+
+      def successes
+        prune_buckets
+        @storage.sum(@buckets, :successes)[:successes]
+      end
+
+      def failures
+        prune_buckets
+        @storage.sum(@buckets, :failures)[:failures]
+      end
+
+      def requests
+        prune_buckets
+        requests = 0
+        @storage.sum(@buckets, StorageKeys).each do |key, value|
+          requests += value
+        end
+        requests
+      end
+
+      def error_percentage
+        prune_buckets
+
+        result = @storage.sum(@buckets, StorageKeys)
+        successes = result[:successes]
+        failures = result[:failures]
+
+        requests = successes + failures
+        return 0 if failures == 0 || requests == 0
+
+        ((failures / requests.to_f) * 100).round
+      end
+
+      def reset
+        @storage.reset(@buckets, StorageKeys)
+        nil
+      end
+
+      private
+
+      def current_bucket(timestamp = Time.now.to_i)
+        bucket = @buckets.detect { |bucket| bucket.include?(timestamp) }
+        return bucket if bucket
+
+        bucket = @bucket_size.bucket(timestamp)
+        @buckets.push bucket
+
+        bucket
+      end
+
+      def prune_buckets(timestamp = Time.now.to_i)
+        pruned_buckets = []
+        bucket_range = BucketRange.generate(timestamp, @number_of_buckets, @bucket_size)
+
+        @buckets.delete_if { |bucket|
+          if bucket_range.prune?(bucket)
+            pruned_buckets << bucket
+            true
+          end
+        }
+
+        if pruned_buckets.any?
+          @storage.prune(pruned_buckets, StorageKeys)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Resilient
+  class CircuitBreaker
+    class Metrics
+      module Storage
+        class Memory
+          attr_reader :source
+
+          def initialize
+            @source = Hash.new { |h, k| h[k] = Hash.new(0) }
+          end
+
+          def increment(buckets, keys)
+            Array(buckets).each do |bucket|
+              Array(keys).each do |key|
+                @source[bucket][key] += 1
+              end
+            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|
+              Array(keys).each do |key|
+                response[key] += @source[bucket][key]
+              end
+            end
+            response
+          end
+
+          def reset(buckets, keys)
+            Array(buckets).each do |bucket|
+              @source.delete(bucket)
+            end
+          end
+
+          def prune(buckets, keys)
+            reset(buckets, keys)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resilient/instrumenters/memory.rb

@@ -0,0 +1,30 @@
+module Resilient
+  module Instrumenters
+    # Instrumentor that is useful for tests as it stores each of the events that
+    # are instrumented.
+    class Memory
+      Event = Struct.new(:name, :payload, :result)
+
+      attr_reader :events
+
+      def initialize
+        @events = []
+      end
+
+      def instrument(name, payload = {})
+        # Copy the payload to guard against later modifications to it, and to
+        # ensure that all instrumentation code uses the payload passed to the
+        # block rather than the one passed to #instrument.
+        payload = payload.dup
+
+        result = if block_given?
+          yield payload
+        else
+          nil
+        end
+        @events << Event.new(name, payload, result)
+        result
+      end
+    end
+  end
+end

data/lib/resilient/instrumenters/noop.rb

@@ -0,0 +1,9 @@
+module Resilient
+  module Instrumenters
+    class Noop
+      def self.instrument(name, payload = {})
+        yield payload if block_given?
+      end
+    end
+  end
+end

data/lib/resilient/test/circuit_breaker_interface.rb

@@ -0,0 +1,30 @@
+module Resilient
+  class Test
+    module CircuitBreakerInterface
+      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
+      end
+
+      def test_mark_success_returns_nothing
+        assert_nil @object.mark_success
+      end
+
+      def test_responds_to_mark_failure
+        assert_respond_to @object, :mark_failure
+      end
+
+      def test_mark_failure_returns_nothing
+        assert_nil @object.mark_failure
+      end
+
+      def test_responds_to_reset
+        assert_respond_to @object, :reset
+      end
+    end
+
+  end
+end

data/lib/resilient/test/config_interface.rb

@@ -0,0 +1,37 @@
+module Resilient
+  class Test
+    module ConfigInterface
+      def test_responds_to_force_open
+        assert_respond_to @object, :force_open
+      end
+
+      def test_responds_to_force_closed
+        assert_respond_to @object, :force_closed
+      end
+
+      def test_responds_to_instrumenter
+        assert_respond_to @object, :instrumenter
+      end
+
+      def test_responds_to_sleep_window_seconds
+        assert_respond_to @object, :sleep_window_seconds
+      end
+
+      def test_responds_to_request_volume_threshold
+        assert_respond_to @object, :request_volume_threshold
+      end
+
+      def test_responds_to_error_threshold_percentage
+        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
+    end
+  end
+end

data/lib/resilient/test/metrics_interface.rb

@@ -0,0 +1,45 @@
+module Resilient
+  class Test
+    module MetricsInterface
+      def test_responds_to_mark_success
+        assert_respond_to @object, :mark_success
+      end
+
+      def test_mark_success_returns_nothing
+        assert_nil @object.mark_success
+      end
+
+      def test_responds_to_mark_failure
+        assert_respond_to @object, :mark_failure
+      end
+
+      def test_mark_failure_returns_nothing
+        assert_nil @object.mark_failure
+      end
+
+      def test_responds_to_successes
+        assert_respond_to @object, :successes
+      end
+
+      def test_responds_to_failures
+        assert_respond_to @object, :failures
+      end
+
+      def test_responds_to_requests
+        assert_respond_to @object, :requests
+      end
+
+      def test_responds_to_error_percentage
+        assert_respond_to @object, :error_percentage
+      end
+
+      def test_responds_to_reset
+        assert_respond_to @object, :reset
+      end
+
+      def test_reset_returns_nothing
+        assert_nil @object.reset
+      end
+    end
+  end
+end

data/lib/resilient/test/metrics_storage_interface.rb

@@ -0,0 +1,142 @@
+module Resilient
+  class Test
+    module MetricsStorageInterface
+      def test_responds_to_increment
+        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
+
+      def test_responds_to_prune
+        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),
+          Resilient::CircuitBreaker::Metrics::Bucket.new(6, 10),
+        ]
+        keys = [
+          :successes,
+          :failures,
+        ]
+        @object.increment(buckets, keys)
+        assert_equal 1, @object.source[buckets[0]][:successes]
+        assert_equal 1, @object.source[buckets[0]][:failures]
+        assert_equal 1, @object.source[buckets[1]][:successes]
+        assert_equal 1, @object.source[buckets[1]][:failures]
+      end
+
+      def test_get_defaults
+        buckets = [
+          Resilient::CircuitBreaker::Metrics::Bucket.new(1, 5),
+          Resilient::CircuitBreaker::Metrics::Bucket.new(6, 10),
+        ]
+        keys = [
+          :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]
+      end
+
+      def test_sum
+        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)
+
+        assert_equal 5, @object.sum(buckets, [:successes])[:successes]
+        assert_equal 5, @object.sum(buckets, [:failures])[:failures]
+        assert_equal 10, @object.sum(buckets, keys).values.inject(0) { |sum, value| sum += value }
+
+        assert_equal 3, @object.sum(buckets[0], [:successes])[:successes]
+        assert_equal 3, @object.sum(buckets[0], [:failures])[:failures]
+        assert_equal 6, @object.sum(buckets[0], keys).values.inject(0) { |sum, value| sum += value }
+
+        assert_equal 2, @object.sum(buckets[1], [:successes])[:successes]
+        assert_equal 2, @object.sum(buckets[1], [:failures])[:failures]
+        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),
+          Resilient::CircuitBreaker::Metrics::Bucket.new(6, 10),
+        ]
+        keys = [
+          :successes,
+          :failures,
+        ]
+        @object.increment(buckets, keys)
+        @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]
+      end
+    end
+  end
+end

data/lib/resilient/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resilient
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - John Nunemaker
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-07 00:00:00.000000000 Z
+date: 2015-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,12 +66,19 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- TODO.md
+- examples/basic.rb
+- examples/long_running.rb
 - lib/resilient.rb
 - lib/resilient/circuit_breaker.rb
-- lib/resilient/circuit_breaker/rolling_config.rb
-- lib/resilient/circuit_breaker/rolling_metrics.rb
-- lib/resilient/circuit_breaker/rolling_metrics/bucket.rb
+- lib/resilient/circuit_breaker/config.rb
+- lib/resilient/circuit_breaker/metrics.rb
+- lib/resilient/circuit_breaker/metrics/storage/memory.rb
+- lib/resilient/instrumenters/memory.rb
+- lib/resilient/instrumenters/noop.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/version.rb
 - resilient.gemspec
 - script/bootstrap

data/TODO.md

@@ -1,4 +0,0 @@
-- [ ] instrumentation
-- [ ] add duration to mark success/failure; use it for tracking latency and for making circuit decisions
-- [ ] add timeout to metrics separate from failures (if we add duration)?
-- [ ] should force closed still instrument and all that so we can test in prod before enabling or should we allow enabling/disabling with instrumentation in a different way?

data/lib/resilient/circuit_breaker/rolling_metrics.rb

@@ -1,73 +0,0 @@
-require "resilient/circuit_breaker/rolling_metrics/bucket"
-
-module Resilient
-  class CircuitBreaker
-    class RollingMetrics
-      attr_reader :number_of_buckets
-      attr_reader :bucket_size_in_seconds
-      attr_reader :buckets
-
-      def initialize(options = {})
-        @number_of_buckets = options.fetch(:number_of_buckets, 6)
-        @bucket_size_in_seconds = options.fetch(:bucket_size_in_seconds, 10)
-        reset
-      end
-
-      def mark_success
-        timestamp = Time.now.to_i
-        bucket(timestamp).mark_success
-        prune_buckets(timestamp)
-        nil
-      end
-
-      def mark_failure
-        timestamp = Time.now.to_i
-        bucket(timestamp).mark_failure
-        prune_buckets(timestamp)
-        nil
-      end
-
-      def successes
-        prune_buckets
-        @buckets.inject(0) { |sum, bucket| sum += bucket.successes }
-      end
-
-      def failures
-        prune_buckets
-        @buckets.inject(0) { |sum, bucket| sum += bucket.failures }
-      end
-
-      def requests
-        prune_buckets
-        @buckets.inject(0) { |sum, bucket| sum += bucket.requests }
-      end
-
-      def error_percentage
-        return 0 if failures == 0 || requests == 0
-        ((failures / requests.to_f) * 100).to_i
-      end
-
-      def reset
-        @buckets = []
-        nil
-      end
-
-      private
-
-      def bucket(timestamp)
-        bucket = @buckets.detect { |bucket| bucket.include?(timestamp) }
-        return bucket if bucket
-
-        bucket = Bucket.new(timestamp, timestamp + @bucket_size_in_seconds - 1)
-        @buckets.push bucket
-
-        bucket
-      end
-
-      def prune_buckets(timestamp = Time.now.to_i)
-        cutoff = timestamp - (@number_of_buckets * @bucket_size_in_seconds)
-        @buckets.delete_if { |bucket| bucket.prune?(cutoff) }
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-module Resilient
-  class CircuitBreaker
-    class RollingMetrics
-      class Bucket
-        attr_reader :successes
-        attr_reader :failures
-
-        def initialize(timestamp_start, timestamp_end)
-          @timestamp_start = timestamp_start
-          @timestamp_end = timestamp_end
-          @successes = 0
-          @failures = 0
-        end
-
-        def mark_success
-          @successes += 1
-        end
-
-        def mark_failure
-          @failures += 1
-        end
-
-        def requests
-          @successes + @failures
-        end
-
-        def include?(timestamp)
-          timestamp >= @timestamp_start && timestamp <= @timestamp_end
-        end
-
-        def prune?(timestamp)
-          @timestamp_end <= timestamp
-        end
-      end
-    end
-  end
-end