maintenance_tasks 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 649f66cc11a303666134c75aad8575b81eb376e358f69312180e21a14528ce50
-  data.tar.gz: b564b46e647c467c5d93a6198ab112729623059cfe194d1115d095c8ab8d9953
+  metadata.gz: 6c3c4c94cf355432e0d558e68bfc3f275972164c8ed932d2505b7c6450f0d124
+  data.tar.gz: 1b80ad4b58b9546d5ab2af77d2d0e64f8bd8b72dc6641ff445d33a67dae03860
 SHA512:
-  metadata.gz: f313350c5a80fa8840b23976eb7cde8776f825bc25a9b6a8fb7ce5d6f1abe8148d547ae7b2c1368a72caf980a2a12377e33b7c325e1447de3c0a0b0686d87a8d
-  data.tar.gz: '084950e7be06503e12d437294c784d02e2f0449c76db6297c5f95fcfd40845e4ce7e3354e16fbe12dd99b82554946f16fbc3415c047c17109aab1303c6b81b9b'
+  metadata.gz: 7402e24bfbc370c6af54b441d2b1050f252ee44f51ab11612875fed7fa6822645420422dc33405b1665596e66f85f8fe1f8b1e443d023d451a626913afe6dc98
+  data.tar.gz: 8f4666aba4abc6f01d77b238de6b6d511d24a5d4932f5ec2499f0e91faefe2e8a3b18435109864c821495b2efde464dd3212a76eae5276b4e622eb1cb6f7da3c

data/README.md

@@ -10,7 +10,7 @@ To install the gem and run the install generator, execute:
 
 ```bash
 $ bundle add maintenance_tasks
-$ rails generate maintenance_tasks:install
+$ bin/rails generate maintenance_tasks:install
 ```
 
 The generator creates and runs a migration to add the necessary table to your
@@ -23,12 +23,12 @@ handler](#customizing-the-error-handler) for more information.
 
 ### Active Job Dependency
 
-The Maintenance Tasks framework relies on ActiveJob behind the scenes to run
-Tasks. The default queuing backend for ActiveJob is
+The Maintenance Tasks framework relies on Active Job behind the scenes to run
+Tasks. The default queuing backend for Active Job is
 [asynchronous][async-adapter]. It is **strongly recommended** to change this to
 a persistent backend so that Task progress is not lost during code or
 infrastructure changes. For more information on configuring a queuing backend,
-take a look at the [ActiveJob documentation][active-job-docs].
+take a look at the [Active Job documentation][active-job-docs].
 
 [async-adapter]: https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html
 [active-job-docs]: https://guides.rubyonrails.org/active_job_basics.html#setting-the-backend
@@ -40,7 +40,7 @@ take a look at the [ActiveJob documentation][active-job-docs].
 A generator is provided to create tasks. Generate a new task by running:
 
 ```bash
-$ rails generate maintenance_tasks:task update_posts
+$ bin/rails generate maintenance_tasks:task update_posts
 ```
 
 This creates the task file `app/tasks/maintenance/update_posts_task.rb`.
@@ -77,7 +77,7 @@ end
 ### Creating a CSV Task
 
 You can also write a Task that iterates on a CSV file. Note that writing CSV
-Tasks **requires ActiveStorage to be configured**. Ensure that the dependency
+Tasks **requires Active Storage to be configured**. Ensure that the dependency
 is specified in your application's Gemfile, and that you've followed the
 [setup instuctions][setup].
 
@@ -86,7 +86,7 @@ is specified in your application's Gemfile, and that you've followed the
 Generate a CSV Task by running:
 
 ```bash
-$ rails generate maintenance_tasks:task import_posts --csv
+$ bin/rails generate maintenance_tasks:task import_posts --csv
 ```
 
 The generated task is a subclass of `MaintenanceTasks::Task` that implements:
@@ -112,6 +112,46 @@ title,content
 My Title,Hello World!
 ```
 
+### Processing Batch Collections
+
+The Maintenance Tasks gem supports processing Active Records in batches. This
+can reduce the number of calls your Task makes to the database. Use
+`ActiveRecord::Batches#in_batches` on the relation returned by your collection to specify that your Task should process
+batches instead of records. Active Record defaults to 1000 records by batch, but a custom size can be
+specified.
+
+```ruby
+# app/tasks/maintenance/update_posts_in_batches_task.rb
+module Maintenance
+  class UpdatePostsInBatchesTask < MaintenanceTasks::Task
+    def collection
+      Post.in_batches
+    end
+
+    def process(batch_of_posts)
+      batch_of_posts.update_all(content: "New content added on #{Time.now.utc}")
+    end
+  end
+end
+```
+
+Ensure that you've implemented the following methods:
+
+* `collection`: return an `ActiveRecord::Batches::BatchEnumerator`.
+* `process`: do the work of your Task on a batch (`ActiveRecord::Relation`).
+
+Note that `#count` is calculated automatically based on the number of batches in
+your collection, and your Task's progress will be displayed in terms of batches
+(not the number of records in the relation).
+
+**Important!** Batches should only be used if `#process` is performing a batch
+operation such as `#update_all` or `#delete_all`. If you need to iterate over
+individual records, you should define a collection that [returns an
+`ActiveRecord::Relation`](#creating-a-task). This uses batching
+internally, but loads the records with one SQL query. Conversely, batch
+collections load the primary keys of the records of the batch first, and then perform an additional query to load the
+records when calling `each` (or any `Enumerable` method) inside `#process`.
+
 ### Throttling
 
 Maintenance Tasks often modify a lot of data and can be taxing on your database.
@@ -145,13 +185,48 @@ end
 
 Note that it's up to you to define a throttling condition that makes sense for
 your app. Shopify implements `DatabaseStatus.healthy?` to check various MySQL
-metrics such as replication lag, DB threads, whether DB writes are available, 
+metrics such as replication lag, DB threads, whether DB writes are available,
 etc.
 
 Tasks can define multiple throttle conditions. Throttle conditions are inherited
 by descendants, and new conditions will be appended without impacting existing
 conditions.
 
+### Custom Task Parameters
+
+Tasks may need additional information, supplied via parameters, to run.
+Parameters can be defined as Active Model Attributes in a Task, and then
+become accessible to any of Task's methods: `#collection`, `#count`, or
+`#process`.
+
+```ruby
+# app/tasks/maintenance/update_posts_via_params_task.rb
+module Maintenance
+  class UpdatePostsViaParamsTask < MaintenanceTasks::Task
+    attribute :updated_content, :string
+    validates :updated_content, presence: true
+
+    def collection
+      Post.all
+    end
+
+    def count
+      collection.count
+    end
+
+    def process(post)
+      post.update!(content: updated_content)
+    end
+  end
+end
+```
+
+Tasks can leverage Active Model Validations when defining parameters. Arguments
+supplied to a Task accepting parameters will be validated before the Task starts
+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.
+
 ### Considerations when writing Tasks
 
 MaintenanceTasks relies on the queue adapter configured for your application to
@@ -241,6 +316,13 @@ To run a Task that processes CSVs from the command line, use the --csv option:
 $ bundle exec maintenance_tasks perform Maintenance::ImportPostsTask --csv 'path/to/my_csv.csv'
 ```
 
+To run a Task that takes arguments from the command line, use the --arguments
+option, passing arguments as a set of <key>:<value> pairs:
+
+```bash
+$ bundle exec maintenance_tasks perform Maintenance::ParamsTask --arguments post_ids:1,2,3 content:"Hello, World!"
+```
+
 You can also run a Task in Ruby by sending `run` with a Task name to Runner:
 
 ```ruby
@@ -257,6 +339,16 @@ MaintenanceTasks::Runner.run(
 )
 ```
 
+To run a Task that takes arguments using the Runner, provide a Hash containing
+the set of arguments (`{ parameter_name: argument_value }`) to `run`:
+
+```ruby
+MaintenanceTasks::Runner.run(
+  name: "Maintenance::ParamsTask",
+  arguments: { post_ids: "1,2,3" }
+)
+```
+
 ### Monitoring your Task's status
 
 The web UI will provide updates on the status of your Task. Here are the states
@@ -364,7 +456,7 @@ The error handler should be a lambda that accepts three arguments:
   exception monitoring service, make sure you **sanitize the object** to avoid
   leaking sensitive data and **convert it to a format** that is compatible with
   your bug tracker. For example, Bugsnag only sends the id and class name of
-  ActiveRecord objects in order to protect sensitive data. CSV rows, on the
+  Active Record objects in order to protect sensitive data. CSV rows, on the
   other hand, are converted to strings and passed raw to Bugsnag, so make sure
   to filter any personal data from these objects before adding them to a
   report.
@@ -451,7 +543,7 @@ Use bundler to check for and upgrade to newer versions. After installing a new
 version, re-run the install command:
 
 ```bash
-$ rails generate maintenance_tasks:install
+$ bin/rails generate maintenance_tasks:install
 ```
 
 This ensures that new migrations are installed and run as well.
@@ -464,12 +556,6 @@ pull requests. You can find the contribution guidelines on
 
 [contributing]: https://github.com/Shopify/maintenance_tasks/blob/main/.github/CONTRIBUTING.md
 
-### Dependabot updates
-
-Whenever Dependabot creates a PR for a gem bump, check out the branch locally
-and run `bin/update-gemfile <gem>` to ensure all the gemfiles have the gem
-updated consistently.
-
 ## Releasing new versions
 
 Updates should be added to the latest draft release on GitHub as Pull Requests
@@ -478,7 +564,6 @@ are merged.
 Once a release is ready, follow these steps:
 
 * Update `spec.version` in `maintenance_tasks.gemspec`.
-* Run `bin/gemfile-update install` to bump the version in all the lockfiles.
 * Open a PR and merge on approval.
 * Deploy via [Shipit][shipit] and see the new version on
   <https://rubygems.org/gems/maintenance_tasks>.

data/app/controllers/maintenance_tasks/tasks_controller.rb

@@ -27,11 +27,15 @@ module MaintenanceTasks
     def run
       task = Runner.run(
         name: params.fetch(:id),
-        csv_file: params[:csv_file]
+        csv_file: params[:csv_file],
+        arguments: params.fetch(:task_arguments, {}).permit!.to_h,
       )
       redirect_to(task_path(task))
     rescue ActiveRecord::RecordInvalid => error
       redirect_to(task_path(error.record.task_name), alert: error.message)
+    rescue ActiveRecord::ValueTooLong => error
+      task_name = params.fetch(:id)
+      redirect_to(task_path(task_name), alert: error.message)
     rescue Runner::EnqueuingError => error
       redirect_to(task_path(error.run.task_name), alert: error.message)
     end

data/app/helpers/maintenance_tasks/tasks_helper.rb

@@ -63,20 +63,6 @@ module MaintenanceTasks
       tag.span(status.capitalize, class: ["tag"] + STATUS_COLOURS.fetch(status))
     end
 
-    # Returns the distance between now and the Run's expected completion time,
-    # if the Run has an estimated_completion_time.
-    #
-    # @param run [MaintenanceTasks::Run] the Run for which the estimated time to
-    #   completion is being calculated.
-    # return [String, nil] the distance in words, or nil if the Run has no
-    #   estimated completion time.
-    def estimated_time_to_completion(run)
-      estimated_completion_time = run.estimated_completion_time
-      if estimated_completion_time.present?
-        time_ago_in_words(estimated_completion_time)
-      end
-    end
-
     # Reports the approximate elapsed time a Run has been processed so far based
     # on the Run's time running attribute.
     #

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

@@ -32,17 +32,35 @@ module MaintenanceTasks
     def build_enumerator(_run, cursor:)
       cursor ||= @run.cursor
       collection = @task.collection
+      @enumerator = nil
 
       collection_enum = case collection
       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 = 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)
       when CSV
         JobIteration::CsvEnumerator.new(collection).rows(cursor: cursor)
       else
-        raise ArgumentError, "#{@task.class.name}#collection must be either "\
-          "an Active Record Relation, Array, or CSV."
+        raise ArgumentError, <<~MSG.squish
+          #{@task.class.name}#collection must be either an
+          Active Record Relation, ActiveRecord::Batches::BatchEnumerator,
+          Array, or CSV.
+        MSG
       end
 
       @task.throttle_conditions.reduce(collection_enum) do |enum, condition|
@@ -71,7 +89,7 @@ module MaintenanceTasks
 
     def before_perform
       @run = arguments.first
-      @task = Task.named(@run.task_name).new
+      @task = @run.task
       if @task.respond_to?(:csv_content=)
         @task.csv_content = @run.csv_file.download
       end
@@ -85,7 +103,9 @@ module MaintenanceTasks
     end
 
     def on_start
-      @run.update!(started_at: Time.now, tick_total: @task.count)
+      count = @task.count
+      count = @enumerator&.size if count == :no_count
+      @run.update!(started_at: Time.now, tick_total: count)
     end
 
     def on_complete

data/app/models/maintenance_tasks/run.rb

@@ -34,10 +34,12 @@ module MaintenanceTasks
       Task.available_tasks.map(&:to_s)
     } }
     validate :csv_attachment_presence, on: :create
+    validate :validate_task_arguments, on: :create
 
     attr_readonly :task_name
 
     serialize :backtrace
+    serialize :arguments, JSON
 
     scope :active, -> { where(status: ACTIVE_STATUSES) }
 
@@ -149,19 +151,19 @@ module MaintenanceTasks
       ACTIVE_STATUSES.include?(status.to_sym)
     end
 
-    # Returns the estimated time the task will finish based on the the number of
-    # ticks left and the average time needed to process a tick.
-    # Returns nil if the Run is completed, or if the tick_count or tick_total is
-    # zero.
+    # Returns the duration left for the Run to finish based on the number of
+    # ticks left and the average time needed to process a tick. Returns nil if
+    # the Run is completed, or if tick_count or tick_total is zero.
     #
-    # @return [Time] the estimated time the Run will finish.
-    def estimated_completion_time
+    # @return [ActiveSupport::Duration] the estimated duration left for the Run
+    #   to finish.
+    def time_to_completion
       return if completed? || tick_count == 0 || tick_total.to_i == 0
 
       processed_per_second = (tick_count.to_f / time_running)
       ticks_left = (tick_total - tick_count)
       seconds_to_finished = ticks_left / processed_per_second
-      Time.now + seconds_to_finished
+      seconds_to_finished.seconds
     end
 
     # Cancels a Run.
@@ -206,6 +208,42 @@ module MaintenanceTasks
       nil
     end
 
+    # Support iterating over ActiveModel::Errors in Rails 6.0 and Rails 6.1+.
+    # To be removed when Rails 6.0 is no longer supported.
+    if Rails::VERSION::STRING.match?(/^6.0/)
+      # Performs validation on the arguments to use for the Task. If the Task is
+      # invalid, the errors are added to the Run.
+      def validate_task_arguments
+        arguments_match_task_attributes if arguments.present?
+        if task.invalid?
+          error_messages = task.errors
+            .map { |attribute, message| "#{attribute.inspect} #{message}" }
+          errors.add(
+            :arguments,
+            "are invalid: #{error_messages.join("; ")}"
+          )
+        end
+      rescue Task::NotFoundError
+        nil
+      end
+    else
+      # Performs validation on the arguments to use for the Task. If the Task is
+      # invalid, the errors are added to the Run.
+      def validate_task_arguments
+        arguments_match_task_attributes if arguments.present?
+        if task.invalid?
+          error_messages = task.errors
+            .map { |error| "#{error.attribute.inspect} #{error.message}" }
+          errors.add(
+            :arguments,
+            "are invalid: #{error_messages.join("; ")}"
+          )
+        end
+      rescue Task::NotFoundError
+        nil
+      end
+    end
+
     # Fetches the attached ActiveStorage CSV file for the run. Checks first
     # whether the ActiveStorage::Attachment table exists so that we are
     # compatible with apps that are not using ActiveStorage.
@@ -216,5 +254,35 @@ module MaintenanceTasks
       return unless ActiveStorage::Attachment.table_exists?
       super
     end
+
+    # Returns a Task instance for this Run. Assigns any attributes to the Task
+    # based on the Run's parameters. Note that the Task instance is not supplied
+    # with :csv_content yet if it's a CSV Task. This is done in the job, since
+    # downloading the CSV file can take some time.
+    #
+    # @return [Task] a Task instance.
+    def task
+      @task ||= begin
+        task = Task.named(task_name).new
+        if task.attribute_names.any? && arguments.present?
+          task.assign_attributes(arguments)
+        end
+        task
+      rescue ActiveModel::UnknownAttributeError
+        task
+      end
+    end
+
+    private
+
+    def arguments_match_task_attributes
+      invalid_argument_keys = arguments.keys - task.attribute_names
+      if invalid_argument_keys.any?
+        error_message = <<~MSG.squish
+          Unknown parameters: #{invalid_argument_keys.map(&:to_sym).join(", ")}
+        MSG
+        errors.add(:base, error_message)
+      end
+    end
   end
 end

data/app/models/maintenance_tasks/runner.rb

@@ -37,18 +37,24 @@ module MaintenanceTasks
     #   for the Task to iterate over when running, in the form of an attachable
     #   (see https://edgeapi.rubyonrails.org/classes/ActiveStorage/Attached/One.html#method-i-attach).
     #   Value is nil if the Task does not use CSV iteration.
+    # @param arguments [Hash] the arguments to persist to the Run and to make
+    #   accessible to the Task.
     #
     # @return [Task] the Task that was run.
     #
     # @raise [EnqueuingError] if an error occurs while enqueuing the Run.
     # @raise [ActiveRecord::RecordInvalid] if validation errors occur while
     #   creating the Run.
-    def run(name:, csv_file: nil)
-      run = Run.active.find_by(task_name: name) || Run.new(task_name: name)
+    # @raise [ActiveRecord::ValueTooLong] if the creation of the Run fails due
+    #   to a value being too long for the column type.
+    def run(name:, csv_file: nil, arguments: {})
+      run = Run.active.find_by(task_name: name) ||
+        Run.new(task_name: name, arguments: arguments)
       run.csv_file.attach(csv_file) if csv_file
 
       run.enqueued!
       enqueue(run)
+      yield run if block_given?
       Task.named(name)
     end
 

data/app/models/maintenance_tasks/task_data.rb

@@ -132,6 +132,15 @@ module MaintenanceTasks
       !deleted? && Task.named(name) < CsvCollection
     end
 
+    # @return [Array<String>] the names of parameters the Task accepts.
+    def parameter_names
+      if deleted?
+        []
+      else
+        Task.named(name).attribute_names
+      end
+    end
+
     private
 
     def runs

data/app/tasks/maintenance_tasks/task.rb

@@ -3,6 +3,9 @@ module MaintenanceTasks
   # Base class that is inherited by the host application's task classes.
   class Task
     extend ActiveSupport::DescendantsTracker
+    include ActiveModel::Attributes
+    include ActiveModel::AttributeAssignment
+    include ActiveModel::Validations
 
     class NotFoundError < NameError; end
 
@@ -128,6 +131,7 @@ module MaintenanceTasks
     #
     # @return [Integer, nil]
     def count
+      :no_count
     end
   end
 end

data/app/views/maintenance_tasks/runs/info/_paused.html.erb

@@ -1,7 +1,7 @@
 <p>
   Ran for <%= time_running_in_words run  %> until paused,
-  <% if run.estimated_completion_time %>
-    <%= estimated_time_to_completion(run) %> remaining.
+  <% if (time_to_completion = run.time_to_completion) %>
+    <%= distance_of_time_in_words(time_to_completion) %> remaining.
   <% else %>
     processed <%= pluralize run.tick_count, 'item' %> so far.
   <% end %>

data/app/views/maintenance_tasks/runs/info/_running.html.erb

@@ -1,5 +1,5 @@
 <p>
-  <% if run.estimated_completion_time %>
-    <%= estimated_time_to_completion(run).capitalize %> remaining.
+  <% if (time_to_completion = run.time_to_completion) %>
+    <%= distance_of_time_in_words(time_to_completion).capitalize %> remaining.
   <% end %>
 </p>

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

@@ -2,8 +2,8 @@
   <div class="content is-large">
     <h3 class="title is-3"> The MaintenanceTasks gem has been successfully installed! </h3>
     <p>
-      Any new Tasks will show up here. To start writing your first Task, 
-      run <code>rails generate maintenance_tasks:task my_task</code>.
+      Any new Tasks will show up here. To start writing your first Task,
+      run <code>bin/rails generate maintenance_tasks:task my_task</code>.
     </p>
   </div>
 <% else %>

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

@@ -16,6 +16,16 @@
           <%= form.file_field :csv_file %>
         </div>
       <% end %>
+      <% if @task.parameter_names.any? %>
+        <div class="block">
+          <%= form.fields_for :task_arguments do |ff| %>
+            <% @task.parameter_names.each do |parameter| %>
+              <%= ff.label parameter, "#{parameter}: ", class: "label" %>
+              <%= ff.text_area parameter, class: "textarea" %>
+            <% end %>
+          <% end %>
+        </div>
+      <% end %>
       <div class="block">
         <%= form.submit 'Run', class: "button is-success", disabled: @task.deleted? %>
       </div>

data/db/migrate/20210517131953_add_arguments_to_maintenance_tasks_runs.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+class AddArgumentsToMaintenanceTasksRuns < ActiveRecord::Migration[6.0]
+  def change
+    add_column(:maintenance_tasks_runs, :arguments, :text)
+  end
+end

data/lib/maintenance_tasks.rb

@@ -7,6 +7,8 @@ require "active_record"
 require "job-iteration"
 require "maintenance_tasks/engine"
 
+require "patches/active_record_batch_enumerator"
+
 # The engine's namespace module. It provides isolation between the host
 # application's code and the engine-specific code. Top-level engine constants
 # and variables are defined under this module.

data/lib/maintenance_tasks/cli.rb

@@ -28,15 +28,21 @@ module MaintenanceTasks
     option :csv, desc: "Supply a CSV file to be processed by a CSV Task, "\
       '--csv "path/to/csv/file.csv"'
 
+    # Specify arguments to supply to a Task supporting parameters
+    option :arguments, type: :hash, desc: "Supply arguments for a Task that "\
+      "accepts parameters as a set of <key>:<value> pairs."
+
     # Command to run a Task.
     #
     # It instantiates a Runner and sends a run message with the given Task name.
     # If a CSV file is supplied using the --csv option, an attachable with the
-    # File IO object is sent along with the Task name to run.
+    # File IO object is sent along with the Task name to run. If arguments are
+    # supplied using the --arguments option, these are also passed to run.
     #
     # @param name [String] the name of the Task to be run.
     def perform(name)
-      task = Runner.run(name: name, csv_file: csv_file)
+      arguments = options[:arguments] || {}
+      task = Runner.run(name: name, csv_file: csv_file, arguments: arguments)
       say_status(:success, "#{task.name} was enqueued.", :green)
     rescue => error
       say_status(:error, error.message, :red)

data/lib/patches/active_record_batch_enumerator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# TODO: Remove this patch once all supported Rails versions include the changes
+# upstream - https://github.com/rails/rails/pull/42312/commits/a031a43d969c87542c4ee8d0d338d55fcbb53376
+module ActiveRecordBatchEnumerator
+  # The primary key value from which the BatchEnumerator starts,
+  #   inclusive of the value.
+  attr_reader :start
+
+  # The primary key value at which the BatchEnumerator ends,
+  #   inclusive of the value.
+  attr_reader :finish
+
+  # The relation from which the BatchEnumerator yields batches.
+  attr_reader :relation
+
+  # The size of the batches yielded by the BatchEnumerator.
+  def batch_size
+    @of
+  end
+end
+
+ActiveRecord::Batches::BatchEnumerator.include(ActiveRecordBatchEnumerator)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maintenance_tasks
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Shopify Engineering
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-05-13 00:00:00.000000000 Z
+date: 2021-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -125,6 +125,7 @@ files:
 - config/routes.rb
 - db/migrate/20201211151756_create_maintenance_tasks_runs.rb
 - db/migrate/20210225152418_remove_index_on_task_name.rb
+- db/migrate/20210517131953_add_arguments_to_maintenance_tasks_runs.rb
 - exe/maintenance_tasks
 - lib/generators/maintenance_tasks/install_generator.rb
 - lib/generators/maintenance_tasks/task_generator.rb
@@ -135,17 +136,15 @@ files:
 - lib/maintenance_tasks.rb
 - lib/maintenance_tasks/cli.rb
 - lib/maintenance_tasks/engine.rb
+- lib/patches/active_record_batch_enumerator.rb
 - lib/tasks/maintenance_tasks_tasks.rake
 homepage: https://github.com/Shopify/maintenance_tasks
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v1.3.0
+  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v1.4.0
   allowed_push_host: https://rubygems.org
-post_install_message: |-
-  Thank you for installing Maintenance Tasks 1.3.0. To complete, please run:
-
-  rails generate maintenance_tasks:install
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib