redis-client-namespace 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b42761a140eeca3fe1fc46feaf42636faafde11bec1aa8144f055c314686806
-  data.tar.gz: 795aa14bf6b0616886b6231fedffd2f23c60901d452f204824a0d1523587a4b1
+  metadata.gz: 1b936795d1c5a2100eccec3e4d0bda4f909dc2c7afa4c6d6585a690efe9d352b
+  data.tar.gz: b86791a8d99b72f3869ec42b1e3fa424b343fb63673abedf9b20d1c2685249ed
 SHA512:
-  metadata.gz: 02cc98329107c65ac11d1e851b277eea83cb520741c82e8d90f8275d4b943163fdc5a7b58806d73f7f4c68151b1b32437050b32b57f8432566a24ad339d95802
-  data.tar.gz: a59cdff0ae554c69cd060a4bfab2062c0e088352b6ffe0afff082c2f8df1ad85ddd93be233588f9c1b61052bbdfd44e6ae0d0596e7652ad5f99a04b9e30a0821
+  metadata.gz: 5b18227306bb697a65ebd78583cc7ac6b1f87ca4281cc82d121f0df9299bfb10e237d56b9e70f31b6ecbcacf749b95f32049dc699c8f0be7bfe62e7b004fe1a5
+  data.tar.gz: 279dc732d7b2a9a692769040e0b6b8ef2de12dbab83638d550d1a4a7e5e47fd5b62cd007e2df8fa00e1f3a7fb8d2706450aa40b865944b966adb3048de1ecaa1

data/.rubocop.yml

@@ -47,13 +47,16 @@ Naming/FileName:
     - 'lib/redis-client-namespace.rb'
 
 # Test helper method for processing Redis commands.json - complexity is justified
+# Also exclude trimed_result method which handles multiple command types
 Metrics/AbcSize:
   Exclude:
     - 'spec/redis_client/namespace/command_builder_auto_spec.rb'
+    - 'lib/redis_client/namespace/command_builder.rb'
 
 Metrics/CyclomaticComplexity:
   Exclude:
     - 'spec/redis_client/namespace/command_builder_auto_spec.rb'
+    - 'lib/redis_client/namespace/command_builder.rb'
 
 Metrics/MethodLength:
   Exclude:
@@ -61,4 +64,5 @@ Metrics/MethodLength:
 
 Metrics/PerceivedComplexity:
   Exclude:
-    - 'spec/redis_client/namespace/command_builder_auto_spec.rb'
+    - 'spec/redis_client/namespace/command_builder_auto_spec.rb'
+    - 'lib/redis_client/namespace/command_builder.rb'

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 ## [Unreleased]
 
+## [0.2.0] - 2025-08-01
+
+### Added
+- Added `RedisClient::Namespace::Middleware` for full namespace support including result processing
+- Added automatic removal of namespace prefixes from command results (KEYS, SCAN, BLPOP, BRPOP)
+- Middleware approach allows proper handling of both command transformation and result trimming
+- Added comprehensive Sidekiq integration tests with Sidekiq::Launcher
+
+### Changed
+- **BREAKING**: Middleware approach is now the recommended way to use RedisClient::Namespace
+- Updated README to focus on middleware usage with comprehensive examples
+- Updated Sidekiq integration examples to use middleware approach
+
+### Deprecated
+- Using `RedisClient::Namespace` as a command_builder is now deprecated
+- The command_builder approach cannot process results to remove namespace prefixes
+- Users should migrate to the middleware approach for complete namespace functionality
+
+### Technical Changes
+- Refactored `namespaced_command` method as a static method in `CommandBuilder` module
+- Added `trimed_result` method for processing command results
+- Enhanced middleware implementation to handle both single commands and pipelined operations
+
+## [0.1.1] - 2025-07-29
+
+- Add `RedisClient::Namespace.command_builder` class method for conditional namespacing based on environment variables
+
 ## [0.1.0] - 2025-07-26
 
 - Initial release

data/README.md

@@ -2,7 +2,7 @@
 
 A Redis namespace extension for [redis-client](https://github.com/redis-rb/redis-client) gem that automatically prefixes Redis keys with a namespace, enabling multi-tenancy and key isolation in Redis applications.
 
-This gem works by wrapping `RedisClient::CommandBuilder` and intercepting Redis commands to transparently add namespace prefixes to keys before they are sent to Redis.
+This gem works by implementing a RedisClient middleware that intercepts Redis commands to transparently add namespace prefixes to keys before they are sent to Redis and removes them from results (with some limitations for certain commands like Pub/Sub events).
 
 ## Motivation
 
@@ -11,10 +11,7 @@ This gem was created to provide namespace support for [Sidekiq](https://github.c
 ## Features
 
 - **Transparent key namespacing**: Automatically prefixes Redis keys with a configurable namespace
-- **Comprehensive command support**: Supports all Redis commands with intelligent key detection
-- **Customizable separator**: Configure the namespace separator (default: `:`)
-- **Nested namespaces**: Support for nested command builders with multiple namespace levels
-- **Zero configuration**: Works out of the box with sensible defaults
+- **Comprehensive command support**: Supports most Redis commands with intelligent key detection
 - **High performance**: Minimal overhead with efficient command transformation
 - **Thread-safe**: Safe for use in multi-threaded applications
 
@@ -40,42 +37,68 @@ gem install redis-client-namespace
 
 ## Usage
 
-### Basic Usage
+### with RedisClient
+
+RedisClient::Namespace is implemented as a [RedisClient middleware](https://github.com/redis-rb/redis-client#instrumentation-and-middlewares) that transparently handles both command transformation and result processing:
 
 ```ruby
 require 'redis-client-namespace'
 
-# Create a namespaced command builder
-namespace = RedisClient::Namespace.new("myapp")
-
-# Use with redis-client
-client = RedisClient.config(command_builder: namespace).new_client
+# Configure RedisClient with the namespace middleware
+client = RedisClient.config(
+  middlewares: [RedisClient::Namespace::Middleware],
+  custom: { namespace: "myapp" }
+).new_client
 
 # All commands will be automatically namespaced
 client.call("SET", "user:123", "john")   # Actually sets "myapp:user:123"
 client.call("GET", "user:123")           # Actually gets "myapp:user:123"
-client.call("DEL", "user:123", "user:456") # Actually deletes "myapp:user:123", "myapp:user:456"
+
+# Commands that return keys will have the namespace automatically removed
+client.call("KEYS", "*")                  # Returns ["user:123"] instead of ["myapp:user:123"]
+client.call("SCAN", 0, "MATCH", "user:*") # Returns keys without namespace prefix
 ```
 
 ### Custom Separator
 
 ```ruby
 # Use a custom separator
-namespace = RedisClient::Namespace.new("myapp", separator: "-")
-client = RedisClient.config(command_builder: namespace).new_client
+client = RedisClient.config(
+  middlewares: [RedisClient::Namespace::Middleware],
+  custom: { namespace: "myapp", separator: "-" }
+).new_client
 
 client.call("SET", "user:123", "john")   # Actually sets "myapp-user:123"
 ```
 
-### Nested Namespaces
+### with Redis (`redis-rb`)
+
+This gem also works with the [redis](https://github.com/redis/redis-rb) gem through its middleware support:
 
 ```ruby
-# Create nested namespaces
-parent = RedisClient::Namespace.new("myapp")
-child = RedisClient::Namespace.new("jobs", parent_command_builder: parent)
+require 'redis'
+require 'redis-client-namespace'
+
+# Use with redis-rb via middleware
+redis = Redis.new(
+  host: 'localhost', 
+  port: 6379,
+  middlewares: [RedisClient::Namespace::Middleware],
+  custom: { namespace: "myapp", separator: ":" }
+)
 
-client = RedisClient.config(command_builder: child).new_client
-client.call("SET", "queue", "important") # Actually sets "jobs:myapp:queue"
+# All commands will be automatically namespaced
+redis.set("user:123", "john")            # Actually sets "myapp:user:123"
+redis.get("user:123")                    # Actually gets "myapp:user:123"
+redis.del("user:123", "user:456")        # Actually deletes "myapp:user:123", "myapp:user:456"
+
+# Works with most Redis commands
+redis.lpush("queue", ["job1", "job2"])   # Actually pushes to "myapp:queue"
+redis.hset("config", "timeout", "30")    # Actually sets in "myapp:config"
+redis.sadd("tags", "ruby", "rails")      # Actually adds to "myapp:tags"
+
+# Pattern matching with automatic namespace removal
+redis.keys("user:*")                     # Returns ["user:123"] instead of ["myapp:user:123"]
 ```
 
 ### Sidekiq Integration
@@ -86,19 +109,19 @@ This gem is particularly useful for Sidekiq applications that need namespace iso
 # In your Sidekiq configuration
 require 'redis-client-namespace'
 
-namespace = RedisClient::Namespace.new("sidekiq_production")
-
 Sidekiq.configure_server do |config|
   config.redis = {
     url: 'redis://redis:6379/1',
-    command_builder: namespace,
+    middlewares: [RedisClient::Namespace::Middleware],
+    custom: { namespace: "sidekiq_production", separator: ":" }
   }
 end
 
 Sidekiq.configure_client do |config|
   config.redis = {
     url: 'redis://redis:6379/1',
-    command_builder: namespace,
+    middlewares: [RedisClient::Namespace::Middleware],
+    custom: { namespace: "sidekiq_production", separator: ":" }
   }
 end
 ```
@@ -120,6 +143,32 @@ RedisClient::Namespace supports the vast majority of Redis commands with intelli
 
 The gem automatically detects which arguments are keys and applies the namespace prefix accordingly.
 
+### Limitations
+
+#### Unknown Commands
+
+Commands not explicitly supported by the gem will generate a warning and be passed through without namespace transformation. This ensures compatibility but means namespace isolation may not work for newer or less common Redis commands.
+
+#### Pub/Sub Events
+
+When using the Middleware approach, Pub/Sub subscribe events (via `pubsub.next_event`) are not automatically processed to remove namespace prefixes from channel names. This is because the middleware doesn't have access to intercept the `next_event` method.
+
+If you're using Pub/Sub with the middleware approach, you'll need to manually handle namespace removal:
+
+```ruby
+# With middleware approach
+pubsub = client.pubsub
+pubsub.call("SUBSCRIBE", "channel1")  # Subscribes to "myapp:channel1"
+
+# You need to manually remove the namespace prefix from received events
+event = pubsub.next_event
+if event && event[0] == "message"
+  channel = event[1].delete_prefix("myapp:")  # Remove namespace manually
+  message = event[2]
+end
+```
+
+
 ## Advanced Features
 
 ### Pattern Matching
@@ -127,11 +176,14 @@ The gem automatically detects which arguments are keys and applies the namespace
 For commands like `SCAN` and `KEYS`, the namespace is automatically applied to patterns:
 
 ```ruby
-namespace = RedisClient::Namespace.new("myapp")
-client = RedisClient.config(command_builder: namespace).new_client
+client = RedisClient.config(
+  middlewares: [RedisClient::Namespace::Middleware],
+  custom: { namespace: "myapp", separator: ":" }
+).new_client
 
 # This will scan for "myapp:user:*" pattern
 client.call("SCAN", 0, "MATCH", "user:*")
+# Returns keys without the namespace prefix for easier handling
 ```
 
 ### Complex Commands
@@ -150,20 +202,21 @@ client.call("EVAL", "return redis.call('get', KEYS[1])", 1, "mykey")
 
 ## Configuration Options
 
+When using the middleware approach, configure via the `custom` option:
+
 - `namespace`: The namespace prefix to use (required)
 - `separator`: The separator between namespace and key (default: `":"`)
-- `parent_command_builder`: Parent command builder for nested namespaces (default: `RedisClient::CommandBuilder`)
 
 ## Thread Safety
 
-RedisClient::Namespace is **thread-safe** and can be used in multi-threaded applications without additional synchronization. The implementation:
+RedisClient::Namespace is **thread-safe** and can be used in multi-threaded applications without additional synchronization. The middleware implementation:
 
-- Uses immutable instance variables (`@namespace`, `@separator`, `@parent_command_builder`) that are set once during initialization
-- Never modifies shared state during command processing
-- Creates new command arrays for each operation without mutating the original
+- Reads configuration from `redis_config.custom` without maintaining any state
+- Uses class methods in `CommandBuilder` that don't modify shared state
+- Each call receives its own command array from RedisClient, avoiding shared mutable state
 - Uses frozen constants for strategy and command mappings
 
-Each `generate` call is completely independent, making it safe to use the same namespace instance across multiple threads.
+Each middleware call is completely independent, making it safe to use the same middleware across multiple threads and connections.
 
 ## Performance
 
@@ -212,4 +265,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the RedisClient::Namespace project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ken39arg/redis-client-namespace/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the RedisClient::Namespace project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ken39arg/redis-client-namespace/blob/main/CODE_OF_CONDUCT.md).

data/benchmark/README.md

@@ -0,0 +1,47 @@
+# Benchmarks
+
+This directory contains performance benchmarks comparing `redis-client-namespace` with the traditional `redis-namespace` gem.
+
+## Running Benchmarks
+
+### Prerequisites
+
+First, install the benchmark dependencies:
+
+```bash
+bundle install --with benchmark
+```
+
+### Redis Namespace Comparison
+
+To run the benchmark comparing `redis-namespace` vs `redis-client-namespace`:
+
+```bash
+# Using default Redis (localhost:6379)
+ruby benchmark/redis_namespace_comparison.rb
+
+# Using custom Redis server
+REDIS_HOST=localhost REDIS_PORT=16379 ruby benchmark/redis_namespace_comparison.rb
+```
+
+This benchmark tests various Redis operations:
+- Single key operations (SET, GET)
+- Multiple key operations (MGET)
+- List operations (LPUSH, LRANGE)
+- Hash operations (HSET, HGETALL)
+- Set operations (SADD, SMEMBERS)
+- Pattern matching (KEYS)
+- Complex operations (ZRANGE)
+- Transactions (MULTI/EXEC)
+
+## Expected Results
+
+The `redis-client-namespace` gem is designed to have minimal overhead compared to `redis-namespace`. The benchmarks help verify that the performance characteristics are comparable or better across different types of Redis operations.
+
+## Adding New Benchmarks
+
+To add new benchmarks:
+1. Create a new Ruby file in this directory
+2. Use `benchmark-ips` for consistent measurement
+3. Include warm-up phases to ensure fair comparison
+4. Test a variety of Redis operations relevant to your use case

data/benchmark/redis_namespace_comparison.rb

@@ -0,0 +1,238 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "benchmark/ips"
+require "redis"
+require "redis-namespace"
+require "redis-client-namespace"
+
+# Setup Redis connections
+REDIS_HOST = ENV.fetch("REDIS_HOST", "127.0.0.1")
+REDIS_PORT = ENV.fetch("REDIS_PORT", "6379")
+REDIS_DB = ENV.fetch("REDIS_DB", "0")
+
+puts "Redis Namespace Benchmark: redis-namespace vs redis-client-namespace"
+puts "=" * 70
+puts "Testing with redis-rb (Redis.new)"
+puts "Redis: #{REDIS_HOST}:#{REDIS_PORT}/#{REDIS_DB}"
+puts "=" * 70
+
+# Create Redis clients
+plain_redis = Redis.new(host: REDIS_HOST, port: REDIS_PORT, db: REDIS_DB)
+
+# redis-namespace (traditional approach)
+redis_namespace = Redis::Namespace.new("bench_old", redis: plain_redis)
+
+# redis-client-namespace (new approach)
+redis_client_namespace = Redis.new(
+  host: REDIS_HOST,
+  port: REDIS_PORT,
+  db: REDIS_DB,
+  middlewares: [RedisClient::Namespace::Middleware],
+  custom: { namespace: "bench_new" }
+)
+
+# Clean up before benchmark
+plain_redis.flushdb
+
+# Warm up
+redis_namespace.set("warmup", "value")
+redis_client_namespace.set("warmup", "value")
+redis_namespace.get("warmup")
+redis_client_namespace.get("warmup")
+
+puts "\n## Single Key Operations"
+puts
+
+Benchmark.ips do |x|
+  x.report("redis-namespace SET") do
+    redis_namespace.set("key", "value")
+  end
+
+  x.report("redis-client-namespace SET") do
+    redis_client_namespace.set("key", "value")
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("redis-namespace GET") do
+    redis_namespace.get("key")
+  end
+
+  x.report("redis-client-namespace GET") do
+    redis_client_namespace.get("key")
+  end
+
+  x.compare!
+end
+
+puts "\n## Multiple Key Operations"
+puts
+
+# Prepare data for MGET
+10.times { |i| redis_namespace.set("mkey#{i}", "value#{i}") }
+10.times { |i| redis_client_namespace.set("mkey#{i}", "value#{i}") }
+
+keys = (0...10).map { |i| "mkey#{i}" }
+
+Benchmark.ips do |x|
+  x.report("redis-namespace MGET") do
+    redis_namespace.mget(*keys)
+  end
+
+  x.report("redis-client-namespace MGET") do
+    redis_client_namespace.mget(*keys)
+  end
+
+  x.compare!
+end
+
+puts "\n## List Operations"
+puts
+
+Benchmark.ips do |x|
+  x.report("redis-namespace LPUSH") do
+    redis_namespace.lpush("list", %w[item1 item2])
+  end
+
+  x.report("redis-client-namespace LPUSH") do
+    redis_client_namespace.lpush("list", %w[item1 item2])
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("redis-namespace LRANGE") do
+    redis_namespace.lrange("list", 0, -1)
+  end
+
+  x.report("redis-client-namespace LRANGE") do
+    redis_client_namespace.lrange("list", 0, -1)
+  end
+
+  x.compare!
+end
+
+puts "\n## Hash Operations"
+puts
+
+Benchmark.ips do |x|
+  x.report("redis-namespace HSET") do
+    redis_namespace.hset("hash", "field1", "value1", "field2", "value2")
+  end
+
+  x.report("redis-client-namespace HSET") do
+    redis_client_namespace.hset("hash", "field1", "value1", "field2", "value2")
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("redis-namespace HGETALL") do
+    redis_namespace.hgetall("hash")
+  end
+
+  x.report("redis-client-namespace HGETALL") do
+    redis_client_namespace.hgetall("hash")
+  end
+
+  x.compare!
+end
+
+puts "\n## Set Operations"
+puts
+
+Benchmark.ips do |x|
+  x.report("redis-namespace SADD") do
+    redis_namespace.sadd("set", %w[member1 member2])
+  end
+
+  x.report("redis-client-namespace SADD") do
+    redis_client_namespace.sadd("set", %w[member1 member2])
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("redis-namespace SMEMBERS") do
+    redis_namespace.smembers("set")
+  end
+
+  x.report("redis-client-namespace SMEMBERS") do
+    redis_client_namespace.smembers("set")
+  end
+
+  x.compare!
+end
+
+puts "\n## Pattern Matching"
+puts
+
+# Create some keys for pattern matching
+10.times { |i| redis_namespace.set("user:#{i}", "value#{i}") }
+10.times { |i| redis_client_namespace.set("user:#{i}", "value#{i}") }
+
+Benchmark.ips do |x|
+  x.report("redis-namespace KEYS") do
+    redis_namespace.keys("user:*")
+  end
+
+  x.report("redis-client-namespace KEYS") do
+    redis_client_namespace.keys("user:*")
+  end
+
+  x.compare!
+end
+
+puts "\n## Complex Operations"
+puts
+
+# Prepare sorted set data
+redis_namespace.zadd("zset", [[1, "member1"], [2, "member2"], [3, "member3"]])
+redis_client_namespace.zadd("zset", [[1, "member1"], [2, "member2"], [3, "member3"]])
+
+Benchmark.ips do |x|
+  x.report("redis-namespace ZRANGE") do
+    redis_namespace.zrange("zset", 0, -1)
+  end
+
+  x.report("redis-client-namespace ZRANGE") do
+    redis_client_namespace.zrange("zset", 0, -1)
+  end
+
+  x.compare!
+end
+
+# Transactions
+puts "\n## Transactions"
+puts
+
+Benchmark.ips do |x|
+  x.report("redis-namespace MULTI") do
+    redis_namespace.multi do |r|
+      r.set("tx_key1", "value1")
+      r.set("tx_key2", "value2")
+    end
+  end
+
+  x.report("redis-client-namespace MULTI") do
+    redis_client_namespace.multi do |r|
+      r.set("tx_key1", "value1")
+      r.set("tx_key2", "value2")
+    end
+  end
+
+  x.compare!
+end
+
+# Clean up
+plain_redis.flushdb
+
+puts "\n#{"=" * 70}"
+puts "Benchmark completed!"

data/benchmark/results.md

@@ -0,0 +1,90 @@
+# Benchmark Results: redis-namespace vs redis-client-namespace
+
+Date: 2025-07-31 (Updated with middleware implementation)
+
+## Test Environment
+
+- Ruby: 3.4.5 (2025-07-16 revision 20cda200d3) +PRISM [arm64-darwin24]
+- Redis: 127.0.0.1:16379
+- Library versions:
+  - redis-namespace: 1.11.0
+  - redis-client-namespace: (current development version)
+
+## Summary
+
+The benchmarks show that `redis-client-namespace` with the new middleware-based architecture performs excellently compared to `redis-namespace`. The middleware implementation has achieved performance parity or slight improvements across all tested operations, with performance differences consistently falling within the margin of error. This demonstrates that the middleware pattern successfully maintains high performance while providing cleaner architecture.
+
+## Detailed Results
+
+### Single Key Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| SET | 4,153.9 i/s | 4,206.5 i/s | Same-ish (within error) |
+| GET | 4,213.9 i/s | 4,283.6 i/s | Same-ish (within error) |
+
+### Multiple Key Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| MGET (10 keys) | 3,993.6 i/s | 4,011.5 i/s | Same-ish (within error) |
+
+### List Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| LPUSH | 4,004.2 i/s | 4,042.7 i/s | Same-ish (within error) |
+| LRANGE | 52.5 i/s | 53.0 i/s | Same-ish (within error) |
+
+### Hash Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| HSET | 4,178.2 i/s | 4,149.7 i/s | Same-ish (within error) |
+| HGETALL | 4,147.0 i/s | 4,090.2 i/s | Same-ish (within error) |
+
+### Set Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| SADD | 3,958.2 i/s | 4,048.4 i/s | Same-ish (within error) |
+| SMEMBERS | 4,129.4 i/s | 4,200.5 i/s | Same-ish (within error) |
+
+### Pattern Matching
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| KEYS | 3,911.4 i/s | 4,049.3 i/s | Same-ish (within error) |
+
+### Complex Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| ZRANGE | 4,215.8 i/s | 4,261.9 i/s | Same-ish (within error) |
+
+### Transactions
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| MULTI/EXEC | 3,941.1 i/s | 4,022.1 i/s | Same-ish (within error) |
+
+## Key Observations
+
+1. **Excellent Performance**: The middleware-based `redis-client-namespace` shows consistently strong performance, often matching or slightly exceeding `redis-namespace` performance across all operations.
+
+2. **Middleware Architecture Success**: The new middleware pattern successfully maintains high performance while providing cleaner, more maintainable code architecture. The abstraction layer introduces virtually no performance penalty.
+
+3. **Significant Performance Improvements**: Compared to previous benchmarks, the middleware implementation shows substantial improvements - throughput has roughly doubled across most operations (from ~2k i/s to ~4k i/s range).
+
+4. **Consistent High Performance**: Both libraries now operate in the 4,000+ i/s range for most operations, demonstrating excellent performance characteristics across different Redis operation types.
+
+5. **Production Ready**: The benchmark results confirm that the middleware-based `redis-client-namespace` is highly suitable for production use, offering both superior architecture and excellent performance.
+
+## Notes
+
+- All comparisons marked as "same-ish" indicate that the performance difference falls within the statistical margin of error
+- The benchmarks used `benchmark-ips` for accurate measurements with proper warm-up periods
+- Each operation was warmed up before measurement to ensure fair comparison
+- LRANGE operations show lower throughput (~53 i/s) due to the large amount of data being transferred, but this is expected behavior
+- The middleware implementation demonstrates that architectural improvements don't require performance sacrifices
+- Performance improvements may also be attributed to Ruby 3.4.5 optimizations and updated testing environment

data/lib/redis_client/namespace/command_builder.rb

@@ -440,30 +440,36 @@ class RedisClient
 
       }.freeze
 
-      def generate(args, kwargs = nil)
-        command = @parent_command_builder.generate(args, kwargs)
-        return command if @namespace.nil? || @namespace.empty? || command.size < 2
+      def self.namespaced_command(command, namespace: nil, separator: ":")
+        return command if namespace.nil? || namespace.empty? || command.size < 2
 
         cmd_name = command[0].to_s.upcase
         strategy = COMMANDS[cmd_name]
 
         # Raise error for unknown commands to maintain compatibility with redis-namespace
         unless strategy
-          raise(::RedisClient::Namespace::Error,
-                "RedisClient::Namespace does not know how to handle '#{cmd_name}'.")
+          warn("RedisClient::Namespace does not know how to handle '#{cmd_name}'.")
+          return command
         end
 
-        STRATEGIES[strategy].call(command) { |key| rename_key(key) }
+        prefix = "#{namespace}#{separator}"
+        STRATEGIES[strategy].call(command) { |key| key.start_with?(prefix) ? key : "#{prefix}#{key}" }
 
         command
       end
 
-      private
-
-      def rename_key(key)
-        return key if @namespace.nil? || @namespace.empty?
-
-        "#{@namespace}#{@separator}#{key}"
+      def self.trimed_result(command, result, namespace: nil, separator: ":")
+        return command if namespace.nil? || namespace.empty? || command.size < 2
+
+        prefix = "#{namespace}#{separator}"
+        case command[0].to_s.upcase
+        when "SCAN"
+          result[1].map { |r| r.delete_prefix!(prefix) } if result.size > 1
+        when "KEYS"
+          result.map { |r| r.delete_prefix!(prefix) }
+        when "BLPOP", "BRPOP"
+          result[0].delete_prefix!(prefix) unless result.nil? || result.empty?
+        end
       end
     end
   end

data/lib/redis_client/namespace/middleware.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "command_builder"
+
+class RedisClient
+  class Namespace
+    # Middleware for RedisClient to add namespace support
+    #
+    # This module implements the RedisClient middleware interface to intercept
+    # Redis commands and apply namespace transformations. It automatically prefixes
+    # keys with a namespace and removes the prefix from certain command results.
+    #
+    # @see https://github.com/redis-rb/redis-client/blob/master/README.md#instrumentation-and-middlewares
+    #
+    # @example Basic usage with RedisClient
+    #   client = RedisClient.config(
+    #     middlewares: [RedisClient::Namespace::Middleware],
+    #     custom: { namespace: "myapp", separator: ":" }
+    #   ).new_client
+    #
+    #   client.call("SET", "key", "value")  # Actually sets "myapp:key"
+    #   client.call("GET", "key")           # Gets "myapp:key" and returns "value"
+    #
+    # The middleware requires the following custom configuration:
+    # - namespace: The namespace prefix to apply (required)
+    # - separator: The separator between namespace and key (optional, default: ":")
+    module Middleware
+      def call(command, redis_config)
+        namespace = redis_config.custom[:namespace] or return super
+        separator = redis_config.custom[:separator] || ":"
+        command = CommandBuilder.namespaced_command(command, namespace: namespace, separator: separator)
+        super.tap do |result|
+          CommandBuilder.trimed_result(command, result, namespace: namespace, separator: separator)
+        end
+      end
+
+      def call_pipelined(commands, redis_config)
+        namespace = redis_config.custom[:namespace] or return super
+        separator = redis_config.custom[:separator] || ":"
+        commands = commands.map do |cmd|
+          CommandBuilder.namespaced_command(cmd, namespace: namespace, separator: separator)
+        end
+        super.tap do |results|
+          commands.each_with_index do |command, i|
+            CommandBuilder.trimed_result(command, results[i], namespace: namespace, separator: separator)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/namespace/version.rb

@@ -2,6 +2,6 @@
 
 class RedisClient
   class Namespace
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/lib/redis_client/namespace.rb

@@ -3,26 +3,34 @@
 require "redis-client"
 require_relative "namespace/version"
 require_relative "namespace/command_builder"
+require_relative "namespace/middleware"
 
 class RedisClient
   # RedisClient::Namespace provides transparent key namespacing for redis-client.
   #
-  # It works by intercepting Redis commands and prefixing keys with a namespace,
-  # allowing multiple applications or components to share a single Redis instance
-  # without key collisions.
+  # **DEPRECATED**: Using this class as a command_builder is deprecated.
+  # Please use RedisClient::Namespace::Middleware instead for full namespace support
+  # including automatic removal of namespace prefixes from command results.
   #
-  # @example Basic usage
-  #   builder = RedisClient::Namespace.new("myapp")
-  #   client = RedisClient.new(command_builder: builder)
+  # The command_builder approach only transforms outgoing commands but cannot
+  # process incoming results to remove namespace prefixes from keys returned by
+  # commands like KEYS, SCAN, BLPOP, etc.
+  #
+  # @deprecated Use {RedisClient::Namespace::Middleware} instead
+  # @example Recommended middleware approach
+  #   client = RedisClient.config(
+  #     middlewares: [RedisClient::Namespace::Middleware],
+  #     custom: { namespace: "myapp", separator: ":" }
+  #   ).new_client
   #   client.call("SET", "key", "value")  # Actually sets "myapp:key"
+  #   client.call("KEYS", "*")            # Returns ["key"] instead of ["myapp:key"]
   #
-  # @example Custom separator
-  #   builder = RedisClient::Namespace.new("myapp", separator: "-")
+  # @example Legacy command_builder usage (not recommended)
+  #   builder = RedisClient::Namespace.new("myapp")
   #   client = RedisClient.new(command_builder: builder)
-  #   client.call("SET", "key", "value")  # Actually sets "myapp-key"
+  #   client.call("SET", "key", "value")  # Actually sets "myapp:key"
+  #   client.call("KEYS", "*")            # Returns ["myapp:key"] - namespace not removed
   class Namespace
-    include RedisClient::Namespace::CommandBuilder
-
     class Error < StandardError; end
 
     attr_reader :namespace, :separator, :parent_command_builder
@@ -32,5 +40,10 @@ class RedisClient
       @separator = separator
       @parent_command_builder = parent_command_builder
     end
+
+    def generate(args, kwargs = nil)
+      CommandBuilder.namespaced_command(@parent_command_builder.generate(args, kwargs), namespace: @namespace,
+                                                                                        separator: @separator)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-client-namespace
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kensaku Araga
@@ -38,10 +38,14 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmark/README.md
+- benchmark/redis_namespace_comparison.rb
+- benchmark/results.md
 - compose.yml
 - lib/redis-client-namespace.rb
 - lib/redis_client/namespace.rb
 - lib/redis_client/namespace/command_builder.rb
+- lib/redis_client/namespace/middleware.rb
 - lib/redis_client/namespace/version.rb
 homepage: https://github.com/ken39arg/redis-client-namespace
 licenses: