ajdc 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d574c616f461f12c106a6aae83b1e4d661f0ef2379c37683e6568cc20fde3bfb
-  data.tar.gz: 84dbb9b64741a0eab088b90cd25ec2ceb81ef0677ec28a7d978f76d2924e029d
+  metadata.gz: 457acb0e1d1bf39fedf55009435838bdb2c571d23f84b2267824305182966dac
+  data.tar.gz: 27a48e7abba53b5dff2174a9ecc8e4f76cf545d3fabcfbf1a1e1c1e046e8bcec
 SHA512:
-  metadata.gz: f945272b9c66c101d06a62fb0c422129ed9e96fa7d764ca1b54d638f0cedc6f498181fddedd225312831d2d618734c85c534708eaa35e111cac8d39c26c39148
-  data.tar.gz: 96692790799a6196a3d4cadda92ed737d77655236cad1aef4f5a4134bc3fe65e224bf8b64abec5c1c224bb6ca9806f07b95e360ff229cea03b9306f9708982d1
+  metadata.gz: f2efc59677a4fa9057e0bab2d4f08a224750574ecd001717ced02d414a87c8b04f8424e1747c07eff032acf8b3e6828222ba26e768f9d0a250c287bcf9fe571f
+  data.tar.gz: c8a7314a4c38ac7cb0b9d2414b6da85b6eb1963047701d8bc19cd8911fc620709ca1c7d253891de2f45d21d00e83c743af3e6f909df9df620d9a19b18ee76e23

data/CHANGELOG.md

@@ -1,3 +1,7 @@
 # Change log
 
 ## master
+
+## 0.1.0
+
+- Initial _Rails World_ release.

data/README.md

@@ -1,37 +1,404 @@
 [![Gem Version](https://badge.fury.io/rb/ajdc.svg)](https://rubygems.org/gems/ajdc)
 [![Build](https://github.com/palkan/ajdc/workflows/Build/badge.svg)](https://github.com/palkan/ajdc/actions)
 
-# AJDC: Active Job Durable Continuation
+# AJ/DC: Active Job Durable Continuation
 
-TBD
+<img align="right" height="150" width="292"
+     title="AJ/DC logo" src="./assets/logo.png">
+
+AJ/DC makes an `ActiveJob::Continuable` job's run and steps durable: they're recorded in the database, not only in the job payload, so progress survives a crash, not only a graceful restart.
 
 ## Installation
 
-Adding to a gem:
+Add to your project's Gemfile:
 
 ```ruby
-# my-cool-gem.gemspec
-Gem::Specification.new do |spec|
+# Gemfile
+gem "ajdc"
+```
+
+or run `bundle add ajdc`.
+
+### Addinng agent skills
+
+The gem ships a skill for coding agents in `skills/ajdc`. It follows the [skills.sh](https://www.skills.sh) layout, so it works with any agent that reads `SKILL.md`.
+
+With [Rails Hyperdrive](https://github.com/rails-hyperdrive/rails-hyperdrive) it installs itself: `bin/rails hyperdrive:init` the first time, then `bundle add ajdc` or `bin/rails hyperdrive:sync` lands it in `.claude/skills/ajdc`.
+
+Without it, install straight from the repository with the [skills.sh](https://www.skills.sh) CLI, or copy `skills/ajdc` into your agent's skills directory:
+
+```sh
+npx skills add palkan/ajdc
+```
+
+Now, you can ask your agent to continue the installation or do it yourself.
+
+### Preparing the database
+
+AJ/DC keeps its data in two tables (`active_job_durable_runs`, `active_job_durable_steps`). Generate the migration and run it:
+
+```sh
+bin/rails generate ajdc:install
+bin/rails db:migrate
+```
+
+To keep the tables in a separate database (the Solid Queue way), declare it in `config/database.yml` with its own `migrations_paths`, then pass its name; the migration lands in that path and an initializer points AJ/DC at the database:
+
+```sh
+bin/rails generate ajdc:install --database=durable
+bin/rails db:prepare
+```
+
+```ruby
+# config/initializers/active_job_durable.rb (generated)
+Rails.application.config.active_job_durable.connects_to = { database: { writing: :durable } }
+```
+
+### Requirements
+
+- Ruby (MRI) >= 3.3
+- Rails >= 8.1 (`ActiveJob::Attributes` needs Rails 8.2)
+- SQLite / PostgreSQL / MySQL
+
+## Usage
+
+Include `ActiveJob::Durable` instead of `ActiveJob::Continuable`. `step`, cursors and `attribute` keep working exactly as they do today:
+
+```ruby
+# before
+class ImportJob < ApplicationJob
+  include ActiveJob::Continuable
+
+  attribute :processed_count, :integer, default: 0
+
+  def perform(import)
+    step :validate
+    step :process do |step|
+      import.records.find_each(start: step.cursor) do |record|
+        record.process!
+        self.processed_count += 1
+        step.advance! from: record.id
+      end
+    end
+  end
+end
+```
+
+```ruby
+# after
+class ImportJob < ApplicationJob
+  include ActiveJob::Durable
+
+  attribute :processed_count, :integer, default: 0
+
+  def perform(import)
+    step :validate
+    step :process do |step|
+      import.records.find_each(start: step.cursor) do |record|
+        record.process!
+        self.processed_count += 1
+        step.advance! from: record.id
+      end
+    end
+  end
+end
+```
+
+Every checkpoint commits the run and the current step's cursor to the database, so a `SIGKILL` loses at most the work since the last checkpoint.
+
+The run and its steps are plain Active Record models:
+
+```ruby
+run = ActiveJob::Durable::Run.last
+run.status           # => "completed"
+run.current_step     # => nil
+run.completed_steps  # => ["validate", "process"]
+run.state            # => {"processed_count" => 128}
+run.steps.map(&:name) # => ["validate", "process"]
+```
+
+### Uniqueness
+
+Durable state allows you to enforce wofkflow runs uniqueness. For that, use the `unique_by` macro in the workflow and specify the `perform` parameters that identify a run. Uniqueness is only enforced for runs that hasn't been terminated: either _live_ runs (with "enqueued", "running", "waiting", "awaiting" status) or _paused_ runs ("failed" or "halted"). Here is an example:
+
+```ruby
+class ImportJob < ApplicationJob
+  include ActiveJob::Durable
+
+  unique_by :import
+
+  def perform(import)
+    step :check
+    step :process
+  end
+end
+
+ImportJob.perform_later(import)   # => the job
+ImportJob.perform_later(import)   # => false, nothing enqueued
+```
+
+You can provide and option `on_conflict` parameter to specify what to do in case of the uniqueness conflict:
+
+- `:skip` (default) enqueues nothing; `perform_later` returns `false`.
+- `:reject` raises `ActiveJob::Durable::RunAlreadyExists` (the currnent run is available as `error.run`).
+- `:replace` cancels the current run and starts the new one. A renewal or a reschedule is `perform_later` again:
+
+```ruby
+class License::LifecycleJob < ApplicationJob
+  include ActiveJob::Durable
+
+  unique_by :license, on_conflict: :replace
   # ...
-  spec.add_dependency "ajdc"
+end
+```
+
+### Reading runs
+
+A job class knows its runs, newest first. `workflow_runs` is an Active Record relation, so the scopes below chain onto it:
+
+```ruby
+ImportJob.workflow_runs
+ImportJob.workflow_runs.failed.at_step(:process)
+```
+
+`for` finds the runs `perform_later` would have created with the same arguments; it derives the key the same way. `for(workflow_key:)` matches a key verbatim:
+
+```ruby
+ImportJob.workflow_runs.for(import)                       # same key as ImportJob.perform_later(import)
+ImportJob.workflow_runs.for(workflow_key: "imports/42")
+ImportJob.workflow_runs.for(import).live.first            # the run in progress, or nil
+```
+
+Without a declaration, every argument is part of the key: positional arguments in order, then keywords sorted by name as `name=value`. A record renders as `collection/id`; a value that is not a string, symbol, number or boolean becomes a short digest:
+
+```ruby
+ImportJob.perform_later(import, "csv", strict: true)      # key "imports/42:csv:strict=true"
+```
+
+`identified_by` narrows the key to the named `perform` parameters, positional or keyword:
+
+```ruby
+class ImportJob < ApplicationJob
+  include ActiveJob::Durable
+
+  identified_by :import   # key "imports/42", whatever the other arguments
+
+  def perform(import, format = "csv", strict: false)
+    # ...
+  end
+end
+```
+
+The block form receives the `perform` arguments and returns one component or an array of them:
+
+```ruby
+identified_by { |import, **kwargs| [import, kwargs.fetch(:format, "csv")] }   # key "imports/42:csv"
+```
+
+A name that is not a `perform` parameter raises `ArgumentError`: at the declaration when the class already defines `perform`, otherwise at the first `perform_later`.
+
+`set(workflow_key:)` names one run's key verbatim, whatever the class derives. It is an enqueue option like `wait:` or `queue:`, so it works with `perform_later`, `perform_now` and `perform_all_later`:
+
+```ruby
+ImportJob.set(workflow_key: "imports/42/retry-3", queue: "low").perform_later(import)
+ImportJob.workflow_runs.for(workflow_key: "imports/42/retry-3")
+```
+
+Other usefule scopes:
+
+```ruby
+MyJob.workflow_runs.live  # enqueued, running, waiting, awaiting
+MyJob.workflow_runs.at_step(:process)
+MyJob.workflow_runs.stuck_for(1.hour)
+MyJob.workflow_runs.newest_first
+```
+
+A run's `status` says where the job is. `enqueued`: the job is in the queue, written at the first enqueue and at every re-enqueue (an isolated step, a graceful-stop interrupt, a resume after an error, a `retry_on` retry). `running`: a worker is executing it. `started_at` is set once, at the first execution, so an `enqueued` run with no `started_at` never ran. `stuck_for` reads `enqueued` runs by `transitioned_at` and `running` runs by `last_heartbeat_at`.
+
+### Halting
+
+Halting allows you to pause the execution on an error that could be resolved by a human (or alike), so the run could be restarted later from the current step/cursor (e.g., a plan out of storage, a file to fix by hand). Use `halt_on` or `halt!` to stop the run but keep it resumeable (unlike `discard_on`):
+
+```ruby
+class ImportJob < ApplicationJob
+  include ActiveJob::Durable
+
+  discard_on ZipFile::InvalidFileError
+  halt_on InsufficientStorageSpaceError
+
+  def perform(import)
+    step :check
+    step :process
+  end
+end
+```
+
+The run's status is `halted`; `error_class` and `error_message` hold the error, `current_step` names the step and its row keeps the cursor.
+
+`halt!(reason)` does the same from inside a step, without an error; the reason lands in `halt_reason`:
+
+```ruby
+step :run do |step|
+  until chat.complete?
+    chat.step
+    halt!(:tool_approval) if chat.awaiting_approval?
+    step.checkpoint!
+  end
+end
+```
+
+```ruby
+ImportJob.workflow_runs.halted.first.halt_reason  # => "tool_approval"
+```
+
+A halted (or failed) run is resumed in place: `resume!` puts the job back in the queue, the step that stopped re-runs from its cursor as a new attempt, and the earlier attempts keep their errors. Any other status raises `ActiveJob::Durable::NotResumable`.
+
+```ruby
+ImportJob.workflow_runs.halted.first.resume!
+```
+
+### Cancelling
+
+`cancel!` ends a run that is not terminal: the row becomes `cancelled` and the queue is left alone. A queued job for a cancelled run performs nothing; a running job stops at its next checkpoint or step boundary, and the open step row is `cancelled` with its cursor. A terminal run raises `ActiveJob::Durable::NotCancellable`.
+
+```ruby
+ImportJob.workflow_runs.for(import).live.sole.cancel!
+```
+
+### Step callbacks
+
+`before_step`, `after_step` and `around_step` are Active Job callbacks, like `before_perform` and friends, for every step that runs; a step skipped on resume triggers none. `after_step` runs only when the step completes. `current_step` is the running `ActiveJob::Continuation::Step`:
+
+```ruby
+class Cable::DiagnosticJob < ApplicationJob
+  include ActiveJob::Durable
+
+  after_step :broadcast_update
+  around_step { |job, block| Rails.logger.tagged(job.current_step.name, &block) }
+
+  def perform(cable)
+    @cable = cable
+    step :provider_status, isolated: true
+    step :websocket_status, isolated: true
+    step :admin_api_status, isolated: true
+  end
+
+  private
+    def broadcast_update
+      @cable.broadcast_replace(partial: "cables/diagnostic", locals: { step: current_step.name })
+    end
+end
+```
+
+### Timers
+
+A workflow run can _go to sleep_ (=pause) and _wake up_ (=resume) eaither at specific time (`wait_until`) or after a given time interval passed (`wait`). Example:
+
+```ruby
+class License::LifecycleJob < ApplicationJob
+  include ActiveJob::Durable
+
+  unique_by :license, on_conflict: :replace
+
+  def perform(license)
+    step :remind, wait_until: license.expires_at - 2.weeks
+    step :expire, wait_until: license.expires_at
+    step :revoke, wait: 2.weeks
+  end
+
   # ...
 end
 ```
 
-Or adding to your project:
+When the workflow reaches the waiting step, it's status is changed to `waiting`, and it's no longer present in the job queue. To wake sleeping workflows up, you need to run a single recurring job, `ActiveJob::Durable::WakeJob`. For example, with Solid Queue:
+
+```yaml
+# config/recurring.yml
+durable_wake:
+  class: ActiveJob::Durable::WakeJob
+  schedule: every minute
+```
+
+The job is one call to `ActiveJob::Durable.wake_up_due`, which wakes every due run once and returns how many. In tests, call it yourself inside `travel_to`:
 
 ```ruby
-# Gemfile
-gem "ajdc"
+travel_to license.expires_at - 2.weeks do
+  perform_enqueued_jobs { ActiveJob::Durable.wake_up_due }
+end
 ```
 
-### Supported Ruby versions
+You can also wake up a single workflow manually by using the `#wake_up` method:
 
-- Ruby (MRI) >= 3.3
+```ruby
+License::LifecycleJob.workflow_runs.for(license).waiting.sole.wake_up   # send the reminder now
+```
 
-## Usage
+### Signals
+
+The durable job can sleep indifinitely waiting for an external signal to wake it up. For that, you can use the `#await` method. It defines a step with no body but a _signal handler_ instead:
+
+```ruby
+class BulkImportJob < ApplicationJob
+  include ActiveJob::Durable
+
+  attribute :confirmed, :boolean, default: false
+
+  def perform(import)
+    await :confirmation, wait: 10.minutes
+    return import.destroy! unless confirmed
+
+    step :apply do
+      BulkImportService.new.call(import)
+    end
+  end
+
+  private
+    def confirmation(signal) = self.confirmed = signal.presence
+end
+```
+
+Then, you can use the `#wake_up` method to send a signal to the job:
+
+```ruby
+# from the controller
+BulkImportJob.workflow_runs.for(import).live.sole.wake_up(:confirmation, true)
+```
+
+A signal sent before the `await` line is stored in the durable state and is replayed as soon as the job reaches this step. So, you can have multiple awaiting steps receiving signals in any order. A second signal for the same name overwrites the first.
+
+If no signal received and the deadline is specified (`wait:`, `wait_until:`), the signal handler is called with the `nil` signal, so you can decide on how to continue.
+
+You can find all the jobs waiting for a particular signal using the corresponding scope:
+
+```ruby
+CardGenerationJob.workflow_runs.awaiting.at_step(:review)
+```
+
+### Housekeeping
+
+Terminal runs (`completed`, `discarded`, `cancelled`) and their steps are kept for 14 days after they end. To delete the older ones, schedule `ActiveJob::Durable::HousekeepingJob`, e.g., with Solid Queue:
+
+```yaml
+# config/recurring.yml
+durable_housekeeping:
+  class: ActiveJob::Durable::HousekeepingJob
+  schedule: every hour
+```
+
+Configure the retention period (`nil` keeps runs forever):
+
+```ruby
+# config/application.rb
+config.active_job_durable.keep_terminal_runs_for = 30.days
+```
+
+Runs that need attention (`failed`, `halted`) are never deleted. Stuck runs are left to the application: `stuck_for` finds `enqueued` runs whose message never arrived, `running` runs whose worker died (no heartbeat), and parked runs the clock missed, and `cancel!` ends any of them:
+
+```ruby
+ActiveJob::Durable::Run.stuck_for(1.hour).running.find_each(&:cancel!)
+```
 
-TBD
+A heartbeat is written at every step boundary and checkpoint, so pick a duration longer than the longest stretch of a step without a checkpoint.
 
 ## Contributing
 

data/db/durable_schema.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Tables for ActiveJob::Durable: one row per run, one row per step attempt.
+#
+# JSON columns hold Active Job-serialized values (ActiveJob::Arguments.serialize),
+# nothing in them is indexed. They carry no database defaults so that the same
+# file loads on SQLite, PostgreSQL and MySQL; the models set the defaults.
+ActiveRecord::Schema[8.1].define(version: 1) do
+  create_table "active_job_durable_runs", if_not_exists: true do |t|
+    t.string "job_class", null: false
+    t.string "key", null: false
+    t.string "active_key"
+    t.string "active_job_id", null: false
+    t.json "arguments", null: false
+    t.string "status", null: false
+    t.string "current_step"
+    t.json "completed_steps", null: false
+    t.json "state", null: false
+    t.datetime "wake_at"
+    t.json "pending_signals", null: false
+    t.json "parked_job"
+    t.integer "resumptions", default: 0, null: false
+    t.datetime "last_heartbeat_at"
+    t.string "error_class"
+    t.text "error_message"
+    t.string "halt_reason"
+    t.datetime "started_at"
+    t.datetime "finished_at"
+    t.datetime "transitioned_at"
+    t.timestamps
+
+    t.index ["job_class", "active_key"], name: "index_active_job_durable_runs_on_active_key", unique: true
+    t.index ["job_class", "key"], name: "index_active_job_durable_runs_on_key"
+    t.index ["active_job_id"], name: "index_active_job_durable_runs_on_active_job_id", unique: true
+    t.index ["status"], name: "index_active_job_durable_runs_on_status"
+    t.index ["status", "wake_at"], name: "index_active_job_durable_runs_on_status_and_wake_at"
+    t.index ["status", "transitioned_at"], name: "index_active_job_durable_runs_on_status_and_transitioned_at"
+  end
+
+  create_table "active_job_durable_steps", if_not_exists: true do |t|
+    t.references "run", null: false, index: false,
+      foreign_key: {to_table: "active_job_durable_runs", on_delete: :cascade}
+    t.string "name", null: false
+    t.integer "position", null: false
+    t.integer "attempt", default: 1, null: false
+    t.string "status", null: false
+    t.json "cursor"
+    t.boolean "isolated", default: false, null: false
+    t.string "error_class"
+    t.text "error_message"
+    t.datetime "started_at"
+    t.datetime "finished_at"
+
+    t.index ["run_id", "name", "attempt"], name: "index_active_job_durable_steps_on_attempt", unique: true
+    t.index ["run_id", "position"], name: "index_active_job_durable_steps_on_position"
+  end
+end

data/lib/active_job/continuable/callbacks.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_job/continuable/configurable"
+require "active_job/continuation/callbacks"
+
+module ActiveJob
+  module Continuable
+    # = Step callbacks
+    #
+    # Callbacks around every step that runs (a step skipped on resume runs none),
+    # with the semantics of `before_perform` and friends; the step is `current_step`.
+    # `after_step` runs only when the step completes.
+    #
+    #   class ProcessImportJob < ApplicationJob
+    #     include ActiveJob::Continuable::Callbacks
+    #
+    #     around_step :measure
+    #     after_step { logger.info "#{current_step.name} done" }
+    #   end
+    module Callbacks
+      extend ActiveSupport::Concern
+      include Configurable
+
+      included do
+        define_callbacks :step, skip_after_callbacks_if_terminated: true
+
+        unless continuation_class <= Continuation::Callbacks
+          self.continuation_class = Class.new(continuation_class) do
+            prepend Continuation::Callbacks
+
+            set_temporary_name "#{superclass.name}(WithCallbacks)"
+          end
+        end
+      end
+
+      class_methods do
+        def before_step(*filters, &blk) = set_callback(:step, :before, *filters, &blk)
+
+        def after_step(*filters, &blk) = set_callback(:step, :after, *filters, &blk)
+
+        def around_step(*filters, &blk) = set_callback(:step, :around, *filters, &blk)
+      end
+
+      # The `ActiveJob::Continuation::Step` that is running, `nil` between steps.
+      def current_step = continuation.running_step
+    end
+  end
+end

data/lib/active_job/continuable/configurable.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "active_job/continuable"
+
+module ActiveJob
+  module Continuable
+    # = Configurable continuation
+    #
+    # Continuable with a pluggable continuation class, which receives any extra
+    # `step` options along with `start:` and `isolated:`:
+    #
+    #   class TimedJob < ApplicationJob
+    #     include ActiveJob::Continuable::Configurable
+    #
+    #     self.continuation_class = TimedContinuation
+    #
+    #     def perform
+    #       step :remind, wait: 2.weeks # TimedContinuation#run_step(:remind, start: nil, isolated: false, wait: 2.weeks)
+    #     end
+    #   end
+    module Configurable
+      extend ActiveSupport::Concern
+      include ActiveJob::Continuable
+
+      # Continuable defines its constructor on the including class, so this one
+      # is prepended to the class to run after it.
+      module Initializer # :nodoc:
+        def initialize(...)
+          super
+          self.continuation = continuation_class.new(self, {})
+        end
+      end
+
+      included do
+        class_attribute :continuation_class, instance_writer: false, default: ActiveJob::Continuation
+
+        prepend Initializer
+      end
+
+      def step(step_name, start: nil, isolated: false, **options, &block)
+        block ||= step_method_block(step_name)
+        checkpoint! if continuation.advanced?
+        continuation.step(step_name, start:, isolated:, **options, &block)
+      end
+
+      if Continuable.private_method_defined?(:continuation_serialized?) # Rails 8.2+
+        private def deserialize_arguments_if_needed
+          serialized, @serialized_continuation = @serialized_continuation, nil
+          super
+          self.continuation = continuation_class.new(self, serialized) if serialized
+        end
+      else
+        def deserialize(job_data) # :nodoc:
+          super
+          self.continuation = continuation_class.new(self, job_data.fetch("continuation", {}))
+        end
+      end
+
+      private
+
+      # The method named after the step, as a step block.
+      def step_method_block(step_name)
+        step_method = method(step_name)
+
+        raise ArgumentError, "Step method '#{step_name}' must accept 0 or 1 arguments" if step_method.arity > 1
+
+        if step_method.parameters.any? { |type, _name| type == :key || type == :keyreq }
+          raise ArgumentError, "Step method '#{step_name}' must not accept keyword arguments"
+        end
+
+        (step_method.arity == 0) ? ->(_step) { step_method.call } : step_method
+      end
+    end
+  end
+end

data/lib/active_job/continuation/callbacks.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "active_job/continuation"
+
+module ActiveJob
+  class Continuation
+    # Runs the job's step callbacks around each step's body. Prepended to the
+    # job's `continuation_class` by `ActiveJob::Continuable::Callbacks`.
+    module Callbacks
+      # The step that is running, `nil` between steps.
+      def running_step = (current if running_step?)
+
+      private
+
+      def instrumenting_step(step, &block) = super { job.run_callbacks(:step, &block) }
+    end
+  end
+end

data/lib/active_job/continuation/rescue_handlers_first.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_job/continuation"
+
+module ActiveJob
+  class Continuation
+    # = Rescue handlers first
+    #
+    # Continuable's `continue` rescues any `StandardError` raised after the job made
+    # progress and resumes the job, so `discard_on`, `retry_on` and `rescue_from`
+    # never see it. Prepended to `ActiveJob::Continuable`, this module gives the
+    # job's own handlers precedence: when a handler exists for the error,
+    # `resume_job` re-raises it, and `perform_now` runs the handler as it would
+    # for any other job. Errors without a handler are resumed as before, and a
+    # `Continuation::Interrupt` is never an error.
+    module RescueHandlersFirst
+      private
+
+      # Rails 8.1 passes the error-resume exception as `{exception: e}`; main
+      # passes it positionally. The argument goes to `super` unchanged.
+      def resume_job(exception)
+        error = exception.is_a?(Hash) ? exception[:exception] : exception
+        raise error if !error.is_a?(Continuation::Interrupt) && handler_for_rescue(error)
+
+        super
+      end
+    end
+  end
+end