httpigeon 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 500fac14ff3591858c0547ea049891de72ffa58747e76ddb1f5faf3cd2a12ba8
-  data.tar.gz: 2f6bce6c474bed8bd6cf9168b8f4271a7d4483145d89a5674a72ce6f83c88ac6
+  metadata.gz: fb08778292f9e4ec48be0c011bb0f1052ed0b9f1a545f3e12b01cc0230edc417
+  data.tar.gz: 5345b29ff264cf7e6717dc93d39a3afc3569388da9644d6babb21c67c817b2d2
 SHA512:
-  metadata.gz: 114d33029253f8ebd4a9dac5e8815f59b1d8a369ab9be4e971d1711da8df4f24618885876902138bd4d7c4888dd89a7d108da8c82296a8d1c996071c5444141f
-  data.tar.gz: fe8312258406cd6f78a162ce3f5f704afcb4091526083802a1bb724b759d5481ff859f885099ecbaacae888df72378e24c7cebb7c1c79704c4ba141b2a92aba8
+  metadata.gz: 3cd0f88eec378aafb85ae799aa070242e7c0caddd26cf21feaa01c50048f65c32e6c904734bf0994812b40e400e4e0e951b2c899f1991b28d3fc89b5aab4e1ee
+  data.tar.gz: 8a1dc3e68162de054e829e488f926a33848c77f63d6c7ea6f47b61f1c13f1d9aea928515c4c2856950ea398f94c55563e75502d03f80f5f6b6fefd876975d18d

data/.github/workflows/reviewdog.yaml

@@ -1,19 +1,29 @@
 name: Reviewdog
 on: [pull_request]
+
 jobs:
   rubocop:
-    name: rubocop
+    permissions:
+      contents: write
     runs-on: ubuntu-latest
     steps:
       - name: Check out code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: 3.1
       - name: rubocop
         uses: reviewdog/action-rubocop@v2
         with:
+          rubocop_flags: -a
           rubocop_version: gemfile
           rubocop_extensions: rubocop-rspec:gemfile
           reporter: github-pr-check
-          fail_on_error: true
+
+      - name: Auto Commit
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: Rubocop Auto Corrections
+          commit_user_name: Rubocop

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [2.2.0](https://github.com/dailypay/httpigeon/compare/v2.1.0...v2.2.0) (2024-05-17)
+
+
+### Features
+
+* Add more callbacks ([#38](https://github.com/dailypay/httpigeon/issues/38)) ([660cfba](https://github.com/dailypay/httpigeon/commit/660cfba63a8cdc2ff73764913426d38644aaf53a))
+* **request:** Implement circuit breaking ([#33](https://github.com/dailypay/httpigeon/issues/33)) ([c25eab4](https://github.com/dailypay/httpigeon/commit/c25eab406d26b50da806d122eb73be0701b84c4e))
+
 ## [2.1.0](https://github.com/dailypay/httpigeon/compare/v2.0.1...v2.1.0) (2024-01-05)
 
 

data/httpigeon.gemspec

@@ -36,6 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rubocop", "~> 1.21"
   spec.add_development_dependency "rubocop-rspec", "~> 2.24"
   spec.add_development_dependency "pry", "~> 0.13.1"
+  spec.add_development_dependency "timecop", "~> 0.9.8"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/lib/httpigeon/circuit_breaker/errors.rb

@@ -0,0 +1,11 @@
+module HTTPigeon
+  module CircuitBreaker
+    class Error < StandardError; end
+
+    class CircuitOpenError < Error
+      def initialize(service_id)
+        super("Circuit open for service: #{service_id}")
+      end
+    end
+  end
+end

data/lib/httpigeon/circuit_breaker/fuse.rb

@@ -0,0 +1,207 @@
+require_relative 'errors'
+require_relative 'fuse_config'
+require_relative 'memory_store'
+require_relative '../middleware/circuit_breaker'
+
+module HTTPigeon
+  module CircuitBreaker
+    class Fuse
+      STATE_OPEN = 'open'.freeze
+      STATE_HALF_OPEN = 'half_open'.freeze
+      STATE_CLOSED = 'closed'.freeze
+
+      def self.from_options(options)
+        new(FuseConfig.new(options))
+      end
+
+      attr_reader :service_id, :config, :store
+
+      def initialize(config)
+        @config = config
+        @service_id = config.service_id.to_s
+        @store = CircuitBreaker::MemoryStore.new(config.sample_window)
+        @open_storage_key = "circuit:#{service_id}:#{STATE_OPEN}"
+        @half_open_storage_key = "circuit:#{service_id}:#{STATE_HALF_OPEN}"
+        @state_change_syncer = Mutex.new
+      end
+
+      def execute(request_id: nil)
+        @request_id = request_id
+
+        if open?
+          record_tripped!
+
+          config.open_circuit_handler.call(config.null_response, config.circuit_open_error)
+        else
+          begin
+            response = yield
+            server_maintenance_timeout = response.headers[config.maintenance_mode_header].to_i
+
+            if server_maintenance_timeout.positive?
+              record_failure!
+              open!(
+                {
+                  expires_in: server_maintenance_timeout,
+                  # for logging purposes. can't log expires_in because it might be overridden if greater than max
+                  server_maintenance_timeout: server_maintenance_timeout
+                }
+              )
+
+              return config.open_circuit_handler.call(response, config.circuit_open_error)
+            end
+
+            record_success!
+            response
+          rescue Faraday::Error => e
+            record_failure! if e.response_status >= 500 || config.error_codes_watchlist.include?(e.response_status)
+
+            raise e
+          end
+        end
+      end
+
+      def open?
+        store.key?(open_storage_key)
+      end
+
+      def half_open?
+        store.key?(half_open_storage_key)
+      end
+
+      def failure_count
+        store.get(stat_storage_key(:failure)).to_i
+      end
+
+      def success_count
+        store.get(stat_storage_key(:success)).to_i
+      end
+
+      def tripped_count
+        store.get(stat_storage_key(:tripped)).to_i
+      end
+
+      def failure_rate
+        total_stats = success_count + failure_count + tripped_count
+
+        return 0.0 unless total_stats.positive?
+
+        (total_stats - success_count).to_f / total_stats
+      end
+
+      def reset!
+        state_change_syncer.synchronize { store.reset! }
+      end
+
+      private
+
+      attr_reader :open_storage_key, :half_open_storage_key, :state_change_syncer, :request_id
+
+      def failed_request?(response)
+        response.status.nil? || response.status >= 500 || config.error_codes_watchlist.include?(response.status)
+      end
+
+      def should_open?
+        return false if failure_count < config.min_failures_count
+
+        failure_count >= config.max_failures_count || failure_rate >= config.failure_rate_threshold
+      end
+
+      def close!(opts = {})
+        state_change_syncer.synchronize do
+          # We only close the circuit if there have been at least one successful request during the current sample window
+          return unless success_count.positive?
+
+          # For the circuit to be closable, it must NOT be open AND
+          # it must be currently half open (i.e half_open_storage_key must be true)
+          # Otherwise, we return early
+          return unless !open? && store.delete(half_open_storage_key)
+
+          # reset failures count for current sample window
+          # so that we can only trip the circuit if we reach the min failures threshold again
+          store.delete(stat_storage_key(:failure))
+        end
+
+        log_circuit_event('circuit_closed', STATE_CLOSED, opts)
+        config.on_circuit_closed.call(store.storage, config.to_h)
+      end
+
+      def open!(opts = {})
+        state_change_syncer.synchronize do
+          return if open?
+
+          trip!(type: :full, **opts)
+
+          # reset failures count for current sample window so that the circuit doesn't re-open immediately
+          # if a request fails while in half_open state
+          store.delete(stat_storage_key(:failure))
+        end
+
+        opts.delete(:expires_in) # don't log expires_in key as it may be overridden if greater than max
+        log_circuit_event('circuit_opened', STATE_OPEN, opts)
+        config.on_circuit_opened.call(store.storage, config.to_h)
+      end
+
+      def half_open!(opts = {})
+        state_change_syncer.synchronize do
+          return if open? || half_open?
+
+          trip!(type: :partial, **opts)
+        end
+
+        log_circuit_event('circuit_half_opened', STATE_HALF_OPEN, opts)
+      end
+
+      def trip!(type:, **opts)
+        if type == :full
+          store.set(open_storage_key, true, { expires_in: config.open_circuit_sleep_window }.merge(opts))
+          store.set(half_open_storage_key, true, { expires_in: config.sample_window }.merge(opts))
+        elsif type == :partial
+          store.set(half_open_storage_key, true, { expires_in: config.sample_window }.merge(opts))
+        end
+      end
+
+      def record_success!
+        record_stat(:success)
+
+        close! if half_open?
+      end
+
+      def record_failure!
+        record_stat(:failure)
+
+        open! if should_open? && (!half_open? || !open?)
+        half_open! if !half_open? && failure_count >= config.min_failures_count
+      end
+
+      def record_tripped!
+        record_stat(:tripped)
+        log_circuit_event('execution_skipped', STATE_OPEN)
+      end
+
+      def record_stat(outcome, value = 1)
+        store.increment(stat_storage_key(outcome), value, expires_in: config.sample_window)
+      end
+
+      def stat_storage_key(outcome)
+        "run_stat:#{service_id}:#{outcome}"
+      end
+
+      def log_circuit_event(event, status, payload = {})
+        return unless HTTPigeon.log_circuit_events
+
+        payload = {
+          event_type: "httpigeon.fuse.#{event}",
+          service_id: service_id,
+          request_id: request_id,
+          circuit_state: status,
+          success_count: success_count,
+          failure_count: failure_count,
+          failure_rate: failure_rate,
+          recorded_at: Time.now.to_i
+        }.merge(payload).compact
+
+        HTTPigeon.event_logger&.log(payload) || HTTPigeon.stdout_logger.log(1, payload.to_json)
+      end
+    end
+  end
+end

data/lib/httpigeon/circuit_breaker/fuse_config.rb

@@ -0,0 +1,71 @@
+require 'faraday'
+
+module HTTPigeon
+  module CircuitBreaker
+    class NullResponse < Faraday::Response
+      attr_reader :api_response, :exception
+
+      def initialize(response = nil, exception = nil)
+        @api_response = response
+        @exception = exception
+        super(status: 503, response_headers: response&.headers || {})
+      end
+    end
+
+    class FuseConfig
+      DEFAULT_MM_TIMEOUT_HEADER = 'X-Maintenance-Mode-Timeout'.freeze
+
+      attr_reader :max_failures_count,
+                  :min_failures_count,
+                  :failure_rate_threshold,
+                  :sample_window,
+                  :open_circuit_sleep_window,
+                  :on_circuit_closed,
+                  :on_circuit_opened,
+                  :open_circuit_handler,
+                  :error_codes_watchlist,
+                  :maintenance_mode_header,
+                  :service_id
+
+      def initialize(fuse_options = {})
+        @service_id = fuse_options[:service_id].presence || raise(ArgumentError, 'service_id is required')
+        @max_failures_count = fuse_options[:max_failures_count] || HTTPigeon.fuse_max_failures_count
+        @min_failures_count = fuse_options[:min_failures_count] || HTTPigeon.fuse_min_failures_count
+        @failure_rate_threshold = fuse_options[:failure_rate_threshold] || HTTPigeon.fuse_failure_rate_threshold
+        @sample_window = fuse_options[:sample_window] || HTTPigeon.fuse_sample_window
+        @open_circuit_sleep_window = fuse_options[:open_circuit_sleep_window] || HTTPigeon.fuse_open_circuit_sleep_window
+        @error_codes_watchlist = fuse_options[:error_codes_watchlist].to_a | HTTPigeon.fuse_error_codes_watchlist.to_a
+        @maintenance_mode_header = fuse_options[:maintenance_mode_header] || DEFAULT_MM_TIMEOUT_HEADER
+
+        @on_circuit_closed = HTTPigeon.fuse_on_circuit_closed
+        @on_circuit_opened = HTTPigeon.fuse_on_circuit_opened
+        @open_circuit_handler = if HTTPigeon.fuse_open_circuit_handler.respond_to?(:call)
+                                  HTTPigeon.fuse_open_circuit_handler
+                                else
+                                  ->(api_response, exception) { null_response(api_response, exception) }
+                                end
+      end
+
+      def to_h
+        {
+          service_id: service_id,
+          max_failures_count: max_failures_count,
+          min_failures_count: min_failures_count,
+          failure_rate_threshold: failure_rate_threshold,
+          sample_window: sample_window,
+          open_circuit_sleep_window: open_circuit_sleep_window,
+          error_codes_watchlist: error_codes_watchlist,
+          maintenance_mode_header: maintenance_mode_header
+        }
+      end
+
+      def null_response(api_response = nil, exception = nil)
+        NullResponse.new(api_response, exception)
+      end
+
+      def circuit_open_error
+        CircuitOpenError.new(service_id)
+      end
+    end
+  end
+end

data/lib/httpigeon/circuit_breaker/memory_store.rb

@@ -0,0 +1,105 @@
+module HTTPigeon
+  module CircuitBreaker
+    class MemoryStore
+      MAX_SAMPLE_WINDOW = 180
+
+      attr_reader :sample_window
+
+      def initialize(sample_window)
+        @storage = {}
+        @mutex = Mutex.new
+        @sample_window = [sample_window.to_i, MAX_SAMPLE_WINDOW].min
+      end
+
+      def get(key)
+        @mutex.synchronize { fetch_bucket(key)&.value }
+      end
+      alias_method :[], :get
+
+      def set(key, value, opts = {})
+        @mutex.synchronize do
+          flush(key)
+
+          @storage[key] = DataBucket.new(value, relative_expires_at(opts[:expires_in]))
+          value
+        end
+      end
+      alias_method :store, :set
+
+      def increment(key, value = 1, opts = {})
+        @mutex.synchronize do
+          existing_bucket = fetch_bucket(key)
+
+          if existing_bucket
+            existing_bucket.expires_at = relative_expires_at(opts[:expires_in])
+            existing_bucket.value += value
+          else
+            @storage[key] = DataBucket.new(value, relative_expires_at(opts[:expires_in]))
+            value
+          end
+        end
+      end
+      alias_method :incr, :increment
+
+      def key?(key)
+        @mutex.synchronize { !fetch_bucket(key).nil? }
+      end
+
+      def delete(key)
+        @mutex.synchronize { @storage.delete(key) }
+      end
+      alias_method :del, :delete
+
+      def reset!
+        @mutex.synchronize { @storage.clear }
+      end
+      alias_method :clear!, :reset!
+
+      def storage
+        @mutex.synchronize { @storage.dup }
+      end
+
+      private
+
+      def fetch_bucket(key)
+        bucket = @storage[key]
+
+        return unless bucket
+        @storage.delete(key) && return if bucket.expired?(current_time)
+
+        bucket
+      end
+
+      def flush(key)
+        bucket = @storage[key]
+
+        @storage.delete(key) if !!bucket&.expired?(current_time)
+      end
+
+      def current_time
+        Time.now.to_i
+      end
+
+      def relative_expires_at(expires_in)
+        current_time + [expires_in.to_i, sample_window].min
+      end
+    end
+
+    class DataBucket
+      attr_accessor :value, :expires_at
+
+      def initialize(value, expires_at)
+        @value = value
+        @expires_at = expires_at
+      end
+
+      def expired?(current_time = Time.now.to_i)
+        expires_at < current_time
+      end
+
+      def to_h
+        { value: value, expires_at: expires_at }
+      end
+    end
+  end
+end

data/lib/httpigeon/configuration.rb

@@ -1,6 +1,24 @@
 module HTTPigeon
   class Configuration
-    attr_accessor :default_event_type, :default_filter_keys, :redactor_string, :log_redactor, :event_logger, :notify_all_exceptions, :exception_notifier, :auto_generate_request_id
+    attr_accessor :default_event_type,
+                  :default_filter_keys,
+                  :redactor_string,
+                  :log_redactor,
+                  :event_logger,
+                  :notify_all_exceptions,
+                  :exception_notifier,
+                  :auto_generate_request_id,
+                  :mount_circuit_breaker,
+                  :log_circuit_events,
+                  :fuse_error_codes_watchlist,
+                  :fuse_on_circuit_opened,
+                  :fuse_on_circuit_closed,
+                  :fuse_open_circuit_handler,
+                  :fuse_max_failures_count,
+                  :fuse_min_failures_count,
+                  :fuse_failure_rate_threshold,
+                  :fuse_sample_window,
+                  :fuse_open_circuit_sleep_window
 
     def initialize
       @default_event_type = 'http.outbound'
@@ -11,6 +29,18 @@ module HTTPigeon
       @auto_generate_request_id = true
       @notify_all_exceptions = false
       @exception_notifier = nil
+      @mount_circuit_breaker = false
+      @log_circuit_events = true
+
+      @fuse_error_codes_watchlist = []
+      @fuse_on_circuit_opened = ->(*_args) {}
+      @fuse_on_circuit_closed = ->(*_args) {}
+      @fuse_open_circuit_handler = nil
+      @fuse_max_failures_count = 10
+      @fuse_min_failures_count = 5
+      @fuse_failure_rate_threshold = 0.5
+      @fuse_sample_window = 60
+      @fuse_open_circuit_sleep_window = 30
     end
   end
 end

data/lib/httpigeon/logger.rb

@@ -78,7 +78,7 @@ module HTTPigeon
     end
 
     def log_to_stdout(log_data)
-      ::Logger.new($stdout).log(1, log_data.to_json)
+      HTTPigeon.stdout_logger.log(1, log_data.to_json)
     end
   end
 end

data/lib/httpigeon/middleware/circuit_breaker.rb

@@ -0,0 +1,50 @@
+require 'faraday'
+
+module HTTPigeon
+  module Middleware
+    class CircuitBreaker < Faraday::Middleware
+      class FailedRequestError < Faraday::Error; end
+
+      def initialize(app, fuse_config)
+        super(app)
+
+        @fuse_config = fuse_config
+      end
+
+      def on_complete(env)
+        return unless failed_request?(env.status)
+
+        raise FailedRequestError, response_values(env)
+      end
+
+      private
+
+      def failed_request?(response_status)
+        response_status.nil? || response_status >= 500 || @fuse_config.error_codes_watchlist.include?(response_status)
+      end
+
+      def response_values(env)
+        {
+          status: env.status,
+          headers: env.response_headers,
+          body: env.body,
+          request: {
+            method: env.method,
+            url: env.url,
+            url_path: env.url.path,
+            params: query_params(env),
+            headers: env.request_headers,
+            body: env.request_body
+          }
+        }
+      end
+
+      def query_params(env)
+        env.request.params_encoder ||= Faraday::Utils.default_params_encoder
+        env.params_encoder.decode(env.url.query)
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware(circuit_breaker: HTTPigeon::Middleware::CircuitBreaker)

data/lib/httpigeon/request.rb

@@ -6,38 +6,39 @@ require_relative "middleware/httpigeon_logger"
 
 module HTTPigeon
   class Request
+    REQUEST_ID_HEADER = 'X-Request-Id'.freeze
+
     class << self
       def get(endpoint, query = {}, headers = {}, event_type = nil, log_filters = [])
         request = new(base_url: endpoint, headers: headers, event_type: event_type, log_filters: log_filters)
-        parsed_response = request.run(method: :get, path: '', payload: query) do |req|
+        request.run(method: :get, path: '', payload: query) do |req|
           yield(req) if block_given?
         end
-
-        HTTPigeon::Response.new(request, parsed_response, request.response)
       end
 
       def post(endpoint, payload, headers = {}, event_type = nil, log_filters = [])
         request = new(base_url: endpoint, headers: headers,  event_type: event_type, log_filters: log_filters)
-        parsed_response = request.run(method: :post, path: '', payload: payload) do |req|
+        request.run(method: :post, path: '', payload: payload) do |req|
           yield(req) if block_given?
         end
-
-        HTTPigeon::Response.new(request, parsed_response, request.response)
       end
     end
 
-    attr_reader :connection, :response, :parsed_response
+    attr_reader :connection, :response, :parsed_response, :base_url, :fuse
 
     delegate :status, :body, to: :response, prefix: true
 
-    def initialize(base_url:, options: nil, headers: nil, adapter: nil, logger: nil, event_type: nil, log_filters: nil)
-      @base_url = base_url
+    def initialize(base_url:, options: nil, headers: nil, adapter: nil, logger: nil, event_type: nil, log_filters: nil, fuse_config: nil)
+      @base_url = URI.parse(base_url)
 
       request_headers = default_headers.merge(headers.to_h)
+      fuse_config_opts = { service_id: @base_url.host }.merge(fuse_config.to_h)
+      @fuse = CircuitBreaker::Fuse.from_options(fuse_config_opts)
 
-      base_connection = Faraday.new(url: base_url).tap do |config|
+      base_connection = Faraday.new(url: @base_url.to_s).tap do |config|
         config.headers.deep_merge!(request_headers)
         config.options.merge!(options.to_h)
+        config.response :circuit_breaker, fuse.config if HTTPigeon.mount_circuit_breaker
         config.response :httpigeon_logger, logger if logger.is_a?(HTTPigeon::Logger)
       end
 
@@ -60,53 +61,37 @@ module HTTPigeon
         connection.headers['Content-Type'] = 'application/json'
       end
 
-      @response = connection.send(method, path, payload) do |request|
-        yield(request) if block_given?
-      end
+      connection.headers[REQUEST_ID_HEADER] = SecureRandom.uuid if HTTPigeon.auto_generate_request_id
 
-      @parsed_response = parse_response || {}
+      raw_response = HTTPigeon.mount_circuit_breaker ? run_with_fuse(method, path, payload) : simple_run(method, path, payload)
+
+      @response = HTTPigeon::Response.new(self, raw_response)
     end
 
     private
 
     attr_reader :logger, :event_type, :log_filters
 
-    def parse_response
-      parsed_body = response_body.is_a?(String) ? JSON.parse(response_body) : response_body
-      deep_with_indifferent_access(parsed_body)
-    rescue JSON::ParserError
-      response_body.presence
-    end
-
-    def deep_with_indifferent_access(obj)
-      case obj
-      when Hash
-        obj.transform_values do |value|
-          deep_with_indifferent_access(value)
-        end.with_indifferent_access
-      when Array
-        obj.map { |item| deep_with_indifferent_access(item) }
-      else
-        obj
-      end
-    end
-
     def default_logger(event_type, log_filters)
       HTTPigeon::Logger.new(event_type: event_type, log_filters: log_filters)
     end
 
     def default_headers
-      HTTPigeon.auto_generate_request_id ? { 'Accept' => 'application/json', 'X-Request-Id' => SecureRandom.uuid } : { 'Accept' => 'application/json' }
+      { 'Accept' => 'application/json' }
     end
-  end
 
-  class Response
-    attr_reader :request, :parsed_response, :raw_response
+    def simple_run(method, path, payload)
+      connection.send(method, path, payload) do |request|
+        yield(request) if block_given?
+      end
+    end
 
-    def initialize(request, parsed_response, raw_response)
-      @request = request
-      @parsed_response = parsed_response
-      @raw_response = raw_response
+    def run_with_fuse(method, path, payload)
+      fuse.execute(request_id: connection.headers[REQUEST_ID_HEADER]) do
+        simple_run(method, path, payload) do |request|
+          yield(request) if block_given?
+        end
+      end
     end
   end
 end

data/lib/httpigeon/response.rb

@@ -0,0 +1,45 @@
+module HTTPigeon
+  class Response
+    attr_reader :request, :parsed_response, :raw_response
+
+    delegate :to_h, :to_json, :with_indifferent_access, to: :parsed_response
+    delegate :status, :body, :env, to: :raw_response
+
+    def initialize(request, raw_response)
+      @request = request
+      @raw_response = raw_response
+
+      parse_response
+    end
+
+    def ==(other)
+      other == parsed_response || other.to_json == to_json || super
+    end
+
+    def [](key)
+      parsed_response[key]
+    end
+
+    private
+
+    def parse_response
+      parsed_body = body.is_a?(String) ? JSON.parse(body) : body
+      @parsed_response = deep_with_indifferent_access(parsed_body)
+    rescue JSON::ParserError
+      @parsed_response = body.presence || {}
+    end
+
+    def deep_with_indifferent_access(obj)
+      case obj
+      when Hash
+        obj.transform_values do |value|
+          deep_with_indifferent_access(value)
+        end.with_indifferent_access
+      when Array
+        obj.map { |item| deep_with_indifferent_access(item) }
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/httpigeon/version.rb

@@ -1,3 +1,3 @@
 module HTTPigeon
-  VERSION = "2.1.0".freeze
+  VERSION = "2.2.0".freeze
 end

data/lib/httpigeon.rb

@@ -5,6 +5,8 @@ require "httpigeon/version"
 require "httpigeon/log_redactor"
 require "httpigeon/logger"
 require "httpigeon/request"
+require "httpigeon/response"
+require "httpigeon/circuit_breaker/fuse"
 
 module HTTPigeon
   extend self
@@ -17,6 +19,8 @@ module HTTPigeon
     CLIENT_SECRET = "/(?'key'(client_?(s|S)?ecret=))(?'value'([^&$])*)/".freeze
   end
 
+  class InvalidConfigurationError < StandardError; end
+
   delegate :default_event_type,
            :default_filter_keys,
            :redactor_string,
@@ -25,19 +29,41 @@ module HTTPigeon
            :auto_generate_request_id,
            :notify_all_exceptions,
            :exception_notifier,
+           :mount_circuit_breaker,
+           :log_circuit_events,
+           :fuse_error_codes_watchlist,
+           :fuse_on_circuit_opened,
+           :fuse_on_circuit_closed,
+           :fuse_open_circuit_handler,
+           :fuse_max_failures_count,
+           :fuse_min_failures_count,
+           :fuse_failure_rate_threshold,
+           :fuse_sample_window,
+           :fuse_open_circuit_sleep_window,
+           :fuse_on_open_circuit,
            to: :configuration
 
   def configure
     @config = HTTPigeon::Configuration.new
 
-    yield(@config)
+    yield(@config) if block_given?
+
+    validate_config(@config)
 
     @config.freeze
   end
 
+  def stdout_logger
+    @stdout_logger ||= ::Logger.new($stdout)
+  end
+
   private
 
   def configuration
     @configuration ||= @config || HTTPigeon::Configuration.new
   end
+
+  def validate_config(config)
+    raise InvalidConfigurationError, "Fuse sleep window: #{config.fuse_open_circuit_sleep_window} must be less than or equal to sample window: #{config.fuse_sample_window}" if fuse_open_circuit_sleep_window > fuse_sample_window
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpigeon
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - 2k-joker
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-04-14 00:00:00.000000000 Z
+date: 2024-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -122,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.13.1
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.8
 description: Client library that simplifies making and logging HTTP requests and responses.
   This library is built as an abstraction on top of the Faraday ruby client.
 email:
@@ -146,11 +160,17 @@ files:
 - bin/setup
 - httpigeon.gemspec
 - lib/httpigeon.rb
+- lib/httpigeon/circuit_breaker/errors.rb
+- lib/httpigeon/circuit_breaker/fuse.rb
+- lib/httpigeon/circuit_breaker/fuse_config.rb
+- lib/httpigeon/circuit_breaker/memory_store.rb
 - lib/httpigeon/configuration.rb
 - lib/httpigeon/log_redactor.rb
 - lib/httpigeon/logger.rb
+- lib/httpigeon/middleware/circuit_breaker.rb
 - lib/httpigeon/middleware/httpigeon_logger.rb
 - lib/httpigeon/request.rb
+- lib/httpigeon/response.rb
 - lib/httpigeon/version.rb
 homepage: https://github.com/dailypay/httpigeon
 licenses:
@@ -173,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.27
 signing_key: 
 specification_version: 4
 summary: Simple, easy way to make and log HTTP requests and responses