good_job 3.27.4 → 3.28.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa73a0d9ffc1feb2548c525af767537d79a8b6fdf4e03092c4963d91041eb73a
-  data.tar.gz: 41365ce2085788ff587d85a96d6bf1568fb5861ea025e98c87990ae65485ffc8
+  metadata.gz: 3bbf6aa5c2cdbc7b2ff5b5f7dd31a219140934b799737c192aa8de55e5030bca
+  data.tar.gz: 1f7c614722781287cf6482af08fe97d4af5305fdfbd7583ce343277b7b8fe5a1
 SHA512:
-  metadata.gz: a300b98ed92353715dff14d18940f0e9fa2896e1cda56428c026e62b162e3f7a2f5a07eba2a9501af2d0c1f4fa51f3c225a4ecc103f73e8eac862ec343902e6e
-  data.tar.gz: 25241155b1d5e375a903cbeec98e88ecaaca2fc46b1134c92ed400fbf2b024a637744db072fe42fb9af486e7ce43cec5262c6c31adceb2f948af3aacb7cc9584
+  metadata.gz: 3f97f043eed52700808203c42ab9a714a7fdefdd33f3a201045a9a1649e675de6305386439f4707788a89842993902187c21b89939e4458e6a1750d25d6972d1
+  data.tar.gz: a3591c147f153964a0d929d8b49c43386b9f03bf53414471eed55d5312d9bb72e0fbd0ee49b966519570b4a13f33d4fa5ddda91c47d6fa31342af928cfa8185a

