maintenance_tasks 2.12.0 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d307d92f96c1d1975cc3fbefcddf6ec2e11086097437b63594090c5bc524eea8
-  data.tar.gz: 9176d7a34c4a54f450601ea2748a88b1a9f134c9e416e97978e613bf3fbf1538
+  metadata.gz: 8402f1f4b8919e892a6334373ad397d49b5c6c78893f2f107b990b90653435d1
+  data.tar.gz: 1459d5b92233a1196aeb83c80bec9da525f04e975a50f6a415cdcd8dc647bd59
 SHA512:
-  metadata.gz: 87d37b437e518c0398023335fe88cb0c7829387142873eeb01aa713df04f397e7711491f0ace1a32baae20f4f1a613313c59e95696deef73d6ecfad24b6fb267
-  data.tar.gz: b0c5fce124651391b77b8f2e5d91f8eb84c0415744fda8429b11a64b730a2e1ef02335c05685a98946fffdfd5042aa3b6f2a23a645a454613acd364af612b09d
+  metadata.gz: 3dff16b85a650f4d73cf79df20267d1278b1181f2ba6717742581909ebfd39145dfdd9b9cf1453edaa785474fb6f7dda87af2bad534e6398bf010945b02f2da3
+  data.tar.gz: c7b75c1edc684fad66c5080ee3642fe469038e1f4ab2329ead0fd3c65e5f0ca2a940250dc988658dce672e2de0d056741b9a317310afa23165ba27794722ce1d

data/README.md

@@ -1027,7 +1027,7 @@ be placed in a `maintenance_tasks.rb` initializer.
 Exceptions raised while a Task is performing are rescued and information about
 the error is persisted and visible in the UI.
 
-Errors are also sent to the `Rails.error.reporter`, which can be configured by
+Errors are also sent to `Rails.error.report`, which can be configured by
 your application. See the [Error Reporting in Rails
 Applications][rails-error-reporting] guide for more details.
 
@@ -1042,11 +1042,42 @@ Reports to the error reporter will contain the following data:
    * `tick_count`: The tick count at the time of the error
    * `errored_element`: The element, if any, that was being processed when the
 * `source`: This will be `maintenance-tasks`
+* `handled`: the value of `MaintenanceTasks.report_errors_as_handled` (default `true`, see below)
 
 Note that `context` may be empty if the Task produced an error before any
 context could be gathered (for example, if deserializing the job to process your
 Task failed).
 
+Here's an example custom subscriber to the Rails error reporter for integrating
+with an exception monitoring service (Bugsnag):
+
+```ruby
+# config/initializers/maintenance_tasks.rb
+MaintenanceTasks.report_errors_as_handled = false
+
+class MaintenanceTasksErrorSubscriber
+  def report(error, handled:, severity:, context:, source: nil)
+    return unless source == "maintenance-tasks"
+
+    unless handled
+      Bugsnag.notify(error) do |notification|
+        notification.add_metadata(:task, context)
+      end
+    else
+      Rails.logger.info(error)
+    end
+  end
+end
+
+Rails.error.subscribe(MaintenanceTasksErrorSubscriber.new)
+```
+
+`MaintenanceTasks.report_errors_as_handled` determines the value for `handled` in this example.
+By default (for backwards compatibility) this is `true`.
+Setting this to `false` provides more accurate error reporting as it allows to distinguish between
+expected (e.g., via `report_on`) and unexpected errors in error subscribers.
+`false` will be the default in v3.0.
+
 #### Reporting errors during iteration
 
 By default, errors raised during task iteration will be raised to the
@@ -1236,6 +1267,42 @@ The value for `MaintenanceTasks.stuck_task_duration` must be an
 `ActiveSupport::Duration`. If no value is specified, it will default to 5
 minutes.
 
+#### Configure status reload frequency
+
+`MaintenanceTasks.status_reload_frequency` can be configured to specify how often
+the run status should be reloaded during iteration. By default, the status is
+reloaded every second, but this can be increased to improve performance. Note that increasing the reload interval impacts how quickly
+your task will stop if it is paused or interrupted.
+
+```ruby
+# config/initializers/maintenance_tasks.rb
+MaintenanceTasks.status_reload_frequency = 10.seconds  # Reload status every 10 seconds
+```
+
+Individual tasks can also override this setting using the `reload_status_every` method:
+
+```ruby
+# app/tasks/maintenance/update_posts_task.rb
+
+module Maintenance
+  class UpdatePostsTask < MaintenanceTasks::Task
+    # Reload status every 5 seconds instead of the global default
+    reload_status_every(5.seconds)
+
+    def collection
+      Post.all
+    end
+
+    def process(post)
+      post.update!(content: "New content!")
+    end
+  end
+end
+```
+
+This optimization can significantly reduce database queries, especially for short iterations.
+This is especially useful if the task doesn't need to check for cancellation/pausing very often.
+
 #### Metadata
 
 `MaintenanceTasks.metadata` can be configured to specify a proc from which to

