legion-data 1.10.28 → 1.11.7

data/lib/legion/data/connection.rb

@@ -2,7 +2,6 @@
 
 require 'legion/logging/helper'
 require 'legion/data/auth_failure_handler'
-require 'legion/data/connection_pool'
 
 require 'fileutils'
 require 'sequel'
@@ -166,52 +165,43 @@ module Legion
       class << self
         include Legion::Logging::Helper
 
-        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
+        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
           @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
+          @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
           @replica_servers = @sequel.opts.fetch(:servers, {}).keys
           log_connection_info
           configure_extensions
@@ -230,8 +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,
-            shutdown:           @sequel&.pool&.shutdown_status,
+            configured_adapter: Legion::Settings[:data][:adapter].to_sym,
             sequel_alive:       (begin
               !@sequel&.test_connection.nil?
             rescue StandardError => e
@@ -298,26 +287,14 @@ module Legion
         end
 
         def shutdown
-          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
-          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
+          @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
@@ -376,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)
@@ -424,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}"
@@ -464,7 +432,7 @@ module Legion
         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

@@ -3,11 +3,12 @@
 module Legion
   module Data
     module DatabaseLock
-      def self.with_claim(database:, table:, key:)
+      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 = database[table].where(key)
+          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)

data/lib/legion/data/event_store.rb

@@ -21,11 +21,10 @@ module Legion
         def append(stream:, type:, data: {}, metadata: {})
           return { error: 'db unavailable' } unless db_ready?
 
-          conn = Legion::Data.connection
-          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
+          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
@@ -35,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,
@@ -54,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
@@ -62,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
@@ -70,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
@@ -129,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

data/lib/legion/data/migration.rb

@@ -16,6 +16,30 @@ module Legion
             return
           end
 
+          if connection.database_type == :postgres
+            role_state = connection.fetch(<<~SQL).first
+              SELECT session_user,
+                     current_user,
+                     current_setting('role') AS active_role,
+                     to_regrole('legionio_migrator')::text AS migrator_role,
+                     CASE
+                       WHEN to_regrole('legionio_migrator') IS NULL THEN NULL
+                       ELSE pg_has_role(session_user, 'legionio_migrator', 'MEMBER')
+                     END AS migrator_member,
+                     CASE
+                       WHEN to_regrole('legionio_migrator') IS NULL THEN NULL
+                       ELSE pg_has_role(session_user, 'legionio_migrator', 'SET')
+                     END AS migrator_set,
+                     has_schema_privilege(session_user, 'public', 'CREATE') AS session_create,
+                     has_schema_privilege(current_user, 'public', 'CREATE') AS current_create,
+                     CASE
+                       WHEN to_regrole('legionio_migrator') IS NULL THEN NULL
+                       ELSE has_schema_privilege('legionio_migrator', 'public', 'CREATE')
+                     END AS migrator_create
+            SQL
+            Legion::Logging.unknown "migration role state=#{role_state.inspect}"
+          end
+
           Legion::Settings[:data][:migrations][:version] = Sequel::Migrator.run(connection, path, **)
           log.info("Legion::Data::Migration ran successfully to version #{Legion::Settings[:data][:migrations][:version]}")
           Legion::Settings[:data][:migrations][:ran] = true

data/lib/legion/data/migrations/139_create_task_logs.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table(:task_logs) do
+      primary_key :id
+      String :uuid, size: 36, null: false, unique: true
+      String :access_scope, size: 20, null: false, default: 'global', index: true
+      foreign_key :identity_principal_id, :identity_principals, null: true, on_delete: :set_null, on_update: :cascade
+      foreign_key :identity_id, :identities, null: true, on_delete: :set_null, on_update: :cascade
+      String :identity_canonical_name, size: 255, null: true, index: true
+      foreign_key :task_id, :tasks, null: true, on_delete: :set_null, on_update: :cascade
+      foreign_key :node_id, :nodes, null: true, on_delete: :set_null, on_update: :cascade
+      foreign_key :function_id, :functions, null: true, on_delete: :set_null, on_update: :cascade
+      String :entry, text: true, null: false
+      DateTime :created, null: false, default: Sequel::CURRENT_TIMESTAMP
+      DateTime :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      DateTime :inserted_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      DateTime :updated_at, null: true
+      index :identity_principal_id
+      index :task_id
+      index :node_id
+      index :function_id
+      index :created
+    end
+  end
+end

