maintenance_tasks 2.5.1 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8952908cba45fd0a79cfcf0d334e89eab4e3a554ba4c0b1acffb318c7e92730f
-  data.tar.gz: bc1312f6269c51fe80480f7af90281c89c36bc9c78f052f65f4b5853effa5a41
+  metadata.gz: 2869ba1c05cb80edb54803f50037bb45b388a5489bec724a79617d2890e78fdc
+  data.tar.gz: 5a936d433f102642e972f4c04e7fd96817193f0075b252e942c1ff86bb6a0e06
 SHA512:
-  metadata.gz: c32f23abae224617aef9148ac7e890a95fb799997e0900b6a5ad72fbb988cadb25ef61ef6a35e803f2483cce93f6ad20d379c202f2a513f72c339d553e830a12
-  data.tar.gz: cead5f36f1038614e23da3c6fa3661be58d00ac326a859681a3740d818977f0c3c311860f567d96701dcd04bc1019e001ad0903c20833444b2a0669dd9aac6e9
+  metadata.gz: 5e054a909fd05bacc7482caa7cba9cc69ed15850bdec1e0bbf09466426ad6bcfadd12c086a4efe185eb5be1edc40b3fbacaca34b555fac39fa0dcfac2df50405
+  data.tar.gz: fa1c8baed4e9cc6b34acd03e9c16ef2266da288293da212fb96c03d6a6be2d87fb5599e167e4d629e80f16a80127b611ffe6b8895867958a92675dca06457e48

data/README.md

@@ -45,10 +45,12 @@ If your task updates your database schema instead of data, use a migration
 instead of a maintenance task.
 
 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.
+[job-iteration jobs][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.
+
+[job-iteration]: https://github.com/shopify/job-iteration
 
 To create seed data for a new application, use the provided Rails `db/seeds.rb`
 file instead.
@@ -91,10 +93,12 @@ take a look at the [Active Job documentation][active-job-docs].
 ### Autoloading
 
 The Maintenance Tasks framework does not support autoloading in `:classic` mode.
-Please ensure your application is using
-[Zeitwerk](https://github.com/fxn/zeitwerk) to load your code.  For more
+Please ensure your application is using [Zeitwerk][] to load your code. For more
 information, please consult the [Rails guides on autoloading and reloading
-constants](https://guides.rubyonrails.org/autoloading_and_reloading_constants.html).
+constants][autoloading].
+
+[Zeitwerk]: https://github.com/fxn/zeitwerk
+[autoloading]: https://guides.rubyonrails.org/autoloading_and_reloading_constants.html
 
 ## Usage
 
@@ -187,15 +191,57 @@ module Maintenance
 end
 ```
 
+`posts.csv`:
 ```csv
-# posts.csv
 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.
+include an ISO 8601 timestamp and the Task name in snake case format.
+
+The implicit `#count` method loads and parses the entire file to determine the
+accurate number of rows. With files with millions of rows, it takes several
+seconds to process. Consider skipping the count (defining a `count` that returns
+`nil`) or use an approximation, eg: count the number of new lines:
+
+```ruby
+def count(task)
+  task.csv_content.count("\n") - 1
+end
+```
+
+#### CSV options
+
+Tasks can pass [options for Ruby's CSV parser][csv-parse-options] by adding
+keyword arguments to `csv_collection`:
+
+[csv-parse-options]: https://ruby-doc.org/3.3.0/stdlibs/csv/CSV.html#class-CSV-label-Options+for+Parsing
+
+```ruby
+# app/tasks/maintenance/import_posts_task.rb
+
+module Maintenance
+  class ImportPosts
+    csv_collection(skip_lines: /^#/, converters: ->(field) { field.strip })
+
+    def process(row)
+      Post.create!(title: row["title"], content: row["content"])
+    end
+  end
+end
+```
+
+These options instruct Ruby's CSV parser to skip lines that start with a `#`,
+and removes the leading and trailing spaces from any field, so that the
+following file will be processed identically as the previous example:
+
+`posts.csv`:
+```csv
+# A comment
+title,content
+ My Title ,Hello World!
+```
 
 #### Batch CSV Tasks
 
@@ -305,11 +351,11 @@ 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.
+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
@@ -377,7 +423,7 @@ module Maintenance
     throttle_on(backoff: -> { RandomBackoffGenerator.generate_duration } ) do
       DatabaseStatus.unhealthy?
     end
-    ...
+    # ...
   end
 end
 ```
@@ -413,6 +459,100 @@ to run. Since arguments are specified in the user interface via text area
 inputs, it’s important to check that they conform to the format your Task
 expects, and to sanitize any inputs if necessary.
 
+### Custom cursor columns to improve performance
+
+The [job-iteration gem][job-iteration], on which this gem depends, adds an
+`order by` clause to the relation returned by the `collection` method, in order
+to iterate through records. It defaults to order on the `id` column.
+
+The [job-iteration gem][job-iteration] supports configuring which columns are
+used to order the cursor, as documented in
+[`build_active_record_enumerator_on_records`][ji-ar-enumerator-doc].
+
+[ji-ar-enumerator-doc]: https://www.rubydoc.info/gems/job-iteration/JobIteration/EnumeratorBuilder#build_active_record_enumerator_on_records-instance_method
+
+The `maintenance-tasks` gem exposes the ability that `job-iteration` provides to
+control the cursor columns, through the `cursor_columns` method in the
+`MaintenanceTasks::Task` class. If the `cursor_columns` method returns `nil`,
+the query is ordered by the primary key. If cursor columns values change during
+an iteration, records may be skipped or yielded multiple times.
+
+```ruby
+module Maintenance
+  class UpdatePostsTask < MaintenanceTasks::Task
+    def cursor_columns
+      [:created_at, :id]
+    end
+
+    def collection
+      Post.where(created_at: 2.days.ago...1.hour.ago)
+    end
+
+    def process(post)
+      post.update!(content: "updated content")
+    end
+  end
+end
+```
+
+### Subscribing to instrumentation events
+
+If you are interested in actioning a specific task event, please refer to the [Using Task Callbacks](#using-task-callbacks) section below. However, if you want to subscribe to all events, irrespective of the task, you can use the following Active Support notifications:
+
+```ruby
+enqueued.maintenance_tasks    # This event is published when a task has been enqueued by the user.
+succeeded.maintenance_tasks   # This event is published when a task has finished without any errors.
+cancelled.maintenance_tasks   # This event is published when the user explicitly halts the execution of a task.
+paused.maintenance_tasks      # This event is published when a task is paused by the user in the middle of its run.
+errored.maintenance_tasks     # This event is published when the task's code produces an unhandled exception.
+```
+
+These notifications offer a way to monitor the lifecycle of maintenance tasks in your application.
+
+Usage example:
+
+ ```ruby
+ ActiveSupport::Notifications.subscribe("succeeded.maintenance_tasks") do |*, payload|
+  task_name = payload[:task_name]
+  arguments = payload[:arguments]
+  metadata = payload[:metadata]
+  job_id = payload[:job_id]
+  run_id = payload[:run_id]
+  time_running = payload[:time_running]
+  started_at = payload[:started_at]
+  ended_at = payload[:ended_at]
+rescue => e
+  Rails.logger.error(e)
+end
+
+ActiveSupport::Notifications.subscribe("errored.maintenance_tasks") do |*, payload|
+  task_name = payload[:task_name]
+  error = payload[:error]
+  error_message = error[:message]
+  error_class = error[:class]
+  error_backtrace = error[:backtrace]
+rescue => e
+  Rails.logger.error(e)
+end
+
+# or
+
+class MaintenanceTasksInstrumenter < ActiveSupport::Subscriber
+  attach_to :maintenance_tasks
+
+  def enqueued(event)
+    task_name = event.payload[:task_name]
+    arguments = event.payload[:arguments]
+    metadata = event.payload[:metadata]
+
+    SlackNotifier.broadcast(SLACK_CHANNEL,
+      "Job #{task_name} was started by #{metadata[:user_email]}} with arguments #{arguments.to_s.truncate(255)}")
+  rescue => e
+    Rails.logger.error(e)
+  end
+end
+```
+
 ### Using Task Callbacks
 
 The Task provides callbacks that hook into its life cycle.
@@ -463,21 +603,6 @@ 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.
 
-Callback behaviour can be shared across all tasks using an initializer.
-
-```ruby
-# config/initializer/maintenance_tasks.rb
-Rails.autoloaders.main.on_load("MaintenanceTasks::Task") do
-  MaintenanceTasks::Task.class_eval do
-    after_start(:notify)
-
-    private
-
-    def notify; end
-  end
-end
-```
-
 ### Considerations when writing Tasks
 
 Maintenance Tasks relies on the queue adapter configured for your application to
@@ -595,6 +720,42 @@ module Maintenance
 end
 ```
 
+### Writing tests for a Task that uses a custom enumerator
+
+Tests for tasks that use custom enumerators need to instantiate the task class
+in order to call `#build_enumerator`. Once the task instance is set up, validate
+that `#build_enumerator` returns an enumerator yielding pairs of [item, cursor]
+as expected.
+
+```ruby
+# test/tasks/maintenance/custom_enumerating_task.rb
+
+require "test_helper"
+
+module Maintenance
+  class CustomEnumeratingTaskTest < ActiveSupport::TestCase
+    setup do
+      @task = CustomEnumeratingTask.new
+    end
+
+    test "#build_enumerator returns enumerator yielding pairs of [item, cursor]" do
+      enum = @task.build_enumerator(cursor: 0)
+      expected_items = [:b, :c]
+
+      assert_equal 2, enum.size
+
+      enum.each_with_index do |item, cursor|
+        assert_equal expected_items[cursor], item
+      end
+    end
+
+    test "#process performs a task iteration" do
+      # ...
+    end
+  end
+end
+```
+
 ### Running a Task
 
 #### Running a Task from the Web UI
@@ -917,7 +1078,7 @@ MaintenanceTasks.parent_controller = "Services::CustomController"
 class Services::CustomController < ActionController::Base
   include CustomSecurityThings
   include CustomLoggingThings
-  ...
+  # ...
 end
 ```
 
@@ -928,12 +1089,14 @@ 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.
+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.
+The value for `MaintenanceTasks.stuck_task_duration` must be an
+`ActiveSupport::Duration`. If no value is specified, it will default to 5
+minutes.
 
 ### Metadata
 

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

@@ -33,6 +33,45 @@ module MaintenanceTasks
     def build_enumerator(_run, cursor:)
       cursor ||= @run.cursor
       @collection_enum = @task.enumerator_builder(cursor: cursor)
+
+      @collection_enum ||= case (collection = @task.collection)
+      when :no_collection
+        enumerator_builder.build_once_enumerator(cursor: nil)
+      when ActiveRecord::Relation
+        enumerator_builder.active_record_on_records(collection, cursor: cursor, columns: @task.cursor_columns)
+      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,
+          columns: @task.cursor_columns,
+        )
+      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
+
       throttle_enumerator(@collection_enum)
     end
 

data/app/models/maintenance_tasks/batch_csv_collection_builder.rb

@@ -12,16 +12,17 @@ module MaintenanceTasks
     # Initialize a BatchCsvCollectionBuilder with a batch size.
     #
     # @param batch_size [Integer] the number of CSV rows in a batch.
-    def initialize(batch_size)
+    # @param csv_options [Hash] options to pass to the CSV parser.
+    def initialize(batch_size, **csv_options)
       @batch_size = batch_size
-      super()
+      super(**csv_options)
     end
 
     # Defines the collection to be iterated over, based on the provided CSV.
     # Includes the CSV and the batch size.
     def collection(task)
       BatchCsv.new(
-        csv: CSV.new(task.csv_content, headers: true),
+        csv: CSV.new(task.csv_content, **@csv_options),
         batch_size: @batch_size,
       )
     end

data/app/models/maintenance_tasks/csv_collection_builder.rb

@@ -5,24 +5,27 @@ require "csv"
 module MaintenanceTasks
   # Strategy for building a Task that processes CSV files.
   #
+  # @param csv_options [Hash] options to pass to the CSV parser.
   # @api private
   class CsvCollectionBuilder
+    def initialize(**csv_options)
+      @csv_options = csv_options
+    end
+
     # Defines the collection to be iterated over, based on the provided CSV.
     #
-    # @return [CSV] the CSV object constructed from the specified CSV content,
-    #   with headers.
+    # @return [CSV] the CSV object constructed from the specified CSV content.
     def collection(task)
-      CSV.new(task.csv_content, headers: true)
+      CSV.new(task.csv_content, **@csv_options)
     end
 
-    # The number of rows to be processed. Excludes the header row from the
-    # count and assumes a trailing newline is at the end of the CSV file.
-    # Note that this number is an approximation based on the number of
-    # newlines.
+    # The number of rows to be processed.
+    # It uses the CSV library for an accurate row count.
+    # Note that the entire file is loaded. It will take several seconds with files with millions of rows.
     #
     # @return [Integer] the approximate number of rows to process.
     def count(task)
-      task.csv_content.count("\n") - 1
+      CSV.new(task.csv_content, **@csv_options).count
     end
 
     # Return that the Task processes CSV content.

data/app/models/maintenance_tasks/progress.rb

@@ -52,17 +52,17 @@ module MaintenanceTasks
       total = @run.tick_total
 
       if !total?
-        "Processed #{number_to_delimited(count)} "\
+        "Processed #{number_to_delimited(count)} " \
           "#{"item".pluralize(count)}."
       elsif over_total?
-        "Processed #{number_to_delimited(count)} "\
-          "#{"item".pluralize(count)} "\
+        "Processed #{number_to_delimited(count)} " \
+          "#{"item".pluralize(count)} " \
           "(expected #{number_to_delimited(total)})."
       else
         percentage = 100.0 * count / total
 
-        "Processed #{number_to_delimited(count)} out of "\
-          "#{number_to_delimited(total)} #{"item".pluralize(total)} "\
+        "Processed #{number_to_delimited(count)} out of " \
+          "#{number_to_delimited(total)} #{"item".pluralize(total)} " \
           "(#{number_to_percentage(percentage, precision: 0)})."
       end
     end

data/app/models/maintenance_tasks/run.rb

@@ -33,7 +33,13 @@ module MaintenanceTasks
     ]
     COMPLETED_STATUSES = [:succeeded, :errored, :cancelled]
 
-    enum status: STATUSES.to_h { |status| [status, status.to_s] }
+    if Rails.gem_version >= Gem::Version.new("7.0.alpha")
+      enum :status, STATUSES.to_h { |status| [status, status.to_s] }
+    else
+      enum status: STATUSES.to_h { |status| [status, status.to_s] }
+    end
+
+    after_save :instrument_status_change
 
     validate :task_name_belongs_to_a_valid_task, on: :create
     validate :csv_attachment_presence, on: :create
@@ -448,6 +454,30 @@ module MaintenanceTasks
 
     private
 
+    def instrument_status_change
+      return unless status_previously_changed? || id_previously_changed?
+      return if running? || pausing? || cancelling? || interrupted?
+
+      attr = {
+        run_id: id,
+        job_id: job_id,
+        task_name: task_name,
+        arguments: arguments,
+        metadata: metadata,
+        time_running: time_running,
+        started_at: started_at,
+        ended_at: ended_at,
+      }
+
+      attr[:error] = {
+        message: error_message,
+        class: error_class,
+        backtrace: backtrace,
+      } if errored?
+
+      ActiveSupport::Notifications.instrument("#{status}.maintenance_tasks", attr)
+    end
+
     def run_task_callbacks(callback)
       task.run_callbacks(callback)
     rescue Task::NotFoundError

data/app/models/maintenance_tasks/runner.rb

@@ -74,7 +74,7 @@ module MaintenanceTasks
 
     def enqueue(run, job)
       unless job.enqueue
-        raise "The job to perform #{run.task_name} could not be enqueued. "\
+        raise "The job to perform #{run.task_name} could not be enqueued. " \
           "Enqueuing has been prevented by a callback."
       end
     rescue => error

data/app/models/maintenance_tasks/task.rb

@@ -65,20 +65,24 @@ module MaintenanceTasks
       # Make this Task a task that handles CSV.
       #
       # @param in_batches [Integer] optionally, supply a batch size if the CSV
-      # should be processed in batches.
+      #   should be processed in batches.
+      # @param csv_options [Hash] optionally, supply options for the CSV parser.
+      #   If not given, defaults to: <code>{ headers: true }</code>
+      # @see https://ruby-doc.org/3.3.0/stdlibs/csv/CSV.html#class-CSV-label-Options+for+Parsing
       #
       # An input to upload a CSV will be added in the form to start a Run. The
       # collection and count method are implemented.
-      def csv_collection(in_batches: nil)
+      def csv_collection(in_batches: nil, **csv_options)
         unless defined?(ActiveStorage)
-          raise NotImplementedError, "Active Storage needs to be installed\n"\
+          raise NotImplementedError, "Active Storage needs to be installed\n" \
             "To resolve this issue run: bin/rails active_storage:install"
         end
 
+        csv_options[:headers] = true unless csv_options.key?(:headers)
         self.collection_builder_strategy = if in_batches
-          BatchCsvCollectionBuilder.new(in_batches)
+          BatchCsvCollectionBuilder.new(in_batches, **csv_options)
         else
-          CsvCollectionBuilder.new
+          CsvCollectionBuilder.new(**csv_options)
         end
       end
 
@@ -230,6 +234,18 @@ module MaintenanceTasks
       self.class.collection_builder_strategy.collection(self)
     end
 
+    # The columns used to build the `ORDER BY` clause of the query for iteration.
+    #
+    # If cursor_columns returns nil, the query is ordered by the primary key.
+    # If cursor columns values change during an iteration, records may be skipped or yielded multiple times.
+    # More details in the documentation of JobIteration::EnumeratorBuilder.build_active_record_enumerator_on_records:
+    # https://www.rubydoc.info/gems/job-iteration/JobIteration/EnumeratorBuilder#build_active_record_enumerator_on_records-instance_method
+    #
+    # @return the cursor_columns.
+    def cursor_columns
+      nil
+    end
+
     # Placeholder method to raise in case a subclass fails to implement the
     # expected instance method.
     #
@@ -248,7 +264,7 @@ module MaintenanceTasks
       self.class.collection_builder_strategy.count(self)
     end
 
-    # Default enumeration builder. You may override this method to return any
+    # Default enumerator 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
@@ -256,46 +272,7 @@ module MaintenanceTasks
     #
     # @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
+      nil
     end
   end
 end

data/lib/generators/maintenance_tasks/task_generator.rb

@@ -6,7 +6,7 @@ module MaintenanceTasks
   # @api private
   class TaskGenerator < Rails::Generators::NamedBase
     source_root File.expand_path("templates", __dir__)
-    desc "This generator creates a task file at app/tasks and a corresponding "\
+    desc "This generator creates a task file at app/tasks and a corresponding " \
       "test."
 
     class_option :csv,
@@ -24,7 +24,7 @@ module MaintenanceTasks
     # Creates the Task file.
     def create_task_file
       if options[:csv] && options[:no_collection]
-        raise "Multiple Task type options provided. Please use either "\
+        raise "Multiple Task type options provided. Please use either " \
           "--csv or --no-collection."
       end
       template_file = File.join(

data/lib/maintenance_tasks/cli.rb

@@ -23,11 +23,11 @@ module MaintenanceTasks
     DESC
 
     # Specify the CSV file to process for CSV Tasks
-    desc = "Supply a CSV file to be processed by a CSV Task, "\
+    desc = "Supply a CSV file to be processed by a CSV Task, " \
       "--csv path/to/csv/file.csv"
     option :csv, lazy_default: :stdin, desc: desc
     # Specify arguments to supply to a Task supporting parameters
-    desc = "Supply arguments for a Task that accepts parameters as a set of "\
+    desc = "Supply arguments for a Task that accepts parameters as a set of " \
       "<key>:<value> pairs."
     option :arguments, type: :hash, desc: desc
 

data/lib/tasks/maintenance_tasks_tasks.rake

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # desc "Explaining what the task does"
 # task :maintenance_tasks do
 #   # Task goes here

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maintenance_tasks
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 2.7.0
 platform: ruby
 authors:
 - Shopify Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-02-09 00:00:00.000000000 Z
+date: 2024-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -171,7 +171,7 @@ homepage: https://github.com/Shopify/maintenance_tasks
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v2.5.1
+  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v2.7.0
   allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []
@@ -188,7 +188,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: A Rails engine for queuing and managing maintenance tasks