circuitbox 1.0.3 → 2.0.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f75524d25326132f1bac120effbfa9b130f95bf1
-  data.tar.gz: ee8a589ff7b55ea95f5e5d119e7c30fe7be4e640
+  metadata.gz: 91bcf88d24630e489540fd2c149ce6b468ecdd7e
+  data.tar.gz: 8576e094971fb74bb390b2a1508fd6c330644915
 SHA512:
-  metadata.gz: 280e82433f43b428b48ee4e5a5a713da46deb723f8df9d886b3e2bf1e7eb922a119c367a706f66d82ee5d731090580773de06030f451ea40784ae544218e1953
-  data.tar.gz: 1b64ba171cfe40c0956ed38f94cc3e37c3e848a051cc987a2944b7578362ab5f51992757208dea50559cb5338d3fcff9c7fa2537ba9df047bfb05f1dabbc4038
+  metadata.gz: 7e2246d5b01dddaa5fb1e3637f5f66a1bb1a9ffcbf20d8bec5d28d787328f748b7dc1818a72662ede92aab94eae32f1608eacc42697cd0fbe72f5ef16f7c42c9
+  data.tar.gz: 9b2022385d22e3e6fc31a1be8028fa047a49fb59f09779c77bdae53712ab8cda482513f6dd7909a1ee3b04ca4a6fdcb1d9a110cc57febb1b5e712b19f284b4a0

data/README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.org/yammer/circuitbox.svg?branch=master)](https://travis-ci.org/yammer/circuitbox) [![Gem Version](https://badge.fury.io/rb/circuitbox.svg)](https://badge.fury.io/rb/circuitbox)
 
-Circuitbox is a Ruby circuit breaker gem. It protects your application from failures of it's service dependencies. It wraps calls to external services and monitors for failures in one minute intervals. Once more than 10 requests have been made with a 50% failure rate, Circuitbox stops sending requests to that failing service for one minute. This helps your application gracefully degrade.
+Circuitbox is a Ruby circuit breaker gem. It protects your application from failures of its service dependencies. It wraps calls to external services and monitors for failures in one minute intervals. Once more than 10 requests have been made with a 50% failure rate, Circuitbox stops sending requests to that failing service for one minute. This helps your application gracefully degrade.
 Resources about the circuit breaker pattern:
 * [http://martinfowler.com/bliki/CircuitBreaker.html](http://martinfowler.com/bliki/CircuitBreaker.html)
 * [https://github.com/Netflix/Hystrix/wiki/How-it-Works#CircuitBreaker](https://github.com/Netflix/Hystrix/wiki/How-it-Works#CircuitBreaker)
@@ -10,13 +10,13 @@ Resources about the circuit breaker pattern:
 ## Usage
 
 ```ruby
-Circuitbox[:your_service] do
+Circuitbox.circuit(:your_service, exceptions: [Net::ReadTimeout]) do
   Net::HTTP.get URI('http://example.com/api/messages')
 end
 ```
 
 Circuitbox will return nil for failed requests and open circuits.
-If your HTTP client has it's own conditions for failure, you can pass an `exceptions` option.
+If your HTTP client has its own conditions for failure, you can pass an `exceptions` option.
 
 ```ruby
 class ExampleServiceClient
@@ -25,47 +25,82 @@ class ExampleServiceClient
   end
 
   def http_get
-    circuit.run do
+    circuit.run(circuitbox_exceptions: false) do
       Zephyr.new("http://example.com").get(200, 1000, "/api/messages")
     end
   end
 end
 ```
 
-Using the `run!` method will throw an exception when the circuit is open or the underlying service fails.
+Using the `run` method will throw an exception when the circuit is open or the underlying service fails.
 
 ```ruby
   def http_get
-    circuit.run! do
+    circuit.run do
       Zephyr.new("http://example.com").get(200, 1000, "/api/messages")
     end
   end
 ```
 
+## Global Configuration
+Circuitbox has defaults for circuit_store, notifier, timer, and logger.
+This can be configured through ```Circuitbox.configure```.
+The circuit cache used by ```Circuitbox.circuit``` will be cleared after running ```Circuitbox.configure```.
+This means when accessing the circuit through ```Circuitbox.circuit``` any custom configuration options should always be given.
 
-## Configuration
+Any circuit created manually through ```Circuitbox::CircuitBreaker``` before updating the configuration
+will need to be recreated to pick up the new defaults.
+
+```ruby
+  Circuitbox.configure do |config|
+    config.default_circuit_store = Circuitbox::MemoryStore.new
+    config.default_notifier = Circuitbox::Notifier::Null.new
+    config.default_timer = Circuitbox::Timer::Simple.new
+    config.default_logger = Rails.logger
+  end
+```
+
+
+## Per-Circuit Configuration
 
 ```ruby
 class ExampleServiceClient
   def circuit
     Circuitbox.circuit(:your_service, {
+      # exceptions circuitbox tracks for counting failures (required)
       exceptions:       [YourCustomException],
 
       # seconds the circuit stays open once it has passed the error threshold
       sleep_window:     300,
 
-      # number of requests within 1 minute before it calculates error rates
+      # length of interval (in seconds) over which it calculates the error rate
+      time_window:      60,
+
+      # number of requests within `time_window` seconds before it calculates error rates (checked on failures)
       volume_threshold: 10,
 
       # the store you want to use to save the circuit state so it can be
       # tracked, this needs to be Moneta compatible, and support increment
-      cache: Moneta.new(:Memory)
+      # this overrides what is set in the global configuration
+      cache: Circuitbox::MemoryStore.new,
 
-      # exceeding this rate will open the circuit
+      # exceeding this rate will open the circuit (checked on failures)
       error_threshold:  50,
 
-      # seconds before the circuit times out
-      timeout_seconds:  1
+      # Logger to use
+      # This overrides what is set in the global configuration
+      logger: Logger.new(STDOUT),
+
+      # Customized Timer object
+      # Use NullTimer if you don't want to time circuit execution
+      # Use MonotonicTimer to avoid bad time metrics on system time resync
+      # This overrides what is set in the global configuration
+      execution_timer: SimpleTimer,
+
+      # Customized notifier
+      # overrides the default
+      # this overrides what is set in the global configuration
+      notifier: Notifier.new
     })
   end
 end
@@ -75,29 +110,26 @@ You can also pass a Proc as an option value which will evaluate each time the ci
 
 ```ruby
 Circuitbox.circuit(:yammer, {
-  sleep_window: Proc.new { Configuration.get(:sleep_window) }
+  sleep_window: Proc.new { Configuration.get(:sleep_window) },
+  exceptions: [Net::ReadTimeout]
 })
 ```
 
 ## Circuit Store (:cache)
 
 Holds all the relevant data to trip the circuit if a given number of requests
-fail in a specified period of time. The store is based on
-[Moneta](https://github.com/minad/moneta) so there are a lot of stores to choose
-from. There are some pre-requisits they need to satisfy so:
-
-- Need to support increment, this is true for most but not all available stores.
-- Need to support concurrent access if you share them. For example sharing a
+fail in a specified period of time. Circuitbox also supports
+[Moneta](https://github.com/minad/moneta). As moneta is not a dependency of circuitbox
+it needs to be loaded prior to use. There are a lot of moneta stores to choose from but
+some pre-requisits need to be satisfied first:
+
+- Needs to support increment, this is true for most but not all available stores.
+- Needs to support expiry.
+- Needs to support concurrent access if you share them. For example sharing a
   KyotoCabinet store across process fails because the store is single writer
   multiple readers, and all circuits sharing the store need to be able to write.
 
 
-## Monitoring & Statistics
-
-You can also run `rake circuits:stats SERVICE={service_name}` to see successes, failures and opened circuits.
-Add `PARTITION={partition_key}` to see the circuit for a particular partition.
-The stats are aggregated into 1 minute intervals.
-
 ## Notifications
 
 circuitbox use ActiveSupport Notifications.
@@ -117,7 +149,7 @@ ActiveSupport::Notifications.subscribe('circuit_close') do |name, start, finish,
   circuit_name = payload[:circuit]
   Rails.logger.info("Close circuit for: #{circuit_name}")
 end
-````
+```
 
 **generate metrics:**
 
@@ -136,9 +168,7 @@ end
 
 `payload[:gauge]` can be:
 
-- `failure_count`
-- `success_count`
-- `error_rate`
+- `execution_time` # execution time will only be notified when circuit is closed and block is successfully executed.
 
 **warnings:**
 in case of misconfiguration, circuitbox will fire a circuitbox_warning
@@ -153,77 +183,6 @@ end
 
 ```
 
-### Multi process Circuits
-
-`circuit_store` is backed by [Moneta](https://github.com/minad/moneta) which
-supports multiple backends. This can be configured by passing `cache:
-Moneta.new(:PStore, file: "myfile.store")` to use for example the built in
-PStore ruby library for persisted store, which can be shared cross process.
-
-Depending on your requirements different stores can make sense, see the
-benchmarks and [moneta
-feature](https://github.com/minad/moneta#backend-feature-matrix) matrix for
-details.
-
-```
-user     system      total        real
-memory:    1.440000   0.140000   1.580000 (  1.579244)
-lmdb:      4.330000   3.280000   7.610000 ( 13.086398)
-pstore:   23.680000   4.350000  28.030000 ( 28.094312)
-daybreak:  2.270000   0.450000   2.720000 (  2.626748)
-```
-
-You can run the benchmarks yourself by running `rake benchmark`.
-
-### Memory
-
-An in memory store, which is local to the process. This is not threadsafe so it
-is not useable with multithreaded webservers for example. It is always going to
-be the fastest option if no multi-process or thread is required, like in
-development on Webbrick.
-
-This is the default.
-
-```ruby
-Circuitbox.circuit :identifier, cache: Moneta.new(:Memory)
-```
-
-### LMDB
-
-An persisted directory backed store, which is thread and multi process safe.
-depends on the `lmdb` gem. It is slower than Memory or Daybreak, but can be
-used in multi thread and multi process environments like like Puma.
-
-```ruby
-require "lmdb"
-Circuitbox.circuit :identifier, cache: Moneta.new(:LMDB, dir: "./", db: "mydb")
-```
-
-### PStore
-
-An persisted file backed store, which comes with the ruby
-[stdlib](http://ruby-doc.org/stdlib-2.3.0/libdoc/pstore/rdoc/PStore.html). It
-has no external dependecies and works on every ruby implementation. Due to it
-being file backed it is multi process safe, good for development using Unicorn.
-
-```ruby
-Circuitbox.circuit :identifier, cache: Moneta.new(:PStore, file: "db.pstore")
-```
-
-### Daybreak
-
-Persisted, file backed key value store in pure ruby. It is process safe and
-outperforms most other stores in circuitbox. This is recommended for production
-use with Unicorn. It depends on the `daybreak` gem.
-
-```ruby
-require "daybreak"
-Circuitbox.circuit :identifier, cache: Moneta.new(:Daybreak, file: "db.daybreak", expires: true)
-```
-
-It is important for the store to have
-[expires](https://github.com/minad/moneta#backend-feature-matrix) support.
-
 ## Faraday
 
 Circuitbox ships with [Faraday HTTP client](https://github.com/lostisland/faraday) middleware.
@@ -247,24 +206,15 @@ end
 By default the Faraday middleware returns a `503` response when the circuit is
 open, but this as many other things can be configured via middleware options
 
-* `exceptions` pass a list of exceptions for the Circuitbreaker to catch,
-  defaults to Timeout and Request failures
-
-```ruby
-c.use Circuitbox::FaradayMiddleware, exceptions: [Faraday::Error::TimeoutError]
-```
-
 * `default_value` value to return for open circuits, defaults to 503 response
   wrapping the original response given by the service and stored as
   `original_response` property of the returned 503, this can be overwritten
   with either
   * a static value
   * a `lambda` which is passed the `original_response` and `original_error`.
-    `original_response` will be populated if Faraday returne an error response,
+    `original_response` will be populated if Faraday returns an error response,
     `original_error` will be populated if an error was thrown before Faraday
-    returned a response.  (It will also accept a lambda with arity 1 that is
-    only passed `original_response`.  This use is deprecated and will be removed
-    in the next major version.)
+    returned a response.
 
 ```ruby
 c.use Circuitbox::FaradayMiddleware, default_value: lambda { |response, error| ... }
@@ -276,15 +226,9 @@ c.use Circuitbox::FaradayMiddleware, default_value: lambda { |response, error| .
 c.use Circuitbox::FaradayMiddleware, identifier: "service_name_circuit"
 ```
 
-* `circuit_breaker_run_options` options passed to the circuit run method, see
-  the main circuitbreaker for those.
-
-```ruby
-conn.get("/api", circuit_breaker_run_options: {})
-```
-
 * `circuit_breaker_options` options to initialize the circuit with defaults to
-  `{ volume_threshold: 10, exceptions: Circuitbox::FaradayMiddleware::DEFAULT_EXCEPTIONS }`
+  `{ exceptions: Circuitbox::FaradayMiddleware::DEFAULT_EXCEPTIONS }`.
+  Accepts same options as Circuitbox:CircuitBreaker#new
 
 ```ruby
 c.use Circuitbox::FaradayMiddleware, circuit_breaker_options: {}
@@ -298,7 +242,9 @@ c.use Circuitbox::FaradayMiddleware, open_circuit: lambda { |response| response.
 ```
 
 ## CHANGELOG
-### version next
+### v1.1.0
+- ruby 2.2 support [#58](https://github.com/yammer/circuitbox/pull/58)
+- configurable logger [#58](https://github.com/yammer/circuitbox/pull/58)
 
 ### v1.0.3
 - fix timeout issue for default configuration, as default `:Memory` adapter does
@@ -315,7 +261,7 @@ c.use Circuitbox::FaradayMiddleware, open_circuit: lambda { |response| response.
   removing the related railtie.
 
 ### v1.0.0
-- support for cross process circuitbreakers by swapping the circuitbreaker store for a 
+- support for cross process circuitbreakers by swapping the circuitbreaker store for a
   `Moneta` supported key value store.
 - Change `FaradayMiddleware` default behaviour to not open on `4xx` errors but just on `5xx`
   server errors and connection errors
@@ -351,7 +297,7 @@ c.use Circuitbox::FaradayMiddleware, open_circuit: lambda { |response| response.
 
 ### v0.10
 - configuration option for faraday middleware for what should be considered to open the circuit [enrico-scalavio](https://github.com/enrico-scalavino)
-- fix for issue 16, support of in_parallel requests in faraday middlware which were opening the circuit.
+- fix for issue 16, support of in_parallel requests in faraday middleware which were opening the circuit.
 - deprecate the __run_option__ `:storage_key`
 
 ### v0.9

data/lib/circuitbox.rb

@@ -1,67 +1,23 @@
 require 'uri'
-require 'singleton'
-require 'active_support'
 require 'logger'
-require 'timeout'
-require 'moneta'
 
-require 'circuitbox/version'
-require 'circuitbox/memcache_store'
-require 'circuitbox/circuit_breaker'
-require 'circuitbox/notifier'
-
-require 'circuitbox/errors/error'
-require 'circuitbox/errors/open_circuit_error'
-require 'circuitbox/errors/service_failure_error'
+require_relative 'circuitbox/version'
+require_relative 'circuitbox/circuit_breaker'
+require_relative 'circuitbox/errors/error'
+require_relative 'circuitbox/errors/open_circuit_error'
+require_relative 'circuitbox/errors/service_failure_error'
+require_relative 'circuitbox/configuration'
 
 class Circuitbox
-  attr_accessor :circuits, :circuit_store
-  cattr_accessor :configure
+  class << self
+    include Configuration
 
-  def self.instance
-    @@instance ||= new
-  end
+    def circuit(service_name, options)
+      circuit = (cached_circuits[service_name] ||= CircuitBreaker.new(service_name, options))
 
-  def initialize
-    self.instance_eval(&@@configure) if @@configure
-  end
-
-  def self.configure(&block)
-    @@configure = block if block
-  end
-
-  def self.reset
-    @@instance = nil
-    @@configure = nil
-  end
-
-  def self.circuit_store
-    self.instance.circuit_store ||= Moneta.new(:Memory, expires: true)
-  end
+      return circuit unless block_given?
 
-  def self.circuit_store=(store)
-    self.instance.circuit_store = store
-  end
-
-  def self.[](service_identifier, options = {})
-    self.circuit(service_identifier, options)
-  end
-
-  def self.circuit(service_identifier, options = {})
-    service_name = self.parameter_to_service_name(service_identifier)
-
-    self.instance.circuits ||= Hash.new
-    self.instance.circuits[service_name] ||= CircuitBreaker.new(service_name, options)
-
-    if block_given?
-      self.instance.circuits[service_name].run { yield }
-    else
-      self.instance.circuits[service_name]
+      circuit.run(circuitbox_exceptions: false) { yield }
     end
   end
-
-  def self.parameter_to_service_name(param)
-    uri = URI(param.to_s)
-    uri.host.present? ? uri.host : param.to_s
-  end
 end

data/lib/circuitbox/circuit_breaker.rb

@@ -1,15 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'circuit_breaker/logger_messages'
+
 class Circuitbox
   class CircuitBreaker
-    attr_accessor :service, :circuit_options, :exceptions, :partition,
-                  :logger, :circuit_store, :notifier
+    include LoggerMessages
+
+    attr_reader :service, :circuit_options, :exceptions,
+                :logger, :circuit_store, :notifier, :time_class, :execution_timer
 
     DEFAULTS = {
-      sleep_window:     300,
+      sleep_window:     90,
       volume_threshold: 5,
       error_threshold:  50,
-      timeout_seconds:  1,
-      time_window:      60,
-    }
+      time_window:      60
+    }.freeze
 
     #
     # Configuration options
@@ -17,241 +22,215 @@ class Circuitbox
     # `sleep_window`      - seconds to sleep the circuit
     # `volume_threshold`  - number of requests before error rate calculation occurs
     # `error_threshold`   - percentage of failed requests needed to trip circuit
-    # `timeout_seconds`   - seconds until it will timeout the request
-    # `exceptions`        - exceptions other than Timeout::Error that count as failures
+    # `exceptions`        - exceptions that count as failures
     # `time_window`       - interval of time used to calculate error_rate (in seconds) - default is 60s
+    # `logger`            - Logger to use - defaults to Rails.logger if defined, otherwise STDOUT
     #
     def initialize(service, options = {})
-      @service = service
-      @circuit_options = options
-      @circuit_store   = options.fetch(:cache) { Circuitbox.circuit_store }
-      @notifier        = options.fetch(:notifier_class) { Notifier }
+      @service = service.to_s
+      @circuit_options = DEFAULTS.merge(options)
+      @circuit_store   = options.fetch(:cache) { Circuitbox.default_circuit_store }
+      @execution_timer = options.fetch(:execution_timer) { Circuitbox.default_timer }
+      @notifier = options.fetch(:notifier) { Circuitbox.default_notifier }
+
+      if @circuit_options[:timeout_seconds]
+        warn('timeout_seconds was removed in circuitbox 2.0. '\
+             'Check the upgrade guide at https://github.com/yammer/circuitbox')
+      end
 
-      @exceptions = options.fetch(:exceptions) { [] }
-      @exceptions = [Timeout::Error] if @exceptions.blank?
+      @exceptions = options.fetch(:exceptions)
+      raise ArgumentError, 'exceptions need to be an array' unless @exceptions.is_a?(Array)
 
-      @logger     = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
-      @time_class   = options.fetch(:time_class) { Time }
-      sanitize_options
+      @logger     = options.fetch(:logger) { Circuitbox.default_logger }
+      @time_class = options.fetch(:time_class) { Time }
+      @state_change_mutex = Mutex.new
+      check_sleep_window
     end
 
     def option_value(name)
-      value = circuit_options.fetch(name) { DEFAULTS.fetch(name) }
+      value = circuit_options[name]
       value.is_a?(Proc) ? value.call : value
     end
 
-    def run!(run_options = {})
-      @partition = run_options.delete(:partition) # sorry for this hack.
-
+    def run(circuitbox_exceptions: true)
       if open?
-        logger.debug "[CIRCUIT] open: skipping #{service}"
-        open! unless open_flag?
-        raise Circuitbox::OpenCircuitError.new(service)
+        skipped!
+        raise Circuitbox::OpenCircuitError.new(service) if circuitbox_exceptions
       else
-        close! if was_open?
-        logger.debug "[CIRCUIT] closed: querying #{service}"
+        logger.debug(circuit_running_message)
 
         begin
-          response = if exceptions.include? Timeout::Error
-            timeout_seconds = run_options.fetch(:timeout_seconds) { option_value(:timeout_seconds) }
-            timeout (timeout_seconds) { yield }
-          else
+          response = execution_timer.time(service, notifier, 'execution_time') do
             yield
           end
 
-          logger.debug "[CIRCUIT] closed: #{service} querie success"
           success!
         rescue *exceptions => exception
-          logger.debug "[CIRCUIT] closed: detected #{service} failure"
+          # Other stores could raise an exception that circuitbox is asked to watch.
+          # setting to nil keeps the same behavior as the previous defination of run.
+          response = nil
           failure!
-          open! if half_open?
-          raise Circuitbox::ServiceFailureError.new(service, exception)
+          raise Circuitbox::ServiceFailureError.new(service, exception) if circuitbox_exceptions
         end
       end
 
-      return response
-    end
-
-    def run(run_options = {})
-      begin
-        run!(run_options, &Proc.new)
-      rescue Circuitbox::Error
-        nil
-      end
+      response
     end
 
     def open?
-      if open_flag?
-        true
-      elsif passed_volume_threshold? && passed_rate_threshold?
-        true
-      else
-        false
-      end
+      circuit_store.key?(open_storage_key)
     end
 
     def error_rate(failures = failure_count, success = success_count)
       all_count = failures + success
       return 0.0 unless all_count > 0
-      failure_count.to_f / all_count.to_f * 100
+      (failures / all_count.to_f) * 100
     end
 
     def failure_count
-      circuit_store.load(stat_storage_key(:failure), raw: true).to_i
+      circuit_store.load(stat_storage_key('failure'), raw: true).to_i
     end
 
     def success_count
-      circuit_store.load(stat_storage_key(:success), raw: true).to_i
+      circuit_store.load(stat_storage_key('success'), raw: true).to_i
     end
 
     def try_close_next_time
-      circuit_store.delete(storage_key(:asleep))
+      circuit_store.delete(open_storage_key)
     end
 
   private
-    def open!
-      log_event :open
-      logger.debug "[CIRCUIT] opening #{service} circuit"
-      circuit_store.store(storage_key(:asleep), true, expires: option_value(:sleep_window))
-      half_open!
-      was_open!
-    end
 
-    ### BEGIN - all this is just here to produce a close notification
-    def close!
-      log_event :close
-      circuit_store.delete(storage_key(:was_open))
-    end
+    def should_open?
+      failures = failure_count
+      successes = success_count
+      rate = error_rate(failures, successes)
 
-    def was_open!
-      circuit_store.store(storage_key(:was_open), true)
+      passed_volume_threshold?(failures, successes) && passed_rate_threshold?(rate)
     end
 
-    def was_open?
-      circuit_store[storage_key(:was_open)].present?
+    def passed_volume_threshold?(failures, successes)
+      failures + successes >= option_value(:volume_threshold)
     end
-    ### END
 
-    def half_open!
-      circuit_store.store(storage_key(:half_open), true)
+    def passed_rate_threshold?(rate)
+      rate >= option_value(:error_threshold)
     end
 
-    def open_flag?
-      circuit_store[storage_key(:asleep)].present?
-    end
+    def half_open_failure
+      @state_change_mutex.synchronize do
+        return if open? || !half_open?
 
-    def half_open?
-      circuit_store[storage_key(:half_open)].present?
-    end
+        trip
+      end
 
-    def passed_volume_threshold?
-      success_count + failure_count > option_value(:volume_threshold)
+      # Running event and logger outside of the synchronize block to allow other threads
+      # that may be waiting to become unblocked
+      notify_opened
     end
 
-    def passed_rate_threshold?
-      read_and_log_error_rate >= option_value(:error_threshold)
-    end
+    def open!
+      @state_change_mutex.synchronize do
+        return if open?
 
-    def read_and_log_error_rate
-      failures = failure_count
-      success  = success_count
-      rate = error_rate(failures, success)
-      log_metrics(rate, failures, success)
-      rate
-    end
+        trip
+      end
 
-    def success!
-      log_event :success
-      circuit_store.delete(storage_key(:half_open))
+      # Running event and logger outside of the synchronize block to allow other threads
+      # that may be waiting to become unblocked
+      notify_opened
     end
 
-    def failure!
-      log_event :failure
+    def notify_opened
+      notify_event('open')
+      logger.debug(circuit_opened_message)
     end
 
-    # Store success/failure/open/close data in memcache
-    def log_event(event)
-      notifier.new(service,partition).notify(event)
-      log_event_to_process(event)
+    def trip
+      circuit_store.store(open_storage_key, true, expires: option_value(:sleep_window))
+      circuit_store.store(half_open_storage_key, true)
     end
 
-    def log_metrics(error_rate, failures, successes)
-      n = notifier.new(service,partition)
-      n.metric_gauge(:error_rate, error_rate)
-      n.metric_gauge(:failure_count, failures)
-      n.metric_gauge(:success_count, successes)
-    end
-
-    def sanitize_options
-      sleep_window = option_value(:sleep_window)
-      time_window  = option_value(:time_window)
-      if sleep_window < time_window
-        notifier.new(service,partition).notify_warning("sleep_window:#{sleep_window} is shorter than time_window:#{time_window}, the error_rate could not be reset properly after a sleep. sleep_window as been set to equal time_window.")
-        @circuit_options[:sleep_window] = option_value(:time_window)
+    def close!
+      @state_change_mutex.synchronize do
+        # If the circuit is not open, the half_open key will be deleted from the store
+        # if half_open exists the deleted value is returned and allows us to continue
+        # if half_open doesn't exist nil is returned, causing us to return early
+        return unless !open? && circuit_store.delete(half_open_storage_key)
       end
+
+      # Running event outside of the synchronize block to allow other threads
+      # that may be waiting to become unblocked
+      notify_event('close')
+      logger.debug(circuit_closed_message)
     end
 
-    # When there is a successful response within a count interval, clear the failures.
-    def clear_failures!
-      circuit_store.store(stat_storage_key(:failure), 0, raw: true)
+    def half_open?
+      circuit_store.key?(half_open_storage_key)
     end
 
-    # Logs to process memory.
-    def log_event_to_process(event)
-      key = stat_storage_key(event)
-      if circuit_store.load(key, raw: true)
-        circuit_store.increment(key)
-      else
-        # yes we want a string here, as the underlying stores impement this as a native type.
-        circuit_store.store(key, "1", raw: true)
-      end
+    def success!
+      increment_and_notify_event('success')
+      logger.debug(circuit_success_message)
+
+      close! if half_open?
     end
 
-    # Logs to Memcache.
-    def log_event_to_stat_store(key)
-      if stat_store.read(key, raw: true)
-        stat_store.increment(key)
-      else
-        stat_store.store(key, 1)
+    def failure!
+      increment_and_notify_event('failure')
+      logger.debug(circuit_failure_message)
+
+      if half_open?
+        half_open_failure
+      elsif should_open?
+        open!
       end
     end
 
-    # For returning stale responses when the circuit is open
-    def response_key(args)
-      Digest::SHA1.hexdigest(storage_key(:cache, args.inspect.to_s))
+    def skipped!
+      notify_event('skipped')
+      logger.debug(circuit_skipped_message)
     end
 
-    def stat_storage_key(event, options = {})
-      storage_key(:stats, align_time_on_minute, event, options)
+    # Send event notification to notifier
+    def notify_event(event)
+      notifier.notify(service, event)
     end
 
-
-    # return time representation in seconds
-    def align_time_on_minute(time=nil)
-      time      ||= @time_class.now.to_i
-      time_window = option_value(:time_window)
-      time - ( time % time_window ) # remove rest of integer division
+    # Increment stat store and send notification
+    def increment_and_notify_event(event)
+      circuit_store.increment(stat_storage_key(event), 1, expires: (option_value(:time_window) * 2))
+      notify_event(event)
     end
 
-    def storage_key(*args)
-      options = args.extract_options!
-
-      key = if options[:without_partition]
-        "circuits:#{service}:#{args.join(":")}"
-      else
-        "circuits:#{service}:#{partition}:#{args.join(":")}"
+    def check_sleep_window
+      sleep_window = option_value(:sleep_window)
+      time_window  = option_value(:time_window)
+      if sleep_window < time_window
+        warning_message = "sleep_window: #{sleep_window} is shorter than time_window: #{time_window}, "\
+                          "the error_rate would not be reset after a sleep."
+        notifier.notify_warning(service, warning_message)
+        warn("Circuit: #{service}, Warning: #{warning_message}")
       end
+    end
 
-      return key
+    def stat_storage_key(event)
+      "circuits:#{service}:stats:#{align_time_to_window}:#{event}"
     end
 
-    def timeout(timeout_seconds, &block)
-      Timeout::timeout(timeout_seconds) { block.call }
+    # return time representation in seconds
+    def align_time_to_window
+      time = time_class.now.to_i
+      time_window = option_value(:time_window)
+      time - (time % time_window) # remove rest of integer division
     end
 
-    def self.reset
-      Circuitbox.reset
+    def open_storage_key
+      @open_storage_key ||= "circuits:#{service}:open"
     end
 
+    def half_open_storage_key
+      @half_open_storage_key ||= "circuits:#{service}:half_open"
+    end
   end
 end