good_job 2.1.0 → 2.4.0

data/lib/good_job/job.rb

@@ -1,299 +1,11 @@
 # frozen_string_literal: true
 module GoodJob
-  # ActiveRecord model that represents an +ActiveJob+ job.
-  # Parent class can be configured with +GoodJob.active_record_parent_class+.
-  # @!parse
-  #   class Job < ActiveRecord::Base; end
-  class Job < Object.const_get(GoodJob.active_record_parent_class)
-    include Lockable
-
-    # Raised if something attempts to execute a previously completed Job again.
-    PreviouslyPerformedError = Class.new(StandardError)
-
-    # ActiveJob jobs without a +queue_name+ attribute are placed on this queue.
-    DEFAULT_QUEUE_NAME = 'default'
-    # ActiveJob jobs without a +priority+ attribute are given this priority.
-    DEFAULT_PRIORITY = 0
-
-    self.table_name = 'good_jobs'
-    self.advisory_lockable_column = 'active_job_id'
-
-    # Parse a string representing a group of queues into a more readable data
-    # structure.
-    # @param string [String] Queue string
-    # @return [Hash]
-    #   How to match a given queue. It can have the following keys and values:
-    #   - +{ all: true }+ indicates that all queues match.
-    #   - +{ exclude: Array<String> }+ indicates the listed queue names should
-    #     not match.
-    #   - +{ include: Array<String> }+ indicates the listed queue names should
-    #     match.
-    # @example
-    #   GoodJob::Job.queue_parser('-queue1,queue2')
-    #   => { exclude: [ 'queue1', 'queue2' ] }
-    def self.queue_parser(string)
-      string = string.presence || '*'
-
-      if string.first == '-'
-        exclude_queues = true
-        string = string[1..-1]
-      end
-
-      queues = string.split(',').map(&:strip)
-
-      if queues.include?('*')
-        { all: true }
-      elsif exclude_queues
-        { exclude: queues }
-      else
-        { include: queues }
-      end
-    end
-
-    # Get Jobs with given class name
-    # @!method with_job_class
-    # @!scope class
-    # @param string [String]
-    #   Job class name
-    # @return [ActiveRecord::Relation]
-    scope :with_job_class, ->(job_class) { where("serialized_params->>'job_class' = ?", job_class) }
-
-    # Get Jobs that have not yet been completed.
-    # @!method unfinished
-    # @!scope class
-    # @return [ActiveRecord::Relation]
-    scope :unfinished, -> { where(finished_at: nil) }
-
-    # Get Jobs that are not scheduled for a later time than now (i.e. jobs that
-    # are not scheduled or scheduled for earlier than the current time).
-    # @!method only_scheduled
-    # @!scope class
-    # @return [ActiveRecord::Relation]
-    scope :only_scheduled, -> { where(arel_table['scheduled_at'].lteq(Time.current)).or(where(scheduled_at: nil)) }
-
-    # Order jobs by priority (highest priority first).
-    # @!method priority_ordered
-    # @!scope class
-    # @return [ActiveRecord::Relation]
-    scope :priority_ordered, -> { order('priority DESC NULLS LAST') }
-
-    # Order jobs by scheduled (unscheduled or soonest first).
-    # @!method schedule_ordered
-    # @!scope class
-    # @return [ActiveRecord::Relation]
-    scope :schedule_ordered, -> { order(Arel.sql('COALESCE(scheduled_at, created_at) ASC')) }
-
-    # Get Jobs were completed before the given timestamp. If no timestamp is
-    # provided, get all jobs that have been completed. By default, GoodJob
-    # deletes jobs after they are completed and this will find no jobs.
-    # However, if you have changed {GoodJob.preserve_job_records}, this may
-    # find completed Jobs.
-    # @!method finished(timestamp = nil)
-    # @!scope class
-    # @param timestamp (Float)
-    #   Get jobs that finished before this time (in epoch time).
-    # @return [ActiveRecord::Relation]
-    scope :finished, ->(timestamp = nil) { timestamp ? where(arel_table['finished_at'].lteq(timestamp)) : where.not(finished_at: nil) }
-
-    # Get Jobs that started but not finished yet.
-    # @!method running
-    # @!scope class
-    # @return [ActiveRecord::Relation]
-    scope :running, -> { where.not(performed_at: nil).where(finished_at: nil) }
-
-    # Get Jobs that do not have subsequent retries
-    # @!method running
-    # @!scope class
-    # @return [ActiveRecord::Relation]
-    scope :head, -> { where(retried_good_job_id: nil) }
-
-    # Get Jobs have errored that will not be retried further
-    # @!method running
-    # @!scope class
-    # @return [ActiveRecord::Relation]
-    scope :dead, -> { head.where.not(error: nil) }
-
-    # Get Jobs on queues that match the given queue string.
-    # @!method queue_string(string)
-    # @!scope class
-    # @param string [String]
-    #   A string expression describing what queues to select. See
-    #   {Job.queue_parser} or
-    #   {file:README.md#optimize-queues-threads-and-processes} for more details
-    #   on the format of the string. Note this only handles individual
-    #   semicolon-separated segments of that string format.
-    # @return [ActiveRecord::Relation]
-    scope :queue_string, (lambda do |string|
-      parsed = queue_parser(string)
-
-      if parsed[:all]
-        all
-      elsif parsed[:exclude]
-        where.not(queue_name: parsed[:exclude]).or where(queue_name: nil)
-      elsif parsed[:include]
-        where(queue_name: parsed[:include])
-      end
-    end)
-
-    # Get Jobs in display order with optional keyset pagination.
-    # @!method display_all(after_scheduled_at: nil, after_id: nil)
-    # @!scope class
-    # @param after_scheduled_at [DateTime, String, nil]
-    #   Display records scheduled after this time for keyset pagination
-    # @param after_id [Numeric, String, nil]
-    #   Display records after this ID for keyset pagination
-    # @return [ActiveRecord::Relation]
-    scope :display_all, (lambda do |after_scheduled_at: nil, after_id: nil|
-      query = order(Arel.sql('COALESCE(scheduled_at, created_at) DESC, id DESC'))
-      if after_scheduled_at.present? && after_id.present?
-        query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at), id) < (:after_scheduled_at, :after_id)'), after_scheduled_at: after_scheduled_at, after_id: after_id)
-      elsif after_scheduled_at.present?
-        query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at)) < (:after_scheduled_at)'), after_scheduled_at: after_scheduled_at)
-      end
-      query
-    end)
-
-    # Finds the next eligible Job, acquire an advisory lock related to it, and
-    # executes the job.
-    # @return [ExecutionResult, nil]
-    #   If a job was executed, returns an array with the {Job} record, the
-    #   return value for the job's +#perform+ method, and the exception the job
-    #   raised, if any (if the job raised, then the second array entry will be
-    #   +nil+). If there were no jobs to execute, returns +nil+.
-    def self.perform_with_advisory_lock
-      unfinished.priority_ordered.only_scheduled.limit(1).with_advisory_lock(unlock_session: true) do |good_jobs|
-        good_job = good_jobs.first
-        break if good_job.blank?
-        break :unlocked unless good_job&.executable?
-
-        begin
-          good_job.with_advisory_lock(key: "good_jobs-#{good_job.active_job_id}") do
-            good_job.perform
-          end
-        rescue RecordAlreadyAdvisoryLockedError => e
-          ExecutionResult.new(value: nil, handled_error: e)
-        end
-      end
-    end
-
-    # Fetches the scheduled execution time of the next eligible Job(s).
-    # @param after [DateTime]
-    # @param limit [Integer]
-    # @param now_limit [Integer, nil]
-    # @return [Array<DateTime>]
-    def self.next_scheduled_at(after: nil, limit: 100, now_limit: nil)
-      query = advisory_unlocked.unfinished.schedule_ordered
-
-      after ||= Time.current
-      after_query = query.where('scheduled_at > ?', after).or query.where(scheduled_at: nil).where('created_at > ?', after)
-      after_at = after_query.limit(limit).pluck(:scheduled_at, :created_at).map { |timestamps| timestamps.compact.first }
-
-      if now_limit&.positive?
-        now_query = query.where('scheduled_at < ?', Time.current).or query.where(scheduled_at: nil)
-        now_at = now_query.limit(now_limit).pluck(:scheduled_at, :created_at).map { |timestamps| timestamps.compact.first }
-      end
-
-      Array(now_at) + after_at
-    end
-
-    # Places an ActiveJob job on a queue by creating a new {Job} record.
-    # @param active_job [ActiveJob::Base]
-    #   The job to enqueue.
-    # @param scheduled_at [Float]
-    #   Epoch timestamp when the job should be executed.
-    # @param create_with_advisory_lock [Boolean]
-    #   Whether to establish a lock on the {Job} record after it is created.
-    # @return [Job]
-    #   The new {Job} instance representing the queued ActiveJob job.
-    def self.enqueue(active_job, scheduled_at: nil, create_with_advisory_lock: false)
-      ActiveSupport::Notifications.instrument("enqueue_job.good_job", { active_job: active_job, scheduled_at: scheduled_at, create_with_advisory_lock: create_with_advisory_lock }) do |instrument_payload|
-        good_job_args = {
-          active_job_id: active_job.job_id,
-          queue_name: active_job.queue_name.presence || DEFAULT_QUEUE_NAME,
-          priority: active_job.priority || DEFAULT_PRIORITY,
-          serialized_params: active_job.serialize,
-          scheduled_at: scheduled_at,
-          create_with_advisory_lock: create_with_advisory_lock,
-        }
-
-        good_job_args[:concurrency_key] = active_job.good_job_concurrency_key if active_job.respond_to?(:good_job_concurrency_key)
-
-        if CurrentExecution.cron_key
-          good_job_args[:cron_key] = CurrentExecution.cron_key
-        elsif CurrentExecution.active_job_id == active_job.job_id
-          good_job_args[:cron_key] = CurrentExecution.good_job.cron_key
-        end
-
-        good_job = GoodJob::Job.new(**good_job_args)
-
-        instrument_payload[:good_job] = good_job
-
-        good_job.save!
-        active_job.provider_job_id = good_job.id
-
-        CurrentExecution.good_job.retried_good_job_id = good_job.id if CurrentExecution.good_job && CurrentExecution.good_job.active_job_id == active_job.job_id
-
-        good_job
-      end
-    end
-
-    # Execute the ActiveJob job this {Job} represents.
-    # @return [ExecutionResult]
-    #   An array of the return value of the job's +#perform+ method and the
-    #   exception raised by the job, if any. If the job completed successfully,
-    #   the second array entry (the exception) will be +nil+ and vice versa.
-    def perform
-      raise PreviouslyPerformedError, 'Cannot perform a job that has already been performed' if finished_at
-
-      self.performed_at = Time.current
-      save! if GoodJob.preserve_job_records
-
-      result = execute
-
-      job_error = result.handled_error || result.unhandled_error
-      self.error = "#{job_error.class}: #{job_error.message}" if job_error
-
-      if result.unhandled_error && GoodJob.retry_on_unhandled_error
-        save!
-      elsif GoodJob.preserve_job_records == true || (result.unhandled_error && GoodJob.preserve_job_records == :on_unhandled_error)
-        self.finished_at = Time.current
-        save!
-      else
-        destroy!
-      end
-
-      result
-    end
-
-    # Tests whether this job is safe to be executed by this thread.
-    # @return [Boolean]
-    def executable?
-      self.class.unscoped.unfinished.owns_advisory_locked.exists?(id: id)
-    end
-
-    private
-
-    # @return [ExecutionResult]
-    def execute
-      GoodJob::CurrentExecution.reset
-      GoodJob::CurrentExecution.good_job = self
-
-      job_data = serialized_params.deep_dup
-      job_data["provider_job_id"] = id
-
-      ActiveSupport::Notifications.instrument("perform_job.good_job", { good_job: self, process_id: GoodJob::CurrentExecution.process_id, thread_name: GoodJob::CurrentExecution.thread_name }) do
-        value = ActiveJob::Base.execute(job_data)
-
-        if value.is_a?(Exception)
-          handled_error = value
-          value = nil
-        end
-        handled_error ||= GoodJob::CurrentExecution.error_on_retry || GoodJob::CurrentExecution.error_on_discard
-
-        ExecutionResult.new(value: value, handled_error: handled_error)
-      rescue StandardError => e
-        ExecutionResult.new(value: nil, unhandled_error: e)
-      end
+  # @deprecated Use {GoodJob::Execution} instead.
+  class Job < Execution
+    after_initialize do |_job|
+      ActiveSupport::Deprecation.warn(
+        "The `GoodJob::Job` class name is deprecated. Replace with `GoodJob::Execution`."
+      )
     end
   end
 end

data/lib/good_job/job_performer.rb

@@ -14,8 +14,8 @@ module GoodJob
     def initialize(queue_string)
       @queue_string = queue_string
 
-      @job_query = Concurrent::Delay.new { GoodJob::Job.queue_string(queue_string) }
-      @parsed_queues = Concurrent::Delay.new { GoodJob::Job.queue_parser(queue_string) }
+      @job_query = Concurrent::Delay.new { GoodJob::Execution.queue_string(queue_string) }
+      @parsed_queues = Concurrent::Delay.new { GoodJob::Execution.queue_parser(queue_string) }
     end
 
     # A meaningful name to identify the performer in logs and for debugging.

data/lib/good_job/log_subscriber.rb

@@ -19,10 +19,10 @@ module GoodJob
     #   @return [void]
     def create(event)
       # FIXME: This method does not match any good_job notifications.
-      good_job = event.payload[:good_job]
+      execution = event.payload[:execution]
 
       debug do
-        "GoodJob created job resource with id #{good_job.id}"
+        "GoodJob created job resource with id #{execution.id}"
       end
     end
 
@@ -96,12 +96,12 @@ module GoodJob
 
     # @!macro notification_responder
     def perform_job(event)
-      good_job = event.payload[:good_job]
+      execution = event.payload[:execution]
       process_id = event.payload[:process_id]
       thread_name = event.payload[:thread_name]
 
       info(tags: [process_id, thread_name]) do
-        "Executed GoodJob #{good_job.id}"
+        "Executed GoodJob #{execution.id}"
       end
     end
 

data/lib/good_job/notifier.rb

@@ -39,7 +39,7 @@ module GoodJob # :nodoc:
     # Send a message via Postgres NOTIFY
     # @param message [#to_json]
     def self.notify(message)
-      connection = Job.connection
+      connection = Execution.connection
       connection.exec_query <<~SQL.squish
         NOTIFY #{CHANNEL}, #{connection.quote(message.to_json)}
       SQL
@@ -169,8 +169,8 @@ module GoodJob # :nodoc:
     end
 
     def with_listen_connection
-      ar_conn = Job.connection_pool.checkout.tap do |conn|
-        Job.connection_pool.remove(conn)
+      ar_conn = Execution.connection_pool.checkout.tap do |conn|
+        Execution.connection_pool.remove(conn)
       end
       pg_conn = ar_conn.raw_connection
       raise AdapterCannotListenError unless pg_conn.respond_to? :wait_for_notify

data/lib/good_job/railtie.rb

@@ -14,11 +14,11 @@ module GoodJob
 
     initializer "good_job.active_job_notifications" do
       ActiveSupport::Notifications.subscribe "enqueue_retry.active_job" do |event|
-        GoodJob::CurrentExecution.error_on_retry = event.payload[:error]
+        GoodJob::CurrentThread.error_on_retry = event.payload[:error]
       end
 
       ActiveSupport::Notifications.subscribe "discard.active_job" do |event|
