legion-data 1.5.3 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 827684e2e0f37c3fb4921f722f6a1053f0585384cad6e3cf89cf6d75c78329f3
-  data.tar.gz: eb9436c4df397ed39e66e4e4cb24d26afc14f0f8e33153d1381c385eddba7a7a
+  metadata.gz: 7d7162dcd4c845698a6c47a4a39f5c70b9da51a5bac097ec9f631934d31716ac
+  data.tar.gz: 13af3da2d55afaec4c54ad77ba97d23d7ebaa35789b22bbb9f6cbe1049751191
 SHA512:
-  metadata.gz: d365a0142a850ca4793e684932dcb9dd7321d8518533032c98738d4af155be69202339814a3a3ece4abc309f29411dfe59417aa403f55fa03645dcf84674e5c8
-  data.tar.gz: f26235a9b780c805c49119f7602b79a4b7d0d5e2f059403051455b9e5f47d4b6e16e7772b11d197b154f064db4d1bb88332e83cd91e944bff5b47a90f92ab0ba
+  metadata.gz: 8a67d01180e7ec8df32339a2e7bfe3a28f972176d2ac921fbaebc78c3194d098e9d11ddc01fb84db65cda53aaa42ee488c928d68583cecacdefe78eefbe313ba
+  data.tar.gz: 7d4f7e00c415d7af0975d575617221d0c010fb3cff4d4c1fae7c4562ee817fd135236ba7b466048fddd8b1c5d06eb84029a3da61c6f900055fab225861efe453

data/.github/CODEOWNERS

@@ -0,0 +1,7 @@
+# Auto-generated from team-config.yml
+# Team: core
+#
+# To apply: scripts/apply-codeowners.sh legion-data
+
+* @LegionIO/maintainers
+* @LegionIO/core

data/.github/dependabot.yml

@@ -0,0 +1,18 @@
+version: 2
+updates:
+  - package-ecosystem: bundler
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"
+  - package-ecosystem: github-actions
+    directory: /
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 5
+    labels:
+      - "type:dependencies"

data/.github/workflows/ci.yml

@@ -3,14 +3,32 @@ on:
   push:
     branches: [main]
   pull_request:
+  schedule:
+    - cron: '0 9 * * 1'
 
 jobs:
   ci:
     uses: LegionIO/.github/.github/workflows/ci.yml@main
 
+  lint:
+    uses: LegionIO/.github/.github/workflows/lint-patterns.yml@main
+
+  security:
+    uses: LegionIO/.github/.github/workflows/security-scan.yml@main
+
+  version-changelog:
+    uses: LegionIO/.github/.github/workflows/version-changelog.yml@main
+
+  dependency-review:
+    uses: LegionIO/.github/.github/workflows/dependency-review.yml@main
+
+  stale:
+    if: github.event_name == 'schedule'
+    uses: LegionIO/.github/.github/workflows/stale.yml@main
+
   release:
-    needs: ci
+    needs: [ci, lint]
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
     uses: LegionIO/.github/.github/workflows/release.yml@main
     secrets:
-      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.rubocop.yml

@@ -55,3 +55,7 @@ Naming/VariableNumber:
 
 Metrics/ParameterLists:
   Max: 8
+
+Style/FileOpen:
+  Exclude:
+    - 'lib/legion/data/connection.rb'

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Legion::Data Changelog
 
