atomic_cache 0.4.0.rc1 → 0.5.2.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f8d7906f63f08bf7e8d7b9f9f88d05a209d65c37375c464f60448ffd9db427e
-  data.tar.gz: ac2b7c09f3299ccbb4dcf588cbe163134c8e81b94d79c08fe908afb6200911a7
+  metadata.gz: 47216ee7b28e97d5a2a0d45ec7a7831d6ee05038f2029498654006b7ad42171c
+  data.tar.gz: 025c598a7d72bd3387c0fe0057a3047227ad9c6ae67ed818912a98d3a3f21e05
 SHA512:
-  metadata.gz: fa4f82e7cd8b729461b5b122a9f9cb92c2c36898c295a63bdd18a510133920ca5694d3e44b9cceceb7d5e2a078b2781f75481b32bda1e21804f720a00287eacb
-  data.tar.gz: 18ca04880e1f4c57308d3442fa4bbb50318121ba9d663ca2858819838ddcd27c118ad79b4767c60708872778deca668b7315f7cad32fdcb951cec2a18dc168ac
+  metadata.gz: d575cb83f4bd7a97d902ad8b15d2da5063ea12edfcadc4d4b6c21f9ea1600413635cb84ee98025747bf49a82a7f97a91a73a5ba6152d7c5095ce19b556c5b7ad
+  data.tar.gz: 19486f04dfeb751f70b8e1c828b6affa6619829f2a467b87070b4c81a38d7656a57d7ceb02d935d1cf33e3bf4fc47f1356769cb27a19ae177a73cd0af86dbb6b

data/docs/USAGE.md

