rails-brotli-cache 0.2.5 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f25f2d703bace978a6a84e686d55a80aa926366d0795d032dc4bbab325b863af
-  data.tar.gz: 027b2040bbe634ccc19e234bbbf550262add716e3f3ecdc2a5b1c82f947847c8
+  metadata.gz: 93b71dde73a988ed1a008810be38e9b30311896e41cf3c6017feebbfce4fec32
+  data.tar.gz: c3c9b8da01d4e3bcadd33fca01a3648b591db18dc807536190f43f34a4af2159
 SHA512:
-  metadata.gz: b84b6bc932bed9537116349df16b39524fc4e93b7b9e54e49e254de080e7a0513fa4a0a58722cc5a1e4a455d0c5c7d9226cf9192731a5617f4bf772eb210c5aa
-  data.tar.gz: bafd5345b64fb78db2815036eccbae16edd8fcbc7dc91b4acc8c1009e114be5c25e80b05e5498de1d500e3a10b138c8b086760127ba6462accaef33777fc57c8
+  metadata.gz: 33648f7e5a975d4c87ea10356e2ea5dc5220ade8d6a188ba3891a5387b47506079d4f4c7763f61458663868835e16f721489cd16132cd6ca671807531f14f0cc
+  data.tar.gz: 27d9f9b5c42134eccd351807bfd44f4d6fcc19baae2ef13a466f013c95406971feab785bced3c82827a709342f4a0672b7dee0e012f2f7c2003fac267daf7d43

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 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,17 +61,17 @@ 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
@@ -79,37 +83,56 @@ 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. 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/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)
@@ -44,7 +46,8 @@ module RailsBrotliCache
       options = (options || {}).reverse_merge(compress: true)
 
       payload = if serialized.bytesize >= COMPRESS_THRESHOLD && !options.fetch(:compress) == false
-        compressed_payload = ::Brotli.deflate(serialized, quality: COMPRESS_QUALITY)
+        compressor = compressor_class(options, default: @compressor_class)
+        compressed_payload = compressor.deflate(serialized)
         if compressed_payload.bytesize < serialized.bytesize
           MARK_BR_COMPRESSED + compressed_payload
         else
@@ -70,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
@@ -78,6 +82,10 @@ module RailsBrotliCache
       Marshal.load(serialized)
     end
 
+     def exist?(name, options = nil)
+      @core_store.exist?(cache_key(name), options)
+    end
+
     def delete(name, options = nil)
       @core_store.delete(cache_key(name), options)
     end
@@ -88,8 +96,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.5"
+  VERSION = "0.3.3"
 end

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
     {}
@@ -39,6 +49,12 @@ describe RailsBrotliCache do
     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

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

@@ -40,6 +40,17 @@ describe RailsBrotliCache do
     end
   end
 
+  describe "exist?" do
+    it "returns true if cache entry exists" do
+      cache_store.write("test-key", 1234)
+      expect(cache_store.exist?("test-key")).to eq true
+    end
+
+    it "returns false if cache entry does not exist" do
+      expect(cache_store.exist?("test-key")).to eq false
+    end
+  end
+
   describe "#core_store" do
     it "exposes the underlying data store" do
       expect(cache_store.core_store.class).to eq ActiveSupport::Cache::MemoryStore

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-brotli-cache
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.3
 platform: ruby
 authors:
 - pawurb
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-21 00:00:00.000000000 Z
+date: 2023-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails