active_durable 0.5.0

data/lib/active_durable/open_telemetry.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "opentelemetry"
+require "active_durable"
+
+module ActiveDurable
+  # Traces executions, steps, compensations and undos as OpenTelemetry spans.
+  #
+  #   # config/initializers/active_durable.rb
+  #   require "active_durable/open_telemetry"
+  #   ActiveDurable::OpenTelemetry.install!
+  #
+  # Spans nest: a worker run ("active_durable.execution checkout") contains its steps, and flow.parallel
+  # branches stay under it even though they run in other threads. Failed steps record the exception.
+  module OpenTelemetry
+    EVENTS = %w[execution step compensation undo].freeze
+
+    class << self
+      def install!(tracer_provider: ::OpenTelemetry.tracer_provider)
+        uninstall!
+        subscriber = Subscriber.new(tracer_provider.tracer("active_durable", ActiveDurable::VERSION))
+        @subscriptions = EVENTS.map { |event| ActiveSupport::Notifications.subscribe("#{event}.active_durable", subscriber) }
+        unless ActiveDurable.branch_wrappers.include?(ContextPropagation)
+          ActiveDurable.branch_wrappers << ContextPropagation
+        end
+        self
+      end
+
+      def uninstall!
+        Array(@subscriptions).each { |subscription| ActiveSupport::Notifications.unsubscribe(subscription) }
+        @subscriptions = nil
+        ActiveDurable.branch_wrappers.delete(ContextPropagation)
+      end
+    end
+
+    # Starts a span when an event starts and ends it when the event finishes, so spans nest naturally.
+    class Subscriber
+      def initialize(tracer)
+        @tracer = tracer
+      end
+
+      def start(name, _id, payload)
+        span = @tracer.start_span(span_name(name, payload), attributes: attributes(payload), kind: :internal)
+        token = ::OpenTelemetry::Context.attach(::OpenTelemetry::Trace.context_with_span(span))
+        stack.push([span, token])
+      end
+
+      def finish(_name, _id, payload)
+        span, token = stack.pop
+        return unless span
+
+        error = payload[:exception_object]
+        if error && !error.is_a?(ActiveDurable::ControlFlow)
+          span.record_exception(error)
+          span.status = ::OpenTelemetry::Trace::Status.error(error.message)
+        end
+        span.finish
+        ::OpenTelemetry::Context.detach(token)
+      end
+
+      private
+
+      def stack
+        Thread.current[:active_durable_otel_spans] ||= []
+      end
+
+      def span_name(event, payload)
+        kind = event.delete_suffix(".active_durable")
+        target = payload[:step] || payload[:recipe]
+        target ? "active_durable.#{kind} #{target}" : "active_durable.#{kind}"
+      end
+
+      def attributes(payload)
+        {
+          "active_durable.execution_id" => payload[:execution_id],
+          "active_durable.recipe" => payload[:recipe],
+          "active_durable.step" => payload[:step],
+          "active_durable.step_kind" => payload[:kind]
+        }.compact.transform_values(&:to_s)
+      end
+    end
+
+    # Carries the current span into flow.parallel branch threads.
+    module ContextPropagation
+      def self.capture
+        ::OpenTelemetry::Context.current
+      end
+
+      def self.wrap(context, &)
+        ::OpenTelemetry::Context.with_current(context, &)
+      end
+    end
+  end
+end

