activejob 7.0.8.4 → 7.1.0.beta1

data/lib/active_job/instrumentation.rb

@@ -1,6 +1,18 @@
 # frozen_string_literal: true
 
 module ActiveJob
+  class << self
+    private
+      def instrument_enqueue_all(queue_adapter, jobs)
+        payload = { adapter: queue_adapter, jobs: jobs }
+        ActiveSupport::Notifications.instrument("enqueue_all.active_job", payload) do
+          result = yield payload
+          payload[:enqueued_count] = result
+          result
+        end
+      end
+  end
+
   module Instrumentation # :nodoc:
     extend ActiveSupport::Concern
 
@@ -21,19 +33,15 @@ module ActiveJob
       end
 
       def instrument(operation, payload = {}, &block)
-        enhanced_block = ->(event_payload) do
-          value = block.call if block
-
-          if defined?(@_halted_callback_hook_called) && @_halted_callback_hook_called
-            event_payload[:aborted] = true
-            @_halted_callback_hook_called = nil
-          end
+        payload[:job] = self
+        payload[:adapter] = queue_adapter
 
+        ActiveSupport::Notifications.instrument("#{operation}.active_job", payload) do
+          value = block.call if block
+          payload[:aborted] = @_halted_callback_hook_called if defined?(@_halted_callback_hook_called)
+          @_halted_callback_hook_called = nil
           value
         end
-
-        ActiveSupport::Notifications.instrument \
-          "#{operation}.active_job", payload.merge(adapter: queue_adapter, job: self), &enhanced_block
       end
 
       def halted_callback_hook(*)

data/lib/active_job/log_subscriber.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/filters"
 require "active_support/log_subscriber"
 
 module ActiveJob
   class LogSubscriber < ActiveSupport::LogSubscriber # :nodoc:
+    class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
+
     def enqueue(event)
       job = event.payload[:job]
       ex = event.payload[:exception_object] || job.enqueue_error
@@ -23,6 +24,7 @@ module ActiveJob
         end
       end
     end
+    subscribe_log_level :enqueue, :info
 
     def enqueue_at(event)
       job = event.payload[:job]
@@ -38,10 +40,38 @@ module ActiveJob
         end
       else
         info do
-          "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)} at #{scheduled_at(event).to_default_s}" + args_info(job)
+          "Enqueued #{job.class.name} (Job ID: #{job.job_id}) to #{queue_name(event)} at #{scheduled_at(event)}" + args_info(job)
+        end
+      end
+    end
+    subscribe_log_level :enqueue_at, :info
+
+    def enqueue_all(event)
+      info do
+        jobs = event.payload[:jobs]
+        adapter = event.payload[:adapter]
+        enqueued_count = event.payload[:enqueued_count]
+
+        if enqueued_count == jobs.size
+          enqueued_jobs_message(adapter, jobs)
+        elsif jobs.any?(&:successfully_enqueued?)
+          enqueued_jobs = jobs.select(&:successfully_enqueued?)
+
+          failed_enqueue_count = jobs.size - enqueued_count
+          if failed_enqueue_count == 0
+            enqueued_jobs_message(adapter, enqueued_jobs)
+          else
+            "#{enqueued_jobs_message(adapter, enqueued_jobs)}. "\
+              "Failed enqueuing #{failed_enqueue_count} #{'job'.pluralize(failed_enqueue_count)}"
+          end
+        else
+          failed_enqueue_count = jobs.size - enqueued_count
+          "Failed enqueuing #{failed_enqueue_count} #{'job'.pluralize(failed_enqueue_count)} "\
+            "to #{ActiveJob.adapter_name(adapter)}"
         end
       end
     end
+    subscribe_log_level :enqueue_all, :info
 
     def perform_start(event)
       info do
@@ -49,6 +79,7 @@ module ActiveJob
         "Performing #{job.class.name} (Job ID: #{job.job_id}) from #{queue_name(event)} enqueued at #{job.enqueued_at}" + args_info(job)
       end
     end
+    subscribe_log_level :perform_start, :info
 
     def perform(event)
       job = event.payload[:job]
@@ -67,6 +98,7 @@ module ActiveJob
         end
       end
     end
+    subscribe_log_level :perform, :info
 
     def enqueue_retry(event)
       job = event.payload[:job]
@@ -75,34 +107,37 @@ module ActiveJob
 
       info do
         if ex
-          "Retrying #{job.class} in #{wait.to_i} seconds, due to a #{ex.class}."
+          "Retrying #{job.class} (Job ID: #{job.job_id}) after #{job.executions} attempts in #{wait.to_i} seconds, due to a #{ex.class} (#{ex.message})."
         else
-          "Retrying #{job.class} in #{wait.to_i} seconds."
+          "Retrying #{job.class} (Job ID: #{job.job_id}) after #{job.executions} attempts in #{wait.to_i} seconds."
         end
       end
     end
+    subscribe_log_level :enqueue_retry, :info
 
     def retry_stopped(event)
       job = event.payload[:job]
       ex = event.payload[:error]
 
       error do
-        "Stopped retrying #{job.class} due to a #{ex.class}, which reoccurred on #{job.executions} attempts."
+        "Stopped retrying #{job.class} (Job ID: #{job.job_id}) due to a #{ex.class} (#{ex.message}), which reoccurred on #{job.executions} attempts."
       end
     end
+    subscribe_log_level :enqueue_retry, :error
 
     def discard(event)
       job = event.payload[:job]
       ex = event.payload[:error]
 
       error do
-        "Discarded #{job.class} due to a #{ex.class}."
+        "Discarded #{job.class} (Job ID: #{job.job_id}) due to a #{ex.class} (#{ex.message})."
       end
     end
+    subscribe_log_level :discard, :error
 
     private
       def queue_name(event)
-        event.payload[:adapter].class.name.demodulize.remove("Adapter") + "(#{event.payload[:job].queue_name})"
+        ActiveJob.adapter_name(event.payload[:adapter]) + "(#{event.payload[:job].queue_name})"
       end
 
       def args_info(job)
@@ -134,6 +169,41 @@ module ActiveJob
       def logger
         ActiveJob::Base.logger
       end
+
+      def info(progname = nil, &block)
+        return unless super
+
+        if ActiveJob.verbose_enqueue_logs
+          log_enqueue_source
+        end
+      end
+
+      def error(progname = nil, &block)
+        return unless super
+
+        if ActiveJob.verbose_enqueue_logs
+          log_enqueue_source
+        end
+      end
+
+      def log_enqueue_source
+        source = extract_enqueue_source_location(caller)
+
+        if source
+          logger.info("↳ #{source}")
+        end
+      end
+
+      def extract_enqueue_source_location(locations)
+        backtrace_cleaner.clean(locations.lazy).first
+      end
+
+      def enqueued_jobs_message(adapter, enqueued_jobs)
+        enqueued_count = enqueued_jobs.size
+        job_classes_counts = enqueued_jobs.map(&:class).tally.sort_by { |_k, v| -v }
+        "Enqueued #{enqueued_count} #{'job'.pluralize(enqueued_count)} to #{ActiveJob.adapter_name(adapter)}"\
+          " (#{job_classes_counts.map { |klass, count| "#{count} #{klass}" }.join(', ')})"
+      end
   end
 end
 

data/lib/active_job/queue_adapter.rb

@@ -3,7 +3,18 @@
 require "active_support/core_ext/string/inflections"
 
 module ActiveJob
-  # The <tt>ActiveJob::QueueAdapter</tt> module is used to load the
+  class << self
+    def adapter_name(adapter) # :nodoc:
+      return adapter.queue_adapter_name if adapter.respond_to?(:queue_adapter_name)
+
+      adapter_class = adapter.is_a?(Module) ? adapter : adapter.class
+      "#{adapter_class.name.demodulize.delete_suffix('Adapter')}"
+    end
+  end
+
+  # = Active Job Queue adapter
+  #
+  # The +ActiveJob::QueueAdapter+ module is used to load the
   # correct adapter. The default queue adapter is the +:async+ queue.
   module QueueAdapter # :nodoc:
     extend ActiveSupport::Concern
@@ -41,7 +52,7 @@ module ActiveJob
           assign_adapter(name_or_adapter.to_s, queue_adapter)
         else
           if queue_adapter?(name_or_adapter)
-            adapter_name = "#{name_or_adapter.class.name.demodulize.remove('Adapter').underscore}"
+            adapter_name = ActiveJob.adapter_name(name_or_adapter).underscore
             assign_adapter(adapter_name, name_or_adapter)
           else
             raise ArgumentError

data/lib/active_job/queue_adapters/async_adapter.rb

@@ -7,7 +7,7 @@ require "concurrent/utility/processor_counter"
 
 module ActiveJob
   module QueueAdapters
-    # == Active Job Async adapter
+    # = Active Job Async adapter
     #
     # The Async adapter runs jobs with an in-process thread pool.
     #
@@ -95,7 +95,7 @@ module ActiveJob
 
         def enqueue_at(job, timestamp, queue_name:)
           delay = timestamp - Time.current.to_f
-          if delay > 0
+          if !immediate && delay > 0
             Concurrent::ScheduledTask.execute(delay, args: [job], executor: executor, &:perform)
           else
             enqueue(job, queue_name: queue_name)

data/lib/active_job/queue_adapters/backburner_adapter.rb

@@ -4,7 +4,7 @@ require "backburner"
 
 module ActiveJob
   module QueueAdapters
-    # == Backburner adapter for Active Job
+    # = Backburner adapter for Active Job
     #
     # Backburner is a beanstalkd-powered job queue that can handle a very
     # high volume of jobs. You create background jobs and place them on
@@ -16,12 +16,16 @@ module ActiveJob
     #   Rails.application.config.active_job.queue_adapter = :backburner
     class BackburnerAdapter
       def enqueue(job) # :nodoc:
-        Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority)
+        response = Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority)
+        job.provider_job_id = response[:id] if response.is_a?(Hash)
+        response
       end
 
       def enqueue_at(job, timestamp) # :nodoc:
         delay = timestamp - Time.current.to_f
-        Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority, delay: delay)
+        response = Backburner::Worker.enqueue(JobWrapper, [job.serialize], queue: job.queue_name, pri: job.priority, delay: delay)
+        job.provider_job_id = response[:id] if response.is_a?(Hash)
+        response
       end
 
       class JobWrapper # :nodoc:

data/lib/active_job/queue_adapters/delayed_job_adapter.rb

@@ -5,7 +5,7 @@ require "active_support/core_ext/string/inflections"
 
 module ActiveJob
   module QueueAdapters
-    # == Delayed Job adapter for Active Job
+    # = Delayed Job adapter for Active Job
     #
     # Delayed::Job (or DJ) encapsulates the common pattern of asynchronously
     # executing longer tasks in the background. Although DJ can have many

data/lib/active_job/queue_adapters/inline_adapter.rb

@@ -2,7 +2,7 @@
 
 module ActiveJob
   module QueueAdapters
-    # == Active Job Inline adapter
+    # = Active Job Inline adapter
     #
     # When enqueuing jobs with the Inline adapter the job will be executed
     # immediately.

data/lib/active_job/queue_adapters/queue_classic_adapter.rb

@@ -4,7 +4,7 @@ require "queue_classic"
 
 module ActiveJob
   module QueueAdapters
-    # == queue_classic adapter for Active Job
+    # = queue_classic adapter for Active Job
     #
     # queue_classic provides a simple interface to a PostgreSQL-backed message
     # queue. queue_classic specializes in concurrent locking and minimizing
@@ -37,10 +37,10 @@ module ActiveJob
         qc_job
       end
 
-      # Builds a <tt>QC::Queue</tt> object to schedule jobs on.
+      # Builds a +QC::Queue+ object to schedule jobs on.
       #
-      # If you have a custom <tt>QC::Queue</tt> subclass you'll need to subclass
-      # <tt>ActiveJob::QueueAdapters::QueueClassicAdapter</tt> and override the
+      # If you have a custom +QC::Queue+ subclass you'll need to subclass
+      # +ActiveJob::QueueAdapters::QueueClassicAdapter+ and override the
       # <tt>build_queue</tt> method.
       def build_queue(queue_name)
         QC::Queue.new(queue_name)

