atomic_cache 0.3.0.rc1 → 0.4.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: becad2b31944cbd2f93353a4b5e015f8f39c6f508f605f3adcd672fd7e8482b9
-  data.tar.gz: a76b093ad299c779adabe12053731f6582eca33b169a4b05c3a2c619f8747855
+  metadata.gz: 0f8d7906f63f08bf7e8d7b9f9f88d05a209d65c37375c464f60448ffd9db427e
+  data.tar.gz: ac2b7c09f3299ccbb4dcf588cbe163134c8e81b94d79c08fe908afb6200911a7
 SHA512:
-  metadata.gz: 71ea9a439a06adde2a837132820555a564aa2168344a9b9b455fcf04e3293aa3ce147ca9a534ed97266dda92a1db09aa0cc33af22262c6997f8dca334ac0ec66
-  data.tar.gz: 3e4c87333014f120f9ef8055492886734525cbc85ef5245fe87c32a3e908ce0ab059f5ea297a6bc3c2c05517c294ac6ee7891e0caa3d3d4f44db83ea3583fc64
+  metadata.gz: fa4f82e7cd8b729461b5b122a9f9cb92c2c36898c295a63bdd18a510133920ca5694d3e44b9cceceb7d5e2a078b2781f75481b32bda1e21804f720a00287eacb
+  data.tar.gz: 18ca04880e1f4c57308d3442fa4bbb50318121ba9d663ca2858819838ddcd27c118ad79b4767c60708872778deca668b7315f7cad32fdcb951cec2a18dc168ac

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._

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)
 

data/lib/atomic_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtomicCache
-  VERSION = "0.3.0.rc1"
+  VERSION = "0.4.0.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)
@@ -191,17 +180,6 @@ describe 'AtomicCacheClient' do
       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/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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic_cache
 version: !ruby/object:Gem::Version
-  version: 0.3.0.rc1
+  version: 0.4.0.rc1
 platform: ruby
 authors:
 - Ibotta Developers
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-02 00:00:00.000000000 Z
+date: 2021-07-07 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