Data

Tools

Indexes

Applications

Experiments

Ruby

A summary of data about the Ruby ecosystem.

https://github.com/redis/redis-rb

A Ruby client library for Redis
https://github.com/redis/redis-rb

Keywords from Contributors

activerecord mvc activejob rubygems rack background-jobs sinatra sidekiq rspec jobs

Last synced: about 11 hours ago
JSON representation

Repository metadata

A Ruby client library for Redis

README.md

redis-rb Build Status Inline docs

A Ruby client that tries to match Redis' API one-to-one, while still providing an idiomatic interface.

See RubyDoc.info for the API docs of the latest published gem.

Getting started

Install with:

$ gem install redis

You can connect to Redis by instantiating the Redis class:

require "redis"

redis = Redis.new

This assumes Redis was started with a default configuration, and is
listening on localhost, port 6379. If you need to connect to a remote
server or a different port, try:

redis = Redis.new(host: "10.0.1.1", port: 6380, db: 15)

You can also specify connection options as a redis:// URL:

redis = Redis.new(url: "redis://:p4ssw0rd@10.0.1.1:6380/15")

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:

redis = Redis.new(path: "/tmp/redis.sock")

To connect to a password protected Redis instance, use:

redis = Redis.new(password: "mysecret")

To connect a Redis instance using ACL, use:

redis = Redis.new(username: 'myname', password: 'mysecret')

The Redis class exports methods that are named identical to the commands
they execute. The arguments these methods accept are often identical to
the arguments specified on the Redis website. For
instance, the SET and GET commands can be called like this:

redis.set("mykey", "hello world")
# => "OK"

redis.get("mykey")
# => "hello world"

All commands, their arguments, and return values are documented and
available on RubyDoc.info.

Connection Pooling and Thread safety

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 heavily recommended to use the connection_pool gem, e.g.:

module MyApp
  def self.redis
    @redis ||= ConnectionPool::Wrapper.new do
      Redis.new(url: ENV["REDIS_URL"])
    end
  end
end

MyApp.redis.incr("some-counter")

Sentinel support

The client is able to perform automatic failover by using Redis
Sentinel. Make sure to run Redis 2.8+
if you want to use this feature.

To connect using Sentinel, use:

SENTINELS = [{ host: "127.0.0.1", port: 26380 },
             { host: "127.0.0.1", port: 26381 }]

redis = Redis.new(name: "mymaster", sentinels: SENTINELS, role: :master)

  • The master name identifies a group of Redis instances composed of a master
    and one or more slaves (mymaster in the example).

  • It is possible to optionally provide a role. The allowed roles are master
    and slave. When the role is slave, the client will try to connect to a
    random slave of the specified master. If a role is not specified, the client
    will connect to the master.

  • When using Sentinel support, you need to specify a list of sentinels to
    connect to. The list does not need to enumerate all your Sentinel instances,
    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 request.

To authenticate with Sentinel itself, you can specify the sentinel_username and sentinel_password. Exclude the sentinel_username option if you're using password-only authentication.

SENTINELS = [{ host: '127.0.0.1', port: 26380},
             { host: '127.0.0.1', port: 26381}]

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 use those credentials.

# 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 credentials and Redis explicitly even if they are the same.

# 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 the Redis instance can be passed as a URL:

redis = Redis.new(url: "redis://appuser:mysecret@mymaster/10", sentinels: SENTINELS, role: :master)

Cluster support

Clustering. is supported via the redis-clustering gem.

Pipelining

When multiple commands are executed sequentially, but are not dependent,
the calls can be pipelined. This means that the client doesn't wait
for reply of the first command before sending the next command. The
advantage is that multiple commands are sent at once, resulting in
faster overall execution.

The client can be instructed to pipeline commands by using the
#pipelined method. After the block is executed, the client sends all
commands to Redis and gathers their replies. These replies are returned
by the #pipelined method.

redis.pipelined do |pipeline|
  pipeline.set "foo", "bar"
  pipeline.incr "baz"
end
# => ["OK", 1]

Commands must be called on the yielded objects. If you call methods
on the original client objects from inside a pipeline, they will be sent immediately:

redis.pipelined do |pipeline|
  pipeline.set "foo", "bar"
  redis.incr "baz" # => 1
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)

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
fashion. This is similar to executing a pipeline, but the commands are
preceded by a call to MULTI, and followed by a call to EXEC. Like
the regular pipeline, the replies to the commands are returned by the
#multi method.

redis.multi do |transaction|
  transaction.set "foo", "bar"
  transaction.incr "baz"
end
# => ["OK", 1]

Futures

Replies to commands in a pipeline can be accessed via the futures they
emit. All calls on the pipeline object return a
Future object, which responds to the #value method. When the
pipeline has successfully executed, all futures are assigned their
respective replies and can be used.

set = incr = nil
redis.pipelined do |pipeline|
  set = pipeline.set "foo", "bar"
  incr = pipeline.incr "baz"
end

set.value
# => "OK"

incr.value
# => 1

Error Handling

In general, if something goes wrong you'll get an exception. For example, if
it can't connect to the server a Redis::CannotConnectError error will be raised.

begin
  redis.ping
rescue Redis::BaseError => e
  e.inspect
# => #<Redis::CannotConnectError: Timed out connecting to Redis on 10.0.1.1:6380>

  e.message
# => Timed out connecting to Redis on 10.0.1.1:6380
end

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:

Redis.new(:timeout => 1)

But you can use specific values for each of them:

Redis.new(
  :connect_timeout => 0.2,
  :read_timeout    => 1.0,
  :write_timeout   => 0.5
)

All timeout values are specified in seconds.

When using pub/sub, you can subscribe to a channel using a timeout as well:

redis = Redis.new(reconnect_attempts: 0)
redis.subscribe_with_timeout(5, "news") do |on|
  on.message do |channel, message|
    # ...
  end
end

If no message is received after 5 seconds, the client will unsubscribe.

Reconnections

By default, this gem will only retry a connection once and then fail, but
the client allows you to configure how many reconnect_attempts it should
complete before declaring a connection as failed.

Redis.new(reconnect_attempts: 0)
Redis.new(reconnect_attempts: 3)

If you wish to wait between reconnection attempts, you can instead pass a list
of durations:

Redis.new(reconnect_attempts: [
  0, # retry immediately
  0.25, # retry a second time after 250ms
  1, # retry a third and final time after another 1s
])

If you wish to disable reconnection only for some commands, you can use
disable_reconnection:

redis.get("some-key") # this may be retried
redis.disable_reconnection do
  redis.incr("some-counter") # this won't be retried.
end

SSL/TLS Support

To enable SSL support, pass the :ssl => true option when configuring the
Redis client, or pass in :url => "rediss://..." (like HTTPS for Redis).
You will also need to pass in an :ssl_params => { ... } hash used to
configure the OpenSSL::SSL::SSLContext object used for the connection:

redis = Redis.new(
  :url        => "rediss://:p4ssw0rd@10.0.1.1:6381/15",
  :ssl_params => {
    :ca_file => "/path/to/ca.crt"
  }
)

The options given to :ssl_params are passed directly to the
OpenSSL::SSL::SSLContext#set_params method and can be any valid attribute
of the SSL context. Please see the OpenSSL::SSL::SSLContext documentation
for all of the available attributes.

Here is an example of passing in params that can be used for SSL client
certificate authentication (a.k.a. mutual TLS):

redis = Redis.new(
  :url        => "rediss://:p4ssw0rd@10.0.1.1:6381/15",
  :ssl_params => {
    :ca_file => "/path/to/ca.crt",
    :cert    => OpenSSL::X509::Certificate.new(File.read("client.crt")),
    :key     => OpenSSL::PKey::RSA.new(File.read("client.key"))
  }
)

Expert-Mode Options

  • inherit_socket: true: disable safety check that prevents a forked child
    from sharing a socket with its parent; this is potentially useful in order to mitigate connection churn when:

    • many short-lived forked children of one process need to talk
      to redis, AND
    • your own code prevents the parent process from using the redis
      connection while a child is alive

    Improper use of inherit_socket will result in corrupted and/or incorrect
    responses.

hiredis binding

By default, redis-rb uses Ruby's socket library to talk with Redis.

