rails-brotli-cache 0.2.3 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f5eae03f927b9f70606cc7b4134fc7173926951da4cf05172bdd9cecb149c61
-  data.tar.gz: c89a69ec5b5d5ddbb8efb432d253784ec30be073ca0a4d142edf347cbc4b75cb
+  metadata.gz: c53c91a3df8a561eadcb309bc1a0a3315ca331ec36fe9bfe0995b21dc09c821b
+  data.tar.gz: d74f60c63d75643f57ac1c3568b436ed817dcb69e73cd19d4ab369c420deeba2
 SHA512:
-  metadata.gz: 7b8b3daea70b8c8f5cd8f445ee08155eb6356fbab042db3fd505dc26e666fe8a1011080391940d1d77e08d912ddef46d9a7908377bf6135c7784c433a37ce495
-  data.tar.gz: 5c37c70c355770b708b7703333a4f941d5b28e51d8a6e140eb256ce5a145fa8da21a86cd72af9498f274c56c97d5b3daa9718e8a58aefe4e206d31f58a8d1471
+  metadata.gz: f2f4b9f01712a860dd57b6da48cb284c68a92593a50955796abf8eafd8b32e5b712233d0e7029aa3c26ed65b098547e25a3311b83cf6c94f8c6f74b2cdcaf443
+  data.tar.gz: c858ee0fd911aa7805ed2b74ab9dc15328b3584918b5da262b60df3a8a27f9982412b00001ba9da4f189038c57e9b0e2620116dba60b4982b91b5da8f7ad8ae4

data/README.md

@@ -1,13 +1,15 @@
 # Rails Brotli Cache [![Gem Version](https://img.shields.io/gem/v/rails-brotli-cache)](https://badge.fury.io/rb/rails-brotli-cache) [![CircleCI](https://circleci.com/gh/pawurb/rails-brotli-cache.svg?style=svg)](https://circleci.com/gh/pawurb/rails-brotli-cache)
 
