lepus-saga 0.3.0

data/lib/lepus/saga/stores/base.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module Lepus
+  module Saga
+    module Stores
+      # The persistence contract the engine runs on. An adapter subclasses it,
+      # implements every method that raises NotImplementedError and returns
+      # its own records: an execution record includes
+      # Lepus::Saga::ExecutionBehaviour and a step attempt record includes
+      # Lepus::Saga::StepAttemptBehaviour. Both need readers and writers for
+      # their behaviour's ATTRIBUTES and `[](name)` returning the raw stored
+      # value.
+      #
+      # Concurrency model: an execution is only changed while its row is held
+      # by #with_lock or #with_locked_execution (an exclusive lock held until
+      # the block returns, like SELECT ... FOR UPDATE inside a transaction).
+      # The only writes made without it are #increment_resume_count, which
+      # must be atomic in storage, and #save_step_attempt on an attempt the
+      # caller opened itself.
+      #
+      # `require "lepus/saga/rspec"` and `it_behaves_like "a lepus saga store"`
+      # verify an adapter against this contract.
+      #
+      # The query methods after #step_succeeded? are optional: they feed
+      # read-only tools such as dashboards and are never called by the engine.
+      # An adapter that implements them returns true from #queries? and runs
+      # `it_behaves_like "a lepus saga query store"`.
+      class Base
+        QUERY_MAX_ROWS = 50_000
+        MAX_SERIES_BUCKETS = 1_000
+        GROUPABLE = %i[saga_name status partition current_step].freeze
+        SERIES_KEYS = ["started", *ExecutionBehaviour::TERMINAL_STATUSES].freeze
+        LATENCY_STATUSES = %w[succeeded failed].freeze
+        PERCENTILES = {p50: 50, p95: 95, p99: 99}.freeze
+
+        # Inserts an execution and returns its record. `attributes` holds
+        # saga_name, resource_type, resource_id, current_step, context,
+        # correlation_id, partition, started_at and last_progress_at. The store
+        # generates the id (a UUIDv7 string) and defaults status to "running",
+        # direction to "execute", epoch and resume_count to 0 and context to {}.
+        def create_execution(attributes)
+          raise NotImplementedError
+        end
+
+        # The execution with this id, or nil. Never locks.
+        def find_execution(id)
+          raise NotImplementedError
+        end
+
+        # Persists every attribute of `execution` and returns it.
+        def save_execution(execution)
+          raise NotImplementedError
+        end
+
+        # Holds an exclusive lock on the execution's row for the duration of
+        # the block, after reloading `execution` in place from storage. Writes
+        # made in the block are atomic: they are kept when the block returns
+        # (including through `next`) and discarded when it raises. Another
+        # caller locking the same execution waits until the block finishes.
+        # Returns the block's value.
+        def with_lock(execution)
+          raise NotImplementedError
+        end
+
+        # Same guarantees as #with_lock, starting from an id: yields a freshly
+        # loaded, locked record, or nil when there is no such execution.
+        # Returns the block's value.
+        def with_locked_execution(id)
+          execution = find_execution(id)
+          return yield(nil) unless execution
+
+          with_lock(execution) { yield execution }
+        end
+
+        # Adds one to the stored resume_count in a single atomic write (never a
+        # read-modify-write of the record, so it cannot clobber or be clobbered
+        # by a concurrent locked update) and touches updated_at. Sets the
+        # record's resume_count and returns the stored value.
+        def increment_resume_count(execution)
+          raise NotImplementedError
+        end
+
+        # Executions in progress (running or compensating) whose
+        # last_progress_at is before `before`, oldest last_progress_at first.
+        # Returns an Enumerable; the caller stops iterating when done.
+        def stalled_executions(before:)
+          raise NotImplementedError
+        end
+
+        # Executions of a resource, most recently created first.
+        def executions_for_resource(resource_type, resource_id)
+          raise NotImplementedError
+        end
+
+        # Inserts a step attempt of `execution` and returns its record.
+        # `attributes` holds step_name, direction, epoch, attempt and
+        # started_at; status defaults to "running" and context_after to {}.
+        # (execution, step_name, direction, epoch, attempt) is unique: a second
+        # insert raises Lepus::Saga::DuplicateAttemptError, and raising it out
+        # of #with_lock discards the block's other writes.
+        def create_step_attempt(execution, attributes)
+          raise NotImplementedError
+        end
+
+        # Persists every attribute of `attempt` and returns it.
+        def save_step_attempt(attempt)
+          raise NotImplementedError
+        end
+
+        # Attempts of an execution ordered by started_at, then created_at.
+        def step_attempts(execution)
+          raise NotImplementedError
+        end
+
+        # Number of attempts of `execution` for this step, direction and epoch,
+        # whatever their status.
+        def count_step_attempts(execution, step_name:, direction:, epoch:)
+          raise NotImplementedError
+        end
+
+        # Whether a "running" attempt for this step, direction and epoch
+        # started at or after `started_since`.
+        def running_step_attempt?(execution, step_name:, direction:, epoch:, started_since:)
+          raise NotImplementedError
+        end
+
+        # "running" attempts for this step, direction and epoch that started
+        # before `started_before`.
+        def stale_step_attempts(execution, step_name:, direction:, epoch:, started_before:)
+          raise NotImplementedError
+        end
+
+        # Whether the step ever succeeded in the execute direction, in any
+        # epoch.
+        def step_succeeded?(execution, step_name)
+          raise NotImplementedError
+        end
+
+        # Whether the optional query methods below are implemented.
+        def queries? = false
+
+        # Executions matching the filters, newest first by id (UUIDv7, so by
+        # creation time), at most `limit` of them. `before_id` returns the
+        # page after the execution with that id. Every filter is optional:
+        # `saga_name`, `status` and `current_step` take a value or a list;
+        # `partition` matches the partition column, and executions without one
+        # whose definition runs in that partition; `resource` is a
+        # case-insensitive substring of resource_type or resource_id; `from`
+        # (inclusive) and `to` (exclusive) bound created_at, `progress_from`
+        # and `progress_to` bound last_progress_at the same way (in-progress
+        # executions with `progress_to: Time.now.utc - 15 * 60` are the
+        # stalled ones). `error_class` and `error_step` take a value or a list
+        # and keep executions with a failed attempt of that error class and at
+        # that step (either filter alone matches on its own attribute);
+        # `error_from` (inclusive) and `error_to` (exclusive) bound that
+        # failed attempt's started_at, the window #failure_summary counts.
+        def list_executions(saga_name: nil, status: nil, current_step: nil, partition: nil, resource: nil, from: nil, to: nil,
+          progress_from: nil, progress_to: nil, error_class: nil, error_step: nil, error_from: nil, error_to: nil, before_id: nil, limit: 50)
+          raise NotImplementedError
+        end
+
+        # Number of executions matching the #list_executions filters, as a
+        # Hash keyed by the value of `group_by` (one of GROUPABLE), or by an
+        # Array of values when `group_by` is an Array. Grouping by partition
+        # resolves executions without one to their definition's partition
+        # (nil for an unknown saga).
+        def count_executions(group_by:, saga_name: nil, status: nil, current_step: nil, partition: nil, resource: nil, from: nil, to: nil,
+          progress_from: nil, progress_to: nil, error_class: nil, error_step: nil, error_from: nil, error_to: nil)
+          raise NotImplementedError
+        end
+
+        # Executions started (by created_at) and finished in each terminal
+        # status (by finished_at) per `bucket` seconds between `from` and
+        # `to`. Returns `{rows: [[bucket_start, {"started" => n, "completed" =>
+        # n, ...}], ...], truncated:}` with every bucket of the window, bucket
+        # starts aligned to multiples of `bucket` since the epoch. At most
+        # `max_rows` of the newest timestamps of each kind are counted;
+        # `truncated` tells whether some were left out.
+        def execution_series(from:, to:, bucket:, saga_name: nil, max_rows: QUERY_MAX_ROWS)
+          raise NotImplementedError
+        end
+
+        # Duration percentiles (nearest rank, in milliseconds) of the
+        # succeeded and failed attempts started between `from` and `to`, per
+        # saga, step and direction. Returns `{rows: [{saga_name:, step_name:,
+        # direction:, count:, p50:, p95:, p99:, max:}, ...], truncated:}`
+        # sorted by saga, step and direction, computed from at most `max_rows`
+        # of the newest attempts.
+        def step_latency(from:, to:, saga_name: nil, max_rows: QUERY_MAX_ROWS)
+          raise NotImplementedError
+        end
+
+        # Failed attempts started between `from` and `to`, grouped by error
+        # class, saga and step, most frequent first (then most recently seen),
+        # at most `limit` groups. Returns `[{error_class:, saga_name:,
+        # step_name:, count:, execution_count:, last_seen_at:,
+        # sample_message:, sample_execution_id:}, ...]` where count is the
+        # failed attempts, execution_count the distinct executions they belong
+        # to and the sample the group's latest failure.
+        def failure_summary(from:, to:, saga_name: nil, limit: 20)
+          raise NotImplementedError
+        end
+
+        # The distinct saga names in storage, sorted.
+        def saga_names
+          raise NotImplementedError
+        end
+
+        def update_execution(execution, attributes)
+          assign(execution, attributes)
+          save_execution(execution)
+        end
+
+        def update_step_attempt(attempt, attributes)
+          assign(attempt, attributes)
+          save_step_attempt(attempt)
+        end
+
+        def finish_step_attempt(attempt, status, context_after: {}, error: nil)
+          update_step_attempt(attempt, attempt.finish_attributes(status, context_after: context_after, error: error))
+        end
+
+        private
+
+        def assign(record, attributes)
+          attributes.each { |name, value| record.public_send(:"#{name}=", value) }
+        end
+
+        def filter_values(value)
+          values = Array(value).map(&:to_s)
+          values unless values.empty?
+        end
+
+        def partition_saga_names(partition)
+          Lepus::Saga.definitions.filter_map { |name, definition| name if definition.partition == partition.to_s }
+        end
+
+        def resolve_partition(partition, saga_name)
+          partition || Lepus::Saga.definitions[saga_name]&.partition
+        end
+
+        def group_keys(group_by)
+          keys = Array(group_by).map(&:to_sym)
+          unknown = keys - GROUPABLE
+          raise ArgumentError, "Cannot group executions by #{unknown.join(", ")}" if keys.empty? || unknown.any?
+
+          keys
+        end
+
+        # Sums `[attributes, count]` rows into the #count_executions Hash.
+        def tally_groups(rows, group_by)
+          keys = group_keys(group_by)
+          rows.each_with_object(Hash.new(0)) do |(attributes, count), counts|
+            values = keys.map do |key|
+              (key == :partition) ? resolve_partition(attributes[:partition], attributes[:saga_name]) : attributes[key]
+            end
+            counts[group_by.is_a?(Array) ? values : values.first] += count
+          end
+        end
+
+        # `rows` holds up to max_rows + 1 entries, newest first.
+        def take_rows(rows, max_rows)
+          [rows.first(max_rows), rows.size > max_rows]
+        end
+
+        def series_bucket(from, to, bucket)
+          seconds = bucket.to_i
+          raise ArgumentError, "bucket must be at least one second" unless seconds.positive?
+          if series_size(from, to, seconds) > MAX_SERIES_BUCKETS
+            raise ArgumentError, "More than #{MAX_SERIES_BUCKETS} buckets between #{from} and #{to}"
+          end
+
+          seconds
+        end
+
+        def series_size(from, to, seconds)
+          ((to.to_r - from.to_i.div(seconds) * seconds) / seconds).ceil
+        end
+
+        # Buckets `started` timestamps and `[finished_at, status]` pairs.
+        def build_series(from, to, seconds, started, finished)
+          first = from.to_i.div(seconds) * seconds
+          rows = Array.new(series_size(from, to, seconds)) do |index|
+            [Time.at(first + index * seconds).utc, SERIES_KEYS.to_h { |key| [key, 0] }]
+          end
+          started.each { |time| rows[(time.to_i - first).div(seconds)].last["started"] += 1 }
+          finished.each { |time, status| rows[(time.to_i - first).div(seconds)].last[status] += 1 }
+          rows
+        end
+
+        # Percentiles of `[saga_name, step_name, direction, duration_ms]` samples.
+        def latency_rows(samples)
+          samples.group_by { |sample| sample.first(3) }.sort_by(&:first).map do |(saga_name, step_name, direction), group|
+            durations = group.map { |sample| sample.last.to_f }.sort
+            {
+              saga_name: saga_name, step_name: step_name, direction: direction, count: durations.size,
+              **PERCENTILES.transform_values { |rank| durations[(Rational(rank, 100) * durations.size).ceil - 1] },
+              max: durations.last
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lepus/saga/stores/memory.rb

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+require "json"
+require "monitor"
+
+module Lepus
+  module Saga
+    module Stores
+      # Thread-safe in-process store for tests and single-process tools.
+      # Records are copies: changing one changes nothing until it is saved, and
+      # every read builds a fresh record. Locks are per execution and
+      # re-entrant; writes made under a lock are undone when the block raises.
+      # Readers see writes as soon as they happen (no isolation between
+      # concurrent transactions), so it is not a database.
+      class Memory < Base
+        class RecordNotFound < StandardError; end
+
+        ATTEMPT_KEY = %i[saga_execution_id step_name direction epoch attempt].freeze
+        JSON_ATTRIBUTES = %i[context context_after].freeze
+
+        class Record
+          class << self
+            attr_reader :attribute_names
+
+            def attributes(*names)
+              @attribute_names = names
+              include(Module.new { attr_accessor(*names) })
+            end
+          end
+
+          def initialize(values = {})
+            load(values)
+          end
+
+          def [](name) = instance_variable_get(:"@#{name}")
+
+          def attributes
+            self.class.attribute_names.to_h { |name| [name, self[name]] }
+          end
+
+          def load(values)
+            values.each { |name, value| instance_variable_set(:"@#{name}", value) }
+            self
+          end
+
+          def ==(other) = other.instance_of?(self.class) && !id.nil? && other.id == id
+
+          alias_method :eql?, :==
+
+          def hash = [self.class, id].hash
+        end
+
+        class Execution < Record
+          attributes(*ExecutionBehaviour::ATTRIBUTES)
+
+          include ExecutionBehaviour
+        end
+
+        class StepAttempt < Record
+          attributes(*StepAttemptBehaviour::ATTRIBUTES)
+
+          include StepAttemptBehaviour
+        end
+
+        def initialize
+          super
+          @mutex = Mutex.new
+          @transaction_key = :"lepus_saga_memory_transaction_#{object_id}"
+          clear!
+        end
+
+        def clear!
+          @mutex.synchronize do
+            @executions = {}
+            @step_attempts = {}
+            @attempt_ids = {}
+            @row_locks = Hash.new { |locks, id| locks[id] = Monitor.new }
+          end
+        end
+
+        def create_execution(attributes)
+          now = Time.now.utc
+          row = {
+            status: "running", direction: "execute", epoch: 0, resume_count: 0,
+            context: {}, last_progress_at: now, **attributes.transform_keys(&:to_sym),
+            id: SecureRandom.uuid_v7, created_at: now, updated_at: now
+          }
+          Execution.new(insert(@executions, row))
+        end
+
+        def find_execution(id)
+          read(@executions, id)&.then { |row| Execution.new(row) }
+        end
+
+        def save_execution(execution)
+          execution.updated_at = Time.now.utc
+          update(@executions, execution.attributes)
+          execution
+        end
+
+        def with_lock(execution)
+          row_lock(execution.id).synchronize do
+            transaction do
+              execution.load(read(@executions, execution.id) || raise(RecordNotFound, "No execution #{execution.id}"))
+              yield execution
+            end
+          end
+        end
+
+        def with_locked_execution(id)
+          row_lock(id).synchronize do
+            transaction { yield find_execution(id) }
+          end
+        end
+
+        def increment_resume_count(execution)
+          row_lock(execution.id).synchronize do
+            execution.resume_count = @mutex.synchronize do
+              row = @executions.fetch(execution.id) { raise RecordNotFound, "No execution #{execution.id}" }
+              log_undo(@executions, execution.id)
+              @executions[execution.id] = row.merge(resume_count: row[:resume_count] + 1, updated_at: Time.now.utc)
+              row[:resume_count] + 1
+            end
+          end
+        end
+
+        def stalled_executions(before:)
+          where(@executions, Execution) { |row| ExecutionBehaviour::IN_PROGRESS_STATUSES.include?(row[:status]) && row[:last_progress_at] < before }
+            .sort_by { |execution| [execution.last_progress_at, execution.id] }
+        end
+
+        def executions_for_resource(resource_type, resource_id)
+          where(@executions, Execution) { |row| row[:resource_type] == resource_type && row[:resource_id] == resource_id }
+            .sort_by { |execution| [execution.created_at, execution.id] }.reverse
+        end
+
+        def create_step_attempt(execution, attributes)
+          now = Time.now.utc
+          row = {
+            direction: "execute", epoch: 0, status: "running", context_after: {},
+            **attributes.transform_keys(&:to_sym),
+            id: SecureRandom.uuid_v7, saga_execution_id: execution.id, created_at: now, updated_at: now
+          }
+          StepAttempt.new(insert(@step_attempts, row, unique: ATTEMPT_KEY))
+        end
+
+        def save_step_attempt(attempt)
+          attempt.updated_at = Time.now.utc
+          update(@step_attempts, attempt.attributes)
+          attempt
+        end
+
+        def step_attempts(execution)
+          @mutex.synchronize { attempt_rows(execution.id) }.map { |row| StepAttempt.new(copy(row)) }
+            .sort_by { |attempt| [attempt.started_at, attempt.created_at, attempt.id] }
+        end
+
+        def count_step_attempts(execution, step_name:, direction:, epoch:)
+          attempts_for_step(execution, step_name, direction, epoch).size
+        end
+
+        def running_step_attempt?(execution, step_name:, direction:, epoch:, started_since:)
+          attempts_for_step(execution, step_name, direction, epoch)
+            .any? { |attempt| attempt.running? && attempt.started_at >= started_since }
+        end
+
+        def stale_step_attempts(execution, step_name:, direction:, epoch:, started_before:)
+          attempts_for_step(execution, step_name, direction, epoch)
+            .select { |attempt| attempt.running? && attempt.started_at < started_before }
+        end
+
+        def step_succeeded?(execution, step_name)
+          step_attempts(execution).any? do |attempt|
+            attempt.step_name == step_name && attempt.direction == "execute" && attempt.succeeded?
+          end
+        end
+
+        def queries? = true
+
+        def list_executions(before_id: nil, limit: 50, **filters)
+          executions = matching_executions(**filters)
+          executions = executions.select { |execution| execution.id < before_id } if before_id
+          executions.sort_by(&:id).reverse.first(limit)
+        end
+
+        def count_executions(group_by:, **filters)
+          tally_groups(matching_executions(**filters).map { |execution| [execution.attributes, 1] }, group_by)
+        end
+
+        def execution_series(from:, to:, bucket:, saga_name: nil, max_rows: QUERY_MAX_ROWS)
+          seconds = series_bucket(from, to, bucket)
+          window = from...to
+          executions = matching_executions(saga_name: saga_name)
+          started, started_truncated = take_rows(
+            executions.map(&:created_at).select { |time| window.cover?(time) }.sort.reverse, max_rows
+          )
+          finished, finished_truncated = take_rows(
+            executions.select { |execution| execution.terminal? && window.cover?(execution.finished_at) }
+              .map { |execution| [execution.finished_at, execution.status] }.sort_by(&:first).reverse,
+            max_rows
+          )
+          {rows: build_series(from, to, seconds, started, finished), truncated: started_truncated || finished_truncated}
+        end
+
+        def step_latency(from:, to:, saga_name: nil, max_rows: QUERY_MAX_ROWS)
+          attempts = attempts_with_saga(from, to, saga_name).select do |attempt, _|
+            LATENCY_STATUSES.include?(attempt.status) && attempt.duration_ms
+          end
+          samples, truncated = take_rows(
+            attempts.sort_by { |attempt, _| attempt.started_at }.reverse
+              .map { |attempt, saga| [saga, attempt.step_name, attempt.direction, attempt.duration_ms] },
+            max_rows
+          )
+          {rows: latency_rows(samples), truncated: truncated}
+        end
+
+        def failure_summary(from:, to:, saga_name: nil, limit: 20)
+          attempts_with_saga(from, to, saga_name).select { |attempt, _| attempt.failed? }
+            .group_by { |attempt, saga| [attempt.error_class, saga, attempt.step_name] }
+            .map { |(error_class, saga, step_name), group| failure_group(error_class, saga, step_name, group.map(&:first)) }
+            .sort_by { |group| [-group[:count], -group[:last_seen_at].to_r] }
+            .first(limit)
+        end
+
+        def saga_names
+          @mutex.synchronize { @executions.each_value.map { |row| row[:saga_name] } }.uniq.sort
+        end
+
+        private
+
+        def matching_executions(saga_name: nil, status: nil, current_step: nil, partition: nil, resource: nil, from: nil, to: nil,
+          progress_from: nil, progress_to: nil, error_class: nil, error_step: nil, error_from: nil, error_to: nil)
+          sagas = filter_values(saga_name)
+          statuses = filter_values(status)
+          steps = filter_values(current_step)
+          partition_sagas = partition_saga_names(partition) unless partition.to_s.strip.empty?
+          needle = resource.to_s.downcase
+          needle = nil if needle.strip.empty?
+          failing = failing_execution_ids(filter_values(error_class), filter_values(error_step), error_from, error_to)
+          where(@executions, Execution) do |row|
+            (sagas.nil? || sagas.include?(row[:saga_name])) &&
+              (statuses.nil? || statuses.include?(row[:status])) &&
+              (steps.nil? || steps.include?(row[:current_step])) &&
+              (from.nil? || row[:created_at] >= from) &&
+              (to.nil? || row[:created_at] < to) &&
+              (progress_from.nil? || row[:last_progress_at] >= progress_from) &&
+              (progress_to.nil? || row[:last_progress_at] < progress_to) &&
+              (failing.nil? || failing.include?(row[:id])) &&
+              (partition_sagas.nil? || in_partition?(row, partition.to_s, partition_sagas)) &&
+              (needle.nil? || row.values_at(:resource_type, :resource_id).any? { |value| value.to_s.downcase.include?(needle) })
+          end
+        end
+
+        def failing_execution_ids(error_classes, steps, from, to)
+          return if [error_classes, steps, from, to].all?(&:nil?)
+
+          @mutex.synchronize do
+            @step_attempts.each_value.filter_map do |row|
+              next unless row[:status] == "failed"
+              next unless error_classes.nil? || error_classes.include?(row[:error_class])
+              next unless steps.nil? || steps.include?(row[:step_name])
+              next if from && row[:started_at] < from
+              next if to && row[:started_at] >= to
+
+              row[:saga_execution_id]
+            end.to_set
+          end
+        end
+
+        def in_partition?(row, partition, saga_names)
+          row[:partition] ? row[:partition] == partition : saga_names.include?(row[:saga_name])
+        end
+
+        # Attempts started in the window as `[attempt, saga_name]` pairs.
+        def attempts_with_saga(from, to, saga_name)
+          sagas = @mutex.synchronize { @executions.transform_values { |row| row[:saga_name] } }
+          wanted = filter_values(saga_name)
+          where(@step_attempts, StepAttempt) do |row|
+            (from...to).cover?(row[:started_at]) && (wanted.nil? || wanted.include?(sagas[row[:saga_execution_id]]))
+          end.map { |attempt| [attempt, sagas[attempt.saga_execution_id]] }
+        end
+
+        def failure_group(error_class, saga_name, step_name, attempts)
+          latest = attempts.max_by { |attempt| [attempt.finished_at, attempt.id] }
+          {
+            error_class: error_class, saga_name: saga_name, step_name: step_name, count: attempts.size,
+            execution_count: attempts.map(&:saga_execution_id).uniq.size, last_seen_at: latest.finished_at, sample_message: latest.error_message,
+            sample_execution_id: latest.saga_execution_id
+          }
+        end
+
+        def attempts_for_step(execution, step_name, direction, epoch)
+          step_attempts(execution).select do |attempt|
+            attempt.step_name == step_name && attempt.direction == direction && attempt.epoch == epoch
+          end
+        end
+
+        def row_lock(id)
+          @mutex.synchronize { @row_locks[id] }
+        end
+
+        def transaction(&block)
+          undo_log ? yield : run_transaction(&block)
+        end
+
+        def run_transaction
+          log = Thread.current[@transaction_key] = []
+          committed = false
+          result = yield
+          committed = true
+          result
+        ensure
+          Thread.current[@transaction_key] = nil
+          rollback(log) unless committed
+        end
+
+        def undo_log = Thread.current[@transaction_key]
+
+        def log_undo(table, id)
+          undo_log&.push([table, id, table[id]])
+        end
+
+        def rollback(log)
+          @mutex.synchronize do
+            log.reverse_each do |table, id, previous|
+              previous ? table[id] = previous : table.delete(id)
+            end
+          end
+        end
+
+        def read(table, id)
+          @mutex.synchronize { table[id] }&.then { |row| copy(row) }
+        end
+
+        def where(table, klass, &filter)
+          @mutex.synchronize { table.values.select(&filter) }.map { |row| klass.new(copy(row)) }
+        end
+
+        def insert(table, row, unique: nil)
+          row = copy(row)
+          @mutex.synchronize do
+            if unique && attempt_rows(row[:saga_execution_id]).any? { |other| other.values_at(*unique) == row.values_at(*unique) }
+              raise DuplicateAttemptError, "Duplicate #{row.slice(*unique).inspect}"
+            end
+
+            log_undo(table, row[:id])
+            table[row[:id]] = row
+            (@attempt_ids[row[:saga_execution_id]] ||= []) << row[:id] if table.equal?(@step_attempts)
+          end
+          copy(row)
+        end
+
+        def update(table, row)
+          row = copy(row)
+          @mutex.synchronize do
+            raise RecordNotFound, "No record #{row[:id]}" unless table.key?(row[:id])
+
+            log_undo(table, row[:id])
+            table[row[:id]] = row
+          end
+        end
+
+        # Attempt rows of an execution through the index kept on insert; ids of
+        # rows a rollback removed are skipped. Call it holding @mutex.
+        def attempt_rows(execution_id)
+          @attempt_ids.fetch(execution_id, []).filter_map { |id| @step_attempts[id] }
+        end
+
+        def copy(row)
+          row.to_h { |name, value| [name, JSON_ATTRIBUTES.include?(name) ? JSON.parse(JSON.generate(value)) : value] }
+        end
+      end
+    end
+  end
+end