redis-client 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d53aaf68e8bf2bc7160a8b708d86c40d13a229a2bfa88734ada0ae03839d6330
-  data.tar.gz: 7ebc1e2e488dbd0bc7895db4714237e893408f017222922cc94faec4b7646e7c
+  metadata.gz: '097ad5acec4f5ea01788629c3fe2c606e54c1a2a0749c4e489487cf6bd446eae'
+  data.tar.gz: 275d778806cb7848d99ddcba33f1e932853efc9f0d149d6409692d1b39452d86
 SHA512:
-  metadata.gz: 397746e753c9c44e6b6f7d046b9e8cb389c25c7a8d8dea40e7ab81c099f328d4f34c1d77d7c2c66c0ea7b12056f282a76c3dc5a700b1acee49b89cddc509070d
-  data.tar.gz: a2fcda7b8bbef1a0988fcd7434306da5769dbcf1ad91b5f790186646eedd1b21fa289b044bacd3f3b91486f8d06e73c51d608f92662bcb366e3d3e871a138b40
+  metadata.gz: c553d706fe8b955a0c6b65a28e9d6a1ddcdec156a562ec5092396a0bca9fa72a251441b8675484fff2d4db3d8e2f335043d226bb4c9c3359e84acc9b7605543f
+  data.tar.gz: 68dcc5d81b1632dd60d22651d0ef600903fe607230d3ac396d5e98aab7694d374d5e577777234d7e514fc4df04b332e0fdb31b3c9971fb116c6b0e87c1ddc5f5

data/.rubocop.yml

@@ -7,6 +7,7 @@ Layout/LineLength:
   Max: 120
   Exclude:
     - 'test/**/*'
+    - 'benchmark/**/*'
 
 Layout/CaseIndentation:
   EnforcedStyle: end

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+# Unreleased
+
+# 0.3.0
+
+- `hiredis` is now the default driver when available.
+- Add `RedisClient.default_driver=`.
+- `#call` now takes an optional block to cast the return value.
+- Treat `#call` keyword arguments as Redis flags.
+- Fix `RedisClient#multi` returning some errors as values instead of raising them.
+
+# 0.2.1
+
+- Use a more robust way to detect the current compiler.
+
+# 0.2.0
+- Added `RedisClient.register` as a public instrumentation API.
+- Fix `read_timeout=` and `write_timeout=` to apply even when the client or pool is already connected.
+- Properly convert DNS resolution errors into `RedisClient::ConnectionError`. Previously it would raise `SocketError`
+
 # 0.1.0
 
 - Initial Release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redis-client (0.0.0)
+    redis-client (0.3.0)
       connection_pool
 
 GEM
@@ -64,4 +64,4 @@ DEPENDENCIES
   toxiproxy
 
 BUNDLED WITH
-   2.3.8
+   2.3.13

data/README.md

@@ -145,19 +145,68 @@ redis.call("LPUSH", "list", "1", "2", "3", "4")
 Hashes are flatenned as well:
 
 ```ruby
-redis.call("HMSET", "hash", foo: 1, bar: 2)
-redis.call("SET", "key", "value", ex: 5)
+redis.call("HMSET", "hash", { "foo" => "1", "bar" => "2" })
 ```
 
 is equivalent to:
 
 ```ruby
 redis.call("HMSET", "hash", "foo", "1", "bar", "2")
-redis.call("SET", "key", "value", "ex", "5")
 ```
 
 Any other type requires the caller to explictly cast the argument as a string.
 
+Keywords arguments are treated as Redis command flags:
+
+```ruby
+redis.call("SET", "mykey", "value", nx: true, ex: 60)
+redis.call("SET", "mykey", "value", nx: false, ex: nil)
+```
+
+is equivalent to:
+
+```ruby
+redis.call("SET", "mykey", "value", "nx", "ex", "60")
+redis.call("SET", "mykey", "value")
+```
+
+If flags are built dynamically, you'll have to explictly pass them as keyword arguments with `**`:
+
+```ruby
+flags = {}
+flags[:nx] = true if something?
+redis.call("SET", "mykey", "value", **flags)
+```
+
+**Important Note**: because of the keyword argument semantic change between Ruby 2 and Ruby 3,
+unclosed hash literals with string keys may be interpreted differently:
+
+```ruby
+redis.call("HMSET", "hash", "foo" => "bar")
+```
+
+On Ruby 2 `"foo" => "bar"` will be passed as a postional argument, but on Ruby 3 it will be interpreted as keyword
+arguments. To avoid such problem, make sure to enclose hash literals:
+
+```ruby
+redis.call("HMSET", "hash", { "foo" => "bar" })
+```
+
+### Commands return values
+
+Contrary to the `redis` gem, `redis-client` doesn't do any type casting on the return value of commands.
+
+If you wish to cast the return value, you can pass a block to the `#call` familly of methods:
+
+```ruby
+redis.call("INCR", "counter") # => 1
+redis.call("GET", "counter") # => "1"
+redis.call("GET", "counter", &:to_i) # => 1
+
+redis.call("EXISTS", "counter") # => 1
+redis.call("EXISTS", "counter") { |c| c > 0 } # => true
+```
+
 ### Blocking commands
 
 For blocking commands such as `BRPOP`, a custom timeout duration can be passed as first argument of the `#blocking_call` method:
@@ -270,6 +319,25 @@ end
 
 ## Production
 
+### Instrumentation
+
+`redis-client` offers a public instrumentation API monitoring tools.
+
+```ruby
+module MyRedisInstrumentation
+  def call(command, redis_config)
+    MyMonitoringService.instrument("redis.query") { super }
+  end
+
+  def call_pipelined(commands, redis_config)
+    MyMonitoringService.instrument("redis.pipeline") { super }
+  end
+end
+RedisClient.register(MyRedisInstrumentation)
+```
+
+Note that this instrumentation is global.
+
 ### Timeouts
 
 The client allows you to configure connect, read, and write timeouts.
@@ -319,6 +387,24 @@ redis.call("GET", "counter") # Will be retried up to 3 times.
 redis.call_once("INCR", "counter") # Won't be retried.
 ```
 
+### Drivers
+
+`redis-client` ships with two connection implementations, a `hiredis` binding and a pure Ruby implementation.
+
+The hiredis binding is only available on Linux, macOS and other POSIX platforms. When available it is the default.
+
+The default driver can be set through `RedisClient.default_driver=`:
+
+```ruby
+RedisClient.default_driver = :ruby
+```
+
+You can also select the driver on a per connection basis:
+
+```ruby
+redis_config = RedisClient.config(driver: :ruby, ...)
+```
+
 ## Notable differences with the `redis` gem
 
 ### Thread Safety

data/Rakefile

@@ -19,7 +19,16 @@ end
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"].exclude("test/sentinel/*_test.rb")
+end
+
+namespace :test do
+  Rake::TestTask.new(:sentinel) do |t|
+    t.libs << "test/sentinel"
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/sentinel/*_test.rb"]
+  end
 end
 
 namespace :hiredis do
@@ -49,7 +58,7 @@ namespace :benchmark do
           env = {}
           args = []
           args << "--yjit" if mode == :yjit
-          env["DRIVER"] = "hiredis" if mode == :hiredis
+          env["DRIVER"] = mode == :hiredis ? "hiredis" : "ruby"
           system(env, RbConfig.ruby, *args, "benchmark/#{suite}.rb", out: output)
         end
 
@@ -74,13 +83,13 @@ namespace :benchmark do
 end
 
 if RUBY_PLATFORM == "java"
-  task default: %i[test rubocop]
+  task default: %i[test test:sentinel rubocop]
 else
-  task default: %i[compile test rubocop]
+  task default: %i[compile test test:sentinel rubocop]
 end
 
 if ENV["DRIVER"] == "hiredis"
-  task ci: %i[compile test]
+  task ci: %i[compile test test:sentinel]
 else
-  task ci: %i[test]
+  task ci: %i[test test:sentinel]
 end

data/ext/redis_client/hiredis/export.clang

@@ -0,0 +1,2 @@
+_Init_hiredis_connection
+_ruby_abi_version

data/ext/redis_client/hiredis/export.gcc

@@ -0,0 +1,7 @@
+hiredis_connection_1.0 { 
+  global: 
+    Init_hiredis_connection;
+    ruby_abi_version;
+  local: 
+    *;
+};

data/ext/redis_client/hiredis/extconf.rb

@@ -2,13 +2,13 @@
 
 require "mkmf"
 
-if RUBY_ENGINE == "ruby"
+if RUBY_ENGINE == "ruby" && !RUBY_ENGINE.match?(/mswin/)
+  have_func("rb_hash_new_capa", "ruby.h")
+
   hiredis_dir = File.expand_path('vendor', __dir__)
 
   make_program = with_config("make-prog", ENV["MAKE"])
   make_program ||= case RUBY_PLATFORM
-  when /mswin/
-    'nmake'
   when /(bsd|solaris)/
     'gmake'
   else
@@ -31,18 +31,33 @@ if RUBY_ENGINE == "ruby"
   end
 
   Dir.chdir(hiredis_dir) do
-    flags = %(CFLAGS="-I#{openssl_include}" SSL_LDFLAGS="-L#{openssl_lib}") if openssl_lib
-    success = system("#{make_program} static USE_SSL=1 #{flags}")
-    raise "Building hiredis failed" unless success
+    flags = ["static", "USE_SSL=1"]
+    if openssl_lib
+      flags << %(CFLAGS="-I#{openssl_include}") << %(SSL_LDFLAGS="-L#{openssl_lib}")
+    end
+
+    flags << "OPTIMIZATION=-g" if ENV["EXT_PEDANTIC"]
+
+    unless system(make_program, *flags)
+      raise "Building hiredis failed"
+    end
   end
 
   $CFLAGS << " -I#{hiredis_dir}"
-  $LDFLAGS << " #{hiredis_dir}/libhiredis.a #{hiredis_dir}/libhiredis_ssl.a -lssl -lcrypto"
-  $CFLAGS << " -O3"
+  $LDFLAGS << " -lssl -lcrypto"
+  $libs << " #{hiredis_dir}/libhiredis.a #{hiredis_dir}/libhiredis_ssl.a "
   $CFLAGS << " -std=c99 "
-
   if ENV["EXT_PEDANTIC"]
     $CFLAGS << " -Werror"
+    $CFLAGS << " -g "
+  else
+    $CFLAGS << " -O3 "
+  end
+
+  if `cc --version`.match?(/ clang /i) || RbConfig::CONFIG['CC'].match?(/clang/i)
+    $LDFLAGS << ' -Wl,-exported_symbols_list,"' << File.join(__dir__, 'export.clang') << '"'
+  elsif RbConfig::CONFIG['CC'].match?(/gcc/i)
+    $LDFLAGS << ' -Wl,--version-script="' << File.join(__dir__, 'export.gcc') << '"'
   end
 
   $CFLAGS << " -Wno-declaration-after-statement" # Older compilers

data/ext/redis_client/hiredis/hiredis_connection.c

@@ -38,6 +38,13 @@
 #include "hiredis.h"
 #include "hiredis_ssl.h"
 
+#if !defined(HAVE_RB_HASH_NEW_CAPA)
+static inline VALUE rb_hash_new_capa(long capa)
+{
+  return rb_hash_new();
+}
+#endif
+
 static VALUE rb_cSet, rb_eRedisClientCommandError, rb_eRedisClientConnectionError;
 static VALUE rb_eRedisClientConnectTimeoutError, rb_eRedisClientReadTimeoutError, rb_eRedisClientWriteTimeoutError;
 static ID id_parse, id_add, id_new;
@@ -148,6 +155,10 @@ static void *reply_create_string(const redisReadTask *task, char *cstr, size_t l
         rb_enc_associate(string, rb_ascii8bit_encoding());
     }
 
+    if (task->type == REDIS_REPLY_STATUS) {
+      rb_str_freeze(string);
+    }
+
     if (task->type == REDIS_REPLY_ERROR) {
         string = rb_funcall(rb_eRedisClientCommandError, id_parse, 1, string);
     }
@@ -162,7 +173,7 @@ static void *reply_create_array(const redisReadTask *task, size_t elements) {
             value = rb_ary_new_capa(elements);
             break;
         case REDIS_REPLY_MAP:
-            value = rb_hash_new();
+            value = rb_hash_new_capa(elements / 2);
             break;
         case REDIS_REPLY_SET:
             value = rb_funcallv(rb_cSet, id_new, 0, NULL);
@@ -428,6 +439,7 @@ static VALUE hiredis_connect_finish(hiredis_connection_t *connection, redisConte
 
     /* Check for socket error */
     if (getsockopt(context->fd, SOL_SOCKET, SO_ERROR, &optval, &optlen) < 0) {
+        context->err = REDIS_ERR_IO;
         redis_raise_error_and_disconnect(context, rb_eRedisClientConnectTimeoutError);
     }
 

data/lib/redis_client/command_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module CommandBuilder
+    extend self
+
+    if Symbol.method_defined?(:name)
+      def generate!(args, kwargs)
+        command = args.flat_map do |element|
+          case element
+          when Hash
+            element.flatten
+          when Set
+            element.to_a
+          else
+            element
+          end
+        end
+
+        kwargs.each do |key, value|
+          if value
+            if value == true
+              command << key.name
+            else
+              command << key.name << value
+            end
+          end
+        end
+
+        command.map! do |element|
+          case element
+          when String
+            element
+          when Symbol
+            element.name
+          when Integer, Float
+            element.to_s
+          else
+            raise TypeError, "Unsupported command argument type: #{element.class}"
+          end
+        end
+
+        command
+      end
+    else
+      def generate!(args, kwargs)
+        command = args.flat_map do |element|
+          case element
+          when Hash
+            element.flatten
+          when Set
+            element.to_a
+          else
+            element
+          end
+        end
+
+        kwargs.each do |key, value|
+          if value
+            if value == true
+              command << key.to_s
+            else
+              command << key.to_s << value
+            end
+          end
+        end
+
+        command.map! do |element|
+          case element
+          when String
+            element
+          when Integer, Float, Symbol
+            element.to_s
+          else
+            raise TypeError, "Unsupported command argument type: #{element.class}"
+          end
+        end
+
+        command
+      end
+    end
+  end
+end

data/lib/redis_client/config.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "openssl"
 require "uri"
 
 class RedisClient
@@ -11,7 +12,7 @@ class RedisClient
     DEFAULT_DB = 0
 
     module Common
-      attr_reader :db, :username, :password, :id, :ssl, :ssl_params,
+      attr_reader :db, :username, :password, :id, :ssl, :ssl_params, :command_builder,
         :connect_timeout, :read_timeout, :write_timeout, :driver, :connection_prelude
 
       alias_method :ssl?, :ssl
@@ -27,7 +28,8 @@ class RedisClient
         connect_timeout: timeout,
         ssl: nil,
         ssl_params: nil,
-        driver: :ruby,
+        driver: nil,
+        command_builder: CommandBuilder,
         reconnect_attempts: false
       )
         @username = username || DEFAULT_USERNAME
@@ -41,17 +43,9 @@ class RedisClient
         @read_timeout = read_timeout
         @write_timeout = write_timeout
 
-        @driver = case driver
-        when :ruby
-          Connection
-        when :hiredis
-          unless defined?(RedisClient::HiredisConnection)
-            require "redis_client/hiredis_connection"
-          end
-          HiredisConnection
-        else
-          raise ArgumentError, "Unknown driver #{driver.inspect}, expected one of: `:ruby`, `:hiredis`"
-        end
+        @driver = driver ? RedisClient.driver(driver) : RedisClient.default_driver
+
+        @command_builder = command_builder
 
         reconnect_attempts = Array.new(reconnect_attempts, 0).freeze if reconnect_attempts.is_a?(Integer)
         @reconnect_attempts = reconnect_attempts
@@ -84,41 +78,8 @@ class RedisClient
         false
       end
 
-      def hiredis_ssl_context
-        @hiredis_ssl_context ||= HiredisConnection::SSLContext.new(
-          ca_file: @ssl_params[:ca_file],
-          ca_path: @ssl_params[:ca_path],
-          cert: @ssl_params[:cert],
-          key: @ssl_params[:key],
-          hostname: @ssl_params[:hostname],
-        )
-      end
-
-      def openssl_context
-        @openssl_context ||= begin
-          params = @ssl_params.dup || {}
-
-          cert = params[:cert]
-          if cert.is_a?(String)
-            cert = File.read(cert) if File.exist?(cert)
-            params[:cert] = OpenSSL::X509::Certificate.new(cert)
-          end
-
-          key = params[:key]
-          if key.is_a?(String)
-            key = File.read(key) if File.exist?(key)
-            params[:key] = OpenSSL::PKey.read(key)
-          end
-
-          context = OpenSSL::SSL::SSLContext.new
-          context.set_params(params)
-          if context.verify_mode != OpenSSL::SSL::VERIFY_NONE
-            if context.respond_to?(:verify_hostname) # Missing on JRuby
-              context.verify_hostname
-            end
-          end
-          context
-        end
+      def ssl_context
+        @ssl_context ||= @driver.ssl_context(@ssl_params)
       end
 
       private

data/lib/redis_client/connection_mixin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module ConnectionMixin
+    def call(command, timeout)
+      write(command)
+      result = read(timeout)
+      if result.is_a?(CommandError)
+        raise result
+      else
+        result
+      end
+    end
+
+    def call_pipelined(commands, timeouts)
+      exception = nil
+
+      size = commands.size
+      results = Array.new(commands.size)
+      write_multi(commands)
+
+      size.times do |index|
+        timeout = timeouts && timeouts[index]
+        result = read(timeout)
+        if result.is_a?(CommandError)
+          exception ||= result
+        end
+        results[index] = result
+      end
+
+      if exception
+        raise exception
+      else
+        results
+      end
+    end
+  end
+end

data/lib/redis_client/decorator.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module Decorator
+    class << self
+      def create(commands_mixin)
+        client_decorator = Class.new(Client)
+        client_decorator.include(commands_mixin)
+
+        pipeline_decorator = Class.new(Pipeline)
+        pipeline_decorator.include(commands_mixin)
+        client_decorator.const_set(:Pipeline, pipeline_decorator)
+
+        client_decorator
+      end
+    end
+
+    module CommandsMixin
+      def initialize(client)
+        @client = client
+      end
+
+      %i(call call_once blocking_call).each do |method|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{method}(*args, &block)
+            @client.#{method}(*args, &block)
+          end
+          ruby2_keywords :#{method} if respond_to?(:ruby2_keywords, true)
+        RUBY
+      end
+    end
+
+    class Pipeline
+      include CommandsMixin
+    end
+
+    class Client
+      include CommandsMixin
+
+      def initialize(_client)
+        super
+        @_pipeline_class = self.class::Pipeline
+      end
+
+      def with(*args)
+        @client.with(*args) { |c| yield self.class.new(c) }
+      end
+      ruby2_keywords :with if respond_to?(:ruby2_keywords, true)
+
+      def pipelined
+        @client.pipelined { |p| yield @_pipeline_class.new(p) }
+      end
+
+      def multi(**kwargs)
+        @client.multi(**kwargs) { |p| yield @_pipeline_class.new(p) }
+      end
+
+      %i(close scan hscan sscan zscan).each do |method|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{method}(*args, &block)
+            @client.#{method}(*args, &block)
+          end
+          ruby2_keywords :#{method} if respond_to?(:ruby2_keywords, true)
+        RUBY
+      end
+
+      %i(id config size connect_timeout read_timeout write_timeout).each do |reader|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{reader}
+            @client.#{reader}
+          end
+        RUBY
+      end
+
+      %i(timeout connect_timeout read_timeout write_timeout).each do |writer|
+        class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{writer}=(value)
+            @client.#{writer} = value
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/redis_client/hiredis_connection.rb

@@ -1,9 +1,24 @@
 # frozen_string_literal: true
 
 require "redis_client/hiredis_connection.so"
+require "redis_client/connection_mixin"
 
 class RedisClient
   class HiredisConnection
+    include ConnectionMixin
+
+    class << self
+      def ssl_context(ssl_params)
+        HiredisConnection::SSLContext.new(
+          ca_file: ssl_params[:ca_file],
+          ca_path: ssl_params[:ca_path],
+          cert: ssl_params[:cert],
+          key: ssl_params[:key],
+          hostname: ssl_params[:hostname],
+        )
+      end
+    end
+
     class SSLContext
       def initialize(ca_file: nil, ca_path: nil, cert: nil, key: nil, hostname: nil)
         if (error = init(ca_file, ca_path, cert, key, hostname))
@@ -24,7 +39,7 @@ class RedisClient
       end
 
       if config.ssl
-        init_ssl(config.hiredis_ssl_context)
+        init_ssl(config.ssl_context)
       end
     end
 

data/lib/redis_client/middlewares.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module Middlewares
+    extend self
+
+    def call(command, _config)
+      yield command
+    end
+    alias_method :call_pipelined, :call
+  end
+end