redis 3.3.5 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 729f56810aa501065e2fc203050363713c80ee37
-  data.tar.gz: e7e13fb75618f794a2c742d73d6c8a72699d5e92
+  metadata.gz: fb5e8fcd26f9729131009cc0c25bed4cdf1009f5
+  data.tar.gz: 9ed7be2cc83d01dcb6c69002680105dc544e659a
 SHA512:
-  metadata.gz: f87e76c751760b7f1feb7c859ea373c41ebf805c104c27e85177cb20a60d42b11c50db2d5a916fb7bfc78b82b13141770a851568aea922ccc1970f4e30ba1dea
-  data.tar.gz: ac4cb236c9c9897d73ead9421e161cf1c7aac2a3c1f77c088b5c52c324cddccda6ab749441093cbcc94ea812e70232f9f9ac1c160a96fd1fbd46d87586d1d7fb
+  metadata.gz: b39badbb4689a4ea93cbc65ad00f0c967f24dadcc41e7750ab82977176236d6d8609d8e7b74e13a3829ce008c4a5de90930e265f6b6e03af710811419da6ccf6
+  data.tar.gz: 3ede92146cb181328657a4713e94473f86661dffe0a66d23f48edaa2c7a6c52543a7e7036794baa9dcc2945bc3f9e5eebd9192b70510bda1ad9c0d6e67253830

data/CHANGELOG.md

@@ -1,8 +1,60 @@
+# Unreleased
+
+# 4.1.0
+
+* Add Redis Cluster support. See #716.
+* Add streams support. See #799 and #811.
+* Add ZPOP* support. See #812.
+* Fix issues with integer-like objects as BPOP timeout
+
+# 4.0.3
+
+* Fix raising command error for first command in pipeline. See #788.
+* Fix the gemspec to stop exposing a `build` executable. See #785.
+* Add `:reconnect_delay` and `:reconnect_delay_max` options. See #778.
+
+# 4.0.2
+
+* Added `Redis#unlink`. See #766.
+
+* `Redis.new` now accept a custom connector via `:connector`. See #591.
+
+* `Redis#multi` no longer perform empty transactions. See #747.
+
+* `Redis#hdel` now accepts hash keys as multiple arguments like `#del`. See #755.
+
+* Allow to skip SSL verification. See #745.
+
+* Add Geo commands: `geoadd`, `geohash`, `georadius`, `georadiusbymember`, `geopos`, `geodist`. See #730.
+
+# 4.0.1
+
+* `Redis::Distributed` now supports `mget` and `mapped_mget`. See #687.
+
+* `Redis::Distributed` now supports `sscan` and `sscan_each`. See #572.
+
+* `Redis#connection` returns a hash with connection information.
+  You shouldn't need to call `Redis#_client`, ever.
+
+* `Redis#flushdb` and `Redis#flushall` now support the `:async` option. See #706.
+
+
+# 4.0
+
+* Removed `Redis.connect`. Use `Redis.new`.
+
+* Removed `Redis#[]` and `Redis#[]=` aliases.
+
+* Added support for `CLIENT` commands. The lower-level client can be
+  accessed via `Redis#_client`.
+
+* Dropped official support for Ruby < 2.2.2.
+
 # 3.3.5
 
 * Fixed Ruby 1.8 compatibility after backporting `Redis#connection`. See #719.
 
-# 3.3.4
+# 3.3.4 (yanked)
 
 * `Redis#connection` returns a hash with connection information.
   You shouldn't need to call `Redis#_client`, ever.
@@ -13,7 +65,7 @@
 
 # 3.3.2
 
-* Added support for SPOP with COUNT. See #628.
+* Added support for `SPOP` with COUNT. See #628.
 
 * Fixed connection glitches when using SSL. See #644.
 

data/README.md

@@ -1,46 +1,17 @@
 # redis-rb [![Build Status][travis-image]][travis-link] [![Inline docs][inchpages-image]][inchpages-link]
 
-[travis-image]: https://secure.travis-ci.org/redis/redis-rb.png?branch=master
-[travis-link]: http://travis-ci.org/redis/redis-rb
-[travis-home]: http://travis-ci.org/
-[inchpages-image]: http://inch-ci.org/github/redis/redis-rb.png
-[inchpages-link]: http://inch-ci.org/github/redis/redis-rb
+A Ruby client that tries to match [Redis][redis-home]' API one-to-one, while still
+providing an idiomatic interface.
 
-A Ruby client library for [Redis][redis-home].
-
-[redis-home]: http://redis.io
-
-A Ruby client that tries to match Redis' API one-to-one, while still
-providing an idiomatic interface. It features thread-safety, client-side
-sharding, pipelining, and an obsession for performance.
-
-## Upgrading from 2.x to 3.0
-
-Please refer to the [CHANGELOG][changelog-3.0.0] for a summary of the
-most important changes, as well as a full list of changes.
-
-[changelog-3.0.0]: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md#300
 
 ## Getting started
 
-To install **redis-rb**, run the following command:
+Install with:
 
 ```
-  gem install redis
+$ gem install redis
 ```
 
-Or if you are using **bundler**, add
-
-```
-  gem 'redis', '~>3.2'
-```
-
-to your `Gemfile`, and run `bundle install`
-
-As of version 2.0 this client only targets Redis version 2.0 and higher.
-You can use an older version of this client if you need to interface
-with a Redis instance older than 2.0, but this is no longer supported.
-
 You can connect to Redis by instantiating the `Redis` class:
 
 ```ruby
@@ -54,17 +25,15 @@ listening on `localhost`, port 6379. If you need to connect to a remote
 server or a different port, try:
 
 ```ruby
-redis = Redis.new(:host => "10.0.1.1", :port => 6380, :db => 15)
+redis = Redis.new(host: "10.0.1.1", port: 6380, db: 15)
 ```
 
 You can also specify connection options as a [`redis://` URL][redis-url]:
 
 ```ruby
-redis = Redis.new(:url => "redis://:p4ssw0rd@10.0.1.1:6380/15")
+redis = Redis.new(url: "redis://:p4ssw0rd@10.0.1.1:6380/15")
 ```
 
-[redis-url]: http://www.iana.org/assignments/uri-schemes/prov/redis
-
 By default, the client will try to read the `REDIS_URL` environment variable
 and use that as URL to connect to. The above statement is therefore equivalent
 to setting this environment variable and calling `Redis.new` without arguments.
@@ -72,13 +41,13 @@ to setting this environment variable and calling `Redis.new` without arguments.
 To connect to Redis listening on a Unix socket, try:
 
 ```ruby
-redis = Redis.new(:path => "/tmp/redis.sock")
+redis = Redis.new(path: "/tmp/redis.sock")
 ```
 
 To connect to a password protected Redis instance, use:
 
 ```ruby
-redis = Redis.new(:password => "mysecret")
+redis = Redis.new(password: "mysecret")
 ```
 
 The Redis class exports methods that are named identical to the commands
@@ -86,8 +55,6 @@ they execute. The arguments these methods accept are often identical to
 the arguments specified on the [Redis website][redis-commands]. For
 instance, the `SET` and `GET` commands can be called like this:
 
-[redis-commands]: http://redis.io/commands
-
 ```ruby
 redis.set("mykey", "hello world")
 # => "OK"
@@ -96,24 +63,22 @@ redis.get("mykey")
 # => "hello world"
 ```
 
-All commands, their arguments and return values are documented, and
-available on [rdoc.info][rdoc].
-
-[rdoc]: http://rdoc.info/github/redis/redis-rb/
+All commands, their arguments, and return values are documented and
+available on [RubyDoc.info][rubydoc].
 
 ## Sentinel support
 
-The client is able to perform automatic failovers by using [Redis
+The client is able to perform automatic failover by using [Redis
 Sentinel](http://redis.io/topics/sentinel).  Make sure to run Redis 2.8+
 if you want to use this feature.
 
 To connect using Sentinel, use:
 
 ```ruby
-SENTINELS = [{:host => "127.0.0.1", :port => 26380},
-             {:host => "127.0.0.1", :port => 26381}]
+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(url: "redis://mymaster", sentinels: SENTINELS, role: :master)
 ```
 
 * The master name identifies a group of Redis instances composed of a master
@@ -211,7 +176,7 @@ it can't connect to the server a `Redis::CannotConnectError` error will be raise
 ```ruby
 begin
   redis.ping
-rescue Exception => e
+rescue StandardError => e
   e.inspect
 # => #<Redis::CannotConnectError: Timed out connecting to Redis on 10.0.1.1:6380>
 
@@ -255,6 +220,51 @@ end
 
 If no message is received after 5 seconds, the client will unsubscribe.
 
+## Reconnections
+
+The client allows you to configure how many `reconnect_attempts` it should
+complete before declaring a connection as failed. Furthermore, you may want
+to control the maximum duration between reconnection attempts with
+`reconnect_delay` and `reconnect_delay_max`.
+
+```ruby
+Redis.new(
+  :reconnect_attempts => 10,
+  :reconnect_delay => 1.5,
+  :reconnect_delay_max => 10.0,
+)
+```
+
+The delay values are specified in seconds. With the above configuration, the
+client would attempt 10 reconnections, exponentially increasing the duration
+between each attempt but it never waits longer than `reconnect_delay_max`.
+
+This is the retry algorithm:
+
+```ruby
+attempt_wait_time = [(reconnect_delay * 2**(attempt-1)), reconnect_delay_max].min
+```
+
+**By default**, this gem will only **retry a connection once** and then fail, but with the
+above configuration the reconnection attempt would look like this:
+
+#|Attempt wait time|Total wait time
+:-:|:-:|:-:
+1|1.5s|1.5s
+2|3.0s|4.5s
+3|6.0s|10.5s
+4|10.0s|20.5s
+5|10.0s|30.5s
+6|10.0s|40.5s
+7|10.0s|50.5s
+8|10.0s|60.5s
+9|10.0s|70.5s
+10|10.0s|80.5s
+
+So if the reconnection attempt #10 succeeds 70 seconds have elapsed trying
+to reconnect, this is likely fine in long-running background processes, but if
+you use Redis to drive your website you might want to have a lower
+`reconnect_delay_max` or have less `reconnect_attempts`.
 
 ## SSL/TLS Support
 
@@ -374,37 +384,28 @@ redis = Redis.new(:driver => :synchrony)
 
 ## Testing
 
-This library is tested using [Travis][travis-home], where it is tested
-against the following interpreters and drivers:
-
-* MRI 1.8.7 (drivers: ruby, hiredis)
-* MRI 1.9.3 (drivers: ruby, hiredis, synchrony)
-* MRI 2.0 (drivers: ruby, hiredis, synchrony)
-* MRI 2.1 (drivers: ruby, hiredis, synchrony)
-* MRI 2.2 (drivers: ruby, hiredis, synchrony)
-* MRI 2.3 (drivers: ruby, hiredis, synchrony)
-* JRuby 1.7 (1.8 mode) (drivers: ruby)
-* JRuby 1.7 (1.9 mode) (drivers: ruby)
+This library is tested against recent Ruby and Redis versions.
+Check [Travis][travis-link] for the exact versions supported.
 
 ## Contributors
 
-(ordered chronologically with more than 5 commits, see `git shortlog -sn` for
-all contributors)
-
-* Ezra Zygmuntowicz
-* Taylor Weibley
-* Matthew Clark
-* Brian McKinney
-* Luca Guidi
-* Salvatore Sanfilippo
-* Chris Wanstrath
-* Damian Janowski
-* Michel Martens
-* Nick Quaranto
-* Pieter Noordhuis
-* Ilya Grigorik
+Several people contributed to redis-rb, but we would like to especially
+mention Ezra Zygmuntowicz. Ezra introduced the Ruby community to many
+new cool technologies, like Redis. He wrote the first version of this
+client and evangelized Redis in Rubyland. Thank you, Ezra.
 
 ## Contributing
 
 [Fork the project](https://github.com/redis/redis-rb) and send pull
 requests. You can also ask for help at `#redis-rb` on Freenode.
+
+
+[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
+[travis-home]:     https://travis-ci.org/
+[travis-image]:    https://secure.travis-ci.org/redis/redis-rb.svg?branch=master
+[travis-link]:     https://travis-ci.org/redis/redis-rb
+[rubydoc]:         http://www.rubydoc.info/gems/redis

data/lib/redis.rb

@@ -1,21 +1,8 @@
 require "monitor"
-require "redis/errors"
+require_relative "redis/errors"
 
 class Redis
 
-  def self.deprecate(message, trace = caller[0])
-    $stderr.puts "\n#{message} (in #{trace})"
-  end
-
-  attr :client
-
-  # @deprecated The preferred way to create a new client object is using `#new`.
-  #             This method does not actually establish a connection to Redis,
-  #             in contrary to what you might expect.
-  def self.connect(options = {})
-    new(options)
-  end
-
   def self.current
     @current ||= Redis.new
   end
@@ -44,11 +31,16 @@ class Redis
   # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
   # @option options [Array] :sentinels List of sentinels to contact
   # @option options [Symbol] :role (:master) Role to fetch via Sentinel, either `:master` or `:slave`
+  # @option options [Array<String, Hash{Symbol => String, Integer}>] :cluster List of cluster nodes to contact
+  # @option options [Boolean] :replica Whether to use readonly replica nodes in Redis Cluster or not
+  # @option options [Class] :connector Class of custom connector
   #
   # @return [Redis] a new client instance
   def initialize(options = {})
     @options = options.dup
-    @original_client = @client = Client.new(options)
+    @cluster_mode = options.key?(:cluster)
+    client = @cluster_mode ? Cluster : Client
+    @original_client = @client = client.new(options)
     @queue = Hash.new { |h, k| h[k] = [] }
 
     super() # Monitor#initialize
@@ -119,6 +111,10 @@ class Redis
     end
   end
 
+  def _client
+    @client
+  end
+
   # Authenticate to the server.
   #
   # @param [String] password must match the password specified in the
@@ -143,10 +139,11 @@ class Redis
 
   # Ping the server.
   #
+  # @param [optional, String] message
   # @return [String] `PONG`
-  def ping
+  def ping(message = nil)
     synchronize do |client|
-      client.call([:ping])
+      client.call([:ping, message].compact)
     end
   end
 
@@ -209,6 +206,25 @@ class Redis
     end
   end
 
+  # Manage client connections.
+  #
+  # @param [String, Symbol] subcommand e.g. `kill`, `list`, `getname`, `setname`
+  # @return [String, Hash] depends on subcommand
+  def client(subcommand = nil, *args)
+    synchronize do |client|
+      client.call([:client, subcommand] + args) do |reply|
+        if subcommand.to_s == "list"
+          reply.lines.map do |line|
+            entries = line.chomp.split(/[ =]/)
+            Hash[entries.each_slice(2).to_a]
+          end
+        else
+          reply
+        end
+      end
+    end
+  end
+
   # Return the number of keys in the selected database.
   #
   # @return [Fixnum]
@@ -226,19 +242,31 @@ class Redis
 
   # Remove all keys from all databases.
   #
+  # @param [Hash] options
+  #   - `:async => Boolean`: async flush (default: false)
   # @return [String] `OK`
-  def flushall
+  def flushall(options = nil)
     synchronize do |client|
-      client.call([:flushall])
+      if options && options[:async]
+        client.call([:flushall, :async])
+      else
+        client.call([:flushall])
+      end
     end
   end
 
   # Remove all keys from the current database.
   #
+  # @param [Hash] options
+  #   - `:async => Boolean`: async flush (default: false)
   # @return [String] `OK`
-  def flushdb
+  def flushdb(options = nil)
     synchronize do |client|
-      client.call([:flushdb])
+      if options && options[:async]
+        client.call([:flushdb, :async])
+      else
+        client.call([:flushdb])
+      end
     end
   end
 
@@ -250,9 +278,7 @@ class Redis
     synchronize do |client|
       client.call([:info, cmd].compact) do |reply|
         if reply.kind_of?(String)
-          reply = Hash[reply.split("\r\n").map do |line|
-            line.split(":", 2) unless line =~ /^(#|$)/
-          end.compact]
+          reply = HashifyInfo.call(reply)
 
           if cmd && cmd.to_s == "commandstats"
             # Extract nested hashes for INFO COMMANDSTATS
@@ -458,31 +484,42 @@ class Redis
   # @param [String] key
   # @param [String] ttl
   # @param [String] serialized_value
+  # @param [Hash] options
+  #   - `:replace => Boolean`: if false, raises an error if key already exists
+  # @raise [Redis::CommandError]
   # @return [String] `"OK"`
-  def restore(key, ttl, serialized_value)
+  def restore(key, ttl, serialized_value, options = {})
+    args = [:restore, key, ttl, serialized_value]
+    args << 'REPLACE' if options[:replace]
+
     synchronize do |client|
-      client.call([:restore, key, ttl, serialized_value])
+      client.call(args)
     end
   end
 
   # Transfer a key from the connected instance to another instance.
   #
-  # @param [String] key
+  # @param [String, Array<String>] key
   # @param [Hash] options
   #   - `:host => String`: host of instance to migrate to
   #   - `:port => Integer`: port of instance to migrate to
   #   - `:db => Integer`: database to migrate to (default: same as source)
   #   - `:timeout => Integer`: timeout (default: same as connection timeout)
+  #   - `:copy => Boolean`: Do not remove the key from the local instance.
+  #   - `:replace => Boolean`: Replace existing key on the remote instance.
   # @return [String] `"OK"`
   def migrate(key, options)
-    host = options[:host] || raise(RuntimeError, ":host not specified")
-    port = options[:port] || raise(RuntimeError, ":port not specified")
-    db = (options[:db] || client.db).to_i
-    timeout = (options[:timeout] || client.timeout).to_i
+    args = [:migrate]
+    args << (options[:host] || raise(':host not specified'))
+    args << (options[:port] || raise(':port not specified'))
+    args << (key.is_a?(String) ? key : '')
+    args << (options[:db] || @client.db).to_i
+    args << (options[:timeout] || @client.timeout).to_i
+    args << 'COPY' if options[:copy]
+    args << 'REPLACE' if options[:replace]
+    args += ['KEYS', *key] if key.is_a?(Array)
 
-    synchronize do |client|
-      client.call([:migrate, host, port, key, db, timeout])
-    end
+    synchronize { |client| client.call(args) }
   end
 
   # Delete one or more keys.
@@ -495,6 +532,16 @@ class Redis
     end
   end
 
+  # Unlink one or more keys.
+  #
+  # @param [String, Array<String>] keys
+  # @return [Fixnum] number of keys that were unlinked
+  def unlink(*keys)
+    synchronize do |client|
+      client.call([:unlink] + keys)
+    end
+  end
+
   # Determine if a key exists.
   #
   # @param [String] key
@@ -756,8 +803,6 @@ class Redis
     end
   end
 
-  alias :[]= :set
-
   # Set the time to live in seconds of a key.
   #
   # @param [String] key
@@ -863,8 +908,6 @@ class Redis
     end
   end
 
-  alias :[] :get
-
   # Get the values of all the given keys.
   #
   # @example
@@ -1041,7 +1084,7 @@ class Redis
   # Prepend one or more values to a list, creating the list if it doesn't exist
   #
   # @param [String] key
-  # @param [String, Array] value string value, or array of string values to push
+  # @param [String, Array<String>] value string value, or array of string values to push
   # @return [Fixnum] the length of the list after the push operation
   def lpush(key, value)
     synchronize do |client|
@@ -1063,7 +1106,7 @@ class Redis
   # Append one or more values to a list, creating the list if it doesn't exist
   #
   # @param [String] key
-  # @param [String] value
+  # @param [String, Array<String>] value string value, or array of string values to push
   # @return [Fixnum] the length of the list after the push operation
   def rpush(key, value)
     synchronize do |client|
@@ -1113,15 +1156,14 @@ class Redis
     end
   end
 
-  def _bpop(cmd, args)
+  def _bpop(cmd, args, &blk)
     options = {}
 
-    case args.last
-    when Hash
+    if args.last.is_a?(Hash)
       options = args.pop
-    when Integer
+    elsif args.last.respond_to?(:to_int)
       # Issue deprecation notice in obnoxious mode...
-      options[:timeout] = args.pop
+      options[:timeout] = args.pop.to_int
     end
 
     if args.size > 1
@@ -1134,7 +1176,7 @@ class Redis
     synchronize do |client|
       command = [cmd, keys, timeout]
       timeout += client.timeout if timeout > 0
-      client.call_with_timeout(command, timeout)
+      client.call_with_timeout(command, timeout, &blk)
     end
   end
 
@@ -1585,6 +1627,90 @@ class Redis
     end
   end
 
+  # Removes and returns up to count members with the highest scores in the sorted set stored at key.
+  #
+  # @example Popping a member
+  #   redis.zpopmax('zset')
+  #   #=> ['b', 2.0]
+  # @example With count option
+  #   redis.zpopmax('zset', 2)
+  #   #=> [['b', 2.0], ['a', 1.0]]
+  #
+  # @params key [String] a key of the sorted set
+  # @params count [Integer] a number of members
+  #
+  # @return [Array<String, Float>] element and score pair if count is not specified
+  # @return [Array<Array<String, Float>>] list of popped elements and scores
+  def zpopmax(key, count = nil)
+    synchronize do |client|
+      members = client.call([:zpopmax, key, count].compact, &FloatifyPairs)
+      count.to_i > 1 ? members : members.first
+    end
+  end
+
+  # Removes and returns up to count members with the lowest scores in the sorted set stored at key.
+  #
+  # @example Popping a member
+  #   redis.zpopmin('zset')
+  #   #=> ['a', 1.0]
+  # @example With count option
+  #   redis.zpopmin('zset', 2)
+  #   #=> [['a', 1.0], ['b', 2.0]]
+  #
+  # @params key [String] a key of the sorted set
+  # @params count [Integer] a number of members
+  #
+  # @return [Array<String, Float>] element and score pair if count is not specified
+  # @return [Array<Array<String, Float>>] list of popped elements and scores
+  def zpopmin(key, count = nil)
+    synchronize do |client|
+      members = client.call([:zpopmin, key, count].compact, &FloatifyPairs)
+      count.to_i > 1 ? members : members.first
+    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.
+  #
+  # @example Popping a member from a sorted set
+  #   redis.bzpopmax('zset', 1)
+  #   #=> ['zset', 'b', 2.0]
+  # @example Popping a member from multiple sorted sets
+  #   redis.bzpopmax('zset1', 'zset2', 1)
+  #   #=> ['zset1', 'b', 2.0]
+  #
+  # @params keys [Array<String>] one or multiple keys of the sorted sets
+  # @params timeout [Integer] the maximum number of seconds to block
+  #
+  # @return [Array<String, String, Float>] a touple of key, member and score
+  # @return [nil] when no element could be popped and the timeout expired
+  def bzpopmax(*args)
+    _bpop(:bzpopmax, args) do |reply|
+      reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
+    end
+  end
+
+  # Removes and returns up to count members with the lowest scores in the sorted set stored at keys,
+  #   or block until one is available.
+  #
+  # @example Popping a member from a sorted set
+  #   redis.bzpopmin('zset', 1)
+  #   #=> ['zset', 'a', 1.0]
+  # @example Popping a member from multiple sorted sets
+  #   redis.bzpopmin('zset1', 'zset2', 1)
+  #   #=> ['zset1', 'a', 1.0]
+  #
+  # @params keys [Array<String>] one or multiple keys of the sorted sets
+  # @params timeout [Integer] the maximum number of seconds to block
+  #
+  # @return [Array<String, String, Float>] a touple of key, member and score
+  # @return [nil] when no element could be popped and the timeout expired
+  def bzpopmin(*args)
+    _bpop(:bzpopmin, args) do |reply|
+      reply.is_a?(Array) ? [reply[0], reply[1], Floatify.call(reply[2])] : reply
+    end
+  end
+
   # Get the score associated with the given member in a sorted set.
   #
   # @example Get the score for member "a"
@@ -1701,6 +1827,30 @@ class Redis
     end
   end
 
+  # Count the members, with the same score in a sorted set, within the given lexicographical range.
+  #
+  # @example Count members matching a
+  #   redis.zlexcount("zset", "[a", "[a\xff")
+  #     # => 1
+  # @example Count members matching a-z
+  #   redis.zlexcount("zset", "[a", "[z\xff")
+  #     # => 26
+  #
+  # @param [String] key
+  # @param [String] min
+  #   - inclusive minimum is specified by prefixing `(`
+  #   - exclusive minimum is specified by prefixing `[`
+  # @param [String] max
+  #   - inclusive maximum is specified by prefixing `(`
+  #   - exclusive maximum is specified by prefixing `[`
+  #
+  # @return [Fixnum] number of members within the specified lexicographical range
+  def zlexcount(key, min, max)
+    synchronize do |client|
+      client.call([:zlexcount, key, min, max])
+    end
+  end
+
   # Return a range of members with the same score in a sorted set, by lexicographical ordering
   #
   # @example Retrieve members matching a
@@ -2053,9 +2203,9 @@ class Redis
   # @param [String] key
   # @param [String, Array<String>] field
   # @return [Fixnum] the number of fields that were removed from the hash
-  def hdel(key, field)
+  def hdel(key, *fields)
     synchronize do |client|
-      client.call([:hdel, key, field])
+      client.call([:hdel, key, *fields])
     end
   end
 
@@ -2661,6 +2811,425 @@ class Redis
     end
   end
 
+  # Adds the specified geospatial items (latitude, longitude, name) to the specified key
+  #
+  # @param [String] key
+  # @param [Array] member arguemnts for member or members: longitude, latitude, name
+  # @return [Intger] number of elements added to the sorted set
+  def geoadd(key, *member)
+    synchronize do |client|
+      client.call([:geoadd, key, member])
+    end
+  end
+
+  # Returns geohash string representing position for specified members of the specified key.
+  #
+  # @param [String] key
+  # @param [String, Array<String>] member one member or array of members
+  # @return [Array<String, nil>] returns array containg geohash string if member is present, nil otherwise
+  def geohash(key, member)
+    synchronize do |client|
+      client.call([:geohash, key, member])
+    end
+  end
+
+
+  # Query a sorted set representing a geospatial index to fetch members matching a
+  # given maximum distance from a point
+  #
+  # @param [Array] args key, longitude, latitude, radius, unit(m|km|ft|mi)
+  # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest to the nearest relative to the center
+  # @param [Integer] count limit the results to the first N matching items
+  # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
+  # @return [Array<String>] may be changed with `options`
+
+  def georadius(*args, **geoptions)
+    geoarguments = _geoarguments(*args, **geoptions)
+
+    synchronize do |client|
+      client.call([:georadius, *geoarguments])
+    end
+  end
+
+  # Query a sorted set representing a geospatial index to fetch members matching a
+  # given maximum distance from an already existing member
+  #
+  # @param [Array] args key, member, radius, unit(m|km|ft|mi)
+  # @param ['asc', 'desc'] sort sort returned items from the nearest to the farthest or the farthest to the nearest relative to the center
+  # @param [Integer] count limit the results to the first N matching items
+  # @param ['WITHDIST', 'WITHCOORD', 'WITHHASH'] options to return additional information
+  # @return [Array<String>] may be changed with `options`
+
+  def georadiusbymember(*args, **geoptions)
+    geoarguments = _geoarguments(*args, **geoptions)
+
+    synchronize do |client|
+      client.call([:georadiusbymember, *geoarguments])
+    end
+  end
+
+  # Returns longitude and latitude of members of a geospatial index
+  #
+  # @param [String] key
+  # @param [String, Array<String>] member one member or array of members
+  # @return [Array<Array<String>, nil>] returns array of elements, where each element is either array of longitude and latitude or nil
+  def geopos(key, member)
+    synchronize do |client|
+      client.call([:geopos, key, member])
+    end
+  end
+
+  # Returns the distance between two members of a geospatial index
+  #
+  # @param [String ]key
+  # @param [Array<String>] members
+  # @param ['m', 'km', 'mi', 'ft'] unit
+  # @return [String, nil] returns distance in spefied unit if both members present, nil otherwise.
+  def geodist(key, member1, member2, unit = 'm')
+    synchronize do |client|
+      client.call([:geodist, key, member1, member2, unit])
+    end
+  end
+
+  # Returns the stream information each subcommand.
+  #
+  # @example stream
+  #   redis.xinfo(:stream, 'mystream')
+  # @example groups
+  #   redis.xinfo(:groups, 'mystream')
+  # @example consumers
+  #   redis.xinfo(:consumers, 'mystream', 'mygroup')
+  #
+  # @param subcommand [String] e.g. `stream` `groups` `consumers`
+  # @param key        [String] the stream key
+  # @param group      [String] the consumer group name, required if subcommand is `consumers`
+  #
+  # @return [Hash]        information of the stream if subcommand is `stream`
+  # @return [Array<Hash>] information of the consumer groups if subcommand is `groups`
+  # @return [Array<Hash>] information of the consumers if subcommand is `consumers`
+  def xinfo(subcommand, key, group = nil)
+    args = [:xinfo, subcommand, key, group].compact
+    synchronize do |client|
+      client.call(args) do |reply|
+        case subcommand.to_s.downcase
+        when 'stream'              then Hashify.call(reply)
+        when 'groups', 'consumers' then reply.map { |arr| Hashify.call(arr) }
+        else reply
+        end
+      end
+    end
+  end
+
+  # Add new entry to the stream.
+  #
+  # @example Without options
+  #   redis.xadd('mystream', f1: 'v1', f2: 'v2')
+  # @example With options
+  #   redis.xadd('mystream', { f1: 'v1', f2: 'v2' }, id: '0-0', maxlen: 1000, approximate: true)
+  #
+  # @param key   [String] the stream key
+  # @param entry [Hash]   one or multiple field-value pairs
+  # @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
+  #
+  # @return [String] the entry id
+  def xadd(key, entry, opts = {})
+    args = [:xadd, key]
+    args.concat(['MAXLEN', (opts[:approximate] ? '~' : nil), opts[:maxlen]].compact) if opts[:maxlen]
+    args << (opts[:id] || '*')
+    args.concat(entry.to_a.flatten)
+    synchronize { |client| client.call(args) }
+  end
+
+  # Trims older entries of the stream if needed.
+  #
+  # @example Without options
+  #   redis.xtrim('mystream', 1000)
+  # @example With options
+  #   redis.xtrim('mystream', 1000, approximate: true)
+  #
+  # @param key         [String]  the stream key
+  # @param mexlen      [Integer] max length of entries
+  # @param approximate [Boolean] whether to add `~` modifier of maxlen or not
+  #
+  # @return [Integer] the number of entries actually deleted
+  def xtrim(key, maxlen, approximate: false)
+    args = [:xtrim, key, 'MAXLEN', (approximate ? '~' : nil), maxlen].compact
+    synchronize { |client| client.call(args) }
+  end
+
+  # Delete entries by entry ids.
+  #
+  # @example With splatted entry ids
+  #   redis.xdel('mystream', '0-1', '0-2')
+  # @example With arrayed entry ids
+  #   redis.xdel('mystream', ['0-1', '0-2'])
+  #
+  # @param key [String]        the stream key
+  # @param ids [Array<String>] one or multiple entry ids
+  #
+  # @return [Integer] the number of entries actually deleted
+  def xdel(key, *ids)
+    args = [:xdel, key].concat(ids.flatten)
+    synchronize { |client| client.call(args) }
+  end
+
+  # Fetches entries of the stream.
+  #
+  # @example Without options
+  #   redis.xrange('mystream')
+  # @example With first entry id option
+  #   redis.xrange('mystream', first: '0-1')
+  # @example With first and last entry id options
+  #   redis.xrange('mystream', first: '0-1', last: '0-3')
+  # @example With count options
+  #   redis.xrange('mystream', count: 10)
+  #
+  # @param key   [String]  the stream key
+  # @param start  [String]  first entry id of range, default value is `+`
+  # @param end [String]  last entry id of range, default value is `-`
+  # @param count [Integer] the number of entries as limit
+  #
+  # @return [Hash{String => Hash}] the entries
+
+  # Fetches entries of the stream in ascending order.
+  #
+  # @example Without options
+  #   redis.xrange('mystream')
+  # @example With a specific start
+  #   redis.xrange('mystream', '0-1')
+  # @example With a specific start and end
+  #   redis.xrange('mystream', '0-1', '0-3')
+  # @example With count options
+  #   redis.xrange('mystream', count: 10)
+  #
+  # @param key [String]  the stream key
+  # @param start [String]  first entry id of range, default value is `-`
+  # @param end [String]  last entry id of range, default value is `+`
+  # @param count [Integer] the number of entries as limit
+  #
+  # @return [Array<Array<String, Hash>>] the ids and entries pairs
+  def xrange(key, start = '-', _end = '+', count: nil)
+    args = [:xrange, key, start, _end]
+    args.concat(['COUNT', count]) if count
+    synchronize { |client| client.call(args, &HashifyStreamEntries) }
+  end
+
+  # Fetches entries of the stream in descending order.
+  #
+  # @example Without options
+  #   redis.xrevrange('mystream')
+  # @example With a specific end
+  #   redis.xrevrange('mystream', '0-3')
+  # @example With a specific end and start
+  #   redis.xrevrange('mystream', '0-3', '0-1')
+  # @example With count options
+  #   redis.xrevrange('mystream', count: 10)
+  #
+  # @param key [String]  the stream key
+  # @param end [String]  first entry id of range, default value is `+`
+  # @param start [String]  last entry id of range, default value is `-`
+  # @params count [Integer] the number of entries as limit
+  #
+  # @return [Array<Array<String, Hash>>] the ids and entries pairs
+  def xrevrange(key, _end = '+', start = '-', count: nil)
+    args = [:xrevrange, key, _end, start]
+    args.concat(['COUNT', count]) if count
+    synchronize { |client| client.call(args, &HashifyStreamEntries) }
+  end
+
+  # Returns the number of entries inside a stream.
+  #
+  # @example With key
+  #   redis.xlen('mystream')
+  #
+  # @param key [String] the stream key
+  #
+  # @return [Integer] the number of entries
+  def xlen(key)
+    synchronize { |client| client.call([:xlen, key]) }
+  end
+
+  # Fetches entries from one or multiple streams. Optionally blocking.
+  #
+  # @example With a key
+  #   redis.xread('mystream', '0-0')
+  # @example With multiple keys
+  #   redis.xread(%w[mystream1 mystream2], %w[0-0 0-0])
+  # @example With count option
+  #   redis.xread('mystream', '0-0', count: 2)
+  # @example With block option
+  #   redis.xread('mystream', '$', block: 1000)
+  #
+  # @param keys  [Array<String>] one or multiple stream keys
+  # @param ids   [Array<String>] one or multiple entry ids
+  # @param count [Integer]       the number of entries as limit per stream
+  # @param block [Integer]       the number of milliseconds as blocking timeout
+  #
+  # @return [Hash{String => Hash{String => Hash}}] the entries
+  def xread(keys, ids, count: nil, block: nil)
+    args = [:xread]
+    args << 'COUNT' << count if count
+    args << 'BLOCK' << block.to_i if block
+    _xread(args, keys, ids, block)
+  end
+
+  # Manages the consumer group of the stream.
+  #
+  # @example With `create` subcommand
+  #   redis.xgroup(:create, 'mystream', 'mygroup', '$')
+  # @example With `setid` subcommand
+  #   redis.xgroup(:setid, 'mystream', 'mygroup', '$')
+  # @example With `destroy` subcommand
+  #   redis.xgroup(:destroy, 'mystream', 'mygroup')
+  # @example With `delconsumer` subcommand
+  #   redis.xgroup(:delconsumer, 'mystream', 'mygroup', 'consumer1')
+  #
+  # @param subcommand     [String] `create` `setid` `destroy` `delconsumer`
+  # @param key            [String] the stream key
+  # @param group          [String] the consumer group name
+  # @param id_or_consumer [String]
+  #   * the entry id or `$`, required if subcommand is `create` or `setid`
+  #   * the consumer name, required if subcommand is `delconsumer`
+  # @param mkstream [Boolean] whether to create an empty stream automatically or not
+  #
+  # @return [String] `OK` if subcommand is `create` or `setid`
+  # @return [Integer] effected count if subcommand is `destroy` or `delconsumer`
+  def xgroup(subcommand, key, group, id_or_consumer = nil, mkstream: false)
+    args = [:xgroup, subcommand, key, group, id_or_consumer, (mkstream ? 'MKSTREAM' : nil)].compact
+    synchronize { |client| client.call(args) }
+  end
+
+  # Fetches a subset of the entries from one or multiple streams related with the consumer group.
+  # Optionally blocking.
+  #
+  # @example With a key
+  #   redis.xreadgroup('mygroup', 'consumer1', 'mystream', '>')
+  # @example With multiple keys
+  #   redis.xreadgroup('mygroup', 'consumer1', %w[mystream1 mystream2], %w[> >])
+  # @example With count option
+  #   redis.xreadgroup('mygroup', 'consumer1', 'mystream', '>', count: 2)
+  # @example With block option
+  #   redis.xreadgroup('mygroup', 'consumer1', 'mystream', '>', block: 1000)
+  # @example With noack option
+  #   redis.xreadgroup('mygroup', 'consumer1', 'mystream', '>', noack: true)
+  #
+  # @param group    [String]        the consumer group name
+  # @param consumer [String]        the consumer name
+  # @param keys     [Array<String>] one or multiple stream keys
+  # @param ids      [Array<String>] one or multiple entry ids
+  # @param opts     [Hash]          several options for `XREADGROUP` command
+  #
+  # @option opts [Integer] :count the number of entries as limit
+  # @option opts [Integer] :block the number of milliseconds as blocking timeout
+  # @option opts [Boolean] :noack whether message loss is acceptable or not
+  #
+  # @return [Hash{String => Hash{String => Hash}}] the entries
+  def xreadgroup(group, consumer, keys, ids, opts = {})
+    args = [:xreadgroup, 'GROUP', group, consumer]
+    args << 'COUNT' << opts[:count] if opts[:count]
+    args << 'BLOCK' << opts[:block].to_i if opts[:block]
+    args << 'NOACK' if opts[:noack]
+    _xread(args, keys, ids, opts[:block])
+  end
+
+  # Removes one or multiple entries from the pending entries list of a stream consumer group.
+  #
+  # @example With a entry id
+  #   redis.xack('mystream', 'mygroup', '1526569495631-0')
+  # @example With splatted entry ids
+  #   redis.xack('mystream', 'mygroup', '0-1', '0-2')
+  # @example With arrayed entry ids
+  #   redis.xack('mystream', 'mygroup', %w[0-1 0-2])
+  #
+  # @param key   [String]        the stream key
+  # @param group [String]        the consumer group name
+  # @param ids   [Array<String>] one or multiple entry ids
+  #
+  # @return [Integer] the number of entries successfully acknowledged
+  def xack(key, group, *ids)
+    args = [:xack, key, group].concat(ids.flatten)
+    synchronize { |client| client.call(args) }
+  end
+
+  # Changes the ownership of a pending entry
+  #
+  # @example With splatted entry ids
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, '0-1', '0-2')
+  # @example With arrayed entry ids
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2])
+  # @example With idle option
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], idle: 1000)
+  # @example With time option
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], time: 1542866959000)
+  # @example With retrycount option
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], retrycount: 10)
+  # @example With force option
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], force: true)
+  # @example With justid option
+  #   redis.xclaim('mystream', 'mygroup', 'consumer1', 3600000, %w[0-1 0-2], justid: true)
+  #
+  # @param key           [String]        the stream key
+  # @param group         [String]        the consumer group name
+  # @param consumer      [String]        the consumer name
+  # @param min_idle_time [Integer]       the number of milliseconds
+  # @param ids           [Array<String>] one or multiple entry ids
+  # @param opts          [Hash]          several options for `XCLAIM` command
+  #
+  # @option opts [Integer] :idle       the number of milliseconds as last time it was delivered of the entry
+  # @option opts [Integer] :time       the number of milliseconds as a specific Unix Epoch time
+  # @option opts [Integer] :retrycount the number of retry counter
+  # @option opts [Boolean] :force      whether to create the pending entry to the pending entries list or not
+  # @option opts [Boolean] :justid     whether to fetch just an array of entry ids or not
+  #
+  # @return [Hash{String => Hash}] the entries successfully claimed
+  # @return [Array<String>]        the entry ids successfully claimed if justid option is `true`
+  def xclaim(key, group, consumer, min_idle_time, *ids, **opts)
+    args = [:xclaim, key, group, consumer, min_idle_time].concat(ids.flatten)
+    args.concat(['IDLE',       opts[:idle].to_i])  if opts[:idle]
+    args.concat(['TIME',       opts[:time].to_i])  if opts[:time]
+    args.concat(['RETRYCOUNT', opts[:retrycount]]) if opts[:retrycount]
+    args << 'FORCE'                                if opts[:force]
+    args << 'JUSTID'                               if opts[:justid]
+    blk = opts[:justid] ? Noop : HashifyStreamEntries
+    synchronize { |client| client.call(args, &blk) }
+  end
+
+  # Fetches not acknowledging pending entries
+  #
+  # @example With key and group
+  #   redis.xpending('mystream', 'mygroup')
+  # @example With range options
+  #   redis.xpending('mystream', 'mygroup', '-', '+', 10)
+  # @example With range and consumer options
+  #   redis.xpending('mystream', 'mygroup', '-', '+', 10, 'consumer1')
+  #
+  # @param key      [String]  the stream key
+  # @param group    [String]  the consumer group name
+  # @param start    [String]  start first entry id of range
+  # @param end      [String]  end   last entry id of range
+  # @param count    [Integer] count the number of entries as limit
+  # @param consumer [String]  the consumer name
+  #
+  # @return [Hash]        the summary of pending entries
+  # @return [Array<Hash>] the pending entries details if options were specified
+  def xpending(key, group, *args)
+    command_args = [:xpending, key, group]
+    case args.size
+    when 0, 3, 4
+      command_args.concat(args)
+    else
+      raise ArgumentError, "wrong number of arguments (given #{args.size + 2}, expected 2, 5 or 6)"
+    end
+
+    summary_needed = args.empty?
+    blk = summary_needed ? HashifyStreamPendings : HashifyStreamPendingDetails
+    synchronize { |client| client.call(command_args, &blk) }
+  end
+
   # Interact with the sentinel command (masters, master, slaves, failover)
   #
   # @param [String] subcommand e.g. `masters`, `master`, `slaves`