data/lib/active_durable/operations.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # What a person can do with an execution: from the console, a script or the dashboard.
+  #
+  #   ActiveDurable.retry("checkout-7")                 # blocked: try again where it stopped
+  #   ActiveDurable.compensate("checkout-7", reason: "") # undo everything (only before the pivot)
+  #   ActiveDurable.rerun("checkout-7", from: :ship)    # a new execution that reuses steps before :ship
+  #
+  # Every operation takes the execution only when no worker holds it, and rotates the lease token so a
+  # stale worker can never write again.
+  module Operations
+    module_function
+
+    # A blocked execution tries again from where it stopped: failed steps (or failed undos, if it was
+    # compensating) get a fresh set of attempts. Deploy the fix first when the cause was a bug.
+    def retry(execution_id)
+      execution = with_idle_execution(execution_id, allowed: %w[blocked]) do |record|
+        failed = record.steps.where(status: "failed")
+        failed = record.compensating ? failed.where(kind: "undo") : failed.where.not(kind: "undo")
+        failed.update_all(status: "retrying", attempts: 0, wake_at: nil, updated_at: ActiveDurable.now)
+        reopen!(record, error: nil)
+      end
+      ActiveDurable.instrument("retried", execution_id: execution.id)
+      execution
+    end
+
+    # Undoes every completed step, last one first. Not possible once the point of no return was passed.
+    def compensate(execution_id, reason: "compensated by an operator")
+      execution = with_idle_execution(execution_id, allowed: %w[blocked pending running sleeping waiting]) do |record|
+        raise Error, "#{record.id} is already compensating; use ActiveDurable.retry to resume it" if record.compensating
+        if record.steps.exists?(kind: "pivot", status: "completed")
+          raise Error, "#{record.id} already passed its point of no return; it can only move forward"
+        end
+
+        error = { "class" => "ActiveDurable::ManualCompensation", "message" => reason,
+                  "at" => ActiveDurable.now.utc.iso8601(6) }
+        reopen!(record, compensating: true, error: error)
+      end
+      ActiveDurable.instrument("compensation_requested", execution_id: execution.id, reason: reason)
+      execution
+    end
+
+    # Starts a new execution with the same input that reuses every completed step before `from`.
+    # Steps from `from` on run again with new tickets, so they have effects again: that is the point.
+    # A blocked original is marked superseded, so it can never compensate the steps they now share.
+    def rerun(execution_id, from:)
+      from = from.to_s
+      execution = nil
+      Record.transaction do
+        original = Execution.lock.find(execution_id)
+        check_rerunnable!(original)
+        start = original.steps.where.not(kind: "undo").find_by(name: from)
+        raise Error, "#{original.id} has no step :#{from} in its notebook" unless start
+
+        execution = Execution.create!(id: rerun_id(original), recipe: original.recipe,
+                                      recipe_version: original.recipe_version, input: original.input,
+                                      status: "pending", forked_from: original.id)
+        copy_steps(original, execution, before: start.position)
+        original.update_columns(status: "superseded", updated_at: ActiveDurable.now) if original.status == "blocked"
+      end
+      ActiveDurable.instrument("rerun", execution_id: execution.id, forked_from: execution.forked_from, from: from)
+      execution
+    end
+
+    def with_idle_execution(execution_id, allowed:)
+      execution = Record.transaction do
+        record = Execution.lock.find(execution_id)
+        unless allowed.include?(record.status)
+          raise Error, "#{record.id} is #{record.status}; this works on #{allowed.join(", ")} executions"
+        end
+        if record.locked_until && record.locked_until > ActiveDurable.now
+          raise Error, "#{record.id} is running right now; try again in a moment"
+        end
+
+        yield record
+        record
+      end
+      ActiveDurable.enqueue(execution.id)
+      execution
+    end
+
+    def reopen!(record, **attributes)
+      record.update_columns(status: "pending", wake_at: nil, locked_until: nil, lease_token: SecureRandom.uuid,
+                            updated_at: ActiveDurable.now, **attributes)
+    end
+
+    def check_rerunnable!(original)
+      return if original.status == "completed"
+      return if original.status == "blocked" && !original.compensating
+
+      raise Error, "#{original.id} is #{original.status}#{" and compensating" if original.compensating}; " \
+                   "only completed executions, or blocked ones that are not compensating, can be rerun"
+    end
+
+    def rerun_id(original)
+      root = original.id.sub(/~rerun-\d+\z/, "")
+      count = Execution.where("id LIKE ?", "#{Execution.sanitize_sql_like(root)}~rerun-%").count
+      "#{root}~rerun-#{count + 1}"
+    end
+
+    def copy_steps(original, execution, before:)
+      now = ActiveDurable.now
+      rows = original.steps.where.not(kind: "undo").where(status: "completed").where(position: ...before).map do |step|
+        { execution_id: execution.id, name: step.name, kind: step.kind, position: step.position,
+          status: "completed", attempts: step.attempts, result: step.result, created_at: now, updated_at: now }
+      end
+      Step.insert_all!(rows) if rows.any?
+    end
+  end
+end

data/lib/active_durable/parallel.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # Collects the branches of a flow.parallel block. Nothing runs while the block is read:
+  # the branches run afterwards, each in its own thread.
+  #
+  #   results = flow.parallel(:reserve) do |branches|
+  #     warehouses.each do |warehouse|
+  #       branches.step(warehouse.code, undo: ->(r) { warehouse.release(r["id"]) }) do |ticket|
+  #         warehouse.reserve(ticket)
+  #       end
+  #     end
+  #   end
+  #   results # => { "MEX" => {...}, "GDL" => {...} }
+  class ParallelGroup
+    Branch = Struct.new(:name, :full_name, :kind, :undo, :options, :block)
+    OPTIONS = %i[retry undo_on_failure].freeze
+
+    attr_reader :branches
+
+    def initialize(parallel_name)
+      @parallel_name = parallel_name
+      @branches = []
+    end
+
+    def step(name, undo: nil, **options, &block)
+      add(name, "step", undo, options, block)
+    end
+
+    def transaction(name, undo: nil, **options, &block)
+      add(name, "transaction", undo, options, block)
+    end
+
+    private
+
+    def add(name, kind, undo, options, block)
+      name = name.to_s
+      raise InvalidRecipe, "branch :#{name} of flow.parallel :#{@parallel_name} needs a block" unless block
+      raise InvalidRecipe, "branch names in flow.parallel :#{@parallel_name} cannot be blank" if name.empty?
+      if name.include?("/") || name.end_with?(":undo")
+        raise InvalidRecipe, "branch name #{name.inspect} cannot contain '/' or end in ':undo'"
+      end
+
+      unknown = options.keys - OPTIONS
+      raise InvalidRecipe, "unknown option(s) for a parallel branch: #{unknown.join(", ")}" if unknown.any?
+      if @branches.any? { |branch| branch.name == name }
+        raise DuplicateStepName, "flow.parallel :#{@parallel_name} declares the branch :#{name} twice"
+      end
+
+      @branches << Branch.new(name, "#{@parallel_name}/#{name}", kind, undo, options, block)
+      nil
+    end
+  end
+end

data/lib/active_durable/record.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # Base class for the gem's tables. It shares ActiveRecord::Base's connection on purpose:
+  # flow.transaction is only atomic when the notebook lives in the same database as your data.
+  class Record < ActiveRecord::Base
+    self.abstract_class = true
+
+    # A JSON type object (not the :json symbol): resolving a symbol needs a database connection,
+    # and these classes may load before the app has configured one.
+    JSON_TYPE = ActiveRecord::Type::Json.new
+  end
+end

data/lib/active_durable/registry.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # A named recipe: the block that describes the steps of a saga.
+  class Recipe
+    attr_reader :name, :version, :block
+
+    def initialize(name, version, block)
+      @name = name
+      @version = version
+      @block = block
+    end
+
+    def call(flow, input)
+      block.call(flow, **input.to_h.transform_keys(&:to_sym))
+    end
+
+    def inspect
+      "#<ActiveDurable::Recipe #{name} v#{version}>"
+    end
+  end
+
+  # Keeps every defined recipe by name and version.
+  #
+  # Recipes are looked up by name when a worker picks up an execution, possibly in a fresh process.
+  # In a Rails app, put each recipe in app/sagas/<name>_saga.rb and assign it to a constant
+  # (CheckoutSaga = Durable.define(:checkout) { ... }). The registry autoloads that constant on a miss.
+  class Registry
+    def initialize
+      @recipes = {}
+      @mutex = Mutex.new
+    end
+
+    def define(name, version: 1, &block)
+      raise ArgumentError, "Durable.define :#{name} needs a block" unless block
+
+      name = name.to_s
+      raise ArgumentError, "recipe names cannot be blank" if name.empty?
+
+      recipe = Recipe.new(name, Integer(version), block)
+      @mutex.synchronize { (@recipes[name] ||= {})[recipe.version] = recipe }
+      recipe
+    end
+
+    def latest(name)
+      versions = versions_for(name)
+      versions.empty? ? raise_unknown(name) : versions.max_by(&:version)
+    end
+
+    def fetch(name, version)
+      versions_for(name).find { |recipe| recipe.version == version.to_i } ||
+        raise(UnknownRecipe, "recipe :#{name} has no version #{version}. Keep old versions defined " \
+                             "until no execution uses them (rake active_durable:versions).")
+    end
+
+    def versions_for(name)
+      name = name.to_s
+      # Always touch the constant, even if the name is known: after a code reload in development the constant
+      # is gone, and referencing it loads the edited file, which defines the recipe again.
+      autoload_constant(name)
+      (@recipes[name] || {}).values.sort_by(&:version)
+    end
+
+    def names
+      @recipes.keys.sort
+    end
+
+    def clear!
+      @mutex.synchronize { @recipes.clear }
+    end
+
+    private
+
+    def raise_unknown(name)
+      raise UnknownRecipe, "no recipe named :#{name}. Define it with Durable.define(:#{name}) " \
+                           "in app/sagas/#{name}_saga.rb and assign it to #{constant_name(name)}."
+    end
+
+    def autoload_constant(name)
+      constant_name(name).safe_constantize
+    rescue StandardError, LoadError
+      nil
+    end
+
+    def constant_name(name)
+      "#{name.to_s.camelize}Saga"
+    end
+  end
+end

data/lib/active_durable/retry_policy.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # How many times a step is tried and how long to wait between tries.
+  #
+  #   flow.step :charge, retry: 5 { ... }
+  #   flow.step :charge, retry: { attempts: 5, backoff: [1, 10, 60] } { ... }
+  #   flow.step :charge, retry: false { ... }   # a single attempt
+  class RetryPolicy
+    attr_reader :attempts
+
+    def self.build(option, default_attempts:)
+      case option
+      when nil then new(attempts: default_attempts)
+      when false then new(attempts: 1)
+      when Integer then new(attempts: option)
+      when Hash then new(attempts: option.fetch(:attempts, default_attempts), backoff: option[:backoff])
+      when RetryPolicy then option
+      else raise ArgumentError, "retry: expects false, an Integer or a Hash, got #{option.inspect}"
+      end
+    end
+
+    def initialize(attempts:, backoff: nil)
+      @attempts = Integer(attempts)
+      raise ArgumentError, "retry attempts must be at least 1" if @attempts < 1
+
+      @backoff = backoff
+    end
+
+    # Seconds to wait after the given failed attempt (1-based).
+    def delay(attempt)
+      backoff = @backoff || ActiveDurable.config.backoff
+      seconds =
+        case backoff
+        when Proc then backoff.call(attempt)
+        when Array then backoff[attempt - 1] || backoff.last
+        else backoff
+        end
+      seconds.to_f
+    end
+  end
+end

data/lib/active_durable/run_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # Runs one execution. Duplicates are harmless: if another worker holds the lease, this one returns.
+  class RunJob < ActiveJob::Base
+    queue_as { ActiveDurable.config.queue_name }
+
+    def perform(execution_id)
+      Runner.run(execution_id)
+    end
+  end
+end

data/lib/active_durable/runner.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # Runs one execution as far as it can go: claims the lease, replays the recipe against the notebook,
+  # and ends by completing, suspending (sleep, wait, retry), compensating or blocking.
+  class Runner
+    SUSPEND = :active_durable_suspend
+
+    # Returns :completed, :compensated, :blocked, :sleeping, :waiting, :busy or :lease_lost.
+    def self.run(execution_id)
+      lease = Lease.claim(execution_id)
+      return :busy unless lease
+
+      new(Execution.find(execution_id), lease).run
+    end
+
+    attr_reader :execution, :lease, :notebook
+
+    def initialize(execution, lease)
+      @execution = execution
+      @lease = lease
+      @notebook = Notebook.new(execution, lease)
+    end
+
+    def run
+      ActiveDurable.instrument("execution", execution_id: execution.id, recipe: execution.recipe) do
+        catch(SUSPEND) { run_recipe }
+      end
+    rescue LeaseLost => e
+      ActiveDurable.config.logger.warn("[ActiveDurable] #{e.message}")
+      :lease_lost
+    end
+
+    # Releases the execution until wake_at (or until a signal arrives) and stops this run.
+    def suspend!(wake_at, status)
+      lease.release!(status: status, wake_at: wake_at)
+      ActiveDurable.enqueue(execution.id, wait_until: wake_at) if wake_at
+      # A signal may have been committed while we held the lease; its own job found us busy.
+      if status == "waiting" && SignalRecord.pending.exists?(execution_id: execution.id)
+        ActiveDurable.enqueue(execution.id)
+      end
+      throw SUSPEND, status.to_sym
+    end
+
+    private
+
+    def run_recipe
+      recipe = ActiveDurable.registry.fetch(execution.recipe, execution.recipe_version)
+      @flow = Flow.new(self, compensating: execution.compensating)
+      output = recipe.call(@flow, execution.input || {})
+      @flow.finish!
+      @flow.compensating? ? compensate! : complete!(output)
+    rescue StopForward
+      compensate!
+    rescue RecipeChanged, InvalidRecipe, NotSerializable, UnknownRecipe => e
+      block!(e)
+    rescue StandardError => e
+      fail!(e)
+    end
+
+    def fail!(error)
+      return block!(error) if @flow.nil? || @flow.pivoted?
+
+      start_compensation!(error) unless @flow.compensating?
+      compensate!
+    end
+
+    def complete!(output)
+      output = Serializer.normalize(output, "the recipe's return value")
+      lease.release!(status: "completed", output: output, wake_at: nil)
+      ActiveDurable.instrument("completed", execution_id: execution.id, recipe: execution.recipe)
+      :completed
+    end
+
+    def block!(error)
+      step = error.respond_to?(:step_name) ? error.step_name : nil
+      dumped = ActiveDurable.dump_error(error, step: step)
+      ActiveDurable.config.logger.error("[ActiveDurable] #{execution.id} blocked: #{error.class}: #{error.message}")
+      lease.release!(status: "blocked", error: dumped, wake_at: nil)
+      ActiveDurable.instrument("blocked", execution_id: execution.id, recipe: execution.recipe, error: dumped)
+      :blocked
+    end
+
+    def start_compensation!(error)
+      step = error.respond_to?(:step_name) ? error.step_name : nil
+      lease.renew!(compensating: true, error: ActiveDurable.dump_error(error, step: step))
+      @flow.compensating!
+    end
+
+    # Runs the undos of every completed step, last one first. Each undo is its own notebook entry,
+    # so a crash in the middle resumes where it stopped.
+    def compensate!
+      if @flow.pivoted?
+        return block!(InvalidRecipe.new("#{execution.id} cannot be compensated: it already passed its point " \
+                                        "of no return (flow.pivot)"))
+      end
+
+      ActiveDurable.instrument("compensation", execution_id: execution.id) do
+        @flow.undo_stack.reverse_each { |entry| undo!(entry) }
+      end
+      lease.release!(status: "compensated", wake_at: nil)
+      ActiveDurable.instrument("compensated", execution_id: execution.id, recipe: execution.recipe)
+      :compensated
+    rescue UndoFailed => e
+      block!(e)
+    end
+
+    def undo!(entry)
+      name = "#{entry.name}:undo"
+      record = notebook[name]
+      return if record&.completed?
+
+      suspend!(record.wake_at, "sleeping") if record&.retrying? && record.wake_at && record.wake_at > ActiveDurable.now
+
+      ticket = "#{execution.id}:#{name}"
+      ActiveDurable.crash_point(:before_undo, entry.name)
+      ActiveDurable.instrument("undo", execution_id: execution.id, step: entry.name) do
+        if entry.kind == "transaction"
+          notebook.transaction { call_undo(entry, ticket, name) }
+        else
+          call_undo(entry, ticket, name)
+        end
+      end
+      ActiveDurable.crash_point(:after_undo_record, entry.name)
+    rescue StandardError => e
+      retry_undo!(entry, name, record, e)
+    end
+
+    def call_undo(entry, ticket, name)
+      callable = entry.undo
+      # (result, undo ticket, ticket of the step being undone): the undo takes as many as it declares.
+      args = [entry.result.deep_dup, ticket, "#{execution.id}:#{entry.name}"]
+      parameters = callable.respond_to?(:parameters) ? callable.parameters : callable.method(:call).parameters
+      if parameters.any? { |type, _| type == :rest }
+        callable.call(*args)
+      else
+        callable.call(*args.first(parameters.count { |type, _| %i[req opt].include?(type) }))
+      end
+      ActiveDurable.crash_point(:after_undo_call, entry.name)
+      notebook.complete!(name, kind: "undo", position: nil, result: nil)
+    end
+
+    def retry_undo!(entry, name, record, error)
+      attempts = (record&.attempts || 0) + 1
+      dumped = ActiveDurable.dump_error(error, step: name)
+      max = ActiveDurable.config.undo_attempts
+      if attempts >= max
+        notebook.fail!(name, kind: "undo", position: nil, attempts: attempts, error: dumped)
+        raise UndoFailed, "undo of :#{entry.name} failed #{attempts} times (#{error.class}: #{error.message})"
+      end
+
+      wake_at = ActiveDurable.now + RetryPolicy.new(attempts: max).delay(attempts)
+      notebook.retry!(name, kind: "undo", position: nil, attempts: attempts, wake_at: wake_at, error: dumped)
+      suspend!(wake_at, "sleeping")
+    end
+  end
+end

data/lib/active_durable/serializer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # Step results, inputs and signal payloads live in the notebook as JSON. This module turns a value
+  # into exactly what a later replay will read back (string keys, no symbols), so the first run and a
+  # replay behave the same. Anything that is not plain JSON is rejected with a message that says where.
+  module Serializer
+    module_function
+
+    def normalize(value, path = "value")
+      case value
+      when nil, true, false, String, Integer then value
+      when Float then finite_float(value, path)
+      when Symbol then value.to_s
+      when Array then value.each_with_index.map { |item, index| normalize(item, "#{path}[#{index}]") }
+      when Hash then normalize_hash(value, path)
+      else
+        raise NotSerializable,
+              "#{path} is a #{value.class}. Steps, inputs and signals must use plain JSON values " \
+              "(nil, true/false, numbers, strings, arrays and hashes). Keep only what you need, " \
+              "for example { \"id\" => charge.id }."
+      end
+    end
+
+    def normalize_hash(hash, path)
+      hash.each_with_object({}) do |(key, item), out|
+        key = key.to_s if key.is_a?(Symbol)
+        raise NotSerializable, "#{path} has a #{key.class} key; use strings or symbols" unless key.is_a?(String)
+
+        out[key] = normalize(item, "#{path}[#{key.inspect}]")
+      end
+    end
+
+    def finite_float(value, path)
+      raise NotSerializable, "#{path} is #{value}, which JSON cannot store" unless value.finite?
+
+      value
+    end
+  end
+end

data/lib/active_durable/signal_record.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # A message for a saga that is (or will be) waiting in flow.wait_for.
+  class SignalRecord < Record
+    self.table_name = "durable_signals"
+
+    attribute :payload, JSON_TYPE
+
+    belongs_to :execution, class_name: "ActiveDurable::Execution", inverse_of: :signals, optional: true
+
+    scope :pending, -> { where(consumed_at: nil) }
+
+    after_create_commit { ActiveDurable.enqueue(execution_id) }
+
+    def self.next_for(execution_id, name)
+      pending.where(execution_id: execution_id, name: name.to_s).order(:id).first
+    end
+  end
+end

data/lib/active_durable/step.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # One notebook entry: a step (or an undo) and what it returned.
+  class Step < Record
+    self.table_name = "durable_steps"
+
+    attribute :result, JSON_TYPE
+    attribute :error, JSON_TYPE
+
+    # optional: the foreign key already guarantees it, and this skips a SELECT on every notebook write.
+    belongs_to :execution, class_name: "ActiveDurable::Execution", inverse_of: :steps, optional: true
+
+    def completed?
+      status == "completed"
+    end
+
+    def failed?
+      status == "failed"
+    end
+
+    def retrying?
+      status == "retrying"
+    end
+
+    def waiting?
+      status == "waiting"
+    end
+
+    def undo?
+      kind == "undo"
+    end
+  end
+end

data/lib/active_durable/sweep_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ActiveDurable
+  # Schedule it every minute (Solid Queue recurring tasks, cron, sidekiq-cron...).
+  class SweepJob < ActiveJob::Base
+    queue_as { ActiveDurable.config.queue_name }
+
+    def perform
+      Sweeper.call
+    end
+  end
+end