+## [1.6.0] - 2026-03-25
+
+### Fixed
+- **Connection pool starvation**: `max_connections`, `pool_timeout`, `preconnect`, and all other Sequel options were never forwarded to `Sequel.connect` — pool was stuck at Sequel's default of 4 connections regardless of settings. 5+ second "slow queries" in daemon logs were actually pool wait time (5s `pool_timeout`) + fast query (~19ms). Now all configured options flow through properly.
+- **Local DB had same issue**: `Legion::Data::Local.setup` used bare `Sequel.sqlite(path)` with no options. Now forwards SQLite adapter options (`timeout`, `readonly`, `disable_dqs`) via `Sequel.connect`.
+
+### Changed
+- **Flat settings structure**: all connection settings now live directly on `data.*` instead of nested `data.connection.*` or `data.adapter_opts.*`. Users configure `data.max_connections`, `data.pool_timeout`, `data.connect_timeout`, etc. regardless of adapter — legion-data figures out which options apply.
+- Default `max_connections` raised from 10 to 25 (was never applied before anyway)
+- Default `preconnect` set to `'concurrently'` (warm pool at boot)
+- Default `pool_timeout` remains 5s (now actually enforced)
+- Per-adapter defaults applied at connection time via `ADAPTER_DEFAULTS`: sqlite (`timeout: 5000`, `readonly: false`, `disable_dqs: true`), postgres (`connect_timeout: 20`, `sslmode: 'disable'`), mysql2 (`connect_timeout: 120`, `encoding: 'utf8mb4'`)
+- Adapter-specific settings (`connect_timeout`, `read_timeout`, `write_timeout`, `encoding`, `sql_mode`, `sslmode`, `sslrootcert`, `search_path`, `timeout`, `readonly`, `disable_dqs`) default to nil in settings and resolve to adapter built-in defaults — only forwarded when the current adapter supports them
+
+### Added
+- `GENERIC_KEYS`, `ADAPTER_KEYS`, `ADAPTER_DEFAULTS` constants on `Connection` for option whitelisting and defaults
+- Connection health extensions (non-SQLite only): `connection_validator` (pings idle connections, default timeout 600s) and `connection_expiration` (retires old connections, default timeout 14400s) — both enabled by default via `data.connection_validation` and `data.connection_expiration`
+- `Legion::Data::Connection.stats` — comprehensive connection metrics: pool stats (type, size, available, in_use, waiting), tuning snapshot, and adapter-specific database stats (postgres: `pg_stat_activity`, `pg_database_size`, server settings; sqlite: PRAGMAs, file size; mysql: `information_schema`, `SHOW STATUS`)
+- `Legion::Data::Connection.pool_stats` — works across all Sequel pool types (`timed_queue`, `threaded`, `single`, sharded variants)
+- `Legion::Data::Local.stats` — local SQLite metrics: PRAGMAs, file size, database size, registered migrations
+- `Legion::Data.stats` — combined `{ shared: Connection.stats, local: Local.stats }` for `/api/stats` endpoint
+- `data.query_log` flag (default `false`): when enabled, pipes ALL SQL queries to `~/.legionio/logs/data-shared-query.log` (shared) or `data-local-query.log` (local) via dedicated `QueryFileLogger` — isolated from the main `Legion::Logging` domain so debug query floods don't pollute application logs
+- `Legion::Data::Connection::QueryFileLogger` — thread-safe file-based logger with timestamped entries, used by both shared and local query log modes
+- `Legion::Data::Connection::SlowQueryLogger` — wraps tagged `Legion::Logging::Logger`, prefixes warn-level messages with `[slow-query]`
+- `data.local.query_log` flag (default `false`): same as above but for the local SQLite connection
+- **StaticCache infrastructure** for lookup models: `Legion::Data.setup_static_cache` applies `Sequel::Plugins::StaticCache` to `Extension`, `Runner`, `Function` — loads entire tables into frozen in-memory hashes for zero-DB-hit reads. Enabled via `data.cache.static_cache: true` (default `false`).
+- `Legion::Data.reload_static_cache` — refreshes in-memory static cache after hot-loading new extensions
+- **External cache infrastructure**: `Legion::Data.setup_external_cache` applies `Sequel::Plugins::Caching` to `Relationship` (ttl 10s), `Node` (ttl 10s), `Setting` (ttl configurable) via `Legion::Cache` backend. Activates when `data.cache.auto_enable` is true and `Legion::Cache` is loaded.
+- `data.cache.static_cache` setting (default `false`)
+
 ## [1.5.3] - 2026-03-25
 
 ### Added

data/CLAUDE.md

@@ -8,7 +8,7 @@
 Manages persistent database storage for the LegionIO framework. Supports SQLite (default), MySQL, and PostgreSQL via Sequel ORM. Provides automatic schema migrations and data models for extensions, functions, runners, nodes, tasks, settings, digital workers, task relationships, Apollo shared knowledge tables (PostgreSQL only), tenants, webhooks, audit log, and archive tables. Also provides a parallel local SQLite database (`Legion::Data::Local`) for agentic cognitive state persistence.
 
 **GitHub**: https://github.com/LegionIO/legion-data
-**Version**: 1.4.12
+**Version**: 1.6.0
 **License**: Apache-2.0
 
 ## Supported Databases
@@ -28,13 +28,22 @@ Legion::Data (singleton module)
 ├── .setup             # Connect, migrate, load models, setup cache, setup local
 ├── .connection        # Sequel database handle (shared/central)
 ├── .local             # Legion::Data::Local accessor
+├── .stats             # Combined { shared: Connection.stats, local: Local.stats }
+├── .reload_static_cache  # Refresh in-memory StaticCache after hot-loading extensions
 ├── .shutdown          # Close both connections
 │
 ├── Connection         # Sequel database connection management (shared)
 │   ├── .adapter       # Reads from settings (sqlite, mysql2, postgres)
 │   ├── .setup         # Establish connection (dev_mode fallback to SQLite if network DB unreachable)
 │   ├── .sequel        # Raw Sequel::Database accessor