The hiredis driver uses the connection facility of hiredis-rb. In turn,
hiredis-rb is a binding to the official hiredis client library. It
optimizes for speed, at the cost of portability. Because it is a C
extension, JRuby is not supported (by default).

It is best to use hiredis when you have large replies (for example:
LRANGE, SMEMBERS, ZRANGE, etc.) and/or use big pipelines.

In your Gemfile, include hiredis-client:

gem "redis"
gem "hiredis-client"

If your application doesn't call Bundler.require, you may have
to require it explicitly:

require "hiredis-client"

This makes the hiredis driver the default.

If you want to be certain hiredis is being used, when instantiating
the client object, specify hiredis:

redis = Redis.new(driver: :hiredis)

Testing

This library is tested against recent Ruby and Redis versions.
Check Github Actions for the exact versions supported.

See Also

Contributors

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 and send pull
requests.

Owner metadata

GitHub Events

Total
Last Year

Committers metadata

Last synced: 7 days ago

Total Commits: 1,772
Total Committers: 249
Avg Commits per committer: 7.116
Development Distribution Score (DDS): 0.771

Commits in past year: 26
Committers in past year: 12
Avg Commits per committer in past year: 2.167
Development Distribution Score (DDS) in past year: 0.5

Name Email Commits
Pieter Noordhuis p****s@g****m 405
Damian Janowski d****i@g****m 273
Jean Boussier j****r@g****m 205
Ezra Zygmuntowicz ez@e****m 82
Taishi Kasuga s****l@y****m 75
Michel Martens m****l@s****m 59
Jan-Erik Rediger j****k@f****e 40
Luca Guidi g****a@g****m 37
Damian Janowski & Michel Martens d****n@g****m 34
Taylor Weibley t****y@e****m 31
Brian McKinney b****n@r****m 29
fatkodima f****3@g****m 20
Ryan Biesemeyer r****n@s****m 18
Michel Martens & Damian Janowski m****i@s****m 18
antirez a****z@g****m 14
Chris Wanstrath c****s@o****g 10
Matt m****c@c****) 10
Ilya Grigorik i****a@i****m 9
Nikita Misharin m****n@g****m 8
Brian P O'Rourke b****n@o****o 8
Spencer Markowski s****r@t****m 8
bitterb b****7@g****m 8
Luca Guidi me@l****m 7
dependabot[bot] 4****] 7
Matías Flores f****s@g****m 6
Evan Phoenix e****n@f****t 6
A.S. Lomoff l****s@g****m 5
Devin Christensen q****n@g****m 5
Mike Perham m****m@g****m 5
Nick Quaranto n****k@q****o 5
and 219 more...

Committer domains:

Issue and Pull Request metadata

Last synced: 26 days ago

Total issues: 123
Total pull requests: 159
Average time to close issues: 10 months
Average time to close pull requests: 19 days
Total issue authors: 113
Total pull request authors: 60
Average comments per issue: 3.52
Average comments per pull request: 1.09
Merged pull request: 117
Bot issues: 0
Bot pull requests: 5

Past year issues: 5
Past year pull requests: 22
Past year average time to close issues: 1 day
Past year average time to close pull requests: 4 days
Past year issue authors: 4
Past year pull request authors: 12
Past year average comments per issue: 2.4
Past year average comments per pull request: 0.59
Past year merged pull request: 17
Past year bot issues: 0
Past year bot pull requests: 2

More stats: https://issues.ecosyste.ms/repositories/lookup?url=https://github.com/redis/redis-rb

Top Issue Authors

  • slai11 (3)
  • underwoo16 (2)
  • ajvondrak (2)
  • agrajgarg1526 (2)
  • roharon (2)
  • davkim (2)
  • runephilosof-karnovgroup (2)
  • Juanmcuello (2)
  • voxik (2)
  • SpencerMarcu (1)
  • craigmcnamara (1)
  • taf2 (1)
  • afilbert (1)
  • verajohne (1)
  • ndbroadbent (1)

Top Pull Request Authors

  • supercaracal (32)
  • casperisfine (19)
  • byroot (9)
  • KJTsanaktsidis (7)
  • dependabot[bot] (5)
  • wholien (4)
  • jasonpenny (4)
  • JerrodCarpenter (4)
  • bsbodden (3)
  • jdelStrother (3)
  • fatkodima (3)
  • wmontgomery-splunk (3)
  • OlegChuev (2)
  • philippeboyd (2)
  • jjb (2)