@@ -72,6 +72,13 @@ All incoming keys are normalized to symbols.  All values are stored with a `valu
 
 It's likely preferable to use an environments file to configure the `key_storage` and `cache_storage` to always be an in-memory adapter when running in the test environment instead of manually configuring the storage adapter per spec.
 
+#### TTL in Tests
+In a test environment, unlike in a production environment, database queries are fast, and time doesn't elapse quite like it does in the real world. As tests get more complex, they perform changes for which they expect the cache to expire. However, because of the synthetic nature of testing, TTLs, particularly those on locks, don't quite work the same either.
+
+There are a few approaches to address this, for example, using `sleep` to cause real time to pass (not preferable) or wrapping each test in a TimeCop, forcing time to pass (works but quite manual).
+
+Since this situation is highly likely to arise, `atomic_cache` provides a feature to globally disable enforcing TTL on locks for the `SharedMemory` implementation. Set `enforce_ttl = false` to disable TTL checking on locks within SharedMemory in a test context. This will prevent tests from failing due to unexpired TTLs on locks. 
+
 #### ★ Testing Tip ★
 If using `SharedMemory` for integration style tests, a global `before(:each)` can be configured in `spec_helper.rb`.
 
@@ -79,9 +86,10 @@ If using `SharedMemory` for integration style tests, a global `before(:each)` ca
 # spec/spec_helper.rb
 RSpec.configure do |config|
 
-  #your other config
+  # your other config
 
   config.before(:each) do
+    AtomicCache::Storage::SharedMemory.enforce_ttl = false
     AtomicCache::Storage::SharedMemory.reset
   end
 end

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
 
@@ -146,6 +144,16 @@ module AtomicCache
         if !value.nil?
           metrics(:increment, 'wait.present', tags: metrics_tags)
           return value
+        else
+          # if we didn't get a fresh value this go-round, check if there's a last known value
+          # if expirations were to come in rapidly, it's possible that the expiration which caused
+          # the wait cycle wrote a value, and it's now in LKV, and a new expiration came in, which
+          # has moved the LMT forward
+          value = last_known_value(keyspace, options, tags)
+          if !value.nil?
+            metrics(:increment, 'wait.lkv.present', tags: metrics_tags)
+            return value
+          end
         end
       end
 

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/storage/memory.rb

@@ -16,7 +16,7 @@ module AtomicCache
 
       def add(raw_key, new_value, ttl, user_options={})
         store_op(raw_key, user_options) do |key, options|
-          return false if store.has_key?(key)
+          return false if store.has_key?(key) && !ttl_expired?(store[key])
           write(key, new_value, ttl, user_options)
         end
       end
@@ -29,8 +29,7 @@ module AtomicCache
           unmarshaled = unmarshal(entry[:value], user_options)
           return unmarshaled if entry[:ttl].nil? or entry[:ttl] == false
 
-          life = Time.now - entry[:written_at]
-          if (life >= entry[:ttl])
+          if ttl_expired?(entry)
             store.delete(key)
             nil
           else
@@ -54,6 +53,12 @@ module AtomicCache
 
       protected
 
+      def ttl_expired?(entry)
+        return false unless entry
+        life = Time.now - entry[:written_at]
+        life >= entry[:ttl]
+      end
+
       def write(key, value, ttl=nil, user_options)
         store[key] = {
           value: marshal(value, user_options),

data/lib/atomic_cache/storage/shared_memory.rb

@@ -10,6 +10,21 @@ module AtomicCache
       STORE = {}
       SEMAPHORE = Mutex.new
 
+      @enforce_ttl = true
+      class << self
+        attr_accessor :enforce_ttl
+      end
+
+      def add(raw_key, new_value, ttl, user_options={})
+        if self.class.enforce_ttl
+          super(raw_key, new_value, ttl, user_options)
+        else
+          store_op(raw_key, user_options) do |key, options|
+            write(key, new_value, ttl, user_options)
+          end
+        end
+      end
+
       def self.reset
         STORE.clear
       end

data/lib/atomic_cache/version.rb

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

data/spec/atomic_cache/atomic_cache_client_spec.rb

@@ -163,18 +163,31 @@ describe 'AtomicCacheClient' do
               expect(result).to eq(new_value)
             end
 
+            it 'uses the last known value if the LMT increments while waiting' do
+              key_storage.set(timestamp_manager.last_modified_time_key, '1420090000')
+              key_storage.set(keyspace.last_known_key_key, 'lkk_key')
+              last_known_value = 'value from another thread'
+
+              # fetching the 'fresh' value continually returns nil (because LMT is incrementing forward)
+              allow(cache_storage).to receive(:read)
+                                        .with(timestamp_manager.current_key(keyspace), anything)
+                                        .and_return(nil, nil, nil, nil)
+
+              # multiple returned values are faking what it would look like if another process
+              # promoted a value (wrote LKV) but then the cache expired right after
+              allow(cache_storage).to receive(:read)
+                                        .with(timestamp_manager.last_known_key(keyspace), anything)
+                                        .and_return(nil, nil, nil, last_known_value)
+
+              result = subject.fetch(keyspace, backoff_duration_ms: 5) { 'value from generate' }
+              expect(result).to eq(last_known_value)
+            end
+
             it 'stops waiting when the max retry count is reached' do
               timestamp_manager.promote(keyspace, last_known_key: 'asdf', timestamp: 1420090000)
               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/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')

data/spec/atomic_cache/storage/memory_spec.rb

@@ -17,17 +17,32 @@ shared_examples 'memory storage' do
       expect(result).to eq(true)
     end
 
-    it 'does not write the key if it exists' do
-      entry = { value: Marshal.dump('foo'), ttl: 100, written_at: 100 }
+    it 'does not write the key if it exists but expiration time is NOT up' do
+      entry = { value: Marshal.dump('foo'), ttl: 5000, written_at: Time.local(2021, 1, 1, 12, 0, 0) }
       subject.store[:key] = entry
 
-      result = subject.add('key', 'value', 200)
-      expect(result).to eq(false)
+      Timecop.freeze(Time.local(2021, 1, 1, 12, 0, 1)) do
+        result = subject.add('key', 'value', 5000)
+        expect(result).to eq(false)
+      end
 
       # stored values should not have changed
       expect(subject.store).to have_key(:key)
       expect(Marshal.load(subject.store[:key][:value])).to eq('foo')
-      expect(subject.store[:key][:ttl]).to eq(100)
+    end
+
+    it 'does write the key if it exists and expiration time IS up' do
+      entry = { value: Marshal.dump('foo'), ttl: 50, written_at: Time.local(2021, 1, 1, 12, 0, 0) }
+      subject.store[:key] = entry
+
+      Timecop.freeze(Time.local(2021, 1, 1, 12, 30, 0)) do
+        result = subject.add('key', 'value', 50)
+        expect(result).to eq(true)
+      end
+
+      # stored values should not have changed
+      expect(subject.store).to have_key(:key)
+      expect(Marshal.load(subject.store[:key][:value])).to eq('value')
     end
   end
 

data/spec/atomic_cache/storage/shared_memory_spec.rb

@@ -3,7 +3,21 @@
 require 'spec_helper'
 require_relative 'memory_spec'
 
-describe 'InstanceMemory' do
+describe 'SharedMemory' do
   subject { AtomicCache::Storage::SharedMemory.new }
   it_behaves_like 'memory storage'
+
+  context 'enforce_ttl disabled' do
+    before(:each) do
+      AtomicCache::Storage::SharedMemory.enforce_ttl = false
+    end
+
+    it 'allows instantly `add`ing keys' do
+      subject.add("foo", 1, ttl: 100000)
+      subject.add("foo", 2, ttl: 1)
+
+      expect(subject.store).to have_key(:foo)
+      expect(Marshal.load(subject.store[:foo][:value])).to eq(2)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -17,4 +17,8 @@ RSpec.configure do |config|
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
     expectations.syntax = :expect
   end
+
+  config.before(:each) do
+    AtomicCache::Storage::SharedMemory.enforce_ttl = true
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic_cache
 version: !ruby/object:Gem::Version
-  version: 0.4.0.rc1
+  version: 0.5.2.rc1
 platform: ruby
 authors:
 - Ibotta Developers
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-07 00:00:00.000000000 Z
+date: 2021-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler