mammoth 0.8.0 → 1.0.0

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,71 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # Prometheus formatting helpers for operational and dispatch metrics.
+  module ObservabilityMetrics
+    include PostgresObservabilityMetrics
+
+    # 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 + postgres_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,27 @@ 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, :slot_health_provider, :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 slot_health_provider [#slot_health, nil] PostgreSQL slot health 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, slot_health_provider: 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)
+      @slot_health_provider = slot_health_provider || Sources::Postgres.new(config)
       @logger = logger || WEBrick::Log.new($stderr, WEBrick::Log::WARN)
       @server = build_server
       mount_endpoints
@@ -81,7 +83,7 @@ module Mammoth
     end
 
     def snapshot
-      ObservabilitySnapshot.new(config, sqlite_store: sqlite_store)
+      ObservabilitySnapshot.new(config, state_adapter:, slot_health_provider:)
     end
   end
 end

data/lib/mammoth/observability_snapshot.rb

@@ -3,23 +3,30 @@
 require "time"
 
 module Mammoth
-  # Builds health, readiness, and metrics snapshots from Mammoth's local
-  # operational state.
+  # Builds health, readiness, and metrics snapshots from Mammoth's operational
+  # state and optional PostgreSQL slot-health provider.
   #
   # 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.
-  class ObservabilitySnapshot
-    attr_reader :config, :sqlite_store, :clock
+  # relay, mutate checkpoints, replay dead letters, or change PostgreSQL slot
+  # state. An injected provider may perform read-only slot inspection. The
+  # endpoints expose process, operational-state, and source status predictably.
+  class ObservabilitySnapshot # rubocop:disable Metrics/ClassLength
+    include ObservabilityMetrics
+
+    attr_reader :config, :state_adapter, :clock, :dispatch_metrics, :slot_health_provider
 
     # @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
+    # @param slot_health_provider [#slot_health, nil] PostgreSQL slot health dependency
+    def initialize(config, state_adapter: nil, clock: -> { Time.now.utc }, dispatch_metrics: DispatchMetrics::INSTANCE,
+                   slot_health_provider: nil)
       @config = config
-      @sqlite_store = sqlite_store
+      @state_adapter = state_adapter || OperationalState::Registry.build_configured(config)
       @clock = clock
+      @dispatch_metrics = dispatch_metrics
+      @slot_health_provider = slot_health_provider
     end
 
     # Build a liveness response.
@@ -39,50 +46,93 @@ module Mammoth
     #
     # @return [Hash] readiness payload
     def readiness
-      store = operational_store
-      store.bootstrap!
+      return unready_payload unless state_adapter.ready?
 
-      {
+      payload = {
         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
       }
+      return payload unless slot_health_provider
+
+      health = postgres_slot_health
+      return postgres_unready_payload(health) unless health.ready?
+
+      payload.merge(postgres_slot: health.summary)
+    rescue ReplicationError => e
+      postgres_error_payload(e)
+    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 + postgres_slot_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 postgres_unready_payload(health)
+      {
+        status: "unready",
+        service: "mammoth",
+        name: mammoth_name,
+        operational_state: "ok",
+        adapter: state_summary.fetch(:adapter),
+        summary: state_summary,
+        postgres_slot: health.summary,
+        checked_at: checked_at
+      }
+    end
+
+    def postgres_error_payload(error)
+      {
+        status: "unready",
+        service: "mammoth",
+        name: mammoth_name,
+        operational_state: "ok",
+        adapter: configured_adapter_name,
+        postgres_slot: {
+          ready: false,
+          reason: "inspection failed",
+          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 +162,39 @@ 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 postgres_slot_metric_lines
+      return [] unless slot_health_provider
+
+      postgres_metric_lines(postgres_slot_health)
+    rescue ReplicationError
+      postgres_inspection_error_metric_lines
+    end
+
+    def postgres_slot_health
+      slot_health_provider.slot_health
+    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 +211,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)

data/lib/mammoth/persisted_payload_deserializer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Mammoth
+  # Reconstructs exact CDC core work items from persisted webhook payloads.
+  #
+  # Dead letters and sample files contain Mammoth's JSON delivery projection,
+  # not live CDC objects. This class is the explicit boundary that converts
+  # those persisted representations back into core vocabulary.
+  class PersistedPayloadDeserializer
+    class << self
+      # Deserialize one persisted event payload.
+      #
+      # @param payload [Hash] Mammoth event payload
+      # @return [CDC::Core::ChangeEvent] reconstructed core event
+      def event(payload)
+        attributes = stringify_keys(payload)
+        data = attributes["data"]
+        metadata = enriched_metadata(attributes)
+
+        CDC::Core::ChangeEvent.new(
+          operation: attributes.fetch("operation"),
+          schema: attributes["namespace"] || attributes.fetch("schema"),
+          table: attributes["entity"] || attributes.fetch("table"),
+          old_values: attributes["old_values"] || delete_values(attributes, data),
+          new_values: attributes["new_values"] || changed_values(attributes, data),
+          primary_key: attributes["identity"] || attributes["primary_key"],
+          transaction_id: attributes["transaction_id"],
+          commit_lsn: attributes["commit_lsn"] || attributes["source_position"],
+          sequence_number: attributes["sequence_number"],
+          occurred_at: parse_time(attributes["occurred_at"]),
+          metadata: metadata
+        )
+      rescue KeyError, ArgumentError, TypeError => e
+        raise ConfigurationError, "invalid persisted CDC event: #{e.message}"
+      end
+
+      # Deserialize one persisted transaction payload.
+      #
+      # @param payload [Hash] Mammoth transaction webhook payload
+      # @return [CDC::Core::TransactionEnvelope] reconstructed core transaction
+      def transaction(payload)
+        attributes = stringify_keys(payload)
+        CDC::Core::TransactionEnvelope.new(
+          transaction_id: attributes.fetch("transaction_id"),
+          events: attributes.fetch("events").map { |event_payload| event(event_payload) },
+          commit_lsn: attributes["commit_lsn"] || attributes["source_position"],
+          committed_at: parse_time(attributes["committed_at"]),
+          metadata: enriched_metadata(attributes)
+        )
+      rescue KeyError, ArgumentError, TypeError => e
+        raise ConfigurationError, "invalid persisted CDC transaction: #{e.message}"
+      end
+
+      private
+
+      def stringify_keys(payload)
+        payload.to_h.transform_keys(&:to_s)
+      end
+
+      def enriched_metadata(attributes)
+        metadata = stringify_keys(attributes["metadata"] || {})
+        %w[event_id source source_position changes type].each do |key|
+          metadata[key] = attributes[key] if attributes.key?(key)
+        end
+        metadata
+      end
+
+      def delete_values(attributes, data)
+        data if attributes["operation"].to_s == "delete"
+      end
+
+      def changed_values(attributes, data)
+        data unless attributes["operation"].to_s == "delete"
+      end
+
+      def parse_time(value)
+        return value if value.nil? || value.is_a?(Time)
+
+        Time.iso8601(value.to_s)
+      end
+    end
+  end
+end

data/lib/mammoth/postgres_observability_metrics.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Mammoth
+  # PostgreSQL slot-specific Prometheus formatting helpers.
+  module PostgresObservabilityMetrics
+    # Metric names and help text for PostgreSQL replication-slot gauges.
+    POSTGRES_METRICS = {
+      "mammoth_postgres_slot_inspection_up" => "1 when PostgreSQL slot inspection succeeds.",
+      "mammoth_postgres_slot_present" => "1 when the configured replication slot exists.",
+      "mammoth_postgres_slot_ready" => "1 when the configured slot is healthy and active.",
+      "mammoth_postgres_slot_active" => "1 when PostgreSQL reports the slot as active.",
+      "mammoth_postgres_slot_retained_wal_bytes" => "WAL retained from the slot restart LSN.",
+      "mammoth_postgres_slot_safe_wal_size_bytes" => "WAL bytes that may be written before the slot risks loss.",
+      "mammoth_postgres_slot_wal_status" => "Current PostgreSQL WAL retention status for the slot.",
+      "mammoth_postgres_slot_invalidated" => "1 when PostgreSQL reports invalidation or conflict.",
+      "mammoth_postgres_slot_inactive_since_timestamp_seconds" => "Unix timestamp when the slot became inactive.",
+      "mammoth_postgres_slot_restart_lsn_bytes" => "Numeric PostgreSQL restart LSN.",
+      "mammoth_postgres_slot_confirmed_flush_lsn_bytes" => "Numeric PostgreSQL confirmed flush LSN."
+    }.freeze
+
+    private
+
+    def postgres_metric_headers
+      POSTGRES_METRICS.flat_map { |name, help| ["# HELP #{name} #{help}", "# TYPE #{name} gauge"] }
+    end
+
+    def postgres_metric_lines(health)
+      labels = { slot_name: health.slot_name }
+      lines = postgres_presence_metric_lines(health, labels:)
+      return lines unless health.present
+
+      lines + postgres_status_metric_lines(health, labels:) + postgres_optional_metric_lines(health, labels:)
+    end
+
+    def postgres_presence_metric_lines(health, labels:)
+      [
+        metric_line("mammoth_postgres_slot_inspection_up", 1, labels:),
+        metric_line("mammoth_postgres_slot_present", health.present ? 1 : 0, labels:)
+      ]
+    end
+
+    def postgres_status_metric_lines(health, labels:)
+      [
+        metric_line("mammoth_postgres_slot_ready", health.ready? ? 1 : 0, labels:),
+        metric_line("mammoth_postgres_slot_active", health.active ? 1 : 0, labels:),
+        metric_line("mammoth_postgres_slot_wal_status", 1,
+                    labels: labels.merge(wal_status: health.wal_status || "unknown")),
+        metric_line("mammoth_postgres_slot_invalidated", invalidated?(health) ? 1 : 0, labels:)
+      ]
+    end
+
+    def postgres_optional_metric_lines(health, labels:)
+      {
+        "mammoth_postgres_slot_retained_wal_bytes" => health.retained_wal_bytes,
+        "mammoth_postgres_slot_safe_wal_size_bytes" => health.safe_wal_size,
+        "mammoth_postgres_slot_inactive_since_timestamp_seconds" => timestamp_seconds(health.inactive_since),
+        "mammoth_postgres_slot_restart_lsn_bytes" => health.restart_lsn_bytes,
+        "mammoth_postgres_slot_confirmed_flush_lsn_bytes" => health.confirmed_flush_lsn_bytes
+      }.filter_map { |name, value| metric_line(name, value, labels:) unless value.nil? }
+    end
+
+    def postgres_inspection_error_metric_lines
+      labels = { slot_name: config.dig("replication", "slot") }
+      [metric_line("mammoth_postgres_slot_inspection_up", 0, labels:)]
+    end
+
+    def timestamp_seconds(value)
+      return nil if value.nil?
+      return value.to_i if value.respond_to?(:to_i) && !value.is_a?(String)
+
+      Time.parse(value.to_s).to_i
+    rescue ArgumentError
+      nil
+    end
+
+    def invalidated?(health)
+      health.conflicting || (!health.invalidation_reason.nil? && health.invalidation_reason != "")
+    end
+  end
+end