readthis 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 513263f9ac89cdc3d8bfc354404778e49902460b
-  data.tar.gz: 525ab985b197507e19c000bcb6dc21683ba068d9
+  metadata.gz: dd2e3cdc15043b250cf043b45d05cc991297114b
+  data.tar.gz: 67ed2a3248bb47a61cef51f3d5af65c56a4d043b
 SHA512:
-  metadata.gz: f9207fe0c1d9746337d17ac05a23acd4bfde8c9d943d1814daa7426160a39fb8d932ea2fd7c69e898097afdf0427eab59cfad320362053547d4e40b3f2a4d4ee
-  data.tar.gz: 14ae7680da85fe6591cc6b623c9f13e2c11dd7905add114288d6ed4138490b4a63a67d0832d0069706246cac73f5fe9de14774f0316e4a4db933ed418e6c60aa
+  metadata.gz: 71eed4853e2cbf4d7e1832a8399ff06ed9ce3fbb2aca120f6ff10ec60c61470dedd96b1096d712a7df47fd47a828f91b60cd7d70c80de87bbdbb7d4d771f2264
+  data.tar.gz: abc9ce7f90b7fd0d4be2c340781bf1087b3f9d34a431dfcee81b5125d0c839d82b7cf703e06e3ed061ad8f2df43f63944f7297370d8fc2631f7d3a9d46dab888

data/CHANGELOG.md

@@ -1,8 +1,17 @@
+## v0.3.0 2014-12-01
+
+- Added: Use `to_param` for key expansion, only when available. Makes it
+  possible to extract a key from any object when ActiveSupport is loaded.
+- Added: Expand hashes as cache keys.
+- Changed: Use `mget` for `read_multi`, faster and more synchronous than relying on
+  `pipelined`.
+- Changed: Delimit compound objects with a slash rather than a colon.
+
 ## v0.2.0 2014-11-24
 
-- Instrument all caching methods. Will use `ActiveSupport::Notifications`
+- Added: Instrument all caching methods. Will use `ActiveSupport::Notifications`
   if available, otherwise falls back to a polyfill.
-- Expand objects with a `cache_key` method and arrays of strings or objects into
+- Added: Expand objects with a `cache_key` method and arrays of strings or objects into
   consistent naespaced keys.
 
 ## v0.1.0 2014-11-22

data/CONTRIBUTING.md

@@ -0,0 +1,14 @@
+# Contributing
+
+## Open an Issue
+
+Let us know about bugs. Include your version of Readthis, Ruby, and the
+environment you are using.
+
+## Submit a Pull Request
+
+1. Fork it ( https://github.com/sorentwo/readthis/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Gemfile

@@ -1,4 +1,9 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in readthis.gemspec
 gemspec
+
+group :benchmarking do
+  gem 'benchmark-ips'
+  gem 'dalli'
+  gem 'redis-activesupport', github: 'sorentwo/redis-activesupport'
+end

data/README.md

@@ -1,12 +1,58 @@
 [![Gem Version](https://badge.fury.io/rb/readthis.svg)](http://badge.fury.io/rb/readthis)
 [![Build Status](https://travis-ci.org/sorentwo/readthis.svg?branch=master)](https://travis-ci.org/sorentwo/readthis)
+[![Code Climate](https://codeclimate.com/github/sorentwo/readthis/badges/gpa.svg)](https://codeclimate.com/github/sorentwo/readthis)
 
 # Readthis
 
-An ActiveSupport::Cache compatible redis based cache focused on speed,
-simplicity, and forced pooling.
+Readthis is a drop in replacement for any ActiveSupport compliant cache, but
+emphasizes performance and simplicity. It takes some cues from Dalli (connection
+pooling), the popular Memcache client. Below are some performance comparisons
+against the only other notable redis cache implementation, `redis-activesupport`,
+which has been abandoned and doesn't actually comply to Rails 4.2 cache store
+behavior for `fetch_multi`.
 
-The only dependencies are `redis` and `connection_pool`.
+## Footprint & Performance
+
+Footprint compared to `redis-activesupport`:
+
+```
+# Total allocated objects after require
+readthis: 19,964
+redis-activesupport: 78,630
+```
+
+Performance compared to `dalli` and `redis-activesupport` for \*multi
+operations:
+
+```
+Calculating -------------------------------------
+ readthis:read-multi   118.000  i/100ms
+  redisas:read-multi    94.000  i/100ms
+    dalli:read-multi    92.000  i/100ms
+-------------------------------------------------
+ readthis:read-multi      1.206k (± 4.6%) i/s -      6.018k
+  redisas:read-multi    973.086  (± 4.4%) i/s -      4.888k
+    dalli:read-multi    949.348  (± 4.1%) i/s -      4.784k
+
+Comparison:
+ readthis:read-multi:     1206.0 i/s
+  redisas:read-multi:      973.1 i/s - 1.24x slower
+    dalli:read-multi:      949.3 i/s - 1.27x slower
+
+Calculating -------------------------------------
+readthis:fetch-multi   114.000  i/100ms
+ redisas:fetch-multi    82.000  i/100ms
+   dalli:fetch-multi    97.000  i/100ms
+-------------------------------------------------
+readthis:fetch-multi      1.157k (± 5.0%) i/s -      5.814k
+ redisas:fetch-multi    829.211  (± 4.2%) i/s -      4.182k
+   dalli:fetch-multi    979.081  (± 3.8%) i/s -      4.947k
+
+Comparison:
+readthis:fetch-multi:     1157.2 i/s
+   dalli:fetch-multi:      979.1 i/s - 1.18x slower
+ redisas:fetch-multi:      829.2 i/s - 1.40x slower
+```
 
 ## Installation
 
@@ -18,20 +64,38 @@ gem 'readthis'
 
 ## Usage
 
-Use it the same way as any other [ActiveSupport::Cache::Store][store]. Readthis
-supports all of the standard cache methods except for the following (with
-reasons):
+Use it the same way as any other [ActiveSupport::Cache::Store][store]. Within a
+rails environment config:
 
-* `cleanup` - redis does this with ttl for us already
-* `delete_matched` - you really don't want to do perform key matching operations
-  in redis. They are linear time and only support basic globbing.
+```ruby
+config.cache_store = :readthis_store, ENV.fetch('REDIS_URL'), {
+  expires_in: 2.weeks,
+  namespace: 'cache'
+}
+```
+
+Otherwise you can use it anywhere, without any reliance on ActiveSupport:
 
-## Contributing
+```ruby
+require 'readthis'
 
-1. Fork it ( https://github.com/[my-github-username]/readthis/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+cache = Readthis::Cache.new(ENV.fetch('REDIS_URL'), expires_in: 2.weeks)
+```
+
+You'll want to use a specific database for caching, just in case you need to
+clear the cache entirely. Appending a number between 0 and 15 will specify the
+redis database, which defaults to 0. For example, using database 2:
+
+```
+REDIS_URL=redis://localhost:6379/2
+```
+
+## Differences
+
+Readthis supports all of standard cache methods except for the following:
+
+* `cleanup` - redis does this with ttl for us already
+* `delete_matched` - you really don't want to perform key matching operations
+  in redis. They are linear time and only support basic globbing.
 
 [store]: http://api.rubyonrails.org/classes/ActiveSupport/Cache/Store.html

data/benchmarks/memory.rb

@@ -0,0 +1,11 @@
+require 'bundler'; Bundler.setup
+a = GC.stat(:total_allocated_object)
+
+require 'readthis'
+b = GC.stat(:total_allocated_object)
+
+require 'redis-activesupport'
+c = GC.stat(:total_allocated_object)
+
+puts "readthis: #{b - a}"
+puts "redis-activesupport: #{c - b}"

data/benchmarks/multi.rb

@@ -0,0 +1,52 @@
+require 'bundler'
+
+Bundler.setup
+
+require 'benchmark/ips'
+require 'dalli'
+require 'redis-activesupport'
+require 'active_support/cache/dalli_store'
+require 'readthis'
+
+redis_url = 'redis://localhost:6379/11'
+dalli     = ActiveSupport::Cache::DalliStore.new('localhost', namespace: 'da', pool_size: 5)
+redisas   = ActiveSupport::Cache::RedisStore.new(redis_url + '/ra')
+readthis  = Readthis::Cache.new(redis_url, namespace: 'rd', expires_in: 60)
+
+('a'..'z').each do |key|
+  dalli.write(key, key * 1024)
+  readthis.write(key, key * 1024)
+  redisas.write(key, key * 1024)
+end
+
+Benchmark.ips do |x|
+  x.report 'readthis:read-multi' do
+    readthis.read_multi(*('a'..'z'))
+  end
+
+  x.report 'redisas:read-multi' do
+    redisas.read_multi(*('a'..'z'))
+  end
+
+  x.report 'dalli:read-multi' do
+    dalli.read_multi(*('a'..'z'))
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report 'readthis:fetch-multi' do
+    readthis.fetch_multi(*('a'..'z')) { |_| 'missing' }
+  end
+
+  x.report 'redisas:fetch-multi' do
+    redisas.fetch_multi(*('a'..'z')) { |_| 'missing' }
+  end
+
+  x.report 'dalli:fetch-multi' do
+    dalli.fetch_multi(*('a'..'z')) { |_| 'missing' }
+  end
+
+  x.compare!
+end

data/lib/readthis/cache.rb

@@ -33,10 +33,8 @@ module Readthis
     end
 
     def read(key, options = {})
-      instrument(:read, key) do
-        with do |store|
-          store.get(namespaced_key(key, merged_options(options)))
-        end
+      invoke(:read, key) do |store|
+        store.get(namespaced_key(key, merged_options(options)))
       end
     end
 
@@ -44,22 +42,18 @@ module Readthis
       options    = merged_options(options)
       namespaced = namespaced_key(key, options)
 
-      instrument(:write, key) do
-        with do |store|
-          if expiration = options[:expires_in]
-            store.setex(namespaced, expiration, value)
-          else
-            store.set(namespaced, value)
-          end
+      invoke(:write, key) do |store|
+        if expiration = options[:expires_in]
+          store.setex(namespaced, expiration, value)
+        else
+          store.set(namespaced, value)
         end
       end
     end
 
     def delete(key, options = {})
-      instrument(:delete, key) do
-        with do |store|
-          store.del(namespaced_key(key, merged_options(options)))
-        end
+      invoke(:delete, key) do |store|
+        store.del(namespaced_key(key, merged_options(options)))
       end
     end
 
@@ -75,33 +69,23 @@ module Readthis
     end
 
     def increment(key, options = {})
-      instrument(:incremenet, key) do
-        with do |store|
-          store.incr(namespaced_key(key, merged_options(options)))
-        end
+      invoke(:incremenet, key) do |store|
+        store.incr(namespaced_key(key, merged_options(options)))
       end
     end
 
     def decrement(key, options = {})
-      instrument(:decrement, key) do
-        with do |store|
-          store.decr(namespaced_key(key, merged_options(options)))
-        end
+      invoke(:decrement, key) do |store|
+        store.decr(namespaced_key(key, merged_options(options)))
       end
     end
 
     def read_multi(*keys)
       options = merged_options(extract_options!(keys))
-      results = []
-
-      instrument(:read_multi, keys) do
-        with do |store|
-          results = store.pipelined do
-            keys.each { |key| store.get(namespaced_key(key, options)) }
-          end
-        end
+      mapping = keys.map { |key| namespaced_key(key, options) }
 
-        keys.zip(results).to_h
+      invoke(:read_multi, keys) do |store|
+        keys.zip(store.mget(mapping)).to_h
       end
     end
 
@@ -116,15 +100,13 @@ module Readthis
       results = read_multi(*keys)
       options = merged_options(extract_options!(keys))
 
-      instrument(:fetch_multi, keys) do
-        with do |store|
-          store.pipelined do
-            results.each do |key, value|
-              if value.nil?
-                value = yield key
-                write(key, value, options)
-                results[key] = value
-              end
+      invoke(:fetch_multi, keys) do |store|
+        store.pipelined do
+          results.each do |key, value|
+            if value.nil?
+              value = yield key
+              write(key, value, options)
+              results[key] = value
             end
           end
         end
@@ -134,19 +116,13 @@ module Readthis
     end
 
     def exist?(key, options = {})
-      instrument(:exist?, key) do
-        with do |store|
-          store.exists(namespaced_key(key, merged_options(options)))
-        end
+      invoke(:exist?, key) do |store|
+        store.exists(namespaced_key(key, merged_options(options)))
       end
     end
 
     def clear
-      instrument(:clear, '*') do
-        with do |store|
-          store.flushdb
-        end
-      end
+      invoke(:clear, '*', &:flushdb)
     end
 
     private
@@ -158,8 +134,10 @@ module Readthis
       self.class.notifications.instrument(name, key) { yield(payload) }
     end
 
-    def with(&block)
-      pool.with(&block)
+    def invoke(operation, key, &block)
+      instrument(operation, key) do
+        pool.with(&block)
+      end
     end
 
     def extract_options!(array)

data/lib/readthis/expanders.rb

@@ -1,13 +1,18 @@
 module Readthis
   module Expanders
     def self.expand(key, namespace = nil)
-      expanded = if key.respond_to?(:cache_key)
-        key.cache_key
-      elsif key.is_a?(Array)
-        key.flat_map { |elem| expand(elem) }.join(':')
-      else
-        key
-      end
+      expanded =
+        if key.respond_to?(:cache_key)
+          key.cache_key
+        elsif key.is_a?(Array)
+          key.flat_map { |elem| expand(elem) }.join('/')
+        elsif key.is_a?(Hash)
+          key.sort_by { |key, _| key.to_s }.map { |key, val| "#{key}=#{val}" }.join('/')
+        elsif key.respond_to?(:to_param)
+          key.to_param
+        else
+          key
+        end
 
       namespace ? "#{namespace}:#{expanded}" : expanded
     end

data/lib/readthis/notifications.rb

@@ -1,6 +1,6 @@
 module Readthis
   module Notifications
-    def self.instrument(name, payload)
+    def self.instrument(_name, payload)
       yield(payload)
     end
   end

data/lib/readthis/version.rb

@@ -1,3 +1,3 @@
 module Readthis
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/spec/readthis/cache_spec.rb

@@ -45,11 +45,11 @@ RSpec.describe Readthis::Cache do
     end
 
     it 'expands non-string keys' do
-      key_obj = double(cache_key: 'custom-key')
+      key_obj = double(cache_key: 'custom')
 
       cache.write(key_obj, 'some-value')
 
-      expect(cache.read('custom-key')).to eq('some-value')
+      expect(cache.read('custom')).to eq('some-value')
     end
   end
 

data/spec/readthis/expanders_spec.rb

@@ -19,8 +19,20 @@ RSpec.describe Readthis::Expanders do
     it 'expands an array of objects' do
       object = double(cache_key: 'gamma')
 
-      expect(expand(['alpha', 'beta'])).to eq('alpha:beta')
-      expect(expand([object, object])).to eq('gamma:gamma')
+      expect(expand(['alpha', 'beta'])).to eq('alpha/beta')
+      expect(expand([object, object])).to eq('gamma/gamma')
+    end
+
+    it 'expands the keys of a hash' do
+      keyhash = { 'beta' => 2, alpha: 1 }
+
+      expect(expand(keyhash)).to eq('alpha=1/beta=2')
+    end
+
+    it 'uses the to_param method if available' do
+      object = double(to_param: 'thing')
+
+      expect(expand(object)).to eq('thing')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: readthis
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Parker Selbert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-25 00:00:00.000000000 Z
+date: 2014-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -91,10 +91,13 @@ files:
 - ".rspec"
 - ".travis.yml"
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/memory.rb
+- benchmarks/multi.rb
 - bin/rspec
 - lib/active_support/cache/readthis_store.rb
 - lib/readthis.rb