@@ -2688,6 +3257,41 @@ class Redis
     end
   end
 
+  # Sends `CLUSTER *` command to random node and returns its reply.
+  #
+  # @see https://redis.io/commands#cluster Reference of cluster command
+  #
+  # @param subcommand [String, Symbol] the subcommand of cluster command
+  #   e.g. `:slots`, `:nodes`, `:slaves`, `:info`
+  #
+  # @return [Object] depends on the subcommand
+  def cluster(subcommand, *args)
+    subcommand = subcommand.to_s.downcase
+    block = case subcommand
+            when 'slots'  then HashifyClusterSlots
+            when 'nodes'  then HashifyClusterNodes
+            when 'slaves' then HashifyClusterSlaves
+            when 'info'   then HashifyInfo
+            else Noop
+            end
+
+    # @see https://github.com/antirez/redis/blob/unstable/src/redis-trib.rb#L127 raw reply expected
+    block = Noop unless @cluster_mode
+
+    synchronize do |client|
+      client.call([:cluster, subcommand] + args, &block)
+    end
+  end
+
+  # Sends `ASKING` command to random node and returns its reply.
+  #
+  # @see https://redis.io/topics/cluster-spec#ask-redirection ASK redirection
+  #
+  # @return [String] `'OK'`
+  def asking
+    synchronize { |client| client.call(%i[asking]) }
+  end
+
   def id
     @original_client.id
   end
@@ -2701,12 +3305,14 @@ class Redis
   end
 
   def connection
+    return @original_client.connection_info if @cluster_mode
+
     {
-      :host     => @original_client.host,
-      :port     => @original_client.port,
-      :db       => @original_client.db,
-      :id       => @original_client.id,
-      :location => @original_client.location
+      host:     @original_client.host,
+      port:     @original_client.port,
+      db:       @original_client.db,
+      id:       @original_client.id,
+      location: @original_client.location
     }
   end
 
@@ -2756,14 +3362,107 @@ private
     }
 
   FloatifyPairs =
-    lambda { |array|
-      if array
-        array.each_slice(2).map do |member, score|
-          [member, Floatify.call(score)]
-        end
+    lambda { |result|
+      result.each_slice(2).map do |member, score|
+        [member, Floatify.call(score)]
+      end
+    }
+
+  HashifyInfo =
+    lambda { |reply|
+      Hash[reply.split("\r\n").map do |line|
+        line.split(':', 2) unless line =~ /^(#|$)/
+      end.compact]
+    }
+
+  HashifyStreams =
+    lambda { |reply|
+      return {} if reply.nil?
+      reply.map do |stream_key, entries|
+        [stream_key, HashifyStreamEntries.call(entries)]
+      end.to_h
+    }
+
+  HashifyStreamEntries =
+    lambda { |reply|
+      reply.map do |entry_id, values|
+        [entry_id, values.each_slice(2).to_h]
       end
     }
 
+  HashifyStreamPendings =
+    lambda { |reply|
+      {
+        'size'         => reply[0],
+        'min_entry_id' => reply[1],
+        'max_entry_id' => reply[2],
+        'consumers'    => reply[3].nil? ? {} : Hash[reply[3]]
+      }
+    }
+
+  HashifyStreamPendingDetails =
+    lambda { |reply|
+      reply.map do |arr|
+        {
+          'entry_id' => arr[0],
+          'consumer' => arr[1],
+          'elapsed'  => arr[2],
+          'count'    => arr[3]
+        }
+      end
+    }
+
+  HashifyClusterNodeInfo =
+    lambda { |str|
+      arr = str.split(' ')
+      {
+        'node_id'        => arr[0],
+        'ip_port'        => arr[1],
+        'flags'          => arr[2].split(','),
+        'master_node_id' => arr[3],
+        'ping_sent'      => arr[4],
+        'pong_recv'      => arr[5],
+        'config_epoch'   => arr[6],
+        'link_state'     => arr[7],
+        'slots'          => arr[8].nil? ? nil : Range.new(*arr[8].split('-'))
+      }
+    }
+
+  HashifyClusterSlots =
+    lambda { |reply|
+      reply.map do |arr|
+        first_slot, last_slot = arr[0..1]
+        master = { 'ip' => arr[2][0], 'port' => arr[2][1], 'node_id' => arr[2][2] }
+        replicas = arr[3..-1].map { |r| { 'ip' => r[0], 'port' => r[1], 'node_id' => r[2] } }
+        {
+          'start_slot' => first_slot,
+          'end_slot'   => last_slot,
+          'master'     => master,
+          'replicas'   => replicas
+        }
+      end
+    }
+
+  HashifyClusterNodes =
+    lambda { |reply|
+      reply.split(/[\r\n]+/).map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+  HashifyClusterSlaves =
+    lambda { |reply|
+      reply.map { |str| HashifyClusterNodeInfo.call(str) }
+    }
+
+  Noop = ->(reply) { reply }
+
+  def _geoarguments(*args, options: nil, sort: nil, count: nil)
+    args.push sort if sort
+    args.push 'count', count if count
+    args.push options if options
+
+    args.uniq
+  end
+
   def _subscription(method, timeout, channels, block)
     return @client.call([method] + channels) if subscribed?
 
@@ -2779,10 +3478,27 @@ private
     end
   end
 
+  def _xread(args, keys, ids, blocking_timeout_msec)
+    keys = keys.is_a?(Array) ? keys : [keys]
+    ids = ids.is_a?(Array) ? ids : [ids]
+    args << 'STREAMS'
+    args.concat(keys)
+    args.concat(ids)
+
+    synchronize do |client|
+      if blocking_timeout_msec.nil?
+        client.call(args, &HashifyStreams)
+      else
+        timeout = client.timeout.to_f + blocking_timeout_msec.to_f / 1000.0
+        client.call_with_timeout(args, timeout, &HashifyStreams)
+      end
+    end
+  end
 end
 
-require "redis/version"
-require "redis/connection"
-require "redis/client"
-require "redis/pipeline"
-require "redis/subscribe"
+require_relative "redis/version"
+require_relative "redis/connection"
+require_relative "redis/client"
+require_relative "redis/cluster"
+require_relative "redis/pipeline"
+require_relative "redis/subscribe"