atomic_cache 0.5.0.rc1 → 0.5.4.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7362eab306c19b619c6eb4bd30501b2b18194cd9e870a344e45b39c6ff18b4ae
-  data.tar.gz: cce7666dec7a66bca3717cb7278bcdb9d7b81aaffc8c68fb020e15e02820f921
+  metadata.gz: e912c124c9879b3208c849a21f6f82a665ddc0f3ab1e268a1355d6cfb7bda54a
+  data.tar.gz: 3fc8b8814852f95414e8c699fb2b6f17d4c0a0516f7bc12dbdb2d167096604ac
 SHA512:
-  metadata.gz: b418f307870a20aa99b326644c14066d3baba30287138ce2a4b533582d788231058c0f3f66737fcf19225cdadbcf5dbb78653d7969ade7eb7555a7c3f849b4c2
-  data.tar.gz: c9f48abddc3b0f9d623db83bd493df4fd555ae468710251dd13db6ed684399052b52a48ffec516f96ae17a1ccc747416688b2234f514ef8278bba0fd4ed550d2
+  metadata.gz: 5104f60b2f4f9d2816a53e7a19dcf58eda5e245b052c1d048c586cae8df985e0eb17f58c13bdc8dc07db4bb50607d033cb57c7a701db50a896955575cc710e3b
+  data.tar.gz: bae2d03aac48378a6075d648c9131cf265271192658e30b5191a6bb82735e7a4aae0162d62b0c4153ed46ad16d9375cf8c832bd899b408e3ab7a9617710d2f71

data/docs/MODEL_SETUP.md

@@ -29,3 +29,65 @@ class Foo < ActiveRecord::Base
   cache_version(5)
 end
 ```
+
+### Inheritance
+
+When either `force_cache_class` or `cache_version` are used, those values will always be preferred by classes which inherit from the class on which those macros exist. When macros are used on descendant classes, the "closet" value wins.
+
+#### Example #1
+The keys used by `Bar` will be prefixed with `custom:v5`, as it prefers both the 'custom' class name and version 5 from the parent.
+```ruby
+class Foo < ActiveRecord::Base
+  include AtomicCache::GlobalLMTCacheConcern
+  force_cache_class('custom')
+  cache_version(5)
+end
+
+class Bar < Foo
+end
+```
+
+#### Example #2
+The keys used by `Bar` will be prefixed with `bar:v5`, as the version 5 is taken from the parent, but the use of forcing on the child class result in the cache class of 'bar'.
+```ruby
+class Foo < ActiveRecord::Base
+  include AtomicCache::GlobalLMTCacheConcern
+  cache_version(5)
+end
+
+class Bar < Foo
+  force_cache_class('bar')
+end
+```
+
+#### Example #3
+The keys used by `Bar` will be still be prefixed with `bar:v5` for the same reasons as above.
+```ruby
+class Foo < ActiveRecord::Base
+  include AtomicCache::GlobalLMTCacheConcern
+  force_cache_class('custom')
+  cache_version(5)
+end
+
+class Bar < Foo
+  force_cache_class('bar')
+end
+```
+
+### Rails Model Inheritance
+
+It's not uncommon in rails to end up with model inhertiance. For example:
+
+```ruby
+class Content < ActiveRecord::Base
+  include AtomicCache::GlobalLMTCacheConcern
+  force_cache_class('content')
+end
+
+class BlogPost < Content
+end
+```
+
+If these models will be cached together into a single key, it's preferable to force the cache class on the parent, causing all the descendant types to use the same keyspace. Not doing this will cause each subtype to use it's own last modified time.
+
+If the models will be treated as separate collections and cached separately, this is not recommended. Alternately, if only some subtypes will be cached together, those should share a forced cache class and version.

data/docs/USAGE.md

@@ -38,6 +38,12 @@ The ideal `generate_ttl_ms` time is just slightly longer than the average genera
 
 If metrics are enabled, the `<namespace>.generate.run` can be used to determine the min/max/average generate time for a particular cache and the `generate_ttl_ms` tuned using that.
 
+##### ⚠️ TTL Rounding
+When using atomic_cache with memcached, be aware that the TTL will be rounded down to the nearest whole seconds. For example, a `generate_ttl_ms` value of 3500 will result in a 3s TTL with memcache.
+
+##### ⚠️ Max Rate of Change
+Atomic_cache will *not* remove the lock after the generation process is done. This is both more efficient, and allows the `generate_ttl_ms` to be used to limit the total rate of change. For example, if the typical database query behind the cache takes 2s to run, but `generate_ttl_ms` is set to 10s, then the lock will live on for 8s after the generate process finishes, preventing other processes from querying for a new value. In many ways, `generate_ttl_ms` is the amount of time that the system will be un-allowed to make additional queries.  
+
 #### `max_retries` & `backoff_duration_ms`
 _`max_retries` defaults to 5._
 _`backoff_duration_ms` defaults to 50ms._

data/lib/atomic_cache/atomic_cache_client.rb

@@ -93,8 +93,8 @@ module AtomicCache
         end
 
         new_key = @timestamp_manager.next_key(keyspace, lmt)
-        @timestamp_manager.promote(keyspace, last_known_key: new_key, timestamp: lmt)
         @storage.set(new_key, new_value, options)
+        @timestamp_manager.promote(keyspace, last_known_key: new_key, timestamp: lmt)
 
         metrics(:increment, 'generate.current-thread', tags: tags)
         log(:debug, "Generating new value for `#{new_key}`")
