atomic_cache 0.1.0.rc2 → 0.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86d21873e0440ffb327b3d9e6de724ffff524d7075c5f4588e4a4c46042cf47a
-  data.tar.gz: 956391de071f7997ccd078157449634436e3ed6316215bf6319e830c979fe0d0
+  metadata.gz: 4534d927a8015f910a8f6a330f5a49ffc2e96931b968bdafe123c104f50ee159
+  data.tar.gz: c8b834855c70ae59b272efd57eb9f491db734b90280a3d20f14ba4b56fe26786
 SHA512:
-  metadata.gz: 72eca9fdf5c4018f8934917219abb4ccde4cba7fae17482550b2087673eacec18cae5e5cb6686a00fb317424bae379ddb83cfc50f767ae456b936ac71fe8a702
-  data.tar.gz: 4739607a81c343ba2b73de9f7e36d18d4c1a76969f51d7ab4c3cbbdf54fb3274e6bc9d0244a75e8b4a8fada4aea59aa0ce5b05ed397085a5ef606fe801afd233
+  metadata.gz: d1f49452ff1cf04f665112f39232749ec595bb6ac3a45f13ee178d52fe0e9581e594466f2936e542495f6dfda5b665617a77aebbd70e320b7a137d551fe1bf13
+  data.tar.gz: 113adcfe789cd195283c3bf2db1691c0724cf2b9e9fb5d1e3ac13bc93d401faac47b6206c54e8da045d666d27c913f617e931aa77e18b7f36c7a39b9cc2a41db

data/README.md

@@ -28,7 +28,7 @@ class Foo < ActiveRecord::Base
 
   def active_foos(ids)
     keyspace = cache_keyspace(:activeids, ids)
-    AtomicCache.fetch(keyspace, expires_in: 5.minutes) do
+    atomic_cache.fetch(keyspace, expires_in: 5.minutes) do
       Foo.active.where(id: ids.uniq)
     end
 

data/docs/PROJECT_SETUP.md

@@ -19,9 +19,13 @@ require 'datadog/statsd'
 require 'atomic_cache'
 
 AtomicCache::DefaultConfig.configure do |config|
-  config.logger    = Rails.logger
-  config.metrics   = Datadog::Statsd.new('localhost', 8125, namespace: 'cache.atomic')
-  config.namespace = 'atom'
+  config.logger  = Rails.logger
+  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
 end
 ```
 
@@ -32,7 +36,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 [options](TODO: LINK).
+  * `default_options` - Default options for every fetch call.  See [fetch options](/Ibotta/atomic_cache/blob/master/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.

data/docs/USAGE.md

@@ -11,10 +11,10 @@ expire_cache(Time.now - 100) # an optional time can be given
 The concern makes a `last_modified_time` method available both on the class and on the instance.
 
 ### Fetch
-The concern makes a `AtomicCache` object available both on the class and on the instance.
+The concern makes a `atomic_cache` object available both on the class and on the instance.
 
 ```ruby
-AtomicCache.fetch(options) do
+atomic_cache.fetch(options) do
   # generate block
 end
 ```

data/lib/atomic_cache/atomic_cache_client.rb

@@ -37,8 +37,7 @@ module AtomicCache
     # @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
-    def fetch(keyspace, options=nil)
-      options ||= {}
+    def fetch(keyspace, options={})
       key = @timestamp_manager.current_key(keyspace)
       tags = ["cache_keyspace:#{keyspace.root}"]
 

data/lib/atomic_cache/concerns/global_lmt_cache_concern.rb

@@ -15,7 +15,7 @@ module AtomicCache
 
     class_methods do
 
-      def AtomicCache
+      def atomic_cache
         init_atomic_cache
         @atomic_cache
       end
@@ -91,8 +91,8 @@ module AtomicCache
       end
     end
 
-    def AtomicCache
-      self.class.AtomicCache
+    def atomic_cache
+      self.class.atomic_cache
     end
 
     def cache_keyspace(ns)

data/lib/atomic_cache/key/last_mod_time_key_manager.rb

@@ -54,7 +54,7 @@ module AtomicCache
     # @param keyspace [AtomicCache::Keyspace] keyspace to lock
     # @param ttl [Numeric] the duration in ms to lock (auto expires after duration is up)
     # @param options [Hash] options to pass to the storage adapter
-    def lock(keyspace, ttl, options=nil)
+    def lock(keyspace, ttl, options={})
       @storage.add(keyspace.lock_key, LOCK_VALUE, ttl, options)
     end
 

data/lib/atomic_cache/storage/dalli.rb

@@ -20,8 +20,8 @@ module AtomicCache
         @dalli_client = dalli_client
       end
 
-      def add(key, new_value, ttl, user_options=nil)
-        opts = user_options&.clone || {}
+      def add(key, new_value, ttl, user_options={})
+        opts = user_options.clone
         opts[:raw] = true
 
         # dalli expects time in seconds
@@ -31,13 +31,11 @@ module AtomicCache
         response.start_with?(ADD_SUCCESS)
       end
 
-      def read(key, user_options=nil)
-        user_options ||= {}
+      def read(key, user_options={})
         @dalli_client.read(key, user_options)
       end
 
-      def set(key, value, user_options=nil)
-        user_options ||= {}
+      def set(key, value, user_options={})
         @dalli_client.set(key, value, user_options)
       end
 

data/lib/atomic_cache/storage/instance_memory.rb

@@ -21,14 +21,13 @@ module AtomicCache
         @store
       end
 
-      def store_op(key, user_options=nil)
+      def store_op(key, user_options={})
         if !key.present?
           desc = if key.nil? then 'Nil' else 'Empty' end
           raise ArgumentError.new("#{desc} key given for storage operation") unless key.present?
         end
 
         normalized_key = key.to_sym
-        user_options ||= {}
         yield(normalized_key, user_options)
       end
 

data/lib/atomic_cache/storage/memory.rb

@@ -12,35 +12,36 @@ module AtomicCache
       def store; raise NotImplementedError end
 
       # @abstract implement performing an operation on the store
-      def store_op(key, user_options=nil); raise NotImplementedError end
+      def store_op(key, user_options={}); raise NotImplementedError end
 
-      def add(raw_key, new_value, ttl, user_options=nil)
+      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)
-          write(key, new_value, ttl)
+          write(key, new_value, ttl, user_options)
         end
       end
 
-      def read(raw_key, user_options=nil)
+      def read(raw_key, user_options={})
         store_op(raw_key, user_options) do |key, options|
           entry = store[key]
           return nil unless entry.present?
 
-          return entry[:value] if entry[:ttl].nil? or entry[:ttl] == false
+          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])
             store.delete(key)
             nil
           else
-            entry[:value]
+            unmarshaled
           end
         end
       end
 
-      def set(raw_key, new_value, user_options=nil)
+      def set(raw_key, new_value, user_options={})
         store_op(raw_key, user_options) do |key, options|
-          write(key, new_value, options[:expires_in])
+          write(key, new_value, options[:expires_in], user_options)
         end
       end
 
@@ -51,12 +52,11 @@ module AtomicCache
         end
       end
 
-      def write(key, value, ttl=nil)
-        stored_value = value.to_s
-        stored_value = nil if value.nil?
+      protected
 
+      def write(key, value, ttl=nil, user_options)
         store[key] = {
-          value: stored_value,
+          value: marshal(value, user_options),
           ttl: ttl || false,
           written_at: Time.now
         }

data/lib/atomic_cache/storage/shared_memory.rb

@@ -26,10 +26,8 @@ module AtomicCache
         STORE
       end
 
-      def store_op(key, user_options=nil)
+      def store_op(key, user_options={})
         normalized_key = key.to_sym
-        user_options ||= {}
-
         SEMAPHORE.synchronize do
           yield(normalized_key, user_options)
         end

data/lib/atomic_cache/storage/store.rb

@@ -26,6 +26,18 @@ module AtomicCache
       # returns true if it succeeds; false otherwise
       def delete(key, user_options); raise NotImplementedError end
 
+      protected
+
+      def marshal(value, user_options={})
+        return value if user_options[:raw]
+        Marshal.dump(value)
+      end
+
+      def unmarshal(value, user_options={})
+        return value if user_options[:raw]
+        Marshal.load(value)
+      end
+
     end
   end
 end

data/lib/atomic_cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtomicCache
-  VERSION = "0.1.0.rc2"
+  VERSION = "0.2.0.rc1"
 end

data/spec/atomic_cache/atomic_cache_client_spec.rb

@@ -86,7 +86,7 @@ describe 'AtomicCacheClient' do
             Timecop.freeze(time) do
               subject.fetch(keyspace) { 'value from block' }
               lmt = key_storage.read(timestamp_manager.last_modified_time_key)
-              expect(lmt).to eq(time.to_i.to_s)
+              expect(lmt).to eq(time.to_i)
             end
           end
 

data/spec/atomic_cache/concerns/global_lmt_cache_concern_spec.rb

@@ -9,7 +9,12 @@ describe 'AtomicCacheConcern' do
   subject do
     class Foo1
       include AtomicCache::GlobalLMTCacheConcern
+
+      def example_method
+        atomic_cache.fetch(cache_keyspace(:foo)) { 'bar' }
+      end
     end
+    Foo1
   end
 
   before(:context) do
@@ -26,17 +31,21 @@ describe 'AtomicCacheConcern' do
     cache_storage.reset
   end
 
-  context 'AtomicCache' do
+  context 'atomic_cache' do
     it 'initializes a cache client' do
-      expect(subject).to respond_to(:AtomicCache)
-      expect(subject.AtomicCache).to be_a(AtomicCacheClient)
-      expect(subject.new.AtomicCache).to be_a(AtomicCacheClient)
+      expect(subject).to respond_to(:atomic_cache)
+      expect(subject.atomic_cache).to be_a(AtomicCacheClient)
+      expect(subject.new.atomic_cache).to be_a(AtomicCacheClient)
     end
 
     it 'uses the name of the class in the default keyspace' do
       subject.expire_cache
       expect(key_storage.store).to have_key(:'foo1:lmt')
     end
+
+    it 'allows methods to be defined that utilize the cache' do
+      expect(subject.new.example_method).to eq('bar')
+    end
   end
 
   context '#expire_cache' do
@@ -44,7 +53,7 @@ describe 'AtomicCacheConcern' do
       time = Time.local(2018, 1, 1, 15, 30, 0)
       subject.expire_cache(time)
       expect(key_storage.store).to have_key(:'foo1:lmt')
-      expect(key_storage.store[:'foo1:lmt'][:value]).to eq(time.to_i.to_s)
+      expect(key_storage.read(:'foo1:lmt')).to eq(time.to_i)
     end
 
     it 'expires all the keyspaces for this class' do
@@ -54,8 +63,8 @@ describe 'AtomicCacheConcern' do
       ns2 = subject.cache_keyspace(:buz)
 
       Timecop.freeze(old_time) do
-        subject.AtomicCache.fetch(ns1) { 'bar' }
-        subject.AtomicCache.fetch(ns2) { 'buz' }
+        subject.atomic_cache.fetch(ns1) { 'bar' }
+        subject.atomic_cache.fetch(ns2) { 'buz' }
       end
 
       Timecop.freeze(new_time) do
@@ -66,8 +75,8 @@ describe 'AtomicCacheConcern' do
         cache_storage.set("foo1:bar:#{lmt}", 'new-bar')
         cache_storage.set("foo1:buz:#{lmt}", 'new-buz')
 
-        ns1_value = subject.AtomicCache.fetch(ns1)
-        ns2_value = subject.AtomicCache.fetch(ns2)
+        ns1_value = subject.atomic_cache.fetch(ns1)
+        ns2_value = subject.atomic_cache.fetch(ns2)
 
         expect(ns1_value).to eq('new-bar')
         expect(ns2_value).to eq('new-buz')
@@ -110,7 +119,7 @@ describe 'AtomicCacheConcern' do
     end
 
     it 'sets the storage for the class' do
-      cache_store = subject.AtomicCache.instance_variable_get(:@storage)
+      cache_store = subject.atomic_cache.instance_variable_get(:@storage)
       expect(cache_store).to eq('valuestore')
 
       key_store = subject.instance_variable_get(:@timestamp_manager).instance_variable_get(:@storage)

data/spec/atomic_cache/key/last_mod_time_key_manager_spec.rb

@@ -42,22 +42,22 @@ describe 'LastModTimeKeyManager' do
 
   it 'promotes a timestamp and last known key' do
     subject.promote(req_keyspace, last_known_key: 'asdf', timestamp: timestamp)
-    expect(storage.store[:'ns:lkk'][:value]).to eq('asdf')
-    expect(storage.store[:'ts:lmt'][:value]).to eq(timestamp.to_s)
-    expect(subject.last_modified_time).to eq(timestamp.to_s)
+    expect(storage.read(:'ns:lkk')).to eq('asdf')
+    expect(storage.read(:'ts:lmt')).to eq(timestamp)
+    expect(subject.last_modified_time).to eq(timestamp)
   end
 
   context '#last_modified_time=' do
     it 'returns the last modified time' do
       subject.last_modified_time = timestamp
-      expect(storage.store[:'ts:lmt'][:value]).to eq(timestamp.to_s)
-      expect(subject.last_modified_time).to eq(timestamp.to_s)
+      expect(storage.read(:'ts:lmt')).to eq(timestamp)
+      expect(subject.last_modified_time).to eq(timestamp)
     end
 
     it 'formats Time' do
       now = Time.now
       subject.last_modified_time = now
-      expect(subject.last_modified_time).to eq(now.to_i.to_s)
+      expect(subject.last_modified_time).to eq(now.to_i)
     end
   end
 

data/spec/atomic_cache/storage/dalli_spec.rb

@@ -19,7 +19,7 @@ describe 'Dalli' do
   end
 
   it 'delegates #read without options' do
-    expect(dalli_client).to receive(:read).with('key', {})
+    expect(dalli_client).to receive(:read).with('key', {}).and_return('asdf')
     subject.read('key')
   end
 

data/spec/atomic_cache/storage/memory_spec.rb

@@ -12,13 +12,13 @@ shared_examples 'memory storage' do
       result = subject.add('key', 'value', 100)
 
       expect(subject.store).to have_key(:key)
-      expect(subject.store[:key][:value]).to eq('value')
+      expect(Marshal.load(subject.store[:key][:value])).to eq('value')
       expect(subject.store[:key][:ttl]).to eq(100)
       expect(result).to eq(true)
     end
 
     it 'does not write the key if it exists' do
-      entry = { value: 'foo', ttl: 100, written_at: 100 }
+      entry = { value: Marshal.dump('foo'), ttl: 100, written_at: 100 }
       subject.store[:key] = entry
 
       result = subject.add('key', 'value', 200)
@@ -26,28 +26,44 @@ shared_examples 'memory storage' do
 
       # stored values should not have changed
       expect(subject.store).to have_key(:key)
-      expect(subject.store[:key][:value]).to eq('foo')
+      expect(Marshal.load(subject.store[:key][:value])).to eq('foo')
       expect(subject.store[:key][:ttl]).to eq(100)
     end
   end
 
   context '#read' do
     it 'returns values' do
-      subject.store[:sugar] = { value: 'foo' }
+      subject.store[:sugar] = { value: Marshal.dump('foo') }
       expect(subject.read('sugar')).to eq('foo')
     end
 
     it 'respects TTL' do
-      subject.store[:sugar] = { value: 'foo', ttl: 100, written_at: Time.now - 1000 }
+      subject.store[:sugar] = { value: Marshal.dump('foo'), ttl: 100, written_at: Time.now - 1000 }
       expect(subject.read('sugar')).to eq(nil)
     end
+
+    it 'returns complex objects' do
+      class ComplexObject
+        attr_accessor :foo, :bar
+      end
+
+      obj = ComplexObject.new
+      obj.foo = 'f'
+      obj.bar = [1,2,3]
+
+      subject.set(:complex, obj)
+
+      obj2 = subject.read(:complex)
+      expect(obj2.foo).to eql('f')
+      expect(obj2.bar).to eql([1,2,3])
+    end
   end
 
   context '#set' do
     it 'adds the value when not present' do
       subject.set(:cane, 'v', expires_in: 100)
       expect(subject.store).to have_key(:cane)
-      expect(subject.store[:cane][:value]).to eq('v')
+      expect(Marshal.load(subject.store[:cane][:value])).to eq('v')
       expect(subject.store[:cane][:ttl]).to eq(100)
     end
 
@@ -56,14 +72,14 @@ shared_examples 'memory storage' do
 
       subject.set(:cane, 'v', expires_in: 100)
       expect(subject.store).to have_key(:cane)
-      expect(subject.store[:cane][:value]).to eq('v')
+      expect(Marshal.load(subject.store[:cane][:value])).to eq('v')
       expect(subject.store[:cane][:ttl]).to eq(100)
     end
   end
 
   context '#delete' do
     it 'deletes the key' do
-      subject.store[:record] = { value: 'foo', written_at: 500 }
+      subject.store[:record] = { value: Marshal.dump('foo'), written_at: 500 }
       subject.delete('record')
       expect(subject.store).to_not have_key(:record)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: atomic_cache
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc2
+  version: 0.2.0.rc1
 platform: ruby
 authors:
 - Ibotta Developers
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-23 00:00:00.000000000 Z
+date: 2018-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler