flight_control 2.0.0.beta.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ad093eeb61f357dc4aead0c094eb413607dfa234cd7cdf4ed15579a0fa0af51
+  data.tar.gz: a7774ba9273438d984569b4f739795019caaea77d1f1e42b033cd862e0af9231
+SHA512:
+  metadata.gz: 9ce93746fa317b44831c7fa4d12bca2590d25a76f4eeb375041df08895f326d1e8c25a414d10da06638b0c072c933c84bdbbe338bbf27a04dd77d0e93e8c9324
+  data.tar.gz: 986514c76126354436fe67b584289a17cf864314f126c9f7c159f1207e48c7dd3816860b82fde3115cc04ecde18e7e483528ae3b93a7d3f8127c2264f89053c5

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [Unreleased]
+
+## [2.0.0] - 2026-07-20
+
+- Drops support for Resque and Async adapters to focus on Solid Queue.
+- Drops support for Rails versions below 8.1.
+- Lists newest jobs first on all pages.
+- Adds a way to run any Active Job and set parameters for it.
+- Shows job run duration in tables with failed and finished jobs.
+- Shows Enqueued and Finished as timestamps in addition to relative time.

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,265 @@
+# Flight Control
+
+A Rails-based frontend for managing [Solid Queue](https://github.com/rails/solid_queue) jobs through Active Job. It lets you inspect job queues and jobs in every status, retry or discard failed jobs, manage recurring tasks and workers, and enqueue any job defined in your application straight from the UI.
+
+Flight Control is a fork of [Mission Control — Jobs](https://github.com/rails/mission_control-jobs) that focuses exclusively on Solid Queue. Resque support has been removed.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "flight_control"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Flight Control requires Solid Queue (>= 1.0) configured as your Active Job queue adapter.
+
+## Basic configuration
+
+Mount the Flight Control engine where you wish to have it accessible from your app, in your `routes.rb` file:
+
+```ruby
+Rails.application.routes.draw do
+  # ...
+  mount FlightControl::Engine, at: "/jobs"
+```
+
+Once you set up [Authentication](#authentication), you should be able to access Flight Control'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)
+
+### API-only apps or apps using `vite_rails` and other asset pipelines outside Rails
+
+If you want to use this gem with an [API-only Rails app](https://guides.rubyonrails.org/api_app.html) or an app that's using `vite_ruby`/`vite_rails`, or some other custom asset pipeline different from Sprockets and Propshaft, you need one more thing: configure an asset pipeline so you can serve the JavaScript and CSS included in this gem. We recommend to use [`Propshaft`](https://github.com/rails/propshaft). You simply need to add this line to your application's Gemfile:
+
+```ruby
+gem "propshaft"
+```
+
+Then execute
+```bash
+$ bundle install
+```
+
+Then, make sure you add a step to your deployment pipeline to precompile assets:
+```
+RAILS_ENV=production rails assets:precompile
+```
+
+For example, if you're using the Dockerfile generated by Rails with an API-only app or having skipped the assets pipeline, re-add:
+```
+# Precompiling assets for production without requiring secret RAILS_MASTER_KEY
+RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile
+```
+
+### Authentication
+
+Flight Control comes with **HTTP basic authentication enabled and closed** by default. Credentials are stored in [Rails's credentials](https://edgeguides.rubyonrails.org/security.html#custom-credentials) like this:
+```yml
+flight_control:
+  http_basic_auth_user: dev
+  http_basic_auth_password: secret
+```
+
+If no credentials are configured, Flight Control won't be accessible. To set these up, you can run the generator provided like this:
+
+```
+bin/rails flight_control:authentication:configure
+```
+
+To set them up for different environments you can use the `RAILS_ENV` environment variable, like this:
+```
+RAILS_ENV=production bin/rails flight_control:authentication:configure
+```
+
+User and password can also be configured by hand like this:
+
+```ruby
+Rails.application.configure do
+  FlightControl.http_basic_auth_user = "dev"
+  FlightControl.http_basic_auth_password = "secret"
+end
+```
+
+#### Custom authentication
+
+You can provide your own authentication mechanism, for example, if you have a certain type of admin user in your app that can access Flight Control. To make this easier, you can specify a different controller as the base class for Flight Control's controllers. By default, Flight Control's controllers will extend the host app's `ApplicationController`, but you can change this easily:
+
+```ruby
+Rails.application.configure do
+  FlightControl.base_controller_class = "AdminController"
+end
+```
+
+Or, in your environment config or `application.rb`:
+```ruby
+config.flight_control.base_controller_class = "AdminController"
+```
+
+If you do this, you can disable the default HTTP Basic Authentication using the following option:
+```ruby
+config.flight_control.http_basic_auth_enabled = false
+```
+
+### Other configuration settings
+
+Besides `base_controller_class`, you can also set the following for `FlightControl` or `config.flight_control`:
+
+- `logger`:  the logger you want Flight Control 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`
+- `internal_query_count_limit`: in count queries, the maximum number of records that will be counted if the adapter needs to limit these queries. True counts above this number will be returned as `INFINITY`. This keeps count queries fast—defaults to `500,000`
+- `scheduled_job_delay_threshold`: the time duration before a scheduled job is considered delayed. Defaults to `1.minute` (a job is considered delayed if it hasn't transitioned from the `scheduled` status 1 minute after the scheduled time).
+- `show_console_help`: whether to show the console help. If you don't want the console help message, set this to `false`—defaults to `true`.
+- `backtrace_cleaner`: a backtrace cleaner used for optionally filtering backtraces on the Failed Jobs detail page. Defaults to `Rails::BacktraceCleaner.new`. See the [Advanced configuration](#advanced-configuration) section for how to configure/override this setting on a per application/server basis.
+- `filter_arguments`: an array of strings representing the job argument keys you want to filter out in the UI. This is useful for hiding sensitive user data. Currently, only root-level hash keys are supported.
+
+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
+
+Without adding any additional configuration to [the one described before](#basic-configuration), Flight Control will be configured with one single app and a single Solid Queue server.
+
+If you manage multiple apps' job backends from a single, centralized app, you can configure the different apps and/or different servers in an initializer like this:
+
+```ruby
+FlightControl.applications.add("hey", solid_queue: ActiveJob::QueueAdapters::SolidQueueAdapter.new)
+FlightControl.applications.add("campfire", solid_queue: ActiveJob::QueueAdapters::SolidQueueAdapter.new)
+```
+
+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
+
+Besides inspecting the queues and the jobs in them, and discarding and retrying failed jobs, you can inspect jobs in different statuses, filter them by _queue name_ and _job class name_, pause and un-pause queues, inspect workers, know which jobs are being run by what worker, check a specific job or a specific worker, and manage recurring tasks.
+
+Job lists are sorted newest first: the most recently enqueued (or finished) jobs appear at the top. Scheduled jobs are the exception; they're listed in the order they will run.
+
+### Running jobs from the UI
+
+The **Run job** tab lets you enqueue any job class defined in your application. Pick the job class, provide its arguments as a JSON array, and optionally override the queue. A trailing JSON object is passed to the job as keyword arguments; for example, for a job defined as `def perform(post_id, notify: false)` you'd enter:
+
+```json
+[ 123, { "notify": true } ]
+```
+
+Arguments must be expressible as JSON, so jobs that take records or other rich objects as arguments can't be launched this way.
+
+![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, Flight Control provides a light console helper to switch between applications and servers. 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 in 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 servers:
+
+```
+>> jobs_help
+You can connect to a job server with
+  connect_to "<app_id>:<server_id>"
+
+Available job servers:
+  * hey:solid_queue
+  * campfire: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 server 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_name: "some_queue")
+
+# All failed jobs of a given class
+ActiveJob.jobs.failed.where(job_class_name: "SomeJob")
+
+# All pending jobs of a given class with limit and offset
+ActiveJob.jobs.pending.where(job_class_name: "SomeJob").limit(10).offset(5)
+
+# All scheduled/in-progress/finished jobs of a given class
+ActiveJob.jobs.scheduled.where(job_class_name: "SomeJob")
+ActiveJob.jobs.in_progress.where(job_class_name: "SomeJob")
+ActiveJob.jobs.finished.where(job_class_name: "SomeJob")
+
+# 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_name: "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_name: "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
+FlightControl.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). Flight Control is a fork of [Mission Control — Jobs](https://github.com/rails/mission_control-jobs), © 37signals, also MIT-licensed.

data/Rakefile

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

data/lib/active_job/errors/invalid_operation.rb

@@ -0,0 +1,5 @@
+module ActiveJob
+  module Errors
+    class InvalidOperation < StandardError; end
+  end
+end

data/lib/active_job/errors/job_not_found_error.rb

@@ -0,0 +1,14 @@
+module ActiveJob
+  module Errors
+    class JobNotFoundError < StandardError
+      attr_reader :job_relation
+
+      def initialize(job_or_job_id, job_relation)
+        @job_relation = job_relation
+
+        job_id = job_or_job_id.is_a?(ActiveJob::Base) ? job_or_job_id.job_id : job_or_job_id
+        super("Job with id '#{job_id}' not found")
+      end
+    end
+  end
+end

data/lib/active_job/errors/query_error.rb

@@ -0,0 +1,5 @@
+module ActiveJob
+  module Errors
+    class QueryError < StandardError; end
+  end
+end

data/lib/active_job/executing.rb

@@ -0,0 +1,41 @@
+# TODO: These (or a version of them) should be moved to +ActiveJob::Core+
+# and related concerns when upstreamed.
+module ActiveJob::Executing
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :raw_data, :position, :finished_at, :blocked_by, :blocked_until, :worker_id, :started_at, :status
+    attr_reader :serialized_arguments
+
+    thread_cattr_accessor :current_queue_adapter
+  end
+
+  class_methods do
+    def queue_adapter
+      ActiveJob::Base.current_queue_adapter || super
+    end
+  end
+
+  def retry
+    ActiveJob.jobs.failed.retry_job(self)
+  end
+
+  def discard
+    jobs_relation_for_discarding.discard_job(self)
+  end
+
+  def dispatch
+    ActiveJob.jobs.dispatch_job(self)
+  end
+
+  private
+
+  def jobs_relation_for_discarding
+    case status
+    when :failed then ActiveJob.jobs.failed
+    when :pending then ActiveJob.jobs.pending.where(queue_name: queue_name)
+    else
+      ActiveJob.jobs
+    end
+  end
+end

data/lib/active_job/execution_error.rb

@@ -0,0 +1,8 @@
+# Information about a given error when executing a job.
+#
+# It's attached to failed jobs at +ActiveJob::Base#last_execution_error+.
+ActiveJob::ExecutionError = Struct.new(:error_class, :message, :backtrace) do
+  def to_s
+    "ERROR #{error_class}: #{message}\n#{backtrace&.collect { |line| "\t#{line}" }&.join("\n")}"
+  end
+end

data/lib/active_job/failed.rb

@@ -0,0 +1,7 @@
+module ActiveJob::Failed
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :last_execution_error, :failed_at
+  end
+end

data/lib/active_job/job_proxy.rb

@@ -0,0 +1,39 @@
+# A proxy for managing jobs without having to load the corresponding
+# job class.
+#
+# This is useful for managing jobs without having the job classes
+# present in the code base.
+class ActiveJob::JobProxy < ActiveJob::Base
+  class UnsupportedError < StandardError; end
+
+  attr_reader :job_class_name
+  # Raw data with the sensitive user data filtered out.
+  attr_accessor :filtered_raw_data
+
+  def initialize(job_data)
+    super
+    @job_class_name = job_data["job_class"]
+    deserialize(job_data)
+  end
+
+  def serialize
+    super.tap do |json|
+      json["job_class"] = @job_class_name
+    end
+  end
+
+  def perform_now
+    raise UnsupportedError, "A JobProxy doesn't support immediate execution, only enqueuing."
+  end
+
+  def duration
+    ended_at = finished_at || failed_at
+    ended_at - scheduled_at if ended_at && scheduled_at
+  end
+
+  ActiveJob::JobsRelation::STATUSES.each do |status|
+    define_method "#{status}?" do
+      self.status == status
+    end
+  end
+end