timex 0.1.0

data/lib/timex/composers/adaptive.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module TIMEx
+  module Composers
+    # Chooses a per-call child deadline from a latency estimator, then delegates
+    # to +child+ with +on_timeout: :raise+ so timeouts feed back into the
+    # estimator uniformly before applying the caller's +on_timeout:+.
+    #
+    # @see Base
+    class Adaptive < Base
+
+      # O(1) streaming quantile estimator (P² algorithm, Jain & Chlamtac 1985).
+      #
+      # {#record} updates markers; {#estimate_ms} reads the last published estimate
+      # without locking. Markers reset every +window+ samples.
+      #
+      # @note {#estimate_ms} is intentionally lock-free; it may briefly return a
+      #   stale value while {#record} runs on another thread.
+      class InMemoryStore
+
+        P_DEFAULT = 0.99
+
+        # @param window [Integer] samples before marker reset
+        # @param alpha [Float] EWMA smoothing factor for the safety margin
+        # @param p [Float] target quantile (default ~p99)
+        def initialize(window: 200, alpha: 0.2, p: P_DEFAULT)
+          @window = window
+          @alpha = alpha
+          @p = p
+          @ewma = nil
+          @count = 0
+          @mutex = Mutex.new
+          @last_estimate_ms = nil
+          reset_markers
+        end
+
+        # Records a latency sample in milliseconds and refreshes the published estimate.
+        #
+        # @param ms [Numeric] observed latency in ms
+        # @return [self]
+        def record(ms)
+          @mutex.synchronize do
+            reset_markers if @count >= @window
+            @count += 1
+            @ewma  = @ewma.nil? ? ms : (@alpha * ms) + ((1 - @alpha) * @ewma)
+
+            if @q.nil?
+              @initial << ms
+              promote_to_psquare if @initial.size == 5
+            else
+              psquare_step(ms)
+            end
+            # Publish the post-record estimate for lock-free reads. Single ivar
+            # write is atomic in MRI; readers see either the previous or new
+            # value, both of which are valid.
+            @last_estimate_ms = compute_estimate
+          end
+          self
+        end
+
+        # Lock-free read: {#record} publishes a fresh estimate at the end of
+        # every call under the mutex. Readers don't need to synchronize.
+        #
+        # @return [Float, nil] last estimated budget in ms, or +nil+ when empty
+        def estimate_ms
+          @last_estimate_ms
+        end
+
+        private
+
+        def compute_estimate
+          return nil if @count.zero?
+
+          base = if @q
+                   @q[2]
+                 else
+                   sorted = @initial.sort
+                   sorted[((sorted.size - 1) * @p).round]
+                 end
+          [base, (@ewma || 0) * 3].max
+        end
+
+        def reset_markers
+          @count   = 0
+          @initial = []
+          @q  = nil
+          @n  = nil
+          @np = nil
+          @dn = nil
+        end
+
+        def promote_to_psquare
+          @q  = @initial.sort
+          @n  = [1, 2, 3, 4, 5]
+          @np = [1.0, 1.0 + (2.0 * @p), 1.0 + (4.0 * @p), 3.0 + (2.0 * @p), 5.0]
+          @dn = [0.0, @p / 2.0, @p, (1.0 + @p) / 2.0, 1.0]
+          @initial = nil
+        end
+
+        def psquare_step(x)
+          k = locate_cell(x)
+          ((k + 1)..4).each { |i| @n[i] += 1 }
+          5.times { |i| @np[i] += @dn[i] }
+          (1..3).each { |i| adjust_marker(i) }
+        end
+
+        def locate_cell(x)
+          if x < @q[0]
+            @q[0] = x
+            0
+          elsif x < @q[1] then 0
+          elsif x < @q[2] then 1
+          elsif x < @q[3] then 2
+          elsif x <= @q[4] then 3
+          else
+            @q[4] = x
+            3
+          end
+        end
+
+        def adjust_marker(i)
+          d = @np[i] - @n[i]
+          return unless (d >= 1 && @n[i + 1] - @n[i] > 1) || (d <= -1 && @n[i - 1] - @n[i] < -1)
+
+          d = d.positive? ? 1 : -1
+          qp = parabolic(i, d)
+          qp = linear(i, d) if qp <= @q[i - 1] || qp >= @q[i + 1]
+          @q[i] = qp
+          @n[i] += d
+        end
+
+        def parabolic(i, d)
+          @q[i] + ((d.to_f / (@n[i + 1] - @n[i - 1])) *
+            ((((@n[i] - @n[i - 1] + d) * (@q[i + 1] - @q[i])) / (@n[i + 1] - @n[i])) +
+             (((@n[i + 1] - @n[i] - d) * (@q[i] - @q[i - 1])) / (@n[i] - @n[i - 1]))))
+        end
+
+        def linear(i, d)
+          @q[i] + ((d * (@q[i + d] - @q[i])) / (@n[i + d] - @n[i]))
+        end
+
+      end
+
+      # @param child [Symbol, Strategies::Base] inner strategy
+      # @param history [#estimate_ms, #record] latency store (defaults to {InMemoryStore})
+      # @param multiplier [Numeric] scales the estimate into a budget
+      # @param floor_ms [Numeric] minimum adaptive budget
+      # @param ceiling_ms [Numeric] maximum adaptive budget
+      # @raise [ArgumentError] when parameters are invalid
+      def initialize(child:, history: InMemoryStore.new, multiplier: 1.5, floor_ms: 25, ceiling_ms: 30_000)
+        super()
+        raise ArgumentError, "multiplier must be > 0" unless multiplier.is_a?(Numeric) && multiplier.positive?
+        raise ArgumentError, "floor_ms must be a positive Numeric" unless floor_ms.is_a?(Numeric) && floor_ms.positive?
+        raise ArgumentError, "ceiling_ms must be >= floor_ms" unless ceiling_ms.is_a?(Numeric) && ceiling_ms >= floor_ms
+
+        @child = Registry.resolve(child)
+        @history = history
+        @multiplier = multiplier
+        @floor_ms = floor_ms
+        @ceiling_ms = ceiling_ms
+      end
+
+      # @param deadline [Deadline, Numeric, Time, nil, Object] optional outer cap (+min+ with adaptive budget)
+      # @param on_timeout [Symbol, Proc] applied after child raises {Expired}
+      # @param opts [Hash{Symbol => Object}] forwarded to +child+
+      # @yieldparam deadline [Deadline]
+      # @return [Object] child return or timeout handler result
+      # @raise [StandardError] non-timeout errors from the child propagate after recording latency
+      def call(deadline: nil, on_timeout: :raise, **opts, &block)
+        estimate  = @history.estimate_ms
+        budget_ms = if estimate
+                      (estimate * @multiplier).clamp(@floor_ms, @ceiling_ms)
+                    else
+                      @ceiling_ms
+                    end
+
+        adaptive_deadline = Deadline.in(budget_ms / 1000.0)
+        effective         = deadline ? Deadline.coerce(deadline).min(adaptive_deadline) : adaptive_deadline
+
+        TIMEx::Telemetry.instrument(
+          event: "composer.adaptive",
+          estimate_ms: estimate&.round,
+          budget_ms: budget_ms.round,
+          deadline_ms: effective.infinite? ? nil : effective.remaining_ms.round
+        ) do |payload|
+          started = Clock.monotonic_ns
+          begin
+            # Force the child to surface `Expired` so we can record a uniform
+            # timeout penalty regardless of the caller's `on_timeout:` (a
+            # `:return_nil`/`:result` path would otherwise be recorded as a
+            # success at ~budget_ms and never penalize the estimator). We
+            # re-apply the caller's `on_timeout:` ourselves.
+            value = @child.call(deadline: effective, on_timeout: :raise, **opts, &block)
+            @history.record((Clock.monotonic_ns - started) / 1_000_000.0)
+            value
+          rescue Expired => e
+            payload[:outcome] = :timeout
+            # Record the *budget* as the penalty (capped at ceiling), not the
+            # multiplied estimate. Previously we recorded the parent-clamped
+            # budget_ms back into history, which on a tight parent deadline
+            # could differ from what we actually waited and bias the estimator.
+            # Use `effective.remaining_ms` (post-clamp elapsed) if available so
+            # the estimator tracks real wait time, falling back to budget_ms.
+            elapsed_ms = (Clock.monotonic_ns - started) / 1_000_000.0
+            @history.record([elapsed_ms, budget_ms.to_f].max.clamp(@floor_ms, @ceiling_ms))
+            handle_timeout(on_timeout, e)
+          rescue StandardError
+            # User-cancelled or otherwise-failed attempts should still feed
+            # the estimator: a child that consistently raises after ~budget_ms
+            # tells us latency is rising, even if the caller is the one
+            # throwing the exception. Cap the recorded sample at the ceiling
+            # so a slow upstream-of-failure doesn't pin the estimator high.
+            elapsed_ms = (Clock.monotonic_ns - started) / 1_000_000.0
+            @history.record(elapsed_ms.clamp(@floor_ms, @ceiling_ms))
+            raise
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/timex/composers/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TIMEx
+  module Composers
+    # Shared mixin for composer objects that orchestrate one or more strategies.
+    #
+    # Composers behave like strategies: they accept +deadline:+ / +on_timeout:+,
+    # expose {.name_symbol} via {NamedComponent}, and route {Expired} through
+    # {TimeoutHandling}. Subclasses implement +#call+ with their own scheduling.
+    #
+    # @see TimeoutHandling
+    # @see NamedComponent
+    class Base
+
+      include TIMEx::NamedComponent
+      include TIMEx::TimeoutHandling
+
+    end
+  end
+end

