Thread-safe formatter caching, added simple benchmark

Author: DavidMikeSimon

Rakefile

@@ -9,3 +9,10 @@ Rake::TestTask.new do |t|
 end
 
 task default: :test
+
+desc 'Run benchmarks'
+namespace :test do
+  Rake::TestTask.new(:benchmark) do |t|
+    t.pattern = 'test/benchmark/*_benchmark.rb'
+  end
+end

jsonapi-resources.gemspec

@@ -25,5 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest-spec-rails'
   spec.add_development_dependency 'simplecov'
   spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'concurrent-ruby-ext'
   spec.add_dependency 'rails', '>= 4.0'
+  spec.add_dependency 'concurrent-ruby'
 end

lib/jsonapi/acts_as_resource_controller.rb

@@ -113,7 +113,7 @@ def serialization_options
     #     JSONAPI.configuration.route = :camelized_route
     #
     # Override if you want to set a per controller key format.
-    # Must return a class derived from KeyFormatter.
+    # Must return an instance of a class derived from KeyFormatter.
     def key_formatter
       JSONAPI.configuration.key_formatter
     end

lib/jsonapi/configuration.rb

@@ -1,14 +1,13 @@
 require 'jsonapi/formatter'
 require 'jsonapi/operations_processor'
 require 'jsonapi/active_record_operations_processor'
+require 'concurrent'
 
 module JSONAPI
   class Configuration
     attr_reader :json_key_format,
                 :resource_key_type,
-                :key_formatter,
                 :route_format,
-                :route_formatter,
                 :raise_if_parameters_not_allowed,
                 :operations_processor,
                 :allow_include,
@@ -23,7 +22,8 @@ class Configuration
                 :top_level_meta_record_count_key,
                 :exception_class_whitelist,
                 :always_include_to_one_linkage_data,
-                :always_include_to_many_linkage_data
+                :always_include_to_many_linkage_data,
+                :cache_formatters
 
     def initialize
       #:underscored_key, :camelized_key, :dasherized_key, or custom
@@ -74,20 +74,69 @@ def initialize
       # NOTE: always_include_to_many_linkage_data is not currently implemented
       self.always_include_to_one_linkage_data = false
       self.always_include_to_many_linkage_data = false
+
+      # Formatter Caching
+      # Set to false to disable caching of string operations on keys and links.
+      self.cache_formatters = true
+    end
+
+    def cache_formatters=(bool)
+      @cache_formatters = bool
+      if bool
+        @key_formatter_tlv = Concurrent::ThreadLocalVar.new
+        @route_formatter_tlv = Concurrent::ThreadLocalVar.new
+      else
+        @key_formatter_tlv = nil
+        @route_formatter_tlv = nil
+      end
     end
 
     def json_key_format=(format)
       @json_key_format = format
-      @key_formatter = JSONAPI::Formatter.formatter_for(format)
+      if @cache_formatters
+        @key_formatter_tlv = Concurrent::ThreadLocalVar.new
+      end
+    end
+
+    def route_format=(format)
+      @route_format = format
+      if @cache_formatters
+        @route_formatter_tlv = Concurrent::ThreadLocalVar.new
+      end
+    end
+
+    def key_formatter
+      if self.cache_formatters
+        formatter = @key_formatter_tlv.value
+        return formatter if formatter
+      end
+
+      formatter = JSONAPI::Formatter.formatter_for(self.json_key_format)
+
+      if self.cache_formatters
+        formatter = @key_formatter_tlv.value = formatter.cached
+      end
+
+      return formatter
     end
 
     def resource_key_type=(key_type)
       @resource_key_type = key_type
     end
 
-    def route_format=(format)
-      @route_format = format
-      @route_formatter = JSONAPI::Formatter.formatter_for(format)
+    def route_formatter
+      if self.cache_formatters
+        formatter = @route_formatter_tlv.value
+        return formatter if formatter
+      end
+
+      formatter = JSONAPI::Formatter.formatter_for(self.route_format)
+
+      if self.cache_formatters
+        formatter = @route_formatter_tlv.value = formatter.cached
+      end
+
+      return formatter
     end
 
     def operations_processor=(operations_processor)

lib/jsonapi/formatter.rb

@@ -9,12 +9,12 @@ def unformat(arg)
         arg
       end
 
-      @@format_to_formatter_cache = JSONAPI::NaiveCache.new do |format|
-        "#{format.to_s.camelize}Formatter".safe_constantize
+      def cached
+        return FormatterWrapperCache.new(self)
       end
 
       def formatter_for(format)
-        @@format_to_formatter_cache.calc(format)
+        "#{format.to_s.camelize}Formatter".safe_constantize
       end
     end
   end
@@ -53,13 +53,32 @@ def unformat(value)
         super(value)
       end
 
-      @@value_type_to_formatter_cache = JSONAPI::NaiveCache.new do |type|
+      def value_formatter_for(type)
         "#{type.to_s.camelize}ValueFormatter".safe_constantize
       end
+    end
+  end
 
-      def value_formatter_for(type)
-        @@value_type_to_formatter_cache.calc(type)
-      end
+  # Warning: Not thread-safe. Wrap in ThreadLocalVar as needed.
+  class FormatterWrapperCache
+    attr_reader :formatter_klass
+
+    def initialize(formatter_klass)
+      @formatter_klass = formatter_klass
+      @format_cache = NaiveCache.new{|arg| formatter_klass.format(arg) }
+      @unformat_cache = NaiveCache.new{|arg| formatter_klass.unformat(arg) }
+    end
+
+    def format(arg)
+      @format_cache.get(arg)
+    end
+
+    def unformat(arg)
+      @unformat_cache.get(arg)
+    end
+
+    def cached
+      self
     end
   end
 end
