use our own lightweight expiring cache instead of moneta

Author: eli-darkly

ldclient-rb.gemspec

@@ -26,14 +26,14 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "codeclimate-test-reporter", "~> 0"
   spec.add_development_dependency "redis", "~> 3.3.5"
   spec.add_development_dependency "connection_pool", ">= 2.1.2"
-  spec.add_development_dependency "moneta", "~> 1.0.0"
   if RUBY_VERSION >= "2.0.0"
     spec.add_development_dependency "rake", "~> 10.0"
     spec.add_development_dependency "rspec_junit_formatter", "~> 0.3.0"
   else
     spec.add_development_dependency "rake", "12.1.0"
     # higher versions of rake fail to install in JRuby 1.7
   end
+  spec.add_development_dependency "timecop", "~> 0.9.1"
 
   spec.add_runtime_dependency "json", [">= 1.8", "< 3"]
   if RUBY_VERSION >= "2.1.0"

lib/ldclient-rb.rb

@@ -2,6 +2,7 @@
 require "ldclient-rb/evaluation"
 require "ldclient-rb/ldclient"
 require "ldclient-rb/cache_store"
+require "ldclient-rb/expiring_cache"
 require "ldclient-rb/memoized_value"
 require "ldclient-rb/in_memory_store"
 require "ldclient-rb/config"

lib/ldclient-rb/expiring_cache.rb

@@ -0,0 +1,76 @@
+
+module LaunchDarkly
+  # A thread-safe cache with maximum number of entries and TTL.
+  # Adapted from https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/ttl/cache.rb
+  # under MIT license with the following changes:
+  #   * made thread-safe
+  #   * removed many unused methods
+  #   * reading a key does not reset its expiration time, only writing
+  class ExpiringCache
+    def initialize(max_size, ttl)
+      @max_size = max_size
+      @ttl = ttl
+      @data_lru = {}
+      @data_ttl = {}
+      @lock = Mutex.new
+    end
+
+    def [](key)
+      @lock.synchronize do
+        ttl_evict
+        @data_lru[key]
+      end
+    end
+
+    def []=(key, val)
+      @lock.synchronize do
+        ttl_evict
+
+        @data_lru.delete(key)
+        @data_ttl.delete(key)
+
+        @data_lru[key] = val
+        @data_ttl[key] = Time.now.to_f
+
+        if @data_lru.size > @max_size
+          key, _ = @data_lru.first # hashes have a FIFO ordering in Ruby
+
+          @data_ttl.delete(key)
+          @data_lru.delete(key)
+        end
+
+        val
+      end
+    end
+
+    def delete(key)
+      @lock.synchronize do
+        ttl_evict
+
+        @data_lru.delete(key)
+        @data_ttl.delete(key)
+      end
+    end
+
+    def clear
+      @lock.synchronize do
+        @data_lru.clear
+        @data_ttl.clear
+      end
+    end
+
+    private
+
+    def ttl_evict
+      ttl_horizon = Time.now.to_f - @ttl
+      key, time = @data_ttl.first
+
+      until time.nil? || time > ttl_horizon
+        @data_ttl.delete(key)
+        @data_lru.delete(key)
+
+        key, time = @data_ttl.first
+      end
+    end
+  end
+end

lib/ldclient-rb/redis_store.rb

@@ -9,15 +9,14 @@ module LaunchDarkly
   # streaming API.  Feature data can also be further cached in memory to reduce overhead
   # of calls to Redis.
   #
-  # To use this class, you must first have the `redis`, `connection-pool`, and `moneta`
-  # gems installed.  Then, create an instance and store it in the `feature_store`
-  # property of your client configuration.
+  # To use this class, you must first have the `redis` and `connection-pool` gems
+  # installed.  Then, create an instance and store it in the `feature_store` property
+  # of your client configuration.
   #
   class RedisFeatureStore
     begin
       require "redis"
       require "connection_pool"
