mammoth 0.8.0 → 0.9.0

data/lib/mammoth/delivery_worker.rb

@@ -17,7 +17,7 @@ module Mammoth
     # @param sink [#deliver] destination sink
     # @param checkpoint_store [Mammoth::CheckpointStore] checkpoint persistence
     # @param dead_letter_store [Mammoth::DeadLetterStore] dead letter persistence
-    # @param delivered_envelope_store [Mammoth::DeliveredEnvelopeStore, nil] downstream delivery ledger
+    # @param delivered_envelope_store [Mammoth::DeliveredEnvelopeStore] downstream delivery ledger
     # @param source_name [String] logical source name
     # @param slot_name [String] replication slot name
     # @param publication_name [String] publication name
@@ -26,13 +26,13 @@ module Mammoth
     # @param sleeper [#call] sleep strategy, injectable for tests
     # @param route_filter [Mammoth::RouteFilter, nil] optional destination route matcher
     # @param enabled [Boolean] whether this destination accepts new deliveries
-    def initialize(sink:, checkpoint_store:, dead_letter_store:, source_name:, slot_name:, publication_name:,
-                   max_attempts:, retry_schedule:, delivered_envelope_store: nil, sleeper: Kernel.method(:sleep),
+    def initialize(sink:, checkpoint_store:, dead_letter_store:, delivered_envelope_store:, source_name:, slot_name:,
+                   publication_name:, max_attempts:, retry_schedule:, sleeper: Kernel.method(:sleep),
                    route_filter: nil, enabled: true)
       @sink = sink
       @checkpoint_store = checkpoint_store
       @dead_letter_store = dead_letter_store
-      @delivered_envelope_store = delivered_envelope_store || DeliveredEnvelopeStore.new(checkpoint_store.sqlite_store)
+      @delivered_envelope_store = delivered_envelope_store
       @source_name = source_name
       @slot_name = slot_name
       @publication_name = publication_name
@@ -49,14 +49,16 @@ module Mammoth
     # @param sink [#deliver] destination sink
     # @param checkpoint_store [Mammoth::CheckpointStore] checkpoint persistence
     # @param dead_letter_store [Mammoth::DeadLetterStore] dead letter persistence
+    # @param delivered_envelope_store [Mammoth::DeliveredEnvelopeStore] downstream delivery ledger
     # @param sleeper [#call] sleep strategy
     # @return [Mammoth::DeliveryWorker]
-    def self.from_config(config, sink:, checkpoint_store:, dead_letter_store:, sleeper: Kernel.method(:sleep),
-                         delivery_policy: {})
+    def self.from_config(config, sink:, checkpoint_store:, dead_letter_store:, delivered_envelope_store:,
+                         sleeper: Kernel.method(:sleep), delivery_policy: {})
       new(
         sink: sink,
         checkpoint_store: checkpoint_store,
         dead_letter_store: dead_letter_store,
+        delivered_envelope_store: delivered_envelope_store,
         source_name: config.dig("mammoth", "name"),
         slot_name: config.dig("replication", "slot"),
         publication_name: Array(config.dig("replication", "publications")).join(","),
@@ -70,7 +72,7 @@ module Mammoth
 
     # Deliver a transaction envelope with retry, checkpoint, and DLQ handling.
     #
-    # @param envelope [#events, #transaction_id] CDC transaction envelope
+    # @param envelope [CDC::Core::TransactionEnvelope] CDC transaction envelope
     # @return [Hash] delivery summary
     def deliver_transaction(envelope)
       deliver_work(envelope, serializer: TransactionEnvelopeSerializer, delivery_method: :deliver_transaction)
@@ -78,7 +80,7 @@ module Mammoth
 
     # Deliver an event with retry, checkpoint, and DLQ handling.
     #
-    # @param event [Hash, #to_h] normalized event
+    # @param event [CDC::Core::ChangeEvent] normalized event
     # @return [Hash] delivery summary
     def deliver(event)
       deliver_work(event, serializer: EventSerializer, delivery_method: :deliver)

data/lib/mammoth/dispatch_metrics.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Thread-safe in-process counters populated by Mammoth's CDC core observer.
+  #
+  # The registry deliberately stores CDC core metric names and tags. Rendering
+  # those counters for a specific backend remains an observability concern.
+  class DispatchMetrics
+    # Create an empty dispatch metric registry.
+    def initialize
+      @mutex = Mutex.new
+      @counters = Hash.new(0)
+    end
+
+    # Process-wide dispatch metrics used by the default observer and snapshot.
+    INSTANCE = new
+
+    # Increment a canonical CDC core metric.
+    #
+    # @param name [String] canonical CDC core metric name
+    # @param tags [Hash] canonical metric tags
+    # @return [Integer] updated counter value
+    def increment(name, tags = {})
+      key = [name.to_s.freeze, normalized_tags(tags)]
+      @mutex.synchronize { @counters[key] += 1 }
+    end
+
+    # Return an immutable point-in-time copy of all counters.
+    #
+    # @return [Array<Hash>] metric entries with name, tags, and value
+    def snapshot
+      @mutex.synchronize do
+        @counters.map do |(name, tags), value|
+          { name: name, tags: tags.to_h, value: value }
+        end
+      end
+    end
+
+    # Clear all counters.
+    #
+    # Intended for process lifecycle management and isolated tests.
+    #
+    # @return [self] cleared registry
+    def reset!
+      @mutex.synchronize { @counters.clear }
+      self
+    end
+
+    private
+
+    def normalized_tags(tags)
+      tags.to_h.transform_keys(&:to_s).sort_by(&:first).freeze
+    end
+  end
+end

data/lib/mammoth/event_serializer.rb

@@ -15,17 +15,19 @@ module Mammoth
     # Default source label used in serialized webhook payloads.
     DEFAULT_SOURCE = "postgresql"
 
-    # Serialize an event-like object into a webhook-ready Hash.
+    # Serialize a core change event into a webhook-ready Hash.
     #
-    # @param event [Hash, #to_h] normalized CDC event
+    # @param event [CDC::Core::ChangeEvent] normalized CDC event
     # @return [Hash] webhook payload
     def self.call(event)
       new(event).call
     end
 
-    # @param event [Hash, #to_h] normalized CDC event
+    # @param event [CDC::Core::ChangeEvent] normalized CDC event
     def initialize(event)
-      @event = event.respond_to?(:to_h) ? event.to_h : event
+      raise ArgumentError, "event must be a CDC::Core::ChangeEvent" unless event.is_a?(CDC::Core::ChangeEvent)
+
+      @event = event.to_h
     end
 
     # Return the webhook payload.
@@ -33,19 +35,20 @@ module Mammoth
     # @return [Hash] webhook payload
     def call
       event_hash = stringify_keys(@event)
+      metadata = stringify_keys(event_hash["metadata"] || {})
       {
-        "event_id" => event_hash["event_id"] || SecureRandom.uuid,
-        "source" => event_hash["source"] || DEFAULT_SOURCE,
+        "event_id" => event_id(metadata),
+        "source" => source(metadata),
         "operation" => normalize_operation(event_hash.fetch("operation")),
-        "namespace" => event_hash["namespace"] || event_hash["schema"],
-        "entity" => event_hash["entity"] || event_hash["table"],
-        "identity" => event_hash["identity"] || event_hash["primary_key"],
-        "source_position" => event_hash["source_position"] || event_hash["commit_lsn"],
+        "namespace" => event_hash["schema"],
+        "entity" => event_hash["table"],
+        "identity" => event_hash["primary_key"],
+        "source_position" => event_hash["commit_lsn"],
         "transaction_id" => event_hash["transaction_id"],
         "occurred_at" => occurred_at(event_hash),
         "data" => event_data(event_hash),
-        "changes" => event_hash["changes"] || [],
-        "metadata" => event_hash["metadata"] || {}
+        "changes" => metadata["changes"] || [],
+        "metadata" => metadata
       }
     end
 
@@ -66,6 +69,14 @@ module Mammoth
       operation.to_s
     end
 
+    def event_id(metadata)
+      metadata["event_id"] || SecureRandom.uuid
+    end
+
+    def source(metadata)
+      metadata["source"] || DEFAULT_SOURCE
+    end
+
     def occurred_at(event_hash)
       value = event_hash["occurred_at"]
       return value.iso8601 if value.respond_to?(:iso8601)

data/lib/mammoth/fanout_delivery_worker.rb

@@ -14,7 +14,7 @@ module Mammoth
 
     # Deliver an event to every configured destination.
     #
-    # @param event [Hash, #to_h] normalized event
+    # @param event [CDC::Core::ChangeEvent] normalized event
     # @return [Hash] aggregate fanout summary
     def deliver(event)
       fanout(:deliver, event)
@@ -22,7 +22,7 @@ module Mammoth
 
     # Deliver a transaction envelope to every configured destination.
     #
-    # @param envelope [#events, #transaction_id] CDC transaction envelope
+    # @param envelope [CDC::Core::TransactionEnvelope] CDC transaction envelope
     # @return [Hash] aggregate fanout summary
     def deliver_transaction(envelope)
       fanout(:deliver_transaction, envelope)
@@ -31,7 +31,7 @@ module Mammoth
     # Deliver an event to one configured destination.
     #
     # @param destination_name [String] destination name
-    # @param event [Hash, #to_h] normalized event
+    # @param event [CDC::Core::ChangeEvent] normalized event
     # @return [Hash] destination delivery summary
     def deliver_to(destination_name, event)
       worker_for(destination_name).deliver(event)
@@ -40,7 +40,7 @@ module Mammoth
     # Deliver a transaction envelope to one configured destination.
     #
     # @param destination_name [String] destination name
-    # @param envelope [#events, #transaction_id] CDC transaction envelope
+    # @param envelope [CDC::Core::TransactionEnvelope] CDC transaction envelope
     # @return [Hash] destination delivery summary
     def deliver_transaction_to(destination_name, envelope)
       worker_for(destination_name).deliver_transaction(envelope)

data/lib/mammoth/metrics_observer.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # CDC core observer that records Mammoth dispatch counters.
+  class MetricsObserver < CDC::Core::Observer
+    attr_reader :metrics
+
+    # @param metrics [Mammoth::DispatchMetrics] dispatch counter registry
+    def initialize(metrics: DispatchMetrics::INSTANCE)
+      super()
+      @metrics = metrics
+    end
+
+    # Record a dispatch attempt.
+    #
+    # @param event [Object] CDC work item
+    # @return [Integer] updated counter
+    def dispatch_started(event)
+      record(self.class.started_metric_name, event)
+    end
+
+    # Record a successful dispatch.
+    #
+    # @param result [CDC::Core::ProcessorResult] processor result
+    # @return [Integer] updated counter
+    def dispatch_succeeded(result)
+      record(self.class.succeeded_metric_name, result)
+    end
+
+    # Record a failed dispatch.
+    #
+    # @param result [CDC::Core::ProcessorResult] processor result
+    # @return [Integer] updated counter
+    def dispatch_failed(result)
+      record(self.class.failed_metric_name, result)
+    end
+
+    # Record a skipped dispatch.
+    #
+    # @param result [CDC::Core::ProcessorResult] processor result
+    # @return [Integer] updated counter
+    def dispatch_skipped(result)
+      record(self.class.skipped_metric_name, result)
+    end
+
+    private
+
+    def record(name, payload)
+      metrics.increment(name, CDC::Core::Observer.metric_tags(payload))
+    end
+  end
+end

data/lib/mammoth/observability_metrics.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Prometheus formatting helpers for operational and dispatch metrics.
+  module ObservabilityMetrics
+    # Maps canonical CDC core metric names to Mammoth's Prometheus counters.
+    DISPATCH_METRIC_NAMES = {
+      CDC::Core::Observer.started_metric_name => "mammoth_dispatch_started_total",
+      CDC::Core::Observer.succeeded_metric_name => "mammoth_dispatch_succeeded_total",
+      CDC::Core::Observer.failed_metric_name => "mammoth_dispatch_failed_total",
+      CDC::Core::Observer.skipped_metric_name => "mammoth_dispatch_skipped_total"
+    }.freeze
+
+    private
+
+    def metric_headers
+      operational_metric_headers + dispatch_metric_headers
+    end
+
+    def operational_metric_headers
+      [
+        "# HELP mammoth_up 1 when Mammoth operational state can be inspected, 0 otherwise.",
+        "# TYPE mammoth_up gauge",
+        "# HELP mammoth_checkpoints_total Number of checkpoint rows stored by Mammoth.",
+        "# TYPE mammoth_checkpoints_total gauge",
+        "# HELP mammoth_dead_letters_total Number of dead-letter rows stored by Mammoth.",
+        "# TYPE mammoth_dead_letters_total gauge",
+        "# HELP mammoth_dead_letters_pending_total Number of pending dead-letter rows.",
+        "# TYPE mammoth_dead_letters_pending_total gauge",
+        "# HELP mammoth_dead_letters_resolved_total Number of resolved dead-letter rows.",
+        "# TYPE mammoth_dead_letters_resolved_total gauge",
+        "# HELP mammoth_dead_letters_ignored_total Number of ignored dead-letter rows.",
+        "# TYPE mammoth_dead_letters_ignored_total gauge",
+        "# HELP mammoth_delivered_envelopes_total Number of delivered-envelope ledger rows.",
+        "# TYPE mammoth_delivered_envelopes_total gauge"
+      ]
+    end
+
+    def dispatch_metric_headers
+      [
+        "# HELP mammoth_dispatch_started_total Number of CDC work items submitted for delivery.",
+        "# TYPE mammoth_dispatch_started_total counter",
+        "# HELP mammoth_dispatch_succeeded_total Number of successful CDC delivery results.",
+        "# TYPE mammoth_dispatch_succeeded_total counter",
+        "# HELP mammoth_dispatch_failed_total Number of failed CDC delivery results.",
+        "# TYPE mammoth_dispatch_failed_total counter",
+        "# HELP mammoth_dispatch_skipped_total Number of skipped CDC delivery results.",
+        "# TYPE mammoth_dispatch_skipped_total counter"
+      ]
+    end
+
+    def dispatch_metric_lines
+      dispatch_metrics.snapshot.sort_by { |entry| [entry.fetch(:name), entry.fetch(:tags).to_a] }.filter_map do |entry|
+        name = DISPATCH_METRIC_NAMES[entry.fetch(:name)]
+        metric_line(name, entry.fetch(:value), labels: entry.fetch(:tags)) if name
+      end
+    end
+
+    def metric_line(name, value, destination: nil, labels: {})
+      labels = { "mammoth_name" => mammoth_name }.merge(labels.transform_keys(&:to_s))
+      labels["destination"] = destination if destination
+      %(#{name}{#{labels.map { |label, label_value| %(#{label}="#{escape_label(label_value)}") }.join(",")}} #{Integer(value)})
+    end
+
+    def escape_label(value)
+      value.to_s.gsub("\\", "\\\\").gsub('"', '\\"').gsub("\n", "\\n")
+    end
+  end
+end

data/lib/mammoth/observability_server.rb

@@ -8,25 +8,25 @@ module Mammoth
   #
   # The server is intentionally independent from the replication loop. Operators
   # may run it as a sidecar-like process or in a separate process that points at
-  # the same SQLite operational database.
+  # the same configured operational-state backend.
   class ObservabilityServer
     # Default bind host for the observability server.
     DEFAULT_HOST = "0.0.0.0"
     # Default TCP port for the observability server.
     DEFAULT_PORT = 9393
 
-    attr_reader :config, :host, :port, :sqlite_store, :logger, :server
+    attr_reader :config, :host, :port, :state_adapter, :logger, :server
 
     # @param config [Mammoth::Configuration] loaded configuration
     # @param host [String, nil] bind host override
     # @param port [Integer, nil] bind port override
-    # @param sqlite_store [Mammoth::SQLiteStore, nil] optional operational store
+    # @param state_adapter [Mammoth::OperationalState::Adapter, nil] operational state dependency
     # @param logger [WEBrick::Log, nil] optional WEBrick logger
-    def initialize(config, host: nil, port: nil, sqlite_store: nil, logger: nil)
+    def initialize(config, host: nil, port: nil, state_adapter: nil, logger: nil)
       @config = config
       @host = host || config.dig("observability", "host") || DEFAULT_HOST
       @port = port || config.dig("observability", "port") || DEFAULT_PORT
-      @sqlite_store = sqlite_store
+      @state_adapter = state_adapter || OperationalState::Registry.build_configured(config)
       @logger = logger || WEBrick::Log.new($stderr, WEBrick::Log::WARN)
       @server = build_server
       mount_endpoints
@@ -81,7 +81,7 @@ module Mammoth
     end
 
     def snapshot
-      ObservabilitySnapshot.new(config, sqlite_store: sqlite_store)
+      ObservabilitySnapshot.new(config, state_adapter: state_adapter)
     end
   end
 end

data/lib/mammoth/observability_snapshot.rb

@@ -9,17 +9,21 @@ module Mammoth
   # ObservabilitySnapshot is intentionally read-only. It does not start the
   # relay, mutate checkpoints, replay dead letters, or inspect PostgreSQL. The
   # health and metrics endpoints use this object to expose Mammoth process and
-  # SQLite operational-state status in a predictable format.
+  # operational-state adapter status in a predictable format.
   class ObservabilitySnapshot
-    attr_reader :config, :sqlite_store, :clock
+    include ObservabilityMetrics
+
+    attr_reader :config, :state_adapter, :clock, :dispatch_metrics
 
     # @param config [Mammoth::Configuration] loaded configuration
-    # @param sqlite_store [Mammoth::SQLiteStore, nil] optional operational store
+    # @param state_adapter [Mammoth::OperationalState::Adapter, nil] operational state dependency
     # @param clock [#call] time source returning a Time-like object
-    def initialize(config, sqlite_store: nil, clock: -> { Time.now.utc })
+    # @param dispatch_metrics [Mammoth::DispatchMetrics] dispatch counter registry
+    def initialize(config, state_adapter: nil, clock: -> { Time.now.utc }, dispatch_metrics: DispatchMetrics::INSTANCE)
       @config = config
-      @sqlite_store = sqlite_store
+      @state_adapter = state_adapter || OperationalState::Registry.build_configured(config)
       @clock = clock
+      @dispatch_metrics = dispatch_metrics
     end
 
     # Build a liveness response.
@@ -39,50 +43,55 @@ module Mammoth
     #
     # @return [Hash] readiness payload
     def readiness
-      store = operational_store
-      store.bootstrap!
+      return unready_payload unless state_adapter.ready?
 
       {
         status: "ready",
         service: "mammoth",
         name: mammoth_name,
-        sqlite: "ok",
-        tables: store.tables,
-        checked_at: checked_at
-      }
-    rescue Mammoth::Error, SQLite3::Exception => e
-      {
-        status: "unready",
-        service: "mammoth",
-        name: mammoth_name,
-        sqlite: "error",
-        error_class: e.class.name,
-        error_message: e.message,
+        operational_state: "ok",
+        adapter: state_summary.fetch(:adapter),
+        summary: state_summary,
         checked_at: checked_at
       }
+    rescue Mammoth::Error => e
+      adapter_error_payload(e)
     end
 
     # Build a Prometheus text exposition document.
     #
     # @return [String] Prometheus metrics text
     def prometheus
-      store = operational_store.bootstrap!
-      checkpoint_store = CheckpointStore.new(store)
-      dead_letter_store = DeadLetterStore.new(store)
-      delivered_store = DeliveredEnvelopeStore.new(store)
+      return down_metrics unless state_adapter.ready?
 
       lines = metric_headers + aggregate_metric_lines(
-        checkpoint_store: checkpoint_store,
-        dead_letter_store: dead_letter_store,
-        delivered_store: delivered_store
-      ) + destination_metric_lines(dead_letter_store:, delivered_store:)
+        checkpoint_store: state_adapter.checkpoint_store,
+        dead_letter_store: state_adapter.dead_letter_store,
+        delivered_store: state_adapter.delivered_envelope_store
+      ) + destination_metric_lines(
+        dead_letter_store: state_adapter.dead_letter_store,
+        delivered_store: state_adapter.delivered_envelope_store
+      ) + dispatch_metric_lines
       "#{lines.join("\n")}\n"
-    rescue Mammoth::Error, SQLite3::Exception
-      "#{(metric_headers + [metric_line("mammoth_up", 0)]).join("\n")}\n"
+    rescue Mammoth::Error
+      down_metrics
     end
 
     private
 
+    def adapter_error_payload(error)
+      {
+        status: "unready",
+        service: "mammoth",
+        name: mammoth_name,
+        operational_state: "error",
+        adapter: configured_adapter_name,
+        error_class: error.class.name,
+        error_message: error.message,
+        checked_at: checked_at
+      }
+    end
+
     def aggregate_metric_lines(checkpoint_store:, dead_letter_store:, delivered_store:)
       [
         metric_line("mammoth_up", 1),
@@ -112,8 +121,27 @@ module Mammoth
       end
     end
 
-    def operational_store
-      sqlite_store || SQLiteStore.connect(config.dig("sqlite", "path"))
+    def unready_payload
+      {
+        status: "unready",
+        service: "mammoth",
+        name: mammoth_name,
+        operational_state: "error",
+        adapter: configured_adapter_name,
+        checked_at: checked_at
+      }
+    end
+
+    def down_metrics
+      "#{(metric_headers + [metric_line("mammoth_up", 0)] + dispatch_metric_lines).join("\n")}\n"
+    end
+
+    def state_summary
+      @state_summary ||= state_adapter.summary
+    end
+
+    def configured_adapter_name
+      config.dig("operational_state", "adapter") || "sqlite"
     end
 
     def mammoth_name
@@ -130,34 +158,5 @@ module Mammoth
     def checked_at
       clock.call.utc.iso8601
     end
-
-    def metric_headers
-      [
-        "# HELP mammoth_up 1 when Mammoth operational state can be inspected, 0 otherwise.",
-        "# TYPE mammoth_up gauge",
-        "# HELP mammoth_checkpoints_total Number of checkpoint rows stored by Mammoth.",
-        "# TYPE mammoth_checkpoints_total gauge",
-        "# HELP mammoth_dead_letters_total Number of dead-letter rows stored by Mammoth.",
-        "# TYPE mammoth_dead_letters_total gauge",
-        "# HELP mammoth_dead_letters_pending_total Number of pending dead-letter rows.",
-        "# TYPE mammoth_dead_letters_pending_total gauge",
-        "# HELP mammoth_dead_letters_resolved_total Number of resolved dead-letter rows.",
-        "# TYPE mammoth_dead_letters_resolved_total gauge",
-        "# HELP mammoth_dead_letters_ignored_total Number of ignored dead-letter rows.",
-        "# TYPE mammoth_dead_letters_ignored_total gauge",
-        "# HELP mammoth_delivered_envelopes_total Number of delivered-envelope ledger rows.",
-        "# TYPE mammoth_delivered_envelopes_total gauge"
-      ]
-    end
-
-    def metric_line(name, value, destination: nil)
-      labels = { "mammoth_name" => mammoth_name }
-      labels["destination"] = destination if destination
-      %(#{name}{#{labels.map { |label, label_value| %(#{label}="#{escape_label(label_value)}") }.join(",")}} #{Integer(value)})
-    end
-
-    def escape_label(value)
-      value.to_s.gsub("\\", "\\\\").gsub('"', '\\"').gsub("\n", "\\n")
-    end
   end
 end

data/lib/mammoth/operational_state/adapter.rb

@@ -23,6 +23,22 @@ module Mammoth
         raise NotImplementedError, "#{self.class} must implement #delivered_envelope_store"
       end
 
+      # Initialize the adapter's durable state.
+      #
+      # @return [Mammoth::OperationalState::Adapter] self
+      def bootstrap!
+        raise NotImplementedError, "#{self.class} must implement #bootstrap!"
+      end
+
+      # Report whether the adapter can serve operational state.
+      #
+      # Implementations must translate backend-specific failures into false.
+      #
+      # @return [Boolean]
+      def ready?
+        raise NotImplementedError, "#{self.class} must implement #ready?"
+      end
+
       # @return [Hash] JSON-friendly state summary
       def summary
         {

data/lib/mammoth/operational_state/registry.rb

@@ -31,6 +31,14 @@ module Mammoth
           fetch(name).from_config(config)
         end
 
+        # Build the operational-state adapter selected by configuration.
+        #
+        # @param config [Mammoth::Configuration] loaded configuration
+        # @return [Mammoth::OperationalState::Adapter] adapter instance
+        def build_configured(config)
+          build(config.dig("operational_state", "adapter") || "sqlite", config)
+        end
+
         # @return [Array<String>] registered operational state adapter names
         def names
           registry.names

data/lib/mammoth/operational_state/sqlite_adapter.rb

@@ -6,10 +6,10 @@ module Mammoth
     class SQLiteAdapter < Adapter
       attr_reader :sqlite_store
 
-      # @param sqlite_store [Mammoth::SQLiteStore] bootstrapped SQLite store
+      # @param sqlite_store [Mammoth::SQLiteStore] SQLite operational store
       def initialize(sqlite_store)
         super()
-        @sqlite_store = sqlite_store.bootstrap!
+        @sqlite_store = sqlite_store
       end
 
       # Build a SQLite state adapter from Mammoth configuration.
@@ -35,6 +35,22 @@ module Mammoth
         @delivered_envelope_store ||= DeliveredEnvelopeStore.new(sqlite_store)
       end
 
+      # Initialize the SQLite schema.
+      #
+      # @return [Mammoth::OperationalState::SQLiteAdapter] self
+      def bootstrap!
+        sqlite_store.bootstrap!
+        self
+      end
+
+      # @return [Boolean] whether SQLite operational state is available
+      def ready?
+        bootstrap!
+        true
+      rescue Mammoth::Error, SQLite3::Exception
+        false
+      end
+
       # @return [Hash] JSON-friendly SQLite state summary
       def summary
         super.merge(adapter: "sqlite", path: sqlite_store.path, tables: sqlite_store.tables)