legion-data 1.10.8 → 1.10.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 869153710ece6717285edf2de7483f4c9f5fe5b493837681b80d05b77b014971
-  data.tar.gz: 2813fd707f0f7a80858802046b7ba2a2f23611f94a1515c66e5c7a5db1771dd6
+  metadata.gz: 8d929f0ed083e64145e6022ee40af61b677b852513e071ec9a986267837953a2
+  data.tar.gz: ed00e7cb0c7670378212cc1f8df39c893f0efbaf7a71961188a411a1956dcab9
 SHA512:
-  metadata.gz: 41aff7bbce675a95d8a2ec6683eb0350decde2cf66854971b0c43fed1d4a09bdc50563e922bfe29d5a01660c522d579be7f2719495150d136ba262f433ba4ac4
-  data.tar.gz: c766be4f0a13cf3ac3dc91e305d275742d5c49206ec90819631d05739137fb1c9eadbc550feeef1d6e635961ec8bf439b9b5fc19dfc334d1798859573d87902a
+  metadata.gz: fdf3cf290669b970b523c3de8e5d6b42b9b14d877bd7260155c2067a708745cd59120605059dc1d5af85fd94f0a63d0c1e4e39ae4b7870409357572085b1d5f2
+  data.tar.gz: 3b1c0bb52ba3bfcc0249f6a6a4c0185b213f7e6cd8201989f5cd0279be1d9e1df1e364c0479d48920397f7e693ff5a63f557048acdaaefecdd32651e212922c7

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Legion::Data Changelog
 
+## [1.10.9] - 2026-07-31
+### Fixed
+- **Postgres session timeouts**: Apply `statement_timeout` (default 5000ms) and `lock_timeout` (default 2000ms) via `after_connect` hook on every new Postgres connection. Prevents unbounded `SELECT` or lock-wait from hanging the process indefinitely — the root cause of ~1h50m connection wedges.
+- **TCP keepalives on Postgres**: Wire libpq `keepalives`, `keepalives_idle` (10s), `keepalives_interval` (5s), `keepalives_count` (3), and `tcp_user_timeout` (15000ms) through the Sequel connection hash. Detects half-open TCP sockets within ~25s instead of relying on OS defaults (often 2+ hours).
+- **Force-disconnect on shutdown**: `shutdown` now waits up to `shutdown_timeout` (default 5s) for checked-out connections to return, then force-disconnects all remaining connections. Previously, `disconnect` only closed idle pool connections — a connection stuck in `select()` survived forever, hanging process exit.
+- **Adapter timeout defaults tightened**: Postgres `connect_timeout` reduced from 20s to 5s; MySQL `connect_timeout` reduced from 120s to 5s, `read_timeout` and `write_timeout` default to 5s. The old 20s/120s values allowed connection attempts to block worker threads far too long under network partition.
+- **MySQL read/write timeout wiring preserved**: `read_timeout` and `write_timeout` remain in `ADAPTER_KEYS[:mysql2]` where Sequel's mysql2 adapter honors them. For Postgres, the equivalent is `statement_timeout` (query bound) plus TCP keepalives (socket bound) — `read_timeout` is not a libpq/Sequel-postgres concept, so it is correctly absent from the Postgres key list.
+
 ## [1.10.8] - 2026-07-23
 ### Fixed
 - Detect auth failures (`role does not exist`, `password authentication failed`) on Sequel pool connections and trigger immediate Vault lease reissue via LeaseManager instead of retrying dead credentials forever. 30-second cooldown prevents reissue storms during bulk credential rotation.

data/lib/legion/data/connection.rb

@@ -19,14 +19,18 @@ module Legion
 
       ADAPTER_KEYS = {
         sqlite:   %i[timeout readonly disable_dqs],
-        postgres: %i[connect_timeout sslmode sslrootcert search_path],
+        postgres: %i[connect_timeout sslmode sslrootcert search_path
+                     keepalives keepalives_idle keepalives_interval keepalives_count
+                     tcp_user_timeout],
         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' }
+        postgres: { connect_timeout: 5, sslmode: 'disable',
+                    keepalives: 1, keepalives_idle: 10, keepalives_interval: 5,
+                    keepalives_count: 3, tcp_user_timeout: 15_000 },
+        mysql2:   { connect_timeout: 5, read_timeout: 5, write_timeout: 5, encoding: 'utf8mb4' }
       }.freeze
 
       QUERY_LOG_DIR = File.expand_path('~/.legionio/logs').freeze
@@ -272,7 +276,10 @@ module Legion
         end
 
         def shutdown
-          @sequel&.disconnect
+          if @sequel
+            timeout = Legion::Settings[:data][:shutdown_timeout]
+            force_disconnect_pool(timeout: timeout)
+          end
           @query_file_logger&.close
           @query_file_logger = nil
           @fallback_active = false
@@ -430,6 +437,28 @@ module Legion
           data_settings[:dev_mode] == true && data_settings[:dev_fallback] != false
         end
 
+        def force_disconnect_pool(timeout:)
+          pool = @sequel.pool
+          in_use = pool.size - (pool.respond_to?(:available_connections) ? pool.available_connections.size : 0)
+
+          if in_use.positive?
+            log.warn("Legion::Data shutdown: #{in_use} connection(s) still checked out, waiting up to #{timeout}s")
+            deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + timeout
+            while ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) < deadline
+              break if pool.size <= (pool.respond_to?(:available_connections) ? pool.available_connections.size : 0)
+
+              sleep 0.1
+            end
+            remaining = pool.size - (pool.respond_to?(:available_connections) ? pool.available_connections.size : 0)
+            log.warn("Legion::Data shutdown: force-disconnecting #{remaining} wedged connection(s)") if remaining.positive?
+          end
+
+          @sequel.disconnect
+        rescue StandardError => e
+          handle_exception(e, level: :warn, handled: true, operation: :force_disconnect_pool)
+          @sequel&.disconnect rescue nil # rubocop:disable Style/RescueModifier
+        end
+
         def sqlite_path
           path = Legion::Settings[:data][:creds][:database] || 'legionio.db'
           return path if File.absolute_path?(path)
@@ -513,6 +542,11 @@ module Legion
           tuning[:connection_expiration]          = data[:connection_expiration]
           tuning[:connection_expiration_timeout]  = data[:connection_expiration_timeout]
 
+          # Session timeouts (postgres)
+          tuning[:statement_timeout]   = data[:statement_timeout]
+          tuning[:lock_timeout]        = data[:lock_timeout]
+          tuning[:shutdown_timeout]    = data[:shutdown_timeout]
+
           # Adapter-specific (only keys relevant to current adapter)
           defaults = ADAPTER_DEFAULTS.fetch(adapter, {})
           ADAPTER_KEYS.fetch(adapter, []).each do |key|
@@ -621,6 +655,7 @@ module Legion
           if adapter == :postgres
             Sequel.extension(:pg_array)
             @sequel.extension(:pg_array)
+            install_postgres_session_timeouts
           end
 
           if data[:connection_validation] != false
@@ -638,6 +673,21 @@ module Legion
           handle_exception(e, level: :warn, handled: true, operation: :configure_extensions, adapter: adapter)
         end
 
+        def install_postgres_session_timeouts
+          data = Legion::Settings[:data]
+          stmt_timeout = data[:statement_timeout]
+          lck_timeout = data[:lock_timeout]
+
+          @sequel.pool.after_connect = proc do |conn|
+            conn.exec("SET statement_timeout = '#{stmt_timeout.to_i}ms'") if stmt_timeout
+            conn.exec("SET lock_timeout = '#{lck_timeout.to_i}ms'") if lck_timeout
+          end
+
+          log.info("Postgres session timeouts: statement_timeout=#{stmt_timeout}ms, lock_timeout=#{lck_timeout}ms")
+        rescue StandardError => e
+          handle_exception(e, level: :warn, handled: true, operation: :install_postgres_session_timeouts)
+        end
+
         def install_auth_failure_hook
           Legion::Data::AuthFailureHandler.install(@sequel)
         rescue StandardError => e

data/lib/legion/data/settings.rb

@@ -58,6 +58,28 @@ module Legion
           connection_expiration:         true,
           connection_expiration_timeout: 14_400,
 
+          # Postgres session timeouts (milliseconds, applied via SET on each new connection).
+          # statement_timeout bounds any single query; lock_timeout bounds lock acquisition.
+          # These prevent a wedged SELECT or lock wait from hanging the process indefinitely.
+          statement_timeout:             5000,
+          lock_timeout:                  2000,
+
+          # TCP keepalives for Postgres (libpq connection params).
+          # Detect half-open sockets where the peer vanished without FIN/RST.
+          # keepalives_idle: seconds before first keepalive probe after idle
+          # keepalives_interval: seconds between probes
+          # keepalives_count: failed probes before declaring connection dead
+          # tcp_user_timeout: total ms for unacked data before kernel drops connection (Linux)
+          keepalives:                    1,
+          keepalives_idle:               10,
+          keepalives_interval:           5,
+          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,

data/lib/legion/data/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Data
-    VERSION = '1.10.8'
+    VERSION = '1.10.9'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-data
 version: !ruby/object:Gem::Version
-  version: 1.10.8
+  version: 1.10.9
 platform: ruby
 authors:
 - Esity