redis 5.0.6 → 5.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b000349da8b2f7ae8ed14909175306d2c719a9873bf1dabe05c4719ae96d0da
-  data.tar.gz: fdcda2f50f9d33265f7ba24d3f29a2e078fabe5240e1eaf01efae51e0b83eb0b
+  metadata.gz: 5d76a0d8a8a0361f991dc110219ffc77c12503148f9ece9586dd274321283265
+  data.tar.gz: fab1b1d4d3a5e22d2d952c98648a1412239f117a2c53bcbdf20ea7c43f456faa
 SHA512:
-  metadata.gz: 990972ebefe548f952cbf630708298f52c1856fa5a142a341f2548bd9173f03f0106d6b745c7e39cc5baa9f084d5fea5e4c0bf42cf1d42df94e404f3558d7816
-  data.tar.gz: e52615e0d5b7ca9d554ffc540fdfec524d2aed74ac1c7fc3c727d3096504aa81ff43a85b9e2ce7b21da87edf21ca5f92197171ff1b1c62fa85c7551839e9df83
+  metadata.gz: 042f0aa785647bb0e6f73ff50722ba5dcf440e3f5e817c7eec030b876b7d34ca8be42a7a5a5a1767eba66b7424a8d2e74fe8e7b9e0362eedefe4fb58878cdb57
+  data.tar.gz: 5bc22d99f3a77929f35c02072be18d663ca127c77055afadd55455d3f571f61bbd70853d6fd4414e0e11f601c20d68872e8f097fce109341e5bda39f6aadb9fe

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Unreleased
 
+# 5.4.1
+
+- Properly handle NOSCRIPT errors.
+
+# 5.4.0
+
+- Fix `blmpop` method to actually use `BLMPOP`, it was mistakenly issuing `LMPOP` commands.
+- `xadd` now accepts a `minid:` argument.
+- `zrank` and `zrevrank` now accepts `with_score:` argument.
+- `Redis#call` now accept a block, allowing to use `Redis` instances where `RedisClient` is expected.
+
+# 5.3.0
+
+- Fix the return type of `hgetall` when used inside a `multi` transaction which is itself inside a pipeline.
+
+# 5.2.0
+
+- Now require Ruby 2.6 because `redis-client` does.
+- Eagerly close subscribed connection when using `subscribe_with_timeout`. See #1259.
+- Add `exception` flag in `pipelined` allowing failed commands to be returned in the result array when set to `false`.
+
+# 5.1.0
+
+- `multi` now accept a `watch` keyword argument like `redis-client`. See #1236.
+- `bitcount` and `bitpos` now accept a `scale:` argument on Redis 7+. See #1242
+- Added `expiretime` and `pexpiretime`. See #1248.
+
+# 5.0.8
+
+- Fix `Redis#without_reconnect` for sentinel clients. Fix #1212.
+- Add `sentinel_username`, `sentinel_password` for sentinel clients. Bump `redis-client` to `>=0.17.0`. See #1213
+
+# 5.0.7
+
+- Fix compatibility with `redis-client 0.15.0` when using Redis Sentinel. Fix #1209.
+
 # 5.0.6
 
 - Wait for an extra `config.read_timeout` in blocking commands rather than an arbitrary 100ms. See #1175.
@@ -27,6 +63,7 @@
 
 # 5.0.0
 
+- Default client timeout decreased from 5 seconds to 1 second.
 - Eagerly and strictly cast Integer and Float parameters.
 - Allow to call `subscribe`, `unsubscribe`, `psubscribe` and `punsubscribe` from a subscribed client. See #1131.
 - Use `MD5` for hashing server nodes in `Redis::Distributed`. This should improve keys distribution among servers. See #1089.
@@ -49,6 +86,10 @@
 - Removed the `synchrony` driver.
 - Removed `Redis.exists_returns_integer`, it's now always enabled.
 
+# 4.8.1
+
+* Automatically reconnect after fork regardless of `reconnect_attempts`
+
 # 4.8.0
 
 * Introduce `sadd?` and `srem?` as boolean returning versions of `sadd` and `srem`.

data/README.md

@@ -1,4 +1,4 @@
-# redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][inchpages-image]][inchpages-link]
+# redis-rb [![Build Status][gh-actions-image]][gh-actions-link] [![Inline docs][rdoc-master-image]][rdoc-master-link]
 
 A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still providing an idiomatic interface.
 
@@ -34,7 +34,7 @@ You can also specify connection options as a [`redis://` URL][redis-url]:
 redis = Redis.new(url: "redis://:p4ssw0rd@10.0.1.1:6380/15")
 ```
 
-The client expects passwords with special chracters to be URL-encoded (i.e.
+The client expects passwords with special characters to be URL-encoded (i.e.
 `CGI.escape(password)`).
 
 To connect to Redis listening on a Unix socket, try:
@@ -77,7 +77,7 @@ The client does not provide connection pooling. Each `Redis` instance
 has one and only one connection to the server, and use of this connection
 is protected by a mutex.
 
-As such it is heavilly recommended to use the [`connection_pool` gem](https://github.com/mperham/connection_pool), e.g.:
+As such it is heavily recommended to use the [`connection_pool` gem](https://github.com/mperham/connection_pool), e.g.:
 
 ```ruby
 module MyApp
@@ -103,7 +103,7 @@ To connect using Sentinel, use:
 SENTINELS = [{ host: "127.0.0.1", port: 26380 },
              { host: "127.0.0.1", port: 26381 }]
 
-redis = Redis.new(url: "redis://mymaster", sentinels: SENTINELS, role: :master)
+redis = Redis.new(name: "mymaster", sentinels: SENTINELS, role: :master)
 ```
 
 * The master name identifies a group of Redis instances composed of a master
@@ -120,13 +120,39 @@ but a few so that if one is down the client will try the next one. The client
 is able to remember the last Sentinel that was able to reply correctly and will
 use it for the next requests.
 
-If you want to [authenticate](https://redis.io/topics/sentinel#configuring-sentinel-instances-with-authentication) Sentinel itself, you must specify the `password` option per instance.
+To [authenticate](https://redis.io/docs/management/sentinel/#configuring-sentinel-instances-with-authentication) Sentinel itself, you can specify the `sentinel_username` and `sentinel_password`. Exclude the `sentinel_username` option if you're using password-only authentication.
 
 ```ruby
-SENTINELS = [{ host: '127.0.0.1', port: 26380, password: 'mysecret' },
-             { host: '127.0.0.1', port: 26381, password: 'mysecret' }]
+SENTINELS = [{ host: '127.0.0.1', port: 26380},
+             { host: '127.0.0.1', port: 26381}]
 
-redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master)
+redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, sentinel_username: 'appuser', sentinel_password: 'mysecret', role: :master)
+```
+
+If you specify a username and/or password at the top level for your main Redis instance, Sentinel *will not* using thouse credentials
+
+```ruby
+# Use 'mysecret' to authenticate against the mymaster instance, but skip authentication for the sentinels:
+SENTINELS = [{ host: '127.0.0.1', port: 26380 },
+             { host: '127.0.0.1', port: 26381 }]
+
+redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret')
+```
+
+So you have to provide Sentinel credential and Redis explicitly even they are the same
+
+```ruby
+# Use 'mysecret' to authenticate against the mymaster instance and sentinel
+SENTINELS = [{ host: '127.0.0.1', port: 26380 },
+             { host: '127.0.0.1', port: 26381 }]
+
+redis = Redis.new(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret', sentinel_password: 'mysecret')
+```
+
+Also the `name`, `password`, `username` and `db` for Redis instance can be passed as an url:
+
+```ruby
+redis = Redis.new(url: "redis://appuser:mysecret@mymaster/10", sentinels: SENTINELS, role: :master)
 ```
 
 ## Cluster support
@@ -165,6 +191,28 @@ end
 # => ["OK"]
 ```
 
+### Exception management
+
+The `exception` flag in the `#pipelined` is a feature that modifies the pipeline execution behavior. When set
+to `false`, it doesn't raise an exception when a command error occurs. Instead, it allows the pipeline to execute all
+commands, and any failed command will be available in the returned array. (Defaults to `true`)
+
+```ruby
+results = redis.pipelined(exception: false) do |pipeline|
+  pipeline.set('key1', 'value1')
+  pipeline.lpush('key1', 'something') # This will fail
+  pipeline.set('key2', 'value2')
+end
+# results => ["OK", #<RedisClient::WrongTypeError: WRONGTYPE Operation against a key holding the wrong kind of value>, "OK"]
+
+results.each do |result|
+  if result.is_a?(Redis::CommandError)
+    # Do something with the failed result
+  end
+end
+```
+
+
 ### Executing commands atomically
 
 You can use `MULTI/EXEC` to run a number of commands in an atomic
@@ -225,6 +273,7 @@ See lib/redis/errors.rb for information about what exceptions are possible.
 ## Timeouts
 
 The client allows you to configure connect, read, and write timeouts.
+Starting in version 5.0, the default for each is 1. Before that, it was 5.
 Passing a single `timeout` option will set all three values:
 
 ```ruby
@@ -357,7 +406,7 @@ gem "hiredis-client"
 ```
 
 If your application doesn't call `Bundler.require`, you may have
-to require it explictly:
+to require it explicitly:
 
 ```ruby
 require "hiredis-client"
@@ -394,11 +443,11 @@ client and evangelized Redis in Rubyland. Thank you, Ezra.
 requests.
 
 
-[inchpages-image]:  https://inch-ci.org/github/redis/redis-rb.svg
-[inchpages-link]:   https://inch-ci.org/github/redis/redis-rb
-[redis-commands]:   https://redis.io/commands
-[redis-home]:       https://redis.io
-[redis-url]:        http://www.iana.org/assignments/uri-schemes/prov/redis
-[gh-actions-image]: https://github.com/redis/redis-rb/workflows/Test/badge.svg
-[gh-actions-link]:  https://github.com/redis/redis-rb/actions
-[rubydoc]:          http://www.rubydoc.info/gems/redis
+[rdoc-master-image]: https://img.shields.io/badge/docs-rdoc.info-blue.svg
+[rdoc-master-link]:  https://rubydoc.info/github/redis/redis-rb
+[redis-commands]:    https://redis.io/commands
+[redis-home]:        https://redis.io
+[redis-url]:         https://www.iana.org/assignments/uri-schemes/prov/redis
+[gh-actions-image]:  https://github.com/redis/redis-rb/workflows/Test/badge.svg
+[gh-actions-link]:   https://github.com/redis/redis-rb/actions
+[rubydoc]:           https://rubydoc.info/gems/redis

data/lib/redis/client.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'redis-client'
-
 class Redis
   class Client < ::RedisClient
     ERROR_MAPPING = {
@@ -17,6 +15,9 @@ class Redis
       RedisClient::ProtocolError => Redis::ProtocolError,
       RedisClient::OutOfMemoryError => Redis::OutOfMemoryError,
     }
+    if defined?(RedisClient::NoScriptError)
+      ERROR_MAPPING[RedisClient::NoScriptError] = Redis::NoScriptError
+    end
 
     class << self
       def config(**kwargs)
@@ -24,7 +25,24 @@ class Redis
       end
 
       def sentinel(**kwargs)
-        super(protocol: 2, **kwargs)
+        super(protocol: 2, **kwargs, client_implementation: ::RedisClient)
+      end
+
+      def translate_error!(error, mapping: ERROR_MAPPING)
+        redis_error = translate_error_class(error.class, mapping: mapping)
+        raise redis_error, error.message, error.backtrace
+      end
+
+      private
+
+      def translate_error_class(error_class, mapping: ERROR_MAPPING)
+        mapping.fetch(error_class)
+      rescue IndexError
+        if (client_error = error_class.ancestors.find { |a| mapping[a] })
+          mapping[error_class] = mapping[client_error]
+        else
+          raise
+        end
       end
     end
 
@@ -69,10 +87,16 @@ class Redis
     undef_method :call_once_v
     undef_method :blocking_call
 
+    def ensure_connected(retryable: true, &block)
+      super(retryable: retryable, &block)
+    rescue ::RedisClient::Error => error
+      Client.translate_error!(error)
+    end
+
     def call_v(command, &block)
       super(command, &block)
     rescue ::RedisClient::Error => error
-      translate_error!(error)
+      Client.translate_error!(error)
     end
 
     def blocking_call_v(timeout, command, &block)
@@ -85,44 +109,23 @@ class Redis
 
       super(timeout, command, &block)
     rescue ::RedisClient::Error => error
-      translate_error!(error)
+      Client.translate_error!(error)
     end
 
-    def pipelined
+    def pipelined(exception: true)
       super
     rescue ::RedisClient::Error => error
-      translate_error!(error)
+      Client.translate_error!(error)
     end
 
-    def multi
+    def multi(watch: nil)
       super
     rescue ::RedisClient::Error => error
-      translate_error!(error)
-    end
-
-    def disable_reconnection(&block)
-      ensure_connected(retryable: false, &block)
+      Client.translate_error!(error)
     end
 
     def inherit_socket!
       @inherit_socket = true
     end
-
-    private
-
-    def translate_error!(error)
-      redis_error = translate_error_class(error.class)
-      raise redis_error, error.message, error.backtrace
-    end
-
-    def translate_error_class(error_class)
-      ERROR_MAPPING.fetch(error_class)
-    rescue IndexError
-      if (client_error = error_class.ancestors.find { |a| ERROR_MAPPING[a] })
-        ERROR_MAPPING[error_class] = ERROR_MAPPING[client_error]
-      else
-        raise
-      end
-    end
   end
 end

data/lib/redis/commands/bitmaps.rb

@@ -27,9 +27,13 @@ class Redis
       # @param [String] key
       # @param [Integer] start start index
       # @param [Integer] stop stop index
+      # @param [String, Symbol] scale the scale of the offset range
+      #     e.g. 'BYTE' - interpreted as a range of bytes, 'BIT' - interpreted as a range of bits
       # @return [Integer] the number of bits set to 1
-      def bitcount(key, start = 0, stop = -1)
-        send_command([:bitcount, key, start, stop])
+      def bitcount(key, start = 0, stop = -1, scale: nil)
+        command = [:bitcount, key, start, stop]
+        command << scale if scale
+        send_command(command)
       end
 
       # Perform a bitwise operation between strings and store the resulting string in a key.
@@ -51,14 +55,17 @@ class Redis
       # @param [Integer] bit whether to look for the first 1 or 0 bit
       # @param [Integer] start start index
       # @param [Integer] stop stop index
+      # @param [String, Symbol] scale the scale of the offset range
+      #     e.g. 'BYTE' - interpreted as a range of bytes, 'BIT' - interpreted as a range of bits
       # @return [Integer] the position of the first 1/0 bit.
       #                  -1 if looking for 1 and it is not found or start and stop are given.
-      def bitpos(key, bit, start = nil, stop = nil)
+      def bitpos(key, bit, start = nil, stop = nil, scale: nil)
         raise(ArgumentError, 'stop parameter specified without start parameter') if stop && !start
 
         command = [:bitpos, key, bit]
         command << start if start
         command << stop if stop
+        command << scale if scale
         send_command(command)
       end
     end

data/lib/redis/commands/hashes.rb

@@ -222,6 +222,8 @@ class Redis
       #   - `:count => Integer`: return count keys at most per iteration
       #
       # @return [String, Array<[String, String]>] the next cursor and all found keys
+      #
+      # See the [Redis Server HSCAN documentation](https://redis.io/docs/latest/commands/hscan/) for further details
       def hscan(key, cursor, **options)
         _scan(:hscan, cursor, [key], **options) do |reply|
           [reply[0], reply[1].each_slice(2).to_a]
@@ -239,6 +241,8 @@ class Redis
       #   - `:count => Integer`: return count keys at most per iteration
       #
       # @return [Enumerator] an enumerator for all found keys
+      #
+      # See the [Redis Server HSCAN documentation](https://redis.io/docs/latest/commands/hscan/) for further details
       def hscan_each(key, **options, &block)
         return to_enum(:hscan_each, key, **options) unless block_given?
 

data/lib/redis/commands/keys.rb

@@ -22,6 +22,8 @@ class Redis
       #   - `:type => String`: return keys only of the given type
       #
       # @return [String, Array<String>] the next cursor and all found keys
+      #
+      # See the [Redis Server SCAN documentation](https://redis.io/docs/latest/commands/scan/) for further details
       def scan(cursor, **options)
         _scan(:scan, cursor, [], **options)
       end
@@ -46,6 +48,8 @@ class Redis
       #   - `:type => String`: return keys only of the given type
       #
       # @return [Enumerator] an enumerator for all found keys
+      #
+      # See the [Redis Server SCAN documentation](https://redis.io/docs/latest/commands/scan/) for further details
       def scan_each(**options, &block)
         return to_enum(:scan_each, **options) unless block_given?
 
@@ -105,6 +109,14 @@ class Redis
         send_command(args, &Boolify)
       end
 
+      # Get a key's expiry time specified as number of seconds from UNIX Epoch
+      #
+      # @param  [String] key
+      # @return [Integer] expiry time specified as number of seconds from UNIX Epoch
+      def expiretime(key)
+        send_command([:expiretime, key])
+      end
+
       # Get the time to live (in seconds) for a key.
       #
       # @param [String] key
@@ -161,6 +173,14 @@ class Redis
         send_command(args, &Boolify)
       end
 
+      # Get a key's expiry time specified as number of milliseconds from UNIX Epoch
+      #
+      # @param  [String] key
+      # @return [Integer] expiry time specified as number of milliseconds from UNIX Epoch
+      def pexpiretime(key)
+        send_command([:pexpiretime, key])
+      end
+
       # Get the time to live (in milliseconds) for a key.
       #
       # @param [String] key
@@ -266,6 +286,8 @@ class Redis
       #
       # @param [String] pattern
       # @return [Array<String>]
+      #
+      # See the [Redis Server KEYS documentation](https://redis.io/docs/latest/commands/keys/) for further details
       def keys(pattern = "*")
         send_command([:keys, pattern]) do |reply|
           if reply.is_a?(String)

data/lib/redis/commands/lists.rb

@@ -183,6 +183,60 @@ class Redis
         send_blocking_command(command, timeout)
       end
 
+      # Pops one or more elements from the first non-empty list key from the list
+      # of provided key names. If lists are empty, blocks until timeout has passed.
+      #
+      # @example Popping a element
+      #   redis.blmpop(1.0, 'list')
+      #   #=> ['list', ['a']]
+      # @example With count option
+      #   redis.blmpop(1.0, 'list', count: 2)
+      #   #=> ['list', ['a', 'b']]
+      #
+      # @params timeout [Float] a float value specifying the maximum number of seconds to block) elapses.
+      #   A timeout of zero can be used to block indefinitely.
+      # @params key [String, Array<String>] one or more keys with lists
+      # @params modifier [String]
+      #  - when `"LEFT"` - the elements popped are those from the left of the list
+      #  - when `"RIGHT"` - the elements popped are those from the right of the list
+      # @params count [Integer] a number of elements to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements or nil
+      def blmpop(timeout, *keys, modifier: "LEFT", count: nil)
+        raise ArgumentError, "Pick either LEFT or RIGHT" unless modifier == "LEFT" || modifier == "RIGHT"
+
+        args = [:blmpop, timeout, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_blocking_command(args, timeout)
+      end
+
+      # Pops one or more elements from the first non-empty list key from the list
+      # of provided key names.
+      #
+      # @example Popping a element
+      #   redis.lmpop('list')
+      #   #=> ['list', ['a']]
+      # @example With count option
+      #   redis.lmpop('list', count: 2)
+      #   #=> ['list', ['a', 'b']]
+      #
+      # @params key [String, Array<String>] one or more keys with lists
+      # @params modifier [String]
+      #  - when `"LEFT"` - the elements popped are those from the left of the list
+      #  - when `"RIGHT"` - the elements popped are those from the right of the list
+      # @params count [Integer] a number of elements to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements or nil
+      def lmpop(*keys, modifier: "LEFT", count: nil)
+        raise ArgumentError, "Pick either LEFT or RIGHT" unless modifier == "LEFT" || modifier == "RIGHT"
+
+        args = [:lmpop, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_command(args)
+      end
+
       # Get an element from a list by its index.
       #
       # @param [String] key

data/lib/redis/commands/pubsub.rb

@@ -29,17 +29,23 @@ class Redis
       end
 
       # Listen for messages published to channels matching the given patterns.
+      # See the [Redis Server PSUBSCRIBE documentation](https://redis.io/docs/latest/commands/psubscribe/)
+      # for further details
       def psubscribe(*channels, &block)
         _subscription(:psubscribe, 0, channels, block)
       end
 
       # Listen for messages published to channels matching the given patterns.
       # Throw a timeout error if there is no messages for a timeout period.
+      # See the [Redis Server PSUBSCRIBE documentation](https://redis.io/docs/latest/commands/psubscribe/)
+      # for further details
       def psubscribe_with_timeout(timeout, *channels, &block)
         _subscription(:psubscribe_with_timeout, timeout, channels, block)
       end
 
       # Stop listening for messages posted to channels matching the given patterns.
+      # See the [Redis Server PUNSUBSCRIBE documentation](https://redis.io/docs/latest/commands/punsubscribe/)
+      # for further details
       def punsubscribe(*channels)
         _subscription(:punsubscribe, 0, channels, nil)
       end
@@ -49,6 +55,27 @@ class Redis
       def pubsub(subcommand, *args)
         send_command([:pubsub, subcommand] + args)
       end
+
+      # Post a message to a channel in a shard.
+      def spublish(channel, message)
+        send_command([:spublish, channel, message])
+      end
+
+      # Listen for messages published to the given channels in a shard.
+      def ssubscribe(*channels, &block)
+        _subscription(:ssubscribe, 0, channels, block)
+      end
+
+      # Listen for messages published to the given channels in a shard.
+      # Throw a timeout error if there is no messages for a timeout period.
+      def ssubscribe_with_timeout(timeout, *channels, &block)
+        _subscription(:ssubscribe_with_timeout, timeout, channels, block)
+      end
+
+      # Stop listening for messages posted to the given channels in a shard.
+      def sunsubscribe(*channels)
+        _subscription(:sunsubscribe, 0, channels, nil)
+      end
     end
   end
 end

data/lib/redis/commands/sets.rb

@@ -184,6 +184,8 @@ class Redis
       #   - `:count => Integer`: return count keys at most per iteration
       #
       # @return [String, Array<String>] the next cursor and all found members
+      #
+      # See the [Redis Server SSCAN documentation](https://redis.io/docs/latest/commands/sscan/) for further details
       def sscan(key, cursor, **options)
         _scan(:sscan, cursor, [key], **options)
       end
@@ -199,6 +201,8 @@ class Redis
       #   - `:count => Integer`: return count keys at most per iteration
       #
       # @return [Enumerator] an enumerator for all keys in the set
+      #
+      # See the [Redis Server SSCAN documentation](https://redis.io/docs/latest/commands/sscan/) for further details
       def sscan_each(key, **options, &block)
         return to_enum(:sscan_each, key, **options) unless block_given?
 

data/lib/redis/commands/sorted_sets.rb

@@ -167,6 +167,72 @@ class Redis
         end
       end
 
+      # Removes and returns up to count members with scores in the sorted set stored at key.
+      #
+      # @example Popping a member
+      #   redis.bzmpop('zset')
+      #   #=> ['zset', ['a', 1.0]]
+      # @example With count option
+      #   redis.bzmpop('zset', count: 2)
+      #   #=> ['zset', [['a', 1.0], ['b', 2.0]]
+      #
+      # @params timeout [Float] a float value specifying the maximum number of seconds to block) elapses.
+      #   A timeout of zero can be used to block indefinitely.
+      # @params key [String, Array<String>] one or more keys with sorted sets
+      # @params modifier [String]
+      #  - when `"MIN"` - the elements popped are those with lowest scores
+      #  - when `"MAX"` - the elements popped are those with the highest scores
+      # @params count [Integer] a number of members to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements and scores
+      def bzmpop(timeout, *keys, modifier: "MIN", count: nil)
+        raise ArgumentError, "Pick either MIN or MAX" unless modifier == "MIN" || modifier == "MAX"
+
+        args = [:bzmpop, timeout, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_blocking_command(args, timeout) do |response|
+          response&.map do |entry|
+            case entry
+            when String then entry
+            when Array then entry.map { |pair| FloatifyPairs.call(pair) }.flatten(1)
+            end
+          end
+        end
+      end
+
+      # Removes and returns up to count members with scores in the sorted set stored at key.
+      #
+      # @example Popping a member
+      #   redis.zmpop('zset')
+      #   #=> ['zset', ['a', 1.0]]
+      # @example With count option
+      #   redis.zmpop('zset', count: 2)
+      #   #=> ['zset', [['a', 1.0], ['b', 2.0]]
+      #
+      # @params key [String, Array<String>] one or more keys with sorted sets
+      # @params modifier [String]
+      #  - when `"MIN"` - the elements popped are those with lowest scores
+      #  - when `"MAX"` - the elements popped are those with the highest scores
+      # @params count [Integer] a number of members to pop
+      #
+      # @return [Array<String, Array<String, Float>>] list of popped elements and scores
+      def zmpop(*keys, modifier: "MIN", count: nil)
+        raise ArgumentError, "Pick either MIN or MAX" unless modifier == "MIN" || modifier == "MAX"
+
+        args = [:zmpop, keys.size, *keys, modifier]
+        args << "COUNT" << Integer(count) if count
+
+        send_command(args) do |response|
+          response&.map do |entry|
+            case entry
+            when String then entry
+            when Array then entry.map { |pair| FloatifyPairs.call(pair) }.flatten(1)
+            end
+          end
+        end
+      end
+
       # Removes and returns up to count members with the highest scores in the sorted set stored at keys,
       #   or block until one is available.
       #
@@ -388,21 +454,55 @@ class Redis
 
       # Determine the index of a member in a sorted set.
       #
+      # @example Retrieve member rank
+      #   redis.zrank("zset", "a")
+      #     # => 3
+      # @example Retrieve member rank with their score
+      #   redis.zrank("zset", "a", :with_score => true)
+      #     # => [3, 32.0]
+      #
       # @param [String] key
       # @param [String] member
-      # @return [Integer]
-      def zrank(key, member)
-        send_command([:zrank, key, member])
+      #
+      # @return [Integer, [Integer, Float]]
+      #   - when `:with_score` is not specified, an Integer
+      #   - when `:with_score` is specified, a `[rank, score]` pair
+      def zrank(key, member, withscore: false, with_score: withscore)
+        args = [:zrank, key, member]
+
+        if with_score
+          args << "WITHSCORE"
+          block = FloatifyPair
+        end
+
+        send_command(args, &block)
       end
 
       # Determine the index of a member in a sorted set, with scores ordered from
       # high to low.
       #
+      # @example Retrieve member rank
+      #   redis.zrevrank("zset", "a")
+      #     # => 3
+      # @example Retrieve member rank with their score
+      #   redis.zrevrank("zset", "a", :with_score => true)
+      #     # => [3, 32.0]
+      #
       # @param [String] key
       # @param [String] member
-      # @return [Integer]
-      def zrevrank(key, member)
-        send_command([:zrevrank, key, member])
+      #
+      # @return [Integer, [Integer, Float]]
+      #   - when `:with_score` is not specified, an Integer
+      #   - when `:with_score` is specified, a `[rank, score]` pair
+      def zrevrank(key, member, withscore: false, with_score: withscore)
+        args = [:zrevrank, key, member]
+
+        if with_score
+          args << "WITHSCORE"
+          block = FloatifyPair
+        end
+
+        send_command(args, &block)
       end
 
       # Remove all members in a sorted set within the given indexes.
@@ -751,6 +851,8 @@ class Redis
       #
       # @return [String, Array<[String, Float]>] the next cursor and all found
       #   members and scores
+      #
+      # See the [Redis Server ZSCAN documentation](https://redis.io/docs/latest/commands/zscan/) for further details
       def zscan(key, cursor, **options)
         _scan(:zscan, cursor, [key], **options) do |reply|
           [reply[0], FloatifyPairs.call(reply[1])]
@@ -768,6 +870,8 @@ class Redis
       #   - `:count => Integer`: return count keys at most per iteration
       #
       # @return [Enumerator] an enumerator for all found scores and members
+      #
+      # See the [Redis Server ZSCAN documentation](https://redis.io/docs/latest/commands/zscan/) for further details
       def zscan_each(key, **options, &block)
         return to_enum(:zscan_each, key, **options) unless block_given?
 

data/lib/redis/commands/streams.rb

@@ -41,18 +41,25 @@ class Redis
       # @param opts  [Hash]   several options for `XADD` command
       #
       # @option opts [String]  :id          the entry id, default value is `*`, it means auto generation
-      # @option opts [Integer] :maxlen      max length of entries
-      # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen or not
+      # @option opts [Integer] :maxlen      max length of entries to keep
+      # @option opts [Integer] :minid       min id of entries to keep
+      # @option opts [Boolean] :approximate whether to add `~` modifier of maxlen/minid or not
       # @option opts [Boolean] :nomkstream  whether to add NOMKSTREAM, default is not to add
       #
       # @return [String] the entry id
-      def xadd(key, entry, approximate: nil, maxlen: nil, nomkstream: nil, id: '*')
+      def xadd(key, entry, approximate: nil, maxlen: nil, minid: nil, nomkstream: nil, id: '*')
         args = [:xadd, key]
         args << 'NOMKSTREAM' if nomkstream
         if maxlen
+          raise ArgumentError, "can't supply both maxlen and minid" if minid
+
           args << "MAXLEN"
           args << "~" if approximate
           args << maxlen
+        elsif minid
+          args << "MINID"
+          args << "~" if approximate
+          args << minid
         end
         args << id
         args.concat(entry.flatten)

data/lib/redis/commands.rb

@@ -83,12 +83,14 @@ class Redis
       end
     }
 
+    FloatifyPair = lambda { |(first, score)|
+      [first, Floatify.call(score)]
+    }
+
     FloatifyPairs = lambda { |value|
       return value unless value.respond_to?(:each_slice)
 
-      value.each_slice(2).map do |member, score|
-        [member, Floatify.call(score)]
-      end
+      value.each_slice(2).map(&FloatifyPair)
     }
 
     HashifyInfo = lambda { |reply|
@@ -199,8 +201,8 @@ class Redis
     # hash, are up to consumers.
     #
     # Redis error replies are raised as Ruby exceptions.
-    def call(*command)
-      send_command(command)
+    def call(*command, &block)
+      send_command(command, &block)
     end
 
     # Interact with the sentinel command (masters, master, slaves, failover)

data/lib/redis/distributed.rb

@@ -130,6 +130,11 @@ class Redis
       node_for(key).expireat(key, unix_time, **kwargs)
     end
 
+    # Get the expiration for a key as a UNIX timestamp.
+    def expiretime(key)
+      node_for(key).expiretime(key)
+    end
+
     # Get the time to live (in seconds) for a key.
     def ttl(key)
       node_for(key).ttl(key)
@@ -145,6 +150,11 @@ class Redis
       node_for(key).pexpireat(key, ms_unix_time, **kwarg)
     end
 
+    # Get the expiration for a key as number of milliseconds from UNIX Epoch.
+    def pexpiretime(key)
+      node_for(key).pexpiretime(key)
+    end
+
     # Get the time to live (in milliseconds) for a key.
     def pttl(key)
       node_for(key).pttl(key)
@@ -370,8 +380,8 @@ class Redis
     end
 
     # Count the number of set bits in a range of the string value stored at key.
-    def bitcount(key, start = 0, stop = -1)
-      node_for(key).bitcount(key, start, stop)
+    def bitcount(key, start = 0, stop = -1, scale: nil)
+      node_for(key).bitcount(key, start, stop, scale: scale)
     end
 
     # Perform a bitwise operation between strings and store the resulting string in a key.
@@ -383,8 +393,8 @@ class Redis
     end
 
     # Return the position of the first bit set to 1 or 0 in a string.
-    def bitpos(key, bit, start = nil, stop = nil)
-      node_for(key).bitpos(key, bit, start, stop)
+    def bitpos(key, bit, start = nil, stop = nil, scale: nil)
+      node_for(key).bitpos(key, bit, start, stop, scale: scale)
     end
 
     # Set the string value of a key and return its old value.
@@ -542,6 +552,20 @@ class Redis
       node_for(key).ltrim(key, start, stop)
     end
 
+    # Iterate over keys, blocking and removing elements from the first non empty liist found.
+    def blmpop(timeout, *keys, modifier: "LEFT", count: nil)
+      ensure_same_node(:blmpop, keys) do |node|
+        node.blmpop(timeout, *keys, modifier: modifier, count: count)
+      end
+    end
+
+    # Iterate over keys, removing elements from the first non list found.
+    def lmpop(*keys, modifier: "LEFT", count: nil)
+      ensure_same_node(:lmpop, keys) do |node|
+        node.lmpop(*keys, modifier: modifier, count: count)
+      end
+    end
+
     # Get the number of members in a set.
     def scard(key)
       node_for(key).scard(key)
@@ -694,6 +718,20 @@ class Redis
       node_for(key).zmscore(key, *members)
     end
 
+    # Iterate over keys, blocking and removing members from the first non empty sorted set found.
+    def bzmpop(timeout, *keys, modifier: "MIN", count: nil)
+      ensure_same_node(:bzmpop, keys) do |node|
+        node.bzmpop(timeout, *keys, modifier: modifier, count: count)
+      end
+    end
+
+    # Iterate over keys, removing members from the first non empty sorted set found.
+    def zmpop(*keys, modifier: "MIN", count: nil)
+      ensure_same_node(:zmpop, keys) do |node|
+        node.zmpop(*keys, modifier: modifier, count: count)
+      end
+    end
+
     # Return a range of members in a sorted set, by index, score or lexicographical ordering.
     def zrange(key, start, stop, **options)
       node_for(key).zrange(key, start, stop, **options)
@@ -714,14 +752,14 @@ class Redis
     end
 
     # Determine the index of a member in a sorted set.
-    def zrank(key, member)
-      node_for(key).zrank(key, member)
+    def zrank(key, member, **options)
+      node_for(key).zrank(key, member, **options)
     end
 
     # Determine the index of a member in a sorted set, with scores ordered from
     # high to low.
-    def zrevrank(key, member)
-      node_for(key).zrevrank(key, member)
+    def zrevrank(key, member, **options)
+      node_for(key).zrevrank(key, member, **options)
     end
 
     # Remove all members in a sorted set within the given indexes.
@@ -910,12 +948,16 @@ class Redis
     end
 
     # Listen for messages published to channels matching the given patterns.
+    # See the [Redis Server PSUBSCRIBE documentation](https://redis.io/docs/latest/commands/psubscribe/)
+    # for further details
     def psubscribe(*channels, &block)
       raise NotImplementedError
     end
 
     # Stop listening for messages posted to channels matching the given
     # patterns.
+    # See the [Redis Server PUNSUBSCRIBE documentation](https://redis.io/docs/latest/commands/punsubscribe/)
+    # for further details
     def punsubscribe(*channels)
       raise NotImplementedError
     end

data/lib/redis/errors.rb

@@ -29,6 +29,11 @@ class Redis
   class OutOfMemoryError < CommandError
   end
 
+  if defined?(RedisClient::NoScriptError)
+    class NoScriptError < CommandError
+    end
+  end
+
   # Base error for connection related errors.
   class BaseConnectionError < BaseError
   end

data/lib/redis/pipeline.rb

@@ -6,9 +6,10 @@ class Redis
   class PipelinedConnection
     attr_accessor :db
 
-    def initialize(pipeline, futures = [])
+    def initialize(pipeline, futures = [], exception: true)
       @pipeline = pipeline
       @futures = futures
+      @exception = exception
     end
 
     include Commands
@@ -37,7 +38,7 @@ class Redis
     end
 
     def send_command(command, &block)
-      future = Future.new(command, block)
+      future = Future.new(command, block, @exception)
       @pipeline.call_v(command) do |result|
         future._set(result)
       end
@@ -46,7 +47,7 @@ class Redis
     end
 
     def send_blocking_command(command, timeout, &block)
-      future = Future.new(command, block)
+      future = Future.new(command, block, @exception)
       @pipeline.blocking_call_v(timeout, command) do |result|
         future._set(result)
       end
@@ -57,7 +58,7 @@ class Redis
 
   class MultiConnection < PipelinedConnection
     def multi
-      raise Redis::Error, "Can't nest multi transaction"
+      raise Redis::BaseError, "Can't nest multi transaction"
     end
 
     private
@@ -79,10 +80,11 @@ class Redis
   class Future < BasicObject
     FutureNotReady = ::Redis::FutureNotReady.new
 
-    def initialize(command, coerce)
+    def initialize(command, coerce, exception)
       @command = command
       @object = FutureNotReady
       @coerce = coerce
+      @exception = exception
     end
 
     def inspect
@@ -95,7 +97,7 @@ class Redis
     end
 
     def value
-      ::Kernel.raise(@object) if @object.is_a?(::StandardError)
+      ::Kernel.raise(@object) if @exception && @object.is_a?(::StandardError)
       @object
     end
 
@@ -116,12 +118,14 @@ class Redis
     end
 
     def _set(replies)
-      if replies
-        @futures.each_with_index do |future, index|
+      @object = if replies
+        @futures.map.with_index do |future, index|
           future._set(replies[index])
+          future.value
         end
+      else
+        replies
       end
-      @object = replies
     end
   end
 end

data/lib/redis/subscribe.rb

@@ -29,6 +29,14 @@ class Redis
       subscription("psubscribe", "punsubscribe", channels, block, timeout)
     end
 
+    def ssubscribe(*channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block)
+    end
+
+    def ssubscribe_with_timeout(timeout, *channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block, timeout)
+    end
+
     def unsubscribe(*channels)
       call_v([:unsubscribe, *channels])
     end
@@ -37,6 +45,10 @@ class Redis
       call_v([:punsubscribe, *channels])
     end
 
+    def sunsubscribe(*channels)
+      call_v([:sunsubscribe, *channels])
+    end
+
     def close
       @client.close
     end
@@ -46,7 +58,11 @@ class Redis
     def subscription(start, stop, channels, block, timeout = 0)
       sub = Subscription.new(&block)
 
-      call_v([start, *channels])
+      case start
+      when "ssubscribe" then channels.each { |c| call_v([start, c]) } # avoid cross-slot keys
+      else call_v([start, *channels])
+      end
+
       while event = @client.next_event(timeout)
         if event.is_a?(::RedisClient::CommandError)
           raise Client::ERROR_MAPPING.fetch(event.class), event.message
@@ -94,5 +110,17 @@ class Redis
     def pmessage(&block)
       @callbacks["pmessage"] = block
     end
+
+    def ssubscribe(&block)
+      @callbacks["ssubscribe"] = block
+    end
+
+    def sunsubscribe(&block)
+      @callbacks["sunsubscribe"] = block
+    end
+
+    def smessage(&block)
+      @callbacks["smessage"] = block
+    end
   end
 end

data/lib/redis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Redis
-  VERSION = '5.0.6'
+  VERSION = '5.4.1'
 end

data/lib/redis.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "redis-client"
+
 require "monitor"
 require "redis/errors"
 require "redis/commands"
@@ -45,7 +47,7 @@ class Redis
   # @option options [String] :host ("127.0.0.1") server hostname
   # @option options [Integer] :port (6379) server port
   # @option options [String] :path path to server socket (overrides host and port)
-  # @option options [Float] :timeout (5.0) timeout in seconds
+  # @option options [Float] :timeout (1.0) timeout in seconds
   # @option options [Float] :connect_timeout (same as timeout) timeout for initial connect in seconds
   # @option options [String] :username Username to authenticate against server
   # @option options [String] :password Password to authenticate against server
@@ -99,10 +101,10 @@ class Redis
     @client
   end
 
-  def pipelined
+  def pipelined(exception: true)
     synchronize do |client|
-      client.pipelined do |raw_pipeline|
-        yield PipelinedConnection.new(raw_pipeline)
+      client.pipelined(exception: exception) do |raw_pipeline|
+        yield PipelinedConnection.new(raw_pipeline, exception: exception)
       end
     end
   end
@@ -137,21 +139,6 @@ class Redis
     end
 
     if options.key?(:sentinels)
-      if url = options.delete(:url)
-        uri = URI.parse(url)
-        if !options.key?(:name) && uri.host
-          options[:name] = uri.host
-        end
-
-        if !options.key?(:password) && uri.password && !uri.password.empty?
-          options[:password] = uri.password
-        end
-
-        if !options.key?(:username) && uri.user && !uri.user.empty?
-          options[:username] = uri.user
-        end
-      end
-
       Client.sentinel(**options).new_client
     else
       Client.config(**options).new_client
@@ -166,6 +153,8 @@ class Redis
     @monitor.synchronize do
       @client.call_v(command, &block)
     end
+  rescue ::RedisClient::Error => error
+    Client.translate_error!(error)
   end
 
   def send_blocking_command(command, timeout, &block)
@@ -188,6 +177,7 @@ class Redis
           @subscription_client.send(method, *channels, &block)
         end
       ensure
+        @subscription_client&.close
         @subscription_client = nil
       end
     else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 5.0.6
+  version: 5.4.1
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -13,10 +13,9 @@ authors:
 - Michel Martens
 - Damian Janowski
 - Pieter Noordhuis
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-16 00:00:00.000000000 Z
+date: 2025-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -24,14 +23,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.22.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.22.0
 description: |2
       A Ruby client that tries to match Redis' API one-to-one, while still
       providing an idiomatic interface.
@@ -75,10 +74,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/redis/redis-rb/issues
   changelog_uri: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/redis/5.0.6
+  documentation_uri: https://www.rubydoc.info/gems/redis/5.4.1
   homepage_uri: https://github.com/redis/redis-rb
-  source_code_uri: https://github.com/redis/redis-rb/tree/v5.0.6
-post_install_message:
+  source_code_uri: https://github.com/redis/redis-rb/tree/v5.4.1
 rdoc_options: []
 require_paths:
 - lib
@@ -86,15 +84,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: A Ruby client library for Redis
 test_files: []