legion-data 1.10.9 → 1.10.28

data/lib/legion/data/connection.rb

@@ -2,9 +2,11 @@
 
 require 'legion/logging/helper'
 require 'legion/data/auth_failure_handler'
+require 'legion/data/connection_pool'
 
 require 'fileutils'
 require 'sequel'
+require 'uri'
 
 module Legion
   module Data
@@ -142,6 +144,9 @@ module Legion
             @closed = true
             @file.close unless @file.closed?
           end
+        rescue IOError, SystemCallError => e
+          handle_exception(e, level: :warn, handled: true, operation: :query_file_close, path: @path)
+          nil
         end
 
         private
@@ -152,9 +157,7 @@ module Legion
 
             @file.puts "[#{Time.now.strftime('%Y-%m-%d %H:%M:%S.%L')}] #{level} #{message}"
           end
-        rescue IOError => e
-          return nil if @closed || @file.closed?
-
+        rescue IOError, SystemCallError => e
           handle_exception(e, level: :warn, handled: true, operation: :query_file_write, path: @path)
           nil
         end
@@ -163,43 +166,61 @@ module Legion
       class << self
         include Legion::Logging::Helper
 
-        attr_accessor :sequel
+        attr_reader :sequel
+
+        def sequel=(database)
+          if database
+            pool = database.pool
+            pool.extend(Legion::Data::ConnectionPool) unless pool.is_a?(Legion::Data::ConnectionPool)
+          end
+          Legion::Data.reset_privileges!
+          @sequel = database
+        end
 
         def adapter
           @adapter ||= Legion::Settings[:data][:adapter]&.to_sym || :sqlite
         end
 
         def setup
+          Legion::Settings[:data][:connected] = false
+          @sequel&.disconnect
+          @sequel = nil
           @adapter = Legion::Settings[:data][:adapter]&.to_sym || :sqlite
           opts = sequel_opts
           log.info("Legion::Data::Connection setup adapter=#{adapter}")
           @fallback_active = false
-          @sequel = if adapter == :sqlite
-                      ::Sequel.connect(opts.merge(adapter: :sqlite, database: sqlite_path))
-                    else
-                      attempted_adapter = adapter
-                      begin
-                        ::Sequel.connect(connection_opts_for(adapter: attempted_adapter, opts: opts))
-                      rescue UnresolvedCredentialError => e
-                        handle_exception(e, level: :fatal, handled: false, operation: :data_connect)
-                        raise
-                      rescue StandardError => e
-                        raise unless dev_fallback?
-
-                        log.error("Legion::Data FALLING BACK TO SQLITE — #{attempted_adapter} network DB connection failed: #{e.message}")
-                        log.error("Legion::Data WARNING: Data written to SQLite will NOT be visible when #{attempted_adapter} reconnects. " \
-                                  'Apollo knowledge, audit logs, and other DB-backed services will use a local-only store.')
-                        handle_exception(e, level: :error, handled: true, operation: :shared_connect, fallback: :sqlite)
-                        @adapter = :sqlite
-                        @fallback_active = true
-                        sqlite_opts = sequel_opts
-                        ::Sequel.connect(sqlite_opts.merge(adapter: :sqlite, database: sqlite_path))
-                      end
-                    end
-          Legion::Settings[:data][:connected] = true
+          @replica_servers = []
+          self.sequel = if adapter == :sqlite
+                          ::Sequel.connect(opts.merge(adapter: :sqlite, database: sqlite_path))
+                        else
+                          attempted_adapter = adapter
+                          begin
+                            ::Sequel.connect(connection_opts_for(adapter: attempted_adapter, opts: opts))
+                          rescue UnresolvedCredentialError => e
+                            handle_exception(e, level: :fatal, handled: false, operation: :data_connect)
+                            raise
+                          rescue ::Sequel::DatabaseConnectionError => e
+                            raise unless dev_fallback?
+
+                            log.error("Legion::Data FALLING BACK TO SQLITE — #{attempted_adapter} network DB connection failed: #{e.message}")
+                            log.error("Legion::Data WARNING: Data written to SQLite will NOT be visible when #{attempted_adapter} reconnects. " \
+                                      'Apollo knowledge, audit logs, and other DB-backed services will use a local-only store.')
+                            handle_exception(e, level: :error, handled: true, operation: :shared_connect, fallback: :sqlite)
+                            @adapter = :sqlite
+                            @fallback_active = true
+                            sqlite_opts = sequel_opts
+                            ::Sequel.connect(sqlite_opts.merge(adapter: :sqlite, database: sqlite_path))
+                          end
+                        end
+          @replica_servers = @sequel.opts.fetch(:servers, {}).keys
           log_connection_info
           configure_extensions
-          connect_with_replicas
+          Legion::Settings[:data][:connected] = true
+        rescue StandardError, LoadError => e
+          shutdown
+          @sequel = nil
+          handle_exception(e, level: :fatal, handled: false, operation: :connection_setup)
+          raise
         end
 
         # Returns connection metadata for health checks and diagnostics.
@@ -210,6 +231,7 @@ module Legion
             connected:          Legion::Settings[:data][:connected],
             fallback_active:    @fallback_active || false,
             configured_adapter: Legion::Settings[:data][:adapter]&.to_sym || :sqlite,
+            shutdown:           @sequel&.pool&.shutdown_status,
             sequel_alive:       (begin
               !@sequel&.test_connection.nil?
             rescue StandardError => e
@@ -276,15 +298,26 @@ module Legion
         end
 
         def shutdown
-          if @sequel
-            timeout = Legion::Settings[:data][:shutdown_timeout]
-            force_disconnect_pool(timeout: timeout)
+          database = @sequel
+          logger = @query_file_logger
+          on_closed = proc do
+            logger&.close
+            if @sequel.equal?(database)
+              @query_file_logger = nil
+              @fallback_active = false
+              @replica_servers = []
+              Legion::Settings[:data][:connected] = false
+            end
+            log.info 'Legion::Data connection closed'
           end
-          @query_file_logger&.close
-          @query_file_logger = nil
-          @fallback_active = false
-          Legion::Settings[:data][:connected] = false
-          log.info 'Legion::Data connection closed'
+          unless database
+            on_closed.call
+            return true
+          end
+
+          closed = database.pool.shutdown(timeout: Legion::Settings[:data][:shutdown_timeout], &on_closed)
+          log.warn("Legion::Data shutdown incomplete: #{database.pool.shutdown_status}") unless closed
+          closed
         end
 
         def reconnect_with_fresh_creds
@@ -305,6 +338,7 @@ module Legion
           old_user = @sequel.opts[:user]
           @sequel.opts[:user] = new_user
           @sequel.opts[:password] = new_pass
+          Legion::Data.reset_privileges!
 
           @sequel.disconnect
           expire_all_pooled_connections
@@ -328,28 +362,6 @@ module Legion
           handle_exception(e, level: :warn, handled: true, operation: :expire_all_pooled_connections)
         end
 
-        def connect_with_replicas
-          return unless adapter == :postgres
-
-          replica_url  = Legion::Settings[:data][:read_replica_url]
-          replica_list = Array(Legion::Settings[:data][:replicas]).dup
-
-          replica_list.prepend(replica_url) if replica_url && !replica_url.empty?
-          replica_list.uniq!
-          replica_list.compact!
-
-          return if replica_list.empty?
-
-          @sequel.extension(:server_block)
-
-          replica_list.each_with_index do |url, idx|
-            @sequel.add_servers("read_#{idx}": url)
-          end
-
-          @replica_servers = replica_list.each_with_index.map { |_, idx| :"read_#{idx}" }
-          log.debug "Registered #{@replica_servers.size} read replica(s)"
-        end
-
         def read_server
           return :default if @replica_servers.nil? || @replica_servers.empty?
 
@@ -386,6 +398,20 @@ module Legion
           creds
         end
 
+        def configure_sqlite_busy_handler(connection:, timeout:)
+          timeout_seconds = timeout.to_f / 1000
+          deadline = nil
+          connection.busy_handler do |attempt|
+            now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            deadline = now + timeout_seconds if attempt.zero?
+            remaining = deadline - now
+            next false unless remaining.positive?
+
+            sleep([0.001, remaining].min)
+            true
+          end
+        end
+
         def creds_builder(final_creds = {})
           final_creds.merge! Legion::Data::Settings.creds(adapter)
           final_creds.merge! Legion::Settings[:data][:creds] if Legion::Settings[:data][:creds].is_a? Hash
@@ -437,28 +463,6 @@ module Legion
           data_settings[:dev_mode] == true && data_settings[:dev_fallback] != false
         end
 
-        def force_disconnect_pool(timeout:)
-          pool = @sequel.pool
-          in_use = pool.size - (pool.respond_to?(:available_connections) ? pool.available_connections.size : 0)
-
-          if in_use.positive?
-            log.warn("Legion::Data shutdown: #{in_use} connection(s) still checked out, waiting up to #{timeout}s")
-            deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + timeout
-            while ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) < deadline
-              break if pool.size <= (pool.respond_to?(:available_connections) ? pool.available_connections.size : 0)
-
-              sleep 0.1
-            end
-            remaining = pool.size - (pool.respond_to?(:available_connections) ? pool.available_connections.size : 0)
-            log.warn("Legion::Data shutdown: force-disconnecting #{remaining} wedged connection(s)") if remaining.positive?
-          end
-
-          @sequel.disconnect
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :force_disconnect_pool)
-          @sequel&.disconnect rescue nil # rubocop:disable Style/RescueModifier
-        end
-
         def sqlite_path
           path = Legion::Settings[:data][:creds][:database] || 'legionio.db'
           return path if File.absolute_path?(path)
@@ -472,9 +476,25 @@ module Legion
           connection_opts = opts.merge(adapter: adapter, **creds_builder)
           validate_no_unresolved_uris!(connection_opts)
           connection_opts[:preconnect] = false if adapter != :sqlite && dev_fallback?
+          if adapter == :postgres
+            servers = postgres_replica_servers
+            connection_opts[:servers] = servers unless servers.empty?
+          end
           connection_opts
         end
 
+        def postgres_replica_servers
+          data = Legion::Settings[:data]
+          urls = [data[:read_replica_url], *Array(data[:replicas])].compact.reject(&:empty?).uniq
+          urls.each_with_index.to_h do |url, index|
+            uri = URI.parse(url)
+            raise ArgumentError, 'Read replicas require PostgreSQL URLs' unless %w[postgres postgresql].include?(uri.scheme)
+
+            options = ::Sequel::Database.send(:options_from_uri, uri).compact
+            [:"read_#{index}", options]
+          end
+        end
+
         def validate_no_unresolved_uris!(connection_opts)
           %i[user username password].each do |key|
             value = connection_opts[key]
@@ -518,10 +538,18 @@ module Legion
             val = data.key?(key) && !data[key].nil? ? data[key] : defaults[key]
             opts[key] = val unless val.nil?
           end
+          opts[:after_connect] = proc { |connection| configure_sqlite_busy_handler(connection: connection, timeout: opts[:timeout]) } if adapter == :sqlite
+          opts[:connect_sqls] = postgres_connect_sqls(data) if adapter == :postgres
 
           opts
         end
 
+        def postgres_connect_sqls(data)
+          %i[statement_timeout lock_timeout].filter_map do |setting|
+            "SET #{setting} = '#{data[setting].to_i}ms'" if data[setting]
+          end
+        end
+
         def tuning_stats(data)
           tuning = {}
 
@@ -655,7 +683,7 @@ module Legion
           if adapter == :postgres
             Sequel.extension(:pg_array)
             @sequel.extension(:pg_array)
-            install_postgres_session_timeouts
+            @sequel.extension(:server_block) unless @replica_servers.empty?
           end
 
           if data[:connection_validation] != false
@@ -670,28 +698,15 @@ module Legion
 
           install_auth_failure_hook
         rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :configure_extensions, adapter: adapter)
-        end
-
-        def install_postgres_session_timeouts
-          data = Legion::Settings[:data]
-          stmt_timeout = data[:statement_timeout]
-          lck_timeout = data[:lock_timeout]
-
-          @sequel.pool.after_connect = proc do |conn|
-            conn.exec("SET statement_timeout = '#{stmt_timeout.to_i}ms'") if stmt_timeout
-            conn.exec("SET lock_timeout = '#{lck_timeout.to_i}ms'") if lck_timeout
-          end
-
-          log.info("Postgres session timeouts: statement_timeout=#{stmt_timeout}ms, lock_timeout=#{lck_timeout}ms")
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :install_postgres_session_timeouts)
+          handle_exception(e, level: :error, handled: false, operation: :configure_extensions, adapter: adapter)
+          raise
         end
 
         def install_auth_failure_hook
           Legion::Data::AuthFailureHandler.install(@sequel)
         rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :install_auth_failure_hook)
