rails-brotli-cache 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38153c74bf09ef2a13760b3dea18a3a3e97790104b1af8a8d244ee104d0ad34e
-  data.tar.gz: ed7760dd1e7373fa7e855f57ec7082a185f68b114e43bd051d29fb4be7619020
+  metadata.gz: 6267cfdccacd5e402e500f1df681e16e8d0be371718e499d0abde30c64822dbd
+  data.tar.gz: 4648a2053526200a231c8cd36632715700a6ee197f672431ed2de1c150e036eb
 SHA512:
-  metadata.gz: dc9430106e033158f55f6421d42253a8aaec9b62833687538a289010e8b67b1ffc4a75ba0b71071e5925b7256d2d070b5930719ebd40d5a60f28dc6d7cd4cd19
-  data.tar.gz: 47483feabfac21321eb6e4e6a0df6d5ffa8646261dbeb7b728897f3026f4deff699e682a4cf525f8cca79b824082173637baf9517d8e96c3cfd91aaf9b0b3291
+  metadata.gz: 3dfdbc83794444e9be00962b4b5f6470f5c8803340cabbe3535f7143c87cc3bb21af6340d226e8b4b647cf6fd02a1318376daf98f4c50baa4707c70bcacca463
+  data.tar.gz: a8baf1bb1409642f3ea7e6251970a9fb8fbf1b3bbf6dade72a77f288d24de3f58fa2d00b36f24b4c82908a8f6e510564f9265b106297dcc1ddd7500b9c4f7306

data/README.md

@@ -9,7 +9,7 @@ You can check out [this blog post](https://pawelurbanek.com/rails-brotli-cache)
 `Gemfile`
 
 ```ruby
-  gem 'brotli' # brotli is an optional dependency because other compressors are supported
+  gem 'brotli' # an optional dependency, other compressors are supported
   gem 'rails-brotli-cache'
 ```
 
@@ -139,10 +139,21 @@ config.cache_store = RailsBrotliCache::Store.new(
 ```
 
 ```ruby
+
+class ZSTDCompressor
+  def self.deflate(payload)
+    ::Zstd.compress(payload, 10)
+  end
+
+  def self.inflate(payload)
+    ::Zstd.decompress(payload)
+  end
+end
+
 Rails.cache.write('test-key', json, compressor_class: Snappy)
 ```
 
-This config expects a class which defines two class methods `inflate` and `deflate`. It allows you to instead use for example a [Google Snappy algorithm](https://github.com/miyucy/snappy) offering even better performance for the cost of worse compresion ratios. Optionally, you can define a custom class wrapping any compression library.
+This config expects a class that defines two methods, `inflate` and `deflate`. It allows to use, for example, a [ZSTD by Facebook](https://github.com/SpringMT/zstd-ruby), offering even better performance and compression.
 
 ## Testing
 

data/benchmarks/Gemfile

@@ -1,5 +1,7 @@
 source 'https://rubygems.org'
 
+gem 'brotli'
 gem 'rails-brotli-cache', path: "../"
 gem 'redis'
 gem 'dalli'
+gem 'zstd-ruby'

data/benchmarks/main.rb

@@ -1,31 +1,62 @@
 require 'active_support'
 require 'active_support/core_ext/hash'
 require 'net/http'
+require 'brotli'
 require 'rails-brotli-cache'
 require 'benchmark'
+require 'zstd-ruby'
+
+class ZSTDCompressor
+  def self.deflate(payload)
+    ::Zstd.compress(payload, 10)
+  end
+
+  def self.inflate(payload)
+    ::Zstd.decompress(payload)
+  end
+end
 
 memory_cache = ActiveSupport::Cache::MemoryStore.new(compress: true) # memory store does not use compression by default
 brotli_memory_cache = RailsBrotliCache::Store.new(memory_cache)
+zstd_memory_cache = RailsBrotliCache::Store.new(memory_cache, compressor_class: ZSTDCompressor, prefix: "zs-")
+
 redis_cache = ActiveSupport::Cache::RedisCacheStore.new
 brotli_redis_cache = RailsBrotliCache::Store.new(redis_cache)
+zstd_redis_cache = RailsBrotliCache::Store.new(redis_cache, compressor_class: ZSTDCompressor, prefix: "zs-")
+
 memcached_cache = ActiveSupport::Cache::MemCacheStore.new
 brotli_memcached_cache = RailsBrotliCache::Store.new(memcached_cache)
+zstd_memcached_cache = RailsBrotliCache::Store.new(memcached_cache, compressor_class: ZSTDCompressor, prefix: "zs-")
+
 file_cache = ActiveSupport::Cache::FileStore.new('/tmp')
 brotli_file_cache = RailsBrotliCache::Store.new(file_cache)
+zstd_file_cache = RailsBrotliCache::Store.new(file_cache, compressor_class: ZSTDCompressor, prefix: "zs-")
 
 json_uri = URI("https://raw.githubusercontent.com/pawurb/rails-brotli-cache/main/spec/fixtures/sample.json")
 json = Net::HTTP.get(json_uri)
 
 puts "Uncompressed JSON size: #{json.size}"
 redis_cache.write("gz-json", json)
-gzip_json_size = redis_cache.redis.get("gz-json").size
+gzip_json_size = redis_cache.redis.with do |conn|
+  conn.get("gz-json").size
+end
 puts "Gzip JSON size: #{gzip_json_size}"
 brotli_redis_cache.write("json", json)
-br_json_size = redis_cache.redis.get("br-json").size
+br_json_size = redis_cache.redis.with do |conn|
+  conn.get("br-json").size
+end
 puts "Brotli JSON size: #{br_json_size}"
 puts "~#{((gzip_json_size - br_json_size).to_f / gzip_json_size.to_f * 100).round}% improvment"
 puts ""
 
+zstd_redis_cache.write("json", json)
+zs_json_size = redis_cache.redis.with do |conn|
+  conn.get("zs-json").size
+end
+puts "ZSTD JSON size: #{zs_json_size}"
+puts "~#{((gzip_json_size - zs_json_size).to_f / gzip_json_size.to_f * 100).round}% improvment"
+puts ""
+
 iterations = 100
 
 Benchmark.bm do |x|
@@ -43,6 +74,13 @@ Benchmark.bm do |x|
     end
   end
 
+  x.report("zstd_memory_cache") do
+    iterations.times do
+      zstd_memory_cache.write("test", json)
+      zstd_memory_cache.read("test")
+    end
+  end
+
   x.report("redis_cache") do
     iterations.times do
       redis_cache.write("test", json)
@@ -57,6 +95,13 @@ Benchmark.bm do |x|
     end
   end
 
+  x.report("zstd_redis_cache") do
+    iterations.times do
+      zstd_redis_cache.write("test", json)
+      zstd_redis_cache.read("test")
+    end
+  end
+
   x.report("memcached_cache") do
     iterations.times do
       memcached_cache.write("test", json)
@@ -71,6 +116,13 @@ Benchmark.bm do |x|
     end
   end
 
+  x.report("zstd_memcached_cache") do
+    iterations.times do
+      zstd_memcached_cache.write("test", json)
+      zstd_memcached_cache.read("test")
+    end
+  end
+
   x.report("file_cache") do
     iterations.times do
       file_cache.write("test", json)
@@ -84,4 +136,11 @@ Benchmark.bm do |x|
       brotli_file_cache.read("test")
     end
   end
+
+  x.report("zstd_file_cache") do
+    iterations.times do
+      zstd_file_cache.write("test", json)
+      zstd_file_cache.read("test")
+    end
+  end
 end

data/lib/rails-brotli-cache/store.rb

@@ -109,14 +109,21 @@ module RailsBrotliCache
 
     def fetch_multi(*names)
       options = names.extract_options!
-      names = names.map { |name| expanded_cache_key(name) }
+      expanded_names = names.map { |name| expanded_cache_key(name) }
       options = options.reverse_merge(@init_options)
 
-      @core_store.fetch_multi(
-        *names, options.merge(compress: false)
-      ) do |name|
-        compressed(yield(name), options)
+      reads   = core_store.send(:read_multi_entries, expanded_names, **options)
+      reads.map do |key, val|
+        [source_cache_key(key), uncompressed(val, options)]
+      end.to_h
+
+      writes  = {}
+      ordered = names.index_with do |name|
+        reads.fetch(name) { writes[name] = yield(name) }
       end
+
+      write_multi(writes)
+      ordered
     end
 
     def exist?(name, options = {})

data/lib/rails-brotli-cache/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsBrotliCache
-  VERSION = "0.6.0"
+  VERSION = "0.6.2"
 end

data/spec/rails-brotli-cache/compatibility_spec.rb

@@ -13,6 +13,15 @@ describe RailsBrotliCache do
   ]
 
   CACHE_STORE_TYPES.each do |cache_store_types|
+    let(:big_enough_to_compress_value) do
+      SecureRandom.hex(2048)
+    end
+
+    after do
+      brotli_store.clear
+      standard_cache.clear
+    end
+
     describe "Brotli cache has the same API as #{cache_store_types[0].class}" do
       subject(:brotli_store) do
         RailsBrotliCache::Store.new(cache_store_types[0])
@@ -35,12 +44,12 @@ describe RailsBrotliCache do
         expect(brotli_store.write("int_val_key", int_val).class).to eq(standard_cache.write("int_val_key", int_val).class)
         expect(brotli_store.read("int_val_key")).to eq(standard_cache.read("int_val_key"))
 
-        str_val = "str"
-        expect(brotli_store.write("str_val_key", int_val).class).to eq(standard_cache.write("str_val_key", int_val).class)
+        str_val = big_enough_to_compress_value
+        expect(brotli_store.write("str_val_key", str_val).class).to eq(standard_cache.write("str_val_key", str_val).class)
         expect(brotli_store.read("str_val_key")).to eq(standard_cache.read("str_val_key"))
 
         complex_val = OpenStruct.new(a: 1, b: 2)
-        expect(brotli_store.write("complex_val_key", int_val).class).to eq(standard_cache.write("complex_val_key", int_val).class)
+        expect(brotli_store.write("complex_val_key", complex_val).class).to eq(standard_cache.write("complex_val_key", complex_val).class)
         expect(brotli_store.read("complex_val_key")).to eq(standard_cache.read("complex_val_key"))
       end
 
@@ -55,15 +64,14 @@ describe RailsBrotliCache do
       end
 
       it "for #fetch" do
-        val = "123"
-        expect(brotli_store.fetch("val_key") { val }).to eq(standard_cache.fetch("val_key") { val })
-        expect(brotli_store.fetch("val_key", force: true) { val }).to eq(standard_cache.fetch("val_key", force: true) { val })
+        expect(brotli_store.fetch("val_key") { big_enough_to_compress_value }).to eq(standard_cache.fetch("val_key") { big_enough_to_compress_value })
+        expect(brotli_store.fetch("val_key", force: true) { big_enough_to_compress_value }).to eq(standard_cache.fetch("val_key", force: true) { big_enough_to_compress_value })
         expect(brotli_store.fetch("val_key")).to eq(standard_cache.fetch("val_key"))
       end
 
       it "for #write_multi and #read_multi" do
         values = {
-          "key_1" => "val_1",
+          "key_1" => big_enough_to_compress_value,
           "key_2" => "val_2"
         }
 
@@ -78,16 +86,16 @@ describe RailsBrotliCache do
 
       it "for #fetch_multi" do
         values = {
-          "key_1" => "val_1",
+          "key_1" => big_enough_to_compress_value,
           "key_2" => "val_2"
         }
 
         brotli_store.fetch_multi("key_1", "key_2") do |key|
-          "val_#{key.split('_').last}"
+          values[key]
         end
 
         standard_cache.fetch_multi("key_1", "key_2") do |key|
-          "val_#{key.split('_').last}"
+          values[key]
         end
 
         expect(brotli_store.read("key_1")).to eq standard_cache.read("key_1")

data/spec/rails-brotli-cache/store_spec.rb

@@ -98,9 +98,55 @@ describe RailsBrotliCache do
   end
 
   describe "fetch_multi" do
-    it "works" do
-      cache_store.fetch_multi("key_1", "key_2", expires_in: 5.seconds) { big_enough_to_compress_value }
-      expect(cache_store.read("key_1")).to eq big_enough_to_compress_value
+    subject do
+      cache_store.fetch_multi(*keys) do |key|
+        big_enough_to_compress_value + key
+      end
+    end
+
+    let(:keys) { %w[key_1 key_2] }
+    let(:response) do
+      {
+        'key_1' => big_enough_to_compress_value + 'key_1',
+        'key_2' => big_enough_to_compress_value + 'key_2'
+      }
+    end
+
+    it "works for store and reread" do
+      expect(subject).to eq response
+
+      expect(cache_store.fetch_multi(*keys) do |key|
+        big_enough_to_compress_value + key
+      end).to eq response
+    end
+
+    context 'with a complex object that responds to #cache_key' do
+      subject do
+        cache_store.fetch_multi(*keys) do |key|
+          big_enough_to_compress_value + key.id
+        end
+      end
+
+      let(:keys) do
+        [
+          OpenStruct.new(cache_key: 'key_1', id: '12345'),
+          OpenStruct.new(cache_key: 'key_2', id: '54321')
+        ]
+      end
+      let(:response) do
+        {
+          keys[0] => big_enough_to_compress_value + '12345',
+          keys[1] => big_enough_to_compress_value + '54321'
+        }
+      end
+
+      it "works for store and reread" do
+        expect(subject).to eq response
+
+        expect(cache_store.fetch_multi(*keys) do |key|
+          big_enough_to_compress_value + key.id
+        end).to eq response
+      end
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-brotli-cache
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - pawurb
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-09 00:00:00.000000000 Z
+date: 2023-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -226,7 +226,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Drop-in enhancement for Rails cache, offering better performance and compression