@@ -69,38 +88,24 @@ class UnderscoredKeyFormatter < JSONAPI::KeyFormatter
 
 class CamelizedKeyFormatter < JSONAPI::KeyFormatter
   class << self
-    @@format_cache = JSONAPI::NaiveCache.new do |key|
-      key.to_s.camelize(:lower)
-    end
-    @@unformat_cache = JSONAPI::NaiveCache.new do |formatted_key|
-      formatted_key.to_s.underscore
-    end
-
     def format(key)
-      @@format_cache.calc(key)
+      super.camelize(:lower)
     end
 
     def unformat(formatted_key)
-      @@unformat_cache.calc(formatted_key)
+      formatted_key.to_s.underscore
     end
   end
 end
 
 class DasherizedKeyFormatter < JSONAPI::KeyFormatter
   class << self
-    @@format_cache = JSONAPI::NaiveCache.new do |key|
-      key.to_s.underscore.dasherize
-    end
-    @@unformat_cache = JSONAPI::NaiveCache.new do |formatted_key|
-      formatted_key.to_s.underscore
-    end
-
     def format(key)
-      @@format_cache.calc(key)
+      super.underscore.dasherize
     end
 
     def unformat(formatted_key)
-      @@unformat_cache.calc(formatted_key)
+      formatted_key.to_s.underscore
     end
   end
 end
@@ -127,38 +132,24 @@ class UnderscoredRouteFormatter < JSONAPI::RouteFormatter
 
 class CamelizedRouteFormatter < JSONAPI::RouteFormatter
   class << self
-    @@format_cache = JSONAPI::NaiveCache.new do |route|
-      route.to_s.camelize(:lower)
-    end
-    @@unformat_cache = JSONAPI::NaiveCache.new do |formatted_route|
-      formatted_route.to_s.underscore
-    end
-
     def format(route)
-      @@format_cache.calc(route)
+      super.camelize(:lower)
     end
 
     def unformat(formatted_route)
-      @@unformat_cache.calc(formatted_route)
+      formatted_route.to_s.underscore
     end
   end
 end
 
 class DasherizedRouteFormatter < JSONAPI::RouteFormatter
   class << self
-    @@format_cache = JSONAPI::NaiveCache.new do |route|
-      route.to_s.dasherize
-    end
-    @@unformat_cache = JSONAPI::NaiveCache.new do |formatted_route|
-      formatted_route.to_s.underscore
-    end
-
     def format(route)
-      @@format_cache.calc(route)
+      super.dasherize
     end
 
     def unformat(formatted_route)
-      @@unformat_cache.calc(formatted_route)
+      formatted_route.to_s.underscore
     end
   end
 end

lib/jsonapi/link_builder.rb

@@ -2,25 +2,24 @@ module JSONAPI
   class LinkBuilder
     attr_reader :base_url,
                 :primary_resource_klass,
-                :route_formatter
+                :route_formatter,
+                :engine_name
 
     def initialize(config = {})
       @base_url               = config[:base_url]
       @primary_resource_klass = config[:primary_resource_klass]
       @route_formatter        = config[:route_formatter]
-      @is_engine              = !!engine_name
+      @engine_name            = build_engine_name
 
+      # Warning: These make LinkBuilder non-thread-safe. That's not a problem with the
+      # request-specific way it's currently used, though.
       @resources_path_cache   = JSONAPI::NaiveCache.new do |source_klass|
         formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
       end
     end
 
     def engine?
-      @is_engine
-    end
-
-    def engine_name
-      @engine_name ||= build_engine_name
+      !!@engine_name
     end
 
     def primary_resources_url
@@ -100,7 +99,7 @@ def engine_resources_path_name_from_class(klass)
     end
 
     def format_route(route)
-      route_formatter.format(route.to_s)
+      route_formatter.format(route)
     end
 
     def formatted_module_path_from_class(klass)
@@ -118,7 +117,7 @@ def module_scopes_from_class(klass)
     end
 
     def regular_resources_path(source_klass)
-      @resources_path_cache.calc(source_klass)
+      @resources_path_cache.get(source_klass)
     end
 
     def regular_primary_resources_path

lib/jsonapi/naive_cache.rb

@@ -1,16 +1,27 @@
 module JSONAPI
+
+  # Cache which memoizes the given block.
+  #
+  # It's "naive" because it clears the least-recently-inserted cache entry
+  # rather than the least-recently-used. This makes lookups faster but cache
+  # misses more frequent after cleanups. Therefore you the best time to use
+  # this cache is when you expect only a small number of unique lookup keys, so
+  # that the cache never has to clear.
+  #
+  # Also, it's not thread safe (although jsonapi-resources is careful to only
+  # use it in a thread safe way).
   class NaiveCache
-    def initialize(cap = 1024, &calculator)
-      @data = {}
+    def initialize(cap = 10000, &calculator)
       @cap = cap
+      @data = {}
       @calculator = calculator
     end
 
-    def calc(key)
-      value = @data.fetch(key, nil)
-      return value unless value.nil?
+    def get(key)
+      found = true
+      value = @data.fetch(key) { found = false }
+      return value if found
       value = @calculator.call(key)
-      raise "Cannot cache nil value (calculated for #{key})" if value.nil?
       @data[key] = value
       @data.shift if @data.length > @cap
       return value

lib/jsonapi/relationship.rb

@@ -22,7 +22,7 @@ def primary_key
     end
 
     def resource_klass
-      @resource_klass = @parent_resource.resource_for(@class_name)
+      @resource_klass ||= @parent_resource.resource_for(@class_name)
     end
 
     def table_name