solid-redis 1.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a8d7e4c46fd3443d3eda55582111998c1c2f1cfa1d97745f53a8d39494d1dbf
-  data.tar.gz: bbd7f6c8da3509f605d20daf2ace8439e4d0f3ffc16bd4d4405a8e6d3f880723
+  metadata.gz: b6c2088305fc897e081c9f3b7d2a5913441ab4816851a9da52158d05ea84d863
+  data.tar.gz: 15d0a731a92ac785fd837ca99be1d6521a728446be45087adbf997f338f6456d
 SHA512:
-  metadata.gz: 3744b1d0cecccd3e286445f5224852d27220afb7cbcfe763d4cf500ddea03976a4e7a73586276219446cfcb590ca09f174510f9f426063f868d5e0d8bf797d41
-  data.tar.gz: d3ae71c56576195f4067db3d3384c7aa19a6c0fad306dbd588cb1562d09289bb0fc39957f80149184eec63ce3e415b169956e1bde816209209e454e85725330f
+  metadata.gz: a20d9fcccf65d69d08045d196ca54478e65c689941c6a07b302acea78e3f2218b6b96b3039904e5f710fff54fc013ef951ef98b267c24d3c9cbf961066ad8442
+  data.tar.gz: 373aac9ed547db8482549be91af26821fba8ed48b4098fae5049ffd9496de97960c7f3176e6ebdbf46e6230196c90058842efce10803d5e5251d321afe623ca8

data/CHANGELOG.md

@@ -4,6 +4,46 @@ All notable changes to this project are documented in this file. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the
 project adheres to [Semantic Versioning](https://semver.org/).
 
+## [1.0.4] - 2026-09-27
+
+### Changed
+
+- Cache the immutable server key instead of allocating it on every Cluster
+  lookup.
+- Encode one-level nested command arguments without creating an intermediate
+  flattened array.
+- Parse RESP data with a buffer cursor and compact only when another socket
+  read is required, reducing response-parser allocations.
+- Attempt non-blocking socket reads and writes before waiting with `IO.select`,
+  while preserving read/write deadlines when the socket would block.
+
+## [1.0.3] - 2026-09-27
+
+### Added
+
+- Deterministic fault-injection and bounded thread/Ractor stress tests in the
+  standard CI suite.
+- A dependency-free local throughput benchmark run by the default Rake task.
+- A reproducible real-Redis comparison with `redis-client` across 1/2/4/8
+  Ractors, pipelines, isolated pools, Cluster, and forced Sentinel failover,
+  including latency percentiles, CPU, RSS, allocations, and errors.
+
+### Fixed
+
+- Consume complete RESP arrays, maps, sets, pushes, and attributes before
+  raising nested Redis errors, preventing connection desynchronization.
+- Handle `:wait_writable` during non-blocking reads and discard connections
+  after protocol errors without replaying commands.
+- Retry `TRYAGAIN` and `CLUSTERDOWN` pipeline replies consistently with direct
+  Cluster calls, and clear `ASKING` state before refreshing the topology.
+- Route `MEMORY USAGE` to the node owning its key.
+- Preserve an explicitly configured `db` when a Redis URL is also provided.
+
+### Changed
+
+- Clarify that Cluster commands are grouped into per-node pipelines rather
+  than sent concurrently.
+
 ## [1.0.2] - 2026-09-27
 
 ### Added
@@ -73,6 +113,8 @@ project adheres to [Semantic Versioning](https://semver.org/).
   TLS, reconnection), `Pool` owned by a single Ractor, pipelines, and
   lifecycle callbacks via `callback-collection`.
 
+[1.0.4]: https://github.com/nicolasva/solid-redis/compare/v1.0.3...v1.0.4
+[1.0.3]: https://github.com/nicolasva/solid-redis/compare/v1.0.2...v1.0.3
 [1.0.2]: https://github.com/nicolasva/solid-redis/compare/v1.0.1...v1.0.2
 [1.0.1]: https://github.com/nicolasva/solid-redis/compare/v1.0.0...v1.0.1
 [1.0.0]: https://github.com/nicolasva/solid-redis/compare/v0.2.1...v1.0.0

data/README.md

@@ -272,9 +272,9 @@ client.call("GET", "user:1")
 client.call("MGET", "{user:1}.name", "{user:1}.email") # same slot via hash tag
 
 client.pipelined do |pipeline|
-  pipeline.call("GET", "a")   # commands are grouped per node,
-  pipeline.call("GET", "b")   # sent in parallel pipelines,
-  pipeline.call("PING")       # and results come back in order
+  pipeline.call("GET", "a")   # commands are grouped into one pipeline
+  pipeline.call("GET", "b")   # per node, and results come back
+  pipeline.call("PING")       # in their original order
 end
 
 pool = CLUSTER.new_pool(size: 5) # a pool of cluster clients
@@ -308,6 +308,10 @@ Direct Redis options:
 | `ssl` | `false` | Enable TLS |
 | `ssl_params` | | Immutable `OpenSSL::SSL::SSLContext` attributes |
 
+An explicit `db:` option takes precedence over a database selected by the URL
+path or `?db=` query parameter. When neither specifies a database, it defaults
+to `0`.
+
 Sentinel additionally requires `name` and `sentinels`, and accepts `role`,
 `sentinel_username`, `sentinel_password`, `sentinel_ssl`, and
 `sentinel_ssl_params`. Sentinel defaults to two reconnect attempts.
@@ -579,6 +583,108 @@ futures. It cannot transparently replace a block-based synchronous pool
 without defining backpressure, cancellation, transaction, Pub/Sub, and
 exception protocols.
 
+## Benchmark
+
+<!-- benchmark-results:start -->
+This is a local-loopback microbenchmark, not a prediction of application
+performance. It excludes Redis server CPU/RAM and network latency.
+Cluster rows compare `solid-redis` with `redis-cluster-client`, the
+Cluster implementation built on `redis-client`. Unsupported combinations
+are reported rather than replaced with a different concurrency model.
+
+**Environment:** Ruby 3.4.4 (arm64-darwin24); solid-redis 1.0.3; Redis server v=8.10.0 sha=00000000:1 malloc=libc bits=64 build=80fd3081013fc32b; redis-client 0.30.1; redis-cluster-client 0.17.1; Apple M2 Max, 12 logical CPUs, 96 GiB RAM, macOS 26.6.2.
+
+Each row is measured in a fresh Ruby process. Both clients use RESP2,
+identical commands and the same local Redis topology. Client order is
+alternated between runs; values are medians of 5 runs.
+Regular workloads warm for 2 seconds and measure
+for 10 seconds. Pipeline latency is amortized
+per command (batch size 50). The isolated-pool scenario creates a
+five-connection pool inside each Ractor, warms it with
+1,000 PINGs, then measures 100,000
+PINGs per Ractor.
+CPU is client-process CPU divided by wall time and may exceed 100% with
+multiple Ractors. Peak RSS excludes Redis server processes. Sentinel
+rows kill the master process 0.5 seconds after measurement starts and
+verify that every Ractor resumes on the promoted replica. Recovery is
+measured from the kill to each Ractor's first successful response.
+Throughput counts successful commands; errors are failed commands
+observed during the measured interval. Allocation and RSS measurements
+include the identical latency-recording harness used for both clients, so
+they are comparative rather than intrinsic library-only costs.
+
+Reproduce the full run (requires `redis-server` and `redis-cli`):
+
+```sh
+BENCHMARK_README=README.md bundle exec rake benchmark:comparison
+```
+
+### GET / SET
+
+| Ractors | Client | Throughput (ops/s) | p50 (ms) | p95 (ms) | p99 (ms) | CPU | Peak RSS | Allocations/op | Errors/run |
+|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| 1 | `redis-client` | 35,636 | 0.027 | 0.033 | 0.045 | 58.3% | 50.6 MiB | 17.4 | 0 |
+| 1 | `solid-redis` | 33,891 | 0.028 | 0.034 | 0.051 | 52.4% | 49.0 MiB | 28.9 | 0 |
+| 2 | `redis-client` | 53,941 | 0.035 | 0.049 | 0.069 | 114.6% | 58.6 MiB | 17.3 | 0 |
+| 2 | `solid-redis` | 56,594 | 0.033 | 0.045 | 0.090 | 104.7% | 57.9 MiB | 28.7 | 0 |
+| 4 | `redis-client` | 67,608 | 0.055 | 0.092 | 0.131 | 238.3% | 63.7 MiB | 17.3 | 0 |
+| 4 | `solid-redis` | 75,539 | 0.049 | 0.082 | 0.141 | 204.1% | 63.8 MiB | 28.5 | 0 |
+| 8 | `redis-client` | 48,828 | 0.078 | 0.171 | 0.236 | 268.5% | 75.4 MiB | 17.3 | 0 |
+| 8 | `solid-redis` | 80,691 | 0.087 | 0.172 | 0.267 | 431.4% | 69.5 MiB | 28.2 | 0 |
+
+### Pipelines
+
+| Ractors | Client | Throughput (ops/s) | p50 (ms) | p95 (ms) | p99 (ms) | CPU | Peak RSS | Allocations/op | Errors/run |
+|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| 1 | `redis-client` | 262,482 | 0.004 | 0.005 | 0.007 | 81.5% | 39.5 MiB | 12.6 | 0 |
+| 1 | `solid-redis` | 317,150 | 0.003 | 0.004 | 0.006 | 77.9% | 41.0 MiB | 16.2 | 0 |
+| 2 | `redis-client` | 270,197 | 0.007 | 0.010 | 0.013 | 149.9% | 39.9 MiB | 12.5 | 0 |
+| 2 | `solid-redis` | 459,445 | 0.004 | 0.007 | 0.009 | 147.5% | 42.5 MiB | 15.9 | 0 |
+| 4 | `redis-client` | 222,813 | 0.017 | 0.025 | 0.031 | 282.8% | 40.0 MiB | 12.5 | 0 |
+| 4 | `solid-redis` | 464,640 | 0.008 | 0.014 | 0.017 | 251.9% | 43.2 MiB | 15.6 | 0 |
+| 8 | `redis-client` | 204,898 | 0.004 | 0.055 | 0.063 | 314.2% | 41.9 MiB | 12.5 | 0 |
+| 8 | `solid-redis` | 341,323 | 0.021 | 0.042 | 0.047 | 550.7% | 43.4 MiB | 15.5 | 0 |
+
+### Isolated pool per Ractor
+
+| Ractors | Client | Throughput (ops/s) | p50 (ms) | p95 (ms) | p99 (ms) | CPU | Peak RSS | Allocations/op | Errors/run |
+|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| 1 | `redis-client` | unsupported: Ractor::IsolationError (`connection_pool` uses non-shareable global state) | — | — | — | — | — | — | — |
+| 1 | `solid-redis` | 34,528 | 0.028 | 0.033 | 0.043 | 53.3% | 39.0 MiB | 25.0 | 0 |
+| 2 | `redis-client` | unsupported: Ractor::IsolationError (`connection_pool` uses non-shareable global state) | — | — | — | — | — | — | — |
+| 2 | `solid-redis` | 57,408 | 0.032 | 0.046 | 0.086 | 106.3% | 44.4 MiB | 24.8 | 0 |
+| 4 | `redis-client` | unsupported: Ractor::IsolationError (`connection_pool` uses non-shareable global state) | — | — | — | — | — | — | — |
+| 4 | `solid-redis` | 78,461 | 0.047 | 0.078 | 0.129 | 205.4% | 54.1 MiB | 24.6 | 0 |
+| 8 | `redis-client` | unsupported: Ractor::IsolationError (`connection_pool` uses non-shareable global state) | — | — | — | — | — | — | — |
+| 8 | `solid-redis` | 72,809 | 0.071 | 0.129 | 0.202 | 297.3% | 68.9 MiB | 24.4 | 0 |
+
+### Cluster
+
+| Ractors | Client | Throughput (ops/s) | p50 (ms) | p95 (ms) | p99 (ms) | CPU | Peak RSS | Allocations/op | Errors/run |
+|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| 1 | `redis-client` | 29,071 | 0.033 | 0.040 | 0.051 | 64.8% | 48.8 MiB | 19.4 | 0 |
+| 1 | `solid-redis` | 29,213 | 0.033 | 0.038 | 0.056 | 57.1% | 47.6 MiB | 34.9 | 0 |
+| 2 | `redis-client` | 50,333 | 0.037 | 0.051 | 0.078 | 124.7% | 57.8 MiB | 19.3 | 0 |
+| 2 | `solid-redis` | 51,805 | 0.036 | 0.050 | 0.097 | 117.2% | 57.0 MiB | 34.7 | 0 |
+| 4 | `redis-client` | 60,752 | 0.062 | 0.099 | 0.139 | 252.6% | 62.5 MiB | 19.3 | 0 |
+| 4 | `solid-redis` | 66,626 | 0.055 | 0.089 | 0.152 | 225.9% | 61.2 MiB | 34.4 | 0 |
+| 8 | `redis-client` | 43,258 | 0.089 | 0.186 | 0.253 | 278.1% | 75.4 MiB | 19.3 | 0 |
+| 8 | `solid-redis` | 48,644 | 0.079 | 0.154 | 0.248 | 241.4% | 74.7 MiB | 34.3 | 0 |
+
+### Sentinel master crash
+
+| Ractors | Client | Throughput (ops/s) | p50 (ms) | p95 (ms) | p99 (ms) | Recovery p50 (ms) | Recovery max (ms) | CPU | Peak RSS | Allocations/op | Errors/run |
+|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 1 | `redis-client` | 29,378 | 0.028 | 0.035 | 0.046 | 1333.8 | 1333.8 | 61.9% | 52.3 MiB | 20.1 | 2050 |
+| 1 | `solid-redis` | 28,794 | 0.029 | 0.035 | 0.050 | 1319.1 | 1319.1 | 55.5% | 48.3 MiB | 33.3 | 2090 |
+| 2 | `redis-client` | 30,829 | 0.036 | 0.049 | 0.070 | 4242.9 | 4243.0 | 87.8% | 53.4 MiB | 20.4 | 3080 |
+| 2 | `solid-redis` | 31,074 | 0.033 | 0.045 | 0.093 | 4440.4 | 4451.4 | 77.3% | 50.3 MiB | 33.1 | 2202 |
+| 4 | `redis-client` | 36,404 | 0.054 | 0.093 | 0.131 | 4302.8 | 4870.8 | 157.2% | 58.0 MiB | 20.5 | 3113 |
+| 4 | `solid-redis` | 41,080 | 0.048 | 0.081 | 0.136 | 4802.3 | 4962.6 | 132.6% | 56.0 MiB | 32.0 | 2251 |
+| 8 | `redis-client` | 48,133 | 0.117 | 0.219 | 0.297 | 2278.4 | 2741.5 | 434.1% | 61.5 MiB | 19.7 | 3114 |
+| 8 | `solid-redis` | 63,627 | 0.087 | 0.171 | 0.277 | 2073.7 | 2085.0 | 374.0% | 64.4 MiB | 30.6 | 2268 |
+<!-- benchmark-results:end -->
+
 ## Development
 
 ```sh
@@ -586,8 +692,15 @@ bundle install
 bundle exec rake
 ```
 
-The default task runs the Minitest suite and builds the gem in `pkg/`.
-CI runs the suite on Ruby 3.1 through 4.0.
+The default task runs the Minitest suite, a deterministic local throughput
+benchmark, and builds the gem in `pkg/`. CI runs all three on Ruby 3.1 through
+4.0. The test suite includes bounded thread/Ractor stress and fault injection
+for truncated responses, timeouts, reconnects, Sentinel, and Cluster errors.
+Run only the benchmark with:
+
+```sh
+bundle exec rake benchmark
+```
 
 The suite needs no running Redis: it uses an in-process fake server
 (`test/support/fake_redis_server.rb`) that speaks RESP2/RESP3, Sentinel,

data/lib/solid_redis/client.rb

@@ -44,10 +44,8 @@ module SolidRedis
       begin
         write(RESP.encode(command))
         @reader.with_timeout(read_timeout) { @reader.read }
-      rescue ConnectionError, IO::WaitReadable, IO::WaitWritable, SystemCallError => error
-        close
-        config.reset if config.sentinel?
-        config.notify(:connection_error, error.class.name, error.message)
+      rescue ProtocolError, ConnectionError, IO::WaitReadable, IO::WaitWritable, SystemCallError => error
+        handle_connection_failure(error)
         raise error if error.is_a?(Error)
 
         raise ConnectionError, error.message, cause: error
@@ -96,10 +94,11 @@ module SolidRedis
       begin
         connect unless connected?
         yield
+      rescue ProtocolError => error
+        handle_connection_failure(error)
+        raise
       rescue ConnectionError, IO::WaitReadable, IO::WaitWritable, SystemCallError => error
-        close
-        config.reset if config.sentinel?
-        config.notify(:connection_error, error.class.name, error.message)
+        handle_connection_failure(error)
         if attempts < config.reconnect_attempts
           attempts += 1
           retry
@@ -110,6 +109,12 @@ module SolidRedis
       end
     end
 
+    def handle_connection_failure(error)
+      close
+      config.reset if config.sentinel?
+      config.notify(:connection_error, error.class.name, error.message)
+    end
+
     def connect
       @target = config.sentinel? ? config.resolve : config
       @socket = open_socket(@target)
@@ -197,14 +202,19 @@ module SolidRedis
 
     def write(payload)
       offset = 0
+      deadline = nil
       while offset < payload.bytesize
-        unless IO.select(nil, [@socket], nil, @target.write_timeout)
-          raise TimeoutError, "Redis write timed out after #{@target.write_timeout}s"
+        chunk = offset.zero? ? payload : payload.byteslice(offset..)
+        written = @socket.write_nonblock(chunk, exception: false)
+        if written == :wait_writable
+          deadline ||= monotonic_time + @target.write_timeout
+          remaining = deadline - monotonic_time
+          if remaining <= 0 || !IO.select(nil, [@socket], nil, remaining)
+            raise TimeoutError, "Redis write timed out after #{@target.write_timeout}s"
+          end
+          next
         end
 
-        written = @socket.write_nonblock(payload.byteslice(offset..), exception: false)
-        next if written == :wait_writable
-
         offset += written
       end
     rescue IOError, SystemCallError => error

data/lib/solid_redis/cluster/command_key.rb

@@ -8,7 +8,7 @@ module SolidRedis
       KEYLESS = Ractor.make_shareable(
         %w[
           ACL ASKING AUTH BGREWRITEAOF BGSAVE CLIENT CLUSTER COMMAND CONFIG DBSIZE DEBUG DISCARD ECHO EXEC
-          FAILOVER FLUSHALL FLUSHDB FUNCTION HELLO INFO LASTSAVE LATENCY LOLWUT MEMORY MODULE MONITOR MULTI PING
+          FAILOVER FLUSHALL FLUSHDB FUNCTION HELLO INFO LASTSAVE LATENCY LOLWUT MODULE MONITOR MULTI PING
           PSUBSCRIBE PUBLISH PUBSUB PUNSUBSCRIBE QUIT RANDOMKEY READONLY READWRITE REPLICAOF RESET ROLE SAVE
           SCAN SCRIPT SELECT SHUTDOWN SLAVEOF SLOWLOG SUBSCRIBE SWAPDB SYNC TIME UNSUBSCRIBE UNWATCH WAIT
         ].to_h { |name| [name, true] },
@@ -42,6 +42,7 @@ module SolidRedis
         end
 
         case name
+        when "MEMORY" then command[1].to_s.casecmp?("USAGE") ? command[2] : nil
         when "XGROUP", "XINFO", "OBJECT" then command[2]
         when "MIGRATE" then command[3].to_s.empty? ? nil : command[3]
         else command[1]

data/lib/solid_redis/cluster_client.rb

@@ -7,6 +7,7 @@ module SolidRedis
   class ClusterClient
     REDIRECTION = /\A(MOVED|ASK) (\d+) (\S+):(\d+)\z/
     RETRY_DELAY = 0.05
+    TRANSIENT_ERRORS = %w[TRYAGAIN CLUSTERDOWN].freeze
 
     attr_reader :config
 
@@ -49,7 +50,8 @@ module SolidRedis
       end
 
       results.each_with_index do |result, index|
-        next unless result.is_a?(CommandError) && result.message.match?(REDIRECTION)
+        next unless result.is_a?(CommandError)
+        next unless result.message.match?(REDIRECTION) || transient_error?(result)
 
         results[index] = begin
           call_v(commands[index])
@@ -107,6 +109,7 @@ module SolidRedis
           redirections += 1
           raise FailoverError, "Cluster unavailable: #{error.message}" if redirections > config.max_redirections
 
+          asking = false
           sleep RETRY_DELAY
           config.state.refresh
           node = node_for(command)
@@ -129,6 +132,10 @@ module SolidRedis
       key ? config.state.node_for_slot(Cluster::KeySlot.for(key)) : config.state.any_node
     end
 
+    def transient_error?(error)
+      error.message.start_with?(*TRANSIENT_ERRORS)
+    end
+
     def client_for(node)
       @clients[node.server_key] ||= node.new_client(name: @name)
     end

data/lib/solid_redis/config.rb

@@ -6,6 +6,7 @@ module SolidRedis
   class Config
     DEFAULT_TIMEOUT = 1.0
     DEFAULT_PORT = 6379
+    UNSPECIFIED = Object.new.freeze
 
     attr_reader :host, :port, :path, :username, :password, :db,
       :connect_timeout, :read_timeout, :write_timeout, :reconnect_attempts,
@@ -18,7 +19,7 @@ module SolidRedis
       path: nil,
       username: nil,
       password: nil,
-      db: 0,
+      db: UNSPECIFIED,
       timeout: DEFAULT_TIMEOUT,
       connect_timeout: timeout,
       read_timeout: timeout,
@@ -35,9 +36,10 @@ module SolidRedis
         path = values[:path]
         username ||= values[:username]
         password ||= values[:password]
-        db = values[:db] unless values[:db].nil?
+        db = values[:db] if db.equal?(UNSPECIFIED) && !values[:db].nil?
         ssl ||= values[:ssl]
       end
+      db = 0 if db.equal?(UNSPECIFIED)
 
       @host = String(host).dup.freeze unless path
       @port = Integer(port) unless path
@@ -54,6 +56,7 @@ module SolidRedis
       @ssl = !!ssl
       @ssl_params = Shareable.copy(ssl_params, label: "ssl_params") if ssl_params
       @callbacks = Shareable.copy(callbacks, label: "callbacks") if callbacks
+      @server_key = [@path, @host, @port].freeze
       Ractor.make_shareable(self)
     end
 
@@ -70,7 +73,7 @@ module SolidRedis
     end
 
     def server_key
-      [path, host, port].freeze
+      @server_key
     end
 
     def server_url
@@ -140,10 +143,10 @@ module SolidRedis
     end
 
     def query_db(uri)
-      return 0 unless uri.query
+      return unless uri.query
 
       value = URI.decode_www_form(uri.query).to_h["db"]
-      value ? Integer(value) : 0
+      Integer(value) if value
     end
 
     def decoded(value)

data/lib/solid_redis/resp.rb

@@ -7,15 +7,23 @@ module SolidRedis
     module_function
 
     def encode(command)
-      command = command.flatten(1)
-      raise ArgumentError, "Redis command cannot be empty" if command.empty?
+      length = command.sum { |argument| argument.is_a?(Array) ? argument.length : 1 }
+      raise ArgumentError, "Redis command cannot be empty" if length.zero?
 
-      command.each_with_object(+"*#{command.length}#{CRLF}") do |argument, buffer|
-        value = encode_argument(argument)
-        buffer << "$#{value.bytesize}#{CRLF}#{value}#{CRLF}"
+      command.each_with_object(+"*#{length}#{CRLF}") do |argument, buffer|
+        if argument.is_a?(Array)
+          argument.each { |value| append_argument(buffer, value) }
+        else
+          append_argument(buffer, argument)
+        end
       end
     end
 
+    def append_argument(buffer, argument)
+      value = encode_argument(argument)
+      buffer << "$#{value.bytesize}#{CRLF}#{value}#{CRLF}"
+    end
+
     def encode_argument(value)
       case value
       when String then value
@@ -32,6 +40,7 @@ module SolidRedis
         @io = io
         @read_timeout = read_timeout
         @buffer = +""
+        @offset = 0
       end
 
       # Temporarily overrides the read timeout. +nil+ waits forever, which is
@@ -49,7 +58,7 @@ module SolidRedis
       # leaves a partially consumed frame behind, so it is the safe way to
       # poll for the next Pub/Sub message.
       def wait_readable(timeout)
-        return true unless @buffer.empty?
+        return true if available_bytes.positive?
         return true unless @io.respond_to?(:to_io)
 
         !IO.select([@io], nil, nil, timeout).nil?
@@ -72,7 +81,7 @@ module SolidRedis
         when "~", ">" then read_collection(exception)
         when "=" then read_verbatim
         when "!" then error_response(read_sized_string, exception)
-        when "|" then read_map(exception) && read(exception: exception)
+        when "|" then read_attribute(exception)
         else raise ProtocolError, "Unknown RESP type byte: #{type.inspect}"
         end
       rescue EOFError
@@ -94,18 +103,46 @@ module SolidRedis
         length = Integer(read_line)
         return if length == -1
 
-        Array.new(length) { read(exception: exception) }
+        finish_collection(Array.new(length) { read(exception: false) }, exception)
       end
 
       def read_collection(exception)
         length = Integer(read_line)
-        Array.new(length) { read(exception: exception) }
+        finish_collection(Array.new(length) { read(exception: false) }, exception)
       end
 
       def read_map(exception)
         length = Integer(read_line)
-        {}.tap do |map|
-          length.times { map[read(exception: exception)] = read(exception: exception) }
+        map = {}.tap do |result|
+          length.times { result[read(exception: false)] = read(exception: false) }
+        end
+        finish_collection(map, exception)
+      end
+
+      def read_attribute(exception)
+        attributes = read_map(false)
+        value = read(exception: false)
+        raise_nested_error(attributes) if exception
+        raise_nested_error(value) if exception
+        value
+      end
+
+      def finish_collection(value, exception)
+        raise_nested_error(value) if exception
+        value
+      end
+
+      def raise_nested_error(value)
+        case value
+        when CommandError
+          raise value
+        when Array
+          value.each { |element| raise_nested_error(element) }
+        when Hash
+          value.each do |key, element|
+            raise_nested_error(key)
+            raise_nested_error(element)
+          end
         end
       end
 
@@ -127,31 +164,50 @@ module SolidRedis
 
       def read_line
         loop do
-          if (index = @buffer.index(CRLF))
-            return @buffer.slice!(0, index + 2).byteslice(0, index)
+          if (index = @buffer.index(CRLF, @offset))
+            value = @buffer.byteslice(@offset, index - @offset)
+            @offset = index + 2
+            clear_consumed_buffer
+            return value
           end
           fill_buffer
         end
       end
 
       def read_bytes(length)
-        fill_buffer while @buffer.bytesize < length
-        @buffer.slice!(0, length)
+        fill_buffer while available_bytes < length
+        value = @buffer.byteslice(@offset, length)
+        @offset += length
+        clear_consumed_buffer
+        value
       end
 
       def fill_buffer
+        compact_buffer
+        wait_for = :readable
+        deadline = nil
         loop do
           if @io.respond_to?(:to_io)
-            unless IO.select([@io], nil, nil, @read_timeout)
-              raise TimeoutError, "Redis read timed out after #{@read_timeout}s"
-            end
-
             chunk = @io.read_nonblock(16_384, exception: false)
           else
             chunk = @io.read(16_384)
           end
 
-          next if chunk == :wait_readable
+          if chunk == :wait_readable || chunk == :wait_writable
+            wait_for = chunk == :wait_readable ? :readable : :writable
+            deadline ||= monotonic_time + @read_timeout if @read_timeout
+            remaining = deadline && deadline - monotonic_time
+            if remaining && remaining <= 0
+              raise TimeoutError, "Redis read timed out after #{@read_timeout}s"
+            end
+
+            readers = wait_for == :readable ? [@io] : nil
+            writers = wait_for == :writable ? [@io] : nil
+            unless IO.select(readers, writers, nil, remaining)
+              raise TimeoutError, "Redis read timed out after #{@read_timeout}s"
+            end
+            next
+          end
           raise EOFError if chunk.nil?
 
           @buffer << chunk
@@ -161,6 +217,28 @@ module SolidRedis
         raise ConnectionError, error.message, cause: error
       end
 
+      def available_bytes
+        @buffer.bytesize - @offset
+      end
+
+      def clear_consumed_buffer
+        return unless @offset == @buffer.bytesize
+
+        @buffer.clear
+        @offset = 0
+      end
+
+      def compact_buffer
+        return if @offset.zero?
+
+        @buffer = @buffer.byteslice(@offset..) || +""
+        @offset = 0
+      end
+
+      def monotonic_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       def error_response(message, exception)
         error = if message.start_with?("NOAUTH", "WRONGPASS")
           AuthenticationError.new(message)

data/lib/solid_redis/subscription.rb

@@ -75,6 +75,9 @@ module SolidRedis
         return unless @reader.wait_readable(timeout)
 
         return decode(@reader.read)
+      rescue ProtocolError => error
+        handle_error(error)
+        raise
       rescue ConnectionError, IO::WaitReadable, IO::WaitWritable, SystemCallError => error
         handle_error(error)
         raise error if attempts >= config.reconnect_attempts
@@ -123,6 +126,9 @@ module SolidRedis
       loop do
         ensure_connected
         return write(RESP.encode(yield))
+      rescue ProtocolError => error
+        handle_error(error)
+        raise
       rescue ConnectionError, IO::WaitReadable, IO::WaitWritable, SystemCallError => error
         handle_error(error)
         raise error if attempts >= config.reconnect_attempts

data/lib/solid_redis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidRedis
-  VERSION = "1.0.2"
+  VERSION = "1.0.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid-redis
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Nicolas Vandenbogaerde
@@ -71,6 +71,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: redis-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.30.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.30.1
+- !ruby/object:Gem::Dependency
+  name: redis-cluster-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
 description: Immutable, shareable Redis, Sentinel and Cluster configuration with isolated
   runtime state, pools, and sockets per Ractor. Supports pipelines, blocking commands,
   and Pub/Sub.
@@ -104,7 +132,7 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-  documentation_uri: https://www.rubydoc.info/gems/solid-redis/1.0.2
+  documentation_uri: https://www.rubydoc.info/gems/solid-redis/1.0.4
   source_code_uri: https://github.com/nicolasva/solid-redis
   changelog_uri: https://github.com/nicolasva/solid-redis/blob/main/CHANGELOG.md
 rdoc_options: []