supervision 0.1.0 → 0.2.0

data/lib/supervision/circuit_monitor.rb

@@ -4,10 +4,55 @@ module Supervision
   # A class responsible for recording circuit performance
   class CircuitMonitor
 
+    attr_reader :times_opened
+
+    # Timestamp for the last circuit open state
+    #
+    # @api public
+    attr_reader :last_opened
+
     def initialize
+      @total_failed_calls  = Counter.new
+      @total_success_calls = Counter.new
+      @total_calls         = Counter.new
+      @state_transitions   = Counter.new
+    end
+
+    def total_calls
+      @total_calls.value
+    end
+
+    def total_success_calls
+      @total_success_calls.value
+    end
+
+    def total_failed_calls
+      @total_failed_calls.value
+    end
+
+    def record_success
+      @total_success_calls.increment
+      @total_calls.increment
+    end
+
+    def record_failure
+      @total_failed_calls.increment
+      @total_calls.increment
+    end
+
+    def measure(type)
+
     end
 
-    def alert(type)
+    # Reset the circuit statistics
+    #
+    # @return [nil]
+    #
+    # @api public
+    def reset
+      total_calls.clear
+      total_success_calls.clear
+      total_failed_calls.clear
     end
-  end
+  end # CircuitMonitor
 end # Supervision

data/lib/supervision/circuit_system.rb

@@ -5,12 +5,41 @@ module Supervision
   class CircuitSystem
     extend Forwardable
 
-    def_delegators '@registry', :[], :get, :[]=, :set,
-                   :register, :delete, :unregister
+    attr_reader :registry
 
+    def_delegators '@registry', :[], :get, :[]=, :set, :register, :delete,
+                   :unregister, :names, :empty?, :registered?
+
+    # Create a CircuitSystem
+    #
+    # @api public
     def initialize
       @registry = Registry.new
     end
 
+    # Shutdown this circuit system
+    #
+    # @api public
+    def shutdown
+      @registry.clear
+    end
+
+    # Detailed string representation of this circuit system
+    #
+    # @return [String]
+    #
+    # @api public
+    def inspect
+      "#<#{self.class.name}:#{object_id}> @names=#{names}>"
+    end
+
+    # Detailed string representation of this circuit system
+    #
+    # @return [String]
+    #
+    # @api public
+    def to_s
+      "#<#{self.class.name}:#{object_id}> @names=#{names}>"
+    end
   end # CircuitSystem
 end # Supervision

data/lib/supervision/configuration.rb

@@ -22,6 +22,19 @@ module Supervision
                                                 DEFAULT_RESET_TIMEOUT))
     end
 
+    # Evalutate this configuration
+    #
+    # @return [self]
+    #
+    # @api public
+    def configure(&block)
+      if block.arity.zero?
+        instance_eval(&block)
+      else
+        yield self
+      end
+    end
+
     def max_failures=(value)
       @max_failures.set(value)
     end
@@ -64,9 +77,9 @@ module Supervision
       end
     end
 
-    # TODO: replace with custom error
     def raise_unknown_config_option(option)
-      raise ArgumentError, "`#{option}` isn`t recognized as valid parameter." \
+      raise InvalidParameterError,
+            "`#{option}` isn`t recognized as valid parameter." \
             " Please use one of `#{known_options.join(', ')}`"
     end
   end # Configuration

data/lib/supervision/counter.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+module Supervision
+  # A class responsible for measuring increments/decrements of value
+  class Counter
+    # Create a Counter
+    #
+    # @api public
+    def initialize
+      @count = Atomic.new(0)
+    end
+
+    # Reset the counter
+    #
+    # @return [nil]
+    #
+    # @api public
+    def clear
+      @count.set(0)
+    end
+
+    # Increment counter
+    #
+    # @return [nil]
+    #
+    # @api public
+    def increment(incr = 1)
+      @count.update { |v| v + incr }
+    end
+
+    # Decrement counter
+    #
+    # @param []
+    #
+    # @return [nil]
+    #
+    # @api public
+    def decrement(decr = 1)
+      @count.update { |v| v + decr }
+    end
+
+    # Return the value
+    #
+    # @api public
+    def value
+      @count.value
+    end
+  end # Counter
+end # Supervision

data/lib/supervision/registry.rb

@@ -3,7 +3,6 @@
 module Supervision
   # A class responsible for registering/unregistering circuits
   class Registry
-
     # Initialize a Registry
     #
     # @api public
@@ -14,10 +13,19 @@ module Supervision
 
     # Register a circuit
     #
+    # @param [String] name
+    #   the name under which to register
+    #
+    # @param [Supervision::CircuitBreaker] circuit
+    #   the registered circuit breaker
+    #
     # @api public
     def []=(name, circuit)
       unless circuit.is_a?(CircuitBreaker)
-        raise TypeError, 'not a circuit'
+        raise TypeError, 'not a type of circuit breaker'
+      end
+      if registered?(name)
+        raise DuplicateEntryError, "`#{name}` is already registered"
       end
       @lock.synchronize do
         @map[name.to_sym] = circuit
@@ -26,6 +34,8 @@ module Supervision
 
     # Retrieve a circuit by name
     #
+    # @param [String] name
+    #
     # @api public
     def [](name)
       @lock.synchronize do
@@ -48,15 +58,39 @@ module Supervision
 
     # Check if circuit is in registry
     #
+    # @return [Boolean]
+    #
     # @api public
     def registered?(name)
-      names.include?(name)
+      names.include?(name) || names.include?(name.to_sym)
     end
 
+    # Retrieve registered circuits' names
+    #
+    # @return [Array]
+    #
+    # @api public
     def names
       @lock.synchronize { @map.keys }
     end
 
+    # Check if registry is empty or not
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def empty?
+      @lock.synchronize { @map.empty? }
+    end
+
+    # Remove all registered circuits
+    #
+    # @example
+    #  registry.clear
+    #
+    # @return [Hash]
+    #
+    # @api public
     def clear
       hash = nil
       @lock.synchronize do

data/lib/supervision/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Supervision
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/spec_helper.rb

@@ -1,5 +1,20 @@
 # encoding: utf-8
 
+if RUBY_VERSION > '1.9' and (ENV['COVERAGE'] || ENV['TRAVIS'])
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name 'spec'
+    add_filter 'spec'
+  end
+end
+
 require 'supervision'
 require 'timeout'
 
@@ -9,6 +24,16 @@ module Helpers
       sleep(duration || 0.01) until yield
     end
   end
+
+  def spawn(threads = 2)
+    threads.times.map do |i|
+      Thread.new do
+        yield i
+      end
+    end.each do |thread|
+      thread.join
+    end
+  end
 end
 
 RSpec.configure do |config|

data/spec/unit/circuit_breaker_spec.rb

@@ -12,17 +12,34 @@ describe Supervision::CircuitBreaker do
 
   let(:object) { described_class }
 
+  it "fails without a block" do
+    expect { object.new }.to raise_error(Supervision::InvalidParameterError)
+  end
+
+  it "resets circuit" do
+    circuit = object.new { }
+    expect(circuit.control).to receive(:reset!)
+    circuit.reset!
+  end
+
+  it "configures the control" do
+    block = -> { }
+    circuit = object.new { }
+    expect(circuit.control.config).to receive(:configure).with(&block)
+    circuit.configure(&block)
+  end
 
   context 'when closed' do
     it "successfully calls the method" do
       circuit = object.new call_timeout: 1.milli do |arg|
         arg == :danger ? dangerouse_call_error : safe_call
       end
+      expect(circuit.current).to be(:closed)
       expect(circuit.call(:safe)).to eql(safe_call)
     end
 
     it "increments a failure counter for exceptions" do
-      circuit = object.new call_timeout: 1.milli do
+      circuit = object.new call_timeout: 1.milli do |arg|
         arg == :danger ? dangerouse_call_error : safe_call
       end
       circuit.call(:danger)
@@ -49,39 +66,39 @@ describe Supervision::CircuitBreaker do
     end
 
     it "enters a :half_open state after the :reset_timeout" do
-      circuit = object.new reset_timeout: 0.1.sec, max_failures: 0 do
+      circuit = object.new reset_timeout: 0.2.sec, max_failures: 0 do
         dangerous_call_error
       end
       expect { circuit.call }.to raise_error(Supervision::CircuitBreakerOpenError)
       expect(circuit.control.current).to eq(:open)
-      sleep 0.2
+      sleep 0.4
       expect(circuit.control.current).to eq(:half_open)
     end
   end
 
   context 'when half open' do
     it "resets the breaker back to :closed state on successful call" do
-      circuit = object.new reset_timeout: 100.milli, max_failures: 0 do |arg|
+      circuit = object.new reset_timeout: 0.2.sec, max_failures: 0 do |arg|
         arg == :danger ? dangerous_call_error : safe_call
       end
       expect {
         circuit.call(:danger)
       }.to raise_error(Supervision::CircuitBreakerOpenError)
       expect(circuit.control.current).to eql(:open)
-      sleep 0.2
+      sleep 0.4
       expect(circuit.control.current).to eql(:half_open)
       circuit.call(:safe)
       expect(circuit.control.current).to eql(:closed)
     end
   end
 
-  context 'when with callback' do
+  context 'with notification' do
     it "notifies about successful call" do
       callbacks = []
       circuit = object.new do safe_call end
       circuit.on_success { callbacks << 'on_success' }
       circuit.call
-      expect(callbacks).to eql(["on_success"])
+      expect(callbacks).to match_array(["on_success"])
     end
 
     it "notifies about failed call" do
@@ -90,13 +107,21 @@ describe Supervision::CircuitBreaker do
       circuit.on_failure { callbacks << 'on_failure'}
       circuit.before { callbacks << 'before'}
       circuit.call
-      expect(callbacks).to eql(['before', 'on_failure'])
+      expect(callbacks).to match_array(['before', 'on_failure'])
     end
   end
 
-  it "fails fast with unknown config option" do
-    expect {
-      object.new max_fail: 2 do safe_call end
-    }.to raise_error(ArgumentError)
+  describe "#to_s" do
+    it 'prints object info' do
+      circuit = object.new(name: :danger) { }
+      expect(circuit.to_s).to include("@name=danger")
+    end
+  end
+
+  describe "#inspect" do
+    it 'prints object info' do
+      circuit = object.new(name: :danger) { }
+      expect(circuit.inspect).to include("@name=danger")
+    end
   end
 end

data/spec/unit/circuit_control_spec.rb

@@ -7,7 +7,7 @@ describe Supervision::CircuitControl do
 
   let(:max_failures) { 1 }
 
-  let(:reset_timeout) { 0.1.sec }
+  let(:reset_timeout) { 0.2.sec }
 
   subject(:control) {
     object.new max_failures: max_failures,
@@ -17,56 +17,87 @@ describe Supervision::CircuitControl do
   context 'when closed' do
     it "resets the failure count on success" do
       expect(control.failure_count).to eql(0)
-      expect(control.fsm.current).to eql(:closed)
+      expect(control.current).to eql(:closed)
       control.record_failure
       expect(control.failure_count).to eql(1)
       control.reset_failure
       expect(control.failure_count).to eql(0)
-      expect(control.fsm.current).to eql(:closed)
+      expect(control.current).to eql(:closed)
     end
 
     it "increments failure count on exceptions and trips the wire" do
       expect(control.failure_count).to eql(0)
-      expect(control.fsm.current).to eql(:closed)
+      expect(control.current).to eql(:closed)
 
-      control.handle
+      control.handle_failure
       expect(control.failure_count).to eql(1)
-      expect(control.fsm.current).to eql(:closed)
+      expect(control.current).to eql(:closed)
 
-      expect{ control.handle }.to raise_error(Supervision::CircuitBreakerOpenError)
+      expect {
+        control.handle_failure
+      }.to raise_error(Supervision::CircuitBreakerOpenError)
       expect(control.failure_count).to eql(2)
-      expect(control.fsm.current).to eql(:open)
+      expect(control.current).to eql(:open)
     end
   end
 
   context 'when open' do
     it "fails all calls fast with CircuitBreakerOpenError" do
-      control.fsm.state = :open
-      expect { control.handle }.to raise_error(Supervision::CircuitBreakerOpenError)
-      expect(control.fsm.current).to eql(:open)
+      control.trip!
+      expect {
+        control.handle_failure
+      }.to raise_error(Supervision::CircuitBreakerOpenError)
+      expect(control.current).to eq(:open)
     end
 
     it "enters :half_open state after the configured :reset_timeout" do
       control.record_failure
-      expect{ control.handle }.to raise_error(Supervision::CircuitBreakerOpenError)
-      sleep 0.2
-      expect(control.fsm.current).to eql(:half_open)
+      expect {
+        control.handle_failure
+      }.to raise_error(Supervision::CircuitBreakerOpenError)
+      sleep 2 * reset_timeout
+      expect(control.current).to eq(:half_open)
     end
   end
 
   context 'when half open' do
-    before { control.fsm.state = :half_open }
+    before { control.attempt_reset! }
 
     it "resets the breaker back to :closed state on successful call" do
+      expect(control.current).to eq(:half_open)
       control.record_success
-      expect(control.fsm.current).to eql(:closed)
+      expect(control.current).to eql(:closed)
       expect(control.failure_count).to eql(0)
     end
 
     it "trips the breaker back to :open state on failed call" do
-      expect { control.handle }.to raise_error(Supervision::CircuitBreakerOpenError)
+      expect(control.current).to eq(:half_open)
+      expect {
+        control.handle_failure
+      }.to raise_error(Supervision::CircuitBreakerOpenError)
       expect(control.failure_count).to eql(1)
-      expect(control.fsm.current).to eql(:open)
+      expect(control.current).to eql(:open)
     end
   end
+
+  describe "#measure_timeout" do
+    it "kills the scheduler thread" do
+      expect {
+        control.trip
+      }.to raise_error(Supervision::CircuitBreakerOpenError)
+      expect(control.current).to eq(:open)
+      expect(control.scheduler).to receive(:kill).once
+      control.stub(:max_thread_lifetime).and_return 0
+      sleep reset_timeout
+      expect(control.current).to eq(:open)
+    end
+  end
+
+  it "forces reset to closed state" do
+    control.attempt_reset!
+    expect(control.current).to eq(:half_open)
+    expect(control).to receive(:reset_failure)
+    control.reset!
+    expect(control.current).to eq(:closed)
+  end
 end