Feature - implementation of Spring Cache methods added in Spring 5.2
Feature - entriesRead and lag fields added to StreamGroup object
Feature - added RFencedLock implementation
Feature - credentialsResolver setting added

Breaking change - default codec changed to Kryo5Codec

Fixed - new Redis node isn't discovered between PubSub subscription attempts
Fixed - codec,nettyHook,addressResolverGroupFactory,connectionListener settings can't be defined through Micronaut config
Fixed - evictions metrics doesn't work for RedissonCache (thanks @Nicola Dardanis)
Fixed - PubSub connection isn't reused if it reached subscriptions limit before unsubscribe operation
Fixed - PubSub connection returns to connection pool only if subscriptions limit was reached
Fixed - use slf4j late-binding when logging instead of string concat (thanks @vatarasov)
Fixed - most of pubsub subscriptions fail to resubscribe after failover
Fixed - RBatch with executionMode = REDIS_WRITE_ATOMIC throws NPE in case of connection starvation
Fixed - CommandDecoder.messageDecoder() method throws NPE if RBatch object used with executionMode = IN_MEMORY (regression since 3.18.1)
Fixed - some scheduled tasks aren't executed (regression since 3.17.5)
Fixed - RFunction doesn't pass keys to Redis correctly (thanks @@jordanrmerrick)
Fixed - incorrectly reset jackson type factory (thanks @noelvo)
Fixed - cluster partitions parsing error isn't logged

Feature - Spring Data Redis 3.0.0 module added

Fixed - PubSub subscription in cluster sometimes doesn't apply to all nodes
Fixed - command replies don't match if connection pool size < 10 and at least one command failed
Fixed - RLock throws CancellationException continuously
Fixed - None of slaves were synced error is thrown after failover during RLock acquisition
Fixed - AWS Elasticache cluster failover
Fixed - hRandFieldWithValues() and hRandField() methods of Spring Data Redis module throw ClassCastException
Fixed - trySetPermitsAsync() method of RPermitExpirableSemaphore object shouldn't allow to overwrite the number of permits if value == 0 (thanks @kscaldef)
Fixed - RKeys object doesn't use nameMapper
Fixed - connection leak after master failover

Feature - Tomcat 10.1.x support
Feature - labels support for RTimeSeries object
Feature - compatibility with Spring Boot 3 (thanks @olivierboudet)
Feature - RxJava and Reactive interfaces for RLocalCachedMap object
Feature - local cache support for JsonBucket object

Improvement - StringCodec now implements JsonCodec

Fixed - RDoubleAdder and RLongAdder objects don't work with nameMapper
Fixed - RBlockingQueue methods should return null if negative timeout defined
Fixed - RLocalCachedMap.clearLocalCacheAsync() method shouldn't retain semaphore after invocation
Fixed - Spring Data Redis methods weren't implemented: zRandMember(), zRandMemberWithScore(), zPopMin(), bZPopMin(), zPopMax(), bZPopMax(), zMScore(), zDiff(), zDiffWithScores(), zDiffStore(), zInter(), zInterWithScores(), zUnion(), zUnionWithScores(), hRandField(), hRandFieldWithValues(), copy(), lMove(), bLMove(), lPop(), rPop(), sMIsMember(), getEx(), getDel()
Fixed - attempts to connect to the failed master after failover in cluster mode
Fixed - RMapCache MapEntryListener doesn't work with nameMapper
Fixed - RJsonBucket.getKeys() method doesn't use path parameter
Fixed - RRateLimiter.getConfig().getRate() throws NPE if it doesn't exist (thanks @Tanky-Zhang)
Fixed - RTransaction objects should be the same instances on each "get..." call
Fixed - RScheduledExecutorService cron triggers fire continuously for hours for some time zones (regression since 3.16.5)
Fixed - RSortedSet.add() throws NPE (thanks @yuwei)
Fixed - RKeysReactive.getKeysByPattern() method isn't giving all entries if downstream consumer is slow
Fixed - "Unable to unfreeze entry" errors in sentinel mode
Fixed - JsonBucket.compareAndSet() method with null as update value deletes whole object
Fixed - Redis Cluster topology scanned partially in case of DNS resolution error
Fixed - Slave nodes failed to pass complete initialization shouldn't be added as nodes
Fixed - ByteBuf leaks when one of multiple parameters can't be encoded
Fixed - SearchDomainUnknownHostException is thrown occasionally

Improvement - Failed connection ping isn't taken in account in Redis slave health check

