atomic_cache 0.2.1.rc1 → 0.2.5.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6587484871a77f213f41c540019fbb9e945b8eb5d759bbab2c535e1c1ba58ea
-  data.tar.gz: c1c4377f19df9b28321e5fb6214c8c687bcc9c6857d5b6843663aa068209b932
+  metadata.gz: 5c6e0bf96718fb99b6047009b67c12f3fb4da0b36fd18ba8eb7aded71b744cb2
+  data.tar.gz: 8443307bb59ff3e3ca393cb6401f6c30974ec97bc3729024848be74504c5abda
 SHA512:
-  metadata.gz: fe10e185b34e6b754329c96c37268fa2a66a81a768c0d8c00c32d462034d0eb4f55c709c7356c537c4fb1f5a0a053412f618c73896876da8b20f0279478dadc8
-  data.tar.gz: 1ab35be3c84aca48ea62194a3ec06e7481681989a36866304e4fa70f9a48eeb54d08c12ba344a0c85afc5f6a1773009ef47f414209c628d18d0956dd78297c80
+  metadata.gz: f438b868a3b60d2d64be72fa314f8cb4ca2a04d9972286d623393bf9754b488577f150d4726c26ee236a0a0cbaae9444fc892fc808b8cda3b23052e2adb8fb8d
+  data.tar.gz: d84517bed76804507f0dc395205eaad4e114e0dfda3023b33f6a1e1191e396d1643b7fb501ebd66e677d8d682ef822b5fa5329660ee5c0c2947d3adb4009c99c

data/docs/USAGE.md

@@ -21,6 +21,14 @@ end
 
 In addition to the below options, any other options given (e.g. `expires_in`, `cache_nils`) are passed through to the underlying storage adapter.  This allows storage-specific options to be passed through (reference: [Dalli config](https://github.com/petergoldstein/dalli#configuration)).
 
+#### TTL
+Various storage clients require TTL to be expressed in different ways. The included storage adapters will unwrap the `ttl` option to an storage-specific representation.
+```ruby
+atomic_cache.fetch(ttl: 500) do
+  # generate block
+end
+```
+
 #### `generate_ttl_ms`
 _Defaults to 30 seconds._
 

data/lib/atomic_cache/atomic_cache_client.rb

@@ -27,7 +27,6 @@ module AtomicCache
       raise ArgumentError.new("`storage` required but none given") unless @storage.present?
     end
 
-
     # Attempts to fetch the given keyspace, using an optional block to generate
     # a new value when the cache is expired
     #
@@ -45,6 +44,7 @@ module AtomicCache
       value = @storage.read(key, options) if key.present?
       if !value.nil?
         metrics(:increment, 'read.present', tags: tags)
+        log(:debug, "Read value from key: '#{key}'")
         return value
       end
 
@@ -59,13 +59,13 @@ module AtomicCache
 
       # quick check back to see if the other process has finished
       # or fall back to the last known value
-      value = quick_retry(keyspace, options, tags) || last_known_value(keyspace, options, tags)
+      value = quick_retry(key, options, tags) || last_known_value(keyspace, options, tags)
       return value if value.present?
 
       # wait for the other process if a last known value isn't there
       if key.present?
         return time('wait.run', tags: tags) do
-          wait_for_new_value(key, options, tags)
+          wait_for_new_value(keyspace, options, tags)
         end
       end
 
@@ -109,10 +109,8 @@ module AtomicCache
       nil
     end
 
-    def quick_retry(keyspace, options, tags)
-      key = @timestamp_manager.current_key(keyspace)
+    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)
@@ -136,6 +134,7 @@ module AtomicCache
         # last known key may have expired
         if !lkv.nil?
           metrics(:increment, 'last-known-value.present', tags: tags)
+          log(:debug, "Read value from last known value key: '#{lkk}'")
           return lkv
         end
 
@@ -149,7 +148,7 @@ module AtomicCache
       nil
     end
 
-    def wait_for_new_value(key, options, tags)
+    def wait_for_new_value(keyspace, options, tags)
       max_retries = option(:max_retries, options, DEFAULT_MAX_RETRIES)
       max_retries.times do |attempt|
         metrics_tags = tags.clone.push("attempt:#{attempt}")
@@ -160,6 +159,8 @@ module AtomicCache
         backoff_duration_ms = option(:backoff_duration_ms, options, backoff_duration_ms)
         sleep((backoff_duration_ms.to_f / 1000) * attempt)
 
+        # re-fetch the key each time, to make sure we're actually getting the latest key with the correct LMT
+        key = @timestamp_manager.current_key(keyspace)
         value = @storage.read(key, options)
         if !value.nil?
           metrics(:increment, 'wait.present', tags: metrics_tags)
@@ -168,7 +169,7 @@ module AtomicCache
       end
 
       metrics(:increment, 'wait.give-up')
-      log(:warn, "Giving up fetching cache key `#{key}`. Exceeded max retries (#{max_retries}).")
+      log(:warn, "Giving up waiting. Exceeded max retries (#{max_retries}).")
       nil
     end
 

data/lib/atomic_cache/storage/dalli.rb

@@ -10,10 +10,6 @@ module AtomicCache
     class Dalli < Store
       extend Forwardable
 
-      ADD_SUCCESS = 'STORED'
-      ADD_UNSUCCESSFUL = 'NOT_STORED'
-      ADD_EXISTS = 'EXISTS'
-
       def_delegators :@dalli_client, :delete
 
       def initialize(dalli_client)
@@ -27,16 +23,17 @@ module AtomicCache
         # dalli expects time in seconds
         # https://github.com/petergoldstein/dalli/blob/b8f4afe165fb3e07294c36fb1c63901b0ed9ce10/lib/dalli/client.rb#L27
         # TODO: verify this unit is being treated correctly through the system
-        response = @dalli_client.add(key, new_value, ttl, opts)
-        response.start_with?(ADD_SUCCESS)
+        !!@dalli_client.add(key, new_value, ttl, opts)
       end
 
       def read(key, user_options={})
-        @dalli_client.read(key, user_options)
+        @dalli_client.get(key, user_options)
       end
 
       def set(key, value, user_options={})
-        @dalli_client.set(key, value, user_options)
+        ttl = user_options[:ttl]
+        user_options.delete(:ttl)
+        !!@dalli_client.set(key, value, ttl, user_options)
       end
 
     end

data/lib/atomic_cache/version.rb

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

data/spec/atomic_cache/default_config_spec.rb

@@ -10,8 +10,13 @@ describe 'DefaultConfig' do
       subject.configure do |manager|
         manager.namespace = 'foo'
       end
-
       expect(subject.instance.namespace).to eq('foo')
+
+      # change it a 2nd time to make sure it sticks
+      subject.configure do |manager|
+        manager.namespace = 'bar'
+      end
+      expect(subject.instance.namespace).to eq('bar')
     end
   end
 end

data/spec/atomic_cache/integration/waiting_spec.rb

@@ -0,0 +1,102 @@
+# 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

data/spec/atomic_cache/storage/dalli_spec.rb

@@ -13,13 +13,20 @@ describe 'Dalli' do
   let(:dalli_client) { FakeDalli.new }
   subject { AtomicCache::Storage::Dalli.new(dalli_client) }
 
-  it 'delegates #set without options' do
-    expect(dalli_client).to receive(:set).with('key', 'value', {})
-    subject.set('key', 'value')
+  context '#set' do
+    it 'delegates #set without options' do
+      expect(dalli_client).to receive(:set).with('key', 'value', nil, {})
+      subject.set('key', 'value')
+    end
+
+    it 'delegates #set with TTL' do
+      expect(dalli_client).to receive(:set).with('key', 'value', 500, {})
+      subject.set('key', 'value', { ttl: 500 })
+    end
   end
 
   it 'delegates #read without options' do
-    expect(dalli_client).to receive(:read).with('key', {}).and_return('asdf')
+    expect(dalli_client).to receive(:get).with('key', {}).and_return('asdf')
     subject.read('key')
   end
 
@@ -30,7 +37,7 @@ describe 'Dalli' do
 
   context '#add' do
     before(:each) do
-      allow(dalli_client).to receive(:add).and_return('NOT_STORED\r\n')
+      allow(dalli_client).to receive(:add).and_return(false)
     end
 
     it 'delegates to #add with the raw option set' do
@@ -40,22 +47,17 @@ describe 'Dalli' do
     end
 
     it 'returns true when the add is successful' do
-      expect(dalli_client).to receive(:add).and_return('STORED\r\n')
+      expect(dalli_client).to receive(:add).and_return(12339031748204560384)
       result = subject.add('key', 'value', 100)
       expect(result).to eq(true)
     end
 
     it 'returns false if the key already exists' do
-      expect(dalli_client).to receive(:add).and_return('EXISTS\r\n')
+      expect(dalli_client).to receive(:add).and_return(false)
       result = subject.add('key', 'value', 100)
       expect(result).to eq(false)
     end
 
-    it 'returns false if the add fails' do
-      expect(dalli_client).to receive(:add).and_return('NOT_STORED\r\n')
-      result = subject.add('key', 'value', 100)
-      expect(result).to eq(false)
-    end
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic_cache
 version: !ruby/object:Gem::Version
-  version: 0.2.1.rc1
+  version: 0.2.5.rc1
 platform: ruby
 authors:
 - Ibotta Developers
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-09 00:00:00.000000000 Z
+date: 2021-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -171,7 +171,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
-description: desc
+description: A gem which prevents the thundering herd problem through a distributed
+  lock
 email: osscompliance@ibotta.com
 executables: []
 extensions: []
@@ -200,6 +201,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/key/keyspace_spec.rb
 - spec/atomic_cache/key/last_mod_time_key_manager_spec.rb
 - spec/atomic_cache/storage/dalli_spec.rb
@@ -229,5 +231,9 @@ requirements: []
 rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
-summary: summary
+summary: In a nutshell:* The key of every cached value includes a timestamp* Once
+  a cache key is written to, it is never written over* When a newer version of a cached
+  value is available, it is written to a new key* When a new value is being generated
+  for a new key only 1 process is allowed to do so at a time* While the new value
+  is being generated, other processes read one key older than most recent
 test_files: []