redis-client-namespace 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b42761a140eeca3fe1fc46feaf42636faafde11bec1aa8144f055c314686806
-  data.tar.gz: 795aa14bf6b0616886b6231fedffd2f23c60901d452f204824a0d1523587a4b1
+  metadata.gz: 7e13d5a883c2e2dd430843640140758704e128296ddd3ff65c7eddae15a6b98e
+  data.tar.gz: 22f7e62d0ccc6d1d2c4b0c888f0985a4e431ede0eb4730f356f7a1a788a1796f
 SHA512:
-  metadata.gz: 02cc98329107c65ac11d1e851b277eea83cb520741c82e8d90f8275d4b943163fdc5a7b58806d73f7f4c68151b1b32437050b32b57f8432566a24ad339d95802
-  data.tar.gz: a59cdff0ae554c69cd060a4bfab2062c0e088352b6ffe0afff082c2f8df1ad85ddd93be233588f9c1b61052bbdfd44e6ae0d0596e7652ad5f99a04b9e30a0821
+  metadata.gz: d46cda192df4c1623c8eeb92ec9b2ade00a59a9f26908a115083d29066129d6a80f96e8f6f814d60973ef419e570d0ce68f5772659e1ff133548ed16acd29fc3
+  data.tar.gz: 626cea93d4bc9e245ced597235cab8b833a05ad2bdcc3c25aae06dce41e5131df59d55b76186b3fced8cf40167ed95cee0c0b75fbe54fa3f6ba52d43e88deb71

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [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

@@ -78,6 +78,34 @@ client = RedisClient.config(command_builder: child).new_client
 client.call("SET", "queue", "important") # Actually sets "jobs:myapp:queue"
 ```
 
+### with `Redis` ([`redis-rb`](https://github.com/redis/redis-rb)) 
+
+This gem also works with the [redis](https://github.com/redis/redis-rb) gem through its `command_builder` option:
+
+```ruby
+require 'redis'
+require 'redis-client-namespace'
+
+# Create a namespaced command builder
+namespace = RedisClient::Namespace.new("myapp")
+
+# Use with redis-rb
+redis = Redis.new(host: 'localhost', port: 6379, command_builder: namespace)
+
+# 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 all 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
+redis.keys("user:*")                     # Actually searches for "myapp:user:*"
+```
+
 ### Sidekiq Integration
 
 This gem is particularly useful for Sidekiq applications that need namespace isolation:
@@ -212,4 +240,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,233 @@
+#!/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)
+namespace_builder = RedisClient::Namespace.new("bench_new")
+redis_client_namespace = Redis.new(host: REDIS_HOST, port: REDIS_PORT, db: REDIS_DB, command_builder: namespace_builder)
+
+# 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,86 @@
+# Benchmark Results: redis-namespace vs redis-client-namespace
+
+Date: 2025-07-29
+
+## 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` performs comparably to `redis-namespace` across all tested operations. In most cases, the performance difference falls within the margin of error, indicating that the new implementation introduces minimal overhead.
+
+## Detailed Results
+
+### Single Key Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| SET | 2,045.7 i/s | 2,093.9 i/s | Same-ish (within error) |
+| GET | 2,516.3 i/s | 2,473.3 i/s | Same-ish (within error) |
+
+### Multiple Key Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| MGET (10 keys) | 2,386.6 i/s | 2,440.0 i/s | Same-ish (within error) |
+
+### List Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| LPUSH | 2,264.6 i/s | 2,198.1 i/s | Same-ish (within error) |
+| LRANGE | 64.4 i/s | 67.7 i/s | Same-ish (within error) |
+
+### Hash Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| HSET | 2,660.7 i/s | 2,326.5 i/s | Same-ish (within error) |
+| HGETALL | 2,299.9 i/s | 2,886.9 i/s | Same-ish (within error) |
+
+### Set Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| SADD | 1,421.5 i/s | 2,536.3 i/s | Same-ish (within error) |
+| SMEMBERS | 2,860.3 i/s | 2,945.3 i/s | Same-ish (within error) |
+
+### Pattern Matching
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| KEYS | 2,137.0 i/s | 2,502.2 i/s | Same-ish (within error) |
+
+### Complex Operations
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| ZRANGE | 2,908.9 i/s | 2,506.6 i/s | Same-ish (within error) |
+
+### Transactions
+
+| Operation | redis-namespace | redis-client-namespace | Comparison |
+|-----------|----------------|----------------------|------------|
+| MULTI/EXEC | 2,039.9 i/s | 1,685.0 i/s | Same-ish (within error) |
+
+## Key Observations
+
+1. **Performance Parity**: `redis-client-namespace` maintains performance parity with `redis-namespace` across all tested operations.
+
+2. **No Significant Overhead**: The new architecture based on `RedisClient::CommandBuilder` doesn't introduce significant overhead compared to the traditional approach.
+
+3. **Consistent Performance**: Both libraries show consistent performance characteristics across different types of Redis operations.
+
+4. **Production Ready**: The benchmark results indicate that `redis-client-namespace` is suitable for production use as a drop-in replacement for `redis-namespace` when using `redis-rb`.
+
+## 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
+- Each operation was warmed up before measurement to ensure fair comparison
+- LRANGE operations show lower throughput due to the large amount of data being transferred

data/lib/redis_client/namespace/version.rb

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

data/lib/redis_client/namespace.rb

@@ -32,5 +32,42 @@ class RedisClient
       @separator = separator
       @parent_command_builder = parent_command_builder
     end
+
+    # Creates a command builder that conditionally applies namespacing.
+    #
+    # If the namespace is nil or empty, returns the parent_command_builder directly,
+    # effectively disabling namespacing. Otherwise, creates a new Namespace instance.
+    #
+    # This is particularly useful for environment-based configuration where you want
+    # to enable/disable namespacing based on environment variables.
+    #
+    # @param namespace [String, nil] The namespace to use. If nil or empty, namespacing is disabled
+    # @param separator [String] The separator between namespace and key (default: ":")
+    # @param parent_command_builder [Object] The parent command builder to use (default: RedisClient::CommandBuilder)
+    # @return [Object] Either a Namespace instance or the parent_command_builder
+    #
+    # @example Environment-based namespacing
+    #   # Enable namespacing only when REDIS_NAMESPACE is set
+    #   builder = RedisClient::Namespace.command_builder(ENV.fetch("REDIS_NAMESPACE", ""))
+    #   client = RedisClient.new(command_builder: builder)
+    #
+    #   # With REDIS_NAMESPACE=myapp: keys will be prefixed with "myapp:"
+    #   # With REDIS_NAMESPACE="" or unset: no namespacing applied
+    #
+    # @example Sidekiq configuration
+    #   Sidekiq.configure_server do |config|
+    #     config.redis = {
+    #       url: 'redis://localhost:6379/1',
+    #       command_builder: RedisClient::Namespace.command_builder(ENV.fetch("REDIS_NAMESPACE", ""))
+    #     }
+    #   end
+    def self.command_builder(namespace = "", separator: ":", parent_command_builder: RedisClient::CommandBuilder)
+      if namespace.nil? || namespace.empty?
+        parent_command_builder
+      else
+        new(namespace, separator: separator,
+                       parent_command_builder: parent_command_builder)
+      end
+    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.1.1
 platform: ruby
 authors:
 - Kensaku Araga
@@ -38,6 +38,9 @@ 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