data/app/controllers/maintenance_tasks/application_controller.rb

@@ -13,9 +13,15 @@ module MaintenanceTasks
         # <style> tag in app/views/layouts/maintenance_tasks/application.html.erb
         "'sha256-WHHDQLdkleXnAN5zs0GDXC5ls41CHUaVsJtVpaNx+EM='",
       )
+      capybara_lockstep_scripts = [
+        "'sha256-1AoN3ZtJC5OvqkMgrYvhZjp4kI8QjJjO7TAyKYiDw+U='",
+        "'sha256-QVSzZi6ZsX/cu4h+hIs1iVivG1BxUmJggiEsGDIXBG0='", # with debug on
+      ] if defined?(Capybara::Lockstep)
       policy.script_src_elem(
         # <script> tag in app/views/layouts/maintenance_tasks/application.html.erb
         "'sha256-NiHKryHWudRC2IteTqmY9v1VkaDUA/5jhgXkMTkgo2w='",
+        # <script> tag for capybara-lockstep
+        *capybara_lockstep_scripts,
       )
 
       policy.require_trusted_types_for # disable because we use new DOMParser().parseFromString

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

@@ -101,7 +101,8 @@ module MaintenanceTasks
       throw(:abort, :skip_complete_callbacks) if @run.stopping?
       task_iteration(input)
       @ticker.tick
-      @run.reload_status
+
+      reload_run_status
     end
 
     def task_iteration(input)
@@ -127,6 +128,8 @@ module MaintenanceTasks
       @ticker = Ticker.new(MaintenanceTasks.ticker_delay) do |ticks, duration|
         @run.persist_progress(ticks, duration)
       end
+
+      @last_status_reload = nil
     end
 
     def on_start
@@ -190,11 +193,28 @@ module MaintenanceTasks
       if MaintenanceTasks.instance_variable_get(:@error_handler)
         errored_element = task_context.delete(:errored_element)
         MaintenanceTasks.error_handler.call(error, task_context.except(:run_id, :tick_count), errored_element)
-      elsif Rails.gem_version >= Gem::Version.new("7.1")
-        Rails.error.report(error, context: task_context, source: "maintenance-tasks")
       else
-        Rails.error.report(error, handled: true, context: task_context)
+        Rails.error.report(
+          error,
+          handled: MaintenanceTasks.report_errors_as_handled,
+          context: task_context,
+          source: "maintenance-tasks",
+        )
       end
     end
+
+    def reload_run_status
+      return unless should_reload_status?
+
+      @run.reload_status
+      @last_status_reload = Time.now
+    end
+
+    def should_reload_status?
+      return true if @last_status_reload.nil?
+
+      time_since_last_reload = Time.now - @last_status_reload
+      time_since_last_reload >= @task.status_reload_frequency
+    end
   end
 end

data/app/models/maintenance_tasks/run.rb

@@ -44,15 +44,9 @@ module MaintenanceTasks
 
     attr_readonly :task_name
 
-    if Rails.gem_version >= Gem::Version.new("7.1.alpha")
-      serialize :backtrace, coder: YAML
-      serialize :arguments, coder: JSON
-      serialize :metadata, coder: JSON
-    else
-      serialize :backtrace
-      serialize :arguments, JSON
-      serialize :metadata, JSON
-    end
+    serialize :backtrace, coder: YAML
+    serialize :arguments, coder: JSON
+    serialize :metadata, coder: JSON
 
     scope :active, -> { where(status: ACTIVE_STATUSES) }
     scope :completed, -> { where(status: COMPLETED_STATUSES) }
@@ -79,11 +73,10 @@ module MaintenanceTasks
     # Rescues and retries status transition if an ActiveRecord::StaleObjectError
     # is encountered.
     def enqueued!
-      status_will_change!
-      super
-    rescue ActiveRecord::StaleObjectError
-      reload_status
-      retry
+      with_stale_object_retry do
+        status_will_change!
+        super
+      end
     end
 
     CALLBACKS_TRANSITION = {
@@ -92,23 +85,39 @@ module MaintenanceTasks
       paused: :pause,
       succeeded: :complete,
     }.transform_keys(&:to_s)
-    private_constant :CALLBACKS_TRANSITION
+
+    DELAYS_PER_ATTEMPT = [0.1, 0.2, 0.4, 0.8, 1.6]
+    MAX_RETRIES = DELAYS_PER_ATTEMPT.size
+
+    private_constant :CALLBACKS_TRANSITION, :DELAYS_PER_ATTEMPT, :MAX_RETRIES
 
     # Saves the run, persisting the transition of its status, and all other
     # changes to the object.
     def persist_transition
-      save!
+      retry_count = 0
+      begin
+        save!
+      rescue ActiveRecord::StaleObjectError
+        if retry_count < MAX_RETRIES
+          sleep(DELAYS_PER_ATTEMPT[retry_count])
+          retry_count += 1
+
+          success = succeeded?
+          reload_status
+          if success
+            self.status = :succeeded
+          else
+            job_shutdown
+          end
+
+          retry
+        else
+          raise
+        end
+      end
+
       callback = CALLBACKS_TRANSITION[status]
       run_task_callbacks(callback) if callback
-    rescue ActiveRecord::StaleObjectError
-      success = succeeded?
-      reload_status
-      if success
-        self.status = :succeeded
-      else
-        job_shutdown
-      end
-      retry
     end
 
     # Increments +tick_count+ by +number_of_ticks+ and +time_running+ by
@@ -126,29 +135,23 @@ module MaintenanceTasks
         time_running: duration,
         touch: true,
       )
-      if locking_enabled?
-        locking_column = self.class.locking_column
-        self[locking_column] += 1
-        clear_attribute_change(locking_column)
-      end
     end
 
     # Marks the run as errored and persists the error data.
     #
     # @param error [StandardError] the Error being persisted.
     def persist_error(error)
-      self.started_at ||= Time.now
-      update!(
-        status: :errored,
-        error_class: truncate(:error_class, error.class.name),
-        error_message: truncate(:error_message, error.message),
-        backtrace: MaintenanceTasks.backtrace_cleaner.clean(error.backtrace),
-        ended_at: Time.now,
-      )
+      with_stale_object_retry do
+        self.started_at ||= Time.now
+        update!(
+          status: :errored,
+          error_class: truncate(:error_class, error.class.name),
+          error_message: truncate(:error_message, error.message),
+          backtrace: MaintenanceTasks.backtrace_cleaner.clean(error.backtrace),
+          ended_at: Time.now,
+        )
+      end
       run_error_callback
-    rescue ActiveRecord::StaleObjectError
-      reload_status
-      retry
     end
 
     # Refreshes the status and lock version attributes on the Active Record
@@ -241,11 +244,8 @@ module MaintenanceTasks
     # is encountered.
     def running
       if locking_enabled?
-        begin
+        with_stale_object_retry do
           running! unless stopping?
-        rescue ActiveRecord::StaleObjectError
-          reload_status
-          retry
         end
       else
         # Preserve swap-and-replace solution for data races until users
@@ -268,11 +268,11 @@ module MaintenanceTasks
     # @param count [Integer] the total iterations to be performed, as
     #   specified by the Task.
     def start(count)
-      update!(started_at: Time.now, tick_total: count)
+      with_stale_object_retry do
+        update!(started_at: Time.now, tick_total: count)
+      end
+
       task.run_callbacks(:start)
-    rescue ActiveRecord::StaleObjectError
-      reload_status
-      retry
     end
 
     # Handles transitioning the status on a Run when the job shuts down.
@@ -307,16 +307,15 @@ module MaintenanceTasks
     # minutes ago, it will transition to cancelled, and the ended_at timestamp
     # will be updated.
     def cancel
-      if paused? || stuck?
-        self.status = :cancelled
-        self.ended_at = Time.now
-        persist_transition
-      else
-        cancelling!
+      with_stale_object_retry do
+        if paused? || stuck?
+          self.status = :cancelled
+          self.ended_at = Time.now
+          persist_transition
+        else
+          cancelling!
+        end
       end
-    rescue ActiveRecord::StaleObjectError
-      reload_status
-      retry
     end
 
     # Marks a Run as pausing.
@@ -327,15 +326,14 @@ module MaintenanceTasks
     # Rescues and retries status transition if an ActiveRecord::StaleObjectError
     # is encountered.
     def pause
-      if stuck?
-        self.status = :paused
-        persist_transition
-      else
-        pausing!
+      with_stale_object_retry do
+        if stuck?
+          self.status = :paused
+          persist_transition
+        else
+          pausing!
+        end
       end
-    rescue ActiveRecord::StaleObjectError
-      reload_status
-      retry
     end
 
     # Returns whether a Run is stuck, which is defined as having a status of
@@ -499,5 +497,26 @@ module MaintenanceTasks
         Rails.application.config.filter_parameters + task.masked_arguments,
       )
     end
+
+    def with_stale_object_retry(retry_count = 0)
+      yield
+    rescue ActiveRecord::StaleObjectError
+      if retry_count < MAX_RETRIES
+        sleep(stale_object_retry_delay(retry_count))
+        retry_count += 1
+        reload_status
+
+        retry
+      else
+        raise
+      end
+    end
+
+    def stale_object_retry_delay(retry_count)
+      delay = DELAYS_PER_ATTEMPT[retry_count]
+      # Add jitter (±25% randomization) to prevent thundering herd
+      jitter = delay * 0.25
+      delay + (rand * 2 - 1) * jitter
+    end
   end
 end

data/app/models/maintenance_tasks/task.rb

@@ -33,6 +33,12 @@ module MaintenanceTasks
     # @api private
     class_attribute :masked_arguments, default: []
 
+    # The frequency at which to reload the run status during iteration.
+    # Defaults to the global MaintenanceTasks.status_reload_frequency setting.
+    #
+    # @api private
+    class_attribute :status_reload_frequency, default: MaintenanceTasks.status_reload_frequency
+
     define_callbacks :start, :complete, :error, :cancel, :pause, :interrupt
 
     attr_accessor :metadata
@@ -167,6 +173,15 @@ module MaintenanceTasks
         self.masked_arguments += attributes
       end
 
+      # Configure how frequently the run status should be reloaded during iteration.
+      # Use this to reduce database queries when processing large collections.
+      #
+      # @param frequency [ActiveSupport::Duration, Numeric] reload status every N seconds (default: 1 second).
+      #   Setting this to 10.seconds means status will be reloaded every 10 seconds.
+      def reload_status_every(frequency)
+        self.status_reload_frequency = frequency
+      end
+
       # Initialize a callback to run after the task starts.
       #
       # @param filter_list apply filters to the callback
@@ -220,14 +235,10 @@ module MaintenanceTasks
       #
       # @param exceptions list of exceptions to rescue and report
       # @param report_options [Hash] optionally, supply additional options for `Rails.error.report`.
-      #   By default: <code>{ source: "maintenance_tasks" }</code> or (Rails <v7.1) <code>{ handled: true }</code>.
+      #   By default: <code>{ handled: true, source: "maintenance-tasks" }</code>.
       def report_on(*exceptions, **report_options)
         rescue_from(*exceptions) do |exception|
-          if Rails.gem_version >= Gem::Version.new("7.1")
-            Rails.error.report(exception, source: "maintenance_tasks", **report_options)
-          else
-            Rails.error.report(exception, handled: true, **report_options)
-          end
+          Rails.error.report(exception, source: "maintenance-tasks", **report_options)
         end
       end
 

data/app/views/layouts/maintenance_tasks/application.html.erb

@@ -3,6 +3,7 @@
   <head>
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1">
+    <%= capybara_lockstep if defined?(Capybara::Lockstep) %>
 
     <title>
       <% if content_for?(:page_title) %>
@@ -99,6 +100,6 @@
 
         <%= yield %>
       </div>
-    </div>
+    </section>
   </body>
 </html>

data/db/migrate/20201211151756_create_maintenance_tasks_runs.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class CreateMaintenanceTasksRuns < ActiveRecord::Migration[6.0]
+class CreateMaintenanceTasksRuns < ActiveRecord::Migration[7.0]
   def change
     create_table(:maintenance_tasks_runs, id: primary_key_type) do |t|
       t.string(:task_name, null: false)

data/db/migrate/20210219212931_change_cursor_to_string.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class ChangeCursorToString < ActiveRecord::Migration[6.0]
+class ChangeCursorToString < ActiveRecord::Migration[7.0]
   # This migration will clear all existing data in the cursor column with MySQL.
   # Ensure no Tasks are paused when this migration is deployed, or they will be resumed from the start.
   # Running tasks are able to gracefully handle this change, even if interrupted.

data/db/migrate/20210225152418_remove_index_on_task_name.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class RemoveIndexOnTaskName < ActiveRecord::Migration[6.0]
+class RemoveIndexOnTaskName < ActiveRecord::Migration[7.0]
   def up
     change_table(:maintenance_tasks_runs) do |t|
       t.remove_index(:task_name)

data/db/migrate/20210517131953_add_arguments_to_maintenance_tasks_runs.rb

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

data/db/migrate/20211210152329_add_lock_version_to_maintenance_tasks_runs.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class AddLockVersionToMaintenanceTasksRuns < ActiveRecord::Migration[6.0]
+class AddLockVersionToMaintenanceTasksRuns < ActiveRecord::Migration[7.0]
   def change
     add_column(
       :maintenance_tasks_runs,

data/db/migrate/20220706101937_change_runs_tick_columns_to_bigints.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class ChangeRunsTickColumnsToBigints < ActiveRecord::Migration[6.0]
+class ChangeRunsTickColumnsToBigints < ActiveRecord::Migration[7.0]
   def up
     change_table(:maintenance_tasks_runs, bulk: true) do |t|
       t.change(:tick_count, :bigint)

data/db/migrate/20220713131925_add_index_on_task_name_and_status_to_runs.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class AddIndexOnTaskNameAndStatusToRuns < ActiveRecord::Migration[6.0]
+class AddIndexOnTaskNameAndStatusToRuns < ActiveRecord::Migration[7.0]
   def change
     remove_index(
       :maintenance_tasks_runs,

data/db/migrate/20230622035229_add_metadata_to_runs.rb

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

data/lib/maintenance_tasks/engine.rb

@@ -21,10 +21,8 @@ module MaintenanceTasks
       MaintenanceTasks.backtrace_cleaner = Rails.backtrace_cleaner
     end
 
-    if Rails.gem_version >= Gem::Version.new("7.1")
-      initializer "maintenance_tasks.deprecator" do
-        Rails.application.deprecators[:maintenance_tasks] = MaintenanceTasks.deprecator
-      end
+    initializer "maintenance_tasks.deprecator" do
+      Rails.application.deprecators[:maintenance_tasks] = MaintenanceTasks.deprecator
     end
 
     config.to_prepare do

data/lib/maintenance_tasks.rb

@@ -85,6 +85,30 @@ module MaintenanceTasks
   #  @return [ActiveSupport::Duration] the threshold in seconds after which a task is considered stuck.
   mattr_accessor :stuck_task_duration, default: 5.minutes
 
+  # @!attribute status_reload_frequency
+  #  @scope class
+  #  The frequency at which to reload the run status during iteration.
+  #  Defaults to 1 second, meaning reload status every second.
+  #
+  #  @return [ActiveSupport::Duration, Numeric] the time interval between status reloads.
+  mattr_accessor :status_reload_frequency, default: 1.second
+
+  # @!attribute report_errors_as_handled
+  #  @scope class
+  #  How unexpected errors are reported to Rails.error.report.
+  #
+  #  When an error occurs that isn't explicitly handled (e.g., via `report_on`),
+  #  it gets reported to Rails.error.report. This setting determines whether
+  #  these errors are marked as "handled" or "unhandled".
+  #
+  #  The current default of `true` is for backwards compatibility, but it prevents
+  #  error subscribers from distinguishing between expected and unexpected errors.
+  #  Setting this to `false` provides more accurate error reporting and will become the default in v3.0.
+  #
+  #  @see https://api.rubyonrails.org/classes/ActiveSupport/ErrorReporter.html#method-i-report
+  #  @return [Boolean] whether to report unexpected errors as handled (true) or unhandled (false).
+  mattr_accessor :report_errors_as_handled, default: true
+
   class << self
     DEPRECATION_MESSAGE = "MaintenanceTasks.error_handler is deprecated and will be removed in the 3.0 release. " \
       "Instead, reports will be sent to the Rails error reporter. Do not set a handler and subscribe " \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maintenance_tasks
 version: !ruby/object:Gem::Version
-  version: 2.12.0
+  version: 2.13.0
 platform: ruby
 authors:
 - Shopify Engineering
@@ -15,42 +15,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: csv
   requirement: !ruby/object:Gem::Requirement
@@ -85,14 +85,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -182,7 +182,7 @@ homepage: https://github.com/Shopify/maintenance_tasks
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v2.12.0
+  source_code_uri: https://github.com/Shopify/maintenance_tasks/tree/v2.13.0
   allowed_push_host: https://rubygems.org
 rdoc_options: []
 require_paths:
@@ -191,14 +191,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.7.2
 specification_version: 4
 summary: A Rails engine for queuing and managing maintenance tasks
 test_files: []