stoplight 4.1.0 → 5.0.1

data/README.md

@@ -5,38 +5,19 @@
 [![Coverage badge][]][coverage]
 [![Climate badge][]][climate]
 
-Stoplight is traffic control for code. It's an implementation of the circuit
-breaker pattern in Ruby.
+Stoplight is traffic control for code. It's an implementation of the circuit breaker pattern in Ruby.
 
 ---
-Does your code use unreliable systems, like a flaky database or a spotty web
-service? Wrap calls to those up in stoplights to prevent them from affecting
-the rest of your application.
-
-Check out [stoplight-admin][] for controlling your stoplights.
-
-- [Installation](#installation)
-- [Basic Usage](#basic-usage)
-  - [Custom Errors](#custom-errors)
-  - [Custom Fallback](#custom-fallback)
-  - [Custom Threshold](#custom-threshold)
-  - [Custom Window Size](#custom-window-size)
-  - [Custom Cool Off Time](#custom-cool-off-time)
-  - [Rails](#rails)
-- [Setup](#setup)
-  - [Data Store](#data-store)
-    - [Redis](#redis)
-  - [Notifiers](#notifiers)
-    - [IO](#io)
-    - [Logger](#logger)
-    - [Community-supported Notifiers](#community-supported-notifiers)
-    - [How to Implement Your Own Notifier?](#how-to-implement-your-own-notifier)
-  - [Rails](#rails-1)
-- [Advanced Usage](#advanced-usage)
-  - [Locking](#locking)
-  - [Testing](#testing)
-- [Maintenance Policy](#maintenance-policy)
-- [Credits](#credits)
+
+:warning:️ You're currently browsing the documentation for Stoplight 5.x. If you're looking for
+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 
+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 
+need it.
 
 ## Installation
 
@@ -52,428 +33,394 @@ Or install it manually:
 $ gem install stoplight
 ```
 
-Stoplight uses [Semantic Versioning][]. Check out [the change log][] for a
-detailed list of changes.
+Stoplight uses [Semantic Versioning][]. Check out [the change log][] for a detailed list of changes.
+
+## Core Concepts
+
+Stoplight operates like a traffic light with three states:
+
+```mermaid
+stateDiagram
+    Green --> Red: Failures reach threshold
+    Red --> Yellow: After cool_off_time
+    Yellow --> Green: Successful attempt
+    Yellow --> Red: Failed attempt
+    Green --> Green: Success
+    
+    classDef greenState fill:#28a745,stroke:#1e7e34,stroke-width:2px,color:#fff
+    classDef redState fill:#dc3545,stroke:#c82333,stroke-width:2px,color:#fff
+    classDef yellowState fill:#ffc107,stroke:#e0a800,stroke-width:2px,color:#000
+    
+    class Green greenState
+    class Red redState
+    class Yellow yellowState
+```
+
+- **Green**: Normal operation. Code runs as expected. (Circuit closed)
+- **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:
+
+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.
 
 ## Basic Usage
 
-To get started, create a stoplight:
+Stoplight works right out of the box with sensible defaults:
 
 ```ruby
-light = Stoplight('example-pi')
+# Create a stoplight with default settings
+light = Stoplight("Payment Service")
+
+# Use it to wrap code that might fail
+result = light.run { payment_gateway.process(order) }
 ```
 
-Then you can run it with a block of code and it will return the result of calling the block. This is
-the green state. (The green state corresponds to the closed state for circuit breakers.)
+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
-light.run { 22.0 / 7 }
-# => 3.142857142857143
-light.color
-# => "green"
+light = Stoplight("Example")
+light.run { 1 / 0 } #=> raises ZeroDivisionError: divided by 0
+light.run { 1 / 0 } #=> raises ZeroDivisionError: divided by 0
+light.run { 1 / 0 } #=> raises ZeroDivisionError: divided by 0
 ```
 
-If everything goes well, you shouldn't even be able to tell that you're using a
-stoplight. That's not very interesting though, so let's make stoplight fail.
+After the last failure, the light turns red. The next call will raise a `Stoplight::Error::RedLight` exception without
+executing the block:
 
-When you run it, the error will be recorded and passed through. After
-running it a few times, the stoplight will stop trying and fail fast. This is
-the red state. (The red state corresponds to the open state for circuit
-breakers.)
+```ruby
+light.run { 1 / 0 } #=> raises Stoplight::Error::RedLight: example-zero
+light.color # => "red"
+```
+
+After one minute, the light transitions to yellow, allowing a test execution:
 
 ```ruby
-light = Stoplight('example-zero')
-# => #<Stoplight::CircuitBreaker:...>
-light.run { 1 / 0 }
-# ZeroDivisionError: divided by 0
-light.run { 1 / 0 }
-# ZeroDivisionError: divided by 0
-light.run { 1 / 0 }
-# Switching example-zero from green to red because ZeroDivisionError divided by 0
-# ZeroDivisionError: divided by 0
-light.run { 1 / 0 }
-# Stoplight::Error::RedLight: example-zero
-light.color
-# => "red"
-```
-
-When the Stoplight changes from green to red, it will notify every configured
-notifier. See [the notifiers section][] to learn more about notifiers.
-
-The stoplight will move into the yellow state after being in the red state for
-a while. (The yellow state corresponds to the half open state for circuit
-breakers.) To configure how long it takes to switch into the yellow state,
-check out [the cool off time section][] When stoplights are yellow, they will
-try to run their code. If it fails, they'll switch back to red. If it succeeds,
-they'll switch to green.
-
-### Custom Errors
-
-Some errors shouldn't cause your stoplight to move into the red state. Usually
-these are handled elsewhere in your stack and don't represent real failures. A
-good example is `ActiveRecord::RecordNotFound`.
-
-To prevent some errors from changing the state of your stoplight, you can
-provide a custom block that will be called with the error and a handler
-`Proc`. It can do one of three things:
-
-1.  Re-raise the error. This causes Stoplight to ignore the error. Do this for
-    errors like `ActiveRecord::RecordNotFound` that don't represent real
-    failures.
-
-2.  Call the handler with the error. This is the default behavior. Stoplight
-    will only ignore the error if it shouldn't have been caught in the first
-    place. See `Stoplight::Error::AVOID_RESCUING` for a list of errors that
-    will be ignored.
-
-3.  Do nothing. This is **not recommended**. Doing nothing causes Stoplight to
-    never ignore the error. That means a `NoMemoryError` could change the color
-    of your stoplights.
+# Wait for the cool off time
+sleep 60
+light.run { 1 / 1 } #=> 1
+```
+
+If the test probe succeeds, the light turns green again. If it fails, the light turns red again.
 
 ```ruby
-light = Stoplight('example-not-found')
-  .with_error_handler do |error, handle|
-    if error.is_a?(ActiveRecord::RecordNotFound)
-      raise error
-    else      
-      handle.call(error)
-    end
-  end
-# => #<Stoplight::CircuitBreaker:...>
-light.run { User.find(123) }
-# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
-light.run { User.find(123) }
-# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
-light.run { User.find(123) }
-# ActiveRecord::RecordNotFound: Couldn't find User with ID=123
-light.color
-# => "green"
+light.color #=> "green"
 ```
 
-### Custom Fallback
+### Using Fallbacks
 
-By default, stoplights will re-raise errors when they're green. When they're
-red, they'll raise a `Stoplight::Error::RedLight` error. You can provide a
-fallback that will be called in both of these cases. It will be passed the
-error if the light was green.
+Provide fallbacks to gracefully handle failures:
 
 ```ruby
+fallback = ->(error) { error ? "Failed: #{error.message}" : "Service unavailable" }
+
 light = Stoplight('example-fallback')
-  .with_fallback { |e| p e; 'default' }
-# => #<Stoplight::CircuitBreaker:..>
-light.run { 1 / 0 }
-# #<ZeroDivisionError: divided by 0>
-# => "default"
-light.run { 1 / 0 }
-# #<ZeroDivisionError: divided by 0>
-# => "default"
-light.run { 1 / 0 }
-# Switching example-fallback from green to red because ZeroDivisionError divided by 0
-# #<ZeroDivisionError: divided by 0>
-# => "default"
-light.run { 1 / 0 }
-# nil
-# => "default"
-```
-
-### Custom Threshold
-
-Some bits of code might be allowed to fail more or less frequently than others.
-You can configure this by setting a custom threshold.
+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 
+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.
 
 ```ruby
-light = Stoplight('example-threshold')
-  .with_threshold(1)
-# => #<Stoplight::CircuitBreaker:...>
-light.run { fail }
-# Switching example-threshold from green to red because RuntimeError
-# RuntimeError:
-light.run { fail }
-# Stoplight::Error::RedLight: example-threshold
+Rails.application.routes.draw do
+  # ...
+
+  mount Stoplight::Admin => '/stoplights'
+
+  # ...
+end
 ```
 
-The default threshold is `3`.
+**IMPORTANT:** Stoplight Admin Panel requires you to have `sinatra` and `sinatra-contrib` gems installed. You can either add them to your Gemfile:
 
-### Custom Window Size
+```ruby
+gem "sinatra", require: false
+gem "sinatra-contrib", require: false
+```
 
-By default, all recorded failures, regardless of the time these happen, will count to reach
-the threshold (hence turning the light to red). If needed, a window size can be set,
-meaning you can control how many errors per period of time will count to reach the red
-state.
+Or install it manually:
+```ruby
+gem install sinatra
+gem install sinatra-contrib
+```
 
-By default, every recorded failure contributes to reaching the threshold, regardless of when it occurs, 
-causing the stoplight to turn red. By configuring a custom window size, you control how errors are 
-counted within a specified time frame. Here's how it works:
+### Standalone Admin Panel Setup
 
-Let's say you set the window size to 2 seconds:
+It is possible to run the Admin Panel separately from your application using the `stoplight-admin:<release-version>` docker image.
 
- ```ruby
-window_size_in_seconds = 2
+```shell
+docker run --net=host stoplight-admin:v5
+```
 
-light = Stoplight('example-threshold')
-  .with_window_size(window_size_in_seconds)
-  .with_threshold(1) #=> #<Stoplight::CircuitBreaker:...>
+**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.:
 
-light.run { 1 / 0 } #=> #<ZeroDivisionError: divided by 0>
-sleep(3)
-light.run { 1 / 0 }
- ```
+```shell
+docker run -e REDIS_URL=redis://localhost:6378  --net=host stoplight-admin:v5
+```
 
-Without the window size configuration, the second `light.run { 1 / 0 }` call will result in a
-`Stoplight::Error::RedLight` exception being raised, as the stoplight transitions to the red state 
-after the first call. With a sliding window of 2 seconds, only the errors that occur within the latest
-2 seconds are considered. The first error causes the stoplight to turn red, but after 3 seconds 
-(when the second error occurs), the window has shifted, and the stoplight switches to green state 
-causing the error to raise again. This provides a way to focus on the most recent errors.
 
-The default window size is infinity, so all failures counts.
+## Configuration 
 
-### Custom Cool Off Time
+### Global Configuration
 
-Stoplights will automatically attempt to recover after a certain amount of
-time. A light in the red state for longer than the cool off period will
-transition to the yellow state. This cool off time is customizable.
+Stoplight allows you to set default values for all lights in your application:
 
 ```ruby
-light = Stoplight('example-cool-off')
-  .with_cool_off_time(1)
-# => #<Stoplight::CircuitBreaker:...>
-light.run { fail }
-# RuntimeError:
-light.run { fail }
-# RuntimeError:
-light.run { fail }
-# Switching example-cool-off from green to red because RuntimeError
-# RuntimeError:
-sleep(1)
-# => 1
-light.color
-# => "yellow"
-light.run { fail }
-# RuntimeError:
-```
-
-The default cool off time is `60` seconds. To disable automatic recovery, set
-the cool off to `Float::INFINITY`. To make automatic recovery instantaneous,
-set the cool off to `0` seconds. Note that this is not recommended, as it
-effectively replaces the red state with yellow.
-
-### Rails
-
-Stoplight was designed to wrap Rails actions with minimal effort. Here's an
-example configuration:
+Stoplight.configure do |config|
+  # Set default behavior for all stoplights
+  config.threshold = 5
+  config.cool_off_time = 30
+  config.window_size = 60
+  
+  # Set up default data store and notifiers
+  config.data_store = Stoplight::DataStore::Redis.new(redis)
+  config.notifiers = [Stoplight::Notifier::Logger.new(Rails.logger)]
+  
+  # Configure error handling defaults
+  config.tracked_errors = [StandardError, CustomError]
+  config.skipped_errors = [ActiveRecord::RecordNotFound]
+end
+```
 
-```ruby
-class ApplicationController < ActionController::Base
-  around_action :stoplight
+### Creating Stoplights
 
-  private
+The simplest way to create a stoplight is with a name:
 
-  def stoplight(&block)
-    Stoplight("#{params[:controller]}##{params[:action]}")
-      .with_fallback do |error|
-        Rails.logger.error(error)
-        render(nothing: true, status: :service_unavailable)
-      end
-      .run(&block)
-  end
-end
+```ruby
+light = Stoplight("Payment Service")
 ```
 
-## Setup
+You can also provide settings during creation:
 
-### Data store
+```ruby
+data_store = Stoplight::DataStore::Redis.new(Redis.new)
+
+light = Stoplight("Payment Service", 
+  threshold: 5,                           # 5 failures before turning red
+  cool_off_time: 60,                      # Wait 60 seconds before attempting recovery
+  window_size: 300,                       # Only count failures in the last five minutes
+  data_store: data_store,                 # Use Redis for persistence
+  tracked_errors: [TimeoutError],         # Only count TimeoutError
+  skipped_errors: [ValidationError]       # Ignore ValidationError
+)
+```
 
-Stoplight uses an in-memory data store out of the box.
+### Modifying Stoplights
+
+You can create specialized versions of existing stoplights:
 
 ```ruby
-require 'stoplight'
-# => true
-Stoplight.default_data_store
-# => #<Stoplight::DataStore::Memory:...>
+# Base configuration for API calls
+base_api = Stoplight("Service API")
+
+# Create specialized version for the users endpoint
+users_api = base_api.with(
+  tracked_errors: [TimeoutError]          # Only track timeouts
+)
 ```
 
-If you want to use a persistent data store, you'll have to set it up. Currently
-the only supported persistent data store is Redis.
+The `#with` method creates a new stoplight instance without modifying the original, making it ideal for creating 
+specialized stoplights from a common configuration.
 
-#### Redis
+## Error Handling
 
-Make sure you have [the Redis gem][] installed before configuring Stoplight.
+By default, Stoplight tracks all `StandardError` exceptions.
+Note: System-level exceptions (e.g., `NoMemoryError`, `SignalException`) are not tracked, as they are not subclasses of `StandardError`.
+
+### Custom Error Configuration
+
+Control which errors affect your stoplight state. Skip specific errors (will not count toward failure threshold)
 
 ```ruby
-require 'redis'
-# => true
-redis = Redis.new
-# => #<Redis client ...>
-data_store = Stoplight::DataStore::Redis.new(redis)
-# => #<Stoplight::DataStore::Redis:...>
-Stoplight.default_data_store = data_store
-# => #<Stoplight::DataStore::Redis:...>
+light = Stoplight("Example API", skipped_errors: [ActiveRecord::RecordNotFound, ValidationError])
 ```
 
-### Notifiers
-
-Stoplight sends notifications to standard error by default.
+Only track specific errors (only these count toward failure threshold)
 
-``` rb
-Stoplight.default_notifiers
-# => [#<Stoplight::Notifier::IO:...>]
+```ruby
+light = Stoplight("Example API", tracked_errors: [NetworkError, Timeout::Error])
 ```
 
-If you want to send notifications elsewhere, you'll have to set them up.
+When both methods are used, `skipped_errors` takes precedence over `tracked_errors`.
 
-#### IO
+## Advanced Configuration
 
-Stoplight can notify not only into STDOUT, but into any IO object. You can configure 
-the `Stoplight::Notifier::IO` notifier for that.
+### Data Store
 
-```ruby
-require 'stringio'
+Stoplight uses an in-memory data store out of the box:
 
-io = StringIO.new
-# => #<StringIO:...>
-notifier = Stoplight::Notifier::IO.new(io)
-# => #<Stoplight::Notifier::IO:...>
-Stoplight.default_notifiers += [notifier]
-# => [#<Stoplight::Notifier::IO:...>, #<Stoplight::Notifier::IO:...>]
+```ruby
+require "stoplight"
+Stoplight::Default::DATA_STORE
+# => #<Stoplight::DataStore::Memory:...>
 ```
 
-#### Logger
-
-Stoplight can be configured to use [the Logger class][] from the standard
-library.
+For production environments, you'll likely want to use a persistent data store. Currently, [Redis] is the supported option:
 
 ```ruby
-require 'logger'
-# => true
-logger = Logger.new(STDERR)
-# => #<Logger:...>
-notifier = Stoplight::Notifier::Logger.new(logger)
-# => #<Stoplight::Notifier::Logger:...>
-Stoplight.default_notifiers += [notifier]
-# => [#<Stoplight::Notifier::IO:...>, #<Stoplight::Notifier::Logger:...>]
+# Configure Redis as the data store
+require "redis"
+redis = Redis.new
+data_store = Stoplight::DataStore::Redis.new(redis)
+
+Stoplight.configure do |config|
+  config.data_store = data_store
+end
 ```
 
-#### Community-supported Notifiers
+#### Connection Pooling with Redis
 
-* [stoplight-sentry]
+For high-traffic applications or when you want to control a number of opened connections to Redis: 
 
-You you want to implement your own notifier, the following section contains all the required information.
+```ruby
+require "connection_pool"
+pool = ConnectionPool.new(size: 5, timeout: 3) { Redis.new }
+data_store = Stoplight::DataStore::Redis.new(pool)
 
-Pull requests to update this section are welcome.
+Stoplight.configure do |config|
+  config.data_store = data_store
+end
+```
 
-#### How to implement your own notifier?
+### Notifiers
 
-A notifier has to implement the `Stoplight::Notifier::Base` interface:
+Stoplight notifies when lights change state. Configure how these notifications are delivered:
 
 ```ruby
-def notify(light, from_color, to_color, error)
-  raise NotImplementedError
+# Log to a specific logger
+logger = Logger.new("stoplight.log")
+notifier = Stoplight::Notifier::Logger.new(logger)
+
+# Configure globally
+Stoplight.configure do |config|
+  config.notifiers = [notifier]
 end
 ```
 
-For convenience, you can use the `Stoplight::Notifier::Generic` module. It takes care of
-the message formatting, and you have to implement only the `put` method, which takes message sting as an argument:
+In this example, when Stoplight fails three times in a row, it will log the error to `stoplight.log`:
 
-```ruby 
-class IO < Stoplight::Notifier::Base
-  include Generic
-   
-  private
-    
-  def put(message)
-    @object.puts(message)
-  end
-end
+```log
+W, [2025-04-16T09:18:46.778447 #44233]  WARN -- : Switching test-light from green to red because RuntimeError bang!
 ```
 
-### Rails
+By default, Stoplight logs state transitions to STDERR.
+
+#### Community-supported Notifiers
+
+* [stoplight-sentry]
+* [stoplight-honeybadger]
+
+Pull requests to update this section are welcome. If you want to implement your own notifier, refer to
+the [notifier interface documentation] for detailed instructions. Pull requests to update this section are welcome.
 
-Stoplight is designed to work seamlessly with Rails. If you want to use the
-in-memory data store, you don't need to do anything special. If you want to use
-a persistent data store, you'll need to configure it. Create an initializer for
-Stoplight:
+### Error Notifiers
+
+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
-# config/initializers/stoplight.rb
-require 'stoplight'
-Stoplight.default_data_store = Stoplight::DataStore::Redis.new(...)
-Stoplight.default_notifiers += [Stoplight::Notifier::Logger.new(Rails.logger)]
+Stoplight.configure do |config|
+  config.error_notifier = ->(error) { Bugsnag.notify(error) }
+end
 ```
 
-## Advanced usage
-
 ### Locking
 
-Although stoplights can operate on their own, occasionally you may want to
-override the default behavior. You can lock a light using `#lock(color)` method.
-Color should be either `Stoplight::Color::GREEN` or ``Stoplight::Color::RED``.
+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
+* **Emergency overrides**: Lock to green to force traffic through during critical operations
+* **Testing scenarios**: Control circuit state without waiting for failures
+* **Gradual rollouts**: Manually control which stoplights are active during deployments
 
 ```ruby
-light = Stoplight('example-locked')
-# => #<Stoplight::CircuitBreaker:..>
-light.run { true }
-# => true
+# Force a stoplight to red state (fail all requests)
+# Useful during planned maintenance or when you know a service is down
 light.lock(Stoplight::Color::RED)
-# => #<Stoplight::CircuitBreaker:..>
-light.run { true } 
-# Stoplight::Error::RedLight: example-locked
+
+# Force a stoplight to green state (allow all requests)
+# Useful for critical operations that must attempt to proceed
+light.lock(Stoplight::Color::GREEN)
+
+# Return to normal operation (automatic state transitions)
+light.unlock
 ```
 
-**Code in locked red lights may still run under certain conditions!** If you
-have configured a custom data store and that data store fails, Stoplight will
-switch over to using a blank in-memory data store. That means you will lose the
-locked state of any stoplights.
+## Rails Integration
 
-You can go back to using the default behavior by unlocking the stoplight using `#unlock`.
+Wrap controller actions with minimal effort:
 
 ```ruby
-light.unlock
-# => #<Stoplight::CircuitBreaker:..>
-```
+class ApplicationController < ActionController::Base
+  around_action :stoplight
+
+  private
 
-### Testing
+  def stoplight(&block)
+    Stoplight("#{params[:controller]}##{params[:action]}")
+      .run(-> { render(nothing: true, status: :service_unavailable) }, &block)
+  end
+end
+```
 
-Stoplights typically work as expected without modification in test suites.
-However there are a few things you can do to make them behave better. If your
-stoplights are spewing messages into your test output, you can silence them
-with a couple configuration changes.
+Configure Stoplight in an initializer:
 
 ```ruby
-Stoplight.default_error_notifier = -> _ {}
-Stoplight.default_notifiers = []
+# config/initializers/stoplight.rb
+require "stoplight"
+Stoplight.configure do |config|
+  config.data_store = Stoplight::DataStore::Redis.new(Redis.new)
+  config.notifiers += [Stoplight::Notifier::Logger.new(Rails.logger)]
+end
 ```
 
-If your tests mysteriously fail because stoplights are the wrong color, you can
-try resetting the data store before each test case. For example, this would
-give each test case a fresh data store with RSpec.
+## Testing
 
+Tips for working with Stoplight in test environments:
+
+1. Silence notifications in tests
 ```ruby
-before(:each) do
-  Stoplight.default_data_store = Stoplight::DataStore::Memory.new
+Stoplight.configure do |config|
+  config.error_notifier = -> _ {}
+  config.notifiers = []
 end
 ```
 
-Sometimes you may want to test stoplights directly. You can avoid resetting the
-data store by giving each stoplight a unique name.
+2. Reset data store between tests
+```ruby
+before(:each) do
+  Stoplight.configure do |config|
+    config.data_store = Stoplight::DataStore::Memory.new
+  end
+end
+```
 
+3. Or use unique names for test Stoplights to avoid persistence between tests:
 ```ruby
 stoplight = Stoplight("test-#{rand}")
 ```
 
 ## Maintenance Policy
 
-Stoplight supports the latest three minor versions of Ruby, which currently are: `3.0.x`, `3.1.x`, and `3.2.x`. Changing
-the minimum supported Ruby version is not considered a breaking change.
-We support the current stable Redis version (`7.2`) and the latest release of the previous major version (`6.2.9`)
+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 
+version (`7.4.x`) and the latest release of the previous major version (`6.2.x`)
 
 ## Credits
 
-Stoplight is brought to you by [@camdez][] and [@tfausak][] from [@OrgSync][]. [@bolshakov][] is the current 
-maintainer of the gem. A [complete list of contributors][] is available on GitHub. We were inspired by
-Martin Fowler's [CircuitBreaker][] article. 
-
-Stoplight is licensed under [the MIT License][].
+Stoplight was originally created by [camdez][] and [tfausak][]. It is currently maintained by [bolshakov][] and
+[Lokideos][]. You can find a [complete list of contributors][] on GitHub. The project was inspired by Martin 
+Fowler’s [CircuitBreaker][] article.
 
 [Stoplight]: https://github.com/bolshakov/stoplight
 [Version badge]: https://img.shields.io/gem/v/stoplight.svg?label=version
@@ -487,21 +434,13 @@ Stoplight is licensed under [the MIT License][].
 [stoplight-admin]: https://github.com/bolshakov/stoplight-admin
 [Semantic Versioning]: http://semver.org/spec/v2.0.0.html
 [the change log]: CHANGELOG.md
-[the notifiers section]: #notifiers
-[the cool off time section]: #custom-cool-off-time
-[the Redis gem]: https://rubygems.org/gems/redis
-[the Bugsnag gem]: https://rubygems.org/gems/bugsnag
-[the Honeybadger gem]: https://rubygems.org/gems/honeybadger
-[the Logger class]: http://ruby-doc.org/stdlib-2.2.3/libdoc/logger/rdoc/Logger.html
-[the Rollbar gem]: https://rubygems.org/gems/rollbar
-[the Sentry gem]: https://rubygems.org/gems/sentry-raven
-[the Slack gem]: https://rubygems.org/gems/slack-notifier
-[the Pagerduty gem]: https://rubygems.org/gems/pagerduty
-[@camdez]: https://github.com/camdez
-[@tfausak]: https://github.com/tfausak
-[@orgsync]: https://github.com/OrgSync
-[@bolshakov]: https://github.com/bolshakov
+[stoplight-sentry]: https://github.com/bolshakov/stoplight-sentry
+[stoplight-honeybadger]: https://github.com/qoqa/stoplight-honeybadger
+[notifier interface documentation]: https://github.com/bolshakov/stoplight/blob/master/lib/stoplight/notifier/generic.rb
+[camdez]: https://github.com/camdez
+[tfausak]: https://github.com/tfausak
+[bolshakov]: https://github.com/bolshakov
+[Lokideos]: https://github.com/Lokideos
 [complete list of contributors]: https://github.com/bolshakov/stoplight/graphs/contributors
 [CircuitBreaker]: http://martinfowler.com/bliki/CircuitBreaker.html
-[the MIT license]: LICENSE.md
-[stoplight-sentry]: https://github.com/bolshakov/stoplight-sentry
+[Redis]: https://redis.io/