legion-data 1.10.17 → 1.11.7

data/lib/legion/data/archival.rb

@@ -10,11 +10,16 @@ module Legion
         tasks:            :tasks_archive,
         metering_records: :metering_records_archive
       }.freeze
+      COLUMN_MAP = { id: :original_id, created_at: :original_created_at, updated_at: :original_updated_at }.freeze
+      TASK_COLUMN_MAP = {
+        id: :original_id, created: :original_created_at, updated: :original_updated_at,
+        function_args: :args, results: :result
+      }.freeze
 
       class << self
         include Legion::Logging::Helper
 
-        def archive!(policy: Policy.new, dry_run: false)
+        def archive!(policy: Policy.from_settings, dry_run: false)
           log.info "Archival run started dry_run=#{dry_run} tables=#{policy.tables.size}"
           results = {}
           policy.tables.each do |table_name|
@@ -42,17 +47,17 @@ module Legion
           return 0 unless archive_table && db_ready?(archive_table)
 
           conn = Legion::Data.connection
-          restored = 0
-          conn.transaction do
-            conn[archive_table].where(original_id: ids).each do |row|
-              restore_row = row.except(:id, :archived_at, :original_id, :original_created_at, :original_updated_at)
-              restore_row[:id] = row[:original_id]
-              restore_row[:created_at] = row[:original_created_at]
-              restore_row[:updated_at] = row[:original_updated_at]
-              conn[source_table].insert(restore_row)
-              restored += 1
+          restored = conn.transaction(savepoint: true, **(conn.database_type == :sqlite ? { mode: :immediate } : {})) do
+            dataset = conn[archive_table].where(original_id: ids).order(:original_id)
+            dataset = dataset.for_update unless conn.database_type == :sqlite
+            archived = dataset.all
+            rows = restore_row_values(conn: conn, source: source_table, archived: archived)
+            rows.each do |row|
+              conn[source_table].insert(source_table == :tasks ? row.merge(parent_id: nil, master_id: nil) : row)
             end
-            conn[archive_table].where(original_id: ids).delete
+            rows.each { |row| conn[:tasks].where(id: row[:id]).update(row.slice(:parent_id, :master_id)) } if source_table == :tasks
+            conn[archive_table].where(id: archived.map { |row| row[:id] }).delete
+            rows.size
           end
           log.info "Restored #{restored} row(s) from #{archive_table} -> #{source_table}"
           restored
@@ -82,30 +87,8 @@ module Legion
 
           return { archived: 0, cutoff: cutoff.iso8601 } unless conn&.table_exists?(:tasks) && conn.table_exists?(:tasks_archive)
 
-          candidates = conn[:tasks]
-                       .where(status: %w[completed failed])
-                       .where(Sequel.lit('created < ?', cutoff))
-                       .limit(batch_size)
-
-          count = candidates.count
-          if count.positive?
-            archive_cols = conn.schema(:tasks_archive).to_set(&:first)
-            conn.transaction do
-              candidates.each do |row|
-                archive_row = {
-                  original_id:         row[:id],
-                  status:              row[:status],
-                  relationship_id:     row[:relationship_id],
-                  original_created_at: row[:created],
-                  original_updated_at: row[:updated],
-                  archived_at:         Time.now
-                }
-                archive_row[:archive_reason] = 'completed_task_archival' if archive_cols.include?(:archive_reason)
-                conn[:tasks_archive].insert(archive_row)
-              end
-              conn[:tasks].where(id: candidates.select(:id)).delete
-            end
-          end
+          count = archive_table!(source: :tasks, destination: :tasks_archive, cutoff: cutoff,
+                                 batch_size: batch_size, dry_run: false, statuses: %w[completed failed])
 
           log.info "archive_completed_tasks: archived #{count} tasks (cutoff: #{cutoff.iso8601})"
           { archived: count, cutoff: cutoff.iso8601 }
@@ -135,24 +118,40 @@ module Legion
 
         private
 
-        def archive_table!(source:, destination:, cutoff:, batch_size:, dry_run:)
+        def archive_table!(source:, destination:, cutoff:, batch_size:, dry_run:, statuses: nil)
           conn = Legion::Data.connection
