good_job 4.0.3 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41adaae5b9a9c016ba000f7610efa23d533a177374e61039f135a1d152be146c
-  data.tar.gz: 92443b132e11697ae1ba31758852a818e5fbaf201cf080649f1c948d927265d4
+  metadata.gz: aead87131c66c247222ce6733d9fe579b6d61fa0cc166b23ae75c6011e2b52db
+  data.tar.gz: 4158e3be14f1b93f46bb2eeefbeee246b4a2d98347519166b507811d343234ab
 SHA512:
-  metadata.gz: 155174df9c9d4daf50f4e898585e2cf40898de46eb5974592acdf32cc435cb4cb13b6d4953862a89a3b8223d7bbd2c9e79c60d4a974642f180092d836d04ebb2
-  data.tar.gz: 84b922a4853ffb85da2380ab80c20b3d7392f403218838c3fdcb8872726d2df469d81edeaa28cb2f5a76401280460839c1d3f6ca1f2c9a98c4a1b275ff99cee4
+  metadata.gz: f7c522339ad17886675ac8c97104087a1d132767fe9e90c5a7f62005fced53abc40f29488e431b18e1a3a1ce528202245448617123eabaef1bda478576a9bfde
+  data.tar.gz: ce6fdd69c377f1e834b41640c5307e3bd030ac95d247b7037eab3fc5e806e6fb3030e57cc2de9d1f18a9e1f22e314e6b7e4a5aee709e2551b74b3d47f1e84388

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [v4.1.0](https://github.com/bensheldon/good_job/tree/v4.1.0) (2024-07-16)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.99.1...v4.1.0)
+
+**Implemented enhancements:**
+
+- Add keepalive SQL query to Notifier [\#1423](https://github.com/bensheldon/good_job/pull/1423) ([bensheldon](https://github.com/bensheldon))
+- Latency charts and histograms for individual job classes [\#1411](https://github.com/bensheldon/good_job/pull/1411) ([Earlopain](https://github.com/Earlopain))
+
+**Fixed bugs:**
+
+- Fix nonexistant association error between DiscreteExecution and Execution [\#1425](https://github.com/bensheldon/good_job/pull/1425) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Could not find the inverse association for execution \(:discrete\_executions in GoodJob::Execution\) [\#1424](https://github.com/bensheldon/good_job/issues/1424)
+- 3.99.1 is marked as the latest version, not 4.0.3 [\#1422](https://github.com/bensheldon/good_job/issues/1422)
+- How to maximise amount of jobs executed in parallel  [\#1418](https://github.com/bensheldon/good_job/issues/1418)
+- Performance Metrics for individual jobs [\#1397](https://github.com/bensheldon/good_job/issues/1397)
+
+**Merged pull requests:**
+
+- Remove some now unnecessary checks against `locked_by_id` existence [\#1421](https://github.com/bensheldon/good_job/pull/1421) ([Earlopain](https://github.com/Earlopain))
+- Use rails enum for `error_event` and `lock_type` [\#1420](https://github.com/bensheldon/good_job/pull/1420) ([Earlopain](https://github.com/Earlopain))
+- Add a little more wording to the v4 "ready to upgrade" instructions [\#1415](https://github.com/bensheldon/good_job/pull/1415) ([bensheldon](https://github.com/bensheldon))
+
+## [v3.99.1](https://github.com/bensheldon/good_job/tree/v3.99.1) (2024-07-10)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v4.0.3...v3.99.1)
+
 ## [v4.0.3](https://github.com/bensheldon/good_job/tree/v4.0.3) (2024-07-10)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v4.0.2...v4.0.3)

data/README.md

@@ -876,7 +876,7 @@ To perform upgrades to the GoodJob database tables:
 
 #### Upgrading v3 to v4
 
-GoodJob v4 changes how job and job execution records are stored in the database; moving from job and executions being commingled in the `good_jobs` table to separately and discretely storing job executions in `good_job_executions`. To safely upgrade, all unfinished jobs must use the new format. This change was introduced in GoodJob [v3.15.4 (April 2023)](https://github.com/bensheldon/good_job/releases/tag/v3.15.4), so your application is likely ready-to-upgrade already if you have kept up with GoodJob updates.
+GoodJob v4 changes how job and job execution records are stored in the database; moving from job and executions being commingled in the `good_jobs` table to separately and discretely storing job executions in `good_job_executions`. To safely upgrade, all unfinished jobs must use the new format. This change was introduced in GoodJob [v3.15.4 (April 2023)](https://github.com/bensheldon/good_job/releases/tag/v3.15.4), so your application is likely ready-to-upgrade in this respect if you have kept up with GoodJob updates and applied migrations (`bin/rails g good_job:update`). _Please be sure to doublecheck you are not missing subsequent migrations or deprecations too by following the instructions below._
 
 To upgrade:
 

data/app/charts/good_job/base_chart.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class BaseChart
+    def start_end_binds
+      end_time = Time.current
+      start_time = end_time - 1.day
+
+      [
+        ActiveRecord::Relation::QueryAttribute.new('start_time', start_time, ActiveRecord::Type::DateTime.new),
+        ActiveRecord::Relation::QueryAttribute.new('end_time', end_time, ActiveRecord::Type::DateTime.new),
+      ]
+    end
+
+    def string_to_hsl(string)
+      hash_value = string.sum
+
+      hue = hash_value % 360
+      saturation = (hash_value % 50) + 50
+      lightness = '50'
+
+      "hsl(#{hue}, #{saturation}%, #{lightness}%)"
+    end
+  end
+end

data/app/charts/good_job/performance_index_chart.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class PerformanceIndexChart < BaseChart
+    def data
+      table_name = GoodJob::DiscreteExecution.table_name
+
+      sum_query = Arel.sql(GoodJob::Job.pg_or_jdbc_query(<<~SQL.squish))
+        SELECT *
+        FROM generate_series(
+          date_trunc('hour', $1::timestamp),
+          date_trunc('hour', $2::timestamp),
+          '1 hour'
+        ) timestamp
+        LEFT JOIN (
+          SELECT
+              date_trunc('hour', scheduled_at) AS scheduled_at,
+              job_class,
+              SUM(duration) AS sum
+            FROM #{table_name} sources
+            GROUP BY date_trunc('hour', scheduled_at), job_class
+        ) sources ON sources.scheduled_at = timestamp
+        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)
+
+      job_names = executions_data.reject { |d| d['sum'].nil? }.map { |d| d['job_class'] || BaseFilter::EMPTY }.uniq
+      labels = []
+      jobs_data = executions_data.to_a.group_by { |d| d['timestamp'] }.each_with_object({}) do |(timestamp, values), hash|
+        labels << timestamp.in_time_zone.strftime('%H:%M')
+        job_names.each do |job_class|
+          sum = values.find { |d| d['job_class'] == job_class }&.[]('sum')
+          duration = sum ? ActiveSupport::Duration.parse(sum).to_f : 0
+          (hash[job_class] ||= []) << duration
+        end
+      end
+
+      {
+        type: "line",
+        data: {
+          labels: labels,
+          datasets: jobs_data.map do |job_class, data|
+            label = job_class || '(none)'
+            {
+              label: label,
+              data: data,
+              backgroundColor: string_to_hsl(label),
+              borderColor: string_to_hsl(label),
+            }
+          end,
+        },
+        options: {
+          plugins: {
+            title: {
+              display: true,
+              text: I18n.t("good_job.performance.index.chart_title"),
+            },
+          },
+          scales: {
+            y: {
+              beginAtZero: true,
+            },
+          },
+        },
+      }
+    end
+  end
+end

data/app/charts/good_job/performance_show_chart.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module GoodJob
+  class PerformanceShowChart < BaseChart
+    # These numbers are lifted from Sidekiq
+    BUCKET_INTERVALS = [
+      0.02, 0.03, 0.045, 0.065, 0.1,
+      0.15, 0.225, 0.335, 0.5, 0.75,
+      1.1, 1.7, 2.5, 3.8, 5.75,
+      8.5, 13, 20, 30, 45,
+      65, 100, 150, 225, 335,
+      10**8 # About 3 years
+    ].freeze
+
+    def initialize(job_class)
+      super()
+      @job_class = job_class
+    end
+
+    def data
+      table_name = GoodJob::DiscreteExecution.table_name
+
+      interval_entries = BUCKET_INTERVALS.map { "interval '#{_1}'" }.join(",")
+      sum_query = Arel.sql(GoodJob::Job.pg_or_jdbc_query(<<~SQL.squish))
+        SELECT
+          WIDTH_BUCKET(duration, ARRAY[#{interval_entries}]) as bucket_index,
+          COUNT(WIDTH_BUCKET(duration, ARRAY[#{interval_entries}])) AS count
+        FROM #{table_name} sources
+        WHERE
+          scheduled_at > $1::timestamp
+          AND scheduled_at < $2::timestamp
+          AND job_class = $3
+          AND duration IS NOT NULL
+        GROUP BY bucket_index
+      SQL
+
+      binds = [
+        *start_end_binds,
+        @job_class,
+      ]
+      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 = executions_data.to_a.index_by { |data| data["bucket_index"] }
+
+      bucket_data = 0.upto(BUCKET_INTERVALS.count).map do |bucket_index|
+        executions_data.dig(bucket_index, "count") || 0
+      end
+
+      {
+        type: "bar",
+        data: {
+          labels: labels,
+          datasets: [{
+            label: @job_class,
+            data: bucket_data,
+            backgroundColor: string_to_hsl(@job_class),
+            borderColor: string_to_hsl(@job_class),
+          }],
+        },
+        options: {
+          scales: {
+            y: {
+              beginAtZero: true,
+            },
+          },
+        },
+      }
+    end
+  end
+end

data/app/charts/good_job/scheduled_by_queue_chart.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 module GoodJob
-  class ScheduledByQueueChart
+  class ScheduledByQueueChart < BaseChart
     def initialize(filter)
+      super()
       @filter = filter
     end
 
     def data
-      end_time = Time.current
-      start_time = end_time - 1.day
       table_name = GoodJob::Job.table_name
 
       count_query = Arel.sql(GoodJob::Job.pg_or_jdbc_query(<<~SQL.squish))
@@ -31,11 +30,7 @@ module GoodJob
         ORDER BY timestamp ASC
       SQL
 
-      binds = [
-        ActiveRecord::Relation::QueryAttribute.new('start_time', start_time, ActiveRecord::Type::DateTime.new),
-        ActiveRecord::Relation::QueryAttribute.new('end_time', end_time, ActiveRecord::Type::DateTime.new),
-      ]
-      executions_data = GoodJob::Job.connection.exec_query(GoodJob::Job.pg_or_jdbc_query(count_query), "GoodJob Dashboard Chart", binds)
+      executions_data = GoodJob::Job.connection.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 = []
@@ -47,27 +42,27 @@ module GoodJob
       end
 
       {
-        labels: labels,
-        datasets: queues_data.map do |queue, data|
-          label = queue || '(none)'
-          {
-            label: label,
-            data: data,
-            backgroundColor: string_to_hsl(label),
-            borderColor: string_to_hsl(label),
-          }
-        end,
+        type: "line",
+        data: {
+          labels: labels,
+          datasets: queues_data.map do |queue, data|
+            label = queue || '(none)'
+            {
+              label: label,
+              data: data,
+              backgroundColor: string_to_hsl(label),
+              borderColor: string_to_hsl(label),
+            }
+          end,
+        },
+        options: {
+          scales: {
+            y: {
+              beginAtZero: true,
+            },
+          },
+        },
       }
     end
-
-    def string_to_hsl(string)
-      hash_value = string.sum
-
-      hue = hash_value % 360
-      saturation = (hash_value % 50) + 50
-      lightness = '50'
-
-      "hsl(#{hue}, #{saturation}%, #{lightness}%)"
-    end
   end
 end

data/app/controllers/good_job/metrics_controller.rb

@@ -9,27 +9,17 @@ module GoodJob
       processes_count = GoodJob::Process.active.count
 
       render json: {
-        jobs_count: number_to_human(jobs_count),
-        batches_count: number_to_human(batches_count),
-        cron_entries_count: number_to_human(cron_entries_count),
-        processes_count: number_to_human(processes_count),
+        jobs_count: helpers.number_to_human(jobs_count),
+        batches_count: helpers.number_to_human(batches_count),
+        cron_entries_count: helpers.number_to_human(cron_entries_count),
+        processes_count: helpers.number_to_human(processes_count),
       }
     end
 
     def job_status
       @filter = JobsFilter.new(params)
 
-      render json: @filter.states.transform_values { |count| number_with_delimiter(count) }
-    end
-
-    private
-
-    def number_to_human(count)
-      helpers.number_to_human(count, **helpers.translate_hash("good_job.number.human.decimal_units"))
-    end
-
-    def number_with_delimiter(count)
-      helpers.number_with_delimiter(count, **helpers.translate_hash('good_job.number.format'))
+      render json: @filter.states.transform_values { |count| helpers.number_with_delimiter(count) }
     end
   end
 end

data/app/controllers/good_job/performance_controller.rb

@@ -15,5 +15,10 @@ module GoodJob
                           ")
                       .order("job_class")
     end
+
+    def show
+      representative_job = GoodJob::Job.find_by!(job_class: params[:id])
+      @job_class = representative_job.job_class
+    end
   end
 end

data/app/frontend/good_job/modules/charts.js

@@ -4,25 +4,13 @@ function renderCharts(animate) {
   for (let i = 0; i < charts.length; i++) {
     const chartEl = charts[i];
     const chartData = JSON.parse(chartEl.dataset.json);
+    chartData.options ||= {};
+    chartData.options.animation = animate;
+    chartData.options.responsive = true;
+    chartData.options.maintainAspectRatio = false;
 
     const ctx = chartEl.getContext('2d');
-    const chart = new Chart(ctx, {
-      type: 'line',
-      data: {
-        labels: chartData.labels,
-        datasets: chartData.datasets
-      },
-      options: {
-        animation: animate,
-        responsive: true,
-        maintainAspectRatio: false,
-        scales: {
-          y: {
-            beginAtZero: true
-          }
-        }
-      }
-    });
+    const chart = new Chart(ctx, chartData);
   }
 }
 

data/app/helpers/good_job/application_helper.rb

@@ -14,7 +14,7 @@ module GoodJob
       if sec < 1
         t 'good_job.duration.milliseconds', ms: (sec * 1000).floor
       elsif sec < 10
-        t 'good_job.duration.less_than_10_seconds', sec: sec.floor
+        t 'good_job.duration.less_than_10_seconds', sec: number_with_delimiter(sec.floor(1))
       elsif sec < 60
         t 'good_job.duration.seconds', sec: sec.floor
       elsif sec < 3600
@@ -30,6 +30,14 @@ module GoodJob
       tag.time(text, datetime: timestamp, title: timestamp)
     end
 
+    def number_to_human(count)
+      super(count, **translate_hash("good_job.number.human.decimal_units"))
+    end
+
+    def number_with_delimiter(count)
+      super(count, **translate_hash('good_job.number.format'))
+    end
+
     def translate_hash(key, **options)
       translation_exists?(key, **options) ? translate(key, **options) : {}
     end

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

@@ -5,41 +5,20 @@ module GoodJob
   module ErrorEvents
     extend ActiveSupport::Concern
 
-    ERROR_EVENTS = [
-      ERROR_EVENT_INTERRUPTED = 'interrupted',
-      ERROR_EVENT_UNHANDLED = 'unhandled',
-      ERROR_EVENT_HANDLED = 'handled',
-      ERROR_EVENT_RETRIED = 'retried',
-      ERROR_EVENT_RETRY_STOPPED = 'retry_stopped',
-      ERROR_EVENT_DISCARDED = 'discarded',
-    ].freeze
-
-    ERROR_EVENT_ENUMS = {
-      ERROR_EVENT_INTERRUPTED => 0,
-      ERROR_EVENT_UNHANDLED => 1,
-      ERROR_EVENT_HANDLED => 2,
-      ERROR_EVENT_RETRIED => 3,
-      ERROR_EVENT_RETRY_STOPPED => 4,
-      ERROR_EVENT_DISCARDED => 5,
-    }.freeze
-
-    # TODO: GoodJob v4 can make this an `enum` once migrations are guaranteed.
-    def error_event
-      return unless self.class.columns_hash['error_event']
-
-      enum = read_attribute(:error_event)
-      return unless enum
-
-      ERROR_EVENT_ENUMS.key(enum)
-    end
-
-    def error_event=(event)
-      return unless self.class.columns_hash['error_event']
-
-      enum = ERROR_EVENT_ENUMS[event]
-      raise(ArgumentError, "Invalid error_event: #{event}") if event && !enum
-
-      write_attribute(:error_event, enum)
+    included do
+      error_event_enum = {
+        interrupted: 0,
+        unhandled: 1,
+        handled: 2,
+        retried: 3,
+        retry_stopped: 4,
+        discarded: 5,
+      }
+      if Gem::Version.new(Rails.version) >= Gem::Version.new('7.1.0.a')
+        enum :error_event, error_event_enum, validate: { allow_nil: true }
+      else
+        enum error_event: error_event_enum
+      end
     end
   end
 end

data/app/models/good_job/base_execution.rb

@@ -409,15 +409,15 @@ module GoodJob
 
             interrupt_error_string = self.class.format_error(GoodJob::InterruptError.new("Interrupted after starting perform at '#{existing_performed_at}'"))
             self.error = interrupt_error_string
-            self.error_event = ERROR_EVENT_INTERRUPTED
+            self.error_event = :interrupted
             monotonic_duration = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - monotonic_start).seconds
 
             discrete_execution_attrs = {
               error: interrupt_error_string,
               finished_at: job_performed_at,
+              error_event: :interrupted,
+              duration: monotonic_duration,
             }
-            discrete_execution_attrs[:error_event] = GoodJob::ErrorEvents::ERROR_EVENT_ENUMS[GoodJob::ErrorEvents::ERROR_EVENT_INTERRUPTED]
-            discrete_execution_attrs[:duration] = monotonic_duration
             discrete_executions.where(finished_at: nil).where.not(performed_at: nil).update_all(discrete_execution_attrs) # rubocop:disable Rails/SkipsModelValidations
           end
 
@@ -451,13 +451,13 @@ module GoodJob
             handled_error ||= current_thread.error_on_retry || current_thread.error_on_discard
 
             error_event = if handled_error == current_thread.error_on_discard
-                            ERROR_EVENT_DISCARDED
+                            :discarded
                           elsif handled_error == current_thread.error_on_retry
-                            ERROR_EVENT_RETRIED
+                            :retried
                           elsif handled_error == current_thread.error_on_retry_stopped
-                            ERROR_EVENT_RETRY_STOPPED
+                            :retry_stopped
                           elsif handled_error
-                            ERROR_EVENT_HANDLED
+                            :handled
                           end
 
             instrument_payload.merge!(
@@ -469,11 +469,11 @@ module GoodJob
             ExecutionResult.new(value: value, handled_error: handled_error, error_event: error_event, retried: current_thread.execution_retried)
           rescue StandardError => e
             error_event = if e.is_a?(GoodJob::InterruptError)
-                            ERROR_EVENT_INTERRUPTED
+                            :interrupted
                           elsif e == current_thread.error_on_retry_stopped
-                            ERROR_EVENT_RETRY_STOPPED
+                            :retry_stopped
                           else
-                            ERROR_EVENT_UNHANDLED
+                            :unhandled
                           end
 
             instrument_payload[:unhandled_error] = e
@@ -481,11 +481,7 @@ module GoodJob
           end
         end
 
-        job_attributes = if self.class.columns_hash.key?("locked_by_id")
-                           { locked_by_id: nil, locked_at: nil }
-                         else
-                           {}
-                         end
+        job_attributes = { locked_by_id: nil, locked_at: nil }
 
         job_error = result.handled_error || result.unhandled_error
         if job_error

data/app/models/good_job/discrete_execution.rb

@@ -7,7 +7,6 @@ module GoodJob # :nodoc:
     self.table_name = 'good_job_executions'
     self.implicit_order_column = 'created_at'
 
-    belongs_to :execution, class_name: 'GoodJob::Execution', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :discrete_executions, optional: true
     belongs_to :job, class_name: 'GoodJob::Job', foreign_key: 'active_job_id', primary_key: 'active_job_id', inverse_of: :discrete_executions, optional: true
 
     scope :finished, -> { where.not(finished_at: nil) }

data/app/models/good_job/job.rb

@@ -146,7 +146,7 @@ module GoodJob
 
           self.class.transaction(joinable: false, requires_new: true) do
             new_active_job = active_job.retry_job(wait: 0, error: error)
-            self.error_event = ERROR_EVENT_RETRIED if error
+            self.error_event = :retried if error
             save!
           end
         end
@@ -212,7 +212,7 @@ module GoodJob
         update(
           finished_at: Time.current,
           error: self.class.format_error(job_error),
-          error_event: ERROR_EVENT_DISCARDED
+          error_event: :discarded
         )
       end
 

data/app/models/good_job/process.rb

@@ -15,18 +15,18 @@ module GoodJob # :nodoc:
 
     self.table_name = 'good_job_processes'
     self.implicit_order_column = 'created_at'
-    LOCK_TYPES = [
-      LOCK_TYPE_ADVISORY = 'advisory',
-    ].freeze
 
-    LOCK_TYPE_ENUMS = {
-      LOCK_TYPE_ADVISORY => 1,
-    }.freeze
-
-    self.table_name = 'good_job_processes'
+    lock_type_enum = {
+      advisory: 0,
+    }
+    if Gem::Version.new(Rails.version) >= Gem::Version.new('7.1.0.a')
+      enum :lock_type, lock_type_enum, validate: { allow_nil: true }
+    else
+      enum lock_type: lock_type_enum
+    end
 
     has_many :locked_jobs, class_name: "GoodJob::Job", foreign_key: :locked_by_id, inverse_of: :locked_by_process, dependent: nil
-    after_destroy { locked_jobs.update_all(locked_by_id: nil) if GoodJob::Job.columns_hash.key?("locked_by_id") } # rubocop:disable Rails/SkipsModelValidations
+    after_destroy { locked_jobs.update_all(locked_by_id: nil) } # rubocop:disable Rails/SkipsModelValidations
 
     # Processes that are active and locked.
     # @!method active
@@ -34,7 +34,7 @@ module GoodJob # :nodoc:
     # @return [ActiveRecord::Relation]
     scope :active, (lambda do
       query = joins_advisory_locks
-      query.where(lock_type: LOCK_TYPE_ENUMS[LOCK_TYPE_ADVISORY]).advisory_locked
+      query.where(lock_type: :advisory).advisory_locked
         .or(query.where(lock_type: nil).where(arel_table[:updated_at].gt(EXPIRED_INTERVAL.ago)))
     end)
 
@@ -44,14 +44,14 @@ module GoodJob # :nodoc:
     # @return [ActiveRecord::Relation]
     scope :inactive, (lambda do
       query = joins_advisory_locks
-      query.where(lock_type: LOCK_TYPE_ENUMS[LOCK_TYPE_ADVISORY]).advisory_unlocked
+      query.where(lock_type: :advisory).advisory_unlocked
         .or(query.where(lock_type: nil).where(arel_table[:updated_at].lt(EXPIRED_INTERVAL.ago)))
     end)
 
     # Deletes all inactive process records.
     def self.cleanup
       inactive.find_each do |process|
-        GoodJob::Job.where(locked_by_id: process.id).update_all(locked_by_id: nil, locked_at: nil) if GoodJob::Job.columns_hash.key?("locked_by_id") # rubocop:disable Rails/SkipsModelValidations
+        GoodJob::Job.where(locked_by_id: process.id).update_all(locked_by_id: nil, locked_at: nil) # rubocop:disable Rails/SkipsModelValidations
         process.delete
       end
     end
@@ -63,7 +63,7 @@ module GoodJob # :nodoc:
       }
       if with_advisory_lock
         attributes[:create_with_advisory_lock] = true
-        attributes[:lock_type] = LOCK_TYPE_ADVISORY
+        attributes[:lock_type] = :advisory
       end
       create!(attributes)
     end
@@ -124,21 +124,5 @@ module GoodJob # :nodoc:
     def schedulers
       state.fetch("schedulers", [])
     end
-
-    def lock_type
-      return unless self.class.columns_hash['lock_type']
-
-      enum = super
-      LOCK_TYPE_ENUMS.key(enum) if enum
-    end
-
-    def lock_type=(value)
-      return unless self.class.columns_hash['lock_type']
-
-      enum = LOCK_TYPE_ENUMS[value]
-      raise(ArgumentError, "Invalid error_event: #{value}") if value && !enum
-
-      super(enum)
-    end
   end
 end

data/app/views/good_job/performance/index.html.erb

@@ -2,6 +2,8 @@
   <h2 class="pt-3 pb-2"><%= t ".title" %></h2>
 </div>
 
+<%= render 'good_job/shared/chart', chart_data: GoodJob::PerformanceIndexChart.new.data %>
+
 <div class="my-3 card">
   <div class="list-group list-group-flush text-nowrap" role="table">
     <header class="list-group-item bg-body-tertiary">
@@ -18,7 +20,7 @@
     <% @performances.each do |performance| %>
       <div role="row" class="list-group-item py-3">
         <div class="row align-items-center">
-          <div class="col-12 col-lg-4"><%= performance.job_class %></div>
+          <div class="col-12 col-lg-4"><%= link_to performance.job_class, performance_path(performance.job_class) %></div>
           <div class="col-6 col-lg-2 text-wrap">
             <div class="d-lg-none small text-muted mt-1"><%= t ".executions" %></div>
             <%= performance.executions_count %>

data/app/views/good_job/performance/show.html.erb

@@ -0,0 +1,5 @@
+<div class="border-bottom">
+  <h2 class="pt-3 pb-2"><%= t ".title" %> - <%= @job_class %></h2>
+</div>
+
+<%= render 'good_job/shared/chart', chart_data: GoodJob::PerformanceShowChart.new(@job_class).data %>

data/app/views/good_job/shared/_filter.erb

@@ -15,7 +15,7 @@
             <option value="" <%= "selected='selected'" if params[:queue_name].blank? %>><%= t ".all_queues" %></option>
 
             <% filter.queues.each do |name, count| %>
-              <option value="<%= name.to_param %>" <%= "selected='selected'" if params[:queue_name] == name %>><%= name %> (<%= number_with_delimiter(count, translate_hash('good_job.number.format')) %>)</option>
+              <option value="<%= name.to_param %>" <%= "selected='selected'" if params[:queue_name] == name %>><%= name %> (<%= number_with_delimiter(count) %>)</option>
             <% end %>
           </select>
         </div>
@@ -26,7 +26,7 @@
             <option value="" <%= "selected='selected'" if params[:job_class].blank? %>><%= t ".all_jobs" %></option>
 
             <% filter.job_classes.each do |name, count| %>
-              <option value="<%= name.to_param %>" <%= "selected='selected'" if params[:job_class] == name %>><%= name %> (<%= number_with_delimiter(count, translate_hash('good_job.number.format')) %>)</option>
+              <option value="<%= name.to_param %>" <%= "selected='selected'" if params[:job_class] == name %>><%= name %> (<%= number_with_delimiter(count) %>)</option>
             <% end %>
           </select>
         </div>

data/config/locales/de.yml

@@ -197,11 +197,15 @@ de:
     performance:
       index:
         average_duration: Durchschnittliche Dauer
+        chart_title: Gesamtdauer der Auftragsausführung in Sekunden
         executions: Hinrichtungen
         job_class: Berufsklasse
         maximum_duration: Maximale Dauer
         minimum_duration: Mindestdauer
         title: Leistung
+      show:
+        slow: Langsam
+        title: Leistung
     processes:
       index:
         cron_enabled: Cron aktiviert

data/config/locales/en.yml

@@ -197,11 +197,15 @@ en:
     performance:
       index:
         average_duration: Average duration
+        chart_title: Total job execution time in seconds
         executions: Executions
         job_class: Job class
         maximum_duration: Maximum duration
         minimum_duration: Minimum duration
         title: Performance
+      show:
+        slow: Slow
+        title: Performance
     processes:
       index:
         cron_enabled: Cron enabled

data/config/locales/es.yml

@@ -197,11 +197,15 @@ es:
     performance:
       index:
         average_duration: Duración promedio
+        chart_title: Tiempo total de ejecución del trabajo en segundos
         executions: Ejecuciones
         job_class: clase de trabajo
         maximum_duration: Duración máxima
         minimum_duration: Duración mínima
         title: Actuación
+      show:
+        slow: Lento
+        title: Actuación
     processes:
       index:
         cron_enabled: Cron habilitado

data/config/locales/fr.yml

@@ -197,11 +197,15 @@ fr:
     performance:
       index:
         average_duration: Durée moyenne
+        chart_title: Durée totale d'exécution du travail en secondes
         executions: Exécutions
         job_class: Catégorie d'emplois
         maximum_duration: Durée maximale
         minimum_duration: Durée minimale
         title: Performance
+      show:
+        slow: Lenteur
+        title: Performance
     processes:
       index:
         cron_enabled: Cron activé

data/config/locales/it.yml

@@ -197,11 +197,15 @@ it:
     performance:
       index:
         average_duration: Durata media
+        chart_title: Tempo totale di esecuzione del lavoro in secondi
         executions: Esecuzioni
         job_class: Classe di lavoro
         maximum_duration: Durata massima
         minimum_duration: Durata minima
         title: Prestazione
+      show:
+        slow: Lento
+        title: Prestazione
     processes:
       index:
         cron_enabled: Cron abilitato

data/config/locales/ja.yml

@@ -197,11 +197,15 @@ ja:
     performance:
       index:
         average_duration: 平均所要時間
+        chart_title: ジョブの総実行時間（秒
         executions: 処刑
         job_class: 職種
         maximum_duration: 最大持続時間
         minimum_duration: 最小期間
         title: パフォーマンス
+      show:
+        slow: 遅い
+        title: パフォーマンス
     processes:
       index:
         cron_enabled: Cron が有効になっている

data/config/locales/ko.yml

@@ -197,11 +197,15 @@ ko:
     performance:
       index:
         average_duration: 평균 지속 시간
+        chart_title: 총 작업 실행 시간(초)
         executions: 처형
         job_class: 직업군
         maximum_duration: 최대 기간
         minimum_duration: 최소 기간
         title: 성능
+      show:
+        slow: 느림
+        title: 성능
     processes:
       index:
         cron_enabled: Cron이 활성화되어 있음

data/config/locales/nl.yml

@@ -197,11 +197,15 @@ nl:
     performance:
       index:
         average_duration: Gemiddelde duur
+        chart_title: Totale uitvoeringstijd van de taak in seconden
         executions: Executies
         job_class: Functie klasse
         maximum_duration: Maximale duur
         minimum_duration: Minimale duur
         title: Prestatie
+      show:
+        slow: Langzaam
+        title: Prestatie
     processes:
       index:
         cron_enabled: Cron ingeschakeld

data/config/locales/pt-BR.yml

@@ -197,11 +197,15 @@ pt-BR:
     performance:
       index:
         average_duration: Duração média
+        chart_title: Tempo total de execução do trabalho em segundos
         executions: Execuções
         job_class: Classe de trabalho
         maximum_duration: Duração máxima
         minimum_duration: Duração mínima
         title: Desempenho
+      show:
+        slow: Lento
+        title: Desempenho
     processes:
       index:
         cron_enabled: Agendamento ativado

data/config/locales/ru.yml

@@ -223,11 +223,15 @@ ru:
     performance:
       index:
         average_duration: Средняя продолжительность
+        chart_title: Общее время выполнения задания в секундах
         executions: Казни
         job_class: Класс работы
         maximum_duration: Максимальная продолжительность
         minimum_duration: Минимальная продолжительность
         title: Производительность
+      show:
+        slow: Медленный
+        title: Производительность
     processes:
       index:
         cron_enabled: Cron включен

data/config/locales/tr.yml

@@ -197,11 +197,15 @@ tr:
     performance:
       index:
         average_duration: Ortalama süre
+        chart_title: Saniye cinsinden toplam iş yürütme süresi
         executions: İnfazlar
         job_class: İş sınıfı
         maximum_duration: Maksimum süre
         minimum_duration: Minimum süre
         title: Verim
+      show:
+        slow: Yavaş
+        title: Verim
     processes:
       index:
         cron_enabled: Cron etkin

data/config/locales/uk.yml

@@ -223,11 +223,15 @@ uk:
     performance:
       index:
         average_duration: Середня тривалість
+        chart_title: Загальний час виконання завдання в секундах
         executions: Страти
         job_class: Клас роботи
         maximum_duration: Максимальна тривалість
         minimum_duration: Мінімальна тривалість
         title: Продуктивність
+      show:
+        slow: Повільно
+        title: Продуктивність
     processes:
       index:
         cron_enabled: Cron увімкнено

data/config/routes.rb

@@ -31,7 +31,7 @@ GoodJob::Engine.routes.draw do
 
   resources :processes, only: %i[index]
 
-  resources :performance, only: %i[index]
+  resources :performance, only: %i[index show]
 
   scope :frontend, controller: :frontends do
     get "modules/:name", action: :module, as: :frontend_module, constraints: { format: 'js' }

data/lib/good_job/capsule_tracker.rb

@@ -84,7 +84,7 @@ module GoodJob # :nodoc:
             if !advisory_locked? || !advisory_locked_connection?
               @record.class.transaction do
                 @record.advisory_lock!
-                @record.update(lock_type: GoodJob::Process::LOCK_TYPE_ADVISORY)
+                @record.update(lock_type: :advisory)
               end
               @advisory_locked_connection = WeakRef.new(@record.class.connection)
             end

data/lib/good_job/notifier.rb

@@ -27,6 +27,8 @@ module GoodJob # :nodoc:
     RECONNECT_INTERVAL = 5
     # Number of consecutive connection errors before reporting an error
     CONNECTION_ERRORS_REPORTING_THRESHOLD = 6
+    # Interval for emitting a noop SQL query to keep the connection alive
+    KEEPALIVE_INTERVAL = 10
 
     # Connection errors that will wait {RECONNECT_INTERVAL} before reconnecting
     CONNECTION_ERRORS = %w[
@@ -78,6 +80,7 @@ module GoodJob # :nodoc:
       @enable_listening = enable_listening
       @task = nil
       @capsule = capsule
+      @last_keepalive_time = Time.current
 
       start
       self.class.instances << self
@@ -269,6 +272,10 @@ module GoodJob # :nodoc:
         raw_connection.wait_for_notify(WAIT_INTERVAL) do |channel, _pid, payload|
           yield(channel, payload)
         end
+        if Time.current - @last_keepalive_time >= KEEPALIVE_INTERVAL
+          raw_connection.async_exec("SELECT 1")
+          @last_keepalive_time = Time.current
+        end
       elsif @enable_listening && raw_connection.respond_to?(:jdbc_connection)
         raw_connection.execute_query("SELECT 1")
         notifications = raw_connection.jdbc_connection.getNotifications

data/lib/good_job/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 4.0.3
+  version: 4.1.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 2024-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -248,6 +248,9 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- app/charts/good_job/base_chart.rb
+- app/charts/good_job/performance_index_chart.rb
+- app/charts/good_job/performance_show_chart.rb
 - app/charts/good_job/scheduled_by_queue_chart.rb
 - app/controllers/good_job/application_controller.rb
 - app/controllers/good_job/batches_controller.rb
@@ -308,6 +311,7 @@ files:
 - app/views/good_job/jobs/index.html.erb
 - app/views/good_job/jobs/show.html.erb
 - app/views/good_job/performance/index.html.erb
+- app/views/good_job/performance/show.html.erb
 - app/views/good_job/processes/index.html.erb
 - app/views/good_job/shared/_alert.erb
 - app/views/good_job/shared/_chart.erb