mission_control-jobs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 63e12a3c6650d55dd75e269ca604320316a5400c6e7b9429b16a05de167717a7
+  data.tar.gz: 617b2ea6236f481ed4ee6b6c22e5b72570b75d9e2bcf69e0cf60ba18eec69e06
+SHA512:
+  metadata.gz: 91a3206ed4772d01f441d7fe6ed10b0e8dc27beb6828333b3805ad65cc314d13157c9a6e2d07f0bed46f09f911549d28250244f320a9dc637883135e5c10f627
+  data.tar.gz: c6f173db8d4d4be438b91ad8925d381f5eb44aabda18fcd9f4b174f91bf80922c779ca7eb71132046c952b496c379209c29c7da1aec94f667f01365a51b79c3a

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 37signals, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,244 @@
+# Mission Control — Jobs
+
+This gem provides a Rails-based frontend to Active Job adapters. It currently supports [Resque](https://github.com/resque/resque/) and [Solid Queue](https://github.com/basecamp/solid_queue). Its features depend on those offered by the adapter itself, but at a minimum, it allows you to inspect job queues, jobs currently waiting in those queues, and inspecting and retrying or discarding failed jobs.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "mission_control-jobs"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+## Basic configuration
+
+Mount Mission Control Job's engine where you wish to have it accessible from your app, in your `routes.rb` file:
+
+```ruby
+Rails.application.routes.draw do
+  # ...
+  mount MissionControl::Jobs::Engine, at: "/jobs"
+```
+
+And that's it. With this alone, you should be able to access Mission Control Job's UI, where you can browse the existing queues, jobs pending in these queues, jobs in different statuses, and discard and retry failed jobs:
+
+![Queues tab in a simple app](docs/images/queues-simple.png)
+
+![Failed jobs tab in a simple app](docs/images/failed-jobs-simple.png)
+
+
+### Authentication and base controller class
+
+By default, Mission Control's controllers will extend the host app's `ApplicationController`. If no authentication is enforced, `/jobs` will be available to everyone. You might want to implement some kind of authentication for this in your app. To make this easier, you can specify a different controller as the base class for Mission Control's controllers:
+
+```ruby
+Rails.application.configure do
+  MissionControl::Jobs.base_controller_class = "AdminController"
+end
+```
+
+Or, in your environment config or `application.rb`:
+```ruby
+config.mission_control.jobs.base_controller_class = "AdminController"
+
+```
+
+### Other configuration settings
+
+Besides `base_controller_class`, you can also set the following for `MissionControl::Jobs` or `config.mission_control.jobs`:
+
+- `logger`:  the logger you want Mission Control Jobs to use. Defaults to `ActiveSupport::Logger.new(nil)` (no logging). Notice that this is different from Active Job's logger or Active Job's backend's configured logger.
+- `delay_between_bulk_operation_batches`: how long to wait between batches when performing bulk operations, such as _discard all_ or _retry all_ jobs—defaults to `0`
+- `adapters`: a list of adapters that you want Mission Control to use and extend. By default this will be the adapter you have set for `active_job.queue_adapter`.
+
+This library extends Active Job with a querying interface, and the following setting:
+- `config.active_job.default_page_size`: the internal batch size that Active Job will use when sending queries to the underlying adapter and the batch size for the bulk operations defined above—defaults to `1000`.
+
+## Advanced configuration
+
+When we built Mission Control Jobs, we did it with the idea of managing multiple apps' job backends from a single, centralized app that we used for monitoring, alerts and other tools that related to all our apps. Some of our apps run in more than one datacenter and we run different Resque instances with different Redis configurations in each. Because of this, we added support for multiple apps and multiple adapters per app. Even when running Mission Control Job within the app it manages and a single DC, as we migrated from Resque to Solid Queue, we needed to manage both adapters from Mission Control.
+
+Without adding any additional configuration to [the one described before](#basic-configuration), Mission Control will be configured with one single app and a single server for your configured `active_job.queue_adapter`.
+
+If you want to support multiple adapters, you need to add them to Mission Control configuration via the `adapters` setting mentioned above. For example:
+
+```ruby
+config.mission_control.jobs.adapters = [ :resque, :solid_queue ]
+```
+
+Then, to configure the different apps and/or different servers, you can do so in an initializer like this (taken from our dummy app for testing purposes):
+
+```ruby
+require "resque"
+require "resque_pause_helper"
+
+require "solid_queue"
+
+Resque.redis = Redis::Namespace.new "#{Rails.env}", redis: Redis.new(host: "localhost", port: 6379, thread_safe: true)
+
+SERVERS_BY_APP = {
+  BC4: %w[ resque_ashburn resque_chicago ],
+  HEY: %w[ resque solid_queue ]
+}
+
+def redis_connection_for(app, server)
+  redis_namespace = Redis::Namespace.new "#{app}:#{server}", redis: Resque.redis.instance_variable_get("@redis")
+  Resque::DataStore.new redis_namespace
+end
+
+SERVERS_BY_APP.each do |app, servers|
+  queue_adapters_by_name = servers.collect do |server|
+    queue_adapter = if server.start_with?("resque")
+      ActiveJob::QueueAdapters::ResqueAdapter.new(redis_connection_for(app, server))
+    else
+      ActiveJob::QueueAdapters::SolidQueueAdapter.new
+    end
+
+    [ server, queue_adapter ]
+  end.to_h
+
+  MissionControl::Jobs.applications.add(app, queue_adapters_by_name)
+end
+```
+
+This is an example for two different apps, BC4 and HEY, each one with two servers. BC4 has two Resque servers with two different configurations and HEY has one Resque server and one Solid Queue server.
+
+Currently only one Solid Queue configuration is supported, but support for several Solid Queue backends (with different databases) [is planned](https://github.com/basecamp/mission_control-jobs/issues/35).
+
+This is how we set Resque and Solid Queue together when we migrated from one to the other:
+
+```ruby
+queue_adapters_by_name = {
+  resque: ActiveJob::QueueAdapters.lookup(:resque).new, # This will use Resque.redis as the redis client
+  solid_queue: ActiveJob::QueueAdapters.lookup(:solid_queue).new
+}
+
+MissionControl::Jobs.applications.add("hey", queue_adapters_by_name)
+```
+
+When you have multiple apps and servers configured, you can choose between them with select and toggle menus:
+
+![Queues tab with multiple apps and servers](docs/images/queues-multiple.png)
+
+## Basic UI usage
+
+As mentioned, the features available in Mission Control depend on the adapter you're using, as each adapter supports different features. Besides inspecting the queues and the jobs in them, and discarding and retrying failed jobs, you can inspect jobs in different statuses supported by each adapter, filter them by _queue name_ and _job class name_ (with the idea of [adding more filters in the future](https://github.com/basecamp/mission_control-jobs/issues/30)), pause and un-pause queues (if the adapter allows that), inspect workers, know which jobs are being run by what worker, checking a specific job or a specific worker...
+
+![Default queue tab](docs/images/default-queue.png)
+
+![In-progress jobs tab](docs/images/in-progress-jobs.png)
+
+![Workers tab](docs/images/workers.png)
+
+![Single job](docs/images/single-job.png)
+
+![Single worker](docs/images/single-worker.png)
+
+
+## Console helpers, scripting and dealing with big sets of jobs
+
+Besides the UI, Mission Control provides a light console helper to switch between applications and adapters. Some potentially destructive actions aren't exposed via the UI (for example, discarding jobs that aren't failed, although this might change in the future) but you can always perform these from the console if you know very well what you're doing.
+
+It's also possible that you need to deal with very big sets of jobs that are unmanageable via the UI, or that you wish to write a script to deal with an incident, some cleanup or some data migration. The console helpers and the querying API with which we've extended Active Job come handy here.
+
+First, when connecting to the Rails console, you'll see this new message:
+
+```
+ bin/rails c
+
+
+Type 'jobs_help' to see how to connect to the available job servers to manage jobs
+```
+
+Typing `jobs_help`, you'll get clear instructions about how to switch between applications and adapters:
+
+```
+>> jobs_help
+You can connect to a job server with
+  connect_to <app_id>:<server_id>
+
+Available job servers:
+  * bc4:resque_ashburn
+  * bc4:resque_chicago
+  * hey:resque
+  * hey:solid_queue
+```
+
+And then:
+```
+>> connect_to "hey:solid_queue"
+Connected to hey:solid_queue
+```
+
+Now you're ready to query and operate over jobs for this adapter via the API. Some examples of queries:
+
+```ruby
+
+# All jobs
+ActiveJob.jobs
+
+# All failed jobs
+ActiveJob.jobs.failed
+
+# All pending jobs in some queue
+ActiveJob.jobs.pending.where(queue: "some_queue")
+
+# All failed jobs of a given class
+ActiveJob.jobs.failed.where(job_class: "SomeJob")
+
+# All pending jobs of a given class with limit and offset
+ActiveJob.jobs.pending.where(job_class: "SomeJob").limit(10).offset(5)
+
+# For adpaters that support these statuses:
+# All scheduled/in-progress/finished jobs of a given class
+ActiveJob.jobs.scheudled.where(job_class: "SomeJob")
+ActiveJob.jobs.in_progress.where(job_class: "SomeJob")
+ActiveJob.jobs.finished.where(job_class: "SomeJob")
+
+# For adapters that support filtering by worker:
+# All jobs in progress being run by a given worker
+ActiveJob.jobs.in_progress.where(worker_id: 42)
+```
+
+Some examples of bulk operations:
+
+```ruby
+# Retry all the jobs (only possible for failed jobs)
+ActiveJob.jobs.failed.retry_all
+
+# Retry all the jobs of a given class (only possible for failed jobs)
+ActiveJob.jobs.failed.where(job_class: "SomeJob").retry_all
+
+# Discard all failed jobs
+ActiveJob.jobs.failed.discard_all
+
+# Discard all pending jobs of a given class
+ActiveJob.jobs.pending.where(job_class: "SomeJob").discard_all
+# Or all pending jobs in a given queue:
+ActiveJob.jobs.pending.where(queue_name: "some-queue").discard_all
+```
+
+When performing these bulk operations in the console, a delay of 2 seconds between batches processed will be introduced, set via [`delay_between_bulk_operation_batches`](#other-configuration-settings). You can modify it as
+```ruby
+MissionControl::Jobs.delay_between_bulk_operation_batches = 5.seconds
+```
+
+## Contributing
+
+Thanks for your interest in contributing! To get the app running locally just run:
+```
+bin/setup
+```
+This will load a bunch of jobs as seeds.
+
+We have both unit and functional tests and system tests. If you want to run system tests, you'd need to install [ChromeDriver](https://chromedriver.chromium.org/). Then, you'll be able to run the tests as:
+```
+bin/rails test test/system
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

data/app/assets/config/mission_control_jobs_manifest.js

@@ -0,0 +1,4 @@
+//= link_directory ../stylesheets/mission_control/jobs .css
+//= link_directory ../../javascript/mission_control/jobs .js
+//= link_directory ../../javascript/mission_control/jobs/controllers .js
+//= link_directory ../../javascript/mission_control/jobs/helpers .js

data/app/assets/stylesheets/mission_control/jobs/application.css

@@ -0,0 +1,16 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */
+

data/app/assets/stylesheets/mission_control/jobs/forms.css

@@ -0,0 +1,8 @@
+/* Hide the HTML datalist wonky arrow in Safari and Chrome, since we add it via bulma. */
+[list]::-webkit-calendar-picker-indicator {
+    opacity: 0;
+}
+
+a[disabled] {
+    pointer-events: none;
+}

data/app/assets/stylesheets/mission_control/jobs/jobs.css

@@ -0,0 +1,7 @@
+.filter input {
+    width: 15rem;
+}
+
+.jobs td {
+    word-break: break-all;
+}

data/app/controllers/concerns/mission_control/jobs/adapter_features.rb

@@ -0,0 +1,20 @@
+module MissionControl::Jobs::AdapterFeatures
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :supported_job_statuses, :queue_pausing_supported?, :workers_exposed?
+  end
+
+  private
+    def workers_exposed?
+      MissionControl::Jobs::Current.server.queue_adapter.exposes_workers?
+    end
+
+    def supported_job_statuses
+      MissionControl::Jobs::Current.server.queue_adapter.supported_statuses & ActiveJob::JobsRelation::STATUSES
+    end
+
+    def queue_pausing_supported?
+      MissionControl::Jobs::Current.server.queue_adapter.supports_queue_pausing?
+    end
+end

data/app/controllers/concerns/mission_control/jobs/application_scoped.rb

@@ -0,0 +1,38 @@
+module MissionControl::Jobs::ApplicationScoped
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_application
+    around_action :activating_job_server
+
+    delegate :applications, to: MissionControl::Jobs
+  end
+
+  private
+    def set_application
+      @application = find_application or raise MissionControl::Jobs::Errors::ResourceNotFound, "Application not found"
+      MissionControl::Jobs::Current.application = @application
+    end
+
+    def find_application
+      if params[:application_id]
+        applications[params[:application_id]]
+      else
+        applications.first
+      end
+    end
+
+    def activating_job_server(&block)
+      @server = find_server or raise MissionControl::Jobs::Errors::ResourceNotFound, "Server not found"
+      MissionControl::Jobs::Current.server = @server
+      @server.activating(&block)
+    end
+
+    def find_server
+      if params[:server_id]
+        MissionControl::Jobs::Current.application.servers[params[:server_id]]
+      else
+        @application.servers.first
+      end
+    end
+end

data/app/controllers/concerns/mission_control/jobs/failed_jobs_bulk_operations.rb

@@ -0,0 +1,17 @@
+module MissionControl::Jobs::FailedJobsBulkOperations
+  extend ActiveSupport::Concern
+
+  MAX_NUMBER_OF_JOBS_FOR_BULK_OPERATIONS = 3000
+
+  included do
+    include MissionControl::Jobs::JobFilters
+  end
+
+  private
+    # We set a hard limit to prevent problems with the data store (for example, overloading Redis
+    # or causing replication lag in MySQL). This should be enough for most scenarios. For
+    # cases where we need to retry a huge sets of jobs, we offer a runbook that uses the API.
+    def bulk_limited_filtered_failed_jobs
+      ApplicationJob.jobs.failed.where(**@job_filters).limit(MAX_NUMBER_OF_JOBS_FOR_BULK_OPERATIONS)
+    end
+end

data/app/controllers/concerns/mission_control/jobs/job_filters.rb

@@ -0,0 +1,18 @@
+module MissionControl::Jobs::JobFilters
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_filters
+
+    helper_method :active_filters?
+  end
+
+  private
+    def set_filters
+      @job_filters = { job_class_name: params.dig(:filter, :job_class_name).presence, queue_name: params.dig(:filter, :queue_name).presence }.compact
+    end
+
+    def active_filters?
+      @job_filters.any?
+    end
+end

data/app/controllers/concerns/mission_control/jobs/job_scoped.rb

@@ -0,0 +1,16 @@
+module MissionControl::Jobs::JobScoped
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_job, except: :index
+  end
+
+  private
+    def set_job
+      @job = jobs_relation.find_by_id!(params[:job_id] || params[:id])
+    end
+
+    def jobs_relation
+      raise NotImplementedError
+    end
+end

data/app/controllers/concerns/mission_control/jobs/not_found_redirections.rb

@@ -0,0 +1,25 @@
+module MissionControl::Jobs::NotFoundRedirections
+  extend ActiveSupport::Concern
+
+  included do
+    rescue_from(ActiveJob::Errors::JobNotFoundError) do |error|
+      redirect_to best_location_for_job_relation(error.job_relation), alert: error.message
+    end
+
+    rescue_from(MissionControl::Jobs::Errors::ResourceNotFound) do |error|
+      redirect_to root_url, alert: error.message
+    end
+  end
+
+  private
+    def best_location_for_job_relation(job_relation)
+      case
+      when job_relation.failed?
+        application_jobs_path(@application, :failed)
+      when job_relation.queue_name.present?
+        application_queue_path(@application, job_relation.queue_name)
+      else
+        root_path
+      end
+    end
+end

data/app/controllers/concerns/mission_control/jobs/queue_scoped.rb

@@ -0,0 +1,12 @@
+module MissionControl::Jobs::QueueScoped
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :set_queue
+  end
+
+  private
+    def set_queue
+      @queue = ActiveJob::Base.queues[params[:queue_id]] or raise MissionControl::Jobs::Errors::ResourceNotFound, "Queue '#{params[:queue_id]}' not found"
+    end
+end

data/app/controllers/mission_control/jobs/application_controller.rb

@@ -0,0 +1,11 @@
+class MissionControl::Jobs::ApplicationController < MissionControl::Jobs.base_controller_class.constantize
+  layout "mission_control/jobs/application"
+
+  include MissionControl::Jobs::ApplicationScoped, MissionControl::Jobs::NotFoundRedirections
+  include MissionControl::Jobs::AdapterFeatures
+
+  private
+    def default_url_options
+      { server_id: MissionControl::Jobs::Current.server }
+    end
+end

data/app/controllers/mission_control/jobs/bulk_discards_controller.rb

@@ -0,0 +1,20 @@
+class MissionControl::Jobs::BulkDiscardsController < MissionControl::Jobs::ApplicationController
+  include MissionControl::Jobs::FailedJobsBulkOperations
+
+  def create
+    jobs_to_discard_count = jobs_to_discard.count
+    jobs_to_discard.discard_all
+
+    redirect_to application_jobs_url(@application, :failed), notice: "Discarded #{jobs_to_discard_count} jobs"
+  end
+
+  private
+    def jobs_to_discard
+      if active_filters?
+        bulk_limited_filtered_failed_jobs
+      else
+        # we don't want to apply any limit since "discarding all" without parameters can be optimized in the adapter as a much faster operation
+        ApplicationJob.jobs.failed
+      end
+    end
+end

data/app/controllers/mission_control/jobs/bulk_retries_controller.rb

@@ -0,0 +1,10 @@
+class MissionControl::Jobs::BulkRetriesController < MissionControl::Jobs::ApplicationController
+  include MissionControl::Jobs::FailedJobsBulkOperations
+
+  def create
+    jobs_to_retry_count = bulk_limited_filtered_failed_jobs.count
+    bulk_limited_filtered_failed_jobs.retry_all
+
+    redirect_to application_jobs_url(@application, :failed), notice: "Retried #{jobs_to_retry_count} jobs"
+  end
+end

data/app/controllers/mission_control/jobs/discards_controller.rb

@@ -0,0 +1,13 @@
+class MissionControl::Jobs::DiscardsController < MissionControl::Jobs::ApplicationController
+  include MissionControl::Jobs::JobScoped
+
+  def create
+    @job.discard
+    redirect_to application_jobs_url(@application, :failed), notice: "Discarded job with id #{@job.job_id}"
+  end
+
+  private
+    def jobs_relation
+      ApplicationJob.jobs.failed
+    end
+end

data/app/controllers/mission_control/jobs/jobs_controller.rb

@@ -0,0 +1,37 @@
+class MissionControl::Jobs::JobsController < MissionControl::Jobs::ApplicationController
+  include MissionControl::Jobs::JobScoped, MissionControl::Jobs::JobFilters
+
+  def index
+    @job_class_names = jobs_with_status.job_class_names
+    @queue_names = ApplicationJob.queues.map(&:name)
+
+    @jobs_page = MissionControl::Jobs::Page.new(filtered_jobs_with_status, page: params[:page].to_i)
+    @jobs_count = @jobs_page.total_count
+  end
+
+  def show
+  end
+
+  private
+    def jobs_relation
+      filtered_jobs
+    end
+
+    def filtered_jobs_with_status
+      filtered_jobs.with_status(jobs_status)
+    end
+
+    def jobs_with_status
+      ApplicationJob.jobs.with_status(jobs_status)
+    end
+
+    def filtered_jobs
+      ApplicationJob.jobs.where(**@job_filters)
+    end
+
+    helper_method :jobs_status
+
+    def jobs_status
+      params[:status].presence&.inquiry
+    end
+end

data/app/controllers/mission_control/jobs/queues/pauses_controller.rb

@@ -0,0 +1,15 @@
+class MissionControl::Jobs::Queues::PausesController < MissionControl::Jobs::ApplicationController
+  include MissionControl::Jobs::QueueScoped
+
+  def create
+    @queue.pause
+
+    redirect_back fallback_location: application_queues_url(@application)
+  end
+
+  def destroy
+    @queue.resume
+
+    redirect_back fallback_location: application_queues_url(@application)
+  end
+end

data/app/controllers/mission_control/jobs/queues_controller.rb

@@ -0,0 +1,24 @@
+class MissionControl::Jobs::QueuesController < MissionControl::Jobs::ApplicationController
+  before_action :set_queue, only: :show
+
+  def index
+    @queues = filtered_queues.sort_by(&:name)
+  end
+
+  def show
+    @jobs_page = MissionControl::Jobs::Page.new(@queue.jobs, page: params[:page].to_i)
+  end
+
+  private
+    def set_queue
+      @queue = ApplicationJob.queues[params[:id]]
+    end
+
+    def filtered_queues
+      if prefix = ApplicationJob.queue_name_prefix
+        ApplicationJob.queues.select { |queue| queue.name.start_with?(prefix) }
+      else
+        ApplicationJob.queues
+      end
+    end
+end

data/app/controllers/mission_control/jobs/retries_controller.rb

@@ -0,0 +1,13 @@
+class MissionControl::Jobs::RetriesController < MissionControl::Jobs::ApplicationController
+  include MissionControl::Jobs::JobScoped
+
+  def create
+    @job.retry
+    redirect_to application_jobs_url(@application, :failed), notice: "Retried job with id #{@job.job_id}"
+  end
+
+  private
+    def jobs_relation
+      ApplicationJob.jobs.failed
+    end
+end

data/app/controllers/mission_control/jobs/workers_controller.rb

@@ -0,0 +1,18 @@
+class MissionControl::Jobs::WorkersController < MissionControl::Jobs::ApplicationController
+  before_action :ensure_exposed_workers
+
+  def index
+    @workers = MissionControl::Jobs::Current.server.workers.sort_by { |worker| -worker.jobs.count }
+  end
+
+  def show
+    @worker = MissionControl::Jobs::Current.server.find_worker(params[:id])
+  end
+
+  private
+    def ensure_exposed_workers
+      unless workers_exposed?
+        redirect_to root_url, alert: "This server doesn't expose workers"
+      end
+    end
+end

data/app/helpers/mission_control/jobs/application_helper.rb

@@ -0,0 +1,8 @@
+module MissionControl::Jobs
+  module ApplicationHelper
+    # Explicit helper inclusion because ApplicationController inherits from the host app.
+    #
+    # We can't rely on +config.action_controller.include_all_helpers = true+ in the host app.
+    include DatesHelper, JobsHelper, NavigationHelper, UiHelper
+  end
+end