incrdecr_cached_counts 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a018b5815304845fe6bd35505944da125418b3e5
-  data.tar.gz: c1799c3ddaa64683faf943ea9e0d352177c896f0
+  metadata.gz: 933d0e94e08544064f20c36691f4c82fc581a843
+  data.tar.gz: d60e51a4e1f2f3be7329f41999199ee04c471675
 SHA512:
-  metadata.gz: d4ae781d8e7394523beb4f91cbb622f018bc9ee30a04a92cbd4e00e7bdecbeb87f93c9f87dacc6b27a41872c1b1b64f97349a4ecfb1a89043345922a8f57b699
-  data.tar.gz: d52e2154bc2bd201b8297b9ca32cd4b142f1a265e2f7f89b8df3b86aa4c0b8ccd79ecf76e847da13c0f86389ca017ef465ae501d330a22653fb13521e73e1862
+  metadata.gz: 0e83facc3fb470a922d4dbbca8fbefdfe525a8a03016a49a9e3f244b97f8ca46e4c77a1d46143fd9ad84046c98d5bc1d9c46ab50fbd861f58c15d618947e9c7b
+  data.tar.gz: c7fb4d8e58784e72ac21884abb76412050a18c6e55520d470b65fc336c49336728ff2677bf2f6b5760c2c6a5bba2ed8683ff44280ebd1967e4982b1125b80352

data/lib/cached_counts/version.rb

@@ -1,3 +1,3 @@
 module CachedCounts
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

data/lib/cached_counts.rb

@@ -39,13 +39,11 @@ module CachedCounts
     # @option options [Integer, #to_s] :version
     #   Cache version - bump if you change the definition of a count.
     #
-    # @option options [Proc] :race_condition_fallback
-    #   Fallback to the result of this proc if the cache is empty, while
-    #   loading the actual value from the db. Works similarly to
-    #   +race_condition_ttl+ but for empty caches rather than expired values.
-    #   Meant to prevent a thundering-herd scenario, if for example a
-    #   memcached instance goes away. Can be nil; defaults to using a value
-    #   grabbed from the cache or DB at startup.
+    # @option options [Lambda] :default_value_lambda
+    #   Uses this value when the cache is empty, while it is being populated
+    #
+    # @option options [Lambda] :value_updater_lambda
+    #   Override logic for updating a cache value - e.g. to perform background updates
     #
     def caches_count_where(attribute_name, options = {})
       # Delay actual run to work around circular dependencies
@@ -136,14 +134,6 @@ module CachedCounts
       version = options.fetch :version, 1
       key = scope_count_key(attribute_name, version)
 
-      unless options.has_key?(:race_condition_fallback)
-        options[:race_condition_fallback] = default_race_condition_fallback_proc(
-          key,
-          relation,
-          options
-        )
-      end
-
       [attribute_name, *Array(options[:alias])].each do |attr_name|
         add_count_attribute_methods(
           attr_name,
@@ -156,23 +146,6 @@ module CachedCounts
       end
     end
 
-    def default_race_condition_fallback_proc(key, relation, options)
-      fallback = Rails.cache.read(key)
-      fallback = fallback.value if fallback.is_a?(ActiveSupport::Cache::Entry)
-
-      if fallback.nil?
-        begin
-          fallback = relation.count
-        rescue ActiveRecord::StatementInvalid => e
-          fallback = 0
-        end
-
-        Rails.cache.write key, fallback, expires_in: options.fetch(:expires_in, 1.week), raw: true
-      end
-
-      -> { fallback }
-    end
-
     def define_association_count_attribute(attribute_name, association, options)
       options = options.dup
 
@@ -225,7 +198,12 @@ module CachedCounts
 
     def add_count_attribute_methods(attribute_name, key_getter, relation_getter, define_with, counted_class, options)
       expires_in = options.fetch :expires_in, 1.week
-      race_condition_fallback = options.fetch :race_condition_fallback, nil
+      default_value_lambda = options.fetch :default_value_lambda, -> {0}
+      value_updater_lambda = options.fetch :value_updater_lambda, default_value_updater_lambda
+      # TODO: need a good strategy to figure this value out
+      # As a fallback value is used, we immediately fire the calculation for the real value
+      # Is it reasonable to wait as long as it takes to calcualte it? Is there an alternative?
+      fallback_expiry_seconds = expires_in
 
       key_method = "#{attribute_name}_count_key"
 
@@ -235,34 +213,23 @@ module CachedCounts
         val = Rails.cache.fetch(
           send(key_method),
           expires_in: expires_in,
-          race_condition_ttl: 30.seconds,
+          race_condition_ttl: fallback_expiry_seconds,
           raw: true # Necessary for incrementing to work correctly
         ) do
-          if race_condition_fallback
-            # Ensure that other reads find something in the cache, but
-            # continue calculating here because the default is likely inaccurate.
-            fallback_value = instance_exec &race_condition_fallback
-            CachedCounts.logger.warn "Setting #{fallback_value} as race_condition_fallback for #{send(key_method)}"
-            Rails.cache.write(
-              send(key_method),
-              fallback_value.to_i,
-              expires_in: 30.seconds,
-              raw: true
-            )
-          end
-
+          # Write down the default value first so subsequent reads don't repeat calculations
+          # TODO: multiple requests can potentially get to this point and start multiple update operations? Is that a problem?
+          default_value = instance_exec &default_value_lambda
+          Rails.cache.write(
+            send(key_method),
+            default_value,
+            expires_in: fallback_expiry_seconds,
+            raw: true
+          )
           relation = instance_exec(&relation_getter)
           relation = relation.reorder('')
           relation.select_values = ['count(*)']
-
-          conn = CachedCounts.connection_for(counted_class)
-          if Rails.version < '4.2'.freeze
-            conn.select_value(relation.to_sql, nil, relation.values[:bind] || []).to_i
-          else
-            conn.select_value(relation.to_sql).to_i
-          end
+          value_updater_lambda.call(counted_class, relation.to_sql, send(key_method), expires_in) || default_value
         end
-
         if val.is_a?(ActiveSupport::Cache::Entry)
           val.value.to_i
         else
@@ -284,6 +251,20 @@ module CachedCounts
       end
     end
 
+    def default_value_updater_lambda()
+      lambda { |counted_class, relation_sql, cache_key, expires_in|
+        conn = CachedCounts.connection_for(counted_class)
+        value = conn.select_value(relation_sql).to_i
+        Rails.cache.write(
+          cache_key,
+          value,
+          expires_in: expires_in,
+          raw: true
+        )
+        return value
+      }
+    end
+
     def add_counting_hooks(attribute_name, key_getter, counted_class, options)
       increment_hook = "increment_#{attribute_name}_count"
       counted_class.send :define_method, increment_hook do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: incrdecr_cached_counts
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - David Judd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-23 00:00:00.000000000 Z
+date: 2016-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -175,18 +175,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A replacement for Rails' counter caches using memcached (via Dalli)
-test_files:
-- spec/caches_count_of_spec.rb
-- spec/caches_count_where_spec.rb
-- spec/database.yml
-- spec/fixtures.rb
-- spec/fixtures/department.rb
-- spec/fixtures/following.rb
-- spec/fixtures/university.rb
-- spec/fixtures/user.rb
-- spec/spec_helper.rb
+test_files: []
 has_rdoc: