activejob 5.2.4.4 → 6.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 579058f1d7a36f41a5520a6b0407313b2239feba0a4650cb8d4de7c26944bb22
-  data.tar.gz: 6ff97713a73eeda521f8e2ac92b57e3307cc5fcb70192b52e30c4f41792b093d
+  metadata.gz: 35320cc54085adaeb2a5cdc283c0287992945e520ec24f2f6eb68690abe7f2c2
+  data.tar.gz: 26aa5b5976bb96e5571a66464b3d25d239a1197167b87a2673c33e67ded91013
 SHA512:
-  metadata.gz: 9cd80bb282fa4dc6078af56863c27484464fd4ef2d0656cf6886e861ed2e03415a7ff158c16313147fcef3782e434277b514ed6e138b378ed0677044250467be
-  data.tar.gz: f1235b757475555ed035b5f340a2fec95168209ce031ddfd65d81f020e661240636611f1f3f15453b9e097036c50612adc23dbd0aace1cec6f0468e716419a29
+  metadata.gz: 6cf40eaaa0a1b5003bdecaecd29a5deb1060998f405677fd1114599fcc95285d1173c2da125f3e5f3557e2773a71a77e49919e39b67a6cd8cdeeb01db37db48b
+  data.tar.gz: aca36b4e3c1348d096dcd9f8e033f18705f648d5f3d092e9a6882b9fd8c6a24bc322bd417d0792c9f7af5c8bebb277250e5c552fdb8b2fce946a0cfefb671888

data/CHANGELOG.md

@@ -1,100 +1,141 @@
-## Rails 5.2.4.4 (September 09, 2020) ##
+## Rails 6.1.1 (January 07, 2021) ##
 
-*   No changes.
+*   Make `retry_job` return the job that was created.
+
+    *Rafael Mendonça França*
+
+*   Include `ActiveSupport::Testing::Assertions` in `ActiveJob::TestHelpers`.
+
+    *Mikkel Malmberg*
 
 
-## Rails 5.2.4.3 (May 18, 2020) ##
+## Rails 6.1.0 (December 09, 2020) ##
 
-*   No changes.
+*   Recover nano precision when serializing `Time`, `TimeWithZone` and `DateTime` objects.
 
+    *Alan Tan*
 
-## Rails 5.2.4.1 (December 18, 2019) ##
+*   Deprecate `config.active_job.return_false_on_aborted_enqueue`.
 
-*   No changes.
+    *Rafael Mendonça França*
+
+*   Return `false` when enqueuing a job is aborted.
 
+    *Rafael Mendonça França*
 
-## Rails 5.2.4 (November 27, 2019) ##
+*   While using `perform_enqueued_jobs` test helper enqueued jobs must be stored for the later check with
+    `assert_enqueued_with`.
 
-*   No changes.
+    *Dmitry Polushkin*
 
+*   `ActiveJob::TestCase#perform_enqueued_jobs` without a block removes performed jobs from the queue.
 
-## Rails 5.2.3 (March 27, 2019) ##
+    That way the helper can be called multiple times and not perform a job invocation multiple times.
 
-*   No changes.
+    ```ruby
+    def test_jobs
+      HelloJob.perform_later("rafael")
+      perform_enqueued_jobs # only runs with "rafael"
+      HelloJob.perform_later("david")
+      perform_enqueued_jobs # only runs with "david"
+    end
+    ```
 
+    *Étienne Barrié*
 
-## Rails 5.2.2.1 (March 11, 2019) ##
+*   `ActiveJob::TestCase#perform_enqueued_jobs` will no longer perform retries:
 
-*   No changes.
+    When calling `perform_enqueued_jobs` without a block, the adapter will
+    now perform jobs that are **already** in the queue. Jobs that will end up in
+    the queue afterwards won't be performed.
 
+    This change only affects `perform_enqueued_jobs` when no block is given.
 
-## Rails 5.2.2 (December 04, 2018) ##
+    *Edouard Chin*
 
-*   Make sure `assert_enqueued_with()` & `assert_performed_with()` work reliably with hash arguments.
+*   Add queue name support to Que adapter.
 
-    *Sharang Dashputre*
+    *Brad Nauta*, *Wojciech Wnętrzak*
 
-*   Restore `ActionController::Parameters` support to `ActiveJob::Arguments.serialize`.
+*   Don't run `after_enqueue` and `after_perform` callbacks if the callback chain is halted.
 
-    *Bernie Chiu*
+        class MyJob < ApplicationJob
+          before_enqueue { throw(:abort) }
+          after_enqueue { # won't enter here anymore }
+        end
 
-*   Restore `HashWithIndifferentAccess` support to `ActiveJob::Arguments.deserialize`.
+    `after_enqueue` and `after_perform` callbacks will no longer run if the callback chain is halted.
+    This behaviour is a breaking change and won't take effect until Rails 6.2.
+    To enable this behaviour in your app right now, you can add in your app's configuration file
+    `config.active_job.skip_after_callbacks_if_terminated = true`.
 
-    *Gannon McGibbon*
+    *Edouard Chin*
 
-*   Include deserialized arguments in job instances returned from
-    `assert_enqueued_with` and `assert_performed_with`
+*   Fix enqueuing and performing incorrect logging message.
 
-    *Alan Wu*
+    Jobs will no longer always log "Enqueued MyJob" or "Performed MyJob" when they actually didn't get enqueued/performed.
 
-*   Increment execution count before deserialize arguments.
+    ```ruby
+      class MyJob < ApplicationJob
+        before_enqueue { throw(:abort) }
+      end
 
-    Currently, the execution count increments after deserializes arguments.
-    Therefore, if an error occurs with deserialize, it retries indefinitely.
+      MyJob.perform_later # Will no longer log "Enqueued MyJob" since job wasn't even enqueued through adapter.
+    ```
 
-    *Yuji Yaginuma*
+    A new message will be logged in case a job couldn't be enqueued, either because the callback chain was halted or
+    because an exception happened during enqueuing. (i.e. Redis is down when you try to enqueue your job)
 
+    *Edouard Chin*
 
-## Rails 5.2.1.1 (November 27, 2018) ##
+*   Add an option to disable logging of the job arguments when enqueuing and executing the job.
 
-*   Do not deserialize GlobalID objects that were not generated by Active Job.
+        class SensitiveJob < ApplicationJob
+          self.log_arguments = false
 
-    Trusting any GlobaID object when deserializing jobs can allow attackers to access
-    information that should not be accessible to them.
+          def perform(my_sensitive_argument)
+          end
+        end
 
-    Fix CVE-2018-16476.
+    When dealing with sensitive arguments as password and tokens it is now possible to configure the job
+    to not put the sensitive argument in the logs.
 
     *Rafael Mendonça França*
 
+*   Changes in `queue_name_prefix` of a job no longer affects all other jobs.
 
-## Rails 5.2.1 (August 07, 2018) ##
+    Fixes #37084.
 
-*   Pass the error instance as the second parameter of block executed by `discard_on`.
+    *Lucas Mansur*
 
-    Fixes #32853.
+*   Allow `Class` and `Module` instances to be serialized.
 
-    *Yuji Yaginuma*
+    *Kevin Deisz*
 
-## Rails 5.2.0 (April 09, 2018) ##
+*   Log potential matches in `assert_enqueued_with` and `assert_performed_with`.
 
-*   Allow block to be passed to `ActiveJob::Base.discard_on` to allow custom handling of discard jobs.
+    *Gareth du Plooy*
 
-    Example:
+*   Add `at` argument to the `perform_enqueued_jobs` test helper.
 
-        class RemoteServiceJob < ActiveJob::Base
-          discard_on(CustomAppException) do |job, exception|
-            ExceptionNotifier.caught(exception)
-          end
+    *John Crepezzi*, *Eileen Uchitelle*
 
-          def perform(*args)
-            # Might raise CustomAppException for something domain specific
-          end
-        end
+*   `assert_enqueued_with` and `assert_performed_with` can now test jobs with relative delay.
+
+    *Vlado Cingel*
+
+*   Add jitter to `ActiveJob::Exceptions.retry_on`.
+
+    `ActiveJob::Exceptions.retry_on` now uses a random amount of jitter in order to
+    prevent the [thundering herd effect](https://en.wikipedia.org/wiki/Thundering_herd_problem). Defaults to
+    15% (represented as 0.15) but overridable via the `:jitter` option when using `retry_on`.
+    Jitter is applied when an `Integer`, `ActiveSupport::Duration` or `:exponentially_longer`, is passed to the `wait` argument in `retry_on`.
 
-    *Aidan Haran*
+    ```ruby
+    retry_on(MyError, wait: :exponentially_longer, jitter: 0.30)
+    ```
 
-*   Support redis-rb 4.0.
+    *Anthony Ross*
 
-    *Jeremy Daer*
 
-Please check [5-1-stable](https://github.com/rails/rails/blob/5-1-stable/activejob/CHANGELOG.md) for previous changes.
+Please check [6-0-stable](https://github.com/rails/rails/blob/6-0-stable/activejob/CHANGELOG.md) for previous changes.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2018 David Heinemeier Hansson
+Copyright (c) 2014-2020 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,7 +1,7 @@
-# Active Job -- Make work happen later
+# Active Job – Make work happen later
 
 Active Job is a framework for declaring jobs and making them run on a variety
-of queueing backends. These jobs can be everything from regularly scheduled
+of queuing backends. These jobs can be everything from regularly scheduled
 clean-ups, to billing charges, to mailings. Anything that can be chopped up into
 small units of work and run in parallel, really.
 
@@ -17,12 +17,13 @@ about API differences between Delayed Job and Resque. Picking your queuing
 backend becomes more of an operational concern, then. And you'll be able to
 switch between them without having to rewrite your jobs.
 
+You can read more about Active Job in the [Active Job Basics](https://edgeguides.rubyonrails.org/active_job_basics.html) guide.
 
 ## Usage
 
-To learn how to use your preferred queueing backend see its adapter
+To learn how to use your preferred queuing backend see its adapter
 documentation at
-[ActiveJob::QueueAdapters](http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+[ActiveJob::QueueAdapters](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
 
 Declare a job like so:
 
@@ -39,7 +40,7 @@ end
 Enqueue a job like so:
 
 ```ruby
-MyJob.perform_later record  # Enqueue a job to be performed as soon as the queueing system is free.
+MyJob.perform_later record  # Enqueue a job to be performed as soon as the queuing system is free.
 ```
 
 ```ruby
@@ -82,15 +83,18 @@ This works with any class that mixes in GlobalID::Identification, which
 by default has been mixed into Active Record classes.
 
 
-## Supported queueing systems
+## Supported queuing systems
 
-Active Job has built-in adapters for multiple queueing backends (Sidekiq,
+Active Job has built-in adapters for multiple queuing backends (Sidekiq,
 Resque, Delayed Job and others). To get an up-to-date list of the adapters
-see the API Documentation for [ActiveJob::QueueAdapters](http://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
+see the API Documentation for [ActiveJob::QueueAdapters](https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters.html).
 
-## Auxiliary gems
+**Please note:** We are not accepting pull requests for new adapters. We
+encourage library authors to provide an ActiveJob adapter as part of
+their gem, or as a stand-alone gem. For discussion about this see the
+following PRs: [23311](https://github.com/rails/rails/issues/23311#issuecomment-176275718),
+[21406](https://github.com/rails/rails/pull/21406#issuecomment-138813484), and [#32285](https://github.com/rails/rails/pull/32285).
 
-* [activejob-stats](https://github.com/seuros/activejob-stats)
 
 ## Download and installation
 
@@ -102,7 +106,8 @@ The latest version of Active Job can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/5-2-stable/activejob
+* https://github.com/rails/rails/tree/master/activejob
+
 
 ## License
 
@@ -115,7 +120,7 @@ Active Job is released under the MIT license:
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
 Bug reports for the Ruby on Rails project can be filed here:
 
@@ -123,4 +128,4 @@ Bug reports for the Ruby on Rails project can be filed here:
 
 Feature requests should be discussed on the rails-core mailing list here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_job.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2014-2018 David Heinemeier Hansson
+# Copyright (c) 2014-2020 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -33,6 +33,7 @@ module ActiveJob
 
   autoload :Base
   autoload :QueueAdapters
+  autoload :Serializers
   autoload :ConfiguredJob
   autoload :TestCase
   autoload :TestHelper

data/lib/active_job/arguments.rb

@@ -14,29 +14,30 @@ module ActiveJob
   end
 
   # Raised when an unsupported argument type is set as a job argument. We
-  # currently support NilClass, Integer, Fixnum, Float, String, TrueClass, FalseClass,
-  # Bignum, BigDecimal, and objects that can be represented as GlobalIDs (ex: Active Record).
+  # currently support String, Integer, Float, NilClass, TrueClass, FalseClass,
+  # BigDecimal, Symbol, Date, Time, DateTime, ActiveSupport::TimeWithZone,
+  # ActiveSupport::Duration, Hash, ActiveSupport::HashWithIndifferentAccess,
+  # Array or GlobalID::Identification instances, although this can be extended
+  # by adding custom serializers.
   # Raised if you set the key for a Hash something else than a string or
   # a symbol. Also raised when trying to serialize an object which can't be
-  # identified with a Global ID - such as an unpersisted Active Record model.
+  # identified with a GlobalID - such as an unpersisted Active Record model.
   class SerializationError < ArgumentError; end
 
   module Arguments
     extend self
-    # :nodoc:
-    TYPE_WHITELIST = [ NilClass, String, Integer, Float, BigDecimal, TrueClass, FalseClass ]
-    TYPE_WHITELIST.push(Fixnum, Bignum) unless 1.class == Integer
-
-    # Serializes a set of arguments. Whitelisted types are returned
-    # as-is. Arrays/Hashes are serialized element by element.
-    # All other types are serialized using GlobalID.
+    # Serializes a set of arguments. Intrinsic types that can safely be
+    # serialized without mutation are returned as-is. Arrays/Hashes are
+    # serialized element by element. All other types are serialized using
+    # GlobalID.
     def serialize(arguments)
       arguments.map { |argument| serialize_argument(argument) }
     end
 
-    # Deserializes a set of arguments. Whitelisted types are returned
-    # as-is. Arrays/Hashes are deserialized element by element.
-    # All other types are deserialized using GlobalID.
+    # Deserializes a set of arguments. Intrinsic types that can safely be
+    # deserialized without mutation are returned as-is. Arrays/Hashes are
+    # deserialized element by element. All other types are deserialized using
+    # GlobalID.
     def deserialize(arguments)
       arguments.map { |argument| deserialize_argument(argument) }
     rescue
@@ -45,16 +46,59 @@ module ActiveJob
 
     private
       # :nodoc:
-      GLOBALID_KEY = "_aj_globalid".freeze
+      PERMITTED_TYPES = [ NilClass, String, Integer, Float, BigDecimal, TrueClass, FalseClass ]
+      # :nodoc:
+      GLOBALID_KEY = "_aj_globalid"
+      # :nodoc:
+      SYMBOL_KEYS_KEY = "_aj_symbol_keys"
+      # :nodoc:
+      RUBY2_KEYWORDS_KEY = "_aj_ruby2_keywords"
       # :nodoc:
-      SYMBOL_KEYS_KEY = "_aj_symbol_keys".freeze
+      WITH_INDIFFERENT_ACCESS_KEY = "_aj_hash_with_indifferent_access"
       # :nodoc:
-      WITH_INDIFFERENT_ACCESS_KEY = "_aj_hash_with_indifferent_access".freeze
-      private_constant :GLOBALID_KEY, :SYMBOL_KEYS_KEY, :WITH_INDIFFERENT_ACCESS_KEY
+      OBJECT_SERIALIZER_KEY = "_aj_serialized"
+
+      # :nodoc:
+      RESERVED_KEYS = [
+        GLOBALID_KEY, GLOBALID_KEY.to_sym,
+        SYMBOL_KEYS_KEY, SYMBOL_KEYS_KEY.to_sym,
+        RUBY2_KEYWORDS_KEY, RUBY2_KEYWORDS_KEY.to_sym,
+        OBJECT_SERIALIZER_KEY, OBJECT_SERIALIZER_KEY.to_sym,
+        WITH_INDIFFERENT_ACCESS_KEY, WITH_INDIFFERENT_ACCESS_KEY.to_sym,
+      ]
+      private_constant :PERMITTED_TYPES, :RESERVED_KEYS, :GLOBALID_KEY,
+        :SYMBOL_KEYS_KEY, :RUBY2_KEYWORDS_KEY, :WITH_INDIFFERENT_ACCESS_KEY
+
+      unless Hash.respond_to?(:ruby2_keywords_hash?) && Hash.respond_to?(:ruby2_keywords_hash)
+        using Module.new {
+          refine Hash do
+            class << Hash
+              if RUBY_VERSION >= "2.7"
+                def ruby2_keywords_hash?(hash)
+                  !new(*[hash]).default.equal?(hash)
+                end
+              else
+                def ruby2_keywords_hash?(hash)
+                  false
+                end
+              end
+
+              def ruby2_keywords_hash(hash)
+                _ruby2_keywords_hash(**hash)
+              end
+
+              private def _ruby2_keywords_hash(*args)
+                args.last
+              end
+              ruby2_keywords(:_ruby2_keywords_hash) if respond_to?(:ruby2_keywords, true)
+            end
+          end
+        }
+      end
 
       def serialize_argument(argument)
         case argument
-        when *TYPE_WHITELIST
+        when *PERMITTED_TYPES
           argument
         when GlobalID::Identification
           convert_to_global_id_hash(argument)
@@ -63,14 +107,19 @@ module ActiveJob
         when ActiveSupport::HashWithIndifferentAccess
           serialize_indifferent_hash(argument)
         when Hash
-          symbol_keys = argument.each_key.grep(Symbol).map(&:to_s)
+          symbol_keys = argument.each_key.grep(Symbol).map!(&:to_s)
+          aj_hash_key = if Hash.ruby2_keywords_hash?(argument)
+            RUBY2_KEYWORDS_KEY
+          else
+            SYMBOL_KEYS_KEY
+          end
           result = serialize_hash(argument)
-          result[SYMBOL_KEYS_KEY] = symbol_keys
+          result[aj_hash_key] = symbol_keys
           result
         when -> (arg) { arg.respond_to?(:permitted?) }
           serialize_indifferent_hash(argument.to_h)
         else
-          raise SerializationError.new("Unsupported argument type: #{argument.class.name}")
+          Serializers.serialize(argument)
         end
       end
 
@@ -78,13 +127,15 @@ module ActiveJob
         case argument
         when String
           argument
-        when *TYPE_WHITELIST
+        when *PERMITTED_TYPES
           argument
         when Array
           argument.map { |arg| deserialize_argument(arg) }
         when Hash
           if serialized_global_id?(argument)
             deserialize_global_id argument
+          elsif custom_serialized?(argument)
+            Serializers.deserialize(argument)
           else
             deserialize_hash(argument)
           end
@@ -101,6 +152,10 @@ module ActiveJob
         GlobalID::Locator.locate hash[GLOBALID_KEY]
       end
 
+      def custom_serialized?(hash)
+        hash.key?(OBJECT_SERIALIZER_KEY)
+      end
+
       def serialize_hash(argument)
         argument.each_with_object({}) do |(key, value), hash|
           hash[serialize_hash_key(key)] = serialize_argument(value)
@@ -113,18 +168,13 @@ module ActiveJob
           result = result.with_indifferent_access
         elsif symbol_keys = result.delete(SYMBOL_KEYS_KEY)
           result = transform_symbol_keys(result, symbol_keys)
+        elsif symbol_keys = result.delete(RUBY2_KEYWORDS_KEY)
+          result = transform_symbol_keys(result, symbol_keys)
+          result = Hash.ruby2_keywords_hash(result)
         end
         result
       end
 
-      # :nodoc:
-      RESERVED_KEYS = [
-        GLOBALID_KEY, GLOBALID_KEY.to_sym,
-        SYMBOL_KEYS_KEY, SYMBOL_KEYS_KEY.to_sym,
-        WITH_INDIFFERENT_ACCESS_KEY, WITH_INDIFFERENT_ACCESS_KEY.to_sym,
-      ]
-      private_constant :RESERVED_KEYS
-
       def serialize_hash_key(key)
         case key
         when *RESERVED_KEYS