resilient_call 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1b6710bbb609417fc8131a025b0a6064bac8bbd1e71d55e87b8a506d90709375
+  data.tar.gz: 106f9defb53a23687ca85e7186e90cdf2732bf5cffeab86472be6521d2478b56
+SHA512:
+  metadata.gz: 61edc4419731654f9b6c0d19f3cbae025766fb2048d6f17e0fad9d177c729ce8580dcdb4f5b5ea6f9eef25209a335fa97c15c5f400c4e95a8fa347435b4fd381
+  data.tar.gz: a63fad56c64a7c4e93ba76837140dea471f09a2e0368fde195db068934155cc1f8020607d5bb20e0285a6a2ddeed1b4db67980ad0900445a3a925c5cbc4a13fc

data/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-12
+
+### Added
+
+- `ResilientCall.call` — wraps any block with configurable retry and optional
+  circuit-breaker protection.
+- Retry engine with `:exponential`, `:linear`, `:fixed`, and custom lambda
+  backoff strategies, plus jitter and a `max_wait` cap.
+- `on:` option to retry only the listed exception classes, propagating others
+  immediately.
+- Named, thread-safe circuit breaker — `Circuit` state machine plus the
+  `CircuitBreaker` registry — with `threshold`, `reset_timeout`, and half-open
+  probing.
+- `fallback:` executed while the circuit is open; `CircuitOpenError` raised when
+  no fallback is set.
+- Lifecycle callbacks: `on_retry`, `on_failure`, and `on_success`.
+- Global defaults via `ResilientCall.configure` and reusable named option sets
+  via `ResilientCall.define_profile`.
+- Option precedence: inline options > profile > global config > gem defaults.
+- `ResilientCall::Mixin` with the `resilient_method` macro to declare resilience
+  at the method level.
+- Error classes `ResilientCall::CircuitOpenError` and
+  `ResilientCall::RetriesExhaustedError` (the latter preserves the native
+  `#cause` chain).
+
+[Unreleased]: https://github.com/VorynLabs/resilient_call/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/VorynLabs/resilient_call/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VorynLabs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,261 @@
+# resilient_call
+
+[![Gem Version](https://img.shields.io/gem/v/resilient_call.svg)](https://rubygems.org/gems/resilient_call)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.0-red.svg)](https://www.ruby-lang.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+> Retry with exponential backoff and a circuit breaker for Ruby — zero dependencies.
+
+`resilient_call` wraps any block of code with configurable retries (exponential,
+linear, fixed, or custom backoff) and a named circuit breaker that protects your
+system when an external service is consistently failing. It works with plain Ruby
+and Rails, relies only on the standard library, and is thread-safe.
+
+## Installation
+
+Add it to your `Gemfile`:
+
+```ruby
+gem "resilient_call"
+```
+
+Then run `bundle install`, or install it directly:
+
+```bash
+gem install resilient_call
+```
+
+## Quick start
+
+```ruby
+require "resilient_call"
+
+result = ResilientCall.call { ExternalApi.fetch }
+```
+
+That single call retries `ExternalApi.fetch` on failure using the default
+exponential backoff, returning the result as soon as it succeeds.
+
+## Usage
+
+### Basic retry
+
+```ruby
+ResilientCall.call(retries: 3, base_wait: 0.5) do
+  HttpClient.get("https://api.example.com/status")
+end
+```
+
+If the block keeps failing past the configured attempts, `ResilientCall.call`
+raises `ResilientCall::RetriesExhaustedError`.
+
+### Retry strategies
+
+Control the wait between attempts with `wait:`. The `attempt` number is 1-based.
+
+| `wait:`        | Behavior                       | Example (`base_wait: 0.5`) |
+| -------------- | ------------------------------ | -------------------------- |
+| `:exponential` | `base_wait * (2 ** attempt)`   | 1s, 2s, 4s, 8s…            |
+| `:linear`      | `base_wait * attempt`          | 0.5s, 1s, 1.5s, 2s…        |
+| `:fixed`       | `base_wait`                    | 0.5s, 0.5s, 0.5s…          |
+| `->(n) { … }`  | custom, receives `attempt`     | any logic                  |
+
+With `jitter: true` (the default), a random `rand(0..base_wait * 0.3)` is added
+to the computed wait before capping it at `max_wait`. This avoids the thundering
+herd problem when many clients retry at once.
+
+```ruby
+ResilientCall.call(wait: :exponential, base_wait: 0.5, max_wait: 30.0, jitter: true) do
+  PaymentGateway.charge(amount: 100)
+end
+```
+
+### Selecting which errors trigger a retry
+
+```ruby
+ResilientCall.call(on: [Net::OpenTimeout, Net::ReadTimeout]) do
+  HttpClient.get(url)
+end
+```
+
+Only the listed exception classes are retried; anything else propagates
+immediately. The default is `[StandardError]`.
+
+### Circuit breaker
+
+Pass `circuit:` to protect a dependency with a named circuit breaker. After
+`threshold` consecutive failures the circuit opens and stops sending requests
+until `reset_timeout` seconds have elapsed, when it allows a single probe.
+
+```ruby
+ResilientCall.call(circuit: :stripe, threshold: 5, reset_timeout: 30) do
+  StripeClient.charge(amount: 100)
+end
+```
+
+While the circuit is open, `ResilientCall.call` raises
+`ResilientCall::CircuitOpenError` (unless a `fallback` is given).
+
+### Fallback
+
+```ruby
+ResilientCall.call(circuit: :stripe, fallback: -> { CachedResult.last }) do
+  StripeClient.charge(amount: 100)
+end
+```
+
+When the circuit is open the `fallback` runs instead of the block, and its
+return value becomes the result of the call.
+
+### Callbacks
+
+```ruby
+ResilientCall.call(
+  on_retry:   ->(attempt, error) { Rails.logger.warn("retry ##{attempt}: #{error.message}") },
+  on_failure: ->(error)          { Sentry.capture_exception(error) },
+  on_success: ->(result, tries)  { StatsD.increment("ok", tags: ["tries:#{tries}"]) }
+) do
+  StripeClient.charge(amount: 100)
+end
+```
+
+### Global configuration
+
+Set defaults once — in `config/initializers/resilient_call.rb` on Rails, or at
+boot in plain Ruby. Options passed to `.call` always override these.
+
+```ruby
+ResilientCall.configure do |c|
+  c.retries       = 3
+  c.wait          = :exponential
+  c.base_wait     = 0.5
+  c.max_wait      = 30.0
+  c.jitter        = true
+  c.on            = [StandardError]
+
+  c.threshold     = 5
+  c.reset_timeout = 60
+
+  c.on_retry      = ->(attempt, error) { Rails.logger.warn("[resilient_call] retry ##{attempt}: #{error.message}") }
+  c.on_failure    = ->(error)          { Rails.logger.error("[resilient_call] failed: #{error.message}") }
+end
+```
+
+### Reusable profiles
+
+Profiles are named option sets. They merge over the global defaults and can be
+overridden inline. Precedence: **inline options > profile > global config > gem defaults**.
+
+```ruby
+ResilientCall.define_profile :payment,
+  retries: 3, wait: :exponential, circuit: :stripe, threshold: 5, reset_timeout: 30
+
+ResilientCall.define_profile :fast_api,
+  retries: 1, wait: :fixed, base_wait: 0.1, on: [Net::OpenTimeout]
+
+ResilientCall.call(profile: :payment) { StripeClient.charge(amount: 100) }
+ResilientCall.call(profile: :fast_api, retries: 2) { SlackNotifier.ping(message) }
+```
+
+### Service object mixin
+
+Declare resilience at the method level — transparent to the caller.
+
+```ruby
+class PaymentService
+  include ResilientCall::Mixin
+
+  def charge(amount)
+    StripeClient.charge(amount: amount)
+  end
+  resilient_method :charge, profile: :payment
+
+  def refund(charge_id)
+    StripeClient.refund(charge_id)
+  end
+  resilient_method :refund, retries: 2, circuit: :stripe
+end
+
+PaymentService.new.charge(100) # retries + circuit breaker applied automatically
+```
+
+`resilient_method` must be called after the method is defined. It forwards
+positional arguments, keyword arguments, and blocks unchanged.
+
+### Inspecting circuits at runtime
+
+```ruby
+circuit = ResilientCall::CircuitBreaker[:stripe]
+
+circuit.state          # => :closed | :open | :half_open
+circuit.failure_count  # => Integer
+circuit.last_failure   # => Exception or nil
+circuit.opened_at      # => Time or nil
+circuit.reset!         # force it closed — handy in a console, rake task, or test
+
+ResilientCall::CircuitBreaker.reset_all! # reset every registered circuit
+```
+
+## Error reference
+
+### `ResilientCall::CircuitOpenError`
+
+Raised when the circuit is open and no `fallback` is set.
+
+```ruby
+rescue ResilientCall::CircuitOpenError => e
+  e.circuit_name # => :stripe
+  e.opens_at     # => Time the circuit opened
+  e.retry_after  # => Integer seconds estimated until half-open
+  e.last_error   # => the last exception that contributed to opening
+end
+```
+
+### `ResilientCall::RetriesExhaustedError`
+
+Raised when every retry has been consumed without success.
+
+```ruby
+rescue ResilientCall::RetriesExhaustedError => e
+  e.attempts # => number of attempts made
+  e.cause    # => the last captured exception (native Ruby #cause)
+end
+```
+
+## Configuration reference
+
+| Option          | Default           | Description                                              |
+| --------------- | ----------------- | -------------------------------------------------------- |
+| `retries`       | `3`               | Attempts after the first failure                         |
+| `wait`          | `:exponential`    | Backoff strategy (`:exponential`/`:linear`/`:fixed`/Proc)|
+| `base_wait`     | `0.5`             | Base seconds for the backoff calculation                 |
+| `max_wait`      | `30.0`            | Upper bound for the backoff, in seconds                  |
+| `jitter`        | `true`            | Add random noise to the wait                             |
+| `on`            | `[StandardError]` | Exception classes that trigger a retry                   |
+| `circuit`       | `nil`             | Named circuit (Symbol); no circuit breaker without it    |
+| `threshold`     | `5`               | Consecutive failures before the circuit opens            |
+| `reset_timeout` | `60`              | Seconds in the open state before a half-open probe       |
+| `fallback`      | `nil`             | Callable run when the circuit is open                    |
+| `on_retry`      | `nil`             | `->(attempt, error)` called on each retry                |
+| `on_failure`    | `nil`             | `->(error)` called when attempts are exhausted           |
+| `on_success`    | `nil`             | `->(result, attempts)` called on success                 |
+
+## Roadmap
+
+| Version | Feature                                                          |
+| ------- | --------------------------------------------------------------- |
+| `v0.2`  | Pluggable storage for circuit state (Redis for multi-process)   |
+| `v0.3`  | `ActiveSupport::Notifications` instrumentation and metrics      |
+| `v0.4`  | Mountable Rack dashboard for live circuit state                 |
+| `v0.5`  | Native timeout integrated into the retry loop                   |
+| `v1.0`  | Stable API, full documentation, published benchmarks            |
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+<https://github.com/VorynLabs/resilient_call>. Run the test suite with
+`bundle exec rspec` before submitting.
+
+## License
+
+Released under the [MIT License](LICENSE).

data/lib/resilient_call/circuit.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ResilientCall
+  # Holds the state of a single named circuit and manages its transitions.
+  # Thread-safe: every public method runs under an internal Mutex.
+  #
+  #   closed --(threshold failures)--> open --(reset_timeout elapsed)--> half_open
+  #     ^                                                                     |
+  #     +------------------------- record_success! -------------------------+
+  #   half_open --(record_failure!)--> open  (restarts the timer)
+  class Circuit
+    attr_reader :name, :threshold, :reset_timeout
+
+    def initialize(name, threshold: 5, reset_timeout: 60)
+      @name          = name
+      @threshold     = threshold
+      @reset_timeout = reset_timeout
+      @state         = :closed
+      @failure_count = 0
+      @opened_at     = nil
+      @last_failure  = nil
+      @mutex         = Mutex.new
+    end
+
+    def state
+      @mutex.synchronize { @state }
+    end
+
+    def failure_count
+      @mutex.synchronize { @failure_count }
+    end
+
+    def last_failure
+      @mutex.synchronize { @last_failure }
+    end
+
+    def opened_at
+      @mutex.synchronize { @opened_at }
+    end
+
+    # Whether a request may pass right now. An :open circuit whose reset_timeout
+    # has elapsed transitions to :half_open and lets a single probe through.
+    def allow_request?
+      @mutex.synchronize do
+        case @state
+        when :closed
+          true
+        when :half_open
+          true
+        when :open
+          if Time.now - @opened_at >= @reset_timeout
+            @state = :half_open
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+
+    def record_success!
+      @mutex.synchronize do
+        case @state
+        when :half_open
+          @state         = :closed
+          @failure_count = 0
+        when :closed
+          @failure_count = 0
+        end
+      end
+    end
+
+    def record_failure!(error)
+      @mutex.synchronize do
+        @failure_count += 1
+        @last_failure   = error
+
+        if @state == :half_open
+          @state     = :open
+          @opened_at = Time.now
+        elsif @state == :closed && @failure_count >= @threshold
+          @state     = :open
+          @opened_at = Time.now
+        end
+      end
+    end
+
+    def reset!
+      @mutex.synchronize do
+        @state         = :closed
+        @failure_count = 0
+        @opened_at     = nil
+        @last_failure  = nil
+      end
+    end
+
+    # Lets the entry point inject configured thresholds onto a circuit that was
+    # created lazily by the registry with default values.
+    def update_config(threshold: nil, reset_timeout: nil)
+      @mutex.synchronize do
+        @threshold     = threshold     unless threshold.nil?
+        @reset_timeout = reset_timeout unless reset_timeout.nil?
+      end
+    end
+  end
+end

data/lib/resilient_call/circuit_breaker.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ResilientCall
+  # Global, thread-safe registry of named Circuit instances.
+  module CircuitBreaker
+    @registry = {}
+    @mutex    = Mutex.new
+
+    # Returns the circuit for `name`, creating it on first access. Created with
+    # the scope-3 defaults (threshold: 5, reset_timeout: 60); scope 4 will inject
+    # configured values through the entry point.
+    def self.[](name)
+      @mutex.synchronize { @registry[name] ||= Circuit.new(name) }
+    end
+
+    def self.reset_all!
+      @mutex.synchronize { @registry.each_value(&:reset!) }
+    end
+  end
+end

data/lib/resilient_call/configuration.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ResilientCall
+  # Holds the global defaults and the registry of named profiles.
+  class Configuration
+    # retry
+    attr_accessor :retries, :wait, :base_wait, :max_wait, :jitter, :on
+    # circuit breaker
+    attr_accessor :threshold, :reset_timeout
+    # callbacks
+    attr_accessor :on_retry, :on_failure, :on_success
+    # named profiles registry
+    attr_accessor :profiles
+
+    def initialize
+      @retries       = 3
+      @wait          = :exponential
+      @base_wait     = 0.5
+      @max_wait      = 30.0
+      @jitter        = true
+      @on            = [StandardError]
+
+      @threshold     = 5
+      @reset_timeout = 60
+
+      @on_retry      = nil
+      @on_failure    = nil
+      @on_success    = nil
+
+      @profiles      = {}
+    end
+
+    # Every default except the profiles registry, ready to be merged in `.call`.
+    def to_h
+      {
+        retries:       @retries,
+        wait:          @wait,
+        base_wait:     @base_wait,
+        max_wait:      @max_wait,
+        jitter:        @jitter,
+        on:            @on,
+        threshold:     @threshold,
+        reset_timeout: @reset_timeout,
+        on_retry:      @on_retry,
+        on_failure:    @on_failure,
+        on_success:    @on_success
+      }
+    end
+  end
+end

data/lib/resilient_call/errors.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ResilientCall
+  # Raised when a request is rejected because its named circuit is open.
+  class CircuitOpenError < StandardError
+    attr_reader :circuit_name, :opens_at, :retry_after, :last_error
+
+    def initialize(circuit_name:, opens_at:, retry_after:, last_error:, message: nil)
+      @circuit_name = circuit_name
+      @opens_at     = opens_at
+      @retry_after  = retry_after
+      @last_error   = last_error
+      super(message || "circuit #{circuit_name.inspect} is open")
+    end
+  end
+
+  # Raised when all configured retries have been exhausted without success.
+  # The original exception is available through Ruby's native `#cause` chain
+  # when this error is raised from inside a rescue block.
+  class RetriesExhaustedError < StandardError
+    attr_reader :attempts
+
+    def initialize(attempts:, message: nil)
+      @attempts = attempts
+      super(message || "exhausted after #{attempts} attempt(s)")
+    end
+  end
+end

data/lib/resilient_call/mixin.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ResilientCall
+  # Adds the `resilient_method` class macro to any class that includes it,
+  # wrapping the named instance method in a transparent ResilientCall.call.
+  module Mixin
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Wraps an already-defined instance method so every invocation runs
+      # through ResilientCall.call with the given options (retry, circuit, etc).
+      def resilient_method(method_name, **options)
+        original = instance_method(method_name)
+
+        define_method(method_name) do |*args, **kwargs, &block|
+          ResilientCall.call(**options) do
+            original.bind_call(self, *args, **kwargs, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resilient_call/retrier.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ResilientCall
+  # Executes a block with retry, computing the wait between attempts and firing
+  # the configured callbacks. Has no knowledge of circuit breakers.
+  class Retrier
+    DEFAULTS = {
+      retries:    3,
+      wait:       :exponential,
+      base_wait:  0.5,
+      max_wait:   30.0,
+      jitter:     true,
+      on:         [StandardError],
+      on_retry:   nil,
+      on_failure: nil,
+      on_success: nil
+    }.freeze
+
+    def initialize(options = {})
+      opts = DEFAULTS.merge(options)
+
+      @retries    = opts[:retries]
+      @wait       = opts[:wait]
+      @base_wait  = opts[:base_wait]
+      @max_wait   = opts[:max_wait]
+      @jitter     = opts[:jitter]
+      @on         = Array(opts[:on])
+      @on_retry   = opts[:on_retry]
+      @on_failure = opts[:on_failure]
+      @on_success = opts[:on_success]
+    end
+
+    # Runs the block. Returns its result, or raises RetriesExhaustedError once
+    # every attempt has been consumed.
+    def call
+      attempt = 0
+
+      begin
+        attempt += 1
+        result = yield
+        @on_success&.call(result, attempt)
+        result
+      rescue *@on => err
+        if attempt <= @retries
+          @on_retry&.call(attempt, err)
+          sleep(wait_time(attempt))
+          retry
+        end
+
+        @on_failure&.call(err)
+        # Raised inside the rescue so Ruby populates #cause with `err`.
+        raise RetriesExhaustedError.new(attempts: attempt)
+      end
+    end
+
+    private
+
+    # 1-based attempt number. Applies jitter before capping at max_wait.
+    def wait_time(attempt)
+      raw = case @wait
+            when :exponential then @base_wait * (2**attempt)
+            when :linear      then @base_wait * attempt
+            when :fixed       then @base_wait
+            when Proc         then @wait.call(attempt)
+            else
+              raise ArgumentError, "unknown wait strategy: #{@wait.inspect}"
+            end
+
+      raw += rand(0..@base_wait * 0.3) if @jitter
+      [raw, @max_wait].min
+    end
+  end
+end

data/lib/resilient_call/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ResilientCall
+  VERSION = "0.1.0"
+end

data/lib/resilient_call.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "resilient_call/version"
+require_relative "resilient_call/errors"
+require_relative "resilient_call/configuration"
+require_relative "resilient_call/circuit"
+require_relative "resilient_call/circuit_breaker"
+require_relative "resilient_call/retrier"
+require_relative "resilient_call/mixin"
+
+module ResilientCall
+  class << self
+    # Runs `block` with retry and, when `circuit:` is given, circuit-breaker
+    # protection. Option precedence: inline > profile > global config > defaults.
+    def call(**options, &block)
+      options = resolve_options(options)
+      circuit = circuit_for(options)
+
+      if circuit && !circuit.allow_request?
+        return options[:fallback].call if options[:fallback]
+
+        raise circuit_open_error(circuit, options)
+      end
+
+      run_with_retry(options, circuit, &block)
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def define_profile(name, **options)
+      configuration.profiles[name] = options
+    end
+
+    # Restores global defaults — useful for isolating tests.
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    private
+
+    # Merges defaults < profile < inline options into a single options hash.
+    def resolve_options(options)
+      merged = configuration.to_h
+
+      if (profile_name = options.delete(:profile))
+        merged = merged.merge(configuration.profiles[profile_name] || {})
+      end
+
+      merged.merge(options)
+    end
+
+    # Resolves the named circuit (if any) and applies the configured thresholds.
+    def circuit_for(options)
+      return unless (name = options[:circuit])
+
+      CircuitBreaker[name].tap do |circuit|
+        circuit.update_config(
+          threshold:     options[:threshold],
+          reset_timeout: options[:reset_timeout]
+        )
+      end
+    end
+
+    def circuit_open_error(circuit, options)
+      CircuitOpenError.new(
+        circuit_name: options[:circuit],
+        opens_at:     circuit.opened_at,
+        retry_after:  (circuit.opened_at + options[:reset_timeout] - Time.now).to_i,
+        last_error:   circuit.last_failure
+      )
+    end
+
+    # Runs the block through the Retrier, feeding circuit outcomes as it goes.
+    def run_with_retry(options, circuit, &block)
+      Retrier.new(options).call do
+        result = block.call
+        circuit&.record_success!
+        result
+      rescue StandardError => e
+        circuit&.record_failure!(e)
+        raise
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: resilient_call
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wesley Sena
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Wrapper for any Ruby block with configurable retries, jitter, named circuit
+  breaker, declarative fallback, and service class mixin support.
+email:
+- vorynworks@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/resilient_call.rb
+- lib/resilient_call/circuit.rb
+- lib/resilient_call/circuit_breaker.rb
+- lib/resilient_call/configuration.rb
+- lib/resilient_call/errors.rb
+- lib/resilient_call/mixin.rb
+- lib/resilient_call/retrier.rb
+- lib/resilient_call/version.rb
+homepage: https://github.com/VorynLabs/resilient_call
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/VorynLabs/resilient_call
+  source_code_uri: https://github.com/VorynLabs/resilient_call
+  changelog_uri: https://github.com/VorynLabs/resilient_call/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key: 
+specification_version: 4
+summary: Retry with exponential backoff and circuit breaker for Ruby
+test_files: []