legion-cache 1.3.4 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c04121f4d10bcc0076e189557b0036d02237fb97fd8bfa9c67779df4298d2e41
-  data.tar.gz: faaf6c6c82212257a9e99866948f57269147e0b942301893d100e580cd47e743
+  metadata.gz: 99c05f6312bd657aa7c85e953e6ec8cbf73ad621953239964a9cb25e7d5ec120
+  data.tar.gz: 95292e0a0e278bf124c4e09bc4dc04a41078d3afff7d3484b64d402f825efba6
 SHA512:
-  metadata.gz: ee4dfdf2ac8827b26ebfe5048450b951573fdc8e548b7016f33ed1f3caf2aa6ca56310aa5107942d7b5a388644b3a881c0e8ecee5a9440ef51a79308ab9b79f7
-  data.tar.gz: 185e0503c8bfbfcd839031ffe1d8300e4f3e4d475e627841d1ca9ae5cd9965566fcf5006da522fd29d65bf7e079fd372562aefae528e7db0f892e4f1738aa48c
+  metadata.gz: 2376fa09e3540aa1044d5eb82169c09a2425fa0cef0d3e597633ab96ed3bff0722e459d3e716383b4b9652bce6c6d4d3883c8afe9df61b6b5e0ba0a7fa0f4fcb
+  data.tar.gz: 689a94946a67c949cf436ba6786f05e67e143a73bfac84796cdc9240f9c36d17da4312739f43022c5c69d2d52c6003607224132e0f142f6177e64a879e280938

data/.rubocop.yml

@@ -48,3 +48,6 @@ Style/FrozenStringLiteralComment:
 
 Naming/FileName:
   Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [1.3.7] - 2026-03-22
+
+### Added
+- Redis driver: `.debug` logging on get (hit/miss), set (ttl/success), delete, flush, mget (key count), mset (key count)
+- Redis driver: `.info` on successful client creation with host/port address
+- Redis driver: private `resolved_redis_address` helper for extracting address at connect time
+- Pool: `.info` on close and restart
+- Cacheable: `.debug` on cache hit/miss in wrapper; `.warn` on swallowed errors in `local_cache_read`/`local_cache_write`
+- Local: `.debug` on get/set/fetch/delete/flush operations
+- Cache: `.info` on successful shared cache setup (driver + server)
+- All new logging calls guarded with `if defined?(Legion::Logging)` for standalone use
+
+## [1.3.6] - 2026-03-21
+
+### Added
+- Redis Cluster mode: `cluster:`, `replica:`, `fixed_hostname:` options in `build_redis_client`
+- `cluster_mode?` predicate for runtime cluster detection
+- `mget(*keys)` and `mset(hash)` with automatic slot-aware grouping for cross-slot operations
+- Cluster-aware `flush` that iterates all primary nodes via `CLUSTER NODES`
+- Failover logging: `Redis::BaseError` rescues log via `Legion::Logging.warn` before re-raising
+- Settings defaults: `cluster: nil`, `replica: false`, `fixed_hostname: nil`
+
+### Fixed
+- `get`, `set`, `delete`, `flush` visibility changed from private to public (were inaccessible on the module directly)
+
+## [1.3.5] - 2026-03-21
+
+### Added
+- TLS support for Redis driver: `ssl: true` + `ssl_params` when TLS enabled via `Legion::Crypt::TLS.resolve`
+- TLS support for Memcached driver: `ssl_context` option when TLS enabled via `Legion::Crypt::TLS.resolve`
+- Port-based auto-detection: Redis TLS port 6380, Memcached TLS port 11207
+
 ## [1.3.3] - 2026-03-20
 
 ### Fixed

data/lib/legion/cache/cacheable.rb

@@ -28,7 +28,12 @@ module Legion
 
             unless bypass_local_method_cache
               cached = Legion::Cache::Cacheable.cache_read(key, scope: config[:scope])
-              return cached unless cached.nil?
+              if cached.nil?
+                Legion::Logging.debug "[cacheable] miss key=#{key}" if defined?(Legion::Logging)
+              else
+                Legion::Logging.debug "[cacheable] hit key=#{key}" if defined?(Legion::Logging)
+                return cached
+              end
             end
 
             result = super(**kwargs)
@@ -86,7 +91,8 @@ module Legion
         return nil unless local_cache_available?
 
         Legion::Cache::Local.get(key)
-      rescue StandardError
+      rescue StandardError => e
+        Legion::Logging.warn "[cacheable] local_cache_read failed key=#{key} error=#{e.message}" if defined?(Legion::Logging)
         nil
       end
 
@@ -94,7 +100,8 @@ module Legion
         return unless local_cache_available?
 
         Legion::Cache::Local.set(key, value, ttl)
-      rescue StandardError
+      rescue StandardError => e
+        Legion::Logging.warn "[cacheable] local_cache_write failed key=#{key} error=#{e.message}" if defined?(Legion::Logging)
         nil
       end
 

data/lib/legion/cache/local.rb

@@ -36,23 +36,33 @@ module Legion
         end
 
         def get(key)
-          @driver.get(key)
+          result = @driver.get(key)
+          Legion::Logging.debug "[cache:local] GET #{key} hit=#{!result.nil?}" if defined?(Legion::Logging)
+          result
         end
 
         def set(key, value, ttl = 180)
-          @driver.set(key, value, ttl)
+          result = @driver.set(key, value, ttl)
+          Legion::Logging.debug "[cache:local] SET #{key} ttl=#{ttl} success=#{result}" if defined?(Legion::Logging)
+          result
         end
 
         def fetch(key, ttl = nil)
-          @driver.fetch(key, ttl)
+          result = @driver.fetch(key, ttl)
+          Legion::Logging.debug "[cache:local] FETCH #{key} hit=#{!result.nil?}" if defined?(Legion::Logging)
+          result
         end
 
         def delete(key)
-          @driver.delete(key)
+          result = @driver.delete(key)
+          Legion::Logging.debug "[cache:local] DELETE #{key} success=#{result}" if defined?(Legion::Logging)
+          result
         end
 
         def flush(delay = 0)
-          @driver.flush(delay)
+          result = @driver.flush(delay)
+          Legion::Logging.debug '[cache:local] FLUSH completed' if defined?(Legion::Logging)
+          result
         end
 
         def client

data/lib/legion/cache/memcached.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'openssl'
 require 'dalli'
 require 'legion/cache/pool'
 
@@ -7,7 +8,7 @@ module Legion
   module Cache
     module Memcached
       include Legion::Cache::Pool
-      extend self # rubocop:disable Style/ModuleFunction
+      extend self
 
       def client(server: nil, servers: nil, **opts)
         return @client unless @client.nil?
@@ -27,6 +28,9 @@ module Legion
         cache_opts[:value_max_bytes] ||= 8 * 1024 * 1024
         cache_opts[:serializer] ||= Legion::JSON
 
+        tls_ctx = memcached_tls_context(port: resolved.first.split(':').last.to_i)
+        cache_opts[:ssl_context] = tls_ctx if tls_ctx
+
         @client = ConnectionPool.new(size: pool_size, timeout: timeout) do
           Dalli::Client.new(resolved, cache_opts)
         end
@@ -62,6 +66,28 @@ module Legion
       def flush(delay = 0)
         client.with { |conn| conn.flush(delay).first }
       end
+
+      private
+
+      def memcached_tls_context(port:)
+        return nil unless defined?(Legion::Crypt::TLS)
+
+        tls = Legion::Crypt::TLS.resolve(memcached_tls_settings, port: port)
+        return nil unless tls[:enabled]
+
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.verify_mode = tls[:verify] == :none ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+        ctx.ca_file     = tls[:ca] if tls[:ca]
+        ctx
+      end
+
+      def memcached_tls_settings
+        return {} unless defined?(Legion::Settings)
+
+        Legion::Settings[:cache][:tls] || {}
+      rescue StandardError
+        {}
+      end
     end
   end
 end

data/lib/legion/cache/pool.rb

@@ -31,6 +31,7 @@ module Legion
         client.shutdown(&:close)
         @client = nil
         @connected = false
+        Legion::Logging.info "#{name} pool closed" if defined?(Legion::Logging)
       end
 
       def restart(**opts)
@@ -41,6 +42,7 @@ module Legion
         client_hash[:timeout] = opts[:timeout] if opts.key? :timeout
         client(**client_hash)
         @connected = true
+        Legion::Logging.info "#{name} pool restarted" if defined?(Legion::Logging)
       end
     end
   end

data/lib/legion/cache/redis.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'openssl'
 require 'redis'
 require 'legion/cache/pool'
 require 'legion/cache/settings'
@@ -8,51 +9,205 @@ module Legion
   module Cache
     module Redis
       include Legion::Cache::Pool
-      extend self # rubocop:disable Style/ModuleFunction
+      extend self
 
-      def client(pool_size: 20, timeout: 5, server: nil, servers: [], cluster: nil, **) # rubocop:disable Metrics/ParameterLists
+      def client(pool_size: 20, timeout: 5, server: nil, servers: [], cluster: nil, replica: false, fixed_hostname: nil, **) # rubocop:disable Metrics/ParameterLists
         return @client unless @client.nil?
 
         @pool_size = pool_size
         @timeout   = timeout
+        @cluster_mode = Array(cluster).compact.any?
 
         @client = ConnectionPool.new(size: pool_size, timeout: timeout) do
-          build_redis_client(server: server, servers: servers, cluster: cluster)
+          build_redis_client(server: server, servers: servers, cluster: cluster,
+                             replica: replica, fixed_hostname: fixed_hostname)
         end
         @connected = true
+        Legion::Logging.info "Redis connected to #{resolved_redis_address(server: server, servers: servers, cluster: cluster)}" if defined?(Legion::Logging)
         @client
       end
 
-      def build_redis_client(server: nil, servers: [], cluster: nil)
+      def build_redis_client(server: nil, servers: [], cluster: nil, replica: false, fixed_hostname: nil)
         nodes = Array(cluster).compact
         if nodes.any?
-          ::Redis.new(cluster: nodes)
+          opts = { cluster: nodes }
+          opts[:replica] = true if replica
+          opts[:fixed_hostname] = fixed_hostname unless fixed_hostname.nil?
+          ::Redis.new(**opts)
         else
           resolved = Legion::Cache::Settings.resolve_servers(
             driver: 'redis', server: server, servers: servers
           )
           host, port = resolved.first.split(':')
-          ::Redis.new(host: host, port: port.to_i)
+          redis_opts = { host: host, port: port.to_i }
+          redis_opts.merge!(redis_tls_options(port: port.to_i))
+          ::Redis.new(**redis_opts)
         end
       end
 
+      def cluster_mode?
+        @cluster_mode == true
+      end
+
       def get(key)
-        client.with { |conn| conn.get(key) }
+        result = client.with { |conn| conn.get(key) }
+        Legion::Logging.debug "[cache] GET #{key} hit=#{!result.nil?}" if defined?(Legion::Logging)
+        result
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
       end
       alias fetch get
 
       def set(key, value, ttl: nil)
         args = {}
         args[:ex] = ttl unless ttl.nil?
-        client.with { |conn| conn.set(key, value, **args) == 'OK' }
+        result = client.with { |conn| conn.set(key, value, **args) == 'OK' }
+        Legion::Logging.debug "[cache] SET #{key} ttl=#{ttl.inspect} success=#{result}" if defined?(Legion::Logging)
+        result
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
       end
 
       def delete(key)
-        client.with { |conn| conn.del(key) == 1 }
+        result = client.with { |conn| conn.del(key) == 1 }
+        Legion::Logging.debug "[cache] DELETE #{key} success=#{result}" if defined?(Legion::Logging)
+        result
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
       end
 
       def flush
-        client.with { |conn| conn.flushdb == 'OK' }
+        result = client.with do |conn|
+          if cluster_mode?
+            cluster_flush(conn)
+          else
+            conn.flushdb == 'OK'
+          end
+        end
+        Legion::Logging.debug '[cache] FLUSH completed' if defined?(Legion::Logging)
+        result
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
+      end
+
+      def mget(*keys)
+        keys = keys.flatten
+        return {} if keys.empty?
+
+        result = client.with do |conn|
+          if cluster_mode?
+            cluster_mget(conn, keys)
+          else
+            values = conn.mget(*keys)
+            keys.zip(values).to_h
+          end
+        end
+        Legion::Logging.debug "[cache] MGET keys=#{keys.size}" if defined?(Legion::Logging)
+        result
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
+      end
+
+      def mset(hash)
+        return true if hash.empty?
+
+        result = client.with do |conn|
+          if cluster_mode?
+            cluster_mset(conn, hash)
+          else
+            conn.mset(*hash.flatten) == 'OK'
+          end
+        end
+        Legion::Logging.debug "[cache] MSET keys=#{hash.size}" if defined?(Legion::Logging)
+        result
+      rescue ::Redis::BaseError => e
+        log_cluster_error(e)
+        raise
+      end
+
+      private
+
+      def cluster_mget(conn, keys)
+        groups = group_keys_by_slot(keys)
+        result = {}
+        groups.each_value do |group_keys|
+          values = conn.mget(*group_keys)
+          group_keys.zip(values).each { |k, v| result[k] = v }
+        end
+        result
+      end
+
+      def cluster_mset(conn, hash)
+        groups = group_keys_by_slot(hash.keys)
+        groups.each_value do |group_keys|
+          pairs = group_keys.flat_map { |k| [k, hash[k]] }
+          conn.mset(*pairs)
+        end
+        true
+      end
+
+      def cluster_flush(conn)
+        node_info = conn.cluster('nodes')
+        primaries = node_info.lines.select { |l| l.include?('master') }.map { |l| l.split[1].split('@').first }
+        primaries.each do |addr|
+          host, port = addr.split(':')
+          node = ::Redis.new(host: host, port: port.to_i)
+          node.flushdb
+          node.close
+        end
+        true
+      rescue StandardError
+        conn.flushdb == 'OK'
+      end
+
+      def group_keys_by_slot(keys)
+        if defined?(::Redis::Cluster::KeySlotConverter)
+          keys.group_by { |k| ::Redis::Cluster::KeySlotConverter.convert(k) }
+        else
+          { 0 => keys }
+        end
+      end
+
+      def resolved_redis_address(server:, servers:, cluster:)
+        nodes = Array(cluster).compact
+        return nodes.join(', ') if nodes.any?
+
+        Legion::Cache::Settings.resolve_servers(driver: 'redis', server: server, servers: Array(servers)).first
+      rescue StandardError
+        'unknown'
+      end
+
+      def log_cluster_error(error)
+        return unless defined?(Legion::Logging)
+
+        Legion::Logging.warn "Redis cluster error: #{error.class} — #{error.message}"
+      end
+
+      def redis_tls_options(port:)
+        return {} unless defined?(Legion::Crypt::TLS)
+
+        tls = Legion::Crypt::TLS.resolve(cache_tls_settings, port: port)
+        return {} unless tls[:enabled]
+
+        ssl_params = {
+          verify_mode: tls[:verify] == :none ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+        }
+        ssl_params[:ca_file] = tls[:ca] if tls[:ca]
+
+        { ssl: true, ssl_params: ssl_params }
+      end
+
+      def cache_tls_settings
+        return {} unless defined?(Legion::Settings)
+
+        Legion::Settings[:cache][:tls] || {}
+      rescue StandardError
+        {}
       end
     end
   end

data/lib/legion/cache/settings.rb

@@ -13,19 +13,22 @@ module Legion
       Legion::Settings.merge_settings(:cache_local, local) if Legion::Settings.method_defined? :merge_settings
       def self.default
         {
-          driver:     driver,
-          servers:    resolve_servers(driver: driver),
-          connected:  false,
-          enabled:    true,
-          namespace:  'legion',
-          compress:   false,
-          failover:   true,
-          threadsafe: true,
-          expires_in: 0,
-          cache_nils: false,
-          pool_size:  10,
-          timeout:    5,
-          serializer: Legion::JSON
+          driver:         driver,
+          servers:        resolve_servers(driver: driver),
+          connected:      false,
+          enabled:        true,
+          namespace:      'legion',
+          compress:       false,
+          failover:       true,
+          threadsafe:     true,
+          expires_in:     0,
+          cache_nils:     false,
+          pool_size:      10,
+          timeout:        5,
+          serializer:     Legion::JSON,
+          cluster:        nil,
+          replica:        false,
+          fixed_hostname: nil
         }
       end
 

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '1.3.4'
+    VERSION = '1.3.7'
   end
 end

data/lib/legion/cache.rb

@@ -86,6 +86,9 @@ module Legion
         @connected = true
         @using_local = false
         Legion::Settings[:cache][:connected] = true
+        driver = Legion::Settings[:cache][:driver] || 'dalli'
+        servers = Legion::Settings[:cache][:servers] || []
+        Legion::Logging.info "Legion::Cache connected (driver=#{driver} servers=#{Array(servers).first})" if defined?(Legion::Logging)
       rescue StandardError => e
         Legion::Logging.warn "Shared cache unavailable (#{e.message}), falling back to Local" if defined?(Legion::Logging)
         if Legion::Cache::Local.connected?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-cache
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.7
 platform: ruby
 authors:
 - Esity