-      require "moneta"
       REDIS_ENABLED = true
     rescue ScriptError, StandardError
       REDIS_ENABLED = false
@@ -38,7 +37,7 @@ class RedisFeatureStore
     #
     def initialize(opts = {})
       if !REDIS_ENABLED
-        raise RuntimeError.new("can't use RedisFeatureStore because one of these gems is missing: redis, connection_pool, moneta")
+        raise RuntimeError.new("can't use RedisFeatureStore because one of these gems is missing: redis, connection_pool")
       end
       @redis_opts = opts[:redis_opts] || Hash.new
       if opts[:redis_url]
@@ -60,9 +59,9 @@ def initialize(opts = {})
       # Moneta can also be used as a wrapper for Redis, but it doesn't support the Redis
       # hash operations that we use.
       if @expiration_seconds > 0
-        @cache = Moneta.new(:LRUHash, expires: true, threadsafe: true, max_count: @capacity)
+        @cache = ExpiringCache.new(@capacity, @expiration_seconds)
       else
-        @cache = Moneta.new(:Null)  # a stub that caches nothing
+        @cache = nil
       end
 
       @stopped = Concurrent::AtomicBoolean.new(false)
@@ -92,7 +91,7 @@ def self.default_prefix
     end
 
     def get(kind, key)
-      f = @cache[cache_key(kind, key)]
+      f = @cache.nil? ? nil : @cache[cache_key(kind, key)]
       if f.nil?
         @logger.debug { "RedisFeatureStore: no cache hit for #{key} in '#{kind[:namespace]}', requesting from Redis" }
         f = with_connection do |redis|
@@ -139,7 +138,7 @@ def delete(kind, key, version)
     end
 
     def init(all_data)
-      @cache.clear
+      @cache.clear if !@cache.nil?
       count = 0
       with_connection do |redis|
         all_data.each do |kind, items|
@@ -174,7 +173,7 @@ def initialized?
     def stop
       if @stopped.make_true
         @pool.shutdown { |redis| redis.close }
-        @cache.clear
+        @cache.clear if !@cache.nil?
       end
     end
 
@@ -213,7 +212,7 @@ def get_redis(kind, redis, key)
     end
 
     def put_cache(kind, key, value)
-      @cache.store(cache_key(kind, key), value, expires: @expiration_seconds)
+      @cache[cache_key(kind, key)] = value if !@cache.nil?
     end
 
     def update_with_versioning(kind, new_item)

spec/expiring_cache_spec.rb

@@ -0,0 +1,76 @@
+require 'timecop'
+
+describe LaunchDarkly::ExpiringCache do
+  subject { LaunchDarkly::ExpiringCache }
+
+  before(:each) do
+    Timecop.freeze(Time.now)
+  end
+
+  after(:each) do
+    Timecop.return
+  end
+  
+  it "evicts entries based on TTL" do
+    c = subject.new(3, 300)
+    c[:a] = 1
+    c[:b] = 2
+
+    Timecop.freeze(Time.now + 330)
+
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3
+  end
+
+  it "evicts entries based on max size" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to eq 2
+    expect(c[:c]).to eq 3
+  end
+
+  it "does not reset LRU on get" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:a]
+    c[:c] = 3
+
+    expect(c[:a]).to be nil
+    expect(c[:b]).to eq 2
+    expect(c[:c]).to eq 3    
+  end
+
+  it "resets LRU on put" do
+    c = subject.new(2, 300)
+    c[:a] = 1
+    c[:b] = 2
+    c[:a] = 1
+    c[:c] = 3
+
+    expect(c[:a]).to eq 1
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3    
+  end
+
+  it "resets TTL on put" do
+    c = subject.new(3, 300)
+    c[:a] = 1
+    c[:b] = 2
+
+    Timecop.freeze(Time.now + 330)
+    c[:a] = 1
+    c[:c] = 3
+
+    expect(c[:a]).to eq 1
+    expect(c[:b]).to be nil
+    expect(c[:c]).to eq 3
+  end
+end