atomic_cache 0.2.5.rc1 → 0.5.1.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c6e0bf96718fb99b6047009b67c12f3fb4da0b36fd18ba8eb7aded71b744cb2
-  data.tar.gz: 8443307bb59ff3e3ca393cb6401f6c30974ec97bc3729024848be74504c5abda
+  metadata.gz: f03b8f8d9294f3a40ea719ea5165d4c6789c3eebb36459768c8fbd0c57d8fc3a
+  data.tar.gz: b2a320b8323c57785e0202e29d89922b33e63fc9ebd898d6df61f76fb5e2600c
 SHA512:
-  metadata.gz: f438b868a3b60d2d64be72fa314f8cb4ca2a04d9972286d623393bf9754b488577f150d4726c26ee236a0a0cbaae9444fc892fc808b8cda3b23052e2adb8fb8d
-  data.tar.gz: d84517bed76804507f0dc395205eaad4e114e0dfda3023b33f6a1e1191e396d1643b7fb501ebd66e677d8d682ef822b5fa5329660ee5c0c2947d3adb4009c99c
+  metadata.gz: f461c2bf7d903c6f7940334b8f5d11672c7ed04d1d55ad5d25c2337c07906d24a39f8958ddf04a2dd5d5dc690c9a0920121fb99c9f25c809c08959e48ee13ae3
+  data.tar.gz: 9100ad9f5e5012c3729e3bc3a3b95ca64705c562f14e5d610df9f223436ee9351ec58cddc64b61c87c186a588f18e6158e891308aa5d431739f56aa2562744fa

data/README.md

@@ -23,7 +23,7 @@ In a nutshell:
 class Foo < ActiveRecord::Base
   include AtomicCache::GlobalLMTCacheConcern
 
-  cache_class(:custom_foo)  # optional
+  force_cache_class(:custom_foo)  # optional
   cache_version(5)          # optional
 
   def active_foos(ids)

data/docs/MODEL_SETUP.md

@@ -7,13 +7,13 @@ class Foo < ActiveRecord::Base
 end
 ```
 
-### cache_class
+### force_cache_class
 By default the cache identifier for a class is set to the name of a class (ie. `self.to_s`).  In some cases it makes sense to set a custom value for the cache identifier.  In cases where a custom cache identifier is set, it's important that the identifier remain unique across the project.
 
 ```ruby
 class SuperDescriptiveDomainModelAbstractFactoryImplManager < ActiveRecord::Base
   include AtomicCache::GlobalLMTCacheConcern
-  cache_class('sddmafim')
+  force_cache_class('sddmafim')
 end
 ```
 

data/docs/PROJECT_SETUP.md

@@ -23,9 +23,10 @@ AtomicCache::DefaultConfig.configure do |config|
   config.metrics = Datadog::Statsd.new('localhost', 8125, namespace: 'cache.atomic')
 
   # note: these values can also be set in an env file for env-specific settings
-  config.namespace      = 'atom'
-  config.cache_storage  = AtomicCache::Storage::SharedMemory.new
-  config.key_storage    = AtomicCache::Storage::SharedMemory.new
+  config.namespace        = 'atom'
+  config.default_options  = { generate_ttl_ms: 500 }
+  config.cache_storage    = AtomicCache::Storage::SharedMemory.new
+  config.key_storage      = AtomicCache::Storage::SharedMemory.new
 end
 ```
 
@@ -36,7 +37,7 @@ Note that `Datadog::Statsd` is not _required_.  Adding it, however, will enable
   * `key_storage` - Storage adapter for key manager (see below)
 
 #### Optional
-  * `default_options` - Default options for every fetch call.  See [fetch options](/Ibotta/atomic_cache/blob/main/docs/USAGE.md#fetch).
+  * `default_options` - Override default options for every fetch call, unless specified at call site.  See [fetch options](/Ibotta/atomic_cache/blob/main/docs/USAGE.md#fetch).
   * `logger` - Logger instance.  Used for debug and warn logs. Defaults to nil.
   * `timestamp_formatter` - Proc to format last modified time for storage. Defaults to timestamp (`Time.to_i`)
   * `metrics` - Metrics instance. Defaults to nil.
@@ -45,6 +46,49 @@ Note that `Datadog::Statsd` is not _required_.  Adding it, however, will enable
 #### ★ Best Practice ★
 Keep the global namespace short.  For example, memcached has a limit of 250 characters for key length.
 
+#### More Complex Rails Configuration
+
+In any real-world project, the need to run multiple caching strategies or setups is likely to arise. In those cases, it's often advantageous
+to keep a DRY setup, with multiple caching clients sharing the same config. Because Rails initializers run after the environment-specific
+config files, a sane way to manage this is to keep client network settings int he config files, then reference them from the initializer.
+
+```ruby
+# config/environments/staging
+config.memcache_hosts = [ "staging.host.cache.amazonaws.com" ]
+config.cache_store_options = {
+  expires_in: 15.minutes,
+  compress: true,
+  # ...
+}
+
+# config/environments/production
+config.memcache_hosts = [ "prod1.host.cache.amazonaws.com", "prod2.host.cache.amazonaws.com" ]
+config.cache_store_options = {
+  expires_in: 1.hour,
+  compress: true,
+  # ...
+}
+
+# config/initializers/cache.rb
+AtomicCache::DefaultConfig.configure do |config|
+  if Rails.env.development? || Rails.env.test?
+    config.cache_storage  = AtomicCache::Storage::SharedMemory.new
+    config.key_storage    = AtomicCache::Storage::SharedMemory.new
+
+  elsif Rails.env.staging? || Rails.env.production?
+    # Your::Application.config will be loaded by config/environments/*
+    memcache_hosts = Your::Application.config.memcache_hosts
+    options = Your::Application.config.cache_store_options
+    
+    dc = Dalli::Client.new(memcache_hosts, options)
+    config.cache_storage  = AtomicCache::Storage::Dalli.new(dc)
+    config.key_storage    = AtomicCache::Storage::Dalli.new(dc)
+  end
+  
+  # other AtomicCache configuration...
+end
+```
+
 ## Storage Adapters
 
 ### InstanceMemory & SharedMemory

data/docs/USAGE.md

@@ -38,17 +38,6 @@ 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.
 
-#### `quick_retry_ms`
-_`false` to disable. Defaults to false._
-
-In the case where another process is computing the new cache value, before falling back to the last known value, if `quick_retry_ms` has a value the atomic client will check the new cache once after the given duration (in milliseconds).
-
-The danger with `quick_retry_ms` is that when enabled it applies a delay to all fall-through requests at the cost of only benefitting some customers.  As the average generate block duration increases, the effectiveness of `quick_retry_ms` decreases because there is less of a likelihood that a customer will get a fresh value.  Consider the graph below.  For example, a cache with an average generate duration of 200ms, configured with a `quick_retry_ms` of 50ms (red) will only likely get a fresh value for 25% of customers.
-
-`quick_retry_ms` is most effective for caches that are quick to generate but whose values are slow to change.  `quick_retry_ms` is least effective for caches that are slow to update but quick to change.
-
-![quick_retry_ms graph](https://github.com/Ibotta/atomic_cache/raw/ca473f28e179da8c24f638eeeeb48750bc8cbe64/docs/img/quick_retry_graph.png)
-
 #### `max_retries` & `backoff_duration_ms`
 _`max_retries` defaults to 5._
 _`backoff_duration_ms` defaults to 50ms._
@@ -83,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`.
 
@@ -90,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

@@ -6,7 +6,6 @@ require 'active_support/core_ext/hash'
 module AtomicCache
   class AtomicCacheClient
 
-    DEFAULT_quick_retry_ms = false
     DEFAULT_MAX_RETRIES = 5
     DEFAULT_GENERATE_TIME_MS = 30000 # 30 seconds
     BACKOFF_DURATION_MS = 50
@@ -32,7 +31,6 @@ module AtomicCache
     #
     # @param keyspace [AtomicCache::Keyspace] the keyspace to fetch
     # @option options [Numeric] :generate_ttl_ms (30000) Max generate duration in ms
-    # @option options [Numeric] :quick_retry_ms (false) Short duration to check back before using last known value
     # @option options [Numeric] :max_retries (5) Max times to rety in waiting case
     # @option options [Numeric] :backoff_duration_ms (50) Duration in ms to wait between retries
     # @yield Generates a new value when cache is expired
@@ -57,9 +55,8 @@ module AtomicCache
         return new_value unless new_value.nil?
       end
 
-      # quick check back to see if the other process has finished
-      # or fall back to the last known value
-      value = quick_retry(key, options, tags) || last_known_value(keyspace, options, tags)
+      # attempt to fall back to the last known value
+      value = last_known_value(keyspace, options, tags)
       return value if value.present?
 
       # wait for the other process if a last known value isn't there
@@ -109,22 +106,6 @@ module AtomicCache
       nil
     end
 
-    def quick_retry(key, options, tags)
-      duration = option(:quick_retry_ms, options, DEFAULT_quick_retry_ms)
-      if duration.present? and key.present?
-        sleep(duration.to_f / 1000)
-        value = @storage.read(key, options)
-
-        if !value.nil?
-          metrics(:increment, 'empty-cache-retry.present', tags: tags)
-          return value
-        end
-        metrics(:increment, 'empty-cache-retry.not-present', tags: tags)
-      end
-
-      nil
-    end
-
     def last_known_value(keyspace, options, tags)
       lkk = @timestamp_manager.last_known_key(keyspace)
 
@@ -138,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

@@ -26,7 +26,7 @@ module AtomicCache
         end
       end
 
-      def cache_class(kls)
+      def force_cache_class(kls)
         ATOMIC_CACHE_CONCERN_MUTEX.synchronize do
           @atomic_cache_class = kls
         end

data/lib/atomic_cache/key/last_mod_time_key_manager.rb

@@ -59,6 +59,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.2.5.rc1"
+  VERSION = "0.5.1.rc1"
 end

data/spec/atomic_cache/atomic_cache_client_spec.rb

@@ -138,17 +138,6 @@ describe 'AtomicCacheClient' do
             timestamp_manager.lock(keyspace, 100)
           end
 
-          it 'waits for a short duration to see if the other thread generated the value' do
-            timestamp_manager.promote(keyspace, last_known_key: 'lkk', timestamp: 1420090000)
-            key_storage.set('lkk', 'old:value')
-            new_value = 'value from another thread'
-            allow(cache_storage).to receive(:read)
-              .with(timestamp_manager.current_key(keyspace), anything)
-              .and_return(nil, new_value)
-
-            expect(subject.fetch(keyspace, quick_retry_ms: 5) { 'value' }).to eq(new_value)
-          end
-
           context 'when the last known value is present' do
             it 'returns the last known value' do
               timestamp_manager.promote(keyspace, last_known_key: 'lkk', timestamp: 1420090000)
@@ -179,29 +168,11 @@ 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
 
       context 'and when a block is NOT given' do
-        it 'waits for a short duration to see if the other thread generated the value' do
-          timestamp_manager.promote(keyspace, last_known_key: 'asdf', timestamp: 1420090000)
-          new_value = 'value from another thread'
-          allow(cache_storage).to receive(:read)
-            .with(timestamp_manager.current_key(keyspace), anything)
-            .and_return(nil, new_value)
-
-          result = subject.fetch(keyspace, quick_retry_ms: 50)
-          expect(result).to eq(new_value)
-        end
-
         it 'returns nil if nothing is present' do
           expect(subject.fetch(keyspace)).to eq(nil)
         end

data/spec/atomic_cache/concerns/global_lmt_cache_concern_spec.rb

@@ -104,12 +104,12 @@ describe 'AtomicCacheConcern' do
       class Foo2
         include AtomicCache::GlobalLMTCacheConcern
         cache_version(3)
-        cache_class('foo')
+        force_cache_class('foo')
       end
       Foo2
     end
 
-    it 'uses the given version and cache_class become part of the cache keyspace' do
+    it 'uses the given version and force_cache_class become part of the cache keyspace' do
       subject.expire_cache
       expect(key_storage.store).to have_key(:'foo:v3:lmt')
     end

data/spec/atomic_cache/integration/integration_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Integration -' do
+  let(:key_storage) { AtomicCache::Storage::SharedMemory.new }
+  let(:cache_storage) { AtomicCache::Storage::SharedMemory.new }
+  let(:keyspace) { AtomicCache::Keyspace.new(namespace: 'int.waiting') }
+  let(:timestamp_manager) { AtomicCache::LastModTimeKeyManager.new(keyspace: keyspace, storage: key_storage) }
+
+  before(:each) do
+    key_storage.reset
+    cache_storage.reset
+  end
+
+  describe 'fallback:' do
+    let(:generating_client) { AtomicCache::AtomicCacheClient.new(storage: cache_storage, timestamp_manager: timestamp_manager) }
+    let(:fallback_client) { AtomicCache::AtomicCacheClient.new(storage: cache_storage, timestamp_manager: timestamp_manager) }
+
+    it 'falls back to the old value when a lock is present' do
+      old_time = Time.local(2021, 1, 1, 15, 30, 0)
+      new_time = Time.local(2021, 1, 1, 16, 30, 0)
+
+      # prime cache with an old value
+
+      Timecop.freeze(old_time) do
+        generating_client.fetch(keyspace) { "old value" }
+      end
+      timestamp_manager.last_modified_time = new_time
+
+      # start generating process for new time
+      generating_thread = ClientThread.new(generating_client, keyspace)
+      generating_thread.start
+      sleep 0.05
+
+      value = fallback_client.fetch(keyspace)
+      generating_thread.terminate
+
+      expect(value).to eq("old value")
+    end
+  end
+
+  describe 'waiting:' do
+    let(:generating_client) { AtomicCache::AtomicCacheClient.new(storage: cache_storage, timestamp_manager: timestamp_manager) }
+    let(:waiting_client) { AtomicCache::AtomicCacheClient.new(storage: cache_storage, timestamp_manager: timestamp_manager) }
+
+    it 'waits for a key when no last know value is available' do
+      generating_thread = ClientThread.new(generating_client, keyspace)
+      generating_thread.start
+      waiting_thread = ClientThread.new(waiting_client, keyspace)
+      waiting_thread.start
+
+      generating_thread.generate
+      sleep 0.05
+      waiting_thread.fetch
+      sleep 0.05
+      generating_thread.complete
+      sleep 0.05
+
+      generating_thread.terminate
+      waiting_thread.terminate
+
+      expect(generating_thread.result).to eq([1, 2, 3])
+      expect(waiting_thread.result).to eq([1, 2, 3])
+    end
+  end
+end
+
+
+# Avert your eyes:
+# this class allows atomic client interaction to happen asynchronously so that
+# the waiting behavior of the client can be tested simultaneous to controlling how
+# long the 'generate' behavior takes
+#
+# It works by accepting an incoming 'message' which it places onto one of two queues
+class ClientThread
+  attr_reader :result
+
+  # idea: maybe make the return value set when the thread is initialized
+  def initialize(client, keyspace)
+    @keyspace = keyspace
+    @client = client
+    @msg_queue = Queue.new
+    @generate_queue = Queue.new
+    @result = nil
+  end
+
+  def start
+    @thread = Thread.new(&method(:run))
+  end
+
+  def fetch
+    @msg_queue << :fetch
+  end
+
+  def generate
+    @msg_queue << :generate
+  end
+
+  def complete
+    @generate_queue << :complete
+  end
+
+  def terminate
+    @msg_queue << :terminate
+  end
+
+  private
+
+  def run
+    loop do
+      msg = @msg_queue.pop
+      sleep 0.001; next unless msg
+
+      case msg
+      when :terminate
+        Thread.stop
+      when :generate
+        do_generate
+      when :fetch
+        @result = @client.fetch(@keyspace)
+      end
+    end
+  end
+
+  def do_generate
+    @client.fetch(@keyspace) do
+      loop do
+        msg = @generate_queue.pop
+        sleep 0.001; next unless msg
+        break if msg == :complete
+      end
+      @result = [1, 2, 3] # generated value
+      @result
+    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.2.5.rc1
+  version: 0.5.1.rc1
 platform: ruby
 authors:
 - Ibotta Developers
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-28 00:00:00.000000000 Z
+date: 2021-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -185,7 +185,6 @@ files:
 - docs/MODEL_SETUP.md
 - docs/PROJECT_SETUP.md
 - docs/USAGE.md
-- docs/img/quick_retry_graph.png
 - lib/atomic_cache.rb
 - lib/atomic_cache/atomic_cache_client.rb
 - lib/atomic_cache/concerns/global_lmt_cache_concern.rb
@@ -201,7 +200,7 @@ files:
 - spec/atomic_cache/atomic_cache_client_spec.rb
 - spec/atomic_cache/concerns/global_lmt_cache_concern_spec.rb
 - spec/atomic_cache/default_config_spec.rb
-- spec/atomic_cache/integration/waiting_spec.rb
+- spec/atomic_cache/integration/integration_spec.rb
 - spec/atomic_cache/key/keyspace_spec.rb
 - spec/atomic_cache/key/last_mod_time_key_manager_spec.rb
 - spec/atomic_cache/storage/dalli_spec.rb

data/spec/atomic_cache/integration/waiting_spec.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'Integration' do
-  let(:key_storage) { AtomicCache::Storage::SharedMemory.new }
-  let(:cache_storage) { AtomicCache::Storage::SharedMemory.new }
-  let(:keyspace) { AtomicCache::Keyspace.new(namespace: 'int.waiting') }
-  let(:timestamp_manager) { AtomicCache::LastModTimeKeyManager.new(keyspace: keyspace, storage: key_storage) }
-
-  let(:generating_client) { AtomicCache::AtomicCacheClient.new(storage: cache_storage, timestamp_manager: timestamp_manager) }
-  let(:waiting_client) { AtomicCache::AtomicCacheClient.new(storage: cache_storage, timestamp_manager: timestamp_manager) }
-
-  it 'correctly waits for a key when no last know value is available' do
-    generating_thread = ClientThread.new(generating_client, keyspace)
-    generating_thread.start
-    waiting_thread = ClientThread.new(waiting_client, keyspace)
-    waiting_thread.start
-
-    generating_thread.generate
-    sleep 0.05
-    waiting_thread.fetch
-    sleep 0.05
-    generating_thread.complete
-    sleep 0.05
-
-    generating_thread.terminate
-    waiting_thread.terminate
-
-    expect(generating_thread.result).to eq([1, 2, 3])
-    expect(waiting_thread.result).to eq([1, 2, 3])
-  end
-end
-
-
-# Avert your eyes:
-# this class allows atomic client interaction to happen asynchronously so that
-# the waiting behavior of the client can be tested simultaneous to controlling how
-# long the 'generate' behavior takes
-#
-# It works by accepting an incoming 'message' which it places onto one of two queues
-class ClientThread
-  attr_reader :result
-
-  def initialize(client, keyspace)
-    @keyspace = keyspace
-    @client = client
-    @msg_queue = Queue.new
-    @generate_queue = Queue.new
-    @result = nil
-  end
-
-  def start
-    @thread = Thread.new(&method(:run))
-  end
-
-  def fetch
-    @msg_queue << :fetch
-  end
-
-  def generate
-    @msg_queue << :generate
-  end
-
-  def complete
-    @generate_queue << :complete
-  end
-
-  def terminate
-    @msg_queue << :terminate
-  end
-
-  private
-
-  def run
-    loop do
-      msg = @msg_queue.pop
-      sleep 0.001; next unless msg
-
-      case msg
-      when :terminate
-        Thread.stop
-      when :generate
-        do_generate
-      when :fetch
-        @result = @client.fetch(@keyspace)
-      end
-    end
-  end
-
-  def do_generate
-    @client.fetch(@keyspace) do
-      loop do
-        msg = @generate_queue.pop
-        sleep 0.001; next unless msg
-        break if msg == :complete
-      end
-      @result = [1, 2, 3] # generated value
-      @result
-    end
-  end
-end