-        GoodJob::CurrentExecution.error_on_discard = event.payload[:error]
+        GoodJob::CurrentThread.error_on_discard = event.payload[:error]
       end
     end
 

data/lib/good_job/scheduler.rb

@@ -230,7 +230,7 @@ module GoodJob # :nodoc:
     # @return [void]
     def create_task(delay = 0)
       future = Concurrent::ScheduledTask.new(delay, args: [performer], executor: executor, timer_set: timer_set) do |thr_performer|
-        Rails.application.executor.wrap do
+        Rails.application.reloader.wrap do
           thr_performer.next
         end
       end
@@ -244,8 +244,8 @@ module GoodJob # :nodoc:
     def instrument(name, payload = {}, &block)
       payload = payload.reverse_merge({
                                         scheduler: self,
-                                        process_id: GoodJob::CurrentExecution.process_id,
-                                        thread_name: GoodJob::CurrentExecution.thread_name,
+                                        process_id: GoodJob::CurrentThread.process_id,
+                                        thread_name: GoodJob::CurrentThread.thread_name,
                                       })
 
       ActiveSupport::Notifications.instrument("#{name}.good_job", payload, &block)

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '2.1.0'
+  VERSION = '2.4.0'
 end

data/lib/good_job.rb

@@ -20,7 +20,7 @@ require "good_job/railtie"
 module GoodJob
   # @!attribute [rw] active_record_parent_class
   #   @!scope class
-  #   The ActiveRecord parent class inherited by +GoodJob::Job+ (default: +ActiveRecord::Base+).
+  #   The ActiveRecord parent class inherited by +GoodJob::Execution+ (default: +ActiveRecord::Base+).
   #   Use this when using multiple databases or other custom ActiveRecord configuration.
   #   @return [ActiveRecord::Base]
   #   @example Change the base class:
@@ -129,7 +129,7 @@ module GoodJob
     timestamp = Time.current - older_than
 
     ActiveSupport::Notifications.instrument("cleanup_preserved_jobs.good_job", { older_than: older_than, timestamp: timestamp }) do |payload|
-      deleted_records_count = GoodJob::Job.finished(timestamp).delete_all
+      deleted_records_count = GoodJob::Execution.finished(timestamp).delete_all
 
       payload[:deleted_records_count] = deleted_records_count
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-09 00:00:00.000000000 Z
+date: 2021-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -351,15 +351,23 @@ files:
 - engine/app/assets/vendor/bootstrap/bootstrap.min.css
 - engine/app/assets/vendor/chartist/chartist.css
 - engine/app/assets/vendor/chartist/chartist.js
-- engine/app/controllers/good_job/active_jobs_controller.rb
 - engine/app/controllers/good_job/assets_controller.rb
 - engine/app/controllers/good_job/base_controller.rb
-- engine/app/controllers/good_job/dashboards_controller.rb
+- engine/app/controllers/good_job/cron_schedules_controller.rb
+- engine/app/controllers/good_job/executions_controller.rb
 - engine/app/controllers/good_job/jobs_controller.rb
+- engine/app/filters/good_job/base_filter.rb
+- engine/app/filters/good_job/executions_filter.rb
+- engine/app/filters/good_job/jobs_filter.rb
 - engine/app/helpers/good_job/application_helper.rb
-- engine/app/views/good_job/active_jobs/show.html.erb
-- engine/app/views/good_job/dashboards/index.html.erb
+- engine/app/models/good_job/active_job_job.rb
+- engine/app/views/good_job/cron_schedules/index.html.erb
+- engine/app/views/good_job/executions/index.html.erb
+- engine/app/views/good_job/jobs/index.html.erb
+- engine/app/views/good_job/jobs/show.html.erb
 - engine/app/views/good_job/shared/_chart.erb
+- engine/app/views/good_job/shared/_executions_table.erb
+- engine/app/views/good_job/shared/_filter.erb
 - engine/app/views/good_job/shared/_jobs_table.erb
 - engine/app/views/good_job/shared/icons/_check.html.erb
 - engine/app/views/good_job/shared/icons/_exclamation.html.erb
@@ -380,8 +388,9 @@ files:
 - lib/good_job/cli.rb
 - lib/good_job/configuration.rb
 - lib/good_job/cron_manager.rb
-- lib/good_job/current_execution.rb
+- lib/good_job/current_thread.rb
 - lib/good_job/daemon.rb
+- lib/good_job/execution.rb
 - lib/good_job/execution_result.rb
 - lib/good_job/job.rb
 - lib/good_job/job_performer.rb

data/engine/app/controllers/good_job/active_jobs_controller.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-module GoodJob
-  class ActiveJobsController < GoodJob::BaseController
-    def show
-      @jobs = GoodJob::Job.where("serialized_params ->> 'job_id' = ?", params[:id])
-                          .order(Arel.sql("COALESCE(scheduled_at, created_at) DESC"))
-    end
-  end
-end

data/engine/app/controllers/good_job/dashboards_controller.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-module GoodJob
-  class DashboardsController < GoodJob::BaseController
-    class JobFilter
-      attr_accessor :params
-
-      def initialize(params)
-        @params = params
-      end
-
-      def last
-        @_last ||= jobs.last
-      end
-
-      def jobs
-        after_scheduled_at = params[:after_scheduled_at].present? ? Time.zone.parse(params[:after_scheduled_at]) : nil
-        sql = GoodJob::Job.display_all(after_scheduled_at: after_scheduled_at, after_id: params[:after_id])
-                          .limit(params.fetch(:limit, 25))
-        sql = sql.with_job_class(params[:job_class]) if params[:job_class]
-        if params[:state]
-          case params[:state]
-          when 'finished'
-            sql = sql.finished
-          when 'unfinished'
-            sql = sql.unfinished
-          when 'running'
-            sql = sql.running
-          when 'errors'
-            sql = sql.where.not(error: nil)
-          end
-        end
-        sql
-      end
-
-      def states
-        {
-          'finished' => GoodJob::Job.finished.count,
-          'unfinished' => GoodJob::Job.unfinished.count,
-          'running' => GoodJob::Job.running.count,
-          'errors' => GoodJob::Job.where.not(error: nil).count,
-        }
-      end
-
-      def job_classes
-        GoodJob::Job.group("serialized_params->>'job_class'").count
-      end
-
-      def to_params(override)
-        {
-          state: params[:state],
-          job_class: params[:job_class],
-        }.merge(override).delete_if { |_, v| v.nil? }
-      end
-    end
-
-    def index
-      @filter = JobFilter.new(params)
-
-      count_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,
-              queue_name,
-              count(*) AS count
-            FROM (
-              SELECT
-                COALESCE(scheduled_at, created_at)::timestamp AS scheduled_at,
-                queue_name
-              FROM good_jobs
-            ) sources
-            GROUP BY date_trunc('hour', scheduled_at), queue_name
-        ) sources ON sources.scheduled_at = timestamp
-        ORDER BY timestamp ASC
-      SQL
-
-      current_time = Time.current
-      binds = [[nil, current_time - 1.day], [nil, current_time]]
-      job_data = GoodJob::Job.connection.exec_query(count_query, "GoodJob Dashboard Chart", binds)
-
-      queue_names = job_data.map { |d| d['queue_name'] }.uniq
-      labels = []
-      queues_data = job_data.to_a.group_by { |d| d['timestamp'] }.each_with_object({}) do |(timestamp, values), hash|
-        labels << timestamp.in_time_zone.strftime('%H:%M %z')
-        queue_names.each do |queue_name|
-          (hash[queue_name] ||= []) << values.find { |d| d['queue_name'] == queue_name }&.[]('count')
-        end
-      end
-
-      @chart = {
-        labels: labels,
-        series: queues_data.map do |queue, data|
-          {
-            name: queue,
-            data: data,
-          }
-        end,
-      }
-    end
-  end
-end

data/engine/app/views/good_job/active_jobs/show.html.erb

@@ -1 +0,0 @@
-<%= render 'good_job/shared/jobs_table', jobs: @jobs %>

data/engine/app/views/good_job/dashboards/index.html.erb

@@ -1,54 +0,0 @@
-<div class="card my-3 p-6">
-  <%= render 'good_job/shared/chart', chart_data: @chart %>
-</div>
-
-<div class='card mb-2'>
-  <div class='card-body d-flex flex-wrap'>
-    <div class='me-4'>
-      <small>Filter by job class</small>
-      <br>
-      <% @filter.job_classes.each do |name, count| %>
-        <% if params[:job_class] == name %>
-          <%= link_to(root_path(@filter.to_params(job_class: nil)), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
-            <%= name %> (<%= count %>)
-          <% end %>
-        <% else %>
-          <%= link_to(root_path(@filter.to_params(job_class: name)), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
-            <%= name %> (<%= count %>)
-          <% end %>
-        <% end %>
-      <% end %>
-    </div>
-    <div>
-      <small>Filter by state</small>
-      <br>
-      <% @filter.states.each do |name, count| %>
-        <% if params[:state] == name %>
-          <%= link_to(root_path(@filter.to_params(state: nil)), class: 'btn btn-sm btn-outline-secondary active', role: "button", "aria-pressed": true)  do %>
-            <%= name %> (<%= count %>)
-          <% end %>
-        <% else %>
-          <%= link_to(root_path(@filter.to_params(state: name)), class: 'btn btn-sm btn-outline-secondary', role: "button") do %>
-            <%= name %> (<%= count %>)
-          <% end %>
-        <% end %>
-      <% end %>
-    </div>
-  </div>
-</div>
-
-<% if @filter.jobs.present? %>
-  <%= render 'good_job/shared/jobs_table', jobs: @filter.jobs %>
-
-  <nav aria-label="Job pagination" class="mt-3">
-    <ul class="pagination">
-      <li class="page-item">
-        <%= link_to({ after_scheduled_at: (@filter.last.scheduled_at || @filter.last.created_at), after_id: @filter.last.id }, class: "page-link") do %>
-          Next jobs <span aria-hidden="true">&raquo;</span>
-        <% end %>
-      </li>
-    </ul>
-  </nav>
-<% else %>
-  <em>No jobs present.</em>
-<% end %>