memcached_store 1.2.0 → 2.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e49987a84d92c00bdc0140eb182b55a7a928f1ed
-  data.tar.gz: 1a9788d127ef7dbf156c261316f39a1fe90c778c
+SHA256:
+  metadata.gz: 35c62775da1377543a0a6720634ffb2a8305f9797f68f953321fe6172601c474
+  data.tar.gz: 1a6faa8fbc0e24c90368596627cd0811619be98bc3b752605eef244e99a489fe
 SHA512:
-  metadata.gz: 7d1d23e7dbbce68a02bba13ab9a920b834044c2bff3b83497bb723f4b3d0c7a8d31074a47e8b5eb4440b61bb361670795fe30de76ba825320089b968a8c3ec7c
-  data.tar.gz: b46f2c4de9bd74ff25abd6cdd6ccd986b8df4e99cdc3d9f5294b7ea4d2281c7d6c165bb3fc8629505df4adb9addc1d38f8c9e33c4e9df834ee5275037cac76ff
+  metadata.gz: edb29ef36b023d97373270005715f2c734b28779e889dd4a5c3dbf9a7147314198e719d0b296acee7426f621f8157c321c906f1095284809333ac5806e7bc492
+  data.tar.gz: e842f684725982fec3815f225a76edaa65c558bec03330fa016382c1acfe16b3dff4f58bde75d1105f5f7395cb438e1cbb9c42b7b5b8a1f5b07b66aa0d85db43

data/lib/active_support/cache/memcached_snappy_store.rb

@@ -12,6 +12,16 @@ module ActiveSupport
     class MemcachedSnappyStore < MemcachedStore
       class UnsupportedOperation < StandardError; end
 
+      module SnappyCompressor
+        def self.compress(source)
+          Snappy.deflate(source)
+        end
+
+        def self.decompress(source)
+          Snappy.inflate(source)
+        end
+      end
+
       def increment(*)
         raise UnsupportedOperation, "increment is not supported by: #{self.class.name}"
       end
@@ -25,21 +35,10 @@ module ActiveSupport
         false
       end
 
-      private
-
-      def serialize_entry(entry, options)
-        value = options[:raw] ? entry.value.to_s : Marshal.dump(entry)
-        [Snappy.deflate(value), true]
-      end
-
-      def deserialize_entry(compressed_value)
-        if compressed_value
-          super(Snappy.inflate(compressed_value))
-        end
-      end
-
-      def cas_raw?(_options)
-        true
+      def initialize(*addresses, **options)
+        options[:codec] ||= ActiveSupport::Cache::MemcachedStore::Codec.new(compressor: SnappyCompressor)
+        options[:compress] = false
+        super(*addresses, **options)
       end
     end
   end

data/lib/active_support/cache/memcached_store.rb

@@ -1,5 +1,6 @@
 # file havily based out off https://github.com/rails/rails/blob/3-2-stable/activesupport/lib/active_support/cache/mem_cache_store.rb
 require 'digest/md5'
+require 'delegate'
 
 module ActiveSupport
   module Cache
@@ -13,34 +14,90 @@ module ActiveSupport
     class MemcachedStore < Store
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
 
+      class Codec
+        # use dalli compatible flags
+        SERIALIZED_FLAG = 0x1
+        COMPRESSED_FLAG = 0x2
+
+        # Older versions of this gem would use 0 for the flags whether or not
+        # the value was marshal dumped. By setting this flag, we can tell if
+        # it were set with an older version for backwards compatible decoding.
+        RAW_FLAG = 0x10
+
+        def initialize(serializer: Marshal, compressor: nil)
+          @serializer = serializer
+          @compressor = compressor
+        end
+
+        def encode(_key, value, flags)
+          unless value.is_a?(String)
+            flags |= SERIALIZED_FLAG
+            value = @serializer.dump(value)
+          end
+          if @compressor
+            flags |= COMPRESSED_FLAG
+            value = @compressor.compress(value)
+          end
+          flags |= RAW_FLAG if flags == 0
+          [value, flags]
+        end
+
+        def decode(_key, value, flags)
+          if (flags & COMPRESSED_FLAG) != 0
+            value = @compressor.decompress(value)
+          end
+
+          if (flags & SERIALIZED_FLAG) != 0
+            @serializer.load(value)
+          elsif flags == 0 # legacy cache value
+            @serializer.load(value) rescue value
+          else
+            value
+          end
+        end
+      end
+
       attr_accessor :read_only, :swallow_exceptions
-      attr_writer :on_error
 
-      def initialize(*addresses)
+      prepend(Strategy::LocalCache)
+
+      def initialize(*addresses, **options)
         addresses = addresses.flatten
-        options = addresses.extract_options!
+        options[:codec] ||= Codec.new
         @swallow_exceptions = true
         @swallow_exceptions = options.delete(:swallow_exceptions) if options.key?(:swallow_exceptions)
 
-        super(options)
+        if options.key?(:coder)
+          raise ArgumentError, "ActiveSupport::Cache::MemcachedStore doesn't support custom coders"
+        end
+
+        # We don't use a coder, so we set it to nil so Active Support don't think we're using
+        # a deprecated one.
+        super(options.merge(coder: nil))
 
         if addresses.first.is_a?(Memcached)
-          @data = addresses.first
+          @connection = addresses.first
           raise "Memcached::Rails is no longer supported, "\
-                "use a Memcached instance instead" if @data.is_a?(Memcached::Rails)
+                "use a Memcached instance instead" if @connection.is_a?(Memcached::Rails)
         else
           mem_cache_options = options.dup
           servers = mem_cache_options.delete(:servers)
           UNIVERSAL_OPTIONS.each { |name| mem_cache_options.delete(name) }
-          @data = Memcached.new([*addresses, *servers], mem_cache_options)
+          @connection = Memcached.new([*addresses, *servers], mem_cache_options)
         end
-
-        extend Strategy::LocalCache
       end
 
-      def logger
-        return @logger if defined?(@logger)
-        @logger = ::Rails.logger if defined?(::Rails)
+      def append(name, value, options = nil)
+        return true if read_only
+        options = merged_options(options)
+        normalized_key = normalize_key(name, options)
+
+        handle_exceptions(return_value_on_error: nil, on_miss: false, miss_exceptions: [Memcached::NotStored]) do
+          instrument(:append, name) do
+            @connection.append(normalized_key, value)
+          end
+          true
+        end
       end
 
       def write(*)
@@ -63,7 +120,7 @@ module ActiveSupport
 
         handle_exceptions(return_value_on_error: {}) do
           instrument(:read_multi, names, options) do
-            if raw_values = @data.get(keys_to_names.keys, false)
+            if raw_values = @connection.get(keys_to_names.keys)
               raw_values.each do |key, value|
                 entry = deserialize_entry(value)
                 values[keys_to_names[key]] = entry.value unless entry.expired?
@@ -77,30 +134,40 @@ module ActiveSupport
       def cas(name, options = nil)
         options = merged_options(options)
         key = normalize_key(name, options)
+        payload = nil
 
-        handle_exceptions(return_value_on_error: false) do
+        success = handle_exceptions(return_value_on_error: false) do
           instrument(:cas, name, options) do
-            @data.cas(key, expiration(options), !cas_raw?(options)) do |raw_value|
+            @connection.cas(key, expiration(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
+              payload = serialize_entry(Entry.new(value, **options), options)
             end
           end
           true
         end
+
+        if success
+          local_cache.write_entry(key, payload) if local_cache
+        else
+          local_cache.delete_entry(key) if local_cache
+        end
+
+        success
       end
 
-      def cas_multi(*names)
-        options = names.extract_options!
+      def cas_multi(*names, **options)
         return if names.empty?
 
         options = merged_options(options)
         keys_to_names = Hash[names.map { |name| [normalize_key(name, options), name] }]
 
+        sent_payloads = nil
+
         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|
+            written_payloads = @connection.cas(keys_to_names.keys, expiration(options)) do |raw_values|
               values = {}
 
               raw_values.each do |key, raw_value|
@@ -113,11 +180,22 @@ module ActiveSupport
               break true if read_only
 
               serialized_values = values.map do |name, value|
-                [normalize_key(name, options), serialize_entry(Entry.new(value, options), options).first]
+                [normalize_key(name, options), serialize_entry(Entry.new(value, **options), options)]
               end
 
-              Hash[serialized_values]
+              sent_payloads = Hash[serialized_values]
             end
+
+            if local_cache && sent_payloads
+              sent_payloads.each_key do |key|
+                if written_payloads.key?(key)
+                  local_cache.write_entry(key, written_payloads[key])
+                else
+                  local_cache.delete_entry(key)
+                end
+              end
+            end
+
             true
           end
         end
@@ -127,7 +205,7 @@ module ActiveSupport
         options = merged_options(options)
         handle_exceptions(return_value_on_error: nil) do
           instrument(:increment, name, amount: amount) do
-            @data.incr(normalize_key(name, options), amount)
+            @connection.incr(normalize_key(name, options), amount)
           end
         end
       end
@@ -136,20 +214,20 @@ module ActiveSupport
         options = merged_options(options)
         handle_exceptions(return_value_on_error: nil) do
           instrument(:decrement, name, amount: amount) do
-            @data.decr(normalize_key(name, options), amount)
+            @connection.decr(normalize_key(name, options), amount)
           end
         end
       end
 
       def clear(options = nil)
         ActiveSupport::Notifications.instrument("cache_clear.active_support", options || {}) do
-          @data.flush
+          @connection.flush
         end
       end
 
       def stats
         ActiveSupport::Notifications.instrument("cache_stats.active_support") do
-          @data.stats
+          @connection.stats
         end
       end
 
@@ -159,104 +237,156 @@ module ActiveSupport
 
       def reset #:nodoc:
         handle_exceptions(return_value_on_error: false) do
-          @data.reset
+          @connection.reset
         end
       end
 
-      protected
+      private
+
+      if private_method_defined?(:read_serialized_entry)
+        class DupLocalStore < DelegateClass(Strategy::LocalCache::LocalStore)
+          def write_entry(_key, entry)
+            if entry.is_a?(Entry)
+              entry.dup_value!
+            end
+            super
+          end
 
-      def read_entry(key, _options) # :nodoc:
-        handle_exceptions(return_value_on_error: nil) do
-          deserialize_entry(@data.get(escape_key(key), false))
+          def fetch_entry(key)
+            entry = super do
+              new_entry = yield
+              if entry.is_a?(Entry)
+                new_entry.dup_value!
+              end
+              new_entry
+            end
+            entry = entry.dup
+
+            if entry.is_a?(Entry)
+              entry.dup_value!
+            end
+
+            entry
+          end
         end
-      end
 
-      def write_entry(key, entry, options) # :nodoc:
-        return true if read_only
-        method = options && options[:unless_exist] ? :add : :set
-        expires_in = expiration(options)
-        value, raw = serialize_entry(entry, options)
-        handle_exceptions(return_value_on_error: false) do
-          @data.send(method, escape_key(key), value, expires_in, !raw)
-          true
+        module DupLocalCache
+          private
+
+          def local_cache
+            if local_cache = super
+              DupLocalStore.new(local_cache)
+            end
+          end
         end
-      end
 
-      def delete_entry(key, _options) # :nodoc:
-        return true if read_only
-        handle_exceptions(return_value_on_error: false, on_miss: true) do
-          @data.delete(escape_key(key))
-          true
+        prepend DupLocalCache
+
+        def read_entry(key, **options) # :nodoc:
+          deserialize_entry(read_serialized_entry(key, **options))
         end
-      end
 
-      private
+        def read_serialized_entry(key, **)
+          handle_exceptions(return_value_on_error: nil) do
+            @connection.get(key)
+          end
+        end
 
-      if ActiveSupport::VERSION::MAJOR < 5
-        def normalize_key(key, options)
-          escape_key(namespaced_key(key, options))
+        def write_entry(key, entry, **options) # :nodoc:
+          return true if read_only
+
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
         end
 
-        def escape_key(key)
-          key = key.to_s.dup
-          key = key.force_encoding(Encoding::ASCII_8BIT)
-          key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
-          key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
-          key
+        def write_serialized_entry(key, value, **options)
+          method = options && options[:unless_exist] ? :add : :set
+          expires_in = expiration(options)
+          handle_exceptions(return_value_on_error: false) do
+            @connection.send(method, key, value, expires_in)
+            true
+          end
         end
       else
-        def normalize_key(key, options)
-          key = super.dup
-          key = key.force_encoding(Encoding::ASCII_8BIT)
-          key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
-          key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
-          key
+        def read_entry(key, _options) # :nodoc:
+          handle_exceptions(return_value_on_error: nil) do
+            deserialize_entry(@connection.get(key))
+          end
         end
 
-        def escape_key(key)
-          key
+        def write_entry(key, entry, options) # :nodoc:
+          return true if read_only
+          method = options && options[:unless_exist] ? :add : :set
+          expires_in = expiration(options)
+          value = serialize_entry(entry, options)
+          handle_exceptions(return_value_on_error: false) do
+            @connection.send(method, key, value, expires_in)
+            true
+          end
         end
       end
 
-      def deserialize_entry(raw_value)
-        if raw_value
-          entry = begin
-                      Marshal.load(raw_value)
-                    rescue
-                      raw_value
-                    end
-          entry.is_a?(Entry) ? entry : Entry.new(entry)
+      def delete_entry(key, _options = nil) # :nodoc:
+        return true if read_only
+        handle_exceptions(return_value_on_error: false, on_miss: true) do
+          @connection.delete(key)
+          true
         end
       end
 
-      def serialize_entry(entry, options)
-        entry = entry.value.to_s if options[:raw]
-        [entry, options[:raw]]
+      private
+
+      def normalize_key(key, options)
+        key = super.dup
+        key = key.force_encoding(Encoding::ASCII_8BIT)
+        key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
+        # When we remove support to Rails 5.1 we can change the code to use ActiveSupport::Digest
+        key = "#{key[0, 213]}:md5:#{::Digest::MD5.hexdigest(key)}" if key.size > 250
+        key
+      end
+
+      def deserialize_entry(value)
+        unless value.nil?
+          value.is_a?(Entry) ? value : Entry.new(value, compress: false)
+        end
       end
 
-      def cas_raw?(options)
-        options[:raw]
+      def serialize_entry(entry, options = nil)
+        if options && options[:raw]
+          entry.value.to_s
+        else
+          entry
+        end
       end
 
       def expiration(options)
         expires_in = options[:expires_in].to_i
-        if expires_in > 0 && !options[:raw]
-          # Set the memcache expire a few minutes in the future to support race condition ttls on read
-          expires_in += 5.minutes.to_i
+        if expires_in > 0 && options[:race_condition_ttl] && !options[:raw]
+          expires_in += options[:race_condition_ttl].to_i
         end
         expires_in
       end
 
-      def handle_exceptions(return_value_on_error:, on_miss: return_value_on_error)
+      def handle_exceptions(return_value_on_error:, on_miss: return_value_on_error, miss_exceptions: [])
         yield
-      rescue Memcached::NotFound, Memcached::ConnectionDataExists
+      rescue Memcached::NotFound, Memcached::ConnectionDataExists, *miss_exceptions
         on_miss
       rescue Memcached::Error => e
-        @on_error.call(e) if @on_error
+        log_warning(e)
         raise unless @swallow_exceptions
-        logger.warn("memcached error: #{e.class}: #{e.message}") if logger
         return_value_on_error
       end
+
+      def log_warning(err)
+        return unless logger
+        return if err.is_a?(Memcached::NotStored) && @swallow_exceptions
+
+        logger.warn(
+          "[MEMCACHED_ERROR] swallowed=#{@swallow_exceptions}" \
+          " exception_class=#{err.class} exception_message=#{err.message}"
+        )
+      end
+
+      ActiveSupport.run_load_hooks(:memcached_store)
     end
   end
 end

data/lib/memcached_store/railtie.rb

@@ -0,0 +1,9 @@
+module MemcachedStore
+  class Railtie < Rails::Railtie
+    initializer 'memcached_store.configuration' do
+      ActiveSupport.on_load(:memcached_store) do
+        ActiveSupport::Cache::MemcachedStore.logger ||= Rails.logger
+      end
+    end
+  end
+end

data/lib/memcached_store/version.rb

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

data/lib/memcached_store.rb

@@ -1,3 +1,4 @@
 require "memcached"
 require "active_support"
 require "active_support/cache"
+require "memcached_store/railtie" if defined?(Rails)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memcached_store
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.3.4
 platform: ruby
 authors:
 - Camilo Lopez
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-05 00:00:00.000000000 Z
+date: 2023-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -19,28 +19,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: memcached
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -55,6 +55,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Plugin-able Memcached adapters to add features (compression, safety)
 email:
 - camilo@camilolopez.com
@@ -70,11 +98,13 @@ files:
 - lib/active_support/cache/memcached_snappy_store.rb
 - lib/active_support/cache/memcached_store.rb
 - lib/memcached_store.rb
+- lib/memcached_store/railtie.rb
 - lib/memcached_store/version.rb
 homepage: https://github.com/Shopify/memcached_store/
 licenses:
 - MIT
-metadata: {}
+metadata:
+  allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -83,15 +113,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.1
+rubygems_version: 3.4.20
 signing_key: 
 specification_version: 4
 summary: Plugin-able Memcached adapters to add features (compression, safety)