@@ -119,13 +119,11 @@ module AtomicCache
           return lkv
         end
 
-        # if the value of the last known key is nil, we can infer that it's
-        # most likely expired, thus remove it so other processes don't waste
-        # time trying to read it
-        @storage.delete(lkk)
+        metrics(:increment, 'last-known-value.nil', tags: tags)
+      else
+        metrics(:increment, 'last-known-value.not-present', tags: tags)
       end
 
-      metrics(:increment, 'last-known-value.not-present', tags: tags)
       nil
     end
 

data/lib/atomic_cache/concerns/global_lmt_cache_concern.rb

@@ -63,15 +63,29 @@ module AtomicCache
         @timestamp_manager.last_modified_time
       end
 
+      # protected
+
+      def cache_version_get
+        return @atomic_cache_version if @atomic_cache_version.present?
+        return self.superclass.cache_version_get if self.superclass.respond_to?(:cache_version_get)
+        nil
+      end
+
+      def cache_class_get
+        return @atomic_cache_class if @atomic_cache_class.present?
+        return self.superclass.cache_class_get if self.superclass.respond_to?(:cache_class_get)
+        nil
+      end
+
       private
 
       def init_atomic_cache
         return if @atomic_cache.present?
         ATOMIC_CACHE_CONCERN_MUTEX.synchronize do
-          cache_class = @atomic_cache_class || default_cache_class
+          cache_class = cache_class_get || default_cache_class
           prefix = [cache_class]
           prefix.unshift(DefaultConfig.instance.namespace) if DefaultConfig.instance.namespace.present?
-          prefix.push("v#{@atomic_cache_version}") if @atomic_cache_version.present?
+          prefix.push("v#{cache_version_get}") if cache_version_get.present?
           @default_cache_keyspace = Keyspace.new(namespace: prefix, root: cache_class)
 
           @timestamp_manager = LastModTimeKeyManager.new(

data/lib/atomic_cache/key/last_mod_time_key_manager.rb

@@ -44,8 +44,7 @@ module AtomicCache
     # @param last_known_key [String] a key with a known value to refer other processes to
     # @param timestamp [String, Numeric, Time] the timestamp with which the last_known_key was updated at
     def promote(keyspace, last_known_key:, timestamp:)
-      key = keyspace.last_known_key_key
-      @storage.set(key, last_known_key)
+      @storage.set(keyspace.last_known_key_key, last_known_key)
       @storage.set(last_modified_time_key, self.format(timestamp))
     end
 
@@ -59,6 +58,13 @@ module AtomicCache
       @storage.add(keyspace.lock_key, LOCK_VALUE, ttl, options)
     end
 
+    # check if the keyspace is locked
+    #
+    # @param keyspace [AtomicCache::Keyspace] keyspace to lock
+    def lock_present?(keyspace)
+      @storage.read(keyspace.lock_key) == LOCK_VALUE
+    end
+
     # remove existing lock to allow other processes to update keyspace
     #
     # @param keyspace [AtomicCache::Keyspace] keyspace to lock

data/lib/atomic_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtomicCache
-  VERSION = "0.5.0.rc1"
+  VERSION = "0.5.4.rc1"
 end

data/spec/atomic_cache/atomic_cache_client_spec.rb

@@ -168,13 +168,6 @@ describe 'AtomicCacheClient' do
               result = subject.fetch(keyspace, backoff_duration_ms: 5) { 'value from generate' }
               expect(result).to eq(nil)
             end
-
-            it 'deletes the last known key' do
-              key_storage.set(keyspace.last_known_key_key, :oldkey)
-              cache_storage.set(:oldkey, nil)
-              subject.fetch(keyspace, backoff_duration_ms: 5) { 'value from generate' }
-              expect(cache_storage.store).to_not have_key(:oldkey)
-            end
           end
         end
       end

data/spec/atomic_cache/concerns/global_lmt_cache_concern_spec.rb

@@ -113,6 +113,61 @@ describe 'AtomicCacheConcern' do
       subject.expire_cache
       expect(key_storage.store).to have_key(:'foo:v3:lmt')
     end
+
+    context 'with version < class inheritance' do
+      subject do
+        class Foo3
+          include AtomicCache::GlobalLMTCacheConcern
+          cache_version(6)
+        end
+        class Foo4 < Foo3
+          force_cache_class('foo')
+        end
+        Foo4
+      end
+
+      it 'uses the version from the parent and the forced class name from the macro' do
+        subject.expire_cache
+        expect(key_storage.store).to have_key(:'foo:v6:lmt')
+      end
+    end
+
+    context 'with class < version inheritance' do
+      subject do
+        class Foo5
+          include AtomicCache::GlobalLMTCacheConcern
+          force_cache_class('foo')
+        end
+        class Foo6 < Foo5
+          cache_version(6)
+        end
+        Foo6
+      end
+
+      it 'uses the cache class from the parent and version from the macro' do
+        subject.expire_cache
+        expect(key_storage.store).to have_key(:'foo:v6:lmt')
+      end
+    end
+
+    context 'dual force_cache_class' do
+      subject do
+        class Foo6
+          include AtomicCache::GlobalLMTCacheConcern
+          force_cache_class('foo')
+        end
+        class Foo7 < Foo6
+          force_cache_class('bar')
+          cache_version(6)
+        end
+        Foo7
+      end
+
+      it 'uses the prefers the forced class name from the macro' do
+        subject.expire_cache
+        expect(key_storage.store).to have_key(:'bar:v6:lmt')
+      end
+    end
   end
 
   context 'storage macros' do

data/spec/atomic_cache/key/last_mod_time_key_manager_spec.rb

@@ -40,6 +40,15 @@ describe 'LastModTimeKeyManager' do
     expect(storage.store).to_not have_key(:'ns:lock')
   end
 
+  it 'checks if the lock is present' do
+    subject.lock(req_keyspace, 100)
+    expect(subject.lock_present?(req_keyspace)).to eq(true)
+  end
+
+  it 'checks if the lock is not present' do
+    expect(subject.lock_present?(req_keyspace)).to eq(false)
+  end
+
   it 'promotes a timestamp and last known key' do
     subject.promote(req_keyspace, last_known_key: 'asdf', timestamp: timestamp)
     expect(storage.read(:'ns:lkk')).to eq('asdf')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic_cache
 version: !ruby/object:Gem::Version
-  version: 0.5.0.rc1
+  version: 0.5.4.rc1
 platform: ruby
 authors:
 - Ibotta Developers
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-08 00:00:00.000000000 Z
+date: 2021-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: gems
   requirement: !ruby/object:Gem::Requirement
@@ -137,6 +137,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -144,9 +158,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -154,9 +165,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6'
 - !ruby/object:Gem::Dependency
   name: murmurhash3
   requirement: !ruby/object:Gem::Requirement