data/lib/timex/composers/hedged.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module TIMEx
+  module Composers
+    # Launches up to +max:+ staggered parallel attempts (+after:+ seconds apart)
+    # of +child+ and returns the first successful result.
+    #
+    # @note Losers are stopped with +Thread#kill+; the block must tolerate
+    #   concurrent execution, partial side effects, and abrupt termination.
+    #
+    # @see Base
+    class Hedged < Base
+
+      # @param after [Numeric] seconds between successive attempt launches
+      # @param child [Symbol, Strategies::Base] strategy used per attempt
+      # @param max [Integer] maximum concurrent attempts (>= 1)
+      # @param idempotent [Boolean] must be +true+; acknowledges concurrent/kill semantics
+      # @raise [ArgumentError] when parameters are invalid
+      def initialize(after:, child:, max: 2, idempotent: false)
+        super()
+        raise ArgumentError, "Hedged requires idempotent: true" unless idempotent
+        raise ArgumentError, "after must be a non-negative Numeric" unless after.is_a?(Numeric) && !after.negative?
+        raise ArgumentError, "max must be >= 1" if max < 1
+
+        @after = after
+        @max = max
+        @child = Registry.resolve(child)
+      end
+
+      # @param deadline [Deadline, Numeric, Time, nil]
+      # @param on_timeout [Symbol, Proc]
+      # @param opts [Hash{Symbol => Object}] forwarded to each child attempt
+      # @yieldparam deadline [Deadline]
+      # @return [Object] first successful value or handler result
+      # @raise [StandardError] re-raised from a failed attempt when no success precedes it
+      def call(deadline:, on_timeout: :raise, **opts, &block)
+        deadline = Deadline.coerce(deadline)
+        results = Queue.new
+        # Side-channel of "a result just landed" notifications so the spawn
+        # loop can block on `signal.pop(timeout:)` instead of polling — we
+        # can't peek at `results` non-destructively without disturbing the
+        # consumption order of `await_outcome`.
+        signal = Queue.new
+        threads = []
+
+        threads << launch(deadline, results, signal, opts, &block)
+        until !results.empty? || (threads.size >= @max) || deadline.expired?
+          status = wait_for_result(@after, signal, deadline)
+          break if status == :result_ready
+          # `wait_for_result` returns `:expired` when the parent deadline
+          # elapsed during the wait. Bail before launching a redundant
+          # worker that would race against the expiration.
+          break if status == :expired
+
+          threads << launch(deadline, results, signal, opts, &block)
+        end
+
+        outcome = await_outcome(results, threads.size, deadline)
+        threads.each { |t| t.kill if t.alive? }
+
+        case outcome[0]
+        when :ok then outcome[1]
+        when :error then raise outcome[1]
+        when :timeout
+          handle_timeout(
+            on_timeout,
+            deadline.expired_error(
+              strategy: :hedged,
+              message: "all hedged attempts timed out"
+            )
+          )
+        end
+      end
+
+      private
+
+      # Drains queued results so that a non-`:ok` outcome doesn't beat a still-
+      # pending successful attempt. Returns the first `:ok`, otherwise the last
+      # outcome seen (preferring `:error` over `:timeout`). Bounded by the
+      # parent deadline so a non-cooperative child cannot hang the composer.
+      #
+      # @param results [Queue]
+      # @param expected [Integer] number of workers launched
+      # @param deadline [Deadline]
+      # @return [Array] +[:ok, value]+, +[:error, exception]+, or +[:timeout]+
+      def await_outcome(results, expected, deadline)
+        seen = []
+        expected.times do
+          remaining = deadline.infinite? ? nil : [deadline.remaining, 0.0].max
+          outcome   = remaining.nil? ? results.pop : results.pop(timeout: remaining)
+          if outcome.nil?
+            # Drain anything that landed between the previous pop and now so a
+            # late-arriving winner isn't dropped on a tight deadline.
+            until results.empty?
+              late = results.pop(timeout: 0)
+              break if late.nil?
+              return late if late[0] == :ok
+
+              seen << late
+            end
+            break
+          end
+          return outcome if outcome[0] == :ok
+
+          seen << outcome
+        end
+        seen.find { |o| o[0] == :error } || seen.last || [:timeout]
+      end
+
+      # @return [Thread]
+      def launch(deadline, results, signal, opts, &block)
+        Thread.new do
+          value = @child.call(deadline:, on_timeout: :raise, **opts, &block)
+          results << [:ok, value]
+          signal  << :ready
+        rescue Expired
+          results << [:timeout]
+          signal  << :ready
+        rescue StandardError => e
+          results << [:error, e]
+          signal  << :ready
+        end
+      end
+
+      # Blocks for up to +seconds+ (or until the parent deadline elapses)
+      # waiting for a worker to enqueue a result. Uses a notification queue so
+      # we don't have to poll or peek at +results+. Returns +:expired+ when
+      # the parent deadline already elapsed (so +signal.pop(timeout: 0)+
+      # would no-op and the caller would otherwise spawn a redundant worker
+      # before the outer +deadline.expired?+ re-check).
+      #
+      # @param seconds [Numeric]
+      # @param signal [Queue]
+      # @param deadline [Deadline]
+      # @return [Symbol] +:result_ready+, +:expired+, or +:time_up+
+      def wait_for_result(seconds, signal, deadline)
+        return :result_ready if signal.pop(timeout: 0)
+        return :expired if !deadline.infinite? && deadline.remaining <= 0
+
+        wait = deadline.infinite? ? seconds : [deadline.remaining, seconds].min
+        signal.pop(timeout: wait) ? :result_ready : :time_up
+      end
+
+    end
+  end
+end

data/lib/timex/composers/two_phase.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module TIMEx
+  module Composers
+    # Runs a **soft** strategy first, then escalates to a **hard** strategy after
+    # +grace+ seconds beyond the soft budget, killing the soft worker and
+    # re-invoking the block (requires +idempotent: true+).
+    #
+    # @see Base
+    class TwoPhase < Base
+
+      attr_reader :soft, :hard, :grace, :hard_deadline, :idempotent
+
+      # @param soft [Symbol, Strategies::Base] strategy for the first attempt
+      # @param hard [Symbol, Strategies::Base] strategy that forcibly bounds the second attempt
+      # @param grace [Numeric] seconds after soft budget before escalation
+      # @param hard_deadline [Numeric] hard-phase budget in seconds (clamped to parent remaining)
+      # @param idempotent [Boolean] must be +true+; acknowledges the block may run twice
+      # @raise [ArgumentError] when invariants are violated
+      def initialize(soft:, hard:, grace: 0.5, hard_deadline: 1.0, idempotent: false)
+        super()
+        raise ArgumentError, "TwoPhase escalates by re-invoking the block; pass idempotent: true to acknowledge" unless idempotent
+        raise ArgumentError, "grace must be a non-negative Numeric" unless grace.is_a?(Numeric) && !grace.negative?
+        raise ArgumentError, "hard_deadline must be a positive Numeric" unless hard_deadline.is_a?(Numeric) && hard_deadline.positive?
+
+        @soft = Registry.resolve(soft)
+        @hard = Registry.resolve(hard)
+        @grace = grace
+        @hard_deadline = hard_deadline
+        @idempotent = idempotent
+      end
+
+      # @param deadline [Deadline, Numeric, Time, nil]
+      # @param on_timeout [Symbol, Proc]
+      # @param opts [Hash{Symbol => Object}] forwarded to child strategies
+      # @yieldparam deadline [Deadline]
+      # @return [Object] soft-path value, hard-path value, or handler result
+      # @raise [StandardError] when the soft worker raises a non-timeout error
+      def call(deadline:, on_timeout: :raise, **opts, &block)
+        deadline = Deadline.coerce(deadline)
+        soft_budget = deadline.infinite? ? nil : deadline.remaining
+        wait = soft_budget ? soft_budget + @grace : nil
+
+        TIMEx::Telemetry.instrument(
+          event: "composer.two_phase",
+          soft_ms: soft_budget && (soft_budget * 1000).round,
+          grace_ms: (@grace * 1000).round
+        ) do |payload|
+          queue = Queue.new
+          worker = Thread.new do
+            value = @soft.call(deadline:, on_timeout: :raise, **opts, &block)
+            queue << [:ok, value]
+          rescue Expired => e
+            queue << [:soft_timeout, e]
+          rescue StandardError => e
+            queue << [:error, e]
+          end
+
+          if (outcome = pop_with_timeout(queue, wait))
+            kind, value = outcome
+            payload[:outcome] = kind == :ok ? :ok : kind
+            return value if kind == :ok
+            raise value if kind == :error
+
+            return handle_timeout(on_timeout, value)
+          end
+
+          # Worker exceeded soft + grace. Force-stop and escalate.
+          worker.kill
+          payload[:soft_timeout] = true
+
+          # Clamp the hard-phase budget to whatever remains on the parent
+          # deadline, so escalation cannot extend the caller's contract.
+          hard_deadline = Deadline.in(@hard_deadline).min(deadline)
+          begin
+            @hard.call(deadline: hard_deadline, on_timeout: :raise, **opts, &block)
+          rescue Expired => e
+            payload[:outcome] = :hard_timeout
+            handle_timeout(on_timeout, e)
+          end
+        end
+      end
+
+      private
+
+      # @param queue [Queue]
+      # @param seconds [Numeric, nil]
+      # @return [Array, nil] queued pair or +nil+ on timeout
+      def pop_with_timeout(queue, seconds)
+        return queue.pop if seconds.nil?
+
+        queue.pop(timeout: seconds)
+      end
+
+    end
+  end
+end

data/lib/timex/configuration.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "monitor"
+require_relative "on_timeout"
+
+module TIMEx
+
+  # Mutable process-wide defaults for {TIMEx.deadline}, propagation, telemetry, and
+  # clock selection.
+  #
+  # Read through {TIMEx.configuration}; updates should go through {TIMEx.configure}
+  # so in-flight callers never observe a half-mutated instance.
+  #
+  # @see TIMEx.configure
+  # @see TIMEx.configuration
+  class Configuration
+
+    attr_reader :default_strategy, :default_on_timeout, :auto_check_default,
+      :auto_check_interval, :telemetry_adapter, :clock, :skew_tolerance_ms
+
+    # Builds defaults aligned with conservative production behavior.
+    #
+    # @return [void]
+    def initialize
+      @default_strategy = :cooperative
+      @default_on_timeout = :raise
+      @auto_check_default = false
+      @auto_check_interval = 1000
+      @telemetry_adapter = nil
+      @clock = nil
+      @skew_tolerance_ms = Deadline::DEFAULT_SKEW_TOLERANCE_MS
+    end
+
+    # @param value [Symbol, #call] registered strategy key or callable strategy
+    # @return [Symbol, #call] the assigned strategy
+    # @raise [ConfigurationError] when +value+ is neither a Symbol nor callable
+    def default_strategy=(value)
+      raise ConfigurationError, "default_strategy must be a Symbol or strategy class" unless value.is_a?(Symbol) || value.respond_to?(:call)
+
+      @default_strategy = value
+    end
+
+    # @param value [Symbol, Proc] one of {ON_TIMEOUT_SYMBOLS} or a custom Proc
+    # @return [Symbol, Proc] the assigned handler
+    # @raise [ConfigurationError] when +value+ is not allowed
+    def default_on_timeout=(value)
+      unless ON_TIMEOUT_SYMBOLS.include?(value) || value.is_a?(Proc)
+        raise ConfigurationError,
+          "default_on_timeout must be one of #{ON_TIMEOUT_SYMBOLS.inspect} or a Proc"
+      end
+
+      @default_on_timeout = value
+    end
+
+    # @param value [Boolean]
+    # @return [Boolean]
+    # @raise [ConfigurationError] when not strictly +true+ or +false+
+    def auto_check_default=(value)
+      raise ConfigurationError, "auto_check_default must be true or false" unless [true, false].include?(value)
+
+      @auto_check_default = value
+    end
+
+    # @param value [Integer] milliseconds between automatic deadline checks
+    # @return [Integer]
+    # @raise [ConfigurationError] when not a positive Integer
+    def auto_check_interval=(value)
+      raise ConfigurationError, "auto_check_interval must be a positive Integer" unless value.is_a?(Integer) && value.positive?
+
+      @auto_check_interval = value
+    end
+
+    # @param value [#emit, nil] adapter object or +nil+ to fall back to global default
+    # @return [#emit, nil]
+    # @raise [ConfigurationError] when non-+nil+ and missing +#emit+
+    def telemetry_adapter=(value)
+      raise ConfigurationError, "telemetry_adapter must respond to :emit" if value && !value.respond_to?(:emit)
+
+      @telemetry_adapter = value
+    end
+
+    # @param value [nil, #monotonic_ns, #wall_ns] process-wide clock override
+    # @return [nil, Object]
+    # @raise [ConfigurationError] when non-+nil+ and missing required methods
+    def clock=(value)
+      ok = value.nil? || (value.respond_to?(:monotonic_ns) && value.respond_to?(:wall_ns))
+      raise ConfigurationError, "clock must respond to :monotonic_ns and :wall_ns" unless ok
+
+      @clock = value
+    end
+
+    # @param value [Numeric] wall skew tolerance used when parsing propagated deadlines
+    # @return [Numeric]
+    # @raise [ConfigurationError] when negative or non-numeric
+    def skew_tolerance_ms=(value)
+      raise ConfigurationError, "skew_tolerance_ms must be a non-negative Numeric" unless value.is_a?(Numeric) && !value.negative?
+
+      @skew_tolerance_ms = value
+    end
+
+    # Duplicates mutable Array/Hash fields after +dup+ so nested configuration
+    # cannot leak mutations across snapshots.
+    #
+    # @note Current fields are primitives; this is defensive for future container fields.
+    #
+    # @return [void]
+    def initialize_copy(source)
+      super
+      instance_variables.each do |iv|
+        val = instance_variable_get(iv)
+        instance_variable_set(iv, val.dup) if val.is_a?(Array) || val.is_a?(Hash)
+      end
+    end
+
+  end
+
+  class << self
+
+    CONFIG_MUTEX = Monitor.new
+    private_constant :CONFIG_MUTEX
+
+    # Returns the process-wide {Configuration}, constructing it once under +CONFIG_MUTEX+.
+    #
+    # @return [Configuration]
+    def configuration
+      @configuration || CONFIG_MUTEX.synchronize { @configuration ||= Configuration.new }
+    end
+    alias config configuration
+
+    # Yields a duplicated {Configuration}, then atomically publishes it when the
+    # outermost block completes without raising.
+    #
+    # Nested +configure+ calls mutate the same draft and only the outermost swap
+    # commits, keeping re-entrant initialization safe.
+    #
+    # @yieldparam draft [Configuration] mutable copy to adjust
+    # @return [Object] the block's return value
+    # @raise [ArgumentError] when no block is given
+    def configure
+      raise ArgumentError, "TIMEx.configure requires a block" unless block_given?
+
+      CONFIG_MUTEX.synchronize do
+        outer = @configure_draft.nil?
+        @configure_draft ||= configuration.dup
+        begin
+          yield @configure_draft
+          @configuration = @configure_draft if outer
+        ensure
+          @configure_draft = nil if outer
+        end
+      end
+    end
+
+    # Replaces the configuration with a fresh {Configuration} under the mutex.
+    #
+    # @return [void]
+    def reset_configuration!
+      CONFIG_MUTEX.synchronize { @configuration = Configuration.new }
+    end
+
+  end
+
+end