legion-cache 1.3.6 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83c05e01834ac3a2715494122657a540ab6fb0fc23c4b4645f5b3ecf0198279c
-  data.tar.gz: e6f944dfa7efa6952810b50766297ce75d39cf6d07bd04af732c8f200e8db051
+  metadata.gz: 99c05f6312bd657aa7c85e953e6ec8cbf73ad621953239964a9cb25e7d5ec120
+  data.tar.gz: 95292e0a0e278bf124c4e09bc4dc04a41078d3afff7d3484b64d402f825efba6
 SHA512:
-  metadata.gz: 79f8620e6101271ab6eb1ec63aecba4a79f2416a2c1b970a1fa02333104a06e6818bc1c7af353a3c5b630d2769834bc9bc8c6a17a4707903cfa4519ffb3884d0
-  data.tar.gz: 41c24ca832173bce18bd4b58772426f2cb2c798443315aff4fccbd5fc460f9682c60ef15f3e5e83264f89a3bd2d52203eac2f74cd3264e06e1416338077fa5d2
+  metadata.gz: 2376fa09e3540aa1044d5eb82169c09a2425fa0cef0d3e597633ab96ed3bff0722e459d3e716383b4b9652bce6c6d4d3883c8afe9df61b6b5e0ba0a7fa0f4fcb
+  data.tar.gz: 689a94946a67c949cf436ba6786f05e67e143a73bfac84796cdc9240f9c36d17da4312739f43022c5c69d2d52c6003607224132e0f142f6177e64a879e280938

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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

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/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

@@ -23,6 +23,7 @@ module Legion
                              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
 
@@ -49,7 +50,9 @@ module Legion
       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
@@ -59,27 +62,33 @@ module Legion
       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 do |conn|
+        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
@@ -89,14 +98,16 @@ module Legion
         keys = keys.flatten
         return {} if keys.empty?
 
-        client.with do |conn|
+        result = client.with do |conn|
           if cluster_mode?
             cluster_mget(conn, keys)
           else
-            result = conn.mget(*keys)
-            keys.zip(result).to_h
+            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
@@ -105,13 +116,15 @@ module Legion
       def mset(hash)
         return true if hash.empty?
 
-        client.with do |conn|
+        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
@@ -160,6 +173,15 @@ module Legion
         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)
 

data/lib/legion/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module Cache
-    VERSION = '1.3.6'
+    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.6
+  version: 1.3.7
 platform: ruby
 authors:
 - Esity