Fixed - RScheduledExecutorService cron expression doesn't support year
Fixed - replaceValues() method of RListMultimap and RSetMultimap throws exception for empty collection
Fixed - RedissonBaseLock throws NPE after failover
Fixed - Spring Data Redis evalsha() method doesn't use key for Redis node routing in Cluster mode
Fixed - DNS change isn't detected in replicated mode
Fixed - RCollectionReactive.addAll() method is executed without subscription
Fixed - RKeysAsync.countExists() method throws errors in cluster mode
Fixed - Spring Data Redis reactive setIfAbsent should return false on error (thanks @zhuangzibin)
Fixed - Micronaut native image configuration
Fixed - RBatchReactive execution stuck forever if useScriptCache = true
Fixed - NameMapper is applied incorrectly to RBoundedBlockingQueue object
Fixed - incorrect IPv6 conversion
Fixed - Spring Boot Module ignores username parameter set via Spring Redis config
Fixed - SpringBoot yaml configuration parsing errors shouldn't be suppressed

Feature - Helidon 3.0 support
Feature - ability to specify MapWriterAsync and MapLoaderAsync in MapOptions object

Improvement - log output string expanded to 1000 characters by default

Fixed - RBuckets methods don't use nameMapper
Fixed - PingConnectionHandler should close channel on RedisLoadingException, RedisTryAgainException, RedisClusterDownException, RedisBusyException
Fixed - Invocation timeout isn't applied for RTopic.removeListenerAsync() methods
Fixed - WriteBehind task isn't stopped after RMap.destroy() method invocation
Fixed - Connection pinging works incorrectly if new connections were created in pool
Fixed - "SlaveConnectionPool no available Redis entries" error occurs in Cluster caused by early excluding of master node from nodes for reading
Fixed - Permanent blocking calling threads

Feature - touch(), unlink() and delete() methods implemented for transactional RSetCache and RSet objects
Feature - transactional RBucket, RMap, RMapCache, RSetCache, RSet objects support expire(), expireAt() and clearExpire() methods
Feature - ExecutorOptions.idGenerator() setting added
Feature - methods with task id added to RExecutorService interface

Fixed - duplicate subscriptions with RedisMessageListenerContainer in Spring Data Redis 2.7
Fixed - NameMapper applied twice to transactional RBucket
Fixed - some Quarkus environment variables clear all Redisson properties set through config file
Fixed - RJsonBucket.delete() method doesn't work
Fixed - RExecutorService.submitAsync(Callable, long, TimeUnit) method throws ClassCastException (thanks @xyqshi) Fixed - Lock synced slaves check
Fixed - reactive scripting commands throw ClassCastException if result is list of list
Fixed - RBatch.getJsonBucket() method should return RJsonBucketAsync interface

Feature - RJsonBucket object added for JSON.* commands support
Feature - RFunction and RShardedTopic objects added to RBatch

Fixed - continuous "Unable to unfreeze entry" error in Sentinel mode
Fixed - nameMapper setting isn't applied to RExecutorService and RScheduledExecutorService
Fixed - channel write exception may lead to wrong commands order
Fixed - don't connect to sentinel resolved by DNS if it's not included in result of SENTINEL SENTINELS command
Fixed - RScript.load() method shouldn't use failed Redis nodes
Fixed - RPermitExpirableSemaphore.acquireAsync() method hangs until leaseTimeout occurs. (regression since 3.16.8)
Fixed - use 60 seconds polling instead of take command for RRemoteService responses
Fixed - eval() and evalSha() methods of Spring Data Redis ReactiveScriptingCommands object throws IndexOutOfBoundsException
Fixed - expired entries eviction process is limited to 5000 per call
Fixed - sharded topic isn't resubscribed after channel reconnection
Fixed - execution of blpop command leads to reconnection

Feature - Hibernate 6 support

Improvement - amount of created connections in parallel reduced to 2 for better stability

Fixed - Spring Boot Starter doesn't start with Spring Boot 2.7
Fixed - RRateLimiter doesn't allow to set expiration time of permits and values

Feature - RScoredSortedSet.replace() method added
Feature - Spring Data Redis 2.7.0 module added
Feature - RPatternTopic.removeAllListenersAsync() method added
Feature - RShardedTopic object added (requires Redis 7.0+)
Feature - allow to specify username and password in redis connection url
Feature - JCache data partitioning with local cache support