Top Issue Labels

  • major (2)

Top Pull Request Labels

  • major (5)
  • dependencies (5)
  • github_actions (2)
  • input-required (1)

Package metadata

gem.coop: redis

A Ruby client that tries to match Redis' API one-to-one, while still providing an idiomatic interface.

rubygems.org: redis

A Ruby client that tries to match Redis' API one-to-one, while still providing an idiomatic interface.

  • Homepage: https://github.com/redis/redis-rb
  • Documentation: http://www.rubydoc.info/gems/redis/
  • Licenses: MIT
  • Latest release: 5.4.1 (published 8 months ago)
  • Last Synced: 2026-02-25T19:01:42.384Z (6 days ago)
  • Versions: 99
  • Dependent Packages: 1,960
  • Dependent Repositories: 65,430
  • Downloads: 536,212,963 Total
  • Docker Downloads: 865,030,831
  • Rankings:
    • Dependent packages count: 0.027%
    • Downloads: 0.038%
    • Docker downloads count: 0.136%
    • Dependent repos count: 0.14%
    • Average: 0.184%
    • Stargazers count: 0.326%
    • Forks count: 0.435%
  • Maintainers (10)
gem.coop: redis-clustering

A Ruby client that tries to match Redis' Cluster API one-to-one, while still providing an idiomatic interface.

  • Homepage: https://github.com/redis/redis-rb/blob/master/cluster
  • Documentation: http://www.rubydoc.info/gems/redis-clustering/
  • Licenses: MIT
  • Latest release: 5.4.1 (published 8 months ago)
  • Last Synced: 2026-02-25T12:32:56.676Z (6 days ago)
  • Versions: 16
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Downloads: 16,880,948 Total
  • Docker Downloads: 3,266
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 0.753%
    • Downloads: 0.974%
    • Docker downloads count: 2.04%
  • Maintainers (1)
proxy.golang.org: github.com/redis/redis-rb

  • Homepage:
  • Documentation: https://pkg.go.dev/github.com/redis/redis-rb#section-documentation
  • Licenses: mit
  • Latest release: v5.4.1+incompatible (published 8 months ago)
  • Last Synced: 2026-02-23T07:50:23.658Z (8 days ago)
  • Versions: 85
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Forks count: 0.854%
    • Stargazers count: 1.062%
    • Average: 5.573%
    • Dependent packages count: 9.576%
    • Dependent repos count: 10.802%
rubygems.org: redis-clustering

A Ruby client that tries to match Redis' Cluster API one-to-one, while still providing an idiomatic interface.

  • Homepage: https://github.com/redis/redis-rb/blob/master/cluster
  • Documentation: http://www.rubydoc.info/gems/redis-clustering/
  • Licenses: MIT
  • Latest release: 5.4.1 (published 8 months ago)
  • Last Synced: 2026-02-23T07:50:21.811Z (8 days ago)
  • Versions: 16
  • Dependent Packages: 1
  • Dependent Repositories: 0
  • Downloads: 16,853,381 Total
  • Docker Downloads: 3,266
  • Rankings:
    • Stargazers count: 0.308%
    • Forks count: 0.409%
    • Dependent packages count: 7.713%
    • Average: 16.139%
    • Downloads: 25.487%
    • Dependent repos count: 46.779%
  • Maintainers (1)
gem.coop: redis2-namespaced

A Ruby client that tries to match Redis2' API one-to-one, while still providing an idiomatic interface. It features thread-safety, client-side sharding, pipelining, and an obsession for performance.

  • Homepage: https://github.com/redis/redis-rb
  • Documentation: http://www.rubydoc.info/gems/redis2-namespaced/
  • Licenses: MIT
  • Latest release: 3.0.7 (published over 11 years ago)
  • Last Synced: 2026-02-23T21:03:00.776Z (8 days ago)
  • Versions: 2
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Downloads: 6,300 Total
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 20.397%
    • Downloads: 61.191%
  • Maintainers (1)
rubygems.org: redis2-namespaced

