maintenance_tasks 2.12.0 → 2.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d307d92f96c1d1975cc3fbefcddf6ec2e11086097437b63594090c5bc524eea8
-  data.tar.gz: 9176d7a34c4a54f450601ea2748a88b1a9f134c9e416e97978e613bf3fbf1538
+  metadata.gz: 7ceffb83ecb318ecf0edd66c78f55d4dd51c6528d4faf72d6e7ca66efa83db02
+  data.tar.gz: 360bc77f347ac909ed96a30495f965cc908cc5fc7956f1edfa8c3b2aba385607
 SHA512:
-  metadata.gz: 87d37b437e518c0398023335fe88cb0c7829387142873eeb01aa713df04f397e7711491f0ace1a32baae20f4f1a613313c59e95696deef73d6ecfad24b6fb267
-  data.tar.gz: b0c5fce124651391b77b8f2e5d91f8eb84c0415744fda8429b11a64b730a2e1ef02335c05685a98946fffdfd5042aa3b6f2a23a645a454613acd364af612b09d
+  metadata.gz: b46d6c5afcb297a2be58c9e218cad173b4abf65d50784574ac5fb4afdbaeaf83fc9add501e0817c85190b6b0e4299988b9a3ca87d28a83147e912e10f8d98cfd
+  data.tar.gz: 5b4ecaeff775b36f909dfe80d50df4834d642ba1fbf09d9668d11d47d011a2bb1a8302b612a07d8bec9f0b4d14ffba2d33f53f6e46b9999b6b74df4c41f9571b

data/README.md

@@ -242,8 +242,8 @@ 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
+def count
+  csv_content.count("\n") - 1
 end
 ```
 
@@ -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

@@ -11,11 +11,17 @@ module MaintenanceTasks
       policy.style_src_elem(
         BULMA_CDN,
         # <style> tag in app/views/layouts/maintenance_tasks/application.html.erb
-        "'sha256-WHHDQLdkleXnAN5zs0GDXC5ls41CHUaVsJtVpaNx+EM='",
+        "'sha256-b9tTK1UaF0U8792/A1vIUkeZwjPgECIOeKJdhYED06A='",
       )
+      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