-          candidates = conn[source].where { created_at < cutoff }.limit(batch_size)
-          count = candidates.count
-          return count if dry_run || count.zero?
-
-          conn.transaction do
-            candidates.each do |row|
-              archive_row = row.dup
-              archive_row[:original_id] = archive_row.delete(:id)
-              archive_row[:original_created_at] = archive_row.delete(:created_at)
-              archive_row[:original_updated_at] = archive_row.delete(:updated_at)
-              archive_row[:archived_at] = Time.now
-              conn[destination].insert(archive_row)
+          date_column = Policy::DATE_COLUMN_OVERRIDES.fetch(source.to_s, :created_at)
+          candidates = conn[source].where(Sequel[date_column] < cutoff).order(:id).limit(batch_size)
+          candidates = candidates.where(status: statuses) if statuses
+          if source == :tasks
+            references = conn.from(Sequel.as(:tasks, :dependent_tasks))
+                             .where(Sequel.|({ parent_id: Sequel[:tasks][:id] }, { master_id: Sequel[:tasks][:id] }))
+                             .exclude(id: Sequel[:tasks][:id]).exists
+            candidates = candidates.exclude(references)
+          end
+          return candidates.count if dry_run
+
+          mapping = source == :tasks ? TASK_COLUMN_MAP : COLUMN_MAP
+          conn.transaction(savepoint: true, **(conn.database_type == :sqlite ? { mode: :immediate } : {})) do
+            locked = conn.database_type == :sqlite ? candidates : candidates.for_update
+            selected_ids = locked.select_map(:id)
+            selected = conn[source].where(id: selected_ids).order(:id)
+            selected = selected.exclude(references) if source == :tasks
+            selected = selected.for_update unless conn.database_type == :sqlite
+            rows = selected.all
+            rows.each do |row|
+              archive_row = row.to_h { |column, value| [mapping.fetch(column, column), value] }
+              conn[destination].insert(archive_row.merge(archived_at: Time.now))
             end
-            conn[source].where(id: candidates.select(:id)).delete
+            conn[source].where(id: rows.map { |row| row[:id] }).delete
+            rows.size
           end
-          count
+        end
+
+        def restore_row_values(conn:, source:, archived:)
+          mapping = source == :tasks ? TASK_COLUMN_MAP : COLUMN_MAP
+          columns = conn.schema(source).reject { |_, info| info[:generated] }.map(&:first)
+          archived.map { |row| columns.to_h { |column| [column, row[mapping.fetch(column, column)]] } }
         end
 
         def db_ready?(table)

data/lib/legion/data/archiver.rb

@@ -115,7 +115,8 @@ module Legion
         end
 
         def archive_batch(conn:, table:, cutoff:, batch_size:, now:, storage_backend:)
-          rows = conn[table].where { created_at < cutoff }.limit(batch_size).all
+          candidates = conn[table].where { created_at < cutoff }.limit(batch_size)
+          rows = candidates.all
           return if rows.empty?
 
           batch_id = SecureRandom.uuid

data/lib/legion/data/audit_log_hash_chain.rb

@@ -19,6 +19,7 @@ module Legion
 
         def verify(records)
           previous_hash = GENESIS_HASH
+          length = 0
           records.each do |record|
             return invalid(record, :parent_mismatch) unless value_for(record, :previous_hash).to_s == previous_hash
 
@@ -26,9 +27,10 @@ module Legion
             return invalid(record, :hash_mismatch) unless value_for(record, :record_hash).to_s == expected
 
             previous_hash = expected
+            length += 1
           end
 
-          { valid: true, length: records.size }
+          { valid: true, length: length }
         end
 
         def canonical_payload(record)

data/lib/legion/data/audit_record.rb

@@ -2,6 +2,7 @@
 
 require 'legion/logging/helper'
 require 'digest'
+require 'legion/data/database_lock'
 
 module Legion
   module Data
@@ -20,17 +21,16 @@ module Legion
         # @param metadata     [Hash]    optional structured context (serialised to JSON)
         # @param sign         [Boolean] when true, attempt signing via legion-crypt
         def append(chain_id:, content_type:, content_hash:, metadata: {}, sign: false)
-          return { error: 'db unavailable' } unless db_ready?
+          return { error: 'db unavailable' } unless Legion::Data.connected?
 
-          conn = Legion::Data.connection
-          conn.transaction do
-            parent_hash = latest_chain_hash(conn, chain_id)
+          Legion::Data::DatabaseLock.with_claim(key: { kind: 'audit', stream_id: chain_id }) do
+            parent_hash = latest_chain_hash(chain_id: chain_id)
             ts          = truncate_to_us(Time.now)
             ch          = compute_chain_hash(parent_hash, content_hash, ts, content_type)
             sig         = sign ? sign_record(ch) : nil
             meta_json   = metadata.empty? ? nil : Legion::JSON.dump(metadata)
 
-            id = conn[:audit_records].insert(
+            record = Legion::Data::Model::AuditRecord.create(
               chain_id:     chain_id,
               content_type: content_type,
               content_hash: content_hash,
@@ -41,23 +41,23 @@ module Legion
               created_at:   ts
             )
 
-            log.debug "AuditRecord append: chain=#{chain_id} type=#{content_type} id=#{id}"
-            { id: id, chain_id: chain_id, chain_hash: ch, parent_hash: parent_hash }
+            log.debug "AuditRecord append: chain=#{chain_id} type=#{content_type} id=#{record.id}"
+            { id: record.id, chain_id: chain_id, chain_hash: ch, parent_hash: parent_hash }
           end
         end
 
-        # Walk all records in the chain ordered by creation time and verify that
+        # Walk all records in append order and verify that
         # each record's stored chain_hash matches a freshly computed one.
         #
         # @param chain_id [String]
         # @return [Hash] { valid: Boolean, length: Integer, broken_at: Integer? }
         def verify(chain_id:)
-          return { valid: false, error: 'db unavailable' } unless db_ready?
+          return { valid: false, error: 'db unavailable' } unless Legion::Data.connected?
 
-          records = Legion::Data.connection[:audit_records]
-                                .where(chain_id: chain_id)
-                                .order(:created_at, :id)
-                                .all
+          records = Legion::Data::Model::AuditRecord
+                    .where(chain_id: chain_id)
+                    .order(:id)
+                    .all
 
           prev_hash = GENESIS_HASH
           records.each do |r|
@@ -84,11 +84,11 @@ module Legion
         # @param since    [Time, nil] optional lower bound on created_at
         # @param limit    [Integer]
         def walk(chain_id:, since: nil, limit: 1000)
-          return [] unless db_ready?
+          return [] unless Legion::Data.connected?
 
-          ds = Legion::Data.connection[:audit_records].where(chain_id: chain_id)
+          ds = Legion::Data::Model::AuditRecord.where(chain_id: chain_id)
           ds = ds.where { created_at >= since } if since
-          ds.order(:created_at, :id).limit(limit).all.map { |r| deserialize(r) }
+          ds.order(:id).limit(limit).all.map { |r| deserialize(r) }
         end
 
         # Return records filtered by content_type across all chains.
@@ -97,9 +97,9 @@ module Legion
         # @param since        [Time, nil]
         # @param limit        [Integer]
         def query_by_type(content_type:, since: nil, limit: 100)
-          return [] unless db_ready?
+          return [] unless Legion::Data.connected?
 
-          ds = Legion::Data.connection[:audit_records].where(content_type: content_type)
+          ds = Legion::Data::Model::AuditRecord.where(content_type: content_type)
           ds = ds.where { created_at >= since } if since
           ds.order(Sequel.desc(:created_at)).limit(limit).all.map { |r| deserialize(r) }
         end
@@ -135,12 +135,13 @@ module Legion
           ::Time.at(Rational(us, 1_000_000))
         end
 
-        def latest_chain_hash(conn, chain_id)
-          last = conn[:audit_records]
-                 .select(:chain_hash)
-                 .where(chain_id: chain_id)
-                 .order(Sequel.desc(:created_at), Sequel.desc(:id))
-                 .first
+        def latest_chain_hash(chain_id:)
+          records = Legion::Data::Model::AuditRecord
+                    .select(:chain_hash)
+                    .where(chain_id: chain_id)
+                    .order(Sequel.desc(:id))
+          records = records.for_update unless Legion::Data::Model::AuditRecord.db.database_type == :sqlite
+          last = records.first
           last ? last[:chain_hash] : GENESIS_HASH
         end
 
@@ -166,13 +167,6 @@ module Legion
             created_at:   row[:created_at]
           }
         end
-
-        def db_ready?
-          defined?(Legion::Data) && Legion::Data.connection&.table_exists?(:audit_records)
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :audit_record_db_ready?)
-          false
-        end
       end
     end
   end

data/lib/legion/data/connection.rb

@@ -168,14 +168,14 @@ module Legion
         attr_accessor :sequel
 
         def adapter
-          @adapter ||= Legion::Settings[:data][:adapter]&.to_sym || :sqlite
+          @adapter || Legion::Settings[:data][:adapter].to_sym
         end
 
         def setup
           Legion::Settings[:data][:connected] = false
           @sequel&.disconnect
           @sequel = nil
-          @adapter = Legion::Settings[:data][:adapter]&.to_sym || :sqlite
+          @adapter = Legion::Settings[:data][:adapter].to_sym
           opts = sequel_opts
           log.info("Legion::Data::Connection setup adapter=#{adapter}")
           @fallback_active = false
@@ -189,7 +189,7 @@ module Legion
                       rescue UnresolvedCredentialError => e
                         handle_exception(e, level: :fatal, handled: false, operation: :data_connect)
                         raise
-                      rescue ::Sequel::DatabaseConnectionError => e
+                      rescue StandardError => e
                         raise unless dev_fallback?
 
                         log.error("Legion::Data FALLING BACK TO SQLITE — #{attempted_adapter} network DB connection failed: #{e.message}")
@@ -220,7 +220,7 @@ module Legion
             adapter:            adapter,
             connected:          Legion::Settings[:data][:connected],
             fallback_active:    @fallback_active || false,
-            configured_adapter: Legion::Settings[:data][:adapter]&.to_sym || :sqlite,
+            configured_adapter: Legion::Settings[:data][:adapter].to_sym,
             sequel_alive:       (begin
               !@sequel&.test_connection.nil?
             rescue StandardError => e
@@ -287,16 +287,14 @@ module Legion
         end
 
         def shutdown
-          if @sequel
-            timeout = Legion::Settings[:data][:shutdown_timeout]
-            force_disconnect_pool(timeout: timeout)
-          end
+          @sequel&.disconnect
           @query_file_logger&.close
           @query_file_logger = nil
           @fallback_active = false
           @replica_servers = []
           Legion::Settings[:data][:connected] = false
           log.info 'Legion::Data connection closed'
+          true
         end
 
         def reconnect_with_fresh_creds
@@ -317,6 +315,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
@@ -354,7 +353,7 @@ module Legion
           return creds if adapter == :sqlite
           return creds unless defined?(Legion::Crypt::TLS)
 
-          tls_settings = data_tls_settings
+          tls_settings = Legion::Settings[:data][:tls]
           return creds unless tls_settings[:enabled] == true
 
           tls = Legion::Crypt::TLS.resolve(tls_settings, port: port)
@@ -402,15 +401,6 @@ module Legion
 
         private
 
-        def data_tls_settings
-          return {} unless defined?(Legion::Settings)
-
-          Legion::Settings[:data][:tls] || {}
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :data_tls_settings)
-          {}
-        end
-
         def log_connection_info
           if adapter == :sqlite
             log.info "Connected to SQLite at #{sqlite_path}"
@@ -441,30 +431,8 @@ 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'
+          path = Legion::Settings[:data][:creds][:database]
           return path if File.absolute_path?(path)
 
           base_dir = File.expand_path('~/.legionio/data')
@@ -610,7 +578,7 @@ module Legion
             stats[pragma.to_sym] = val unless val.nil?
           end
 
-          db_path = Legion::Settings[:data][:creds][:database] || 'legionio.db'
+          db_path = Legion::Settings[:data][:creds][:database]
           stats[:file_size] = File.size(db_path) if File.exist?(db_path)
           stats[:database_size_bytes] = (stats[:page_size].to_i * stats[:page_count].to_i) if stats[:page_size] && stats[:page_count]
           stats
@@ -698,15 +666,14 @@ module Legion
 
           install_auth_failure_hook
         rescue StandardError => e
-          handle_exception(e, level: :error, handled: false, operation: :configure_extensions, adapter: adapter)
-          raise
+          handle_exception(e, level: :warn, handled: true, operation: :configure_extensions, adapter: adapter)
+          raise e
         end
 
         def install_auth_failure_hook
           Legion::Data::AuthFailureHandler.install(@sequel)
         rescue StandardError => e
-          handle_exception(e, level: :error, handled: false, operation: :install_auth_failure_hook)
-          raise
+          handle_exception(e, level: :warn, handled: true, operation: :install_auth_failure_hook)
         end
 
         def build_data_logger

data/lib/legion/data/database_lock.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Data
+    module DatabaseLock
+      def self.with_claim(key:)
+        database = Legion::Data::Model::AppendClaim.db
+        options = { savepoint: true }
+        options[:mode] = :immediate if database.database_type == :sqlite
+        database.transaction(**options) do
+          claim = Legion::Data::Model::AppendClaim.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/event_store.rb

@@ -2,6 +2,7 @@
 
 require 'legion/logging/helper'
 require 'digest'
+require 'legion/data/database_lock'
 
 module Legion
   module Data
@@ -20,12 +21,11 @@ module Legion
         def append(stream:, type:, data: {}, metadata: {})
           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
+          database = Legion::Data::Model::GovernanceEvent.db
+          Legion::Data::DatabaseLock.with_claim(key: { kind: 'event', stream_id: stream }) do
+            records = Legion::Data::Model::GovernanceEvent.where(stream_id: stream).order(Sequel.desc(:sequence_number))
+            records = records.for_update unless database.database_type == :sqlite
+            last = records.first
 
             seq = (last&.[](:sequence_number) || 0) + 1
             prev_hash = last&.[](:event_hash) || ('0' * 64)
@@ -34,7 +34,7 @@ module Legion
             metadata_json = Legion::JSON.dump(metadata)
             event_hash = compute_hash(stream, seq, type, data_json, metadata_json, prev_hash)
 
-            conn[:governance_events].insert(
+            Legion::Data::Model::GovernanceEvent.create(
               stream_id:       stream,
               event_type:      type,
               sequence_number: seq,
@@ -53,7 +53,7 @@ module Legion
         def read_stream(stream, since: nil)
           return [] unless db_ready?
 
-          ds = Legion::Data.connection[:governance_events].where(stream_id: stream)
+          ds = Legion::Data::Model::GovernanceEvent.where(stream_id: stream)
           ds = ds.where { created_at >= since } if since
           ds.order(:sequence_number).all.map { |e| deserialize(e) }
         end
@@ -61,7 +61,7 @@ module Legion
         def read_by_type(type, since: nil, limit: 100)
           return [] unless db_ready?
 
-          ds = Legion::Data.connection[:governance_events].where(event_type: type)
+          ds = Legion::Data::Model::GovernanceEvent.where(event_type: type)
           ds = ds.where { created_at >= since } if since
           ds.order(Sequel.desc(:created_at)).limit(limit).all.map { |e| deserialize(e) }
         end
@@ -69,10 +69,10 @@ module Legion
         def verify_chain(stream)
           return { valid: false, error: 'db unavailable' } unless db_ready?
 
-          events = Legion::Data.connection[:governance_events]
-                               .where(stream_id: stream)
-                               .order(:sequence_number)
-                               .all
+          events = Legion::Data::Model::GovernanceEvent
+                   .where(stream_id: stream)
+                   .order(:sequence_number)
+                   .all
 
           prev_hash = '0' * 64
           legacy_hashes = 0
@@ -128,7 +128,7 @@ module Legion
         end
 
         def db_ready?
-          defined?(Legion::Data) && Legion::Data.connection&.table_exists?(:governance_events)
+          Legion::Data.connected? && Legion::Data::Model::GovernanceEvent.db.table_exists?(:governance_events)
         rescue StandardError => e
           handle_exception(e, level: :warn, handled: true, operation: :event_store_db_ready?)
           false

data/lib/legion/data/extract.rb

@@ -102,16 +102,14 @@ module Legion
         end
 
         def persist_step_timings(extract_id, timings)
-          return unless defined?(Legion::Data)
+          return unless Legion::Data.connected?
 
-          connection = Legion::Data.connection
-          return unless connection&.table_exists?(:extract_step_timings)
+          existing_steps = Legion::Data::Model::ExtractStepTiming.where(extract_id: extract_id).select_map(:name)
+          timings.each do |timing|
+            next if existing_steps.include?(timing[:name])
 
-          existing_steps = connection[:extract_step_timings].where(extract_id: extract_id).select_map(:name)
-          rows = timings.reject { |timing| existing_steps.include?(timing[:name]) }.map do |timing|
-            timing.merge(extract_id: extract_id)
+            Legion::Data::Model::ExtractStepTiming.create(timing.merge(extract_id: extract_id))
           end
-          connection[:extract_step_timings].multi_insert(rows) unless rows.empty?
         rescue StandardError => e
           handle_exception(e, level: :warn, handled: true, operation: :persist_extract_step_timings,
                             extract_id: extract_id)

data/lib/legion/data/helper.rb

@@ -20,7 +20,7 @@ module Legion
       end
 
       def data_connected?
-        defined?(Legion::Settings) && Legion::Settings[:data][:connected]
+        Legion::Settings[:data][:connected]
       end
 
       def data_connection

data/lib/legion/data/local.rb

@@ -17,7 +17,7 @@ module Legion
         def setup(database: nil, **)
           return if @connected
 
-          db_file = database || local_settings[:database] || 'legionio_local.db'
+          db_file = database || Legion::Settings[:data][:local][:database]
           unless File.absolute_path?(db_file)
             base_dir = File.expand_path('~/.legionio')
             FileUtils.mkdir_p(base_dir)
@@ -26,19 +26,19 @@ module Legion
           @db_path = db_file
 
           sqlite_defaults = Legion::Data::Connection::ADAPTER_DEFAULTS.fetch(:sqlite, {})
-          data = defined?(Legion::Settings) ? Legion::Settings[:data] : {}
+          data = Legion::Settings[:data]
           opts = { adapter: :sqlite, database: db_file }
           Legion::Data::Connection::ADAPTER_KEYS.fetch(:sqlite, []).each do |key|
             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[:timeout] = data[:timeout].nil? ? 30_000 : data[:timeout]
           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]
+          if Legion::Settings[:data][:local][:query_log]
             log_path = File.join(Legion::Data::Connection::QUERY_LOG_DIR, 'data-local-query.log')
             @query_file_logger = Legion::Data::Connection::QueryFileLogger.new(log_path)
             opts[:logger]          = @query_file_logger
@@ -99,7 +99,7 @@ module Legion
             connected:             true,
             adapter:               :sqlite,
             path:                  @db_path,
-            query_log:             local_settings[:query_log] || false,
+            query_log:             Legion::Settings[:data][:local][:query_log],
             query_log_path:        @query_file_logger&.path,
             registered_migrations: registered_migrations.keys
           }
