identity_cache 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba4de54fb34aecd2a44702ea1bb950c718cdc715
+  data.tar.gz: 752b53a7d7399f5273fd7083152c4b28ee5cbdeb
+SHA512:
+  metadata.gz: ffa0486c327789a3d975ea768ffe63ed73878f4916aa54b24fa06c1771ece940b4e8bd67a2b8838e224d996a9088b2bd6696237209040608b30c10ed28bb0438
+  data.tar.gz: 903fc321ed4092d797d230302cfb8a09bfb3a4f47e58f0e67b605391ca0ea6dbc5916dd801ed06ee58e65ffae8793e6f25d8f7e94a875d2dd35d1fa427e62825

data/.travis.yml

@@ -1,6 +1,7 @@
 language: ruby
 rvm:
   - 1.9.3
+  - 2.0.0
 
 services:
   - memcache

data/CHANGELOG

@@ -1,3 +1,10 @@
+0.0.3
+* Fix: memoization for multi hits actually work
+* Fix: quotes SELECT projection elements on cache misses
+* Add CPU performance benchmark
+* Fix: table names are not hardcoded anymore
+* Logger now differentiates memoized vs non memoized hits
+
 0.0.2
 * Fix: Existent embedded entries will no longer raise when ActiveModel::MissingAttributeError when accessing a newly created attribute.
 * Fix: Do not marshal raw AcriveRecord associations

data/README.md

@@ -16,6 +16,8 @@ gem 'identity_cache'
 And then execute:
 
     $ bundle
+    
+
 
 Add the following to your environment/production.rb:
 
@@ -23,6 +25,12 @@ Add the following to your environment/production.rb:
 config.identity_cache_store = :mem_cache_store, Memcached::Rails.new(:servers => ["mem1.server.com"])
 ```
 
+Add an initializer with this code:
+
+```ruby
+IdentityCache.cache_backend = ActiveSupport::Cache.lookup_store(*Rails.configuration.identity_cache_store)
+```
+
 ## Usage
 
 ### Basic Usage

data/Rakefile

@@ -14,3 +14,22 @@ Rake::TestTask.new(:test) do |t|
   t.pattern = 'test/**/*_test.rb'
   t.verbose = true
 end
+
+namespace :benchmark do
+  desc "Run the identity cache CPU benchmark"
+  task :cpu do
+    ruby "./performance/cpu.rb"
+  end
+
+  task :externals do
+    ruby "./performance/externals.rb"
+  end
+end
+
+namespace :profile do
+  desc "Profile IDC code"
+  task :run do
+    ruby "./performance/profile.rb"
+  end
+end
+

data/identity_cache.gemspec

@@ -22,7 +22,8 @@ Gem::Specification.new do |gem|
   gem.add_dependency('cityhash', '0.6.0')
   gem.add_development_dependency('memcache-client')
   gem.add_development_dependency('rake')
-  gem.add_development_dependency('mocha')
+  gem.add_development_dependency('mocha', '0.14.0')
   gem.add_development_dependency('mysql2')
   gem.add_development_dependency('debugger')
+  gem.add_development_dependency('ruby-prof')
 end

data/lib/{belongs_to_caching.rb → identity_cache/belongs_to_caching.rb}

@@ -1,21 +1,21 @@
 module IdentityCache
   module BelongsToCaching
+    extend ActiveSupport::Concern
 
-    def self.included(base)
-      base.send(:extend, ClassMethods)
+    included do |base|
       base.class_attribute :cached_belongs_tos
+      base.cached_belongs_tos = {}
     end
 
     module ClassMethods
       def cache_belongs_to(association, options = {})
-        self.cached_belongs_tos ||= {}
         self.cached_belongs_tos[association] = options
 
         options[:embed] ||= false
-        options[:cached_accessor_name] ||= "fetch_#{association}"
-        options[:foreign_key] ||= reflect_on_association(association).foreign_key
-        options[:associated_class] ||= reflect_on_association(association).class_name
-
+        options[:cached_accessor_name]    ||= "fetch_#{association}"
+        options[:foreign_key]             ||= reflect_on_association(association).foreign_key
+        options[:association_class]       ||= reflect_on_association(association).klass
+        options[:prepopulate_method_name] ||= "prepopulate_fetched_#{association}"
         if options[:embed]
           raise NotImplementedError
         else
@@ -27,11 +27,15 @@ module IdentityCache
         self.class_eval(ruby = <<-CODE, __FILE__, __LINE__)
           def #{options[:cached_accessor_name]}
             if IdentityCache.should_cache? && #{options[:foreign_key]}.present? && !association(:#{association}).loaded?
-              self.#{association} = #{options[:associated_class]}.fetch_by_id(#{options[:foreign_key]})
+              self.#{association} = #{options[:association_class]}.fetch_by_id(#{options[:foreign_key]})
             else
               #{association}
             end
           end
+
+          def #{options[:prepopulate_method_name]}(record)
+            self.#{association} = record
+          end
         CODE
       end
     end

data/lib/identity_cache/cache_key_generation.rb

@@ -0,0 +1,58 @@
+module IdentityCache
+  module CacheKeyGeneration
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def rails_cache_key(id)
+        rails_cache_key_prefix + id.to_s
+      end
+
+      def rails_cache_key_prefix
+        @rails_cache_key_prefix ||= begin
+          "IDC:blob:#{base_class.name}:#{IdentityCache.denormalized_schema_hash(self)}:"
+        end
+      end
+
+      def rails_cache_index_key_for_fields_and_values(fields, values)
+        "IDC:index:#{base_class.name}:#{rails_cache_string_for_fields_and_values(fields, values)}"
+      end
+
+      def rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values)
+        "IDC:attribute:#{base_class.name}:#{attribute}:#{rails_cache_string_for_fields_and_values(fields, values)}"
+      end
+
+      def rails_cache_string_for_fields_and_values(fields, values)
+        "#{fields.join('/')}:#{IdentityCache.memcache_hash(values.join('/'))}"
+      end
+    end
+
+    def primary_cache_index_key # :nodoc:
+      self.class.rails_cache_key(id)
+    end
+
+    def secondary_cache_index_key_for_current_values(fields) # :nodoc:
+      self.class.rails_cache_index_key_for_fields_and_values(fields, fields.collect {|field| self.send(field)})
+    end
+
+    def secondary_cache_index_key_for_previous_values(fields) # :nodoc:
+      self.class.rails_cache_index_key_for_fields_and_values(fields, old_values_for_fields(fields))
+    end
+
+    def attribute_cache_key_for_attribute_and_previous_values(attribute, fields) # :nodoc:
+      self.class.rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, old_values_for_fields(fields))
+    end
+
+    def old_values_for_fields(fields) # :nodoc:
+      fields.map do |field|
+        field_string = field.to_s
+        if destroyed? && transaction_changed_attributes.has_key?(field_string)
+          transaction_changed_attributes[field_string]
+        elsif persisted? && transaction_changed_attributes.has_key?(field_string)
+          transaction_changed_attributes[field_string]
+        else
+          self.send(field)
+        end
+      end
+    end
+  end
+end

data/lib/identity_cache/configuration_dsl.rb

@@ -0,0 +1,301 @@
+module IdentityCache
+  module ConfigurationDSL
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.class_attribute :cache_indexes
+      base.class_attribute :cache_attributes
+      base.class_attribute :cached_has_manys
+      base.class_attribute :cached_has_ones
+      base.class_attribute :primary_cache_index_enabled
+
+      base.cached_has_manys = {}
+      base.cached_has_ones = {}
+      base.cache_attributes = []
+      base.cache_indexes = []
+      base.primary_cache_index_enabled = true
+
+      base.private_class_method :build_normalized_has_many_cache, :build_denormalized_association_cache,
+                                :add_parent_expiry_hook, :identity_cache_multiple_value_dynamic_fetcher,
+                                :identity_cache_single_value_dynamic_fetcher, :identity_cache_sql_conditions
+    end
+
+    module ClassMethods
+      # Declares a new index in the cache for the class where IdentityCache was
+      # included.
+      #
+      # IdentityCache will add a fetch_by_field1_and_field2_and_...field for every
+      # index.
+      #
+      # == Example:
+      #
+      #  class Product
+      #    include IdentityCache
+      #    cache_index :name, :vendor
+      #  end
+      #
+      # Will add Product.fetch_by_name_and_vendor
+      #
+      # == Parameters
+      #
+      # +fields+ Array of symbols or strings representing the fields in the index
+      #
+      # == Options
+      # * unique: if the index would only have unique values
+      #
+      def cache_index(*fields)
+        raise NotImplementedError, "Cache indexes need an enabled primary index" unless primary_cache_index_enabled
+        options = fields.extract_options!
+        self.cache_indexes.push fields
+
+        field_list = fields.join("_and_")
+        arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(',')
+
+        if options[:unique]
+          self.instance_eval(ruby = <<-CODE, __FILE__, __LINE__)
+            def fetch_by_#{field_list}(#{arg_list})
+              identity_cache_single_value_dynamic_fetcher(#{fields.inspect}, [#{arg_list}])
+            end
+
+            # exception throwing variant
+            def fetch_by_#{field_list}!(#{arg_list})
+              fetch_by_#{field_list}(#{arg_list}) or raise ActiveRecord::RecordNotFound
+            end
+          CODE
+        else
+          self.instance_eval(ruby = <<-CODE, __FILE__, __LINE__)
+            def fetch_by_#{field_list}(#{arg_list})
+              identity_cache_multiple_value_dynamic_fetcher(#{fields.inspect}, [#{arg_list}])
+            end
+          CODE
+        end
+      end
+
+
+      # Will cache an association to the class including IdentityCache.
+      # The embed option, if set, will make IdentityCache keep the association
+      # values in the same cache entry as the parent.
+      #
+      # Embedded associations are more effective in offloading database work,
+      # however they will increase the size of the cache entries and make the
+      # whole entry expire when any of the embedded members change.
+      #
+      # == Example:
+      #   class Product
+      #    cached_has_many :options, :embed => false
+      #    cached_has_many :orders
+      #    cached_has_many :buyers, :inverse_name => 'line_item'
+      #   end
+      #
+      # == Parameters
+      # +association+ Name of the association being cached as a symbol
+      #
+      # == Options
+      #
+      # * embed: If set will cause IdentityCache to keep the values for this
+      #   association in the same cache entry as the parent, instead of its own.
+      # * inverse_name: The name of the parent in the association if the name is
+      #   not the lowercase pluralization of the parent object's class
+      def cache_has_many(association, options = {})
+        options[:embed] ||= false
+        options[:inverse_name] ||= self.name.underscore.to_sym
+        raise InverseAssociationError unless self.reflect_on_association(association)
+        self.cached_has_manys[association] = options
+
+        if options[:embed]
+          build_denormalized_association_cache(association, options)
+        else
+          build_normalized_has_many_cache(association, options)
+        end
+      end
+
+      # Will cache an association to the class including IdentityCache.
+      # The embed option if set will make IdentityCache keep the association
+      # values in the same cache entry as the parent.
+      #
+      # Embedded associations are more effective in offloading database work,
+      # however they will increase the size of the cache entries and make the
+      # whole entry expire with the change of any of the embedded members
+      #
+      # == Example:
+      #   class Product
+      #    cached_has_one :store, :embed => false
+      #    cached_has_one :vendor
+      #   end
+      #
+      # == Parameters
+      # +association+ Symbol with the name of the association being cached
+      #
+      # == Options
+      #
+      # * embed: If set will cause IdentityCache to keep the values for this
+      #   association in the same cache entry as the parent, instead of its own.
+      # * inverse_name: The name of the parent in the association ( only
+      #   necessary if the name is not the lowercase pluralization of the
+      #   parent object's class)
+      def cache_has_one(association, options = {})
+        options[:embed] ||= true
+        options[:inverse_name] ||= self.name.underscore.to_sym
+        raise InverseAssociationError unless self.reflect_on_association(association)
+        self.cached_has_ones[association] = options
+
+        if options[:embed]
+          build_denormalized_association_cache(association, options)
+        else
+          raise NotImplementedError
+        end
+      end
+
+      # Will cache a single attribute on its own blob, it will add a
+      # fetch_attribute_by_id (or the value of the by option).
+      #
+      # == Example:
+      #   class Product
+      #    cache_attribute :quantity, :by => :name
+      #    cache_attribute :quantity  :by => [:name, :vendor]
+      #   end
+      #
+      # == Parameters
+      # +attribute+ Symbol with the name of the attribute being cached
+      #
+      # == Options
+      #
+      # * by: Other attribute or attributes in the model to keep values indexed. Default is :id
+      def cache_attribute(attribute, options = {})
+        options[:by] ||= :id
+        fields = Array(options[:by])
+
+        self.cache_attributes.push [attribute, fields]
+
+        field_list = fields.join("_and_")
+        arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(',')
+
+        self.instance_eval(ruby = <<-CODE, __FILE__, __LINE__)
+          def fetch_#{attribute}_by_#{field_list}(#{arg_list})
+            attribute_dynamic_fetcher(#{attribute.inspect}, #{fields.inspect}, [#{arg_list}])
+          end
+        CODE
+      end
+
+      def disable_primary_cache_index
+        raise NotImplementedError, "Secondary indexes rely on the primary index to function. You must either remove the secondary indexes or don't disable the primary" if self.cache_indexes.size > 0
+        self.primary_cache_index_enabled = false
+      end
+
+      def identity_cache_single_value_dynamic_fetcher(fields, values) # :nodoc:
+        sql_on_miss = "SELECT `id` FROM `#{table_name}` WHERE #{identity_cache_sql_conditions(fields, values)} LIMIT 1"
+        cache_key = rails_cache_index_key_for_fields_and_values(fields, values)
+        id = IdentityCache.fetch(cache_key) { connection.select_value(sql_on_miss) }
+        unless id.nil?
+          record = fetch_by_id(id.to_i)
+          IdentityCache.cache.delete(cache_key) unless record
+        end
+
+        record
+      end
+
+      def identity_cache_multiple_value_dynamic_fetcher(fields, values) # :nodoc
+        sql_on_miss = "SELECT `id` FROM `#{table_name}` WHERE #{identity_cache_sql_conditions(fields, values)}"
+        cache_key = rails_cache_index_key_for_fields_and_values(fields, values)
+        ids = IdentityCache.fetch(cache_key) { connection.select_values(sql_on_miss) }
+
+        ids.empty? ? [] : fetch_multi(*ids)
+      end
+
+      def build_denormalized_association_cache(association, options) #:nodoc:
+        options[:association_class]      ||= reflect_on_association(association).klass
+        options[:cached_accessor_name]   ||= "fetch_#{association}"
+        options[:records_variable_name]     ||= "cached_#{association}"
+        options[:population_method_name] ||= "populate_#{association}_cache"
+
+
+        unless instance_methods.include?(options[:cached_accessor_name].to_sym)
+          self.class_eval(ruby = <<-CODE, __FILE__, __LINE__)
+            def #{options[:cached_accessor_name]}
+              fetch_denormalized_cached_association('#{options[:records_variable_name]}', :#{association})
+            end
+
+            def #{options[:population_method_name]}
+              populate_denormalized_cached_association('#{options[:records_variable_name]}', :#{association})
+            end
+          CODE
+
+          add_parent_expiry_hook(options.merge(:only_on_foreign_key_change => false))
+        end
+      end
+
+      def build_normalized_has_many_cache(association, options) #:nodoc:
+        singular_association = association.to_s.singularize
+        options[:association_class]       ||= reflect_on_association(association).klass
+        options[:cached_accessor_name]    ||= "fetch_#{association}"
+        options[:ids_name]                ||= "#{singular_association}_ids"
+        options[:cached_ids_name]         ||= "fetch_#{options[:ids_name]}"
+        options[:ids_variable_name]       ||= "cached_#{options[:ids_name]}"
+        options[:records_variable_name]   ||= "cached_#{association}"
+        options[:population_method_name]  ||= "populate_#{association}_cache"
+        options[:prepopulate_method_name] ||= "prepopulate_fetched_#{association}"
+
+        self.class_eval(ruby = <<-CODE, __FILE__, __LINE__)
+          attr_reader :#{options[:ids_variable_name]}
+
+          def #{options[:cached_ids_name]}
+            #{options[:population_method_name]} unless @#{options[:ids_variable_name]}
+            @#{options[:ids_variable_name]}
+          end
+
+          def #{options[:population_method_name]}
+            @#{options[:ids_variable_name]} = #{options[:ids_name]}
+            association_cache.delete(:#{association})
+          end
+
+          def #{options[:cached_accessor_name]}
+            if IdentityCache.should_cache? || #{association}.loaded?
+              #{options[:population_method_name]} unless @#{options[:ids_variable_name]} || @#{options[:records_variable_name]}
+              @#{options[:records_variable_name]} ||= #{options[:association_class]}.fetch_multi(*@#{options[:ids_variable_name]})
+            else
+              #{association}
+            end
+          end
+
+          def #{options[:prepopulate_method_name]}(records)
+            @#{options[:records_variable_name]} = records
+          end
+        CODE
+
+        add_parent_expiry_hook(options.merge(:only_on_foreign_key_change => true))
+      end
+
+      def attribute_dynamic_fetcher(attribute, fields, values) #:nodoc:
+        cache_key = rails_cache_key_for_attribute_and_fields_and_values(attribute, fields, values)
+        sql_on_miss = "SELECT `#{attribute}` FROM `#{table_name}` WHERE #{identity_cache_sql_conditions(fields, values)} LIMIT 1"
+
+        IdentityCache.fetch(cache_key) { connection.select_value(sql_on_miss) }
+      end
+
+      def add_parent_expiry_hook(options)
+        child_class = options[:association_class]
+        child_association = child_class.reflect_on_association(options[:inverse_name])
+        raise InverseAssociationError unless child_association
+        foreign_key = child_association.association_foreign_key
+        parent_class ||= self.name
+        new_parent = options[:inverse_name]
+
+        child_class.send(:include, ArTransactionChanges) unless child_class.include?(ArTransactionChanges)
+        child_class.send(:include, ParentModelExpiration) unless child_class.include?(ParentModelExpiration)
+
+        child_class.class_eval(ruby = <<-CODE, __FILE__, __LINE__)
+          after_commit :expire_parent_cache
+          after_touch  :expire_parent_cache
+
+          def expire_parent_cache
+            expire_parent_cache_on_changes(:#{options[:inverse_name]}, '#{foreign_key}', #{parent_class}, #{options[:only_on_foreign_key_change]})
+          end
+        CODE
+      end
+
+      def identity_cache_sql_conditions(fields, values)
+        fields.each_with_index.collect { |f, i| "`#{f}` = #{quote_value(values[i])}" }.join(" AND ")
+      end
+    end
+  end
+end

data/lib/identity_cache/memoized_cache_proxy.rb

@@ -0,0 +1,118 @@
+require 'monitor'
+
+module IdentityCache
+  class MemoizedCacheProxy
+    attr_writer :memcache
+
+    def initialize(memcache = nil)
+      @memcache = memcache || Rails.cache
+      @key_value_maps = Hash.new {|h, k| h[k] = {} }
+    end
+
+    def memoized_key_values
+      @key_value_maps[Thread.current]
+    end
+
+    def with_memoization(&block)
+      Thread.current[:memoizing_idc] = true
+      yield
+    ensure
+      clear_memoization
+      Thread.current[:memoizing_idc] = false
+    end
+
+    def write(key, value)
+      memoized_key_values[key] = value if memoizing?
+      @memcache.write(key, value)
+    end
+
+    def read(key)
+      used_memcached = true
+
+      result = if memoizing?
+        used_memcached = false
+        mkv = memoized_key_values
+
+        mkv.fetch(key) do
+          used_memcached = true
+          mkv[key] = @memcache.read(key)
+        end
+
+      else
+        @memcache.read(key)
+      end
+
+      if result
+        IdentityCache.logger.debug { "[IdentityCache] #{ used_memcached ? '(memcache)'  : '(memoized)'  } cache hit for #{key}" }
+      else
+        IdentityCache.logger.debug { "[IdentityCache] cache miss for #{key}" }
+      end
+
+      result
+    end
+
+    def delete(key)
+      memoized_key_values.delete(key) if memoizing?
+      @memcache.delete(key)
+    end
+
+    def read_multi(*keys)
+
+      if IdentityCache.logger.debug?
+        memoized_keys , memcache_keys = [], []
+      end
+
+      result = if memoizing?
+        hash = {}
+        mkv = memoized_key_values
+
+        missing_keys = keys.reject do |key|
+          if mkv.has_key?(key)
+            memoized_keys << key if IdentityCache.logger.debug?
+            hit = mkv[key]
+            hash[key] = hit unless hit.nil?
+            true
+          end
+        end
+
+        hits =   missing_keys.empty? ? {} : @memcache.read_multi(*missing_keys)
+
+        missing_keys.each do |key|
+          hit = hits[key]
+          mkv[key] = hit
+          hash[key] = hit unless hit.nil?
+        end
+        hash
+      else
+        @memcache.read_multi(*keys)
+      end
+
+      if IdentityCache.logger.debug?
+
+        result.each do |k, v|
+          memcache_keys << k if !v.nil? && !memoized_keys.include?(k)
+        end
+
+        memoized_keys.each{ |k| IdentityCache.logger.debug "[IdentityCache] (memoized) cache hit for #{k} (multi)" }
+        memcache_keys.each{ |k| IdentityCache.logger.debug "[IdentityCache] (memcache) cache hit for #{k} (multi)" }
+      end
+
+      result
+    end
+
+    def clear
+      clear_memoization
+      @memcache.clear
+    end
+
+    private
+
+    def clear_memoization
+      @key_value_maps.delete(Thread.current)
+    end
+
+    def memoizing?
+      Thread.current[:memoizing_idc]
+    end
+  end
+end

data/lib/identity_cache/parent_model_expiration.rb

@@ -0,0 +1,34 @@
+module IdentityCache
+  module ParentModelExpiration # :nodoc:
+    def expire_parent_cache_on_changes(parent_name, foreign_key, parent_class, only_on_foreign_key_change)
+      new_parent = send(parent_name)
+
+      if new_parent && new_parent.respond_to?(:expire_primary_index, true)
+        if should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)
+          new_parent.expire_primary_index
+          new_parent.expire_parent_cache if new_parent.respond_to?(:expire_parent_cache)
+        end
+      end
+
+      if transaction_changed_attributes[foreign_key].present?
+        begin
+          old_parent = parent_class.find(transaction_changed_attributes[foreign_key])
+          old_parent.expire_primary_index if old_parent.respond_to?(:expire_primary_index)
+          old_parent.expire_parent_cache  if old_parent.respond_to?(:expire_parent_cache)
+        rescue ActiveRecord::RecordNotFound => e
+          # suppress errors finding the old parent if its been destroyed since it will have expired itself in that case
+        end
+      end
+
+      true
+    end
+
+    def should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)
+      if only_on_foreign_key_change
+        destroyed? || was_new_record? || transaction_changed_attributes[foreign_key].present?
+      else
+        true
+      end
+    end
+  end
+end