rescue memcached errors in a consistent way

activesupport/lib/active_support/cache/mem_cache_store.rb

@@ -115,11 +115,10 @@ def read_multi(*names)
       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)
+          rescue_error_with nil do
+            @data.incr(normalize_key(name, options), amount)
+          end
         end
-      rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}") if logger
-        nil
       end
 
       # Decrement a cached value. This method uses the memcached decr atomic
@@ -129,20 +128,16 @@ def increment(name, amount = 1, options = nil) # :nodoc:
       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)
+          rescue_error_with nil do
+            @data.decr(normalize_key(name, options), amount)
+          end
         end
-      rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}") if logger
-        nil
       end
 
       # Clear the entire cache on all memcached servers. This method should
       # be used with care when shared cache is being used.
       def clear(options = nil)
-        @data.flush_all
-      rescue Dalli::DalliError => e
-        logger.error("DalliError (#{e}): #{e.message}") if logger
-        nil
+        rescue_error_with(nil) { @data.flush_all }
       end
 
       # Get the statistics from the memcached servers.
@@ -153,10 +148,7 @@ def stats
       protected
         # Read an entry from the cache.
         def read_entry(key, options) # :nodoc:
-          deserialize_entry(@data.get(key, options))
-        rescue Dalli::DalliError => e
-          logger.error("DalliError (#{e}): #{e.message}") if logger
-          nil
+          rescue_error_with(nil) { deserialize_entry(@data.get(key, options)) }
         end
 
         # Write an entry to the cache.
@@ -168,18 +160,14 @@ def write_entry(key, entry, options) # :nodoc:
             # Set the memcache expire a few minutes in the future to support race condition ttls on read
             expires_in += 5.minutes
           end
-          @data.send(method, key, value, expires_in, options)
-        rescue Dalli::DalliError => e
-          logger.error("DalliError (#{e}): #{e.message}") if logger
-          false
+          rescue_error_with false do
+            @data.send(method, key, value, expires_in, options)
+          end
         end
 
         # Delete an entry from the cache.
         def delete_entry(key, options) # :nodoc:
-          @data.delete(key)
-        rescue Dalli::DalliError => e
-          logger.error("DalliError (#{e}): #{e.message}") if logger
-          false
+          rescue_error_with(false) { @data.delete(key) }
         end
 
       private
@@ -199,10 +187,15 @@ 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
           end
         end
+
+        def rescue_error_with(fallback)
+          yield
+        rescue Dalli::DalliError => e
+          logger.error("DalliError (#{e}): #{e.message}") if logger
+          fallback
+        end
     end
   end
 end