data/lib/legion/data/model.rb

@@ -11,9 +11,9 @@ module Legion
         attr_reader :loaded_models
 
         def models
-          %w[extension function relationship chain task runner node setting digital_worker
+          %w[extension function relationship chain task task_log runner node setting digital_worker
              apollo_entry apollo_relation apollo_expertise apollo_access_log audit_log
-             audit_record extract_step_timing
+             audit_record governance_event append_claim data_archive extract_step_timing
              identity/identity identity/principal identity/providers identity/group
              identity/group_memberships identity/audit_log
              apollo/entries apollo/relation apollo/access_log apollo/expertise
@@ -30,10 +30,7 @@ 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
 
@@ -52,22 +49,6 @@ 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/append_claim.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Legion
+  module Data
+    module Model
+      class AppendClaim < Sequel::Model(:append_claims)
+      end
+    end
+  end
+end

data/lib/legion/data/models/data_archive.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Legion
+  module Data
+    module Model
+      class DataArchive < Sequel::Model(:data_archive)
+      end
+    end
+  end
+end

data/lib/legion/data/models/governance_event.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Legion
+  module Data
+    module Model
+      class GovernanceEvent < Sequel::Model(:governance_events)
+      end
+    end
+  end
+end

data/lib/legion/data/models/task.rb

@@ -2,15 +2,15 @@
 
 require 'digest'
 require 'legion/json'
+require 'legion/data/task/status'
 require 'time'
 
 module Legion
   module Data
     module Model
       class Task < Sequel::Model
-        TERMINAL_STATUSES = %w[
-          completed complete failed error cancelled canceled timeout timed_out
-        ].freeze
+        TERMINAL_STATUSES = (Legion::Data::Task::Status::TERMINAL_STATUSES +
+                             Legion::Data::Task::Status::LEGACY_TERMINAL_STATUSES).freeze
 
         many_to_one :function
         many_to_one :relationship
@@ -60,9 +60,9 @@ module Legion
           when Array
             value.map { |item| canonical_payload(item) }
           when Time
-            value.utc.iso8601(6)
+            value.getutc.iso8601(6)
           when DateTime
-            value.to_time.utc.iso8601(6)
+            value.to_time.getutc.iso8601(6)
           else
             value
           end

data/lib/legion/data/models/task_log.rb

@@ -1,11 +1,27 @@
 # frozen_string_literal: true
 
+require 'securerandom'
+
 module Legion
   module Data
     module Model
       class TaskLog < Sequel::Model
         many_to_one :task
         many_to_one :node
+        many_to_one :function
+
+        def self.insert(values)
+          create(values).id
+        end
+
+        def before_create
+          self[:uuid] ||= SecureRandom.uuid
+          self[:created] ||= Time.now
+          self[:created] = self[:created].getlocal if self[:created].is_a?(Time)
+          self[:created_at] ||= self[:created]
+          self[:created_at] = self[:created_at].getlocal if self[:created_at].is_a?(Time)
+          super
+        end
       end
     end
   end

data/lib/legion/data/settings.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/logging/helper'
+require 'legion/settings'
 
 module Legion
   module Data
@@ -76,10 +77,6 @@ module Legion
           keepalives_count:              3,
           tcp_user_timeout:              15_000,
 
-          # Shutdown: max seconds to wait for checked-out connections to return before
-          # force-disconnecting them.
-          shutdown_timeout:              5,
-
           # Adapter-specific (nil = use adapter built-in default)
           connect_timeout:               nil,
           read_timeout:                  nil,
@@ -95,6 +92,7 @@ module Legion
 
           # Grouped settings
           creds:                         creds,
+          tls:                           { enabled: false },
           cache:                         cache,
           migrations:                    migrations,
           models:                        models,
@@ -141,7 +139,10 @@ module Legion
       def self.archival
         {
           retention_days:  90,
+          warm_after_days: 7,
+          cold_after_days: 90,
           batch_size:      1000,
+          tables:          %w[tasks metering_records],
           storage_backend: nil
         }
       end
@@ -158,8 +159,4 @@ module Legion
   end
 end
 
-begin
-  Legion::Settings.merge_settings('data', Legion::Data::Settings.default) if Legion.const_defined?('Settings', false)
-rescue StandardError => e
-  Legion::Data::Settings.handle_exception(e, level: :fatal, operation: :merge_settings)
-end
+Legion::Settings.register_library(:data, Legion::Data::Settings.default)