A Ruby client that tries to match Redis2' API one-to-one, while still providing an idiomatic interface. It features thread-safety, client-side sharding, pipelining, and an obsession for performance.

  • Homepage: https://github.com/redis/redis-rb
  • Documentation: http://www.rubydoc.info/gems/redis2-namespaced/
  • Licenses: MIT
  • Latest release: 3.0.7 (published over 11 years ago)
  • Last Synced: 2026-02-23T07:50:22.175Z (8 days ago)
  • Versions: 2
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Downloads: 6,300 Total
  • Rankings:
    • Stargazers count: 0.273%
    • Forks count: 0.382%
    • Dependent packages count: 15.706%
    • Average: 25.099%
    • Dependent repos count: 46.782%
    • Downloads: 62.352%
  • Maintainers (1)
debian-10: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Documentation: https://packages.debian.org/buster/ruby-redis
  • Licenses:
  • Latest release: 3.3.5-1 (published 20 days ago)
  • Last Synced: 2026-02-13T04:25:06.999Z (18 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-24.10: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Licenses:
  • Latest release: 4.8.0-2 (published 22 days ago)
  • Last Synced: 2026-02-09T17:09:19.658Z (22 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
debian-11: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Documentation: https://packages.debian.org/bullseye/ruby-redis
  • Licenses:
  • Latest release: 4.2.5-1 (published 20 days ago)
  • Last Synced: 2026-02-13T08:24:16.803Z (18 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-20.04: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Licenses:
  • Latest release: 4.1.2-4 (published 18 days ago)
  • Last Synced: 2026-02-13T07:21:36.025Z (18 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
debian-12: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Documentation: https://packages.debian.org/bookworm/ruby-redis
  • Licenses:
  • Latest release: 4.8.0-1 (published 18 days ago)
  • Last Synced: 2026-02-12T23:39:23.908Z (18 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
ubuntu-22.04: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Licenses:
  • Latest release: 4.2.5-1 (published 18 days ago)
  • Last Synced: 2026-02-13T13:24:29.121Z (18 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-24.04: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Licenses:
  • Latest release: 4.8.0-2 (published 25 days ago)
  • Last Synced: 2026-02-06T15:56:23.745Z (25 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
ubuntu-23.04: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Licenses:
  • Latest release: 4.8.0-1 (published 20 days ago)
  • Last Synced: 2026-02-11T06:48:20.437Z (20 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
debian-13: ruby-redis-clustering

  • Homepage: https://github.com/redis/redis-rb/blob/master/cluster
  • Documentation: https://packages.debian.org/trixie/ruby-redis-clustering
  • Licenses:
  • Latest release: 5.3.0-1.1 (published 19 days ago)
  • Last Synced: 2026-02-13T13:19:03.254Z (18 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
debian-13: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Documentation: https://packages.debian.org/trixie/ruby-redis
  • Licenses:
  • Latest release: 5.3.0-1 (published 19 days ago)
  • Last Synced: 2026-02-13T13:19:02.484Z (18 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%
ubuntu-23.10: ruby-redis

  • Homepage: https://github.com/redis/redis-rb
  • Licenses:
  • Latest release: 4.8.0-1 (published 18 days ago)
  • Last Synced: 2026-02-13T18:31:21.168Z (18 days ago)
  • Versions: 1
  • Dependent Packages: 0
  • Dependent Repositories: 0
  • Rankings:
    • Dependent repos count: 0.0%
    • Dependent packages count: 0.0%
    • Average: 100%

Dependencies

Gemfile rubygems
  • jruby-openssl < 0.10.0
  • minitest >= 0
  • rake >= 0
  • rubocop ~> 1.0, < 1.12
redis.gemspec rubygems
  • em-synchrony >= 0 development
  • hiredis >= 0 development
  • mocha >= 0 development
.github/workflows/test.yaml actions
  • actions/cache v3 composite
  • actions/checkout v3 composite
  • ruby/setup-ruby v1 composite
cluster/Gemfile rubygems
  • minitest >= 0
  • mocha >= 0
  • rake >= 0
  • rubocop ~> 1.25.1
cluster/redis-clustering.gemspec rubygems
  • redis-cluster-client >= 0.3.7

Score: 35.58250861147471