incrdecr_cached_counts 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f47ca230c62c31bfaa2f488764ebb48b9e2aeefe611ba9fae8cd15d458a53e8
-  data.tar.gz: ed2839fb88a855bd60c92a3506fe367206b74db71479732009e6769af346c9a6
+  metadata.gz: 42bbe0c4b1d6ddc82d92bc3d1475dcf3e7553ef9f8299d0e3d75aa5d7c8519c6
+  data.tar.gz: 652f35c8b0c667c3ee9517494c2a23b04ea3f90a7591d74922538c84906c754f
 SHA512:
-  metadata.gz: 8bf76a8198b3dc430c8ff5658da2d4889aa7344dad224241af7fd82c318100932a2d81582a946b942ab908ffc3e0e60a3dbe916999c4130fecc02e3f26bbd1ca
-  data.tar.gz: 31c5dc4eef93988cf1463827daf60b78bd19a0bf8e3ad536ee6cbe8f4f940b19ebe35c32b4027bf081e565f9c97e921336d9257f0d9a17a0d5be98786c648fdd
+  metadata.gz: 6610220977371d6bde5f48e6aa6dfbe879e4213d04fd0ae7bc05a00e4766751ee427b5e2f3e42ecb88fb8e665885a786f38a125a81fc042b258078e3a3debfa1
+  data.tar.gz: 6d8c16611f42f680f4350b196935cf0caffef9253e6b016e1731b142f5d719c3ce43f2293869efb6393cb52f61e05e4819dfdac6357fccf4f228ff05111b3306

data/lib/cached_counts.rb

@@ -39,11 +39,13 @@ module CachedCounts
     # @option options [Integer, #to_s] :version
     #   Cache version - bump if you change the definition of a count.
     #
-    # @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
+    # @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.
     #
     def caches_count_where(attribute_name, options = {})
       # Delay actual run to work around circular dependencies
@@ -134,6 +136,14 @@ 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,
@@ -146,6 +156,23 @@ 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
 
@@ -210,12 +237,7 @@ 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
-      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
+      race_condition_fallback = options.fetch :race_condition_fallback, nil
 
       key_method = "#{attribute_name}_count_key"
 
@@ -225,23 +247,34 @@ module CachedCounts
         val = Rails.cache.fetch(
           send(key_method),
           expires_in: expires_in,
-          race_condition_ttl: fallback_expiry_seconds,
+          race_condition_ttl: 30.seconds,
           raw: true # Necessary for incrementing to work correctly
         ) do
-          # 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
-          )
+          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
+
           relation = instance_exec(&relation_getter)
           relation = relation.reorder('')
           relation.select_values = ['count(*)']
-          value_updater_lambda.call(counted_class, relation.to_sql, send(key_method), expires_in) || default_value
+
+          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
         end
+
         if val.is_a?(ActiveSupport::Cache::Entry)
           val.value.to_i
         else
@@ -263,20 +296,6 @@ 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".to_sym
       counted_class.send :define_method, increment_hook do

data/lib/cached_counts/version.rb

@@ -1,3 +1,3 @@
 module CachedCounts
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: incrdecr_cached_counts
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - David Judd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-18 00:00:00.000000000 Z
+date: 2019-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -177,4 +177,13 @@ rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A replacement for Rails' counter caches using memcached (via Dalli)
-test_files: []
+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