Rename micronaut-redis to micronaut-cache-redis

- Rename module directory and update all references
- Add trace logging to RedisCache for debugging key operations
- Add changelog.txt

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: pditommaso

.github/workflows/build.yml

@@ -83,7 +83,7 @@ jobs:
           bash publish.sh lib-serde-moshi
           bash publish.sh lib-serde-jackson
           bash publish.sh lib-trace
-          bash publish.sh micronaut-redis
+          bash publish.sh micronaut-cache-redis
 
         env:
           GRADLE_OPTS: '-Dorg.gradle.daemon=false'

.github/workflows/generate-submit-dependencies.yml

@@ -34,7 +34,7 @@ jobs:
           "lib-serde-jackson",
           "lib-trace",
           "lib-util-http",
-          "micronaut-redis",
+          "micronaut-cache-redis",
           "wave-api",
           "wave-utils"
         ]

micronaut-redis/README.md micronaut-cache-redis/README.mdmicronaut-redis/README.md renamed to micronaut-cache-redis/README.md

@@ -17,7 +17,7 @@ Add the dependency to your `build.gradle`:
 
 ```groovy
 dependencies {
-    implementation 'io.seqera:micronaut-redis:1.0.0'
+    implementation 'io.seqera:micronaut-cache-redis:1.0.0'
 }
 ```
 
@@ -139,6 +139,67 @@ public class CacheService {
 }
 ```
 
+### Custom Value Serializer
+
+The default serializer uses JDK serialization, which requires cached objects to implement `Serializable`. For objects that don't implement `Serializable` (e.g., generated DTOs), you can use a JSON-based serializer.
+
+Create a Jackson serializer:
+
+```java
+@Singleton
+public class JacksonObjectSerializer implements ObjectSerializer {
+
+    @Inject
+    private ObjectMapper objectMapper;
+
+    @Override
+    public Optional<byte[]> serialize(Object object) {
+        if (object == null) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(objectMapper.writeValueAsBytes(object));
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to serialize object", e);
+        }
+    }
+
+    @Override
+    public <T> Optional<T> deserialize(byte[] bytes, Class<T> requiredType) {
+        if (bytes == null || bytes.length == 0) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.ofNullable(objectMapper.readValue(bytes, requiredType));
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to deserialize object", e);
+        }
+    }
+
+    @Override
+    public <T> Optional<T> deserialize(byte[] bytes, Argument<T> requiredType) {
+        if (bytes == null || bytes.length == 0) {
+            return Optional.empty();
+        }
+        try {
+            return Optional.ofNullable(objectMapper.readValue(bytes,
+                    objectMapper.constructType(requiredType.asType())));
+        } catch (IOException e) {
+            throw new RuntimeException("Failed to deserialize object", e);
+        }
+    }
+}
+```
+
+Configure it:
+
+```yaml
+redis:
+  caches:
+    my-cache:
+      value-serializer: com.example.JacksonObjectSerializer
+```
+
 ### Custom Expiration Policy
 
 Implement `ExpirationAfterWritePolicy` for dynamic TTL:

micronaut-redis/VERSION micronaut-cache-redis/VERSIONmicronaut-redis/VERSION renamed to micronaut-cache-redis/VERSION

@@ -0,0 +1,13 @@
+# micronaut-cache-redis changelog
+
+1.0.0 - 8 Jan 2026
+- Initial release of micronaut-cache-redis
+- Micronaut cache implementation using Jedis Redis driver
+- Drop-in compatibility with official Micronaut Redis (Lettuce) cache module
+- Support for @Cacheable, @CachePut, @CacheInvalidate annotations
+- JedisPool-based connection pooling
+- Expiration policies: expire-after-write, expire-after-access
+- Custom ExpirationAfterWritePolicy support for dynamic TTL
+- AsyncCache support via CompletableFuture
+- Configurable key and value serializers
+- Same configuration namespace as official Lettuce implementation

micronaut-redis/build.gradle micronaut-cache-redis/build.gradlemicronaut-redis/build.gradle renamed to micronaut-cache-redis/build.gradle

@@ -37,6 +37,9 @@
 import redis.clients.jedis.params.SetParams;
 import redis.clients.jedis.resps.ScanResult;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.time.Duration;
 import java.util.List;
 import java.util.Optional;
@@ -55,6 +58,8 @@
 @Requires(classes = SyncCache.class)
 public class RedisCache implements SyncCache<JedisPool>, AutoCloseable {
 
+    private static final Logger log = LoggerFactory.getLogger(RedisCache.class);
+
     private final JedisPool jedisPool;
     private final ObjectSerializer keySerializer;
     private final ObjectSerializer valueSerializer;
@@ -133,22 +138,26 @@ public JedisPool getNativeCache() {
     @NonNull
     @Override
     public <T> Optional<T> get(@NonNull Object key, @NonNull Argument<T> requiredType) {
+        log.trace("Cache '{}' GET key={}", getName(), key);
         byte[] serializedKey = serializeKey(key);
         try (Jedis jedis = jedisPool.getResource()) {
             byte[] data = jedis.get(serializedKey);
             if (expireAfterAccess != null && data != null) {
                 jedis.pexpire(serializedKey, expireAfterAccess);
             }
             if (data != null) {
+                log.trace("Cache '{}' HIT key={}", getName(), key);
                 return valueSerializer.deserialize(data, requiredType);
             }
+            log.trace("Cache '{}' MISS key={}", getName(), key);
             return Optional.empty();
         }
     }
 
     @NonNull
     @Override
     public <T> T get(@NonNull Object key, @NonNull Argument<T> requiredType, @NonNull Supplier<T> supplier) {
+        log.trace("Cache '{}' GET-WITH-SUPPLIER key={}", getName(), key);
         byte[] serializedKey = serializeKey(key);
         try (Jedis jedis = jedisPool.getResource()) {
             byte[] data = jedis.get(serializedKey);
@@ -158,11 +167,13 @@ public <T> T get(@NonNull Object key, @NonNull Argument<T> requiredType, @NonNul
                     if (expireAfterAccess != null) {
                         jedis.pexpire(serializedKey, expireAfterAccess);
                     }
+                    log.trace("Cache '{}' HIT key={}", getName(), key);
                     return deserialized.get();
                 }
             }
         }
 
+        log.trace("Cache '{}' MISS key={}, invoking supplier", getName(), key);
         T value = supplier.get();
         putValue(serializedKey, value);
         return value;
@@ -172,25 +183,30 @@ public <T> T get(@NonNull Object key, @NonNull Argument<T> requiredType, @NonNul
     @Override
     @SuppressWarnings("unchecked")
     public <T> Optional<T> putIfAbsent(@NonNull Object key, @NonNull T value) {
+        log.trace("Cache '{}' PUT-IF-ABSENT key={}", getName(), key);
         byte[] serializedKey = serializeKey(key);
         try (Jedis jedis = jedisPool.getResource()) {
             byte[] existingData = jedis.get(serializedKey);
             if (existingData != null) {
+                log.trace("Cache '{}' PUT-IF-ABSENT key={} already exists, returning existing value", getName(), key);
                 return valueSerializer.deserialize(existingData, Argument.of((Class<T>) value.getClass()));
             }
+            log.trace("Cache '{}' PUT-IF-ABSENT key={} storing new value", getName(), key);
             putValue(serializedKey, value);
             return Optional.empty();
         }
     }
 
     @Override
     public void put(@NonNull Object key, @NonNull Object value) {
+        log.trace("Cache '{}' PUT key={}", getName(), key);
         byte[] serializedKey = serializeKey(key);
         putValue(serializedKey, value);
     }
 
     @Override
     public void invalidate(@NonNull Object key) {
+        log.trace("Cache '{}' INVALIDATE key={}", getName(), key);
         byte[] serializedKey = serializeKey(key);
         try (Jedis jedis = jedisPool.getResource()) {
             jedis.del(serializedKey);
@@ -199,20 +215,25 @@ public void invalidate(@NonNull Object key) {
 
     @Override
     public void invalidateAll() {
+        log.trace("Cache '{}' INVALIDATE-ALL pattern={}", getName(), getKeysPattern());
         String pattern = getKeysPattern();
         try (Jedis jedis = jedisPool.getResource()) {
             ScanParams params = new ScanParams()
                     .match(pattern)
                     .count(invalidateScanCount.intValue());
             String cursor = ScanParams.SCAN_POINTER_START;
+            int totalDeleted = 0;
             do {
                 ScanResult<byte[]> scanResult = jedis.scan(cursor.getBytes(redisCacheConfiguration.getCharset()), params);
                 List<byte[]> keys = scanResult.getResult();
                 if (!keys.isEmpty()) {
                     jedis.del(keys.toArray(new byte[0][]));
+                    totalDeleted += keys.size();
+                    log.trace("Cache '{}' INVALIDATE-ALL deleted {} keys in this batch", getName(), keys.size());
                 }
                 cursor = scanResult.getCursor();
             } while (!ScanParams.SCAN_POINTER_START.equals(cursor));
+            log.trace("Cache '{}' INVALIDATE-ALL completed, total keys deleted: {}", getName(), totalDeleted);
         }
     }
 
@@ -263,11 +284,14 @@ protected <T> void putValue(byte[] serializedKey, T value) {
                 byte[] bytes = serialized.get();
                 if (expireAfterWritePolicy != null) {
                     long ttl = expireAfterWritePolicy.getExpirationAfterWrite(value);
+                    log.trace("Cache '{}' storing value with TTL={}ms, size={} bytes", getName(), ttl, bytes.length);
                     jedis.psetex(serializedKey, ttl, bytes);
                 } else {
+                    log.trace("Cache '{}' storing value without TTL, size={} bytes", getName(), bytes.length);
                     jedis.set(serializedKey, bytes);
                 }
             } else {
+                log.trace("Cache '{}' value serialization returned empty, deleting key", getName());
                 jedis.del(serializedKey);
             }
         }