maintenance_tasks 2.3.3 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f292dbc04fbbb71588c0be3af0bc95bfb5de5ca27f9aa7562b681cad39c6241
-  data.tar.gz: d631953126ffbd114721fea778fc8d43f5c86c20461c04943c3127a1b6f9e0d3
+  metadata.gz: f26c6afe0c4b45b6d191162ab2c37e3b058e8b6ae473b17cfc3724e29e638fce
+  data.tar.gz: 4308f3356279fa5879429077cb482d91033336bfa62c1c4afb51fc9d957b1785
 SHA512:
-  metadata.gz: 146510c2a63f74b6084b43f9fa939c017e242b79ae0c453008b17b8e5c5e2332bd0d972ab4d8dce4d9d365836bcada8df8a7f1a7d717dc1d733232edd0830a4e
-  data.tar.gz: d1df2c04b6274843b32e4feb44a4bfb1eec3e64717ae67d78bbb440c08c34f24f63882d880dfc602529b2971f9bbfc9ce74345b848ecd3f780d1ab9270a610ec
+  metadata.gz: 383bc985f1a465e00889b20997d5718ff2039d5cdc6ca6b14a427a183fef4df3ff445eda2893d10b41d0bf243a6150ad5699afdfcbe3beaf280e4d35f130c1f5
+  data.tar.gz: d2b54c567a3d89e78f3538ca22b35d83dcb150e7520fc3014aa2040836f2e2741eb2bda700211c6411b8355b54ee19814655cf79827358d2d2f922fa855934af

data/README.md

@@ -5,35 +5,35 @@ A Rails engine for queuing and managing maintenance tasks.
 By ”maintenance task”, this project means a data migration, i.e. code that
 changes data in the database, often to support schema migrations. For example,
 in order to introduce a new `NOT NULL` column, it has to be added as nullable
-first, backfilled with values, before finally being changed to `NOT NULL`.
-This engine helps with the second part of this process, backfilling.
+first, backfilled with values, before finally being changed to `NOT NULL`. This
+engine helps with the second part of this process, backfilling.
 
-Maintenance tasks are collection-based tasks, usually using Active Record,
-that update the data in your database. They can be paused or interrupted.
-Maintenance tasks can operate [in batches](#processing-batch-collections) and
-use [throttling](#throttling) to control the load on your database.
+Maintenance tasks are collection-based tasks, usually using Active Record, that
+update the data in your database. They can be paused or interrupted. Maintenance
+tasks can operate [in batches](#processing-batch-collections) and use
+[throttling](#throttling) to control the load on your database.
 
 Maintenance tasks aren't meant to happen on a regular basis. They're used as
 needed, or as one-offs. Normally maintenance tasks are ephemeral, so they are
 used briefly and then deleted.
 
-The Rails engine has a web-based UI for listing maintenance tasks, seeing
-their status, and starting, pausing and restarting them.
+The Rails engine has a web-based UI for listing maintenance tasks, seeing their
+status, and starting, pausing and restarting them.
 
 [![Link to demo video](static/demo.png)](https://www.youtube.com/watch?v=BTuvTQxlFzs)
 
 ## Should I Use Maintenance Tasks?
 
-Maintenance tasks have a limited, specific job UI. While the engine can be
-used to provide a user interface for other data changes, such as data changes
-for support requests, we recommend you use regular application code for those
-use cases instead. These inevitably require more flexibility than this engine
-will be able to provide.
+Maintenance tasks have a limited, specific job UI. While the engine can be used
+to provide a user interface for other data changes, such as data changes for
+support requests, we recommend you use regular application code for those use
+cases instead. These inevitably require more flexibility than this engine will
+be able to provide.
 
-If your task shouldn't run as an Active Job, it probably isn't a good match
-for this gem. If your task doesn't need to run in the background,
-consider a runner script instead. If your task doesn't need to be
-interruptible, consider a normal Active Job.
+If your task shouldn't run as an Active Job, it probably isn't a good match for
+this gem. If your task doesn't need to run in the background, consider a runner
+script instead. If your task doesn't need to be interruptible, consider a normal
+Active Job.
 
 Maintenance tasks can be interrupted between iterations. If your task [isn't
 collection-based](#tasks-that-dont-need-a-collection) (no CSV file or database
@@ -48,9 +48,10 @@ If your task happens regularly, consider Active Jobs with a scheduler or cron,
 [job-iteration jobs](https://github.com/shopify/job-iteration) and/or [custom
 rails_admin UIs][rails-admin-engines] instead of the Maintenance Tasks gem.
 Maintenance tasks should be ephemeral, to suit their intentionally limited UI.
+They should not repeat.
 
-To create seed data for a new application, use the provided Rails
-`db/seeds.rb` file instead.
+To create seed data for a new application, use the provided Rails `db/seeds.rb`
+file instead.
 
 If your application can't handle a half-completed migration, maintenance tasks
 are probably the wrong tool. Remember that maintenance tasks are intentionally
@@ -99,7 +100,8 @@ constants](https://guides.rubyonrails.org/autoloading_and_reloading_constants.ht
 
 The typical Maintenance Tasks workflow is as follows:
 
-1. [Generate a class describing the Task](#creating-a-task) and the work to be done.
+1. [Generate a class describing the Task](#creating-a-task) and the work to be
+   done.
 2. Run the Task
     - either by [using the included web UI](#running-a-task-from-the-web-ui),
     - or by [using the command line](#running-a-task-from-the-command-line),
@@ -191,9 +193,9 @@ title,content
 My Title,Hello World!
 ```
 
-The files uploaded to your Active Storage service provider will be renamed
-to include an ISO 8601 timestamp and the Task name in snake case format.
-The CSV is expected to have a trailing newline at the end of the file.
+The files uploaded to your Active Storage service provider will be renamed to
+include an ISO 8601 timestamp and the Task name in snake case format. The CSV is
+expected to have a trailing newline at the end of the file.
 
 #### Batch CSV Tasks
 
@@ -270,8 +272,8 @@ inside `#process`.
 ### Tasks that don’t need a Collection
 
 Sometimes, you might want to run a Task that performs a single operation, such
-as enqueuing another background job or querying an external API. The gem supports
-collection-less tasks.
+as enqueuing another background job or querying an external API. The gem
+supports collection-less tasks.
 
 Generate a collection-less Task by running:
 
@@ -297,6 +299,35 @@ module Maintenance
 end
 ```
 
+### Tasks with Custom Enumerators
+
+If you have a special use case requiring iteration over an unsupported
+collection type, such as external resources fetched from some API, you can
+implement the `enumerator_builder(cursor:)` method in your task.
+
+This method should return an `Enumerator`, yielding pairs of
+`[item, cursor]`. Maintenance Tasks takes care of persisting the current
+cursor position and will provide it as the `cursor` argument if your task is
+interrupted or resumed. The `cursor` is stored as a `String`, so your custom
+enumerator should handle serializing/deserializing the value if required.
+
+```ruby
+# app/tasks/maintenance/custom_enumerator_task.rb
+
+module Maintenance
+  class CustomEnumeratorTask < MaintenanceTasks::Task
+    def enumerator_builder(cursor:)
+      after_id = cursor&.to_i
+      PostAPI.index(after_id: after_id).map { |post| [post, post.id] }.to_enum
+    end
+
+    def process(post)
+      Post.create!(post)
+    end
+  end
+end
+```
+
 ### Throttling
 
 Maintenance tasks often modify a lot of data and can be taxing on your database.
@@ -409,10 +440,9 @@ module Maintenance
 end
 ```
 
-Note: The `after_error` callback is guaranteed to complete,
-so any exceptions raised in your callback code are ignored.
-If your `after_error` callback code can raise an exception,
-you’ll need to rescue it and handle it appropriately
+Note: The `after_error` callback is guaranteed to complete, so any exceptions
+raised in your callback code are ignored. If your `after_error` callback code
+can raise an exception, you’ll need to rescue it and handle it appropriately
 within the callback.
 
 ```ruby
@@ -430,9 +460,8 @@ module Maintenance
 end
 ```
 
-If any of the other callbacks cause an exception,
-it will be handled by the error handler,
-and will cause the task to stop running.
+If any of the other callbacks cause an exception, it will be handled by the
+error handler, and will cause the task to stop running.
 
 Callback behaviour can be shared across all tasks using an initializer.
 
@@ -474,14 +503,14 @@ depend on the queue adapter but in general, you should follow these rules:
 When the Task runs or resumes, the Runner enqueues a job, which processes the
 Task. That job will instantiate a Task object which will live for the duration
 of the job. The first time the job runs, it will call `count`. Every time a job
-runs, it will call `collection` on the Task object, and then `process`
-for each item in the collection, until the job stops. The job stops when either the
+runs, it will call `collection` on the Task object, and then `process` for each
+item in the collection, until the job stops. The job stops when either the
 collection is finished processing or after the maximum job runtime has expired.
 
 This means memoization can be misleading within `process`, since the memoized
 values will be available for subsequent calls to `process` within the same job.
-Still, memoization can be used for throttling or reporting, and you can use [Task
-callbacks](#using-task-callbacks) to persist or log a report for example.
+Still, memoization can be used for throttling or reporting, and you can use
+[Task callbacks](#using-task-callbacks) to persist or log a report for example.
 
 ### Writing tests for a Task
 
@@ -559,7 +588,7 @@ module Maintenance
 
     test "#process performs a task iteration" do
       assert_difference -> { Post.first.content } do
-        task.process(Post.first)
+        @task.process(Post.first)
       end
     end
   end
@@ -671,7 +700,7 @@ tweaked in an initializer if necessary.
 [max-job-runtime]: https://github.com/Shopify/job-iteration/blob/-/guides/best-practices.md#max-job-runtime
 
 Running tasks will also be interrupted and re-enqueued when needed. For example
-[when Sidekiq workers shuts down for a deploy][sidekiq-deploy]:
+[when Sidekiq workers shut down for a deploy][sidekiq-deploy]:
 
 [sidekiq-deploy]: https://github.com/mperham/sidekiq/wiki/Deployment
 
@@ -684,19 +713,24 @@ Running tasks will also be interrupted and re-enqueued when needed. For example
 When Sidekiq is stopping, it will give workers 25 seconds to finish before
 forcefully terminating them (this is the default but can be configured with the
 `--timeout` option). Before the worker threads are terminated, Sidekiq will try
-to re-enqueue the job so your Task will be resumed. However, the position in
-the collection won’t be persisted so at least one iteration may run again.
+to re-enqueue the job so your Task will be resumed. However, the position in the
+collection won’t be persisted so at least one iteration may run again.
+
+Job queues other than Sidekiq may handle this in different ways.
 
 #### Help! My Task is stuck
 
-Finally, if the queue adapter configured for your application doesn’t have this
-property, or if Sidekiq crashes, is forcefully terminated, or is unable to
-re-enqueue the jobs that were in progress, the Task may be in a seemingly stuck
-situation where it appears to be running but is not. In that situation, pausing
-or cancelling it will not result in the Task being paused or cancelled, as the
-Task will get stuck in a state of `pausing` or `cancelling`. As a work-around,
-if a Task is `cancelling` for more than 5 minutes, you can cancel it again.
-It will then be marked as fully cancelled, allowing you to run it again.
+If the queue adapter configured for your application doesn’t have this property,
+or if Sidekiq crashes, is forcefully terminated, or is unable to re-enqueue the
+jobs that were in progress, the Task may be in a seemingly stuck situation where
+it appears to be running but is not. In that situation, pausing or cancelling it
+will not result in the Task being paused or cancelled, as the Task will get
+stuck in a state of `pausing` or `cancelling`. As a work-around, if a Task is
+`cancelling` for more than 5 minutes, you can cancel it again. It will then be
+marked as fully cancelled, allowing you to run it again.
+
+If you are stuck in `pausing` and wish to preserve your tasks's position
+(instead of cancelling and rerunning), you may click "Force pause".
 
 ### Configuring the gem
 
@@ -757,9 +791,10 @@ If no value is specified, it will default to `Maintenance`.
 
 #### Organizing tasks using namespaces
 
-Tasks may be nested arbitrarily deeply under `app/tasks/maintenance`, for example given a
-task file `app/tasks/maintenance/team_name/service_name/update_posts_task.rb` we
-can define the task as:
+Tasks may be nested arbitrarily deeply under `app/tasks/maintenance`, for
+example given a task file
+`app/tasks/maintenance/team_name/service_name/update_posts_task.rb` we can
+define the task as:
 
 ```ruby
 module Maintenance
@@ -848,8 +883,8 @@ default.
 #### Customizing the backtrace cleaner
 
 `MaintenanceTasks.backtrace_cleaner` can be configured to specify a backtrace
-cleaner to use when a Task errors and the backtrace is cleaned and persisted.
-An `ActiveSupport::BacktraceCleaner` should be used.
+cleaner to use when a Task errors and the backtrace is cleaned and persisted. An
+`ActiveSupport::BacktraceCleaner` should be used.
 
 ```ruby
 # config/initializers/maintenance_tasks.rb
@@ -865,8 +900,8 @@ clean backtraces.
 
 #### Customizing the parent controller for the web UI
 
-`MaintenanceTasks.parent_controller` can be configured to specify a controller class for all of the web UI engine's
-controllers to inherit from.
+`MaintenanceTasks.parent_controller` can be configured to specify a controller
+class for all of the web UI engine's controllers to inherit from.
 
 This allows applications with common logic in their `ApplicationController` (or
 any other controller) to optionally configure the web UI to inherit that logic
@@ -891,11 +926,21 @@ controller class which **must inherit** from `ActionController::Base`.
 
 If no value is specified, it will default to `"ActionController::Base"`.
 
+#### Configure time after which the task will be considered stuck
+
+To specify a time duration after which a task is considered stuck if it has not been updated,
+you can configure `MaintenanceTasks.stuck_task_duration`. This duration should account for
+job infrastructure events that may prevent the maintenance tasks job from being executed and cancelling the task.
+
+The value for `MaintenanceTasks.stuck_task_duration` must be an `ActiveSupport::Duration`.
+If no value is specified, it will default to 5 minutes.
+
 ### Metadata
 
-`MaintenanceTasks.metadata` can be configured to specify a proc from which to get extra information about the run.
-Since this proc will be ran in the context of the `MaintenanceTasks.parent_controller`, it can be used to keep the id
-or email of the user who performed the maintenance task.
+`MaintenanceTasks.metadata` can be configured to specify a proc from which to
+get extra information about the run. Since this proc will be ran in the context
+of the `MaintenanceTasks.parent_controller`, it can be used to keep the id or
+email of the user who performed the maintenance task.
 
 ```ruby
 # config/initializers/maintenance_tasks.rb
@@ -915,7 +960,7 @@ bin/rails generate maintenance_tasks:install
 
 This ensures that new migrations are installed and run as well.
 
-**What if I’ve deleted my previous Maintenance Task migrations?**
+### What if I’ve deleted my previous Maintenance Task migrations?
 
 The install command will attempt to reinstall these old migrations and migrating
 the database will cause problems. Use `bin/rails

data/app/controllers/maintenance_tasks/runs_controller.rb

@@ -29,7 +29,7 @@ module MaintenanceTasks
 
     # Updates a Run status to paused.
     def pause
-      @run.pausing!
+      @run.pause
       redirect_to(task_path(@run.task_name))
     rescue ActiveRecord::RecordInvalid => error
       redirect_to(task_path(@run.task_name), alert: error.message)

data/app/helpers/maintenance_tasks/tasks_helper.rb

@@ -101,8 +101,17 @@ module MaintenanceTasks
       )
     end
 
-    # Return the appropriate field tag for the parameter
+    # Return the appropriate field tag for the parameter, based on its type.
+    # If the parameter has a `validates_inclusion_of` validator, return a dropdown list of options instead.
     def parameter_field(form_builder, parameter_name)
+      inclusion_validator = form_builder.object.class.validators_on(parameter_name).find do |validator|
+        validator.kind == :inclusion
+      end
+
+      return form_builder.select(
+        parameter_name, inclusion_validator.options[:in], prompt: "Select a value"
+      ) if inclusion_validator
+
       case form_builder.object.class.attribute_types[parameter_name]
       when ActiveModel::Type::Integer
         form_builder.number_field(parameter_name)

data/app/jobs/concerns/maintenance_tasks/task_job_concern.rb

@@ -32,45 +32,7 @@ module MaintenanceTasks
 
     def build_enumerator(_run, cursor:)
       cursor ||= @run.cursor
-      collection = @task.collection
-      @enumerator = nil
-
-      @collection_enum = case collection
-      when :no_collection
-        enumerator_builder.build_once_enumerator(cursor: nil)
-      when ActiveRecord::Relation
-        enumerator_builder.active_record_on_records(collection, cursor: cursor)
-      when ActiveRecord::Batches::BatchEnumerator
-        if collection.start || collection.finish
-          raise ArgumentError, <<~MSG.squish
-            #{@task.class.name}#collection cannot support
-            a batch enumerator with the "start" or "finish" options.
-          MSG
-        end
-
-        # For now, only support automatic count based on the enumerator for
-        # batches
-        enumerator_builder.active_record_on_batch_relations(
-          collection.relation,
-          cursor: cursor,
-          batch_size: collection.batch_size,
-        )
-      when Array
-        enumerator_builder.build_array_enumerator(collection, cursor: cursor&.to_i)
-      when BatchCsvCollectionBuilder::BatchCsv
-        JobIteration::CsvEnumerator.new(collection.csv).batches(
-          batch_size: collection.batch_size,
-          cursor: cursor&.to_i,
-        )
-      when CSV
-        JobIteration::CsvEnumerator.new(collection).rows(cursor: cursor&.to_i)
-      else
-        raise ArgumentError, <<~MSG.squish
-          #{@task.class.name}#collection must be either an
-          Active Record Relation, ActiveRecord::Batches::BatchEnumerator,
-          Array, or CSV.
-        MSG
-      end
+      @collection_enum = @task.enumerator_builder(cursor: cursor)
       throttle_enumerator(@collection_enum)
     end
 
@@ -165,6 +127,7 @@ module MaintenanceTasks
       @ticker.persist if defined?(@ticker)
 
       if defined?(@run)
+        @run.cursor = cursor_position
         @run.persist_error(error)
 
         task_context = {

data/app/models/maintenance_tasks/run.rb

@@ -32,7 +32,6 @@ module MaintenanceTasks
       :cancelled,
     ]
     COMPLETED_STATUSES = [:succeeded, :errored, :cancelled]
-    STUCK_TASK_TIMEOUT = 5.minutes
 
     enum status: STATUSES.to_h { |status| [status, status.to_s] }
 
@@ -320,21 +319,29 @@ module MaintenanceTasks
 
     # Marks a Run as pausing.
     #
+    # If the Run has been stuck on pausing for more than 5 minutes, it forces
+    # the transition to paused. The ended_at timestamp will be updated.
+    #
     # Rescues and retries status transition if an ActiveRecord::StaleObjectError
     # is encountered.
-    def pausing!
-      super
+    def pause
+      if stuck?
+        self.status = :paused
+        persist_transition
+      else
+        pausing!
+      end
     rescue ActiveRecord::StaleObjectError
       reload_status
       retry
     end
 
     # Returns whether a Run is stuck, which is defined as having a status of
-    # cancelling, and not having been updated in the last 5 minutes.
+    # cancelling or pausing, and not having been updated in the last 5 minutes.
     #
     # @return [Boolean] whether the Run is stuck.
     def stuck?
-      cancelling? && updated_at <= STUCK_TASK_TIMEOUT.ago
+      (cancelling? || pausing?) && updated_at <= MaintenanceTasks.stuck_task_duration.ago
     end
 
     # Performs validation on the task_name attribute.

data/app/models/maintenance_tasks/task.rb

@@ -187,13 +187,7 @@ module MaintenanceTasks
         namespace = MaintenanceTasks.tasks_module.safe_constantize
         return unless namespace
 
-        load_const = lambda do |root|
-          root.constants.each do |name|
-            object = root.const_get(name)
-            load_const.call(object) if object.instance_of?(Module)
-          end
-        end
-        load_const.call(namespace)
+        Rails.autoloaders.main.eager_load_namespace(namespace)
       end
     end
 
@@ -253,5 +247,55 @@ module MaintenanceTasks
     def count
       self.class.collection_builder_strategy.count(self)
     end
+
+    # Default enumeration builder. You may override this method to return any
+    # Enumerator yielding pairs of `[item, item_cursor]`.
+    #
+    # @param cursor [String, nil] cursor position to resume from, or nil on
+    #   initial call.
+    #
+    # @return [Enumerator]
+    def enumerator_builder(cursor:)
+      collection = self.collection
+
+      job_iteration_builder = JobIteration::EnumeratorBuilder.new(nil)
+
+      case collection
+      when :no_collection
+        job_iteration_builder.build_once_enumerator(cursor: nil)
+      when ActiveRecord::Relation
+        job_iteration_builder.active_record_on_records(collection, cursor: cursor)
+      when ActiveRecord::Batches::BatchEnumerator
+        if collection.start || collection.finish
+          raise ArgumentError, <<~MSG.squish
+            #{self.class.name}#collection cannot support
+            a batch enumerator with the "start" or "finish" options.
+          MSG
+        end
+
+        # For now, only support automatic count based on the enumerator for
+        # batches
+        job_iteration_builder.active_record_on_batch_relations(
+          collection.relation,
+          cursor: cursor,
+          batch_size: collection.batch_size,
+        )
+      when Array
+        job_iteration_builder.build_array_enumerator(collection, cursor: cursor&.to_i)
+      when BatchCsvCollectionBuilder::BatchCsv
+        JobIteration::CsvEnumerator.new(collection.csv).batches(
+          batch_size: collection.batch_size,
+          cursor: cursor&.to_i,
+        )
+      when CSV
+        JobIteration::CsvEnumerator.new(collection).rows(cursor: cursor&.to_i)
+      else
+        raise ArgumentError, <<~MSG.squish
+          #{self.class.name}#collection must be either an
+          Active Record Relation, ActiveRecord::Batches::BatchEnumerator,
+          Array, or CSV.
+        MSG
+      end
+    end
   end
 end

data/app/validators/maintenance_tasks/run_status_validator.rb

@@ -60,6 +60,9 @@ module MaintenanceTasks
       # interrupted -> errored occurs when the task is deleted while it is
       #   interrupted.
       "interrupted" => ["running", "pausing", "cancelling", "errored"],
+      # errored -> enqueued occurs when the task is retried after encounting an
+      #   error.
+      "errored" => ["enqueued"],
     }
 
     # Validate whether a transition from one Run status

data/app/views/maintenance_tasks/runs/_arguments.html.erb

@@ -1,22 +1,4 @@
-<% if run.arguments.present? %>
-  <div class="table-container">
-    <h6 class="title is-6">Arguments:</h6>
-    <table class="table">
-      <tbody>
-        <% run.arguments.transform_values(&:to_s).each do |key, value| %>
-          <tr>
-            <td class="is-family-monospace"><%= key %></td>
-            <td>
-              <% next if value.empty? %>
-              <% if value.include?("\n") %>
-                <pre><%= value %></pre>
-              <% else %>
-                <code><%= value %></code>
-              <% end %>
-            </td>
-          </tr>
-          <% end %>
-      </tbody>
-    </table>
-  </div>
+<% if arguments.present? %>
+  <h6 class="title is-6">Arguments:</h6>
+  <%= render "maintenance_tasks/runs/serializable", serializable: arguments %>
 <% end %>

data/app/views/maintenance_tasks/runs/_metadata.html.erb

@@ -0,0 +1,4 @@
+<% if metadata.present? %>
+  <h6 class="title is-6">Metadata:</h6>
+  <%= render "maintenance_tasks/runs/serializable", serializable: metadata %>
+<% end %>

data/app/views/maintenance_tasks/runs/_run.html.erb

@@ -2,6 +2,7 @@
   <h5 class="title is-5">
     <%= time_tag run.created_at, title: run.created_at.utc.iso8601 %>
     <%= status_tag run.status %>
+    <span class="is-pulled-right" title="Run ID">#<%= run.id %></span>
   </h5>
 
   <%= progress run %>
@@ -16,12 +17,16 @@
 
   <%= render "maintenance_tasks/runs/csv", run: run %>
   <%= tag.hr if run.csv_file.present? && run.arguments.present? %>
-  <%= render "maintenance_tasks/runs/arguments", run: run %>
+  <%= render "maintenance_tasks/runs/arguments", arguments: run.arguments %>
+  <%= tag.hr if run.csv_file.present? || run.arguments.present? && run.metadata.present? %>
+  <%= render "maintenance_tasks/runs/metadata", metadata: run.metadata %>
 
   <div class="buttons">
     <% if run.paused? %>
       <%= button_to 'Resume', resume_task_run_path(@task, run), method: :put, class: 'button is-primary', disabled: @task.deleted? %>
       <%= button_to 'Cancel', cancel_task_run_path(@task, run), method: :put, class: 'button is-danger' %>
+    <% elsif run.errored? %>
+      <%= button_to 'Resume', resume_task_run_path(@task, run), method: :put, class: 'button is-primary', disabled: @task.deleted? %>
     <% elsif run.cancelling? %>
       <% if run.stuck? %>
         <%= button_to 'Cancel', cancel_task_run_path(@task, run), method: :put, class: 'button is-danger', disabled: @task.deleted? %>
@@ -29,6 +34,9 @@
     <% elsif run.pausing? %>
       <%= button_to 'Pausing', pause_task_run_path(@task, run), method: :put, class: 'button is-warning', disabled: true %>
       <%= button_to 'Cancel', cancel_task_run_path(@task, run), method: :put, class: 'button is-danger' %>
+      <% if run.stuck? %>
+        <%= button_to 'Force pause', pause_task_run_path(@task, run), method: :put, class: 'button is-danger', disabled: @task.deleted? %>
+      <% end %>
     <% elsif run.active? %>
       <%= button_to 'Pause', pause_task_run_path(@task, run), method: :put, class: 'button is-warning', disabled: @task.deleted? %>
       <%= button_to 'Cancel', cancel_task_run_path(@task, run), method: :put, class: 'button is-danger' %>

data/app/views/maintenance_tasks/runs/_serializable.html.erb

@@ -0,0 +1,26 @@
+<% if serializable.present? %>
+  <% case serializable %>
+  <% when Hash %>
+    <div class="table-container">
+      <table class="table">
+        <tbody>
+          <% serializable.transform_values(&:to_s).each do |key, value| %>
+            <tr>
+              <td class="is-family-monospace"><%= key %></td>
+              <td>
+                <% next if value.empty? %>
+                <% if value.include?("\n") %>
+                  <pre><%= value %></pre>
+                <% else %>
+                  <code><%= value %></code>
+                <% end %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+    </div>
+  <% else %>
+    <code><%= serializable.inspect %></code>
+  <% end %>
+<% end %>

data/app/views/maintenance_tasks/tasks/_task.html.erb

@@ -21,6 +21,8 @@
 
     <%= render "maintenance_tasks/runs/csv", run: run %>
     <%= tag.hr if run.csv_file.present? && run.arguments.present? %>
-    <%= render "maintenance_tasks/runs/arguments", run: run %>
+    <%= render "maintenance_tasks/runs/arguments", arguments: run.arguments %>
+    <%= tag.hr if run.csv_file.present? || run.arguments.present? && run.metadata.present? %>
+    <%= render "maintenance_tasks/runs/metadata", metadata: run.metadata %>
   <% end %>
 </div>

data/lib/generators/maintenance_tasks/templates/task_spec.rb.tt

@@ -6,10 +6,14 @@ module <%= tasks_module %>
 <% module_namespacing do -%>
   RSpec.describe <%= class_name %>Task do
     describe "#process" do
+      <%- if no_collection? -%>
+      subject(:process) { described_class.process }
+      <%- else -%>
       subject(:process) { described_class.process(element) }
       let(:element) {
         # Object to be processed in a single iteration of this task
       }
+      <%- end -%>
       pending "add some examples to (or delete) #{__FILE__}"
     end
   end

data/lib/maintenance_tasks/cli.rb

@@ -15,6 +15,12 @@ module MaintenanceTasks
     end
 
     desc "perform [TASK NAME]", "Runs the given Maintenance Task"
+    long_desc <<~DESC
+      `maintenance_tasks perform` will run the Maintenance Task specified by
+      the [TASK NAME] argument.
+
+      Use `maintenance_tasks list` to get a list of all available tasks.
+    DESC
 
     # Specify the CSV file to process for CSV Tasks
     desc = "Supply a CSV file to be processed by a CSV Task, "\
@@ -41,19 +47,14 @@ module MaintenanceTasks
       say_status(:error, error.message, :red)
     end
 
-    # `long_desc` only allows us to use a static string as "long description".
-    # By redefining the `#long_description` method on the "perform" Command
-    # object instead, we make it dynamic, thus delaying the task loading
-    # process until it's actually required.
-    commands["perform"].define_singleton_method(:long_description) do
-      <<~LONGDESC
-        `maintenance_tasks perform` will run the Maintenance Task specified by
-        the [TASK NAME] argument.
-
-        Available Tasks:
+    desc "list", "Load and list all available tasks."
 
-        #{Task.load_all.map(&:name).sort.join("\n\n")}
-      LONGDESC
+    # Command to list all available Tasks.
+    #
+    # It needs to use `Task.load_all` in order to load all the tasks available
+    # in the project before displaying them.
+    def list
+      say(Task.load_all.map(&:name).sort.join("\n"))
     end
 
     private

data/lib/maintenance_tasks.rb

@@ -89,4 +89,11 @@ module MaintenanceTasks
   #
   #   @return [Proc] generates a hash containing the metadata to be stored on the Run
   mattr_accessor :metadata, default: nil
+
+  # @!attribute stuck_task_duration
+  #  @scope class
+  #  The duration after which a task is considered stuck and can be force cancelled.
+  #
+  #  @return [ActiveSupport::Duration] the threshold in seconds after which a task is considered stuck.
+  mattr_accessor :stuck_task_duration, default: 5.minutes
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maintenance_tasks
 version: !ruby/object:Gem::Version
-  version: 2.3.3
+  version: 2.5.0
 platform: ruby
 authors:
 - Shopify Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-11 00:00:00.000000000 Z
+date: 2024-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.6.2
 description: 
 email: gems@shopify.com
 executables:
@@ -114,7 +128,9 @@ files:
 - app/views/layouts/maintenance_tasks/application.html.erb
 - app/views/maintenance_tasks/runs/_arguments.html.erb
 - app/views/maintenance_tasks/runs/_csv.html.erb
+- app/views/maintenance_tasks/runs/_metadata.html.erb
 - app/views/maintenance_tasks/runs/_run.html.erb
+- app/views/maintenance_tasks/runs/_serializable.html.erb
 - app/views/maintenance_tasks/runs/info/_cancelled.html.erb
 - app/views/maintenance_tasks/runs/info/_cancelling.html.erb
 - app/views/maintenance_tasks/runs/info/_custom.html.erb
@@ -143,7 +159,6 @@ files:
 - lib/generators/maintenance_tasks/task_generator.rb
 - lib/generators/maintenance_tasks/templates/csv_task.rb.tt
 - lib/generators/maintenance_tasks/templates/no_collection_task.rb.tt
-- lib/generators/maintenance_tasks/templates/no_collection_task_test.rb.tt
 - lib/generators/maintenance_tasks/templates/task.rb.tt
 - lib/generators/maintenance_tasks/templates/task_spec.rb.tt
 - lib/generators/maintenance_tasks/templates/task_test.rb.tt
@@ -156,7 +171,7 @@ homepage: https://github.com/Shopify/maintenance_tasks
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v2.3.3
+  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v2.5.0
   allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []
@@ -173,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
+rubygems_version: 3.5.5
 signing_key: 
 specification_version: 4
 summary: A Rails engine for queuing and managing maintenance tasks

data/lib/generators/maintenance_tasks/templates/no_collection_task_test.rb.tt

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module <%= tasks_module %>
-<% module_namespacing do -%>
-  class <%= class_name %>TaskTest < ActiveSupport::TestCase
-    # test "#process performs a task iteration" do
-    #   <%= tasks_module %>::<%= class_name %>Task.process
-    # end
-  end
-<% end -%>
-end