-│   └── .shutdown      # Close connection
+│   ├── .stats         # Pool metrics, tuning snapshot, adapter-specific DB stats
+│   ├── .pool_stats    # Connection pool usage (size, available, in_use, waiting)
+│   ├── .shutdown      # Close connection
+│   ├── GENERIC_KEYS   # Pool options forwarded to Sequel (:max_connections, :pool_timeout, etc.)
+│   ├── ADAPTER_KEYS   # Per-adapter option whitelists (sqlite, postgres, mysql2)
+│   ├── ADAPTER_DEFAULTS # Built-in defaults per adapter when user hasn't set a value
+│   ├── SlowQueryLogger    # Wraps Legion::Logging with [slow-query] prefix for Sequel warn
+│   └── QueryFileLogger    # Thread-safe file logger for query_log mode (~/.legionio/logs/)
 │
 ├── Local              # Local SQLite database for agentic cognitive state
 │   ├── .setup         # Lazy init — creates legionio_local.db on first access
@@ -43,6 +52,7 @@ Legion::Data (singleton module)
 │   ├── .db_path       # Path to the local SQLite file
 │   ├── .model(:table) # Create Sequel::Model bound to local connection
 │   ├── .register_migrations(name:, path:) # Extensions register their migration dirs
+│   ├── .stats         # Local SQLite metrics (PRAGMAs, file size, registered migrations)
 │   ├── .shutdown      # Close local connection
 │   └── .reset!        # Clear all state (testing)
 │
@@ -105,12 +115,16 @@ Legion::Data (singleton module)
 ### Key Design Patterns
 
 - **Two-Database Architecture**: Shared (MySQL/PG/SQLite) for control plane data + Local (always SQLite) for agentic cognitive state. Two files, always separate, no cross-database joins.
-- **Adapter-Driven**: `Connection.adapter` reads from settings; SQLite uses `Sequel.sqlite(path)`, others use `Sequel.connect`
+- **Adapter-Driven**: `Connection.adapter` reads from settings; all adapters (including SQLite) use `Sequel.connect` so all options flow through uniformly
+- **Flat Settings**: all connection/pool/adapter options live directly on `data.*` — legion-data resolves which options apply to the current adapter via `ADAPTER_KEYS` whitelists
+- **Per-Adapter Defaults**: `ADAPTER_DEFAULTS` provides built-in defaults (e.g., sqlite timeout 5000, postgres connect_timeout 20) when user hasn't set a value; nil in settings means "use adapter default"
 - **Dev Mode Fallback**: When `dev_mode: true` and network DB unreachable, shared connection falls back to SQLite (`legionio.db`) with warning log
+- **Connection Health**: `connection_validator` (pings idle connections) and `connection_expiration` (retires old connections) extensions auto-enabled for non-SQLite adapters
 - **Cross-DB Migrations**: Shared migrations use IntegerMigrator (Sequel DSL), local migrations use TimestampMigrator (per-extension registration)
 - **Auto-Migration**: Runs Sequel migrations on startup (`auto_migrate: true` by default)
 - **Sequel ORM**: Shared models are `Sequel::Model` subclasses (inherit global connection). Local models use `Legion::Data::Local.model(:table)` (explicit connection binding).
-- **Optional Caching**: `setup_cache` checks for `Legion::Cache` presence but Sequel model caching is currently disabled (code is commented out, pending implementation)
+- **Two-Tier Caching**: StaticCache (in-process frozen hash, no external deps) for lookup models (Extension, Runner, Function) + external Caching plugin (via `Legion::Cache` — Redis/Memcached/Memory) for dynamic models (Relationship, Node, Setting). Both disabled by default.
+- **Query Log Isolation**: `query_log` flag pipes all SQL to dedicated files (`~/.legionio/logs/data-shared-query.log`, `data-local-query.log`) via `QueryFileLogger` — completely isolated from the `Legion::Logging` domain
 - **Cryptographic Erasure**: Deleting `legionio_local.db` is a hard guarantee — no residual data. Used by `lex-privatecore`.
 - **CLI Executable**: Ships with `legionio_migrate` executable in `exe/` for running database migrations standalone
 
@@ -123,14 +137,40 @@ Legion::Data (singleton module)
   "dev_mode": false,
   "dev_fallback": true,
   "connect_on_start": true,
-  "connection": {
-    "log": false,
-    "log_connection_info": false,
-    "log_warn_duration": 1,
-    "sql_log_level": "debug",
-    "max_connections": 10,
-    "preconnect": false
-  },
+
+  "max_connections": 25,
+  "pool_timeout": 5,
+  "preconnect": "concurrently",
+  "single_threaded": false,
+  "test": true,
+  "name": null,
+
+  "log": false,
+  "query_log": false,
+  "log_connection_info": false,
+  "log_warn_duration": 1,
+  "sql_log_level": "debug",
+
+  "connection_validation": true,
+  "connection_validation_timeout": 600,
+  "connection_expiration": true,
+  "connection_expiration_timeout": 14400,
+
+  "connect_timeout": null,
+  "read_timeout": null,
+  "write_timeout": null,
+  "encoding": null,
+  "sql_mode": null,
+  "sslmode": null,
+  "sslrootcert": null,
+  "search_path": null,
+  "timeout": null,
+  "readonly": null,
+  "disable_dqs": null,
+
+  "read_replica_url": null,
+  "replicas": [],
+
   "creds": {
     "database": "legionio.db"
   },
@@ -147,6 +187,7 @@ Legion::Data (singleton module)
   "local": {
     "enabled": true,
     "database": "legionio_local.db",
+    "query_log": false,
     "migrations": {
       "auto_migrate": true
     }
@@ -154,11 +195,36 @@ Legion::Data (singleton module)
   "cache": {
     "connected": false,
     "auto_enable": false,
+    "static_cache": false,
     "ttl": 60
+  },
+  "archival": {
+    "retention_days": 90,
+    "batch_size": 1000,
+    "storage_backend": null
   }
 }
 ```
 
+Settings are **flat** — all pool, logging, health, and adapter-specific options live directly on `data.*`. Adapter-specific options (e.g., `connect_timeout`, `encoding`, `sslmode`) default to `null` and resolve to per-adapter built-in defaults at connection time:
+
+| Adapter | Applied Options | Defaults |
+|---------|----------------|----------|
+| sqlite | `timeout`, `readonly`, `disable_dqs` | `timeout: 5000`, `readonly: false`, `disable_dqs: true` |
+| postgres | `connect_timeout`, `sslmode`, `sslrootcert`, `search_path` | `connect_timeout: 20`, `sslmode: "disable"` |
+| mysql2 | `connect_timeout`, `read_timeout`, `write_timeout`, `encoding`, `sql_mode` | `connect_timeout: 120`, `encoding: "utf8mb4"` |
+
+### Caching
+
+Two independent caching tiers, both disabled by default:
+
+| Tier | Setting | Models | Backend | Use Case |
+|------|---------|--------|---------|----------|
+| **StaticCache** | `data.cache.static_cache: true` | Extension, Runner, Function | In-process frozen Ruby hash | Zero-DB-hit reads for lookup tables. No external deps. Call `Legion::Data.reload_static_cache` after hot-loading extensions. |
+| **External Cache** | `data.cache.auto_enable: true` + `Legion::Cache` loaded | Relationship (10s), Node (10s), Setting (ttl) | `Legion::Cache` (Redis/Memcached/Memory) | Cross-process cache sharing for dynamic models. Requires `legion-cache` gem connected. |
+
+For thousands of agents, enable `static_cache` first — biggest impact, zero dependencies. External cache only adds value when you need cross-process sharing via Redis/Memcached.
+
 Per-adapter credential defaults are defined in `Settings::CREDS`:
 - **sqlite**: `{ database: "legionio.db" }`
 - **mysql2**: `{ username: "legion", password: "legion", database: "legionio", host: "127.0.0.1", port: 3306 }`

data/lib/legion/data/connection.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'sequel'
 
 module Legion
@@ -7,6 +8,22 @@ module Legion
     module Connection
       ADAPTERS = %i[sqlite mysql2 postgres].freeze
 
+      GENERIC_KEYS = %i[max_connections pool_timeout preconnect single_threaded test name].freeze
+
+      ADAPTER_KEYS = {
+        sqlite:   %i[timeout readonly disable_dqs],
+        postgres: %i[connect_timeout sslmode sslrootcert search_path],
+        mysql2:   %i[connect_timeout read_timeout write_timeout encoding sql_mode]
+      }.freeze
+
+      ADAPTER_DEFAULTS = {
+        sqlite:   { timeout: 5000, readonly: false, disable_dqs: true },
+        postgres: { connect_timeout: 20, sslmode: 'disable' },
+        mysql2:   { connect_timeout: 120, encoding: 'utf8mb4' }
+      }.freeze
+
+      QUERY_LOG_DIR = File.expand_path('~/.legionio/logs').freeze
+
       # Wraps a tagged Legion::Logging::Logger for Sequel's logger interface.
       # Prefixes warn-level messages with [slow-query] since Sequel uses warn
       # for queries exceeding log_warn_duration.
@@ -32,6 +49,52 @@ module Legion
         end
       end
 
+      # File-based query logger that writes all SQL to a dedicated log file.
+      # Isolated from the main Legion::Logging domain.
+      class QueryFileLogger
+        attr_reader :path
+
+        def initialize(path)
+          @path = path
+          dir = File.dirname(path)
+          FileUtils.mkdir_p(dir)
+          FileUtils.chmod(0o700, dir) if File.directory?(dir)
+          @file = File.open(path, File::WRONLY | File::APPEND | File::CREAT, 0o600)
+          @file.sync = true
+          @mutex = Mutex.new
+        end
+
+        def debug(message)
+          write('DEBUG', message)
+        end
+
+        def info(message)
+          write('INFO', message)
+        end
+
+        def warn(message)
+          write('WARN', message)
+        end
+
+        def error(message)
+          write('ERROR', message)
+        end
+
+        def close
+          @mutex.synchronize { @file.close unless @file.closed? }
+        end
+
+        private
+
+        def write(level, message)
+          @mutex.synchronize do
+            @file.puts "[#{Time.now.strftime('%Y-%m-%d %H:%M:%S.%L')}] #{level} #{message}"
+          end
+        rescue IOError
+          nil
+        end
+      end
+
       class << self
         attr_accessor :sequel
 
@@ -40,11 +103,12 @@ module Legion
         end
 
         def setup
+          opts = sequel_opts
           @sequel = if adapter == :sqlite
-                      ::Sequel.sqlite(sqlite_path)
+                      ::Sequel.connect(opts.merge(adapter: :sqlite, database: sqlite_path))
                     else
                       begin
-                        ::Sequel.connect(adapter: adapter, **creds_builder)
+                        ::Sequel.connect(opts.merge(adapter: adapter, **creds_builder))
                       rescue StandardError => e
                         raise unless dev_fallback?
 
@@ -54,7 +118,8 @@ module Legion
                           )
                         end
                         @adapter = :sqlite
-                        ::Sequel.sqlite(sqlite_path)
+                        sqlite_opts = sequel_opts
+                        ::Sequel.connect(sqlite_opts.merge(adapter: :sqlite, database: sqlite_path))
                       end
                     end
           Legion::Settings[:data][:connected] = true
@@ -70,12 +135,61 @@ module Legion
               Legion::Logging.info "Connected to #{adapter}://#{user}@#{host}:#{port}/#{db}"
             end
           end
-          configure_logging
+          configure_extensions
           connect_with_replicas
         end
 
+        def stats
+          return { connected: false } unless @sequel
+
+          data = Legion::Settings[:data]
+          {
+            connected: data[:connected],
+            adapter:   adapter,
+            pool:      pool_stats,
+            tuning:    tuning_stats(data),
+            database:  database_stats
+          }
+        rescue StandardError => e
+          { connected: (data[:connected] if data.is_a?(Hash)), adapter: adapter, error: e.message }
+        end
+
+        def pool_stats
+          return {} unless @sequel
+
+          pool = @sequel.pool
+          stats = {
+            type:     pool.pool_type,
+            size:     pool.size,
+            max_size: pool.respond_to?(:max_size) ? pool.max_size : nil
+          }
+
+          case pool.pool_type
+          when :timed_queue, :sharded_timed_queue
+            queue_size = pool.instance_variable_get(:@queue)&.size || 0
+            stats[:available] = queue_size
+            stats[:in_use]    = stats[:size] - queue_size
+            stats[:waiting]   = pool.num_waiting
+          when :threaded, :sharded_threaded
+            avail = pool.instance_variable_get(:@available_connections)
+            stats[:available] = avail&.size || 0
+            stats[:in_use]    = stats[:size] - stats[:available]
+            stats[:waiting]   = pool.num_waiting
+          when :single, :sharded_single
+            stats[:available] = pool.size
+            stats[:in_use]    = 0
+            stats[:waiting]   = 0
+          end
+
+          stats.compact
+        rescue StandardError
+          {}
+        end
+
         def shutdown
           @sequel&.disconnect
+          @query_file_logger&.close
+          @query_file_logger = nil
           Legion::Settings[:data][:connected] = false
           Legion::Logging.info 'Legion::Data connection closed' if defined?(Legion::Logging)
         end
@@ -176,12 +290,175 @@ module Legion
           Legion::Settings[:data][:creds][:database] || 'legionio.db'
         end
 
-        def configure_logging
-          return if Legion::Settings[:data][:connection].nil? || Legion::Settings[:data][:connection][:log].nil?
+        def sequel_opts
+          data = Legion::Settings[:data]
+          opts = {}
 
-          @sequel.logger = build_data_logger
-          @sequel.sql_log_level = Legion::Settings[:data][:connection][:sql_log_level]
-          @sequel.log_warn_duration = Legion::Settings[:data][:connection][:log_warn_duration]
+          # Generic pool options
+          GENERIC_KEYS.each do |key|
+            val = data[key]
+            opts[key] = val unless val.nil?
+          end
+
+          # Query log mode: all queries to dedicated file, isolated from main domain
+          if data[:query_log]
+            log_path = File.join(QUERY_LOG_DIR, 'data-shared-query.log')
+            @query_file_logger = QueryFileLogger.new(log_path)
+            opts[:logger]              = @query_file_logger
+            opts[:sql_log_level]       = :debug
+            opts[:log_connection_info] = data[:log_connection_info] || false
+          elsif data[:log] && defined?(Legion::Logging)
+            # Standard mode: slow-query warnings through Legion::Logging domain
+            opts[:logger]              = build_data_logger
+            opts[:sql_log_level]       = data[:sql_log_level]&.to_sym || :debug
+            opts[:log_warn_duration]   = data[:log_warn_duration]
+            opts[:log_connection_info] = data[:log_connection_info] || false
+          end
+
+          # Adapter-specific: user setting wins, then built-in default, skip if nil
+          defaults = ADAPTER_DEFAULTS.fetch(adapter, {})
+          ADAPTER_KEYS.fetch(adapter, []).each do |key|
+            val = data.key?(key) && !data[key].nil? ? data[key] : defaults[key]
+            opts[key] = val unless val.nil?
+          end
+
+          opts
+        end
+
+        def tuning_stats(data)
+          tuning = {}
+
+          # Pool tuning
+          GENERIC_KEYS.each { |key| tuning[key] = data[key] }
+
+          # Logging
+          tuning[:log]                 = data[:log]
+          tuning[:query_log]           = data[:query_log]
+          tuning[:query_log_path]      = @query_file_logger&.path
+          tuning[:log_warn_duration]   = data[:log_warn_duration]
+          tuning[:sql_log_level]       = data[:sql_log_level]
+          tuning[:log_connection_info] = data[:log_connection_info]
+
+          # Connection health
+          tuning[:connection_validation] = data[:connection_validation]
+          tuning[:connection_validation_timeout]  = data[:connection_validation_timeout]
+          tuning[:connection_expiration]          = data[:connection_expiration]
+          tuning[:connection_expiration_timeout]  = data[:connection_expiration_timeout]
+
+          # Adapter-specific (only keys relevant to current adapter)
+          defaults = ADAPTER_DEFAULTS.fetch(adapter, {})
+          ADAPTER_KEYS.fetch(adapter, []).each do |key|
+            tuning[key] = data.key?(key) && !data[key].nil? ? data[key] : defaults[key]
+          end
+
+          tuning
+        end
+
+        def database_stats
+          case adapter
+          when :sqlite   then sqlite_stats
+          when :postgres then postgres_stats
+          when :mysql2   then mysql_stats
+          else {}
+          end
+        rescue StandardError => e
+          { error: e.message }
+        end
+
+        def sqlite_stats
+          db = @sequel
+          stats = {}
+          %w[page_size page_count freelist_count journal_mode wal_autocheckpoint
+             cache_size busy_timeout].each do |pragma|
+            val = begin
+              db.fetch("PRAGMA #{pragma}").single_value
+            rescue StandardError
+              nil
+            end
+            stats[pragma.to_sym] = val unless val.nil?
+          end
+
+          db_path = Legion::Settings[:data][:creds][:database] || 'legionio.db'
+          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
+        end
+
+        def postgres_stats
+          db = @sequel
+          stats = {}
+
+          row = db.fetch('SELECT current_database() AS db, pg_database_size(current_database()) AS size_bytes').first
+          stats[:database_name]       = row[:db]
+          stats[:database_size_bytes] = row[:size_bytes]
+
+          activity = db.fetch(<<~SQL).first
+            SELECT
+              count(*) FILTER (WHERE state = 'active') AS active,
+              count(*) FILTER (WHERE state = 'idle') AS idle,
+              count(*) FILTER (WHERE state = 'idle in transaction') AS idle_in_transaction,
+              count(*) AS total
+            FROM pg_stat_activity
+            WHERE datname = current_database()
+          SQL
+          stats[:server_connections] = activity
+
+          settings = db.fetch(<<~SQL).first
+            SELECT
+              current_setting('max_connections')::int AS max_connections,
+              current_setting('shared_buffers') AS shared_buffers,
+              current_setting('work_mem') AS work_mem,
+              current_setting('server_version') AS server_version
+          SQL
+          stats[:server] = settings
+
+          stats
+        end
+
+        def mysql_stats
+          db = @sequel
+          stats = {}
+
+          size_row = db.fetch(<<~SQL).first
+            SELECT SUM(data_length + index_length) AS size_bytes
+            FROM information_schema.tables
+            WHERE table_schema = DATABASE()
+          SQL
+          stats[:database_name]       = db.fetch('SELECT DATABASE() AS db').single_value
+          stats[:database_size_bytes] = size_row[:size_bytes]&.to_i
+
+          threads = {}
+          db.fetch("SHOW STATUS WHERE Variable_name IN ('Threads_connected','Threads_running','Max_used_connections')").each do |row|
+            threads[row[:Variable_name].downcase.to_sym] = row[:Value].to_i
+          end
+          stats[:server_connections] = threads
+
+          max_conn = db.fetch("SHOW VARIABLES LIKE 'max_connections'").first
+          version  = db.fetch('SELECT VERSION() AS v').single_value
+          stats[:server] = {
+            max_connections: max_conn ? max_conn[:Value].to_i : nil,
+            server_version:  version
+          }
+
+          stats
+        end
+
+        def configure_extensions
+          return if adapter == :sqlite
+
+          data = Legion::Settings[:data]
+
+          if data[:connection_validation] != false
+            @sequel.extension(:connection_validator)
+            @sequel.pool.connection_validation_timeout = data[:connection_validation_timeout] || 600
+          end
+
+          if data[:connection_expiration] != false
+            @sequel.extension(:connection_expiration)
+            @sequel.pool.connection_expiration_timeout = data[:connection_expiration_timeout] || 14_400
+          end
+        rescue StandardError => e
+          Legion::Logging.warn "Failed to load connection extensions: #{e.message}" if defined?(Legion::Logging)
         end
 
         def build_data_logger

data/lib/legion/data/local.rb

@@ -14,7 +14,23 @@ module Legion
 
           db_file = database || local_settings[:database] || 'legionio_local.db'
           @db_path = db_file
-          @connection = ::Sequel.sqlite(db_file)
+
+          sqlite_defaults = Legion::Data::Connection::ADAPTER_DEFAULTS.fetch(:sqlite, {})
+          data = defined?(Legion::Settings) ? 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
+
+          if local_settings[: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
+            opts[:sql_log_level] = :debug
+          end
+
+          @connection = ::Sequel.connect(opts)
           @connected = true
           run_migrations
           Legion::Logging.info "Legion::Data::Local connected to #{db_file}" if defined?(Legion::Logging)
@@ -22,6 +38,8 @@ module Legion
 
         def shutdown
           @connection&.disconnect
+          @query_file_logger&.close
+          @query_file_logger = nil
           @connection = nil
           @connected = false
         end
@@ -46,6 +64,37 @@ module Legion
           ::Sequel::Model(connection[table_name])
         end
 
+        def stats
+          return { connected: false } unless connected?
+
+          stats = {
+            connected:             true,
+            adapter:               :sqlite,
+            path:                  @db_path,
+            query_log:             local_settings[:query_log] || false,
+            query_log_path:        @query_file_logger&.path,
+            registered_migrations: registered_migrations.keys
+          }
+
+          stats[:file_size] = File.size(@db_path) if @db_path && File.exist?(@db_path)
+
+          %w[page_size page_count freelist_count journal_mode
+             wal_autocheckpoint cache_size busy_timeout].each do |pragma|
+            val = begin
+              @connection.fetch("PRAGMA #{pragma}").single_value
+            rescue StandardError
+              nil
+            end
+            stats[pragma.to_sym] = val unless val.nil?
+          end
+
+          stats[:database_size_bytes] = stats[:page_size].to_i * stats[:page_count].to_i if stats[:page_size] && stats[:page_count]
+
+          stats
+        rescue StandardError => e
+          { connected: connected?, error: e.message }
+        end
+
         def reset!
           @connection = nil
           @connected = false

data/lib/legion/data/settings.rb

@@ -25,20 +25,55 @@ module Legion
 
       def self.default
         {
-          adapter:          'sqlite',
-          connected:        false,
-          cache:            cache,
-          connection:       connection,
-          creds:            creds,
-          migrations:       migrations,
-          models:           models,
-          local:            local,
-          dev_mode:         false,
-          dev_fallback:     true,
-          connect_on_start: true,
-          read_replica_url: nil,
-          replicas:         [],
-          archival:         archival
+          adapter:                       'sqlite',
+          connected:                     false,
+
+          # Connection pool
+          max_connections:               25,
+          pool_timeout:                  5,
+          preconnect:                    'concurrently',
+          single_threaded:               false,
+          test:                          true,
+          name:                          nil,
+
+          # Logging
+          log:                           false,
+          query_log:                     false,
+          log_connection_info:           false,
+          log_warn_duration:             1,
+          sql_log_level:                 'debug',
+
+          # Connection health (network adapters only, ignored for sqlite)
+          connection_validation:         true,
+          connection_validation_timeout: 600,
+          connection_expiration:         true,
+          connection_expiration_timeout: 14_400,
+
+          # Adapter-specific (nil = use adapter built-in default)
+          connect_timeout:               nil,
+          read_timeout:                  nil,
+          write_timeout:                 nil,
+          encoding:                      nil,
+          sql_mode:                      nil,
+          sslmode:                       nil,
+          sslrootcert:                   nil,
+          search_path:                   nil,
+          timeout:                       nil,
+          readonly:                      nil,
+          disable_dqs:                   nil,
+
+          # Grouped settings
+          creds:                         creds,
+          cache:                         cache,
+          migrations:                    migrations,
+          models:                        models,
+          local:                         local,
+          dev_mode:                      false,
+          dev_fallback:                  true,
+          connect_on_start:              true,
+          read_replica_url:              nil,
+          replicas:                      [],
+          archival:                      archival
         }
       end
 
@@ -46,6 +81,7 @@ module Legion
         {
           enabled:    true,
           database:   'legionio_local.db',
+          query_log:  false,
           migrations: { auto_migrate: true }
         }
       end
@@ -66,17 +102,6 @@ module Legion
         }
       end
 
-      def self.connection
-        {
-          log:                 false,
-          log_connection_info: false,
-          log_warn_duration:   1,
-          sql_log_level:       'debug',
-          max_connections:     10,
-          preconnect:          false
-        }
-      end
-
       def self.creds(adapter = nil)
         adapter = (adapter || :sqlite).to_sym
         CREDS.fetch(adapter, CREDS[:sqlite]).dup
@@ -92,9 +117,10 @@ module Legion
 
       def self.cache
         {
-          connected:   false,
-          auto_enable: Legion::Settings[:cache][:connected],
-          ttl:         60
+          connected:    false,
+          auto_enable:  Legion::Settings[:cache][:connected],
+          static_cache: false,
+          ttl:          60
         }
       end
     end

data/lib/legion/data/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Data
-    VERSION = '1.5.3'
+    VERSION = '1.6.0'
   end
 end

data/lib/legion/data.rb

@@ -47,22 +47,48 @@ module Legion
         Legion::Data::Local
       end
 
+      def stats
+        {
+          shared: Legion::Data::Connection.stats,
+          local:  Legion::Data::Local.stats
+        }
+      end
+
       def setup_cache
-        return if Legion::Settings[:data][:cache][:enabled]
-
-        nil unless defined?(::Legion::Cache)
-
-        # Legion::Data::Model::Relationship.plugin :caching, Legion::Cache, ttl: 10
-        # Legion::Data::Model::Runner.plugin :caching, Legion::Cache, ttl: 60
-        # Legion::Data::Model::Chain.plugin :caching, Legion::Cache, ttl: 60
-        # Legion::Data::Model::Function.plugin :caching, Legion::Cache, ttl: 120
-        # Legion::Data::Model::Extension.plugin :caching, Legion::Cache, ttl: 120
-        # Legion::Data::Model::Node.plugin :caching, Legion::Cache, ttl: 10
-        # Legion::Data::Model::TaskLog.plugin :caching, Legion::Cache, ttl: 12
-        # Legion::Data::Model::Task.plugin :caching, Legion::Cache, ttl: 10
-        # Legion::Data::Model::User.plugin :caching, Legion::Cache, ttl: 120
-        # Legion::Data::Model::Group.plugin :caching, Legion::Cache, ttl: 120
-        # Legion::Logging.info 'Legion::Data connected to Legion::Cache'
+        cache_settings = Legion::Settings[:data][:cache]
+        setup_static_cache if cache_settings[:static_cache]
+        setup_external_cache if cache_settings[:auto_enable] && defined?(::Legion::Cache)
+      end
+
+      def setup_static_cache
+        [Model::Extension, Model::Runner, Model::Function].each do |model|
+          model.plugin :static_cache
+          Legion::Logging.debug("StaticCache enabled for #{model}") if defined?(Legion::Logging)
+        rescue StandardError => e
+          Legion::Logging.warn("StaticCache failed for #{model}: #{e.message}") if defined?(Legion::Logging)
+        end
+        Legion::Logging.info 'Legion::Data static cache loaded' if defined?(Legion::Logging)
+      end
+
+      def reload_static_cache
+        [Model::Extension, Model::Runner, Model::Function].each do |model|
+          model.load_cache if model.respond_to?(:load_cache)
+        end
+      end
+
+      def setup_external_cache
+        ttl = Legion::Settings[:data][:cache][:ttl] || 60
+        {
+          Model::Relationship => 10,
+          Model::Node         => 10,
+          Model::Setting      => ttl
+        }.each do |model, model_ttl|
+          model.plugin :caching, ::Legion::Cache, ttl: model_ttl
+          Legion::Logging.debug("Caching enabled for #{model} (ttl: #{model_ttl})") if defined?(Legion::Logging)
+        rescue StandardError => e
+          Legion::Logging.warn("Caching failed for #{model}: #{e.message}") if defined?(Legion::Logging)
+        end
+        Legion::Logging.info 'Legion::Data external cache connected' if defined?(Legion::Logging)
       end
 
       def shutdown

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-data
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.6.0
 platform: ruby
 authors:
 - Esity
@@ -75,6 +75,8 @@ extra_rdoc_files:
 - LICENSE
 - README.md
 files:
+- ".github/CODEOWNERS"
+- ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rubocop.yml"