rails3_libmemcached_store 0.4.0 → 0.5.0

data/BENCHMARKS

@@ -0,0 +1,37 @@
+Testing with
+ruby 1.9.3p125 (2012-02-16 revision 34643) [x86_64-darwin10.8.0]
+Dalli 2.1.0
+Libmemcached_store 0.5.0
+                                      user     system      total        real
+write:short:dalli                 0.260000   0.060000   0.320000 (  0.341703)
+write:short:libm                  0.040000   0.030000   0.070000 (  0.176990)
+write:long:dalli                  0.240000   0.060000   0.300000 (  0.327882)
+write:long:libm                   0.040000   0.030000   0.070000 (  0.213028)
+write:raw:dalli                   0.210000   0.060000   0.270000 (  0.271676)
+write:raw:libm                    0.040000   0.030000   0.070000 (  0.149668)
+
+read:miss:dalli                   0.310000   0.080000   0.390000 (  0.395997)
+read:miss:libm                    0.060000   0.040000   0.100000 (  0.199834)
+read:miss2:dalli                  0.210000   0.060000   0.270000 (  0.274769)
+read:miss2:libm                   0.060000   0.040000   0.100000 (  0.219939)
+read:exist:dalli                  0.210000   0.060000   0.270000 (  0.330582)
+read:exist:libm                   0.050000   0.050000   0.100000 (  0.186952)
+read:expired:dalli                0.240000   0.060000   0.300000 (  0.306864)
+read:expired:libm                 0.060000   0.040000   0.100000 (  0.212305)
+read:raw:dalli                    0.320000   0.070000   0.390000 (  0.391410)
+read:raw:libm                     0.040000   0.050000   0.090000 (  0.175050)
+
+exist:miss:dalli                  0.200000   0.060000   0.260000 (  0.271294)
+exist:miss:libm                   0.060000   0.040000   0.100000 (  0.211563)
+exist:hit:dalli                   0.200000   0.060000   0.260000 (  0.324383)
+exist:hit:libm                    0.050000   0.050000   0.100000 (  0.173287)
+
+delete:miss:dalli                 0.230000   0.050000   0.280000 (  0.281045)
+delete:miss:libm                  0.050000   0.030000   0.080000 (  0.213801)
+delete:hit:dalli                  0.290000   0.060000   0.350000 (  0.354938)
+delete:hit:libm                   0.060000   0.030000   0.090000 (  0.212315)
+
+increment:dalli                   0.210000   0.050000   0.260000 (  0.271489)
+increment:libm                    0.040000   0.040000   0.080000 (  0.153906)
+decrement:dalli                   0.220000   0.050000   0.270000 (  0.292662)
+decrement:libm                    0.040000   0.040000   0.080000 (  0.147424)

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.5.0
+  * Use Memcached#exist if available (performance improvement ~25%)
+  * Correctly escape bad characters and too long keys
+  * Add benchmarks
+  * Remove the use of ActiveSupport::Entry which was a performance bottleneck #3
+
+## 0.4.0
+  * Optimize read_multi to only make one call to memecached server
+  * Update test suite to reflect Rails' one
+  * Add session store tests

data/Gemfile

@@ -1,3 +1,7 @@
 source "http://rubygems.org"
 
-gemspec
+gemspec
+
+group :test do
+  gem 'dalli'
+end

data/README.md

@@ -8,11 +8,11 @@ This cache is designed for Rails 3+ applications.
 
 You'll need the memcached gem installed:
 
-```ruby  
+```ruby
 gem install memcached
 ```
 
-or in your Gemfile  
+or in your Gemfile
 
 ```ruby
 gem 'memcached'
@@ -48,18 +48,30 @@ designation. If no port is given, 11211 is assumed:
 config.cache_store = :libmemcached_store, %w(cache-01 cache-02 127.0.0.1:11212)
 ```
 
-Other options are passed directly to the memcached client
-  
+Standard Rails cache store options can be used
+
+```ruby
+config.cache_store = :libmemcached_store, '127.0.0.1:11211', :compress => true, :expires_in => 3600
+```
+
+More advanced options can be passed directly to the client
+
 ```ruby
-config.cache_store = :libmemcached_store, '127.0.0.1:11211', :default_ttl => 3600, :compress => true
+config.cache_store = :libmemcached_store, '127.0.0.1:11211', :client => { :binary_protocol => true, :no_block => true }
 ```
 
 You can also use `:libmemcached_store` to store your application sessions
 
 ```ruby