Fixed - "Can't add slave" exceptions after fail over in cluster mode
Fixed - "Unable to acquire subscription" error after connection interruption
Fixed - JCache hangs forever when getting value from cache with useScriptCache=true
Fixed - RMap.merge() method hangs if MapLoader specified
Fixed - FairLock thread counter should start from 1 (thanks to @thisiswanghy)

Feature - transient fields support for LiveObjects to avoid data serialization
Feature - removeAllListenersAsync() method added to RTopic object
Feature - transactionAware setting added to RedissonSpringCacheManager

Improvement - amount of created connections in parallel reduced to 5, for better stability

Fixed - RedissonReactiveClient.getMultilock() method should accept RLockReactive objects
Fixed - RedissonRxClient.getMultilock() method should accept RLockRx objects
Fixed - don't close connection on error response during topology scan
Fixed - SET command should be an idempotent operation
Fixed - MasterSlaveConnectionManager throws ClassCastException if host unknown
Fixed - RReadWriteLock renewal doesn't work if writeLock released before readLock then both were acquired
Fixed - Spring Data Redis module. Scan In cluster mode, other nodes cannot be scanned
Fixed - RReliableTopic object throws "attempt to compare nil with number" error
Fixed - RedissonSpinLock.tryLock() method returns false instead of true if the remaining wait time is negative
Fixed - an error should be thrown if merge(), compute(), computeIfAbsent() and computeIfPresent() of RMap used in batch
Fixed - Unable to specify timezone in CronSchedule object
Fixed - RMapCache.destroy() method throws NPE
Fixed - RLock.tryLock() method throws CancellationException
Fixed - Unable to connect to Redis server error is thrown due to NPE
Fixed - RBlockingQueue.pollLastAndOfferFirstTo() throws ClassCastException if result is empty
Fixed - internal AsyncSemaphore doesn't skip canceled tasks in the same thread
Fixed - RLocalCachedMap.getAll() method doesn't respect storeCacheMiss setting
Fixed - 0 value for waitTime and leastTime isn't handled correctly by RMultiLock object
Fixed - Spring Data Redis module. RedissonConnection.execute() method doesn't invoke overloaded methods correctly

Feature - RFunction object added (requires Redis 7.0+)
Feature - pollLastEntriesFromAny() and pollFirstEntriesFromAny() methods added to RScoredSortedSet object (requires Redis 7.0+)
Feature - expireIfSet(), expireIfNotSet(), expireIfGreater() and expireIfLess() methods added to RExpirable interface (requires Redis 7.0+)
Feature - checkLockSyncedSlaves setting added
Feature - getAndExpire and getAndClearExpire() methods added to RBucket object (requires Redis 6.2.0+)
Feature - pollFirstFromAny() and pollLastFromAny() methods with timeout and count added to RScoredSortedSet object (requires Redis 7.0+)
Feature - pollFirst() and pollLast() methods with timeout and count added to RScoredSortedSet object (requires Redis 7.0+)
Feature - addAllIfLess(), addAllIfGreater(), addAllIfExist(), addAllIfAbsent() methods added to RScoredSortedSet object
Feature - RExpirable.expire(Duration) method added
Feature - RExpirable.expireTime() method added (requires Redis 7.0+)
Feature - range(), rangeReversed(), entryRange(), entryRangeReversed() methods with limit parameter added to RTimeSeries object
Feature - TransactionalOperation.syncSlaves setting added
Feature - pollFirstFromAny() and pollLastFromAny() methods added to RBlockingQueue object (requires Redis 7.0+)

Improvement - read-only cached scripts should be executed on slaves (requires Redis 7.0+)
Improvement - SORT_RO command is used for slave nodes (requires Redis 7.0+)
Improvement - decrease size of allocated data by RPermitExpirableSemaphore

Fixed - RedissonLocalCachedMap.clearLocalCache() method throws IllegalArgumentException
Fixed - RedissonMultiLock doesn't work properly with RedissonSpinLock
Fixed - SlaveConnectionPool no available Redis entries error occurs in Cluster mode
Fixed - RKeys.deleteByPattern() method does not always delete keys correctly
Fixed - expireAt(Instant) method of RExpirableReactive and RExpirableRx interfaces doesn't work
Fixed - wrong detection of added and removed slots in Redis Cluster mode
Fixed - RScoredSortedSet.addIfGreater() and RScoredSortedSet.addIfLess() methods always return false
Fixed - Spring Data Connection in multi mode causes thread stuck (regression since 3.16.7)
Fixed - Sentinel username setting is not applied (thanks to @nicolas-tg-ch)
Fixed - RTimeSeries doesn't handle same values for different timestamps
Fixed - Quarkus environment variables aren't parsed correctly
Fixed - check expiration before release in RPermitExpirableSemaphore (thanks to @randomVariable2)
Fixed - RedisTimeoutException: Command execution timeout for command: (PING) (regression since 3.16.3)
Fixed - wrong wait time calculation in RedissonMultiLock lock method causes deadlock
Fixed - RLocalCachedMap throws NPE if cache update listener receives message during init
Fixed - AsyncRemoteProxy throws Redisson is shutdown exception
Fixed - RedisClusterNode.clusterSlots() method throws Exception

Fixed - Quarkus redisson config fails to load in cluster mode with one node address
Fixed - registered RReliableTopic listener doesn't get old messages
Fixed - pubsub channel isn't released if subscription timeout occurred
Fixed - Quarkus Redisson config should be read at runtime
Fixed - RTopic channels aren't unsubscribed
Fixed - race condition causes Subscription timeout
Fixed - RMapCache.readAllKeySet() doesn't use MapKey codec
Fixed - Spring Data Redis RedissonConnection doesn't implement lpos command (thanks @woodyDM)
Fixed - master host isn't formatted into compressed format for IPV6 addresses in Sentinel mode
Fixed - Spring Data Redis restore() method throws Busy exception

Improvement - MessageListener should be annotated by FunctionalInterface

Fixed - RScript.scriptLoad() method doesn't load script into Slave nodes
Fixed - Spring Data RedissonConnection eval should use ByteArrayCodec (thanks @woodyDM)
Fixed - RSet.distributedIterator() and RScoredSortedSet.distributedIterator() methods throw script error
Fixed - synced slaves amount is not checked in RLock object
Fixed - race condition during hostname resolution in sentinel mode which may cause slave shutdown
Fixed - error should be thrown if slaves aren't defined in MasterSlave mode and readMode != MASTER
Fixed - master node shouldn't be initialized as slave in single mode
Fixed - can't find node error arise in replicated mode

Fixed - race condition causes wrong detection of failed slaves in Replicated mode. (regression since 3.16.5)

Feature - countIntersection() method added to RSet object
Feature - added reactive interface for RListMultimapCache and RSetMultimapCache objects
Feature - sentinelUsername setting added
Feature - added distributed iterator (thanks @Vorotyntsev)
Feature - added Spring Data Redis 2.6.0 support

Fixed - RedissonConnectionFactory.getReactiveConnection() method of Spring Data Redis isn't compatible with Redis cluster mode
Fixed - Mybatis RedissonCache should search redisson.yaml config at root package
Fixed - Can't find host in slaves! error after failover with a new IP of master host
Fixed - failed slaves aren't detected in Replicated mode
Fixed - get operation before put may cause inconsistent state of local cache
Fixed - RList.remove(object, count) throws exception if multiple objects were removed (thanks @cartermc24)
Fixed - RLocalCachedMap.delete() method clears local cache asynchronously
Fixed - IdleConnectionWatcher shouldn't close RedisPubSubConnection if it's in subscribed state
Fixed - SSL is not used for Sentinel master host
Fixed - update sync strategy of LocalCachedMap objects shouldn't apply updated value twice to instance of update source
Fixed - JCache dependency updated to 1.1.1
Fixed - Sentinel master-host = ? setting isn't handled properly during slave check
Fixed - RBuckets.trySet() method throws CROSSSLOT error (thanks to @deerRule)
Fixed - DNS monitor makes a new attempt to change master while current attempt wasn't finished

Feature - sentinelsDiscovery setting added
Feature - quarkus.redisson.file setting added to redisson-quarkus module to define external Redisson config file

Improvement - optimization of ClusterConnectionManager.checkSlaveNodesChange() and ClusterConnectionManager.checkMasterNodesChange() methods

Fixed - master change monitoring task in Replicated mode stops execution if it's invoked before the dns change
Fixed - RemoteService cannot be called if requestId is null (thanks to @jimichan)
Fixed - codec is not applied to RBuckets.set() method in non Cluster mode
Fixed - recovered slave shouldn't be added again in Redis Cluster mode
Fixed - releaseConnection method may cause StackOverflowError
Fixed - MOVED response with hostname isn't handled properly
Fixed - RStream.readGroup() method throws IndexOutOfBoundsException if group has a message without data
Fixed - NPE in CommandPubSubDecoder
Fixed - RExecutorService may execute same task twice at the same time
Fixed - dependencies for testing should use appropriate scope
Fixed - RPriorityQueue.add() method uses async method
Fixed - don't retry non-idempotent operations which were successfully sent
Fixed - RMapCache.fastRemove throws RedisException: too many results to unpack
Fixed - RRateLimiter decreases limit over the time in highly concurrent environment
Fixed - don't PING connection if it's in use

Improvement - RBuckets.get() method should group keys by slot in Redis Cluster mode
Improvement - RBatch result decoding optimization

Fixed - RExecutorService, RRemoteService execution may hang if connection used for tasks pooling was interrupted
Fixed - RBatch with skipResult() option affects result of other commands (regression since 3.16.1)
Fixed - connection leak (regression since 3.16.1)
Fixed - getBuckets().set() method throws CROSSSLOT error (thanks to @mikawudi)
Fixed - RedissonMapCache.addListener() method throws NPE
Fixed - master-host of Slave node isn't resolved in Sentinel mode
Fixed - interrupted RLock.tryLock() method keeps renewing lock indefinitely (thanks to @Cesarla)
Fixed - don't ping connection if it's in use
Fixed - natMapper isn't applied to resolved Sentinel and Cluster hosts

Feature - Micronaut 3.0 integration
Feature - added batched merge() method to RLiveObjectService interface
Feature - resolve hostnames used in Redis Cluster topology
Feature - resolve hostnames used in Redis Sentinel topology
Feature - added batched addLast() and addFirst() methods to RDeque, RDequeRx and RDequeReactive interfaces
Feature - added addAllCounted() and removeAllCounted() methods to RSet, RSetRx and RSetReactive interfaces

Fixed - Redis Stream trim command with MINID strategy is not fully supported
Fixed - Quarkus requires AutowiredAnnotationBeanPostProcessor class during native image execution
Fixed - issues with Quarkus Netty dependencies
Fixed - MOVED redirection loop detected error in Redis Cluster
Fixed - handling master with empty slots in Redis Cluster topology
Fixed - SentinelConnectionManager should use unified compressed format for IPv6
Fixed - RLocalCachedMap.readAllValues() method uses key decoder instead of value
Fixed - empty array passed to RKeys.delete() method causes thread blocking
Fixed - cluster partition without address causes NPE
Fixed - threads waiting for RSemaphore permits acquisition unable to acquire them if permits added
Fixed - RRateLimiter allows limit overcome
Fixed - RMapCacheReactive and RMapCacheRx interfaces miss method to define eviction algorithm
Fixed - write-behind tasks aren't flushed after Redisson shutdown() method invocation
Fixed - LiveObjects with indexed field can't be stored using batch persist method
Fixed - failed master shouldn't skipped in Redis Cluster topology scan (thanks to @JerryWzc)
Fixed - RListReactive iterator with filter returns non-deterministic result
Fixed - replicatedServers mode should use ip addresses if nodes defined using hostnames
Fixed - multiple masters check removed for replicatedServers mode
Fixed - MapWriter should be defined along with writeBehind settings

Improvement - MarshallingCodec and JsonJacksonCodec warmup added
Improvement - performance improvement for connection pool with few connections

Fixed - connection leak after command error if Batch executed in REDIS_WRITE_ATOMIC mode Fixed - AsyncSemaphore race condition issue
Fixed - Quarkus native remote service invocation fails
Fixed - nameMapper setting isn't applied to RTopic object
Fixed - Batch in REDIS_WRITE_ATOMIC mode doesn't respect batch settings
Fixed - UndeclaredThrowableException is thrown when cache down while executing RLiveObjectService.get() method
Fixed - Reactive Transactions aren't unlocking transactional locks
Fixed - keySet() method of transactional map throws Exception
Fixed - lock expiration renewal should be canceled if owner doesn't exist (thanks to @regidio)

Feature - GraalVM native-image support
Feature - Spring Data Redis 2.5.x support
Feature - Helidon CDI integration
Feature - Quarkus integration
Feature - Micronaut integration
Feature - data partitioning support for JCache

Fixed - Live Object Conditions.in() aren't considered if defined in Conditions.and() clause
Fixed - Redisson shutdown takes much time after RBatch execution
Fixed - RBatch object in REDIS_WRITE_ATOMIC or REDIS_READ_ATOMIC mode can be corrupted by PING command
Fixed - RKeysReactive.getKeysByPattern() method returns wrong result
Fixed - RExpirable.expire(Instant) method doesn't work for RBloomFilter, RBoundedBlockingQueue, RDelayedQueue, RLock, RIdGenerator, RMultimap, RMapCache, RPriorityQueue, RRateLimiter, RReliableTopic, RSetMultimap, RTimeSeries objects
Fixed - RBlockingDequeReactive.takeElements() method does not consume all elements
Fixed - RScheduledExecutorService stops to work if task timeout occurred
Fixed - RedissonReactiveSubscription removes listener after first 32 messages
Fixed - RedisNodeNotFoundException is thrown after cluster failover (thanks to @UzimakiNaruto)

Fixed - RedisSentinel.getMaster() method throws NPE
Fixed - RSemaphore.drainPermits() throws ClassCastException
Fixed - missed implementation of few methods in Spring Data's RedissonConnection
Fixed - RLocalCachedMap.containsKey() method doesn't invoke map loader
Fixed - RSemaphore permits can't be acquired due to "Maximum permit count exceeded" error
Fixed - RedissonNode unable to start due to ClassNotFoundException
Fixed - SENTINEL SENTINELS command timeout (thanks to @zhwq1216)
Fixed - JCachingProvider shouldn't depend on class from Jackson 2.12.x
Fixed - JCache.get() method swallows Redis errors
Fixed - RLocalCachedMap doesn't used MapLoader if storeMode = LOCALCACHE

Feature - discard() method added to RBatch object
Feature - broadcastSessionUpdates setting added to Tomcat Session Manager

Fixed - no error if jcache has wrong configuration in yaml format
Fixed - frequent Redis master failover causes memory leak in IdleConnectionWatcher
Fixed - RedisStreamCommands.xGroupDelConsumer() method in Spring Data module uses incorrect Redis command
Fixed - RLock can't be acquired anymore if pubsub connection limit was reached (thanks to @zhwq1216)
Fixed - PubSub Lock entries memory-leak during Lock acquisition (thanks to @zhwq1216)
Fixed - dns monitor shouldn't use IP addresses as hostnames
Fixed - failover handling stops to work if Redis Cluster node returned empty topology
Fixed - mGet() and mSet() methods of Spring Data RedissonConnection object throw CROSSSLOT error
Fixed - touch(), mDel(), mUnlink(), expire(), pExpire(), expireAt(), pExpireAt(), persist() methods of Spring Data ReactiveKeyCommands interface should be executed as write operation
Fixed - RMap.computeIfPresent() doesn't update mutable objects
Fixed - MapReduce timeout isn't applied if ExecutorService node is down
Fixed - Redisson tries reconnect to Redis nodes which marked as shutdown by topology manager

Feature - sslProtocols setting added
Feature - nameMapper setting added
Feature - getSigned(), setSigned(), incrementAndGetSigned(), getUnsigned(), setUnsigned(), incrementAndGetUnsigned() methods added to RBitSet object
Feature - updateEntryExpiration(), getWithTTLOnly() methods added to RMapCache object

Improvement - Spring Cache, MyBatis Cache, Hibernate Cache implementations should read data from Redis slave if idleTime and cache size weren't specified

Fixed - ClusterConnectionManager.upDownSlaves() method throws ConcurrentModificationException
Fixed - ClusterConnectionManager.checkMasterNodesChange() method throws NPE
Fixed - JCache CacheEntryUpdatedListener doesn't get old value of changed entry (thanks to @testower)

Feature - connectionListener setting added

Fixed - tryAcquire() and availablePermits() method of RRateLimiter object throw too many results to unpack error
Fixed - RRateLimiter object throws LUA-script error
Fixed - connection leak in Topology Manager for Replicated Redis config
Fixed - ConnectionListener.onConnect() method isn't triggered during Redisson start
Fixed - addLastIfExists() and addLastIfExists() methods of RDeque object don't work
Fixed - ArrayIndexOutOfBoundsException is thrown if Redis master change was unsuccessful
Fixed - RScheduledExecutorService.scheduleAtFixedRate() starts multiple instances of the same task if multiple workers defined
Fixed - tasks scheduled via RScheduledExecutorService.scheduleAtFixedRate() method aren't executed after some time

Feature - move() method added to RDeque and RBlockingDeque objects
Feature - MINID trimming strategy and LIMIT argument added to RStream.add() method
Feature - new config checkSlaveStatusWithSyncing setting added (thanks to @mikawudi)
Feature - enable tcpNoDelay setting by default
Feature - RedissonClient.reactive() and RedissonClient.rxJava() methods added
Feature - Spring Boot auto configuration should create Reactive and RxJava instances

Improvement - simplified API of RStream.read() and RStream.readGroup()

Fixed - Hibernate modules prior 5.3 version don't support fallback for nextTimestamp() method
Fixed - MarshallingCodec doesn't release allocated ByteBuf object if exception thrown during encoding
Fixed - retryInterval isn't used for next attempt if Redis client didn't send response
Fixed - lease timeout updated in non-safe way in org.redisson.RedissonLock#tryLockInnerAsync method (thanks to @coding-tortoise)
Fixed - references in RxJava objects aren't supported
Fixed - Spring Data Redis module doesn't support StreamReadOptions.isNoack() option in RedisStreamCommands.xReadGroup() method. Fixed - trying to authentificate sentinel server without password
Fixed - RStream.getInfo() method doesn't decode entries
Fixed - Redisson doesn't reconnect slave if it was excluded before due to errors in failedSlaveCheckInterval time range. (thanks to @mikawudi)

Feature - expireAt(Instant) method added to RExpirable object
Feature - random() method added to RScoredSortedSet object
Feature - randomKeys() and randomEntries() methods added to RMap object
Feature - count with any parameter added for search in RGeo object
Feature - ability to search in box added for RGeo object

Improvement - simplified RGeo API with search methods
Improvement - added check for invocation of sync methods in async/rx/reactive listeners

Fixed - continuous reconnecting to broken host if it was defined as hostname in Redisson Cluster config
Fixed - WeightedRoundRobinBalancer filters master node in readMode=ReadMode.MASTER_SLAVE
Fixed - RPatternTopicReactive.removeListener() method should return Mono<Void>
Fixed - remove authType and principal attributes on Apache Tomcat logout
Fixed - scheduled tasks via RScheduledExecutorService object can't be canceled
Fixed - RStream.claim() method throws NPE if given id does not exist
Fixed - RPatternTopic on keyspace/keyevent notification subscribes only to single master node in Redis cluster
Fixed - Class cast exception is thrown during iteration of RMapCache entries
Fixed - internal RedissonBaseLock.evalWriteAsync() method isn't executed again if cluster slaves amount > 0
Fixed - CPU spike after Slave failover if subscriptionMode=SLAVE
Fixed - rename() method throws throws RedisException if RBloomFilter is empty
Fixed - output full exception stacktrace if unable connect to sentinel server
Fixed - duplicated PING sent when Redis connection got reconnected
Fixed - Optional class can't be used as a result object in RemoteService interface
Fixed - redisson-spring-boot-starter should use redisson-spring-data-24 module
Fixed - RMapCacheRx.getLock() returns org.redisson.RedissonLock instead of org.redisson.api.RLockRx
Fixed - RMapCacheReactive.getLock() returns org.redisson.RedissonLock instead of org.redisson.api.RLockReactive

Feature - Apache Tomcat 10 support added
Feature - Spin Lock added. Please refer to documentation for more details (thanks to @Vorotyntsev)
Feature - sentinelPassword setting added (thanks to @ghollies)
Feature - RedisNode.getMemoryStatistics() method added
Feature - setAndKeepTTL() method added to RBucket object
Feature - min idle time parameter added to listPending() and pendingRange() methods of RStream object
Feature - autoClaim(), fastAutoClaim() and createConsumer() methods added to RStream object
Feature - addIfExists(), addIfGreater() and addIfLess() methods added to RScoredSortedSet object
Feature - putIfExists() and fastPutIfExists() methods added to RMap object
Feature - tryAdd() and addIfExists() methods added to RGeo object
Feature - readUnion(), readIntersection(), diff(), readDiff(), rangeTo(), revRangeTo() methods added to RScoredSortedSet object
Feature - ScoredSortedSetAddListener added to RScoredSortedSet object

Improvement - use System.nanoTime() in IdleConnectionWatcher to avoid clock drifting

Fixed - eval command executed on Redis cluster doesn't use key for master/slave selection
Fixed - MOVED or ASK response from Redis causes Unable to acquire connection! error
Fixed - Spring Redis Data PatternTopic listeners are invoked multiple times per message
Fixed - don't add Redis Slave as active if connections can't be established (thanks to @yann9)
Fixed - RBatch object throws Exception if not all slots are covered in Redis Cluster
Fixed - stream and queue object may lost entry during execution of any blocking poll operation
Fixed - Redis BUSY response handling (thanks to @wuqian0808)
Fixed - InterruptedExceptions are hidden by RedisException
Fixed - primitive class numbers aren't indexed correctly in LiveObject search engine
Fixed - NPE is thrown if LiveObject index stored for the first time in Redis cluster
Fixed - NPE is thrown if Redis node doesn't return "flags" parameter

Feature - added option LocalCachedMapOptions.storeCacheMiss to store cache miss in a local cache (thanks to @ipalbeniz)
Feature - LFU eviction algorithm added to trySetMaxSize and setMaxSize methods of RMapCache interface

Improvement - RedisNodes ping results check optimization (thanks to @blackstorm)
Improvement - keySet().isEmpty() and values().isEmpty() methods of RMap object aren't efficient

Fixed - connection leak if new discovered slaves in LOADING Redis is loading the dataset in memory state (thanks to @mikawudi)
Fixed - RMap.putIfAbsent() method doesn't check value for null
Fixed - Apache Tomcat Valve objects should be added in context pipeline instead of engine's pipeline
Fixed - slaves synchronization timeout isn't respected during RLock.lock() method invocation
Fixed - ConnectionWatchdog may cause connection leak (thanks to @mikawudi)
Fixed - Redisson.shutdown() method throws RejectedExecutionException
Fixed - count() and addAll() methods of RScoredSortedSetReactive and RScoredSortedSetRx interfaces throw ClassCastException
Fixed - GEORADIUS_RO command should be used instead of GEORADIUS in Spring Redis Data module
Fixed - Spring Data Redis RedissonConnection.del() method doesn't work in pipeline on Redis cluster
Fixed - RLocalCachedMap.putAll() method updates in wrong way log used for Reconnection.LOAD strategy
Fixed - redisRepository.opsForSet().distinctRandomMembers() method throws ClassCastException

Spring Session implementation is deprecated now. Please refer to documentation for more details

Feature - RReliableTopic object added. Please refer to documentation for more details
Feature - IdGenerator object added. Please refer to documentation for more details
Feature - Spring Data Redis 2.4.0 integration
Feature - StreamMessageId.AUTO_GENERATED const added
Feature - Rx API for RMultimapCache object (thanks to @mlkammer)
Feature - cluster-safe implementation of rename, renameNX methods of RedissonClusterConnection object (thanks to @eager)
Feature - RxJava2 API replaced with RxJava3
Feature - tryAdd() method added to RSet and RSetCache objects

Improvement - preventing sending CLUSTER NODES to the same host (thanks to @serssp)

Fixed - RSetMultimap could throw a class cast exception on its get() method because it actually contained a list based multimap instance (thanks to @mlkammer)
Fixed - Spring Data Redis redisTemplate.opsForGeo().radius() method doesn't work
Fixed - RKeys.deleteByPattern() method executed in batch should throw UnsupportedOperationException in cluster mode
Fixed - CACHE_REGION_PREFIX setting isn't applied for hibernate 5.3+
Fixed - deprecation error log about JSON config even though it's not used
Fixed - update new master record in DNS monitor only if it replaced old master successfully
Fixed - RQueue.removeIf() method should throw UnsupportedOperationException
Fixed - Lock watchdog won't renew after reconnection (thanks to @burgleaf)
Fixed - TimeSeries.iterator() method doesn't respect the ordering
Fixed - RRateLimiter throws "bad argument #2 to 'unpack' (string expected, got nil)."
Fixed - CROSSSLOT error rised when clearing a redis-spring-data cache
Fixed - RLongAdder.sum() and RDoubleAdder.sum() methods return wrong result
Fixed - getting error while connecting to sentinel using password
Fixed - result of RStream.read() method isn't sorted by key

Improvement - set pingConnectionInterval = 30000 by default

Fixed - CROSSLOT error thrown during RLiveObject update
Fixed - RRateLimiter.delete() method returns false
Fixed - RBitSet.set(long bitIndex, boolean value) should return boolean
Fixed - RBatch doesn't handle MOVED, ASK Redis errors in Redis
Fixed - "response has been skipped due to timeout" warnings were removed
Fixed - additional check for blocking command added in PingConnectionHandler
Fixed - object's name should be checked for null
Fixed - redisson-spring-boot-starter doesn't load config file
Fixed - RTransaction should be executed in IN_MEMORY_ATOMIC mode
Fixed - high contention during connection acquisition from connection pool