Merge pull request #55583 from byroot/opt-aj-serialize-index

Optimize Active Job argument serialization by ~5x

Author: byroot

activejob/CHANGELOG.md

@@ -1,3 +1,10 @@
+*   `ActiveJob::Serializers::ObjectSerializers#klass` method is now public.
+
+    Custom Active Job serializers must have a public `#klass` method too.
+    The returned class will be index allowing for faster serialization.
+
+    *Jean Boussier*
+
 *   Allow jobs to the interrupted and resumed with Continuations
 
     A job can use Continuations by including the `ActiveJob::Continuable`

activejob/lib/active_job/arguments.rb

@@ -31,8 +31,44 @@ module Arguments
     # 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) }
+    def serialize(argument)
+      case argument
+      when nil, true, false, Integer, Float # Types that can hardly be subclassed
+        argument
+      when String
+        if argument.class == String
+          argument
+        else
+          begin
+            Serializers.serialize(argument)
+          rescue SerializationError
+            argument
+          end
+        end
+      when Symbol
+        { OBJECT_SERIALIZER_KEY => "ActiveJob::Serializers::SymbolSerializer", "value" => argument.name }
+      when GlobalID::Identification
+        convert_to_global_id_hash(argument)
+      when Array
+        argument.map { |arg| serialize(arg) }
+      when ActiveSupport::HashWithIndifferentAccess
+        serialize_indifferent_hash(argument)
+      when Hash
+        symbol_keys = argument.keys
+        symbol_keys.select! { |k| k.is_a?(Symbol) }
+        symbol_keys.map!(&:name)
+
+        aj_hash_key = if Hash.ruby2_keywords_hash?(argument)
+          RUBY2_KEYWORDS_KEY
+        else
+          SYMBOL_KEYS_KEY
+        end
+        result = serialize_hash(argument)
+        result[aj_hash_key] = symbol_keys
+        result
+      else
+        Serializers.serialize(argument)
+      end
     end
 
     # Deserializes a set of arguments. Intrinsic types that can safely be
@@ -68,48 +104,6 @@ def deserialize(arguments)
       private_constant :RESERVED_KEYS, :GLOBALID_KEY,
         :SYMBOL_KEYS_KEY, :RUBY2_KEYWORDS_KEY, :WITH_INDIFFERENT_ACCESS_KEY
 
-      def serialize_argument(argument)
-        case argument
-        when nil, true, false, Integer, Float # Types that can hardly be subclassed
-          argument
-        when String
-          if argument.class == String
-            argument
-          else
-            begin
-              Serializers.serialize(argument)
-            rescue SerializationError
-              argument
-            end
-          end
-        when GlobalID::Identification
-          convert_to_global_id_hash(argument)
-        when Array
-          argument.map { |arg| serialize_argument(arg) }
-        when ActiveSupport::HashWithIndifferentAccess
-          serialize_indifferent_hash(argument)
-        when Hash
-          symbol_keys = argument.keys
-          symbol_keys.select! { |k| k.is_a?(Symbol) }
-          symbol_keys.map!(&:name)
-
-          aj_hash_key = if Hash.ruby2_keywords_hash?(argument)
-            RUBY2_KEYWORDS_KEY
-          else
-            SYMBOL_KEYS_KEY
-          end
-          result = serialize_hash(argument)
-          result[aj_hash_key] = symbol_keys
-          result
-        else
-          if argument.respond_to?(:permitted?) && argument.respond_to?(:to_h)
-            serialize_indifferent_hash(argument.to_h)
-          else
-            Serializers.serialize(argument)
-          end
-        end
-      end
-
       def deserialize_argument(argument)
         case argument
         when nil, true, false, String, Integer, Float
@@ -143,7 +137,7 @@ def custom_serialized?(hash)
 
       def serialize_hash(argument)
         argument.each_with_object({}) do |(key, value), hash|
-          hash[serialize_hash_key(key)] = serialize_argument(value)
+          hash[serialize_hash_key(key)] = serialize(value)
         end
       end
 

activejob/lib/active_job/railtie.rb

@@ -52,6 +52,14 @@ class Railtie < Rails::Railtie # :nodoc:
       end
     end
 
+    initializer "active_job.action_controller_parameters" do |app|
+      ActiveSupport.on_load(:active_job) do
+        ActiveSupport.on_load(:action_controller) do
+          ActiveJob::Serializers.add_serializers ActiveJob::Serializers::ActionControllerParametersSerializer
+        end
+      end
+    end
+
     initializer "active_job.set_configs" do |app|
       options = app.config.active_job
       options.queue_adapter ||= (Rails.env.test? ? :test : :async)

activejob/lib/active_job/serializers.rb

@@ -19,16 +19,17 @@ module Serializers # :nodoc:
     autoload :ModuleSerializer
     autoload :RangeSerializer
     autoload :BigDecimalSerializer
+    autoload :ActionControllerParametersSerializer
 
-    mattr_accessor :_additional_serializers
-    self._additional_serializers = Set.new
+    @serializers = Set.new
+    @serializers_index = {}
 
     class << self
       # Returns serialized representative of the passed object.
       # Will look up through all known serializers.
       # Raises ActiveJob::SerializationError if it can't find a proper serializer.
       def serialize(argument)
-        serializer = serializers.detect { |s| s.serialize?(argument) }
+        serializer = @serializers_index[argument.class] || serializers.find { |s| s.serialize?(argument) }
         raise SerializationError.new("Unsupported argument type: #{argument.class.name}") unless serializer
         serializer.serialize(argument)
       end
@@ -47,24 +48,53 @@ def deserialize(argument)
       end
 
       # Returns list of known serializers.
-      def serializers
-        self._additional_serializers
+      attr_reader :serializers
+
+      def serializers=(serializers)
+        @serializers = serializers
+        index_serializers
       end
 
       # Adds new serializers to a list of known serializers.
       def add_serializers(*new_serializers)
-        self._additional_serializers += new_serializers.flatten
+        new_serializers = new_serializers.flatten
+        new_serializers.map! do |s|
+          if s.is_a?(Class) && s < ObjectSerializer
+            s.instance
+          else
+            s
+          end
+        end
+
+        @serializers += new_serializers
+        index_serializers
+        @serializers
       end
+
+      private
+        def index_serializers
+          @serializers_index.clear
+          serializers.each do |s|
+            if s.respond_to?(:klass)
+              @serializers_index[s.klass] = s
+            elsif s.respond_to?(:klass, true)
+              ActiveJob.deprecator.warn(<<~MSG.squish)
+                #{s.klass.name}#klass method should be public.
+              MSG
+              @serializers_index[s.send(:klass)] = s
+            end
+          end
+        end
     end
 
-    add_serializers SymbolSerializer,
-      DurationSerializer,
-      DateTimeSerializer,
-      DateSerializer,
-      TimeWithZoneSerializer,
-      TimeSerializer,
-      ModuleSerializer,
-      RangeSerializer,
-      BigDecimalSerializer
+    add_serializers SymbolSerializer.instance,
+      DurationSerializer.instance,
+      DateTimeSerializer.instance,
+      DateSerializer.instance,
+      TimeWithZoneSerializer.instance,
+      TimeSerializer.instance,
+      ModuleSerializer.instance,
+      RangeSerializer.instance,
+      BigDecimalSerializer.instance
   end
 end

activejob/lib/active_job/serializers/action_controller_parameters_serializer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Serializers
+    class ActionControllerParametersSerializer < ObjectSerializer
+      def serialize(argument)
+        Arguments.serialize(argument.to_h.with_indifferent_access)
+      end
+
+      def deserialize(hash)
+        raise NotImplementedError # Serialized as a HashWithIndifferentAccess
+      end
+
+      def serialize?(argument)
+        argument.respond_to?(:permitted?) && argument.respond_to?(:to_h)
+      end
+
+      def klass
+        if defined?(ActionController::Parameters)
+          ActionController::Parameters
+        end
+      end
+    end
+  end
+end

activejob/lib/active_job/serializers/big_decimal_serializer.rb

@@ -13,10 +13,9 @@ def deserialize(hash)
         BigDecimal(hash["value"])
       end
 
-      private
-        def klass
-          BigDecimal
-        end
+      def klass
+        BigDecimal
+      end
     end
   end
 end

activejob/lib/active_job/serializers/date_serializer.rb

@@ -11,10 +11,9 @@ def deserialize(hash)
         Date.iso8601(hash["value"])
       end
 
-      private
-        def klass
-          Date
-        end
+      def klass
+        Date
+      end
     end
   end
 end

activejob/lib/active_job/serializers/date_time_serializer.rb

@@ -7,10 +7,9 @@ def deserialize(hash)
         DateTime.iso8601(hash["value"])
       end
 
-      private
-        def klass
-          DateTime
-        end
+      def klass
+        DateTime
+      end
     end
   end
 end

activejob/lib/active_job/serializers/duration_serializer.rb

@@ -6,20 +6,19 @@ 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))
+        super("value" => duration.value, "parts" => Arguments.serialize(duration.parts.to_a))
       end
 
       def deserialize(hash)
         value = hash["value"]
-        parts = Arguments.deserialize(hash["parts"])
+        parts = Arguments.deserialize(hash["parts"].to_h)
         # `parts` is originally a hash, but will have been flattened to an array by Arguments.serialize
         klass.new(value, parts.to_h)
       end
 
-      private
-        def klass
-          ActiveSupport::Duration
-        end
+      def klass
+        ActiveSupport::Duration
+      end
     end
   end
 end

activejob/lib/active_job/serializers/module_serializer.rb

@@ -12,10 +12,9 @@ def deserialize(hash)
         hash["value"].constantize
       end
 
-      private
-        def klass
-          Module
-        end
+      def klass
+        Module
+      end
     end
   end
 end