stoplight 5.0.3 → 5.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1bf0d52652310dd2f35ddfca4b3fef8609ee4a27c69c14a8e8df56779a94dc65
-  data.tar.gz: cb757bad124b5eb2fc145bc98dd11cd1cc115ab71bcd086b54d42c95b89085c8
+  metadata.gz: 4b9625eb129c8bbefdab0e3c9552bd6abe6d146c6ffaaab8f25edcb14ddf29db
+  data.tar.gz: db63d134926cceef9e46ed7b0dd72156fa1d55a883f116626a46ee1aaa7af9ff
 SHA512:
-  metadata.gz: '09c6323f9b5c7a48248e60a0171fcc4a9fac0f942a22a6169cf0dbfaa8a3dc7de9ad8fc71ebe895968483c1727b73d5e131e981644e05be04a086615cc336662'
-  data.tar.gz: 7bf6bed6db5100bf241fce259a45e69ff1719bcfc546c95f38464adec087a4943233f7448371bbb1dcf992ac0da6638d0a1d17571197129ebfd4d4c29ceaf4b4
+  metadata.gz: 7c59ce8f66fdf2871c2998e59adec143ad563e2815f3ebeaf7e8555a5ca39c65062fc0b067067067e1c7541c39db99d3724539eca6e26102abc5fd5f908a2326
+  data.tar.gz: 7c9c7a289d356acfbdbda23f0f28f32d0379999f644e7eae447a9f60b6a6ac05fc73c01af0118f05158802a53eabe449ec03ba5cbdad0de3b2b7148b2b91aa22

data/README.md

@@ -13,10 +13,10 @@ Stoplight is traffic control for code. It's an implementation of the circuit bre
 the documentation of the previous version 4.x, you can find it [here](https://github.com/bolshakov/stoplight/tree/v4.1.1).
 
 Stoplight helps your application gracefully handle failures in external dependencies
-(like flaky databases, unreliable APIs, or spotty web services). By wrapping these unreliable 
+(like flaky databases, unreliable APIs, or spotty web services). By wrapping these unreliable
 calls, Stoplight prevents cascading failures from affecting your entire application.
 
-**The best part?** Stoplight works with zero configuration out of the box, while offering deep customization when you 
+**The best part?** Stoplight works with zero configuration out of the box, while offering deep customization when you
 need it.
 
 ## Installation
@@ -41,10 +41,10 @@ Stoplight operates like a traffic light with three states:
 
 ```mermaid
 stateDiagram
-    Green --> Red: Failures reach threshold
+    Green --> Red: Errors reach threshold
     Red --> Yellow: After cool_off_time
-    Yellow --> Green: Successful attempt
-    Yellow --> Red: Failed attempt
+    Yellow --> Green: Successful recovery
+    Yellow --> Red: Failed recovery
     Green --> Green: Success
     
     classDef greenState fill:#28a745,stroke:#1e7e34,stroke-width:2px,color:#fff
@@ -60,11 +60,15 @@ stateDiagram
 - **Red**: Failure state. Fast-fails without running the code. (Circuit open)
 - **Yellow**: Recovery state. Allows a test execution to see if the problem is resolved. (Circuit half-open)
 
-Stoplight's behavior is controlled by three primary parameters:
+Stoplight's behavior is controlled by two main parameters:
 
-1. **Threshold** (default: `3`): Number of failures required to transition from green to red.
-2. **Cool Off Time** (default: `60` seconds): Time to wait in the red state before transitioning to yellow.
-3. **Window Size** (default: `nil`): Time window in which failures are counted toward the threshold. By default, all failures are counted.
+1. **Window Size** (default: `nil`): Time window in which errors are counted toward the threshold. By default, all errors are counted.
+2. **Threshold** (default: `3`): Number of errors required to transition from green to red.
+
+Additionally, two other parameters control how Stoplight behaves after it turns red:
+ 
+1. **Cool Off Time** (default: `60` seconds): Time to wait in the red state before transitioning to yellow.
+2. **Recovery Threshold** (default: `1`): Number of successful attempts required to transition from yellow back to green.
 
 ## Basic Usage
 
@@ -78,7 +82,7 @@ light = Stoplight("Payment Service")
 result = light.run { payment_gateway.process(order) }
 ```
 
-When everything works, the light stays green and your code runs normally. If the code fails repeatedly, the 
+When everything works, the light stays green and your code runs normally. If the code fails repeatedly, the
 light turns red and raises a `Stoplight::Error::RedLight` exception to prevent further calls.
 
 ```ruby
@@ -112,7 +116,7 @@ light.color #=> "green"
 
 ### Using Fallbacks
 
-Provide fallbacks to gracefully handle failures:
+Provide fallbacks to gracefully handle errors:
 
 ```ruby
 fallback = ->(error) { error ? "Failed: #{error.message}" : "Service unavailable" }
@@ -121,25 +125,30 @@ light = Stoplight('example-fallback')
 result = light.run(fallback) { external_service.call }
 ```
 
-If the light is green but the call fails, the fallback receives the `error`. If the light is red, the fallback 
+If the light is green but the call fails, the fallback receives the `error`. If the light is red, the fallback
 receives `nil`. In both cases, the return value of the fallback becomes the return value of the `run` method.
 
 ## Admin Panel
 
 Stoplight goes with a built-in Admin Panel that can track all active Lights and manually lock them in the desired state (`Green` or `Red`). Locking lights in certain states might be helpful in scenarios like E2E testing.
 
-To add Admin Panel to your Rails project, add this configuration to your `config/routes.rb` file.
+To add Admin Panel protected by basic authentication to your Rails project, add this configuration to your `config/routes.rb` file.
 
 ```ruby
 Rails.application.routes.draw do
   # ...
 
+  Stoplight::Admin.use(Rack::Auth::Basic) do |username, password|
+    username == ENV["STOPLIGHT_ADMIN_USERNAME"] && password == ENV["STOPLIGHT_ADMIN_PASSWORD"]
+  end
   mount Stoplight::Admin => '/stoplights'
 
   # ...
 end
 ```
 
+Then set up `STOPLIGHT_ADMIN_USERNAME` and `STOPLIGHT_ADMIN_PASSWORD` env variables to access your Admin panel.
+
 **IMPORTANT:** Stoplight Admin Panel requires you to have `sinatra` and `sinatra-contrib` gems installed. You can either add them to your Gemfile:
 
 ```ruby
@@ -158,17 +167,16 @@ gem install sinatra-contrib
 It is possible to run the Admin Panel separately from your application using the `stoplight-admin:<release-version>` docker image.
 
 ```shell
-docker run --net=host stoplight-admin:v5
+docker run --net=host bolshakov/stoplight-admin
 ```
 
 **IMPORTANT:** Standalone Admin Panel should use the same Redis your application uses. To achieve this, set the `REDIS_URL` ENV variable via `-e REDIS_URL=<url-to-your-redis-servier>.` E.g.:
 
 ```shell
-docker run -e REDIS_URL=redis://localhost:6378  --net=host stoplight-admin:v5
+docker run -e REDIS_URL=redis://localhost:6378  --net=host bolshakov/stoplight-admin
 ```
 
-
-## Configuration 
+## Configuration
 
 ### Global Configuration
 
@@ -177,9 +185,11 @@ Stoplight allows you to set default values for all lights in your application:
 ```ruby
 Stoplight.configure do |config|
   # Set default behavior for all stoplights
-  config.threshold = 5
+  config.traffic_control = :error_rate
+  config.window_size = 300
+  config.threshold = 0.5
   config.cool_off_time = 30
-  config.window_size = 60
+  config.recovery_threshold = 5
   
   # Set up default data store and notifiers
   config.data_store = Stoplight::DataStore::Redis.new(redis)
@@ -204,10 +214,11 @@ You can also provide settings during creation:
 ```ruby
 data_store = Stoplight::DataStore::Redis.new(Redis.new)
 
-light = Stoplight("Payment Service", 
-  threshold: 5,                           # 5 failures before turning red
+light = Stoplight("Payment Service",
+  window_size: 300,                       # Only count errors in the last five minutes
+  threshold: 5,                           # 5 errors before turning red
   cool_off_time: 60,                      # Wait 60 seconds before attempting recovery
-  window_size: 300,                       # Only count failures in the last five minutes
+  recovery_threshold: 1,                  # 1 successful attempt to turn green again
   data_store: data_store,                 # Use Redis for persistence
   tracked_errors: [TimeoutError],         # Only count TimeoutError
   skipped_errors: [ValidationError]       # Ignore ValidationError
@@ -228,7 +239,7 @@ users_api = base_api.with(
 )
 ```
 
-The `#with` method creates a new stoplight instance without modifying the original, making it ideal for creating 
+The `#with` method creates a new stoplight instance without modifying the original, making it ideal for creating
 specialized stoplights from a common configuration.
 
 ## Error Handling
@@ -254,6 +265,117 @@ When both methods are used, `skipped_errors` takes precedence over `tracked_erro
 
 ## Advanced Configuration
 
+### Traffic Control Strategies
+
+You've seen how Stoplight transitions from green to red when errors reach the threshold. But **how exactly does it 
+decide when that threshold is reached?** That's where traffic control strategies come in.
+
+Stoplight offers two built-in strategies for counting errors:
+
+#### Consecutive Errors (Default)
+
+Stops traffic when a specified number of consecutive errors occur. Works with or without time sliding windows.
+
+```ruby
+light = Stoplight(
+  "Payment API", 
+  traffic_control: :consecutive_errors, 
+  threshold: 5,
+)
+```
+
+Counts consecutive errors regardless of when they occurred. Once 5 consecutive errors happen, the stoplight 
+turns red and stops traffic.
+
+```ruby
+light = Stoplight(
+  "Payment API", 
+  traffic_control: :consecutive_errors, 
+  threshold: 5, 
+  window_size: 300,
+)
+```
+
+Counts consecutive errors within a 5-minute sliding window. Both conditions must be met: 5 consecutive errors 
+AND at least 5 total errors within the window.
+
+_This is Stoplight's default strategy when no `traffic_control` is specified._ You can omit `traffic_control` parameter 
+in the above examples:
+
+```ruby
+light = Stoplight(
+  "Payment API",
+  threshold: 5,
+)
+```
+
+#### Error Rate
+
+Stops traffic when the error rate exceeds a percentage within a sliding time window. Requires `window_size` to be 
+configured:
+
+
+```ruby
+light = Stoplight(
+  "Payment API", 
+  traffic_control: :error_rate, 
+  window_size: 300, 
+  threshold: 0.5,
+)
+```
+
+Monitors error rate over a 5-minute sliding window. The stoplight turns red when error rate exceeds 50%.
+
+```ruby
+light = Stoplight(
+  "Payment API", 
+  traffic_control: {
+    error_rate: { min_requests: 20 },
+  }, 
+  window_size: 300, 
+  threshold: 0.5,
+)
+```
+
+Only evaluates error rate after at least 20 requests within the window. Default `min_requests` is 10.
+
+
+#### When to use:
+
+* **Consecutive Errors**: Low-medium traffic, simple behavior, occasional spikes expected
+* **Error Rate**: High traffic, percentage-based SLAs, variable traffic patterns
+
+### Traffic Recovery Strategies
+
+In the yellow state, Stoplight behaves differently from normal (green) operation. Instead of
+blocking all traffic, it allows a limited number of real requests to pass through to
+the underlying service to determine if it has recovered. These aren't synthetic probes -
+they're actual user requests that will execute normally if the service is healthy.
+
+After collecting the necessary data from these requests, Stoplight decides whether to
+return to green or red state.
+
+Traffic Recovery strategies control how Stoplight evaluates these requests during
+the recovery phase.
+
+#### Consecutive Successes (Default)
+
+Returns to green after a specified number of consecutive successful recovery attempts. This is the default behavior.
+
+```ruby
+light = Stoplight(
+  "Payment API", 
+  traffic_recovery: :consecutive_successes, 
+  recovery_threshold: 3,
+)
+```
+
+This configuration requires 3 consecutive successful recovery probes before resuming normal traffic. If any probe 
+fails during recovery, the stoplight immediately returns to red and waits for another cool-off period before trying again.
+
+**Default behavior**: If no `recovery_threshold` is specified, Stoplight uses a conservative default of 1, meaning a 
+single successful recovery probe will resume traffic flow.
+
 ### Data Store
 
 Stoplight uses an in-memory data store out of the box:
@@ -279,7 +401,7 @@ end
 
 #### Connection Pooling with Redis
 
-For high-traffic applications or when you want to control a number of opened connections to Redis: 
+For high-traffic applications or when you want to control a number of opened connections to Redis:
 
 ```ruby
 require "connection_pool"
@@ -324,7 +446,7 @@ the [notifier interface documentation] for detailed instructions. Pull requests
 
 ### Error Notifiers
 
-Stoplight is built for resilience. If the Redis data store fails, Stoplight automatically falls back to the in-memory 
+Stoplight is built for resilience. If the Redis data store fails, Stoplight automatically falls back to the in-memory
 data store. To get notified about such errors, you can configure an error notifier:
 
 ```ruby
@@ -335,7 +457,7 @@ end
 
 ### Locking
 
-Sometimes you need to override Stoplight's automatic behavior. Locking allows you to manually control the state of 
+Sometimes you need to override Stoplight's automatic behavior. Locking allows you to manually control the state of
 a stoplight, which is useful for:
 
 * **Maintenance periods**: Lock to red when a service is known to be unavailable
@@ -384,6 +506,12 @@ Stoplight.configure do |config|
 end
 ```
 
+You can generate initializer with Redis, Admin Panel route and add needed gems to your Gemfile:
+
+```sh
+rails generate stoplight:install --with-admin-panel
+```
+
 ## Testing
 
 Tips for working with Stoplight in test environments:
@@ -413,9 +541,15 @@ stoplight = Stoplight("test-#{rand}")
 ## Maintenance Policy
 
 Stoplight supports the latest three minor versions of Ruby, which currently are: `3.2.x`, `3.3.x`, and `3.4.x`. Changing
-the minimum supported Ruby version is not considered a breaking change. We support the current stable Redis 
+the minimum supported Ruby version is not considered a breaking change. We support the current stable Redis
 version (`7.4.x`) and the latest release of the previous major version (`6.2.x`)
 
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Run tests with `bundle exec rspec` and check 
+code style with `bundle exec standardrb`. We follow a git flow branching strategy - see our [Git Flow wiki page] for 
+details on branch naming, releases, and contribution workflow.
+
 ## Credits
 
 Stoplight was originally created by [camdez][] and [tfausak][]. It is currently maintained by [bolshakov][] and
@@ -444,3 +578,4 @@ Fowler’s [CircuitBreaker][] article.
 [complete list of contributors]: https://github.com/bolshakov/stoplight/graphs/contributors
 [CircuitBreaker]: http://martinfowler.com/bliki/CircuitBreaker.html
 [Redis]: https://redis.io/
+[Git Flow wiki page]: https://github.com/bolshakov/stoplight/wiki/Git-Flow

data/lib/generators/stoplight/install/USAGE

@@ -0,0 +1,16 @@
+Description:
+  Generates stoplight initializer to setup Stoplight Redis configuration
+    and optionally sets up Admin panel
+  
+Examples:
+  rails generate stoplight:install
+
+    This will generate "config/initializers/stoplight.rb" initializer with basic config
+    Then you should adjust Redis config there.
+
+  rails generate stoplight:install --with-admin-panel
+
+    This generated all needed requirements to set up Stoplight Admin Panel:
+    * It generates initializer "config/initializers/stoplight.rb" with Redis configuration
+    * It injects your "config/routes.rb" with route with basic authentication to Stoplight Admin panel
+    * It injects your Gemfile with needed dependencies ('redis', 'sinatra' and 'sinatra-contrib')

data/lib/generators/stoplight/install/install_generator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+begin
+  require "rails/generators"
+rescue LoadError
+  raise <<~WARN
+    Currently generators are only available for Rails applications
+  WARN
+end
+
+module Stoplight
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base # :nodoc:
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :with_admin_panel, type: :boolean, optional: true,
+        desc: "Define whether to set up admin panel"
+
+      ROUTES_PATH = "config/routes.rb"
+      STOPLIGHT_CONFIG_TEMPLATE = "stoplight.rb.erb"
+      INITIALIZERS_PATH = "config/initializers"
+      AFTER_INSTALL_NOTIFICATION = <<~TEXT
+        \nThank you for using stoplight!
+        Now to finish configuration:
+        * Run `bundle` from the project root to install new gems
+        * Go to 'config/initializers/stoplight.rb' to set up connection to Redis.\n
+      TEXT
+
+      STOPLIGHT_ADMIN_ROUTE = <<-RUBY
+  mount Stoplight::Admin => '/stoplights'
+      RUBY
+
+      STOPLIGHT_AUTH = <<-RUBY
+  Stoplight::Admin.use(Rack::Auth::Basic) do |username, password|
+    username == ENV["STOPLIGHT_ADMIN_USERNAME"] && password == ENV["STOPLIGHT_ADMIN_PASSWORD"]
+  end
+      RUBY
+
+      def generate_redis_gem
+        if options[:with_admin_panel]
+          conf = "\ngem 'redis'"
+          inject_into_file "Gemfile", conf
+        end
+      end
+
+      def generate_sinatra_deps
+        if options[:with_admin_panel]
+          conf = <<~RUBY
+            gem 'sinatra', require: false
+            gem 'sinatra-contrib', require: false
+          RUBY
+
+          inject_into_file "Gemfile", "\n#{conf}"
+        end
+      end
+
+      def generate_initializer
+        initializer_template = STOPLIGHT_CONFIG_TEMPLATE
+        copy_file initializer_template, "#{INITIALIZERS_PATH}/stoplight.rb"
+      end
+
+      def generate_admin_panel
+        if options[:with_admin_panel]
+          route_config = "#{STOPLIGHT_AUTH}#{STOPLIGHT_ADMIN_ROUTE}\n"
+
+          inject_into_file ROUTES_PATH, route_config, after: ".application.routes.draw do\n"
+        end
+      end
+
+      def redis_configuration_notification
+        print AFTER_INSTALL_NOTIFICATION
+      end
+    end
+  end
+end

data/lib/generators/stoplight/install/templates/stoplight.rb.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "redis"
+
+# Set up your project-specific Redis setup here
+# One of the simplest configurations would be configuring Redis via url
+# Example:
+#   redis = Redis.new(url: ENV["REDIS_URL"])
+# REDIS_URL usually looks like this
+#   "redis://<username>:<password>@<server ip address>:<port>/<redis db>"
+# Example:
+#   "redis://admin:p4ssw0rd@10.0.1.1:6380/15"
+redis = Redis.new
+data_store = Stoplight::DataStore::Redis.new(redis)
+
+Stoplight.configure do |config|
+  config.data_store = data_store
+end

data/lib/stoplight/admin.rb

@@ -25,7 +25,7 @@ module Stoplight
     helpers Helpers
 
     set :protection, except: %i[json_csrf]
-    set :data_store, proc { Stoplight.config_provider.data_store }
+    set :data_store, proc { Stoplight.default_config.data_store }
     set :views, File.join(__dir__, "admin", "views")
 
     get "/" do

data/lib/stoplight/config/compatibility_result.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Stoplight
+  module Config
+    # The +CompatibilityResult+ class represents the result of a compatibility check
+    # for a strategy. It provides methods to determine if the strategy is compatible
+    # and to retrieve error messages when it is not.
+    class CompatibilityResult
+      class << self
+        # Creates a new +CompatibilityResult+ instance representing a compatible strategy.
+        #
+        # @return [CompatibilityResult] An instance with no errors.
+        def compatible
+          new(errors: [])
+        end
+
+        # Creates a new +CompatibilityResult+ instance representing an incompatible strategy.
+        #
+        # @param errors [Array<String>] List of error messages indicating incompatibility.
+        # @return [CompatibilityResult] An instance with the provided errors.
+        def incompatible(*errors)
+          new(errors:)
+        end
+      end
+
+      # Initializes a new `CompatibilityResult` instance.
+      # @param errors [Array<String>] List of error messages if the strategy is not compatible.
+      def initialize(errors: [])
+        @errors = errors.freeze
+      end
+
+      # Checks if the strategy is compatible.
+      # @return [Boolean] `true` if there are no errors, `false` otherwise.
+      def compatible?
+        @errors.empty?
+      end
+
+      def incompatible? = !compatible?
+
+      # Retrieves the list of error messages.
+      # @return [Array<String>] The list of error messages.
+      attr_reader :errors
+
+      # Retrieves a concatenated error message string.
+      # @return [String, nil] A string containing all error messages joined by "; ",
+      #   or `nil` if the strategy is compatible.
+      def error_messages
+        unless compatible?
+          @errors.join("; ")
+        end
+      end
+    end
+  end
+end

data/lib/stoplight/config/dsl.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Stoplight
+  module Config
+    # This is a DSL for configuring Stoplight settings. It is responsible for
+    # transforming the provided settings into a format that can be used by Stoplight.
+    #
+    # @api private
+    class DSL
+      def transform(settings)
+        if settings.has_key?(:data_store)
+          settings[:data_store] = build_data_store(settings[:data_store])
+        end
+
+        if settings.has_key?(:notifiers)
+          settings[:notifiers] = build_notifiers(settings[:notifiers])
+        end
+
+        if settings.has_key?(:tracked_errors)
+          settings[:tracked_errors] = build_tracked_errors(settings[:tracked_errors])
+        end
+
+        if settings.has_key?(:skipped_errors)
+          settings[:skipped_errors] = build_skipped_errors(settings[:skipped_errors])
+        end
+
+        if settings.has_key?(:cool_off_time)
+          settings[:cool_off_time] = build_cool_off_time(settings[:cool_off_time])
+        end
+
+        if settings.has_key?(:traffic_control)
+          settings[:traffic_control] = build_traffic_control(settings[:traffic_control])
+        end
+
+        if settings.has_key?(:traffic_recovery)
+          settings[:traffic_recovery] = build_traffic_recovery(settings[:traffic_recovery])
+        end
+        settings
+      end
+
+      private
+
+      def build_data_store(data_store)
+        DataStore::FailSafe.wrap(data_store)
+      end
+
+      def build_notifiers(notifiers)
+        notifiers.map { |notifier| Notifier::FailSafe.wrap(notifier) }
+      end
+
+      def build_tracked_errors(tracked_error)
+        Array(tracked_error)
+      end
+
+      def build_skipped_errors(skipped_errors)
+        Array(skipped_errors)
+      end
+
+      def build_cool_off_time(cool_off_time)
+        cool_off_time.to_i
+      end
+
+      def build_traffic_control(traffic_control)
+        case traffic_control
+        in Stoplight::TrafficControl::Base
+          traffic_control
+        in :consecutive_errors
+          Stoplight::TrafficControl::ConsecutiveErrors.new
+        in :error_rate
+          Stoplight::TrafficControl::ErrorRate.new
+        in {error_rate: error_rate_settings}
+          Stoplight::TrafficControl::ErrorRate.new(**error_rate_settings)
+        else
+          raise Error::ConfigurationError, <<~ERROR
+            unsupported traffic_control strategy provided (`#{traffic_control}`). Supported options:
+              * Stoplight::TrafficControl::ConsecutiveErrors
+              * Stoplight::TrafficControl::ErrorRate
+          ERROR
+        end
+      end
+
+      def build_traffic_recovery(traffic_recovery)
+        case traffic_recovery
+        in Stoplight::TrafficRecovery::Base
+          traffic_recovery
+        in :consecutive_successes
+          Stoplight::TrafficRecovery::ConsecutiveSuccesses.new
+        else
+          raise Error::ConfigurationError, <<~ERROR
+            unsupported traffic_recovery strategy provided (`#{traffic_recovery}`). Supported options:
+              * Stoplight::TrafficRecovery::ConsecutiveSuccesses
+          ERROR
+        end
+      end
+    end
+  end
+end

data/lib/stoplight/config/library_default_config.rb

@@ -4,26 +4,18 @@ module Stoplight
   module Config
     # Provides default settings for the Stoplight library.
     # @api private
-    class LibraryDefaultConfig
-      DEFAULT_SETTINGS = {
-        cool_off_time: Stoplight::Default::COOL_OFF_TIME,
-        data_store: Stoplight::Default::DATA_STORE,
-        error_notifier: Stoplight::Default::ERROR_NOTIFIER,
-        notifiers: Stoplight::Default::NOTIFIERS,
-        threshold: Stoplight::Default::THRESHOLD,
-        window_size: Stoplight::Default::WINDOW_SIZE,
-        tracked_errors: Stoplight::Default::TRACKED_ERRORS,
-        skipped_errors: Stoplight::Default::SKIPPED_ERRORS,
-        traffic_control: Stoplight::Default::TRAFFIC_CONTROL,
-        traffic_recovery: Stoplight::Default::TRAFFIC_RECOVERY
-      }.freeze
-      private_constant :DEFAULT_SETTINGS
-
-      # Returns library default settings.
-      # @return [Hash]
-      def to_h
-        DEFAULT_SETTINGS
-      end
-    end
+    LibraryDefaultConfig = Light::Config.empty.with(
+      cool_off_time: Stoplight::Default::COOL_OFF_TIME,
+      data_store: Stoplight::Default::DATA_STORE,
+      error_notifier: Stoplight::Default::ERROR_NOTIFIER,
+      notifiers: Stoplight::Default::NOTIFIERS,
+      threshold: Stoplight::Default::THRESHOLD,
+      recovery_threshold: Stoplight::Default::RECOVERY_THRESHOLD,
+      window_size: Stoplight::Default::WINDOW_SIZE,
+      tracked_errors: Stoplight::Default::TRACKED_ERRORS,
+      skipped_errors: Stoplight::Default::SKIPPED_ERRORS,
+      traffic_control: Stoplight::Default::TRAFFIC_CONTROL,
+      traffic_recovery: Stoplight::Default::TRAFFIC_RECOVERY
+    )
   end
 end

data/lib/stoplight/config/system_config.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Stoplight
+  module Config
+    SystemConfig = LibraryDefaultConfig
+  end
+end