+          handle_exception(e, level: :error, handled: false, operation: :install_auth_failure_hook)
+          raise
         end
 
         def build_data_logger

data/lib/legion/data/connection_pool.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'legion/logging/helper'
+
+module Legion
+  module Data
+    module ConnectionPool
+      include Legion::Logging::Helper
+
+      def self.extended(pool)
+        pool.instance_variable_set(:@shutdown_mutex, Mutex.new)
+        pool.instance_variable_set(:@shutdown_condition, ConditionVariable.new)
+        pool.instance_variable_set(:@shutdown_owners, {}.compare_by_identity)
+        pool.instance_variable_set(:@shutdown_state, :open)
+      end
+
+      def hold(server = :default)
+        owner = Sequel.current
+        @shutdown_mutex.synchronize do
+          raise Sequel::Error, 'Database pool is shutting down or closed' unless @shutdown_state == :open || @shutdown_owners.key?(owner)
+
+          @shutdown_owners[owner] = @shutdown_owners.fetch(owner, 0) + 1
+        end
+        begin
+          super
+        ensure
+          finish = @shutdown_mutex.synchronize do
+            @shutdown_owners[owner] -= 1
+            @shutdown_owners.delete(owner) if @shutdown_owners[owner].zero?
+            if @shutdown_state == :draining && @shutdown_owners.empty?
+              @shutdown_state = :closing
+              true
+            end
+          end
+          finish_shutdown if finish
+        end
+      end
+
+      def shutdown(timeout:, &on_closed)
+        deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + timeout
+        finish = @shutdown_mutex.synchronize do
+          @shutdown_callback ||= on_closed
+          @shutdown_state = :draining if %i[open failed].include?(@shutdown_state)
+          if @shutdown_state == :draining && @shutdown_owners.empty?
+            @shutdown_state = :closing
+            true
+          end
+        end
+        finish_shutdown if finish
+        @shutdown_mutex.synchronize do
+          until @shutdown_state == :closed
+            remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            return false if remaining <= 0 || @shutdown_state == :failed || @shutdown_owners.key?(Sequel.current)
+
+            @shutdown_condition.wait(@shutdown_mutex, remaining)
+          end
+        end
+        true
+      end
+
+      def shutdown_status
+        @shutdown_mutex.synchronize { { state: @shutdown_state, active_requests: @shutdown_owners.size } }
+      end
+
+      private
+
+      def finish_shutdown
+        disconnect
+        @shutdown_callback.call
+        @shutdown_mutex.synchronize do
+          @shutdown_state = :closed
+          @shutdown_condition.broadcast
+        end
+      rescue StandardError => e
+        @shutdown_mutex.synchronize do
+          @shutdown_state = :failed
+          @shutdown_condition.broadcast
+        end
+        handle_exception(e, level: :error, handled: true, operation: :pool_shutdown)
+      end
+    end
+  end
+end

data/lib/legion/data/database_lock.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Legion
+  module Data
+    module DatabaseLock
+      def self.with_claim(database:, table:, key:)
+        options = { savepoint: true }
+        options[:mode] = :immediate if database.database_type == :sqlite
+        database.transaction(**options) do
+          claim = database[table].where(key)
+          # InnoDB needs exclusive duplicate-key locks to avoid shared-lock upgrade deadlocks.
+          claim = claim.on_duplicate_key_update(*key.keys) if database.database_type == :mysql
+          claim.insert(key)
+          result = yield
+          # The unique-key lock lasts until commit; historical keys need no retained rows.
+          claim.delete
+          result
+        end
+      end
+    end
+  end
+end

data/lib/legion/data/encryption/key_provider.rb

@@ -15,8 +15,7 @@ module Legion
         end
 
         def key_for(tenant_id: nil)
-          cache_key = tenant_id || '__default__'
-          @key_cache[cache_key] ||= derive_key(tenant_id)
+          @key_cache[tenant_id] ||= derive_key(tenant_id)
         end
 
         def clear_cache!

data/lib/legion/data/event_store.rb

@@ -2,6 +2,7 @@
 
 require 'legion/logging/helper'
 require 'digest'
+require 'legion/data/database_lock'
 
 module Legion
   module Data
@@ -21,11 +22,11 @@ module Legion
           return { error: 'db unavailable' } unless db_ready?
 
           conn = Legion::Data.connection
-          conn.transaction do
-            last = conn[:governance_events]
-                   .where(stream_id: stream)
-                   .order(Sequel.desc(:sequence_number))
-                   .first
+          Legion::Data::DatabaseLock.with_claim(database: conn, table: :append_claims,
+                                                key: { kind: 'event', stream_id: stream }) do
+            records = conn[:governance_events].where(stream_id: stream).order(Sequel.desc(:sequence_number))
+            records = records.for_update unless conn.database_type == :sqlite
+            last = records.first
 
             seq = (last&.[](:sequence_number) || 0) + 1
             prev_hash = last&.[](:event_hash) || ('0' * 64)

data/lib/legion/data/local.rb

@@ -32,6 +32,11 @@ module Legion
             val = data.key?(key) && !data[key].nil? ? data[key] : sqlite_defaults[key]
             opts[key] = val unless val.nil?
           end
+          opts[:timeout] = data[:timeout] || 30_000
+          opts[:after_connect] = proc do |connection|
+            Legion::Data::Connection.configure_sqlite_busy_handler(connection: connection, timeout: opts[:timeout])
+            connection.execute_batch('PRAGMA synchronous=NORMAL; PRAGMA cache_size=-20000; PRAGMA mmap_size=268435456')
+          end
 
           if local_settings[:query_log]
             log_path = File.join(Legion::Data::Connection::QUERY_LOG_DIR, 'data-local-query.log')
@@ -46,14 +51,11 @@ module Legion
 
           @connection = ::Sequel.connect(opts)
           @connection.run('PRAGMA journal_mode=WAL')
-          @connection.run('PRAGMA busy_timeout=30000')
-          @connection.run('PRAGMA synchronous=NORMAL')
-          @connection.run('PRAGMA cache_size=-20000')
-          @connection.run('PRAGMA mmap_size=268435456')
-          @connected = true
           run_migrations
-          log.info "Legion::Data::Local connected to #{db_file} (WAL mode, 30s busy_timeout, 20MB cache, 256MB mmap)"
-        rescue StandardError => e
+          @connected = true
+          log.info "Legion::Data::Local connected to #{db_file} (WAL mode, #{opts[:timeout]}ms busy timeout, 20MB cache, 256MB mmap)"
+        rescue StandardError, LoadError => e
+          shutdown
           handle_exception(e, level: :error, handled: false, operation: :local_setup, database: db_file)
           raise
         end
@@ -74,6 +76,10 @@ module Legion
           @registered_migrations ||= {}
           @registered_migrations[name] = path
           run_single_migration(name, path) if connected?
+        rescue StandardError, LoadError => e
+          shutdown
+          handle_exception(e, level: :error, handled: false, operation: :register_migrations, name: name, path: path)
+          raise
         end
 
         def registered_migrations
@@ -142,8 +148,9 @@ module Legion
 
           table = :"schema_migrations_#{name}"
           ::Sequel::TimestampMigrator.new(@connection, path, table: table).run
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :local_migration, name: name, path: path)
+        rescue StandardError, LoadError => e
+          handle_exception(e, level: :error, handled: false, operation: :local_migration, name: name, path: path)
+          raise
         end
 
         def local_settings

data/lib/legion/data/migrations/137_preserve_task_archive_fields.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    alter_table(:tasks_archive) do
+      add_column :function_id, Integer
+      add_column :parent_id, Integer
+      add_column :master_id, Integer
+      add_column :payload, String, text: true
+      add_column :worker_id, String, size: 36
+      add_column :tenant_id, String, size: 64
+      add_column :depth, Integer
+      add_column :cancelled_at, DateTime
+      add_column :task_delay, Integer
+      add_column :created_at, DateTime
+      add_column :idempotency_key, String, size: 64
+      add_column :idempotency_expires_at, DateTime
+    end
+  end
+
+  down do
+    alter_table(:tasks_archive) do
+      drop_column :function_id
+      drop_column :parent_id
+      drop_column :master_id
+      drop_column :payload
+      drop_column :worker_id
+      drop_column :tenant_id
+      drop_column :depth
+      drop_column :cancelled_at
+      drop_column :task_delay
+      drop_column :created_at
+      drop_column :idempotency_key
+      drop_column :idempotency_expires_at
+    end
+  end
+end

data/lib/legion/data/migrations/138_add_append_claims.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table(:append_claims) do
+      String :kind, size: 16, null: false
+      String :stream_id, size: 255, null: false
+      primary_key %i[kind stream_id]
+    end
+  end
+end

data/lib/legion/data/model.rb

@@ -30,7 +30,10 @@ module Legion
         def load
           log.info 'Loading Legion::Data::Models'
           @loaded_models ||= []
+          database = Legion::Data::Connection.sequel
+          Sequel::Model.db = database
           require_sequel_models(models)
+          bind_database(namespace: Legion::Data::Model, database: database)
           Legion::Settings[:data][:models][:loaded] = true
         end
 
@@ -49,6 +52,22 @@ module Legion
           handle_exception(e, level: :fatal, operation: :load_sequel_model, model: model)
           raise e unless Legion::Settings[:data][:models][:continue_on_load_fail]
         end
+
+        private
+
+        def bind_database(namespace:, database:)
+          namespace.constants(false).each do |name|
+            value = namespace.const_get(name, false)
+            if value.is_a?(Class) && value < Sequel::Model
+              next if value.db.equal?(database)
+
+              value.set_dataset(database[value.table_name])
+              value.association_reflections.each_value { |reflection| reflection[:cache]&.clear }
+            elsif value.is_a?(Module)
+              bind_database(namespace: value, database: database)
+            end
+          end
+        end
       end
     end
   end

data/lib/legion/data/models/audit_log.rb

@@ -8,9 +8,11 @@ module Legion
     module Model
       class AuditLog < Sequel::Model(:audit_log)
         include Legion::Logging::Helper
+        extend Legion::Logging::Helper
 
         VALID_EVENT_TYPES = %w[runner_execution lifecycle_transition].freeze
         VALID_STATUSES    = %w[success failure denied].freeze
+        HASH_CHAIN_COLUMNS = [:id, :record_hash, *Legion::Data::AuditLogHashChain::CANONICAL_FIELDS].freeze
 
         def validate
           super
@@ -39,9 +41,39 @@ module Legion
           Legion::Data::AuditLogHashChain.compute_hash(record)
         end
 
-        def self.verify_chain(records = order(:created_at, :id).all)
-          Legion::Data::AuditLogHashChain.verify(records)
+        def self.verify_chain(records = nil)
+          return Legion::Data::AuditLogHashChain.verify(records) unless records.nil?
+
+          hot = dataset.naked.select(*HASH_CHAIN_COLUMNS)
+          unless audit_archive_exists?
+            result = Legion::Data::AuditLogHashChain.verify(hot.order(:created_at, :id))
+            # Retention may create the archive and move rows after the first presence check.
+            return result unless audit_archive_exists?
+          end
+
+          warm = db[:audit_log_archive].select(*HASH_CHAIN_COLUMNS)
+          Legion::Data::AuditLogHashChain.verify(hot.union(warm, all: true).order(:created_at, :id))
+        end
+
+        def self.audit_archive_exists?
+          db.transaction(savepoint: :only) { db[:audit_log_archive].get(Sequel::NULL) }
+          true
+        rescue Sequel::DatabaseError => e
+          cause = e.wrapped_exception
+          missing = case db.database_type
+                    when :postgres
+                      cause.is_a?(::PG::UndefinedTable)
+                    when :mysql
+                      cause.respond_to?(:error_number) && cause.error_number == 1146
+                    when :sqlite
+                      cause.is_a?(::SQLite3::SQLException) && cause.message.start_with?('no such table: audit_log_archive')
+                    end
+          raise unless missing
+
+          handle_exception(e, level: :debug, handled: true, operation: :audit_archive_presence)
+          false
         end
+        private_class_method :audit_archive_exists?
       end
     end
   end