-This gem enables support for compressing Ruby on Rails cache entries using the [Brotli compression algorithm](https://github.com/google/brotli). `RailsBrotliCache::Store` offers better compression and faster performance compared to the default `Rails.cache` regardless of the underlying data store.
+This gem enables support for compressing Ruby on Rails cache entries using the [Brotli compression algorithm](https://github.com/google/brotli). `RailsBrotliCache::Store` offers better compression and faster performance compared to the default `Rails.cache`, regardless of the underlying data store. The gem also allows specifying any custom compression algorithm instead of Brotli.
 
 ## Benchmarks
 
 Brotli cache works as a proxy layer wrapping the underlying cache data store.
 
 ```ruby
-redis_cache = ActiveSupport::Cache::RedisCacheStore.new
+redis_cache = ActiveSupport::Cache::RedisCacheStore.new(
+  url: "redis://localhost:6379"
+)
 brotli_redis_cache = RailsBrotliCache::Store.new(redis_cache)
 ```
 
@@ -19,9 +21,10 @@ json.size # => 435662
 redis_cache.write("json", json)
 brotli_redis_cache.write("json", json)
 
-## Check the size of cache entry stored in Redis
-$redis.get("json").size # => 31698
-$redis.get("br-json").size # => 24058
+## Check the size of cache entries stored in Redis
+redis = Redis.new(url: "redis://localhost:6379")
+redis.get("json").size # => 31698
+redis.get("br-json").size # => 24058
 ```
 
 **~20%** better compression of a sample ActiveRecord objects array:
@@ -30,8 +33,9 @@ $redis.get("br-json").size # => 24058
 users = User.limit(100).to_a # 100 ActiveRecord objects
 redis_cache.write("users", users)
 brotli_redis_cache.write("users", users)
-$redis.get("users").size # => 12331
-$redis.get("br-users").size # => 10299
+
+redis.get("users").size # => 12331
+redis.get("br-users").size # => 10299
 ```
 
 **~25%** faster performance for reading/writing a larger JSON file:
@@ -57,59 +61,78 @@ Benchmark.bm do |x|
   # ...
 end
 
-# memory_cache  2.081221   0.051615   2.132836 (  2.132877)
-# brotli_memory_cache  1.134411   0.032996   1.167407 (  1.167418)
 # redis_cache  1.782225   0.049936   1.832161 (  2.523317)
 # brotli_redis_cache  1.218365   0.051084   1.269449 (  1.850894)
 # memcached_cache  1.766268   0.045351   1.811619 (  2.504233)
 # brotli_memcached_cache  1.194646   0.051750   1.246396 (  1.752982)
+# file_cache  1.727967   0.071138   1.799105 (  1.799229)
+# brotli_file_cache  1.128514   0.044308   1.172822 (  1.172983)
 ```
 
-Regardless of the underlying data store, Brotli cache offers between 20%-40% performance improvment.
+Regardless of the underlying data store, Brotli cache offers 20%-40% performance improvement.
 
-You can run the benchmarks yourself by executing:
+You can run the benchmarks by executing:
 
 ```ruby
 cp docker-compose.yml.sample docker-compose.yml
 docker compose up -d
 cd benchmarks
 bundle install
-ruby main.rb
+bundle exec ruby main.rb
 ```
 
 ## Configuration
 
-Gem works as a drop-in replacement for a standard Rails cache store. Here's how you can configure it with different store types:
+Gem works as a drop-in replacement for a standard Rails cache store. You can configure it with different store types:
 
 ```ruby
 config.cache_store = RailsBrotliCache::Store.new(
-  ActiveSupport::Cache::RedisCacheStore.new(redis: $redis)
+  ActiveSupport::Cache::RedisCacheStore.new(url: "redis://localhost:6379")
 )
 ```
 
 ```ruby
 config.cache_store = RailsBrotliCache::Store.new(
-  ActiveSupport::Cache::MemoryStore.new
+  ActiveSupport::Cache::MemCacheStore.new("localhost:11211")
 )
 ```
 
 ```ruby
 config.cache_store = RailsBrotliCache::Store.new(
-  ActiveSupport::Cache::MemCacheStore.new("localhost:11211")
+  ActiveSupport::Cache::FileStore.new('/tmp')
 )
 ```
 
-Gem appends `br-` to the cache key names to prevent conflicts with previously saved cache entries. You can disable this behaviour by passing `{ prefix: nil }` during initialization:
+You should avoid using it with `ActiveSupport::Cache::MemoryStore`. This type of cache store does not serialize or compress objects but keeps them directly in the RAM of a Ruby process. In this case, adding this gem would reduce RAM usage but add huge performance overhead.
+
+Gem appends `br-` to the cache key names to prevent conflicts with previously saved entries. You can disable this behavior by passing `{ prefix: nil }` during initialization:
 
 ```ruby
 config.cache_store = RailsBrotliCache::Store.new(
-  ActiveSupport::Cache::MemoryStore.new,
+  ActiveSupport::Cache::RedisCacheStore.new,
   { prefix: nil }
 )
 ```
 
 Addition of the prefix means that you can safely add the Brotli the cache config and avoid compression algorithm conflicts between old and new entries. After configuring the Brotli cache you should run `Rails.cache.clear` to remove the outdated (gzipped) entries.
 
+### Use a custom compressor class
+
+By default gem uses a Brotli compression, but you can customize the algorithm. You can pass a `compressor_class` object as a store configuration argument or directly to `read/write/fetch` methods:
+
+```ruby
+config.cache_store = RailsBrotliCache::Store.new(
+  ActiveSupport::Cache::RedisCacheStore.new,
+  { compressor_class: Snappy }
+)
+```
+
+```ruby
+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.
+
 ## Testing
 
 ```bash

data/benchmarks/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
 gem 'rails-brotli-cache'
+gem 'redis'
+gem 'dalli'

data/benchmarks/main.rb

@@ -8,6 +8,8 @@ redis_cache = ActiveSupport::Cache::RedisCacheStore.new
 brotli_redis_cache = RailsBrotliCache::Store.new(redis_cache)
 memcached_cache = ActiveSupport::Cache::MemCacheStore.new
 brotli_memcached_cache = RailsBrotliCache::Store.new(memcached_cache)
+file_cache = ActiveSupport::Cache::FileStore.new('/tmp')
+brotli_file_cache = RailsBrotliCache::Store.new(file_cache)
 
 json_uri = URI("https://raw.githubusercontent.com/pawurb/rails-brotli-cache/main/spec/fixtures/sample.json")
 json = Net::HTTP.get(json_uri)
@@ -66,4 +68,18 @@ Benchmark.bm do |x|
       brotli_memcached_cache.read("test")
     end
   end
+
+  x.report("file_cache") do
+    iterations.times do
+      file_cache.write("test", json)
+      file_cache.read("test")
+    end
+  end
+
+  x.report("brotli_file_cache") do
+    iterations.times do
+      brotli_file_cache.write("test", json)
+      brotli_file_cache.read("test")
+    end
+  end
 end

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

@@ -6,7 +6,7 @@ require 'brotli'
 module RailsBrotliCache
   class Store < ::ActiveSupport::Cache::Store
     COMPRESS_THRESHOLD = ENV.fetch("BR_CACHE_COMPRESS_THRESHOLD", 1).to_f * 1024.0
-    COMPRESS_QUALITY = ENV.fetch("BR_CACHE_COMPRESS_QUALITY", 5).to_i
+    BR_COMPRESS_QUALITY = ENV.fetch("BR_CACHE_COMPRESS_QUALITY", 5).to_i
     MARK_BR_COMPRESSED = "\x02".b
 
     attr_reader :core_store
@@ -18,6 +18,8 @@ module RailsBrotliCache
       else
         "br-"
       end
+
+      @compressor_class = compressor_class(options, default: BrotliCompressor)
     end
 
     def fetch(name, options = nil, &block)
@@ -41,9 +43,11 @@ module RailsBrotliCache
 
     def write(name, value, options = nil)
       serialized = Marshal.dump(value)
+      options = (options || {}).reverse_merge(compress: true)
 
-      payload = if serialized.bytesize >= COMPRESS_THRESHOLD
-        compressed_payload = ::Brotli.deflate(serialized, quality: COMPRESS_QUALITY)
+      payload = if serialized.bytesize >= COMPRESS_THRESHOLD && !options.fetch(:compress) == false
+        compressor = compressor_class(options, default: @compressor_class)
+        compressed_payload = compressor.deflate(serialized)
         if compressed_payload.bytesize < serialized.bytesize
           MARK_BR_COMPRESSED + compressed_payload
         else
@@ -56,7 +60,7 @@ module RailsBrotliCache
       @core_store.write(
         cache_key(name),
         payload,
-        (options || {}).merge(compress: false)
+        options.merge(compress: false)
       )
     end
 
@@ -69,7 +73,8 @@ module RailsBrotliCache
       return nil unless payload.present?
 
       serialized = if payload.start_with?(MARK_BR_COMPRESSED)
-        ::Brotli.inflate(payload.byteslice(1..-1))
+        compressor = compressor_class(options, default: @compressor_class)
+        compressor.inflate(payload.byteslice(1..-1))
       else
         payload
       end
@@ -87,8 +92,27 @@ module RailsBrotliCache
 
     private
 
+    def compressor_class(options, default:)
+      options = options || {}
+      if (klass = options[:compressor_class])
+        klass
+      else
+        default
+      end
+    end
+
     def cache_key(name)
       "#{@prefix}#{name}"
     end
+
+    class BrotliCompressor
+      def self.deflate(payload)
+        ::Brotli.deflate(payload, quality: BR_COMPRESS_QUALITY)
+      end
+
+      def self.inflate(payload)
+        ::Brotli.inflate(payload)
+      end
+    end
   end
 end

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

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

data/rails-brotli-cache.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |gem|
   gem.version       = RailsBrotliCache::VERSION
   gem.authors       = ["pawurb"]
   gem.email         = ["contact@pawelurbanek.com"]
-  gem.summary       = %q{ Rails cache using Brotli algorithm offers better compression and performance. }
-  gem.description   = %q{ rails-brotli-cache allows to reduce storage needed for Rails cache by using Brotli compression which can produce outputs smaller by ~20%. }
+  gem.summary       = %q{ Drop-in enhancement for Rails cache, offering better performance and compression with Brotli algorithm. }
+  gem.description   = %q{ This gem reduces storage needed for Rails cache by using Brotli compression, which can produce outputs smaller by ~20% and offers better performance than Gzip. }
   gem.homepage      = "https://github.com/pawurb/rails-brotli-cache"
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = gem.files.grep(%r{^(spec)/})

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

@@ -4,6 +4,16 @@ require 'spec_helper'
 
 return unless ENV['RAILS_CACHE_STORE'] == 'redis_cache_store'
 
+class DummyCompressor
+  def self.deflate(payload)
+    payload
+  end
+
+  def self.inflate(payload)
+    payload
+  end
+end
+
 describe RailsBrotliCache do
   let(:options) do
     {}
@@ -33,6 +43,18 @@ describe RailsBrotliCache do
     expect($redis.get("gz-test-key").size > $redis.get("br-test-key").size).to eq true
   end
 
+  it "respects { compress: false } setting and does not apply compression" do
+    Rails.cache.write("gz-test-key", json)
+    cache_store.write("test-key", json, compress: false)
+    expect($redis.get("gz-test-key").size < $redis.get("br-test-key").size).to eq true
+  end
+
+  it "allows specyfing custom compressor class" do
+    Rails.cache.write("gz-test-key", json)
+    cache_store.write("test-key", json, compressor_class: DummyCompressor)
+    expect($redis.get("gz-test-key").size < $redis.get("br-test-key").size).to eq true
+  end
+
   describe "disable_prefix" do
     context "default prefix" do
       it "appends 'br-' prefix" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-brotli-cache
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.2
 platform: ruby
 authors:
 - pawurb
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-20 00:00:00.000000000 Z
+date: 2023-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,8 +94,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: " rails-brotli-cache allows to reduce storage needed for Rails cache
-  by using Brotli compression which can produce outputs smaller by ~20%. "
+description: " This gem reduces storage needed for Rails cache by using Brotli compression,
+  which can produce outputs smaller by ~20% and offers better performance than Gzip. "
 email:
 - contact@pawelurbanek.com
 executables: []
@@ -184,7 +184,8 @@ requirements: []
 rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
-summary: Rails cache using Brotli algorithm offers better compression and performance.
+summary: Drop-in enhancement for Rails cache, offering better performance and compression
+  with Brotli algorithm.
 test_files:
 - spec/dummy/Gemfile
 - spec/dummy/README.md