memcached_store 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0915f7c2305d9b4962115d99c52997673e711a58
-  data.tar.gz: 0cc5bbca84c1aee1bcf70f782735d90cd562252d
+  metadata.gz: a346167d61e3e802e7ce5d1c45b9ba225e6100e2
+  data.tar.gz: 33f531223bd3e02d5a760078975243777a83a6fc
 SHA512:
-  metadata.gz: b8a0873627bf43775afd6ef3a7aeb9788a3b5d96d82eaac63f3a49879942e43daf9ace73d8c90c697fc0ca4a4f8a6ee777b3314339634c18734953c84e065d94
-  data.tar.gz: 5326f2375fa65be54b8c0f5a9c163e0a606c8f6a474ee21f7476c8175fa39252813392e206ad599494b3b72251b6054ad8c824024e963dd9addc3ea16316513c
+  metadata.gz: 02c614d50425a3287076e9947a951ba836dde85eb43214f42c42a94e07fac1b8b3bf902f57dafdf247b6d14f08cdc11fa379b847ad96fd56d70d91866fb2c0f3
+  data.tar.gz: 7f08c3cd9c8ed9f0d12af91d4a935eeaab25e88a6c78b3a5450a708f768eccdadbe29e8e32aba46b6e974f184708d5320b887745c106fde98cc4acb5c8bb5a18

data/lib/active_support/cache/memcached_store.rb

@@ -11,37 +11,25 @@ module ActiveSupport
     # MemcachedStore implements the Strategy::LocalCache strategy which implements
     # an in-memory cache inside of a block.
     class MemcachedStore < Store
-      FATAL_EXCEPTIONS = [Memcached::ABadKeyWasProvidedOrCharactersOutOfRange,
-                          Memcached::AKeyLengthOfZeroWasProvided,
-                          Memcached::ConnectionBindFailure,
-                          Memcached::ConnectionDataDoesNotExist,
-                          Memcached::ConnectionFailure,
-                          Memcached::ConnectionSocketCreateFailure,
-                          Memcached::CouldNotOpenUnixSocket,
-                          Memcached::NoServersDefined,
-                          Memcached::TheHostTransportProtocolDoesNotMatchThatOfTheClient]
-
-      NONFATAL_EXCEPTIONS = if defined?(::Rails) && ::Rails.env.test?
-        []
-      else
-        Memcached::EXCEPTIONS - FATAL_EXCEPTIONS
-      end
-
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
 
-      attr_accessor :read_only
+      attr_accessor :read_only, :swallow_exceptions
 
       def initialize(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
+        @swallow_exceptions = true
+        @swallow_exceptions = options.delete(:swallow_exceptions) if options.key?(:swallow_exceptions)
+
         super(options)
 
         if addresses.first.respond_to?(:get)
           @data = addresses.first
         else
           mem_cache_options = options.dup
+          servers = mem_cache_options.delete(:servers)
           UNIVERSAL_OPTIONS.each { |name| mem_cache_options.delete(name) }
-          @data = Memcached::Rails.new(*(addresses + [mem_cache_options]))
+          @data = Memcached.new([*addresses, *servers], mem_cache_options)
         end
 
         extend Strategy::LocalCache
@@ -64,39 +52,40 @@ module ActiveSupport
 
       def read_multi(*names)
         options = names.extract_options!
+        return {} if names.empty?
+
         options = merged_options(options)
         keys_to_names = Hash[names.map { |name| [normalize_key(name, options), name] }]
         values = {}
 
-        instrument(:read_multi, names, options) do
-          if raw_values = @data.get_multi(keys_to_names.keys, raw: true)
-            raw_values.each do |key, value|
-              entry = deserialize_entry(value)
-              values[keys_to_names[key]] = entry.value unless entry.expired?
+        handle_exceptions(return_value_on_error: {}) do
+          instrument(:read_multi, names, options) do
+            if raw_values = @data.get(keys_to_names.keys, false)
+              raw_values.each do |key, value|
+                entry = deserialize_entry(value)
+                values[keys_to_names[key]] = entry.value unless entry.expired?
+              end
             end
           end
+          values
         end
-        values
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        {}
       end
 
       def cas(name, options = nil)
         options = merged_options(options)
         key = normalize_key(name, options)
 
-        instrument(:cas, name, options) do
-          @data.cas(key, expiration(options), cas_raw?(options)) do |raw_value|
-            entry = deserialize_entry(raw_value)
-            value = yield entry.value
-            break true if read_only
-            serialize_entry(Entry.new(value, options), options).first
+        handle_exceptions(return_value_on_error: false) do
+          instrument(:cas, name, options) do
+            @data.cas(key, expiration(options), !cas_raw?(options)) do |raw_value|
+              entry = deserialize_entry(raw_value)
+              value = yield entry.value
+              break true if read_only
+              serialize_entry(Entry.new(value, options), options).first
+            end
           end
+          true
         end
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        false
       end
 
       def cas_multi(*names)
@@ -106,54 +95,52 @@ module ActiveSupport
         options = merged_options(options)
         keys_to_names = Hash[names.map { |name| [normalize_key(name, options), name] }]
 
-        instrument(:cas_multi, names, options) do
-          @data.cas(keys_to_names.keys, expiration(options), cas_raw?(options)) do |raw_values|
-            values = {}
+        handle_exceptions(return_value_on_error: false) do
+          instrument(:cas_multi, names, options) do
+            @data.cas(keys_to_names.keys, expiration(options), !cas_raw?(options)) do |raw_values|
+              values = {}
 
-            raw_values.each do |key, raw_value|
-              entry = deserialize_entry(raw_value)
-              values[keys_to_names[key]] = entry.value unless entry.expired?
-            end
+              raw_values.each do |key, raw_value|
+                entry = deserialize_entry(raw_value)
+                values[keys_to_names[key]] = entry.value unless entry.expired?
+              end
 
-            values = yield values
+              values = yield values
 
-            break true if read_only
+              break true if read_only
 
-            serialized_values = values.map do |name, value|
-              [normalize_key(name, options), serialize_entry(Entry.new(value, options), options).first]
-            end
+              serialized_values = values.map do |name, value|
+                [normalize_key(name, options), serialize_entry(Entry.new(value, options), options).first]
+              end
 
-            Hash[serialized_values]
+              Hash[serialized_values]
+            end
+            true
           end
         end
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        false
       end
 
       def increment(name, amount = 1, options = nil) # :nodoc:
         options = merged_options(options)
-        instrument(:increment, name, amount: amount) do
-          @data.incr(normalize_key(name, options), amount)
+        handle_exceptions(return_value_on_error: nil) do
+          instrument(:increment, name, amount: amount) do
+            @data.incr(normalize_key(name, options), amount)
+          end
         end
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        nil
       end
 
       def decrement(name, amount = 1, options = nil) # :nodoc:
         options = merged_options(options)
-        instrument(:decrement, name, amount: amount) do
-          @data.decr(normalize_key(name, options), amount)
+        handle_exceptions(return_value_on_error: nil) do
+          instrument(:decrement, name, amount: amount) do
+            @data.decr(normalize_key(name, options), amount)
+          end
         end
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        nil
       end
 
       def clear(options = nil)
         ActiveSupport::Notifications.instrument("cache_clear.active_support", options || {}) do
-          @data.flush_all
+          @data.flush
         end
       end
 
@@ -168,19 +155,17 @@ module ActiveSupport
       end
 
       def reset #:nodoc:
-        @data.reset
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        false
+        handle_exceptions(return_value_on_error: false) do
+          @data.reset
+        end
       end
 
       protected
 
       def read_entry(key, _options) # :nodoc:
-        deserialize_entry(@data.get(escape_key(key), true))
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        nil
+        handle_exceptions(return_value_on_error: nil) do
+          deserialize_entry(@data.get(escape_key(key), false))
+        end
       end
 
       def write_entry(key, entry, options) # :nodoc:
@@ -188,19 +173,18 @@ module ActiveSupport
         method = options && options[:unless_exist] ? :add : :set
         expires_in = expiration(options)
         value, raw = serialize_entry(entry, options)
-        @data.send(method, escape_key(key), value, expires_in, raw)
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        false
+        handle_exceptions(return_value_on_error: false) do
+          @data.send(method, escape_key(key), value, expires_in, !raw)
+          true
+        end
       end
 
       def delete_entry(key, _options) # :nodoc:
         return true if read_only
-        @data.delete(escape_key(key))
-        true
-      rescue *NONFATAL_EXCEPTIONS => e
-        @data.log_exception(e)
-        false
+        handle_exceptions(return_value_on_error: false, on_miss: true) do
+          @data.delete(escape_key(key))
+          true
+        end
       end
 
       private
@@ -259,6 +243,16 @@ module ActiveSupport
         end
         expires_in
       end
+
+      def handle_exceptions(return_value_on_error:, on_miss: return_value_on_error)
+        yield
+      rescue Memcached::NotFound, Memcached::ConnectionDataExists
+        on_miss
+      rescue Memcached::Error => e
+        raise unless @swallow_exceptions
+        logger.warn("memcached error: #{e.class}: #{e.message}") if logger
+        return_value_on_error
+      end
     end
   end
 end

data/lib/memcached_store/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module MemcachedStore
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memcached_store
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Camilo Lopez
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-01 00:00:00.000000000 Z
+date: 2017-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -91,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Plugin-able Memcached adapters to add features (compression, safety)