data/lib/active_job/queue_adapters/resque_adapter.rb

@@ -16,7 +16,7 @@ end
 
 module ActiveJob
   module QueueAdapters
-    # == Resque adapter for Active Job
+    # = Resque adapter for Active Job
     #
     # Resque (pronounced like "rescue") is a Redis-backed library for creating
     # background jobs, placing those jobs on multiple queues, and processing

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
+gem "sidekiq", ">= 4.1.0"
 require "sidekiq"
 
 module ActiveJob
   module QueueAdapters
-    # == Sidekiq adapter for Active Job
+    # = Sidekiq adapter for Active Job
     #
     # Simple, efficient background processing for Ruby. Sidekiq uses threads to
     # handle many jobs at the same time in the same process. It does not
-    # require Rails but will integrate tightly with it to make background
+    # require \Rails but will integrate tightly with it to make background
     # processing dead simple.
     #
     # Read more about Sidekiq {here}[http://sidekiq.org].
@@ -18,21 +19,48 @@ module ActiveJob
     #   Rails.application.config.active_job.queue_adapter = :sidekiq
     class SidekiqAdapter
       def enqueue(job) # :nodoc:
-        # Sidekiq::Client does not support symbols as keys
-        job.provider_job_id = Sidekiq::Client.push \
-          "class"   => JobWrapper,
-          "wrapped" => job.class,
-          "queue"   => job.queue_name,
-          "args"    => [ job.serialize ]
+        job.provider_job_id = JobWrapper.set(
+          wrapped: job.class,
+          queue: job.queue_name
+        ).perform_async(job.serialize)
       end
 
       def enqueue_at(job, timestamp) # :nodoc:
-        job.provider_job_id = Sidekiq::Client.push \
-          "class"   => JobWrapper,
-          "wrapped" => job.class,
-          "queue"   => job.queue_name,
-          "args"    => [ job.serialize ],
-          "at"      => timestamp
+        job.provider_job_id = JobWrapper.set(
+          wrapped: job.class,
+          queue: job.queue_name,
+        ).perform_at(timestamp, job.serialize)
+      end
+
+      def enqueue_all(jobs) # :nodoc:
+        enqueued_count = 0
+        jobs.group_by(&:class).each do |job_class, same_class_jobs|
+          same_class_jobs.group_by(&:queue_name).each do |queue, same_class_and_queue_jobs|
+            immediate_jobs, scheduled_jobs = same_class_and_queue_jobs.partition { |job| job.scheduled_at.nil? }
+
+            if immediate_jobs.any?
+              jids = Sidekiq::Client.push_bulk(
+                "class" => JobWrapper,
+                "wrapped" => job_class,
+                "queue" => queue,
+                "args" => immediate_jobs.map { |job| [job.serialize] },
+              )
+              enqueued_count += jids.compact.size
+            end
+
+            if scheduled_jobs.any?
+              jids = Sidekiq::Client.push_bulk(
+                "class" => JobWrapper,
+                "wrapped" => job_class,
+                "queue" => queue,
+                "args" => scheduled_jobs.map { |job| [job.serialize] },
+                "at" => scheduled_jobs.map { |job| job.scheduled_at }
+              )
+              enqueued_count += jids.compact.size
+            end
+          end
+        end
+        enqueued_count
       end
 
       class JobWrapper # :nodoc:

data/lib/active_job/queue_adapters/sneakers_adapter.rb

@@ -5,7 +5,7 @@ require "monitor"
 
 module ActiveJob
   module QueueAdapters
-    # == Sneakers adapter for Active Job
+    # = Sneakers adapter for Active Job
     #
     # A high-performance RabbitMQ background processing framework for Ruby.
     # Sneakers is being used in production for both I/O and CPU intensive

data/lib/active_job/queue_adapters/sucker_punch_adapter.rb

@@ -4,13 +4,13 @@ require "sucker_punch"
 
 module ActiveJob
   module QueueAdapters
-    # == Sucker Punch adapter for Active Job
+    # = Sucker Punch adapter for Active Job
     #
     # Sucker Punch is a single-process Ruby asynchronous processing library.
     # This reduces the cost of hosting on a service like Heroku along
     # with the memory footprint of having to maintain additional jobs if
     # hosting on a dedicated server. All queues can run within a
-    # single application (e.g. Rails, Sinatra, etc.) process.
+    # single application (e.g. \Rails, Sinatra, etc.) process.
     #
     # Read more about Sucker Punch {here}[https://github.com/brandonhilkert/sucker_punch].
     #

data/lib/active_job/queue_adapters/test_adapter.rb

@@ -2,11 +2,11 @@
 
 module ActiveJob
   module QueueAdapters
-    # == Test adapter for Active Job
+    # = Test adapter for Active Job
     #
     # The test adapter should be used only in testing. Along with
     # ActiveJob::TestCase and ActiveJob::TestHelper
-    # it makes a great tool to test your Rails application.
+    # it makes a great tool to test your \Rails application.
     #
     # To use the test adapter set +queue_adapter+ config to +:test+.
     #

data/lib/active_job/queue_adapters.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveJob
-  # == Active Job adapters
+  # = Active Job adapters
   #
   # Active Job has adapters for the following queuing backends:
   #
@@ -13,10 +13,14 @@ module ActiveJob
   # * {Sidekiq}[https://sidekiq.org]
   # * {Sneakers}[https://github.com/jondot/sneakers]
   # * {Sucker Punch}[https://github.com/brandonhilkert/sucker_punch]
-  # * {Active Job Async Job}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
-  # * {Active Job Inline}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]
   # * Please Note: We are not accepting pull requests for new adapters. See the {README}[link:files/activejob/README_md.html] for more details.
   #
+  # For testing and development Active Job has three built-in adapters:
+  #
+  # * {Active Job Async}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/AsyncAdapter.html]
+  # * {Active Job Inline}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/InlineAdapter.html]
+  # * {Active Job Test}[https://api.rubyonrails.org/classes/ActiveJob/QueueAdapters/TestAdapter.html]
+  #
   # === Backends Features
   #
   #   |                   | Async | Queues | Delayed    | Priorities | Timeout | Retries |
@@ -31,6 +35,7 @@ module ActiveJob
   #   | Sucker Punch      | Yes   | Yes    | Yes        | No         | No      | No      |
   #   | Active Job Async  | Yes   | Yes    | Yes        | No         | No      | No      |
   #   | Active Job Inline | No    | Yes    | N/A        | N/A        | N/A     | N/A     |
+  #   | Active Job Test   | No    | Yes    | N/A        | N/A        | N/A     | N/A     |
   #
   # ==== Async
   #
@@ -106,10 +111,6 @@ module ActiveJob
   # N/A: The adapter does not run in a separate process, and therefore doesn't
   # support retries.
   #
-  # === Async and Inline Queue Adapters
-  #
-  # Active Job has two built-in queue adapters intended for development and
-  # testing: +:async+ and +:inline+.
   module QueueAdapters
     extend ActiveSupport::Autoload
 

data/lib/active_job/queue_priority.rb

@@ -18,7 +18,24 @@ module ActiveJob
       #     end
       #   end
       #
-      # Specify either an argument or a block.
+      # Can be given a block that will evaluate in the context of the job
+      # so that a dynamic priority can be applied:
+      #
+      #   class PublishToFeedJob < ApplicationJob
+      #     queue_with_priority do
+      #       post = self.arguments.first
+      #
+      #       if post.paid?
+      #         10
+      #       else
+      #         50
+      #       end
+      #     end
+      #
+      #     def perform(post)
+      #       post.to_feed!
+      #     end
+      #   end
       def queue_with_priority(priority = nil, &block)
         if block_given?
           self.priority = block

data/lib/active_job/railtie.rb

@@ -10,6 +10,10 @@ module ActiveJob
     config.active_job.custom_serializers = []
     config.active_job.log_query_tags_around_perform = true
 
+    initializer "active_job.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_job] = ActiveJob.deprecator
+    end
+
     initializer "active_job.logger" do
       ActiveSupport.on_load(:active_job) { self.logger = ::Rails.logger }
     end
@@ -25,6 +29,15 @@ module ActiveJob
       options = app.config.active_job
       options.queue_adapter ||= :async
 
+      config.after_initialize do
+        options.each do |k, v|
+          k = "#{k}="
+          if ActiveJob.respond_to?(k)
+            ActiveJob.send(k, v)
+          end
+        end
+      end
+
       ActiveSupport.on_load(:active_job) do
         # Configs used in other initializers
         options = options.except(
@@ -32,19 +45,19 @@ module ActiveJob
           :custom_serializers
         )
 
-        options.each do  |k, v|
+        options.each do |k, v|
           k = "#{k}="
-          send(k, v) if respond_to? k
+          if ActiveJob.respond_to?(k)
+            ActiveJob.send(k, v)
+          elsif respond_to? k
+            send(k, v)
+          end
         end
       end
 
       ActiveSupport.on_load(:action_dispatch_integration_test) do
         include ActiveJob::TestHelper
       end
-
-      ActiveSupport.on_load(:active_record) do
-        self.destroy_association_async_job = ActiveRecord::DestroyAssociationAsyncJob
-      end
     end
 
     initializer "active_job.set_reloader_hook" do |app|
@@ -70,5 +83,11 @@ module ActiveJob
         end
       end
     end
+
+    initializer "active_job.backtrace_cleaner" do
+      ActiveSupport.on_load(:active_job) do
+        LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner
+      end
+    end
   end
 end

data/lib/active_job/serializers/big_decimal_serializer.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module ActiveJob
+  module Serializers
+    class BigDecimalSerializer < ObjectSerializer # :nodoc:
+      def serialize(big_decimal)
+        super("value" => big_decimal.to_s)
+      end
+
+      def deserialize(hash)
+        BigDecimal(hash["value"])
+      end
+
+      private
+        def klass
+          BigDecimal
+        end
+    end
+  end
+end

data/lib/active_job/serializers/duration_serializer.rb

@@ -4,14 +4,16 @@ module ActiveJob
   module Serializers
     class DurationSerializer < ObjectSerializer # :nodoc:
       def serialize(duration)
+        # Ideally duration.parts would be wrapped in an array before passing to Arguments.serialize,
+        # but we continue passing the bare hash for backwards compatibility:
         super("value" => duration.value, "parts" => Arguments.serialize(duration.parts))
       end
 
       def deserialize(hash)
         value = hash["value"]
         parts = Arguments.deserialize(hash["parts"])
-
-        klass.new(value, parts)
+        # `parts` is originally a hash, but will have been flattened to an array by Arguments.serialize
+        klass.new(value, parts.to_h)
       end
 
       private

data/lib/active_job/serializers.rb

@@ -3,7 +3,9 @@
 require "set"
 
 module ActiveJob
-  # The <tt>ActiveJob::Serializers</tt> module is used to store a list of known serializers
+  # = Active Job \Serializers
+  #
+  # The +ActiveJob::Serializers+ module is used to store a list of known serializers
   # and to add new ones. It also has helpers to serialize/deserialize objects.
   module Serializers # :nodoc:
     extend ActiveSupport::Autoload
@@ -18,6 +20,7 @@ module ActiveJob
     autoload :TimeSerializer
     autoload :ModuleSerializer
     autoload :RangeSerializer
+    autoload :BigDecimalSerializer
 
     mattr_accessor :_additional_serializers
     self._additional_serializers = Set.new
@@ -25,7 +28,7 @@ module ActiveJob
     class << self
       # Returns serialized representative of the passed object.
       # Will look up through all known serializers.
-      # Raises <tt>ActiveJob::SerializationError</tt> if it can't find a proper serializer.
+      # Raises ActiveJob::SerializationError if it can't find a proper serializer.
       def serialize(argument)
         serializer = serializers.detect { |s| s.serialize?(argument) }
         raise SerializationError.new("Unsupported argument type: #{argument.class.name}") unless serializer
@@ -63,6 +66,7 @@ module ActiveJob
       TimeWithZoneSerializer,
       TimeSerializer,
       ModuleSerializer,
-      RangeSerializer
+      RangeSerializer,
+      BigDecimalSerializer
   end
 end