@@ -135,7 +135,7 @@ module Legion
         private
 
         def run_migrations
-          return unless local_settings.dig(:migrations, :auto_migrate) != false
+          return unless Legion::Settings[:data][:local][:migrations][:auto_migrate]
 
           registered_migrations.each do |name, path|
             run_single_migration(name, path)
@@ -143,7 +143,7 @@ module Legion
         end
 
         def run_single_migration(name, path)
-          return unless local_settings.dig(:migrations, :auto_migrate) != false
+          return unless Legion::Settings[:data][:local][:migrations][:auto_migrate]
           return unless File.directory?(path)
 
           table = :"schema_migrations_#{name}"
@@ -153,12 +153,6 @@ module Legion
           raise
         end
 
-        def local_settings
-          return {} unless defined?(Legion::Settings)
-
-          Legion::Settings[:data]&.dig(:local) || {}
-        end
-
         def build_local_logger
           tagged = if defined?(Legion::Logging::TaggedLogger) && respond_to?(:tagged_logger_settings, true)
                      Legion::Logging::TaggedLogger.new(
@@ -181,17 +175,11 @@ module Legion
         end
 
         def resolved_sql_log_level
-          (local_settings[:sql_log_level] || Legion::Settings[:data][:sql_log_level] || 'debug').to_sym
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :resolved_sql_log_level)
-          :debug
+          Legion::Settings[:data][:local].fetch(:sql_log_level, Legion::Settings[:data][:sql_log_level]).to_sym
         end
 
         def resolved_log_warn_duration
-          local_settings[:log_warn_duration] || Legion::Settings[:data][:log_warn_duration]
-        rescue StandardError => e
-          handle_exception(e, level: :warn, handled: true, operation: :resolved_log_warn_duration)
-          nil
+          Legion::Settings[:data][:local].fetch(:log_warn_duration, Legion::Settings[:data][:log_warn_duration])
         end
       end
     end