data/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+## [v3.28.1](https://github.com/bensheldon/good_job/tree/v3.28.1) (2024-04-24)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.28.0...v3.28.1)
+
+**Fixed bugs:**
+
+- Ensure job context does not leak into extensions when`perform_now` is called within another job [\#1336](https://github.com/bensheldon/good_job/pull/1336) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Executing perform\_now on a good\_job with GoodJobs::ActiveJobExtensions::Concurrency can run twice [\#1335](https://github.com/bensheldon/good_job/issues/1335)
+- `erb_lint` doesn't lint all files [\#1329](https://github.com/bensheldon/good_job/issues/1329)
+- Server hangs after \#1297 [\#1301](https://github.com/bensheldon/good_job/issues/1301)
+- Figure out how to use bind parameters for time queries [\#1285](https://github.com/bensheldon/good_job/issues/1285)
+
+**Merged pull requests:**
+
+- Upgrade development / demo Ruby to v3.3.1 [\#1333](https://github.com/bensheldon/good_job/pull/1333) ([bensheldon](https://github.com/bensheldon))
+- Exploratory testing for presence of scheduled\_at when enqueuing [\#1332](https://github.com/bensheldon/good_job/pull/1332) ([bensheldon](https://github.com/bensheldon))
+- Run `erb_lint` against all the views and partials [\#1331](https://github.com/bensheldon/good_job/pull/1331) ([bensheldon](https://github.com/bensheldon))
+
+## [v3.28.0](https://github.com/bensheldon/good_job/tree/v3.28.0) (2024-04-19)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v3.27.4...v3.28.0)
+
+**Implemented enhancements:**
+
+- Store and optionally display the full execution backtrace [\#1328](https://github.com/bensheldon/good_job/pull/1328) ([Earlopain](https://github.com/Earlopain))
+- Store error backtraces on discrete executions [\#1325](https://github.com/bensheldon/good_job/pull/1325) ([Intrepidd](https://github.com/Intrepidd))
+
+**Fixed bugs:**
+
+- add missing dropdown-item class [\#1327](https://github.com/bensheldon/good_job/pull/1327) ([patriciomacadden](https://github.com/patriciomacadden))
+
+**Closed issues:**
+
+- Proposal: Migrating Documentation to a Separate Website [\#1324](https://github.com/bensheldon/good_job/issues/1324)
+- Potential documentation error in GoodJob::ActiveJobExtensions::NotifyOptions [\#1321](https://github.com/bensheldon/good_job/issues/1321)
+- ActiveSupport::CurrentAttributes reset after `perform_later` [\#1320](https://github.com/bensheldon/good_job/issues/1320)
+- Storing backtrace in database? [\#1162](https://github.com/bensheldon/good_job/issues/1162)
+- Potential locking race condition when using cron scheduler across multiple processes [\#731](https://github.com/bensheldon/good_job/issues/731)
+
+**Merged pull requests:**
+
+- docs: corrected a typo regarding the use of GoodJob::ActiveJobExtensions::NotifyOptions [\#1322](https://github.com/bensheldon/good_job/pull/1322) ([pgvsalamander](https://github.com/pgvsalamander))
+- Add "best practices" section to Readme [\#1318](https://github.com/bensheldon/good_job/pull/1318) ([bensheldon](https://github.com/bensheldon))
+- Change ApplicationRecord to ApplicationJob for label documentation. [\#1317](https://github.com/bensheldon/good_job/pull/1317) ([frans-k](https://github.com/frans-k))
+- Run test matrix against Ruby 3.3; remove pry [\#1315](https://github.com/bensheldon/good_job/pull/1315) ([bensheldon](https://github.com/bensheldon))
+- Add `Rails.application.load_server` to Demo `config.ru`; quiet puma web-concurrency warnings [\#1314](https://github.com/bensheldon/good_job/pull/1314) ([bensheldon](https://github.com/bensheldon))
+- Fix test leakage of configuration double [\#1312](https://github.com/bensheldon/good_job/pull/1312) ([bensheldon](https://github.com/bensheldon))
+- Rewrite queries to all use bind parameters and prepare: true [\#1308](https://github.com/bensheldon/good_job/pull/1308) ([bensheldon](https://github.com/bensheldon))
+
 ## [v3.27.4](https://github.com/bensheldon/good_job/tree/v3.27.4) (2024-04-04)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v3.27.3...v3.27.4)

data/README.md

@@ -72,6 +72,11 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - [Write tests](#write-tests)
     - [PgBouncer compatibility](#pgbouncer-compatibility)
     - [CLI HTTP health check probes](#cli-http-health-check-probes)
+- [Doing your best job with GoodJob](#doing-your-best-job-with-goodjob)
+    - [Sizing jobs: mice and elephants](#sizing-jobs-mice-and-elephants)
+    - [Isolating by total latency](#isolating-by-total-latency)
+    - [Configuring your queues](#configuring-your-queues)
+    - [Additional observations](#additional-observations)
 - [Contribute](#contribute)
     - [Gem development](#gem-development)
         - [Development setup](#development-setup)
@@ -500,12 +505,12 @@ Higher priority numbers run first in all versions of GoodJob v3.x and below. Goo
 Labels are the recommended way to add context or metadata to specific jobs. For example, all jobs that have a dependency on an email service could be labeled `email`. Using labels requires adding the Active Job extension `GoodJob::ActiveJobExtensions::Labels` to your job class.
 
 ```ruby
-class ApplicationRecord < ActiveJob::Base
+class ApplicationJob < ActiveJob::Base
   include GoodJob::ActiveJobExtensions::Labels
 end
 
 # Add a default label to every job within the class
-class WelcomeJob < ApplicationRecord
+class WelcomeJob < ApplicationJob
   self.good_job_labels = ["email"]
 
   def perform
@@ -1527,6 +1532,90 @@ gem 'webrick'
 
 If WEBrick is configured to be used, but the dependency is not found, GoodJob will log a warning and fallback to the default probe server.
 
+## Doing your best job with GoodJob
+
+_This section explains how to use GoodJob the most efficiently and performantly, according to its maintainers. GoodJob is very flexible and you don’t necessarily have to use it this way, but the concepts explained here are part of GoodJob’s design intent._
+
+Background jobs are hard. There are two extremes:
+
+- **Throw resources (compute, servers, money) at it** by creating dedicated processes (or servers) for each type of job or queue and scaling them independently to achieve the lowest latency and highest throughput.
+- **Do the best you can in a small budget** by creating dedicated _thread pools_ within a process for each type of job or queue to produce quality-of-service and compromise maximum latency (or tail latency) because of shared resources and thread contention. You can even run them in the web process if you’re really cheap.
+
+This section will largely focused on optimizing within the latter small-budget scenario, but the concepts and explanation should help you optimize the big-budget scenario too.
+
+Let’s start with anti-patterns, and then the rest of this section will explain an alternative:
+
+- **Don’t use functional names for your queues** like `mailers` or `sms` or `turbo` or `batch`.  Instead name them after the total latency target (the total duration within queue and executing till finish) you expect for that job e.g.`latency_30s` or `latency_5m` or `literally_whenever`.
+- **Priority can’t fix a lack of capacity.** Priority rules (i.e. weighing or ordering which jobs or queues execute first) only works when there is  capacity available to execute that _next_ job. When all capacity is in-use, priority cannot preempt a job that is already executing ("head-of-line blocking").
+
+The following will explain methods to create homogenous workloads (based on latency) and increase execution capacity when queuing latency causes the jobs to exceed their total latency target.
+
+### Sizing jobs: mice and elephants
+
+Queuing theory will refer to fast/small/low-latency tasks as **Mice** (e.g. a password reset email, an MFA token via SMS) and slow/big/high-latency tasks as **Elephants** (e.g. sending an email newsletter to 10k recipients, a batched update that touches every record in the database).
+
+Explicitly group your jobs by their latency: how quickly you expect them to finish to achieve your expected quality of service. This should be their **total latency** (or duration) which is the sum of: **queuing latency** which is how long the job waits in queue until execution capacity becomes available (which ideally should be zero, because you have idle capacity and can start executing a job immediately as soon as it is enqueued or upon its scheduled time) and **execution latency** which is how long the job’s execution takes (e.g. the email being sent). Example: I expect this Password Reset Email Job to have a total latency of 30 seconds or less.
+
+In a working application, you likely will have more gradations than just small and big or slow and fast (analogously: badgers, wildebeests; maybe even tardigrades or blue whales for tiny and huge, respectively), but there will regardless be a relatively small and countable number of discrete latency buckets to organize your jobs into.
+
+### Isolating by total latency
+
+The most efficient workloads are homogenous (similar) workloads. If you know every job to be executed will take about the same amount of time, you can estimate the maximum delay for a new job at the back of the queue and have that drive decisions about capacity. Alternatively, if those jobs are heterogenous (mixed) it’s possible that a very slow/long-duration job could hold everything back for much longer than anticipated and it’s sorta random. That’s bad!
+
+A fun visual image here for a single-file queue is a doorway: If you only have 1 doorway, it must be big enough to fit an elephant. But if an elephant is going through the door (and it will go through slowly!) no mice can fit through the door until the elephant is fully clear. Your mice will be delayed!
+
+Priority will not help when an elephant is in the doorway. Yes, you could say mice have a higher priority than elephants and always allow any mouse to go _before_ any elephant in queue will start. But once an elephant *has started* going through the door, any subsequent mouse who arrives must wait for the elephant to egress regardless of their priority. In Active Job and Ruby, it’s really hard to stop or cancel or preempt a running job (unless you’ve already architected that into your jobs, like with the [`job-iteration`](https://github.com/Shopify/job-iteration) library)
+
+The best solution is to have a 2nd door, but only sized for mice, so an elephant can’t ever block it. With a mouse-sized doorway _and_ an elephant-sized doorway, mice can still go through the big elephant door when an elephant isn’t using it. Each door has a _maximum_ size (or “latency”) we want it to accept, and smaller is ok, just not larger.
+
+### Configuring your queues
+
+If we wanted to capture the previous 2-door scenario in GoodJob, we’d configure the queues like this;
+
+```ruby
+config.good_job.queues = "mice:1; elephant,mice:1"
+```
+
+This configuration creates two isolated thread pools (separated by a semicolon) each with 1 thread each (the number after the colon). The 2nd thread pool recognizes that both elephants and mice can use that isolated thread pool; if there is an influx of mice, it's possible to use the elephant’s thread pool if an elephant isn't already in progress.
+
+So what if we add an intermediately-sized `badgers` ? In that case, we can make 3 distinct queues:
+
+```ruby
+config.good_job.queues = "mice:1; badgers,mice:1; elephants,badgers,mice:1"
+```
+
+In this case, we make a mouse sized queue, a badger sized queue, and an elephant sized queue. We can simplify this even further:
+
+```ruby
+config.good_job.queues = "mice:1; badgers,mice:1; *:1"
+```
+
+Using the wildcard  `*` for any queue also helps ensure that if a job is enqueued to a newly declared queue (maybe via a dependency or just inadvertently) it will still get executed until you notice and decide on its appropriate latency target.
+
+In these examples, the order doesn’t matter; it just is maybe more readable to go from the lowest-latency to largest-latency pool (the semicolon groups), and then within a pool to list the largest allowable latency first (the commas). Nothing here is about “job priority” or “queue priority”, this is wholly about grouping.
+
+In your application, not the zoo, you’ll want to enqueue your `PaswordResetJob` on the `mice` queue, your `CreateComplicatedObjectJob` on the `badger` queue, and your `AuditEveryAccountEverJob` on the `elephant` queue. But you want to name your queues by latency, so that ends up being:
+
+```ruby
+config.good_job.queues = "latency_30s:1; latency_2m,latency_30s:1; *:1"
+```
+
+And you likely want to have more than one thread (though more than 3-5 threads per process will cause thread contention and slow everything down a bit):
+
+```ruby
+config.good_job.queues = "latency_30s:2; latency_2m,latency_30s:2; *:2"
+```
+
+### Additional observations
+
+- Unlike GoodJob, other Active Job backends may treat a "queue" and an "isolated execution pool" as one and the same. GoodJob allows composing multiple Active Job queues into the same pool for flexibility and to make it easier to migrate from functionally-named queues to latency-based ones.
+- You don't *have* to name your queues explicitly like `latency_30s` but it makes it easier to identify outliers and communicate your operational targets. Many people push back on this; that's ok. An option to capture functional details is to use GoodJob's Labels feature instead of encoding them in the queue name.
+- The downside of organizing your jobs like this is that you may have jobs with the same latency target but wildly different operational parameters, like being coupled to another system that has limited throughput or questionable reliability. GoodJob offers Concurrency and Throttling Controls, but isolation is always the most performant and reliable option, though it requires dedicated resources and costs more.
+- Observe, monitor, and adapt your job queues over time. You likely have incomplete information about the execution latency of your jobs inclusive of all dependencies across all scenarios. You should expect to adjust your queues and grouping over time as you observe their behavior.
+- If you find you have unreliable external dependencies that introduce latency, you may also want to further isolate your jobs based on those dependencies, for example, isolating `latency_10s_email_service` to its own execution pool.
+- Scale on queue latency. Per the previous point in which you do not have complete control over execution latency, you do have control over the queue latency. If queue latency is causing your jobs to miss their total latency target, you must add more capacity (e.g. processes or servers.
+- This is all largely about latency-based queue design. It’s possible to go further and organize by latency _and_ parallelism. For that I recommend Nate Berkopec’s [*Complete Guide to Rails Performance*](https://www.railsspeed.com/) which covers things like Amdahl’s Law.
+
 ## Contribute
 
 <!-- Please keep this section in sync with CONTRIBUTING.md -->

data/app/frontend/good_job/style.css

@@ -42,3 +42,7 @@
 .min-w-auto {
   min-width: auto;
 }
+
+.w-fit-content {
+  width: fit-content
+}

data/app/models/concerns/good_job/advisory_lockable.rb

@@ -46,14 +46,19 @@ module GoodJob
         cte_query = cte_query.limit(select_limit) if select_limit
         cte_type = supports_cte_materialization_specifiers? ? :MATERIALIZED : :""
         composed_cte = Arel::Nodes::As.new(cte_table, Arel::Nodes::UnaryOperation.new(cte_type, cte_query.arel))
+
+        lock_condition = "#{function}(('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)"
         query = cte_table.project(cte_table[:id])
                          .with(composed_cte)
-                         .where(Arel.sql("#{function}(('x' || substr(md5(#{connection.quote(table_name)} || '-' || #{connection.quote_table_name(cte_table.name)}.#{connection.quote_column_name(column)}::text), 1, 16))::bit(64)::bigint)"))
+                         .where(defined?(Arel::Nodes::BoundSqlLiteral) ? Arel::Nodes::BoundSqlLiteral.new(lock_condition, [], {}) : Arel::Nodes::SqlLiteral.new(lock_condition))
 
         limit = original_query.arel.ast.limit
         query.limit = limit.value if limit.present?
 
-        unscoped.where(arel_table[primary_key].in(query)).merge(original_query.only(:order))
+        # Arel.sql and the IN clause prevent this from being preparable
+        # That's why this is manually composed of BoundSqlLiteral's and an InfixOperation
+        # to sidestep anywhere in Arel where the `collector.preparable = false` is set
+        unscoped.where(Arel::Nodes::InfixOperation.new("IN", arel_table[primary_key], query)).merge(original_query.only(:order))
       end)
 
       # Joins the current query with Postgres's +pg_locks+ table (it provides

data/app/models/concerns/good_job/filterable.rb

@@ -17,9 +17,9 @@ module GoodJob
       scope :display_all, (lambda do |after_scheduled_at: nil, after_id: nil|
         query = order(Arel.sql('COALESCE(scheduled_at, created_at) DESC, id DESC'))
         if after_scheduled_at.present? && after_id.present?
-          query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at), id) < (:after_scheduled_at, :after_id)'), after_scheduled_at: after_scheduled_at, after_id: after_id)
+          query = query.where Arel::Nodes::Grouping.new([coalesce_scheduled_at_created_at, arel_table["id"]]).lt(Arel::Nodes::Grouping.new([bind_value('coalesce', after_scheduled_at, ActiveRecord::Type::DateTime), bind_value('id', after_id, ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Uuid)]))
         elsif after_scheduled_at.present?
-          query = query.where(Arel.sql('(COALESCE(scheduled_at, created_at)) < (:after_scheduled_at)'), after_scheduled_at: after_scheduled_at)
+          query = query.where coalesce_scheduled_at_created_at.lt(bind_value('coalesce', after_scheduled_at, ActiveRecord::Type::DateTime))
         end
         query
       end)
@@ -34,6 +34,7 @@ module GoodJob
         query = query.to_s.strip
         next if query.blank?
 
+        # TODO: turn this into proper bind parameters in Arel
         tsvector = "(to_tsvector('english', id::text) || to_tsvector('english', COALESCE(active_job_id::text, '')) || to_tsvector('english', serialized_params) || to_tsvector('english', COALESCE(error, ''))#{" || to_tsvector('english', COALESCE(array_to_string(labels, ' '), ''))" if labels_migrated?})"
         to_tsquery_function = database_supports_websearch_to_tsquery? ? 'websearch_to_tsquery' : 'plainto_tsquery'
         where("#{tsvector} @@ #{to_tsquery_function}(?)", query)

data/app/models/good_job/base_record.rb

@@ -40,6 +40,10 @@ module GoodJob
       end
     end
 
+    def self.bind_value(name, value, type_class)
+      Arel::Nodes::BindParam.new(ActiveRecord::Relation::QueryAttribute.new(name, value, type_class.new))
+    end
+
     ActiveSupport.run_load_hooks(:good_job_base_record, self)
   end
 end

data/app/models/good_job/batch_record.rb

@@ -18,6 +18,8 @@ module GoodJob
     scope :not_discarded, -> { where(discarded_at: nil) }
     scope :succeeded, -> { finished.not_discarded }
 
+    scope :finished_before, ->(timestamp) { where(arel_table['finished_at'].lteq(bind_value('finished_at', timestamp, ActiveRecord::Type::DateTime))) }
+
     alias_attribute :enqueued?, :enqueued_at
     alias_attribute :discarded?, :discarded_at
     alias_attribute :finished?, :finished_at
@@ -25,9 +27,13 @@ module GoodJob
     scope :display_all, (lambda do |after_created_at: nil, after_id: nil|
       query = order(created_at: :desc, id: :desc)
       if after_created_at.present? && after_id.present?
-        query = query.where(Arel.sql('(created_at, id) < (:after_created_at, :after_id)'), after_created_at: after_created_at, after_id: after_id)
+        query = if Gem::Version.new(Rails.version) < Gem::Version.new('7.0.0.a') || Concurrent.on_jruby?
+                  query.where(Arel.sql('(created_at, id) < (:after_created_at, :after_id)'), after_created_at: after_created_at, after_id: after_id)
+                else
+                  query.where Arel::Nodes::Grouping.new([arel_table["created_at"], arel_table["id"]]).lt(Arel::Nodes::Grouping.new([bind_value('created_at', after_created_at, ActiveRecord::Type::DateTime), bind_value('id', after_id, ActiveRecord::Type::String)]))
+                end
       elsif after_created_at.present?
-        query = query.where(Arel.sql('(after_created_at) < (:after_created_at)'), after_created_at: after_created_at)
+        query = query.where arel_table["created_at"].lt(bind_value('created_at', after_created_at, ActiveRecord::Type::DateTime))
       end
       query
     end)

data/app/models/good_job/discrete_execution.rb

@@ -21,6 +21,13 @@ module GoodJob # :nodoc:
       false
     end
 
+    def self.backtrace_migrated?
+      return true if columns_hash["error_backtrace"].present?
+
+      migration_pending_warning!
+      false
+    end
+
     def number
       serialized_params.fetch('executions', 0) + 1
     end
@@ -58,5 +65,9 @@ module GoodJob # :nodoc:
                                 _good_job_execution: attributes.except('serialized_params'),
                               })
     end
+
+    def filtered_error_backtrace
+      Rails.backtrace_cleaner.clean(error_backtrace || [])
+    end
   end
 end

data/app/models/good_job/execution.rb

@@ -95,7 +95,7 @@ module GoodJob
     # @!method only_scheduled
     # @!scope class
     # @return [ActiveRecord::Relation]
-    scope :only_scheduled, -> { where(arel_table['scheduled_at'].lteq(Arel::Nodes::BindParam.new(ActiveModel::Attribute.with_cast_value("scheduled_at", Time.current, ActiveModel::Type::DateTime.new)))).or(where(scheduled_at: nil)) }
+    scope :only_scheduled, -> { where(arel_table['scheduled_at'].lteq(bind_value('scheduled_at', DateTime.current, ActiveRecord::Type::DateTime))).or(where(scheduled_at: nil)) }
 
     # Order executions by priority (highest priority first).
     # @!method priority_ordered
@@ -161,7 +161,7 @@ module GoodJob
     # @param timestamp (Float)
     #   Get jobs that finished before this time (in epoch time).
     # @return [ActiveRecord::Relation]
-    scope :finished, ->(timestamp = nil) { timestamp ? where(arel_table['finished_at'].lteq(timestamp)) : where.not(finished_at: nil) }
+    scope :finished, ->(timestamp = nil) { timestamp ? where(arel_table['finished_at'].lteq(bind_value('finished_at', timestamp, ActiveRecord::Type::DateTime))) : where.not(finished_at: nil) }
 
     # Get Jobs that started but not finished yet.
     # @!method running
@@ -290,11 +290,12 @@ module GoodJob
       query = advisory_unlocked.unfinished.schedule_ordered
 
       after ||= Time.current
-      after_query = query.where('scheduled_at > ?', after).or query.where(scheduled_at: nil).where('created_at > ?', after)
+      after_bind = bind_value('scheduled_at', after, ActiveRecord::Type::DateTime)
+      after_query = query.where(arel_table['scheduled_at'].gt(after_bind)).or query.where(scheduled_at: nil).where(arel_table['created_at'].gt(after_bind))
       after_at = after_query.limit(limit).pluck(:scheduled_at, :created_at).map { |timestamps| timestamps.compact.first }
 
       if now_limit&.positive?
-        now_query = query.where('scheduled_at < ?', Time.current).or query.where(scheduled_at: nil)
+        now_query = query.where(arel_table['scheduled_at'].lt(bind_value('scheduled_at', Time.current, ActiveRecord::Type::DateTime))).or query.where(scheduled_at: nil)
         now_at = now_query.limit(now_limit).pluck(:scheduled_at, :created_at).map { |timestamps| timestamps.compact.first }
       end
 
@@ -460,6 +461,7 @@ module GoodJob
           if discrete_execution
             discrete_execution.error = error_string
             discrete_execution.error_event = result.error_event
+            discrete_execution.error_backtrace = job_error.backtrace if discrete_execution.class.backtrace_migrated?
           end
         else
           job_attributes[:error] = nil

data/app/models/good_job/job.rb

@@ -44,14 +44,14 @@ module GoodJob
     # @!scope class
     # @param timestamp (DateTime, Time)
     # @return [ActiveRecord::Relation]
-    scope :finished_before, ->(timestamp) { where(arel_table['finished_at'].lteq(timestamp)) }
+    scope :finished_before, ->(timestamp) { where(arel_table['finished_at'].lteq(bind_value('finished_at', timestamp, ActiveRecord::Type::DateTime))) }
 
     # First execution will run in the future
-    scope :scheduled, -> { where(finished_at: nil).where(coalesce_scheduled_at_created_at.gt(DateTime.current)).where(params_execution_count.lt(2)) }
+    scope :scheduled, -> { where(finished_at: nil).where(coalesce_scheduled_at_created_at.gt(bind_value('coalesce', Time.current, ActiveRecord::Type::DateTime))).where(params_execution_count.lt(2)) }
     # Execution errored, will run in the future
-    scope :retried, -> { where(finished_at: nil).where(coalesce_scheduled_at_created_at.gt(DateTime.current)).where(params_execution_count.gt(1)) }
+    scope :retried, -> { where(finished_at: nil).where(coalesce_scheduled_at_created_at.gt(bind_value('coalesce', Time.current, ActiveRecord::Type::DateTime))).where(params_execution_count.gt(1)) }
     # Immediate/Scheduled time to run has passed, waiting for an available thread run
-    scope :queued, -> { where(finished_at: nil).where(coalesce_scheduled_at_created_at.lteq(DateTime.current)).joins_advisory_locks.where(pg_locks: { locktype: nil }) }
+    scope :queued, -> { where(finished_at: nil).where(coalesce_scheduled_at_created_at.lteq(bind_value('coalesce', Time.current, ActiveRecord::Type::DateTime))).joins_advisory_locks.where(pg_locks: { locktype: nil }) }
     # Advisory locked and executing
     scope :running, -> { where(finished_at: nil).joins_advisory_locks.where.not(pg_locks: { locktype: nil }) }
     # Finished executing (succeeded or discarded)

data/app/views/good_job/batches/_jobs.erb

@@ -2,14 +2,14 @@
     <div class="list-group list-group-flush text-nowrap table-jobs" role="table">
       <header class="list-group-item bg-body-tertiary">
         <div class="row small text-muted text-uppercase align-items-center">
-        <div class="col-4"><%=t "good_job.models.batch.jobs" %></div>
-          <div class="d-none d-lg-block col-lg-1 text-lg-center"><%=t "good_job.models.job.queue" %></div>
-          <div class="d-none d-lg-block col-lg-1 text-lg-end"><%=t "good_job.models.job.priority" %></div>
-          <div class="d-none d-lg-block col-lg-1 text-lg-end"><%=t "good_job.models.job.attempts" %></div>
+        <div class="col-4"><%= t("good_job.models.batch.jobs") %></div>
+          <div class="d-none d-lg-block col-lg-1 text-lg-center"><%= t "good_job.models.job.queue" %></div>
+          <div class="d-none d-lg-block col-lg-1 text-lg-end"><%= t "good_job.models.job.priority" %></div>
+          <div class="d-none d-lg-block col-lg-1 text-lg-end"><%= t "good_job.models.job.attempts" %></div>
           <div class="col text-end">
             <%= tag.button type: "button", class: "btn btn-sm text-muted", role: "button",
                            data: { bs_toggle: "collapse", bs_target: ".job-params" },
-                           aria: { expanded: false, controls: jobs.map { |job| "##{dom_id(job, "params")}" }.join(" ") } do %>
+                           aria: { expanded: false, controls: jobs.map { |job| "##{dom_id(job, 'params')}" }.join(" ") } do %>
               <%= render_icon "info" %>
               <span class="visually-hidden">Inspect</span>
             <% end %>
@@ -26,22 +26,24 @@
                 <%= tag.h5 tag.code(link_to(job.display_name, job_path(job), class: "text-reset text-decoration-none")), class: "text-reset mb-0" %>
               </div>
               <div class="col-4 col-lg-1 text-lg-center">
-                <div class="d-lg-none small text-muted mt-1"><%=t "good_job.models.job.queue" %></div>
+                <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.queue" %></div>
                 <span class="badge bg-primary text-dark font-monospace"><%= job.queue_name %></span>
               </div>
               <div class="col-4 col-lg-1 text-lg-end">
-                <div class="d-lg-none small text-muted mt-1"><%=t "good_job.models.job.priority" %>Priority</div>
+                <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.priority" %>Priority</div>
                 <span class="font-monospace fw-bold"><%= job.priority %></span>
               </div>
               <div class="col-4 col-lg-1 text-lg-end">
-                <div class="d-lg-none small text-muted mt-1"><%=t "good_job.models.job.attempts" %></div>
+                <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.job.attempts" %></div>
                 <% if job.executions_count > 0 && job.status != :finished %>
-                  <%= tag.span job.executions_count, class: "badge rounded-pill bg-danger", data: {
-                    bs_toggle: "popover",
-                    bs_trigger: "hover focus click",
-                    bs_placement: "bottom",
-                    bs_content: job.recent_error
-                  } %>
+                  <%= tag.span job.executions_count, class: "badge rounded-pill bg-danger",
+                    data: {
+                      bs_toggle: "popover",
+                      bs_trigger: "hover focus click",
+                      bs_placement: "bottom",
+                      bs_content: job.recent_error,
+                    }
+                  %>
                 <% else %>
                   <span class="badge bg-secondary rounded-pill"><%= job.executions_count %></span>
                 <% end %>
@@ -53,33 +55,33 @@
                 <div class="dropdown float-end">
                   <button class="d-flex align-items-center btn btn-sm" type="button" id="<%= dom_id(job, :actions) %>" data-bs-toggle="dropdown" aria-expanded="false">
                     <%= render_icon :dots %>
-                    <span class="visually-hidden"><%=t ".actions.title" %></span>
+                    <span class="visually-hidden"><%= t ".actions.title" %></span>
                   </button>
                   <ul class="dropdown-menu shadow" aria-labelledby="<%= dom_id(job, :actions) %>">
                     <li>
                       <% job_reschedulable = job.status.in? [:scheduled, :retried, :queued] %>
                       <%= link_to reschedule_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job_reschedulable}", title: t(".actions.reschedule"), data: { confirm: t(".actions.confirm_reschedule"), disable: true } do %>
                         <%= render_icon "skip_forward" %>
-                        <%=t "good_job.actions.reschedule" %>
+                        <%= t "good_job.actions.reschedule" %>
                       <% end %>
                     </li>
                     <li>
                       <% job_discardable = job.status.in? [:scheduled, :retried, :queued] %>
                       <%= link_to discard_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job_discardable}", title: t(".actions.discard"), data: { confirm: t(".actions.confirm_discard"), disable: true } do %>
                         <%= render_icon "stop" %>
-                        <%=t "good_job.actions.discard" %>
+                        <%= t "good_job.actions.discard" %>
                       <% end %>
                     </li>
                     <li>
                       <%= link_to retry_job_path(job.id), method: :put, class: "dropdown-item #{'disabled' unless job.status == :discarded}", title: t(".actions.retry"), data: { confirm: t(".actions.confirm_retry"), disable: true } do %>
                         <%= render_icon "arrow_clockwise" %>
-                        <%=t "good_job.actions.retry" %>
+                        <%= t "good_job.actions.retry" %>
                       <% end %>
                     </li>
                     <li>
                       <%= link_to job_path(job.id), method: :delete, class: "dropdown-item #{'disabled' unless job.status.in? [:discarded, :finished]}", title: t(".actions.destroy"), data: { confirm: t(".actions.confirm_destroy"), disable: true } do %>
                         <%= render_icon "trash" %>
-                        <%=t "good_job.actions.destroy" %>
+                        <%= t "good_job.actions.destroy" %>
                       <% end %>
                     </li>
 
@@ -89,7 +91,7 @@
                                   data: { bs_toggle: "collapse" },
                                   aria: { expanded: false, controls: dom_id(job, "params") } do %>
                         <%= render_icon "info" %>
-                        <%=t "good_job.actions.inspect" %>
+                        <%= t "good_job.actions.inspect" %>
                       <% end %>
                     </li>
                   </ul>
@@ -103,7 +105,7 @@
         <% end %>
       <% else %>
         <div class="list-group-item py-4 text-center text-muted">
-          <%=t ".no_jobs_found" %>
+          <%= t ".no_jobs_found" %>
         </div>
       <% end %>
     </div>

data/app/views/good_job/batches/_table.erb

@@ -2,18 +2,18 @@
     <div class="list-group list-group-flush text-nowrap table-batches" role="table">
       <header class="list-group-item bg-body-tertiary">
         <div class="row small text-muted text-uppercase align-items-center">
-          <div class="col-4"><%=t "good_job.models.batch.name" %></div>
-          <div class="col-lg-1 d-none d-lg-block"><%=t "good_job.models.batch.created" %></div>
-          <div class="col-lg-1 d-none d-lg-block"><%=t "good_job.models.batch.enqueued" %></div>
-          <div class="col-lg-1 d-none d-lg-block"><%=t "good_job.models.batch.discarded" %></div>
-          <div class="col-lg-1 d-none d-lg-block"><%=t "good_job.models.batch.finished" %></div>
-          <div class="col-lg-1 d-none d-lg-block"><%=t "good_job.models.batch.jobs" %></div>
+          <div class="col-4"><%= t "good_job.models.batch.name" %></div>
+          <div class="col-lg-1 d-none d-lg-block"><%= t "good_job.models.batch.created" %></div>
+          <div class="col-lg-1 d-none d-lg-block"><%= t "good_job.models.batch.enqueued" %></div>
+          <div class="col-lg-1 d-none d-lg-block"><%= t "good_job.models.batch.discarded" %></div>
+          <div class="col-lg-1 d-none d-lg-block"><%= t "good_job.models.batch.finished" %></div>
+          <div class="col-lg-1 d-none d-lg-block"><%= t "good_job.models.batch.jobs" %></div>
           <div class="col text-end">
             <%= tag.button type: "button", class: "btn btn-sm text-muted", role: "button",
                            data: { bs_toggle: "collapse", bs_target: ".batch-properties" },
-                           aria: { expanded: false, controls: batches.map { |batch| "##{dom_id(batch, "params")}" }.join(" ") } do %>
+                           aria: { expanded: false, controls: batches.map { |batch| "##{dom_id(batch, 'params')}" }.join(" ") } do %>
               <%= render_icon "info" %>
-              <span class="visually-hidden"><%=t "good_job.actions.inspect" %></span>
+              <span class="visually-hidden"><%= t "good_job.actions.inspect" %></span>
             <% end %>
           </div>
         </div>
@@ -33,29 +33,29 @@
                 <% end %>
               </div>
               <div class="col-6 col-lg-1 text-wrap">
-                <div class="d-lg-none small text-muted mt-1"><%=t "good_job.models.batch.created_at" %></div>
+                <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.batch.created_at" %></div>
                 <%= relative_time(batch.created_at) %>
               </div>
               <div class="col-6 col-lg-1 text-wrap">
                 <% if batch.enqueued_at %>
-                  <div class="d-lg-none small text-muted mt-1"><%=t "good_job.models.batch.enqueued_at" %></div>
+                  <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.batch.enqueued_at" %></div>
                   <%= relative_time(batch.enqueued_at) %>
                 <% end %>
               </div>
               <div class="col-6 col-lg-1 text-wrap">
                 <% if batch.discarded_at %>
-                  <div class="d-lg-none small text-muted mt-1"><%=t "good_job.models.batch.discarded_at" %></div>
+                  <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.batch.discarded_at" %></div>
                   <%= relative_time(batch.discarded_at) %>
                 <% end %>
               </div>
               <div class="col-6 col-lg-1 text-wrap">
                 <% if batch.finished_at %>
-                  <div class="d-lg-none small text-muted mt-1"><%=t "good_job.models.batch.finished_at" %></div>
+                  <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.batch.finished_at" %></div>
                   <%= relative_time(batch.finished_at) %>
                 <% end %>
               </div>
               <div class="col-6 col-lg-1">
-                <div class="d-lg-none small text-muted mt-1"><%=t "good_job.models.batch.jobs" %></div>
+                <div class="d-lg-none small text-muted mt-1"><%= t "good_job.models.batch.jobs" %></div>
                 <%= batch.jobs.count %>
               </div>
               <div class="col text-end">
@@ -64,7 +64,7 @@
                                data: { bs_toggle: "collapse", bs_target: "##{dom_id(batch, 'properties')}" },
                                aria: { expanded: false, controls: dom_id(batch, "state") } do %>
                   <%= render_icon "info" %>
-                  <span class="visually-hidden"><%=t "good_job.actions.inspect" %></span>
+                  <span class="visually-hidden"><%= t "good_job.actions.inspect" %></span>
                 <% end %>
               </div>
             </div>
@@ -75,7 +75,7 @@
         <% end %>
       <% else %>
         <div class="list-group-item py-4 text-center text-muted">
-          <%=t ".no_batches_found" %>
+          <%= t ".no_batches_found" %>
         </div>
       <% end %>
     </div>