good_job 4.14.1 → 4.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af515dffcbbdb5c6f3e02ec7a1426b7d59aea355b33791c81cc20d043bcab7f4
-  data.tar.gz: e44f93e479b483af4c3848c7957df934198fb780260c3008c427ff864c3d67a8
+  metadata.gz: 0f0f62c12c0c19a4afd8f71d3dae19479ac4a7df6342ac399bf8e447fbbe8f5b
+  data.tar.gz: 75a2a8a282b0c28e370230397dfc5f1de470681b1d53cbb0dd6ee46384e87fe4
 SHA512:
-  metadata.gz: 812281e391af58a897dd119e875be51c7569eaefa021f7fc05d42d69b185819c4077c04e8f40d23c3cf498862e04f8f9285fe9a29931a1d9bba4f1a61650ca37
-  data.tar.gz: 1941b6294d3339c590e2c37188a2f1568a3c32bc5e1f9cb2a76f0c58b94cce6781797d3d86853111a842f435adb8262611eca426dc16001bb6bc1b0a8437bde4
+  metadata.gz: ba1a959622762c21e723f6d406d30d8fda81d736560f3c710a7c363d8206697d0eb856dbe9ee865a340ad4f3d8db5354a707f78d695d0221fe1779ba07709c7b
+  data.tar.gz: 0bb8d09ca31aefe0e6da18096da53f5fdfc7e7be820afb54791b051f7ea29464c730aefb9eaeffaeaaa5fa3a6f5e029d158651fde41bd8876fd280e3fcd4269a

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [v4.14.2](https://github.com/bensheldon/good_job/tree/v4.14.2) (2026-04-06)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.14.1...v4.14.2)
+
+**Closed issues:**
+
+- Incompatible with permanent\_connection\_checkout = :disallowed [\#1729](https://github.com/bensheldon/good_job/issues/1729)
+
+**Merged pull requests:**
+
+- Replace Base.connection with lease\_connection and with\_connection throughout [\#1730](https://github.com/bensheldon/good_job/pull/1730) ([bensheldon](https://github.com/bensheldon))
+
 ## [v4.14.1](https://github.com/bensheldon/good_job/tree/v4.14.1) (2026-04-03)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.14.0...v4.14.1)

data/app/charts/good_job/performance_index_chart.rb

@@ -23,7 +23,7 @@ module GoodJob
         ORDER BY timestamp ASC
       SQL
 
-      executions_data = GoodJob::Job.connection.exec_query(GoodJob::Job.pg_or_jdbc_query(sum_query), "GoodJob Performance Chart", start_end_binds)
+      executions_data = GoodJob::Job.connection_pool.with_connection { |conn| conn.exec_query(GoodJob::Job.pg_or_jdbc_query(sum_query), "GoodJob Performance Chart", start_end_binds) }
 
       job_names = executions_data.reject { |d| d['sum'].nil? }.map { |d| d['job_class'] || BaseFilter::EMPTY }.uniq
       labels = []

data/app/charts/good_job/performance_show_chart.rb

@@ -40,7 +40,7 @@ module GoodJob
       ]
       labels = BUCKET_INTERVALS.map { |interval| GoodJob::ApplicationController.helpers.format_duration(interval) }
       labels[-1] = I18n.t("good_job.performance.show.slow")
-      executions_data = GoodJob::Job.connection.exec_query(GoodJob::Job.pg_or_jdbc_query(sum_query), "GoodJob Performance Job Chart", binds)
+      executions_data = GoodJob::Job.connection_pool.with_connection { |conn| conn.exec_query(GoodJob::Job.pg_or_jdbc_query(sum_query), "GoodJob Performance Job Chart", binds) }
       executions_data = executions_data.to_a.index_by { |data| data["bucket_index"] }
 
       bucket_data = 0.upto(BUCKET_INTERVALS.count).map do |bucket_index|

data/app/charts/good_job/scheduled_by_queue_chart.rb

@@ -28,7 +28,7 @@ module GoodJob
         ORDER BY timestamp ASC
       SQL
 
-      executions_data = GoodJob::Job.connection.exec_query(GoodJob::Job.pg_or_jdbc_query(count_query), "GoodJob Dashboard Chart", start_end_binds)
+      executions_data = GoodJob::Job.connection_pool.with_connection { |conn| conn.exec_query(GoodJob::Job.pg_or_jdbc_query(count_query), "GoodJob Dashboard Chart", start_end_binds) }
 
       queue_names = executions_data.reject { |d| d['count'].nil? }.map { |d| d['queue_name'] || BaseFilter::EMPTY }.uniq
       labels = []

data/app/models/concerns/good_job/advisory_lockable.rb

@@ -30,6 +30,24 @@ module GoodJob
       # Default Postgres function to be used for Advisory Locks
       class_attribute :advisory_lockable_function, default: "pg_try_advisory_lock"
 
+      # Rails < 7.2 does not have lease_connection as a class method.
+      define_singleton_method(:lease_connection) { connection } unless respond_to?(:lease_connection)
+
+      # Rails < 7.2 does not have adapter_class as a class method, and adapter
+      # quoting methods (quote_table_name, quote_column_name) are instance-only.
+      # Provide a proxy that responds to those methods by delegating to a connection.
+      unless respond_to?(:adapter_class)
+        define_singleton_method(:adapter_class) do
+          @_adapter_class ||= begin
+            pool = connection_pool
+            proxy = Object.new
+            proxy.define_singleton_method(:quote_table_name) { |name| pool.with_connection { |c| c.quote_table_name(name) } }
+            proxy.define_singleton_method(:quote_column_name) { |name| pool.with_connection { |c| c.quote_column_name(name) } }
+            proxy
+          end
+        end
+      end
+
       # Attempt to acquire an advisory lock on the selected records and
       # return only those records for which a lock could be acquired.
       # @!method advisory_lock(column: _advisory_lockable_column, function: advisory_lockable_function)
@@ -39,6 +57,7 @@ module GoodJob
       # @return [ActiveRecord::Relation]
       #   A relation selecting only the records that were locked.
       scope :advisory_lock, (lambda do |column: _advisory_lockable_column, function: advisory_lockable_function, select_limit: nil|
+        lease_connection # ensure a sticky connection; advisory locks are session-scoped and must outlive this query
         original_query = self
 
         primary_key_for_select = primary_key.to_sym
@@ -55,7 +74,7 @@ module GoodJob
         cte_type = supports_cte_materialization_specifiers? ? :MATERIALIZED : :""
         composed_cte = Arel::Nodes::As.new(cte_table, Arel::Nodes::UnaryOperation.new(cte_type, cte_query.arel))
 
-        lock_condition = "#{function}(('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)"
+        lock_condition = "#{function}(('x' || substr(md5(#{_quoted_table_name_string} || '-' || #{adapter_class.quote_table_name(cte_table.name)}.#{adapter_class.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)"
         query = cte_table.project(cte_table[:id])
                   .with(composed_cte)
                   .where(defined?(Arel::Nodes::BoundSqlLiteral) ? Arel::Nodes::BoundSqlLiteral.new(lock_condition, [], {}) : Arel::Nodes::SqlLiteral.new(lock_condition))
@@ -82,11 +101,12 @@ module GoodJob
       # @example Get the records that have a session awaiting a lock:
       #   MyLockableRecord.joins_advisory_locks.where("pg_locks.granted = ?", false)
       scope :joins_advisory_locks, (lambda do |column: _advisory_lockable_column|
+        quoted_column = adapter_class.quote_column_name(column)
         joins(<<~SQL.squish)
           LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'
             AND pg_locks.objsubid = 1
-            AND pg_locks.classid = ('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(32)::int
-            AND pg_locks.objid = (('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{quoted_table_name}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64) << 32)::bit(32)::int
+            AND pg_locks.classid = ('x' || substr(md5(#{_quoted_table_name_string} || '-' || #{quoted_table_name}.#{quoted_column}::text), 1, 16))::bit(32)::int
+            AND pg_locks.objid = (('x' || substr(md5(#{_quoted_table_name_string} || '-' || #{quoted_table_name}.#{quoted_column}::text), 1, 16))::bit(64) << 32)::bit(32)::int
         SQL
       end)
 
@@ -96,8 +116,8 @@ module GoodJob
       # @param column [String, Symbol] column values to Advisory Lock against
       # @return [ActiveRecord::Relation]
       scope :includes_advisory_locks, (lambda do |column: _advisory_lockable_column|
-        owns_advisory_lock_sql = "#{connection.quote_table_name('pg_locks')}.#{connection.quote_column_name('pid')} = pg_backend_pid() AS owns_advisory_lock"
-        joins_advisory_locks(column: column).select("#{quoted_table_name}.*, #{connection.quote_table_name('pg_locks')}.locktype, #{owns_advisory_lock_sql}")
+        owns_advisory_lock_sql = "#{adapter_class.quote_table_name('pg_locks')}.#{adapter_class.quote_column_name('pid')} = pg_backend_pid() AS owns_advisory_lock"
+        joins_advisory_locks(column: column).select("#{quoted_table_name}.*, #{adapter_class.quote_table_name('pg_locks')}.locktype, #{owns_advisory_lock_sql}")
       end)
 
       # Find records that do not have an advisory lock on them.
@@ -174,18 +194,20 @@ module GoodJob
       def with_advisory_lock(column: _advisory_lockable_column, function: advisory_lockable_function, unlock_session: false, select_limit: nil)
         raise ArgumentError, "Must provide a block" unless block_given?
 
-        records = advisory_lock(column: column, function: function, select_limit: select_limit).to_a
-
-        begin
-          unscoped { yield(records) }
-        ensure
-          if unlock_session
-            advisory_unlock_session
-          else
-            unlock_function = advisory_unlockable_function(function)
-            if unlock_function
-              records.each do |record|
-                record.advisory_unlock(key: record.lockable_column_key(column: column), function: unlock_function)
+        connection_pool.with_connection do
+          records = advisory_lock(column: column, function: function, select_limit: select_limit).to_a
+
+          begin
+            unscoped { yield(records) }
+          ensure
+            if unlock_session
+              advisory_unlock_session
+            else
+              unlock_function = advisory_unlockable_function(function)
+              if unlock_function
+                records.each do |record|
+                  record.advisory_unlock(key: record.lockable_column_key(column: column), function: unlock_function)
+                end
               end
             end
           end
@@ -213,15 +235,20 @@ module GoodJob
           ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
         ]
 
-        locked = connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).first['locked']
-        return locked unless block_given?
-        return nil unless locked
+        if block_given?
+          connection_pool.with_connection do |conn|
+            locked = conn.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).first['locked']
+            return nil unless locked
 
-        begin
-          yield
-        ensure
-          unlock_function = advisory_unlockable_function(function)
-          advisory_unlock_key(key, function: unlock_function) if unlock_function
+            begin
+              yield
+            ensure
+              unlock_function = advisory_unlockable_function(function)
+              advisory_unlock_key(key, function: unlock_function) if unlock_function
+            end
+          end
+        else
+          lease_connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).first['locked']
         end
       end
 
@@ -241,7 +268,7 @@ module GoodJob
         binds = [
           ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
         ]
-        connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).first['unlocked']
+        lease_connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).first['unlocked']
       end
 
       # Tests whether the provided key has an advisory lock on it.
@@ -261,7 +288,7 @@ module GoodJob
           ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
           ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
         ]
-        connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Locked?', binds).any?
+        connection_pool.with_connection { |conn| conn.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Locked?', binds).any? }
       end
 
       # Tests whether this record is locked by the current database session.
@@ -282,17 +309,21 @@ module GoodJob
           ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
           ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
         ]
-        connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Owns Advisory Lock?', binds).any?
+        lease_connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Owns Advisory Lock?', binds).any?
       end
 
       def _advisory_lockable_column
         advisory_lockable_column || primary_key
       end
 
+      def _quoted_table_name_string
+        @_quoted_table_name_string ||= "'#{table_name.gsub("'", "''")}'"
+      end
+
       def supports_cte_materialization_specifiers?
         return @_supports_cte_materialization_specifiers if defined?(@_supports_cte_materialization_specifiers)
 
-        @_supports_cte_materialization_specifiers = connection.postgresql_version >= 120000
+        @_supports_cte_materialization_specifiers = connection_pool.with_connection { |conn| conn.postgresql_version >= 120000 }
       end
 
       # Postgres advisory unlocking function for the class
@@ -307,7 +338,7 @@ module GoodJob
       # Unlocks all advisory locks active in the current database session/connection
       # @return [void]
       def advisory_unlock_session
-        connection.exec_query("SELECT pg_advisory_unlock_all()::text AS unlocked", 'GoodJob::Lockable Unlock Session').first[:unlocked]
+        lease_connection.exec_query("SELECT pg_advisory_unlock_all()::text AS unlocked", 'GoodJob::Lockable Unlock Session').first[:unlocked]
       end
 
       # Converts SQL query strings between PG-compatible and JDBC-compatible syntax
@@ -371,12 +402,14 @@ module GoodJob
     def with_advisory_lock(key: lockable_key, function: advisory_lockable_function)
       raise ArgumentError, "Must provide a block" unless block_given?
 
-      advisory_lock!(key: key, function: function)
-      begin
-        yield
-      ensure
-        unlock_function = self.class.advisory_unlockable_function(function)
-        advisory_unlock(key: key, function: unlock_function) if unlock_function
+      self.class.connection_pool.with_connection do
+        advisory_lock!(key: key, function: function)
+        begin
+          yield
+        ensure
+          unlock_function = self.class.advisory_unlockable_function(function)
+          advisory_unlock(key: key, function: unlock_function) if unlock_function
+        end
       end
     end
 
@@ -399,21 +432,6 @@ module GoodJob
     # @return [Boolean]
     def owns_advisory_lock?(key: lockable_key)
       self.class.owns_advisory_lock_key?(key)
-      query = <<~SQL.squish
-        SELECT 1 AS one
-        FROM pg_locks
-        WHERE pg_locks.locktype = 'advisory'
-          AND pg_locks.objsubid = 1
-          AND pg_locks.classid = ('x' || substr(md5($1::text), 1, 16))::bit(32)::int
-          AND pg_locks.objid = (('x' || substr(md5($2::text), 1, 16))::bit(64) << 32)::bit(32)::int
-          AND pg_locks.pid = pg_backend_pid()
-        LIMIT 1
-      SQL
-      binds = [
-        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
-        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
-      ]
-      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Owns Advisory Lock?', binds).any?
     end
 
     # Releases all advisory locks on the record that are held by the current

data/app/models/concerns/good_job/filterable.rb

@@ -52,7 +52,7 @@ module GoodJob
       def database_supports_websearch_to_tsquery?
         return @_database_supports_websearch_to_tsquery if defined?(@_database_supports_websearch_to_tsquery)
 
-        @_database_supports_websearch_to_tsquery = connection.postgresql_version >= 110000
+        @_database_supports_websearch_to_tsquery = connection_pool.with_connection { |conn| conn.postgresql_version >= 110000 }
       end
     end
   end

data/app/models/good_job/base_record.rb

@@ -44,6 +44,13 @@ module GoodJob
     def self.bind_value(name, value, type_class)
       Arel::Nodes::BindParam.new(ActiveRecord::Relation::QueryAttribute.new(name, value, type_class.new))
     end
+
+    # Rails < 7.2 does not have lease_connection; connection is behaviorally equivalent.
+    unless respond_to?(:lease_connection)
+      def self.lease_connection
+        connection
+      end
+    end
   end
 end
 

data/config/brakeman.ignore

@@ -1,5 +1,47 @@
 {
   "ignored_warnings": [
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "e3b77f1540f622502491e00b2825b0d5cb6cb3962017fa3ef18d4d463799f3fd",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/concerns/good_job/advisory_lockable.rb",
+      "line": 89,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "joins(\"LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'\\n  AND pg_locks.objsubid = 1\\n  AND pg_locks.classid = ...#{_quoted_table_name_string}...\\n\".squish)",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "GoodJob",
+        "method": null
+      },
+      "user_input": "_quoted_table_name_string",
+      "confidence": "Medium",
+      "cwe_id": [89],
+      "note": "Values are quoted identifiers and an escaped table name string; not user input."
+    },
+    {
+      "warning_type": "SQL Injection",
+      "warning_code": 0,
+      "fingerprint": "ffcbcbd3d170cb7e40cc3b7054e6157983b6ccdf7eab02bc1b0f525158b35248",
+      "check_name": "SQL",
+      "message": "Possible SQL injection",
+      "file": "app/models/concerns/good_job/advisory_lockable.rb",
+      "line": 89,
+      "link": "https://brakemanscanner.org/docs/warning_types/sql_injection/",
+      "code": "joins(\"LEFT JOIN pg_locks ON pg_locks.locktype = 'advisory'\\n  AND pg_locks.objsubid = 1\\n  AND pg_locks.classid = ...#{_quoted_table_name_string}...\\n\".squish)",
+      "render_path": null,
+      "location": {
+        "type": "method",
+        "class": "GoodJob::AdvisoryLockable",
+        "method": null
+      },
+      "user_input": "_quoted_table_name_string",
+      "confidence": "Medium",
+      "cwe_id": [89],
+      "note": "Values are quoted identifiers and an escaped table name string; not user input."
+    },
     {
       "warning_type": "Dynamic Render Path",
       "warning_code": 15,

data/lib/good_job/capsule_tracker.rb

@@ -77,11 +77,11 @@ module GoodJob # :nodoc:
                 @record.advisory_lock!
                 @record.update(lock_type: :advisory)
               end
-              @advisory_locked_connection = WeakRef.new(@record.class.connection)
+              @advisory_locked_connection = WeakRef.new(@record.class.lease_connection)
             end
           else
             @record = GoodJob::Process.find_or_create_record(id: @record_id, with_advisory_lock: true)
-            @advisory_locked_connection = WeakRef.new(@record.class.connection)
+            @advisory_locked_connection = WeakRef.new(@record.class.lease_connection)
             create_refresh_task
           end
         end
@@ -155,7 +155,8 @@ module GoodJob # :nodoc:
     private
 
     def advisory_locked_connection?
-      @record&.class&.connection && @advisory_locked_connection&.weakref_alive? && @advisory_locked_connection.eql?(@record.class.connection)
+      conn = @record&.class&.lease_connection
+      conn && @advisory_locked_connection&.weakref_alive? && @advisory_locked_connection.eql?(conn)
     end
 
     def task_interval

data/lib/good_job/notifier.rb

@@ -54,10 +54,11 @@ module GoodJob # :nodoc:
     # Send a message via Postgres NOTIFY
     # @param message [#to_json]
     def self.notify(message)
-      connection = ::GoodJob::Job.connection
-      connection.exec_query <<~SQL.squish
-        NOTIFY #{CHANNEL}, #{connection.quote(message.to_json)}
-      SQL
+      ::GoodJob::Job.connection_pool.with_connection do |connection|
+        connection.exec_query <<~SQL.squish
+          NOTIFY #{CHANNEL}, #{connection.quote(message.to_json)}
+        SQL
+      end
     end
 
     # List of recipients that will receive notifications.

data/lib/good_job/overridable_connection.rb

@@ -17,6 +17,12 @@ module GoodJob # :nodoc:
         _overridden_connection || super
       end
 
+      # Overrides lease_connection to use the assigned connection when set.
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      def lease_connection
+        _overridden_connection || super
+      end
+
       # Block interface to assign the connection, yield, then unassign the connection.
       # @param conn [ActiveRecord::ConnectionAdapters::AbstractAdapter]
       # @return [void]

data/lib/good_job/version.rb

@@ -2,7 +2,7 @@
 
 module GoodJob
   # GoodJob gem version.
-  VERSION = '4.14.1'
+  VERSION = '4.14.2'
 
   # GoodJob version as Gem::Version object
   GEM_VERSION = Gem::Version.new(VERSION)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.14.1
+  version: 4.14.2
 platform: ruby
 authors:
 - Ben Sheldon