+require 'action_dispatch/session/libmemcached_store'
 config.session_store = :libmemcached_store, :namespace => '_session', :expire_after => 1800
 ```
 
+## Performance
+
+Used with Rails, __libmemcached_store__ is at least 1.5x faster than __dalli__. See [BENCHMARKS](https://github.com/ccocchi/libmemcached_store/blob/master/BENCHMARKS)
+for details
+
 ## Props
 
 Thanks to Brian Aker ([http://tangent.org](http://tangent.org)) for creating libmemcached, and Evan

data/lib/action_dispatch/session/libmemcached_store.rb

@@ -1,17 +1,17 @@
 require 'memcached'
-require 'rack/session/abstract/id'
+require 'action_dispatch/middleware/session/abstract_store'
 
 module ActionDispatch
   module Session
     class LibmemcachedStore < AbstractStore
 
-      DEFAULT_OPTIONS = Rack::Session::Abstract::ID::DEFAULT_OPTIONS.merge(:prefix_key => 'rack:session', :memcache_server => 'localhost:11211')
-
       def initialize(app, options = {})
         options[:expire_after] ||= options[:expires]
         super
+        client_options = { default_ttl: options.fetch(:expire_after, 0) }
+        client_options[:namespace] = options[:namespace] || 'rack:session'
         @mutex = Mutex.new
-        @pool = options[:cache] || Memcached.new(@default_options[:memcache_server], @default_options)
+        @pool = options[:cache] || Memcached.new(@default_options[:memcache_server], client_options)
       end
 
       private
@@ -20,7 +20,7 @@ module ActionDispatch
         loop do
           sid = super
           begin
-            @pool.get(sid)
+            @pool.exist(sid)
           rescue Memcached::NotFound
             break sid
           end
@@ -40,8 +40,7 @@ module ActionDispatch
       end
 
       def set_session(env, session_id, new_session, options = {})
-        expiry  = options[:expire_after]
-        expiry = expiry.nil? ? 0 : expiry + 1
+        expiry = options[:expire_after].to_i
 
         with_lock(env, false) do
           @pool.set(session_id, new_session, expiry)
@@ -64,7 +63,7 @@ module ActionDispatch
           with_lock(env, false) do
             @pool.delete(sid)
           end
-        end 
+        end
       end
 
       def with_lock(env, default)

data/lib/active_support/cache/libmemcached_store.rb

@@ -1,67 +1,169 @@
 require 'memcached'
+require 'memcached/get_with_flags'
 
-class ActiveSupport::Cache::Entry
-  # In 3.0 all values returned from Rails.cache.read are frozen.
-  # This makes sense for an in-memory store storing object references,
-  # but for a marshalled store we should be able to modify things.
-  # Starting with 3.2, values are not frozen anymore.
-  def value_with_dup
-    result = value_without_dup
-    result.frozen? && result.duplicable? ? result.dup : result
-  end
-  alias_method_chain :value, :dup
-end
+require 'digest/md5'
 
 module ActiveSupport
   module Cache
-    class LibmemcachedStore < Store
+
+    #
+    # Store using memcached gem as client
+    #
+    # Global options can be passed to be applied to each method by default.
+    # Supported options are
+    # * <tt>:compress</tt> : if set to true, data will be compress before stored
+    # * <tt>:compress_threshold</tt> : specify the threshold at which to compress
+    # value, default is 4K
+    # * <tt>:namespace</tt> : prepend each key with this value for simple namespacing
+    # * <tt>:expires_in</tt> : default TTL in seconds for each. Default value is 0, i.e. forever
+    # Specific value can be passed per key with write and fetch command.
+    #
+    # Options can also be passed direclty to the memcache client, via the <tt>:client</tt>
+    # option. For example, if you want to use pipelining, you can use
+    # :client => { :no_block => true }
+    #
+    class LibmemcachedStore
       attr_reader :addresses
 
-      DEFAULT_OPTIONS = {
-        :distribution => :consistent_ketama,
-        :binary_protocol => true
-      }
+      DEFAULT_CLIENT_OPTIONS = { distribution: :consistent_ketama, binary_protocol: true, default_ttl: 0 }
+      ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
+      DEFAULT_COMPRESS_THRESHOLD = 4096
+      FLAG_COMPRESSED = 0x2
+
+      attr_reader :silence, :options
+      alias_method :silence?, :silence
+
+      # Silence the logger.
+      def silence!
+        @silence = true
+        self
+      end
+
+      # Silence the logger within a block.
+      def mute
+        previous_silence, @silence = defined?(@silence) && @silence, true
+        yield
+      ensure
+        @silence = previous_silence
+      end
 
       def initialize(*addresses)
         addresses.flatten!
-        @options = addresses.extract_options!
+        options = addresses.extract_options!
+        client_options = options.delete(:client) || {}
+        if options[:namespace]
+          client_options[:prefix_key] = options.delete(:namespace)
+          client_options[:prefix_delimiter] = ':'
+          @namespace_length = client_options[:prefix_key].length + 1
+        else
+          @namespace_length = 0
+        end
+        client_options[:default_ttl] = options.delete(:expires_in).to_i if options[:expires_in]
+
+        @options = options.reverse_merge(compress_threshold: DEFAULT_COMPRESS_THRESHOLD)
         @addresses = addresses
-        @cache = Memcached.new(@addresses, @options.reverse_merge(DEFAULT_OPTIONS))
+        @cache = Memcached.new(@addresses, client_options.reverse_merge(DEFAULT_CLIENT_OPTIONS))
+        @cache.instance_eval { send(:extend, GetWithFlags) }
+      end
+
+      def fetch(key, options = nil)
+        if block_given?
+          key = expanded_key(key)
+          unless options && options[:force]
+            entry = instrument(:read, key, options) do |payload|
+              payload[:super_operation] = :fetch if payload
+              read_entry(key, options)
+            end
+          end
+
+          if entry.nil?
+            result = instrument(:generate, key, options) do |payload|
+              yield
+            end
+            write_entry(key, result, options)
+            result
+          else
+            instrument(:fetch_hit, key, options) { |payload| }
+            entry
+          end
+        else
+          read(key, options)
+        end
+      end
+
+      def read(key, options = nil)
+        key = expanded_key(key)
+        instrument(:read, key, options) do |payload|
+          entry = read_entry(key, options)
+          payload[:hit] = !!entry if payload
+          entry
+        end
+      end
+
+      def write(key, value, options = nil)
+        key = expanded_key(key)
+        instrument(:write, key, options) do |payload|
+          write_entry(key, value, options)
+        end
+      end
+
+      def delete(key, options = nil)
+        key = expanded_key(key)
+        instrument(:delete, key) do |payload|
+          delete_entry(key, options)
+        end
+      end
+
+      def exist?(key, options = nil)
+        key = expanded_key(key)
+        instrument(:exist?, key) do |payload|
+          if @cache.respond_to?(:exist)
+            @cache.exist(escape_and_normalize(key))
+            true
+          else
+            read_entry(key, options) != nil
+          end
+        end
+      rescue Memcached::NotFound
+        false
       end
 
       def increment(key, amount = 1, options = nil)
+        key = expanded_key(key)
         instrument(:increment, key, amount: amount) do
-          @cache.incr(key, amount)
+          @cache.incr(escape_and_normalize(key), amount)
         end
-      rescue Memcached::Error
+      rescue Memcached::NotFound
+        nil
+      rescue Memcached::Error => e
+        log_error(e)
         nil
       end
 
       def decrement(key, amount = 1, options = nil)
+        key = expanded_key(key)
         instrument(:decrement, key, amount: amount) do
-          @cache.decr(key, amount)
+          @cache.decr(escape_and_normalize(key), amount)
         end
-      rescue Memcached::Error
+      rescue Memcached::NotFound
+        nil
+      rescue Memcached::Error => e
+        log_error(e)
         nil
       end
 
-      #
-      # Optimize read_multi to only make one call to memcached
-      # server.
-      #
       def read_multi(*names)
+        names.flatten!
         options = names.extract_options!
-        options = merged_options(options)
 
         return {} if names.empty?
 
-        keys_to_names = Hash[names.map {|name| [namespaced_key(name, options), name] }]
-        raw_values = @cache.get(keys_to_names.keys, false)
+        mapping = Hash[names.map {|name| [escape_and_normalize(expanded_key(name)), name] }]
+        raw_values, flags = @cache.get(mapping.keys, false, true)
 
         values = {}
         raw_values.each do |key, value|
-          entry = deserialize_entry(value)
-          values[keys_to_names[key]] = entry.value unless entry.expired?
+          values[mapping[key]] = deserialize(value, options[:raw], flags[key])
         end
         values
       end
@@ -77,7 +179,9 @@ module ActiveSupport
       protected
 
       def read_entry(key, options = nil)
-        deserialize_entry(@cache.get(key, false))
+        options ||= {}
+        raw_value, flags = @cache.get(escape_and_normalize(key), false, true)
+        deserialize(raw_value, options[:raw], flags)
       rescue Memcached::NotFound
         nil
       rescue Memcached::Error => e
@@ -85,13 +189,18 @@ module ActiveSupport
         nil
       end
 
-      # Set the key to the given value. Pass :unless_exist => true if you want to
-      # skip setting a key that already exists.
       def write_entry(key, entry, options = nil)
-        method = (options && options[:unless_exist]) ? :add : :set
-        value = options[:raw] ? entry.value.to_s : entry
+        options = options ? @options.merge(options) : @options
+        method = options[:unless_exist] ? :add : :set
+        entry = options[:raw] ? entry.to_s : Marshal.dump(entry)
+        flags = 0
 
-        @cache.send(method, key, value, expires_in(options), marshal?(options))
+        if options[:compress] && entry.bytesize >= options[:compress_threshold]
+          entry = Zlib::Deflate.deflate(entry)
+          flags |= FLAG_COMPRESSED
+        end
+
+        @cache.send(method, escape_and_normalize(key), entry, options[:expires_in].to_i, false, flags)
         true
       rescue Memcached::Error => e
         log_error(e)
@@ -99,7 +208,7 @@ module ActiveSupport
       end
 
       def delete_entry(key, options = nil)
-        @cache.delete(key)
+        @cache.delete(escape_and_normalize(key))
         true
       rescue Memcached::NotFound
         false
@@ -109,27 +218,66 @@ module ActiveSupport
       end
 
       private
-      def deserialize_entry(raw_value)
-        if raw_value
-          entry = Marshal.load(raw_value) rescue raw_value
-          entry.is_a?(Entry) ? entry : Entry.new(entry)
-        else
-          nil
+
+      def deserialize(value, raw = false, flags = 0)
+        value = Zlib::Inflate.inflate(value) if (flags & FLAG_COMPRESSED) != 0
+        raw ? value : Marshal.load(value)
+      rescue TypeError, ArgumentError
+        value
+      end
+
+      def escape_and_normalize(key)
+        key = key.to_s.force_encoding("BINARY").gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
+        key_length = key.length
+
+        return key if @namespace_length + key_length <= 250
+
+        max_key_length = 213 - @namespace_length
+        "#{key[0, max_key_length]}:md5:#{Digest::MD5.hexdigest(key)}"
+      end
+
+      def expanded_key(key) # :nodoc:
+        return key.cache_key.to_s if key.respond_to?(:cache_key)
+
+        case key
+        when Array
+          if key.size > 1
+            key = key.collect { |element| expanded_key(element) }
+          else
+            key = key.first
+          end
+        when Hash
+          key = key.sort_by { |k,_| k.to_s }.collect { |k, v| "#{k}=#{v}" }
         end
+
+        key.to_param
       end
 
-      def expires_in(options)
-        (options || {})[:expires_in].to_i
+      def instrument(operation, key, options=nil)
+        log(operation, key, options)
+
+        if ActiveSupport::Cache::Store.instrument
+          payload = { :key => key }
+          payload.merge!(options) if options.is_a?(Hash)
+          ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload){ yield(payload) }
+        else
+          yield(nil)
+        end
       end
 
-      def marshal?(options)
-        !(options || {})[:raw]
+      def log(operation, key, options=nil)
+        return unless !silence? && logger && logger.debug?
+        logger.debug("Cache #{operation}: #{key}#{options.blank? ? "" : " (#{options.inspect})"}")
       end
 
       def log_error(exception)
-        return unless logger && logger.error?
+        return unless !silence? && logger && logger.error?
         logger.error "MemcachedError (#{exception.inspect}): #{exception.message}"
       end
+
+      def logger
+        Rails.logger
+      end
     end
   end
 end

data/lib/libmemcached_store.rb

@@ -1,3 +1,2 @@
 require 'active_support/cache/libmemcached_store'
-require 'active_support/cache/compressed_libmemcached_store'
 require 'action_dispatch/session/libmemcached_store'

data/lib/memcached/get_with_flags.rb

@@ -0,0 +1,42 @@
+#
+# Allow get method to returns value + entry's flags
+# This is useful to set compression flag.
+#
+module GetWithFlags
+  def get(keys, marshal=true, with_flags=false)
+    if keys.is_a? Array
+      # Multi get
+      ret = Memcached::Lib.memcached_mget(@struct, keys);
+      check_return_code(ret, keys)
+
+      hash, flags_hash = {}, {}
+      value, key, flags, ret = Memcached::Lib.memcached_fetch_rvalue(@struct)
+      while ret != 21 do # Lib::MEMCACHED_END
+        if ret == 0 # Lib::MEMCACHED_SUCCESS
+          hash[key] = value
+          flags_hash[key] = flags if with_flags
+        elsif ret != 16 # Lib::MEMCACHED_NOTFOUND
+          check_return_code(ret, key)
+        end
+        value, key, flags, ret = Memcached::Lib.memcached_fetch_rvalue(@struct)
+      end
+      if marshal
+        hash.each do |key, value|
+          hash[key] = Marshal.load(value)
+        end
+      end
+      with_flags ? [hash, flags_hash] : hash
+    else
+      # Single get
+      value, flags, ret = Memcached::Lib.memcached_get_rvalue(@struct, keys)
+      check_return_code(ret, keys)
+      value =  Marshal.load(value) if marshal
+      with_flags ? [value, flags] : value
+    end
+  rescue => e
+    tries ||= 0
+    raise unless tries < options[:exception_retry_limit] && should_retry(e)
+    tries += 1
+    retry
+  end
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module LibmemcachedStore
-  VERSION = "0.4.0".freeze
+  VERSION = "0.5.0".freeze
 end

data/test/active_support/libmemcached_store_test.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'test_helper'
 require 'memcached'
 require 'active_support'
@@ -7,67 +9,101 @@ require 'active_support/cache/libmemcached_store'
 
 # Make it easier to get at the underlying cache options during testing.
 class ActiveSupport::Cache::LibmemcachedStore
-  delegate :options, :to => '@cache'
+  def client_options
+    @cache.options
+  end
 end
 
-module CacheStoreBehavior
-  def test_should_read_and_write_strings
-    assert_equal true, @cache.write('foo', 'bar')
-    assert_equal 'bar', @cache.read('foo')
-  end
-
-  def test_should_overwrite
-    @cache.write('foo', 'bar')
-    @cache.write('foo', 'baz')
-    assert_equal 'baz', @cache.read('foo')
+class MockUser
+  def cache_key
+    'foo'
   end
+end
 
+module CacheStoreBehavior
   def test_fetch_without_cache_miss
     @cache.write('foo', 'bar')
-    @cache.expects(:write).never
+    @cache.expects(:write_entry).never
     assert_equal 'bar', @cache.fetch('foo') { 'baz' }
   end
 
   def test_fetch_with_cache_miss
-    @cache.expects(:write).with('foo', 'baz', @cache.options)
+    @cache.expects(:write_entry).with('foo', 'baz', nil)
     assert_equal 'baz', @cache.fetch('foo') { 'baz' }
   end
 
   def test_fetch_with_forced_cache_miss
     @cache.write('foo', 'bar')
-    @cache.expects(:read).never
-    @cache.expects(:write).with('foo', 'bar', @cache.options.merge(:force => true))
-    @cache.fetch('foo', :force => true) { 'bar' }
+    @cache.expects(:read_entry).never
+    @cache.expects(:write_entry).with('foo', 'baz', force: true)
+    assert_equal 'baz', @cache.fetch('foo', force: true) { 'baz' }
+  end
+
+  def test_fetch_with_cached_false
+    @cache.write('foo', false)
+    refute @cache.fetch('foo') { raise }
+  end
+
+  def test_fetch_with_raw_object
+    o = Object.new
+    o.instance_variable_set :@foo, 'bar'
+    assert_equal o, @cache.fetch('foo', raw: true) { o }
   end
 
-  def test_fetch_with_cached_nil
-    @cache.write('foo', nil)
-    @cache.expects(:write).never
-    assert_nil @cache.fetch('foo') { 'baz' }
+  def test_fetch_with_cache_key
+    u = MockUser.new
+    @cache.write(u.cache_key, 'bar')
+    assert_equal 'bar', @cache.fetch(u) { raise }
+  end
+
+  def test_should_read_and_write_strings
+    assert @cache.write('foo', 'bar')
+    assert_equal 'bar', @cache.read('foo')
   end
 
   def test_should_read_and_write_hash
-    assert_equal true, @cache.write('foo', {:a => "b"})
-    assert_equal({:a => "b"}, @cache.read('foo'))
+    assert @cache.write('foo', { a: 'b' })
+    assert_equal({ a: 'b' }, @cache.read('foo'))
   end
 
   def test_should_read_and_write_integer
-    assert_equal true, @cache.write('foo', 1)
+    assert @cache.write('foo', 1)
     assert_equal 1, @cache.read('foo')
   end
 
   def test_should_read_and_write_nil
-    assert_equal true, @cache.write('foo', nil)
+    assert @cache.write('foo', nil)
     assert_equal nil, @cache.read('foo')
   end
 
   def test_should_read_and_write_false
     assert @cache.write('foo', false)
-    if ActiveSupport::VERSION::MAJOR == 3 && ActiveSupport::VERSION::MINOR == 0
-      assert_equal nil, @cache.read('foo')
-    else
-      assert_equal false, @cache.read('foo')
-    end
+    assert_equal false, @cache.read('foo')
+  end
+
+  def test_read_and_write_compressed_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1)
+    assert_equal 'bar', @cache.read('foo')
+  end
+
+  def test_write_should_overwrite
+    @cache.write('foo', 'bar')
+    @cache.write('foo', 'baz')
+    assert_equal 'baz', @cache.read('foo')
+  end
+
+  def test_write_compressed_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1, :raw => true)
+    assert_equal Zlib::Deflate.deflate('bar'), @cache.instance_variable_get(:@cache).get('foo', false)
+  end
+
+  def test_read_miss
+    assert_nil @cache.read('foo')
+  end
+
+  def test_read_should_return_a_different_object_id_each_time_it_is_called
+    @cache.write('foo', 'bar')
+    refute_equal @cache.read('foo').object_id, @cache.read('foo').object_id
   end
 
   def test_read_multi
@@ -77,94 +113,75 @@ module CacheStoreBehavior
     assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
   end
 
-  def test_read_multi_with_expires
-    @cache.write('foo', 'bar', :expires_in => 0.001)
+  def test_read_multi_with_array
+    @cache.write('foo', 'bar')
     @cache.write('fu', 'baz')
-    @cache.write('fud', 'biz')
-    sleep(0.002)
-    assert_equal({"fu" => "baz"}, @cache.read_multi('foo', 'fu'))
-  end
-
-  def test_read_and_write_compressed_small_data
-    @cache.write('foo', 'bar', :compress => true)
-    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
-    assert_equal 'bar', @cache.read('foo')
-    value = Marshal.load(raw_value) rescue raw_value
-    assert_equal 'bar', value
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi(['foo', 'fu']))
   end
 
-  def test_read_and_write_compressed_large_data
-    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
-    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
-    assert_equal 'bar', @cache.read('foo')
-    assert_equal 'bar', Marshal.load(Zlib::Inflate.inflate(raw_value))
+  def test_read_multi_with_raw
+    @cache.write('foo', 'bar', :raw => true)
+    @cache.write('fu', 'baz', :raw => true)
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
   end
 
-  def test_read_and_write_compressed_nil
-    @cache.write('foo', nil, :compress => true)
-    assert_nil @cache.read('foo')
+  def test_read_multi_with_compress
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 1)
+    @cache.write('fu', 'baz', :compress => true, :compress_threshold => 1)
+    assert_equal({"foo" => "bar", "fu" => "baz"}, @cache.read_multi('foo', 'fu'))
   end
 
   def test_cache_key
-    obj = Object.new
-    def obj.cache_key
-      :foo
-    end
-    @cache.write(obj, "bar")
-    assert_equal "bar", @cache.read("foo")
+    o = MockUser.new
+    @cache.write(o, 'bar')
+    assert_equal 'bar', @cache.read('foo')
   end
 
   def test_param_as_cache_key
     obj = Object.new
     def obj.to_param
-      "foo"
+      'foo'
     end
-    @cache.write(obj, "bar")
-    assert_equal "bar", @cache.read("foo")
+    @cache.write(obj, 'bar')
+    assert_equal 'bar', @cache.read('foo')
   end
 
   def test_array_as_cache_key
-    @cache.write([:fu, "foo"], "bar")
-    assert_equal "bar", @cache.read("fu/foo")
+    @cache.write([:fu, 'foo'], 'bar')
+    assert_equal 'bar', @cache.read('fu/foo')
   end
 
   def test_hash_as_cache_key
-    @cache.write({:foo => 1, :fu => 2}, "bar")
-    assert_equal "bar", @cache.read("foo=1/fu=2")
+    @cache.write({:foo => 1, :fu => 2}, 'bar')
+    assert_equal 'bar', @cache.read('foo=1/fu=2')
   end
 
   def test_keys_are_case_sensitive
-    @cache.write("foo", "bar")
-    assert_nil @cache.read("FOO")
+    @cache.write('foo', 'bar')
+    assert_nil @cache.read('FOO')
   end
 
-  def test_exist
-    @cache.write('foo', 'bar')
-    assert_equal true, @cache.exist?('foo')
-    assert_equal false, @cache.exist?('bar')
+  def test_keys_with_spaces
+    assert_equal 'baz', @cache.fetch('foo bar') { 'baz' }
   end
 
-  def test_nil_exist
-    @cache.write('foo', nil)
-    assert_equal true, @cache.exist?('foo')
+  def test_exist
+    @cache.write('foo', 'bar')
+    assert @cache.exist?('foo')
+    refute @cache.exist?('bar')
   end
 
   def test_delete
     @cache.write('foo', 'bar')
     assert @cache.exist?('foo')
-    assert_equal true, @cache.delete('foo')
-    assert !@cache.exist?('foo')
+    assert @cache.delete('foo')
+    refute @cache.exist?('foo')
   end
 
   def test_delete_with_unexistent_key
     @cache.expects(:log_error).never
-    assert !@cache.exist?('foo')
-    assert_equal false, @cache.delete('foo')
-  end
-
-  def test_read_should_return_a_different_object_id_each_time_it_is_called
-    @cache.write('foo', 'bar')
-    refute_equal @cache.read('foo').object_id, @cache.read('foo').object_id
+    refute @cache.exist?('foo')
+    refute @cache.delete('foo')
   end
 
   def test_store_objects_should_be_immutable
@@ -179,112 +196,42 @@ module CacheStoreBehavior
     assert_equal 'baz', bar.gsub!(/r/, 'z')
   end
 
-  def test_expires_in
-    time = Time.local(2008, 4, 24)
-    Time.stubs(:now).returns(time)
-
-    @cache.write('foo', 'bar', :expires_in => 45)
-    assert_equal 'bar', @cache.read('foo')
-
-    Time.stubs(:now).returns(time + 30)
-    assert_equal 'bar', @cache.read('foo')
-
-    Time.stubs(:now).returns(time + 61)
-    assert_nil @cache.read('foo')
-  end
-
-  def test_expires_in_as_activesupport_duration
-    time = Time.local(2012, 02, 03)
-    Time.stubs(:now).returns(time)
-
-    @cache.write('foo', 'bar', :expires_in => 1.minute)
-    assert_equal 'bar', @cache.read('foo')
-
-    Time.stubs(:now).returns(time + 30)
-    assert_equal 'bar', @cache.read('foo')
-
-    Time.stubs(:now).returns(time + 61)
-    assert_nil @cache.read('foo')
-  end
-
-  def test_expires_in_as_float
-    time = Time.local(2012, 02, 03)
-    Time.stubs(:now).returns(time)
-
-    @cache.write('foo', 'bar', :expires_in => 60.0)
-    assert_equal 'bar', @cache.read('foo')
-
-    Time.stubs(:now).returns(time + 30)
-    assert_equal 'bar', @cache.read('foo')
-
-    Time.stubs(:now).returns(time + 61)
-    assert_nil @cache.read('foo')
-  end
-
-  def test_race_condition_protection
-    time = Time.now
-    @cache.write('foo', 'bar', :expires_in => 60)
-    Time.stubs(:now).returns(time + 61)
-    result = @cache.fetch('foo', :race_condition_ttl => 10) do
-      assert_equal 'bar', @cache.read('foo')
-      "baz"
-    end
-    assert_equal "baz", result
-  end
-
-  def test_race_condition_protection_is_limited
-    time = Time.now
-    @cache.write('foo', 'bar', :expires_in => 60)
-    Time.stubs(:now).returns(time + 71)
-    result = @cache.fetch('foo', :race_condition_ttl => 10) do
-      assert_equal nil, @cache.read('foo')
-      "baz"
-    end
-    assert_equal "baz", result
-  end
-
-  def test_race_condition_protection_is_safe
-    time = Time.now
-    @cache.write('foo', 'bar', :expires_in => 60)
-    Time.stubs(:now).returns(time + 61)
-    begin
-      @cache.fetch('foo', :race_condition_ttl => 10) do
-        assert_equal 'bar', @cache.read('foo')
-        raise ArgumentError.new
-      end
-    rescue ArgumentError
-    end
-    assert_equal "bar", @cache.read('foo')
-    Time.stubs(:now).returns(time + 71)
-    assert_nil @cache.read('foo')
-  end
-
   def test_crazy_key_characters
     crazy_key = "#/:*(<+=> )&$%@?;'\"\'`~-"
-    assert_equal true, @cache.write(crazy_key, "1", :raw => true)
+    assert @cache.write(crazy_key, "1", :raw => true)
     assert_equal "1", @cache.read(crazy_key)
     assert_equal "1", @cache.fetch(crazy_key)
-    assert_equal true, @cache.delete(crazy_key)
+    assert @cache.delete(crazy_key)
+    refute @cache.exist?(crazy_key)
     assert_equal "2", @cache.fetch(crazy_key, :raw => true) { "2" }
     assert_equal 3, @cache.increment(crazy_key)
     assert_equal 2, @cache.decrement(crazy_key)
   end
 
-  # def test_really_long_keys
-  #   key = ""
-  #   900.times{key << "x"}
-  #   assert @cache.write(key, "bar")
-  #   assert_equal "bar", @cache.read(key)
-  #   assert_equal "bar", @cache.fetch(key)
-  #   assert_nil @cache.read("#{key}x")
-  #   assert_equal({key => "bar"}, @cache.read_multi(key))
-  #   assert @cache.delete(key)
-  # end
+  def test_really_long_keys
+    key = "a" * 251
+    assert @cache.write(key, "bar")
+    assert_equal "bar", @cache.read(key)
+    assert_equal "bar", @cache.fetch(key)
+    assert_nil @cache.read("#{key}x")
+    assert_equal({key => "bar"}, @cache.read_multi(key))
+    assert @cache.delete(key)
+    refute @cache.exist?(key)
+    assert @cache.write(key, '2', :raw => true)
+    assert_equal 3, @cache.increment(key)
+    assert_equal 2, @cache.decrement(key)
+  end
+
+  def test_really_long_keys_with_namespace
+    @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, :expires_in => 60, :namespace => 'namespace')
+    @cache.silence!
+    test_really_long_keys
+  end
 end
 
 module CacheIncrementDecrementBehavior
   def test_increment
-    @cache.write('foo', 1, :raw => true)
+    @cache.write('foo', '1', :raw => true)
     assert_equal 1, @cache.read('foo').to_i
     assert_equal 2, @cache.increment('foo')
     assert_equal 2, @cache.read('foo').to_i
@@ -293,13 +240,36 @@ module CacheIncrementDecrementBehavior
   end
 
   def test_decrement
-    @cache.write('foo', 3, :raw => true)
+    @cache.write('foo', '3', :raw => true)
     assert_equal 3, @cache.read('foo').to_i
     assert_equal 2, @cache.decrement('foo')
     assert_equal 2, @cache.read('foo').to_i
     assert_equal 1, @cache.decrement('foo')
     assert_equal 1, @cache.read('foo').to_i
   end
+
+  def test_increment_decrement_non_existing_keys
+    @cache.expects(:log_error).never
+    assert_nil @cache.increment('foo')
+    assert_nil @cache.decrement('bar')
+  end
+end
+
+module CacheCompressBehavior
+  def test_read_and_write_compressed_small_data
+    @cache.write('foo', 'bar', :compress => true)
+    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
+    assert_equal 'bar', @cache.read('foo')
+    value = Marshal.load(raw_value) rescue raw_value
+    assert_equal 'bar', value
+  end
+
+  def test_read_and_write_compressed_large_data
+    @cache.write('foo', 'bar', :compress => true, :compress_threshold => 2)
+    raw_value = @cache.send(:read_entry, 'foo', {}).raw_value
+    assert_equal 'bar', @cache.read('foo')
+    assert_equal 'bar', Marshal.load(Zlib::Inflate.inflate(raw_value))
+  end
 end
 
 class LibmemcachedStoreTest < MiniTest::Unit::TestCase
@@ -307,7 +277,7 @@ class LibmemcachedStoreTest < MiniTest::Unit::TestCase
   include CacheIncrementDecrementBehavior
 
   def setup
-    @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, :expires_in => 60)
+    @cache = ActiveSupport::Cache.lookup_store(:libmemcached_store, expires_in: 60)
     @cache.clear
     @cache.silence!
   end
@@ -326,26 +296,34 @@ class LibmemcachedStoreTest < MiniTest::Unit::TestCase
   end
 
   def test_should_enable_consistent_ketema_hashing_by_default
-    assert_equal :consistent_ketama, @cache.options[:distribution]
+    assert_equal :consistent_ketama, @cache.client_options[:distribution]
   end
 
   def test_should_not_enable_non_blocking_io_by_default
-    assert_equal false, @cache.options[:no_block]
+    assert_equal false, @cache.client_options[:no_block]
   end
 
   def test_should_not_enable_server_failover_by_default
-    assert_nil @cache.options[:failover]
+    assert_nil @cache.client_options[:failover]
   end
 
   def test_should_allow_configuration_of_custom_options
-    options = {
-      :tcp_nodelay => true,
-      :distribution => :modula
-    }
+    options = { client: { tcp_nodelay: true, distribution: :modula } }
 
     store = ActiveSupport::Cache.lookup_store :libmemcached_store, 'localhost', options
 
-    assert_equal :modula, store.options[:distribution]
-    assert_equal true, store.options[:tcp_nodelay]
+    assert_equal :modula, store.client_options[:distribution]
+    assert_equal true, store.client_options[:tcp_nodelay]
+  end
+
+  def test_should_allow_mute_and_silence
+    cache = ActiveSupport::Cache.lookup_store :libmemcached_store, 'localhost'
+    cache.mute do
+      assert cache.write('foo', 'bar')
+      assert_equal 'bar', cache.read('foo')
+    end
+    refute cache.silence?
+    cache.silence!
+    assert cache.silence?
   end
 end

data/test/profile/benchmark.rb

@@ -0,0 +1,94 @@
+require 'benchmark'
+require 'active_support'
+
+require 'libmemcached_store'
+require 'active_support/cache/libmemcached_store'
+
+require 'dalli'
+require 'active_support/cache/dalli_store'
+
+puts "Testing with"
+puts RUBY_DESCRIPTION
+puts "Dalli #{Dalli::VERSION}"
+puts "Libmemcached_store #{LibmemcachedStore::VERSION}"
+
+# We'll use a simple @value to try to avoid spending time in Marshal,
+# which is a constant penalty that both clients have to pay
+@value = []
+@marshalled = Marshal.dump(@value)
+
+@servers = ['127.0.0.1:11211']
+@key1 = "Short"
+@key2 = "Sym1-2-3::45"*4
+@key3 = "Long"*40
+@key4 = "Medium"*8
+
+N = 2_500
+
+@dalli = ActiveSupport::Cache::DalliStore.new(@servers).silence!
+@libm = ActiveSupport::Cache::LibmemcachedStore.new(@servers).silence!
+
+def clear
+  @dalli.clear
+  @libm.clear
+end
+
+def test_method(title, method_name, key, *arguments)
+  { dalli: @dalli, libm: @libm }.each do |name, store|
+    @job.report("#{title}:#{name}") { N.times { store.send(method_name, key, *arguments) } }
+  end
+end
+
+def run_method(method_name, key, *arguments)
+  [@dalli, @libm].each do |store|
+    store.send(method_name, key, *arguments)
+  end
+end
+
+Benchmark.bm(31) do |x|
+  @job = x
+
+  test_method('write:short', :write, @key1, @value)
+  test_method('write:long',  :write, @key3, @value)
+  test_method('write:raw',   :write, @key4, @value, raw: true)
+
+  puts
+  clear
+
+  test_method('read:miss',  :read, @key1)
+  test_method('read:miss2', :read, @key1)
+
+  run_method(:write, @key4, @value)
+  test_method('read:exist', :read, @key4)
+
+  run_method(:write, @key4, @value, expires_in: 1)
+  sleep(1)
+  test_method('read:expired', :read, @key2)
+
+  run_method(:write, @key3, @value, raw: true)
+  test_method('read:raw', :read, @key3, raw: true)
+
+  puts
+  clear
+
+  test_method('exist:miss', :exist?, @key4)
+
+  run_method(:write, @key4, @value)
+  test_method('exist:hit', :exist?, @key4)
+
+  puts
+  clear
+
+  test_method('delete:miss', :delete, @key4)
+
+  run_method(:write, @key1, @value)
+  test_method('delete:hit', :delete, @key1)
+
+  puts
+  clear
+
+  run_method(:write, @key4, 0, raw: true)
+
+  test_method('increment', :increment, @key4)
+  test_method('decrement', :decrement, @key4)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails3_libmemcached_store
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-16 00:00:00.000000000 Z
+date: 2012-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: memcached
@@ -120,6 +120,8 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- BENCHMARKS
+- CHANGELOG.md
 - Gemfile
 - MIT-LICENSE
 - README.md
@@ -128,15 +130,16 @@ files:
 - gemfiles/rails31.gemfile
 - gemfiles/rails32.gemfile
 - lib/action_dispatch/session/libmemcached_store.rb
-- lib/active_support/cache/compressed_libmemcached_store.rb
 - lib/active_support/cache/libmemcached_store.rb
 - lib/libmemcached_store.rb
+- lib/memcached/get_with_flags.rb
 - lib/version.rb
 - libmemcached_store.gemspec
 - test/action_dispatch/abstract_unit.rb
 - test/action_dispatch/libmemcached_store_test.rb
 - test/active_support/libmemcached_store_test.rb
 - test/fixtures/session_autoload_test.rb
+- test/profile/benchmark.rb
 - test/test_helper.rb
 homepage: http://github.com/ccocchi/libmemcached_store
 licenses: []
@@ -158,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.8.21
 signing_key: 
 specification_version: 3
 summary: ActiveSupport 3+ cache store for the C-based libmemcached client
@@ -167,4 +170,5 @@ test_files:
 - test/action_dispatch/libmemcached_store_test.rb
 - test/active_support/libmemcached_store_test.rb
 - test/fixtures/session_autoload_test.rb
+- test/profile/benchmark.rb
 - test/test_helper.rb

data/lib/active_support/cache/compressed_libmemcached_store.rb

@@ -1,15 +0,0 @@
-module ActiveSupport
-  module Cache
-    class CompressedLibmemcachedStore < LibmemcachedStore
-      def read(name, options = {})
-        if value = super(name, (options || {}).merge(:raw => true))
-          Marshal.load(ActiveSupport::Gzip.decompress(value))
-        end
-      end
-
-      def write(name, value, options = {})
-        super(name, ActiveSupport::Gzip.compress(Marshal.dump(value)), (options || {}).merge(:raw => true))
-      end
-    end
-  end
-end