good_job 2.9.2 → 2.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 43a641edf5b6ff33dc8752874c6b317ad96bfd74ed4cbcb3a9bbeee7ff9c14cf
-  data.tar.gz: bfcf81a0d6c2d7bef01c3abdad9222fcc92cc8a5fd0ead3059fe5b9afd96aefa
+  metadata.gz: 64642ab1c4e807f67310c70fca0d57ae636955b923dbf1c9a0e09a88a4c66a5d
+  data.tar.gz: 69a4d004af970032be6583bfd5a7281c3ee185dedbeb7250cb7d64d9adfc2d46
 SHA512:
-  metadata.gz: ea801613572d4ccdce2af524303220eed9f50532ce80160c8fd9063bb994f0be725cf806d84aad8ea2bf5028f593a79fa13b5d1f7e796ece29eee70d42df9fa8
-  data.tar.gz: 9344d31ec8ffacdaa531a7e8bb7292270b151ad440d9dd95cd7ebfbe4106ca6b276ec3cff671df2ad97c9aee50892d453b584f948a7fc5e1bf7710fd935b2d40
+  metadata.gz: 9c154d015c820d314a4f2b7e7b611d4d858c75950bdef0fbde8d89b7264271b85a43669607e274ea1eca46234e603d48a441fb7a291b6a1969f8c5fb3896bf86
+  data.tar.gz: 5d9534cc68b264fe3901f447383de0265d301ddea893b435b39542575f2b16410569a4442ddb5a5187e803546cf721e3cf1e49a1f81a3c4439f59c4b46b42249

data/CHANGELOG.md

@@ -1,5 +1,66 @@
 # Changelog
 
+## [v2.9.6](https://github.com/bensheldon/good_job/tree/v2.9.6) (2022-02-07)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.9.5...v2.9.6)
+
+**Merged pull requests:**
+
+- Limit query for allowed concurrent jobs to unfinished [\#515](https://github.com/bensheldon/good_job/pull/515) ([til](https://github.com/til))
+
+## [v2.9.5](https://github.com/bensheldon/good_job/tree/v2.9.5) (2022-02-07)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.9.4...v2.9.5)
+
+**Fixed bugs:**
+
+- Transactions in "aborting" threads do not commit; causes GoodJob::Process record not destroyed on exit [\#489](https://github.com/bensheldon/good_job/issues/489)
+- Deserialize ActiveJob arguments when manually retrying a job [\#513](https://github.com/bensheldon/good_job/pull/513) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Concurrency key proc is missing `arguments` when retrying a discarded job. [\#512](https://github.com/bensheldon/good_job/issues/512)
+- Cron Schedule not visible in dashboard [\#496](https://github.com/bensheldon/good_job/issues/496)
+
+**Merged pull requests:**
+
+- Rename methods to `advisory_lock_key` and allow it to take a block instead of `with_advisory_lock` [\#511](https://github.com/bensheldon/good_job/pull/511) ([bensheldon](https://github.com/bensheldon))
+- README: Limiting concurrency - fetch symbol instead of string [\#510](https://github.com/bensheldon/good_job/pull/510) ([BenSto](https://github.com/BenSto))
+- Add arbitrary lock on class level too [\#499](https://github.com/bensheldon/good_job/pull/499) ([pandwoter](https://github.com/pandwoter))
+
+## [v2.9.4](https://github.com/bensheldon/good_job/tree/v2.9.4) (2022-01-31)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.9.3...v2.9.4)
+
+**Fixed bugs:**
+
+- Fix navbar toggler [\#506](https://github.com/bensheldon/good_job/pull/506) ([JuanVqz](https://github.com/JuanVqz))
+- Guard LogSubscriber against tagged logger without a formatter [\#504](https://github.com/bensheldon/good_job/pull/504) ([bensheldon](https://github.com/bensheldon))
+- Markdown lint fixes + Added missing responsive meta tag  [\#492](https://github.com/bensheldon/good_job/pull/492) ([zeevy](https://github.com/zeevy))
+
+**Closed issues:**
+
+- The navbar icon doesn't show the navbar menu when clicking it [\#503](https://github.com/bensheldon/good_job/issues/503)
+- Not all loggers have a formatter [\#502](https://github.com/bensheldon/good_job/issues/502)
+- Error logs from failed jobs used all storage space [\#495](https://github.com/bensheldon/good_job/issues/495)
+
+**Merged pull requests:**
+
+- Update Code of Conduct to Contributor Covenant 2.1 [\#501](https://github.com/bensheldon/good_job/pull/501) ([bensheldon](https://github.com/bensheldon))
+- Test with Ruby 3.1 [\#498](https://github.com/bensheldon/good_job/pull/498) ([aried3r](https://github.com/aried3r))
+
+## [v2.9.3](https://github.com/bensheldon/good_job/tree/v2.9.3) (2022-01-23)
+
+[Full Changelog](https://github.com/bensheldon/good_job/compare/v2.9.2...v2.9.3)
+
+**Fixed bugs:**
+
+- Use `*_url` route helpers for Dashboard assets to avoid being overridden by `config.asset_host` [\#493](https://github.com/bensheldon/good_job/pull/493) ([bensheldon](https://github.com/bensheldon))
+
+**Closed issues:**
+
+- Assets not loaded when Rails is configured with a different hostname for assets [\#491](https://github.com/bensheldon/good_job/issues/491)
+
 ## [v2.9.2](https://github.com/bensheldon/good_job/tree/v2.9.2) (2022-01-19)
 
 [Full Changelog](https://github.com/bensheldon/good_job/compare/v2.9.1...v2.9.2)

data/README.md

@@ -119,7 +119,7 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
     - By default, GoodJob separates job enqueuing from job execution so that jobs can be scaled independently of the web server.  Use the GoodJob command-line tool to execute jobs:
 
         ```bash
-        $ bundle exec good_job start
+        bundle exec good_job start
         ```
 
         Ideally the command-line tool should be run on a separate machine or container from the web process. For example, on Heroku:
@@ -133,8 +133,8 @@ For more of the story of GoodJob, read the [introductory blog post](https://isla
 
     - GoodJob can also be configured to execute jobs within the web server process to save on resources. This is useful for low-workloads when economy is paramount.
 
-        ```
-        $ GOOD_JOB_EXECUTION_MODE=async rails server
+        ```bash
+        GOOD_JOB_EXECUTION_MODE=async rails server
         ```
 
         Additional configuration is likely necessary, see the reference below for configuration.
@@ -399,11 +399,9 @@ class MyJob < ApplicationJob
 
     # A unique key to be globally locked against.
     # Can be String or Lambda/Proc that is invoked in the context of the job.
-    # Note: Arguments passed to #perform_later must be accessed through `arguments` method.
-    key: -> { "Unique-#{arguments.first}" } #  MyJob.perform_later("Alice") => "Unique-Alice"
-
-    # If the method uses named parameters, they can be accessed like so:
-    # key: -> { "Unique-#{arguments.first['name']}" } #  MyJob.perform_later(name: "Alice")
+    # Note: Arguments passed to #perform_later can be accessed through ActiveJob's `arguments` method
+    # which is an array containing positional arguments and, optionally, a kwarg hash.
+    key: -> { "Unique-#{arguments.first}-#{arguments.last[:version]}" } #  MyJob.perform_later("Alice", version: 'v2') => "Unique-Alice-v2"
   )
 
   def perform(first_name)
@@ -470,7 +468,7 @@ To perform upgrades to the GoodJob database tables:
    Optional: If using Rails' multiple databases with the `migrations_paths` configuration option, use the `--database` option:
 
     ```bash
-    $ bin/rails g good_job:update --database animals
+    bin/rails g good_job:update --database animals
     ```
 
 1. Run the database migration locally
@@ -703,7 +701,7 @@ GoodJob can execute jobs "async" in the same process as the web server (e.g. `bi
 - Or, with environment variables:
 
     ```bash
-    $ GOOD_JOB_EXECUTION_MODE=async GOOD_JOB_MAX_THREADS=4 GOOD_JOB_POLL_INTERVAL=30 bin/rails server
+    GOOD_JOB_EXECUTION_MODE=async GOOD_JOB_MAX_THREADS=4 GOOD_JOB_POLL_INTERVAL=30 bin/rails server
     ```
 
 Depending on your application configuration, you may need to take additional steps:
@@ -821,7 +819,7 @@ It is also necessary to delete these preserved jobs from the database after a ce
 - For example, using the `good_job` command-line utility:
 
     ```bash
-    $ bundle exec good_job cleanup_preserved_jobs --before-seconds-ago=86400
+    bundle exec good_job cleanup_preserved_jobs --before-seconds-ago=86400
     ```
 
 ### PgBouncer compatibility

data/engine/app/views/layouts/good_job/base.html.erb

@@ -2,23 +2,26 @@
 <html lang="en">
 <head>
   <title>Good Job Dashboard</title>
+  <meta charset="utf-8">
+  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
   <%= csrf_meta_tags %>
   <%= csp_meta_tag %>
 
-  <%= stylesheet_link_tag bootstrap_path(format: :css, v: GoodJob::VERSION) %>
-  <%= stylesheet_link_tag style_path(format: :css, v: GoodJob::VERSION) %>
+  <%# Assets must use *_url route helpers to avoid being overriden by config.asset_host %>
+  <%= stylesheet_link_tag bootstrap_url(format: :css, v: GoodJob::VERSION), skip_pipeline: true %>
+  <%= stylesheet_link_tag style_url(format: :css, v: GoodJob::VERSION) %>
 
-  <%= javascript_include_tag bootstrap_path(format: :js, v: GoodJob::VERSION), nonce: true %>
-  <%= javascript_include_tag chartjs_path(format: :js, v: GoodJob::VERSION), nonce: true %>
-  <%= javascript_include_tag scripts_path(format: :js, v: GoodJob::VERSION), nonce: true %>
+  <%= javascript_include_tag bootstrap_url(format: :js, v: GoodJob::VERSION), nonce: true %>
+  <%= javascript_include_tag chartjs_url(format: :js, v: GoodJob::VERSION), nonce: true %>
+  <%= javascript_include_tag scripts_url(format: :js, v: GoodJob::VERSION), nonce: true %>
 
-  <%= javascript_include_tag rails_ujs_path(format: :js, v: GoodJob::VERSION), nonce: true %>
+  <%= javascript_include_tag rails_ujs_url(format: :js, v: GoodJob::VERSION), nonce: true %>
 </head>
 <body>
   <nav class="navbar navbar-expand-lg navbar-light bg-light">
     <div class="container-fluid">
       <%= link_to "GoodJob 👍", root_path, class: 'navbar-brand mb-0 h1' %>
-      <button class="navbar-toggler" type="button" data-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
+      <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
         <span class="navbar-toggler-icon"></span>
       </button>
 

data/lib/good_job/active_job_extensions/concurrency.rb

@@ -30,7 +30,7 @@ module GoodJob
           key = job.good_job_concurrency_key
           next(block.call) if key.blank?
 
-          GoodJob::Execution.new.with_advisory_lock(key: key, function: "pg_advisory_lock") do
+          GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
             enqueue_concurrency = if enqueue_limit
                                     GoodJob::Execution.where(concurrency_key: key).unfinished.advisory_unlocked.count
                                   else
@@ -61,8 +61,8 @@ module GoodJob
           key = job.good_job_concurrency_key
           next if key.blank?
 
-          GoodJob::Execution.new.with_advisory_lock(key: key, function: "pg_advisory_lock") do
-            allowed_active_job_ids = GoodJob::Execution.where(concurrency_key: key).advisory_locked.order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC")).limit(perform_limit).pluck(:active_job_id)
+          GoodJob::Execution.advisory_lock_key(key, function: "pg_advisory_lock") do
+            allowed_active_job_ids = GoodJob::Execution.unfinished.where(concurrency_key: key).advisory_locked.order(Arel.sql("COALESCE(performed_at, scheduled_at, created_at) ASC")).limit(perform_limit).pluck(:active_job_id)
             # The current job has already been locked and will appear in the previous query
             raise GoodJob::ActiveJobExtensions::Concurrency::ConcurrencyExceededError unless allowed_active_job_ids.include? job.job_id
           end

data/lib/good_job/execution.rb

@@ -267,7 +267,9 @@ module GoodJob
     end
 
     def active_job
-      ActiveJob::Base.deserialize(active_job_data)
+      ActiveJob::Base.deserialize(active_job_data).tap do |aj|
+        aj.send(:deserialize_arguments_if_needed)
+      end
     end
 
     private

data/lib/good_job/lockable.rb

@@ -148,6 +148,7 @@ module GoodJob
         raise ArgumentError, "Must provide a block" unless block_given?
 
         records = advisory_lock(column: column, function: function).to_a
+
         begin
           unscoped { yield(records) }
         ensure
@@ -161,6 +162,53 @@ module GoodJob
         end
       end
 
+      # Acquires an advisory lock on this record if it is not already locked by
+      # another database session. Be careful to ensure you release the lock when
+      # you are done with {#advisory_unlock_key} to release all remaining locks.
+      # @param key [String, Symbol] Key to Advisory Lock against
+      # @param function [String, Symbol] Postgres Advisory Lock function name to use
+      # @return [Boolean] whether the lock was acquired.
+      def advisory_lock_key(key, function: advisory_lockable_function)
+        query = if function.include? "_try_"
+                  <<~SQL.squish
+                    SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS locked
+                  SQL
+                else
+                  <<~SQL.squish
+                    SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint)::text AS locked
+                  SQL
+                end
+
+        binds = [
+          ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+        ]
+        locked = connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).first['locked']
+        return locked unless block_given?
+        return nil unless locked
+
+        begin
+          yield
+        ensure
+          advisory_unlock_key(key, function: advisory_unlockable_function(function))
+        end
+      end
+
+      # Releases an advisory lock on this record if it is locked by this database
+      # session. Note that advisory locks stack, so you must call
+      # {#advisory_unlock} and {#advisory_lock} the same number of times.
+      # @param key [String, Symbol] Key to lock against
+      # @param function [String, Symbol] Postgres Advisory Lock function name to use
+      # @return [Boolean] whether the lock was released.
+      def advisory_unlock_key(key, function: advisory_unlockable_function)
+        query = <<~SQL.squish
+          SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS unlocked
+        SQL
+        binds = [
+          ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
+        ]
+        connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).first['unlocked']
+      end
+
       def _advisory_lockable_column
         advisory_lockable_column || primary_key
       end
@@ -205,20 +253,7 @@ module GoodJob
     # @param function [String, Symbol] Postgres Advisory Lock function name to use
     # @return [Boolean] whether the lock was acquired.
     def advisory_lock(key: lockable_key, function: advisory_lockable_function)
-      query = if function.include? "_try_"
-                <<~SQL.squish
-                  SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS locked
-                SQL
-              else
-                <<~SQL.squish
-                  SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint)::text AS locked
-                SQL
-              end
-
-      binds = [
-        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
-      ]
-      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Lock', binds).first['locked']
+      self.class.advisory_lock_key(key, function: function)
     end
 
     # Releases an advisory lock on this record if it is locked by this database
@@ -228,13 +263,7 @@ module GoodJob
     # @param function [String, Symbol] Postgres Advisory Lock function name to use
     # @return [Boolean] whether the lock was released.
     def advisory_unlock(key: lockable_key, function: self.class.advisory_unlockable_function(advisory_lockable_function))
-      query = <<~SQL.squish
-        SELECT #{function}(('x'||substr(md5($1::text), 1, 16))::bit(64)::bigint) AS unlocked
-      SQL
-      binds = [
-        ActiveRecord::Relation::QueryAttribute.new('key', key, ActiveRecord::Type::String.new),
-      ]
-      self.class.connection.exec_query(pg_or_jdbc_query(query), 'GoodJob::Lockable Advisory Unlock', binds).first['unlocked']
+      self.class.advisory_unlock_key(key, function: function)
     end
 
     # Acquires an advisory lock on this record or raises
@@ -245,8 +274,7 @@ module GoodJob
     # @raise [RecordAlreadyAdvisoryLockedError]
     # @return [Boolean] +true+
     def advisory_lock!(key: lockable_key, function: advisory_lockable_function)
-      result = advisory_lock(key: key, function: function)
-      result || raise(RecordAlreadyAdvisoryLockedError)
+      self.class.advisory_lock_key(key, function: function) || raise(RecordAlreadyAdvisoryLockedError)
     end
 
     # Acquires an advisory lock on this record and safely releases it after the
@@ -266,9 +294,11 @@ module GoodJob
       raise ArgumentError, "Must provide a block" unless block_given?
 
       advisory_lock!(key: key, function: function)
-      yield
-    ensure
-      advisory_unlock(key: key, function: self.class.advisory_unlockable_function(function)) unless $ERROR_INFO.is_a? RecordAlreadyAdvisoryLockedError
+      begin
+        yield
+      ensure
+        advisory_unlock(key: key, function: self.class.advisory_unlockable_function(function))
+      end
     end
 
     # Tests whether this record has an advisory lock on it.

data/lib/good_job/log_subscriber.rb

@@ -206,7 +206,7 @@ module GoodJob
       good_job_tag = ["ActiveJob"].freeze
 
       self.class.loggers.inject(block) do |inner, each_logger|
-        if each_logger.respond_to?(:tagged)
+        if each_logger.respond_to?(:tagged) && each_logger.formatter
           tags_for_logger = if each_logger.formatter.current_tags.include?("ActiveJob")
                               good_job_tag + tags
                             else

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '2.9.2'
+  VERSION = '2.9.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 2.9.2
+  version: 2.9.6
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-19 00:00:00.000000000 Z
+date: 2022-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob