ldclient-rb 3.0.3 → 4.0.0

data/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

data/lib/ldclient-rb/ldclient.rb

@@ -28,7 +28,11 @@ module LaunchDarkly
       @config = config
       @store = config.feature_store
 
-      @event_processor = EventProcessor.new(sdk_key, config)
+      if @config.offline? || !@config.send_events
+        @event_processor = NullEventProcessor.new
+      else
+        @event_processor = EventProcessor.new(sdk_key, config)
+      end
 
       if @config.use_ldd?
         @config.logger.info { "[LDClient] Started LaunchDarkly Client in LDD mode" }
@@ -38,12 +42,16 @@ module LaunchDarkly
       requestor = Requestor.new(sdk_key, config)
 
       if !@config.offline?
-        if @config.stream?
-          @update_processor = StreamProcessor.new(sdk_key, config, requestor)
+        if @config.update_processor.nil?
+          if @config.stream?
+            @update_processor = StreamProcessor.new(sdk_key, config, requestor)
+          else
+            @config.logger.info { "Disabling streaming API" }
+            @config.logger.warn { "You should only disable the streaming API if instructed to do so by LaunchDarkly support" }
+            @update_processor = PollingProcessor.new(config, requestor)
+          end
         else
-          @config.logger.info { "Disabling streaming API" }
-          @config.logger.warn { "You should only disable the streaming API if instructed to do so by LaunchDarkly support" }
-          @update_processor = PollingProcessor.new(config, requestor)
+          @update_processor = @config.update_processor
         end
         @update_processor.start
       end
@@ -113,12 +121,6 @@ module LaunchDarkly
     def variation(key, user, default)
       return default if @config.offline?
 
-      unless user
-        @config.logger.error { "[LDClient] Must specify user" }
-        @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user)
-        return default
-      end
-
       if !initialized?
         if @store.initialized?
           @config.logger.warn { "[LDClient] Client has not finished initializing; using last known values from feature store" }
@@ -129,7 +131,7 @@ module LaunchDarkly
         end
       end
 
-      sanitize_user(user)
+      sanitize_user(user) if !user.nil?
       feature = @store.get(FEATURES, key)
 
       if feature.nil?
@@ -138,24 +140,29 @@ module LaunchDarkly
         return default
       end
 
+      unless user
+        @config.logger.error { "[LDClient] Must specify user" }
+        @event_processor.add_event(make_feature_event(feature, user, nil, default, default))
+        return default
+      end
+
       begin
-        res = evaluate(feature, user, @store)
+        res = evaluate(feature, user, @store, @config.logger)
         if !res[:events].nil?
           res[:events].each do |event|
             @event_processor.add_event(event)
           end
         end
-        if !res[:value].nil?
-          @event_processor.add_event(kind: "feature", key: key, user: user, value: res[:value], default: default, version: feature[:version])
-          return res[:value]
-        else
+        value = res[:value]
+        if value.nil?
           @config.logger.debug { "[LDClient] Result value is null in toggle" }
-          @event_processor.add_event(kind: "feature", key: key, user: user, value: default, default: default, version: feature[:version])
-          return default
+          value = default
         end
+        @event_processor.add_event(make_feature_event(feature, user, res[:variation], value, default))
+        return value
       rescue => exn
         @config.logger.warn { "[LDClient] Error evaluating feature flag: #{exn.inspect}. \nTrace: #{exn.backtrace}" }
-        @event_processor.add_event(kind: "feature", key: key, user: user, value: default, default: default, version: feature[:version])
+        @event_processor.add_event(make_feature_event(feature, user, nil, default, default))
         return default
       end
     end
@@ -200,7 +207,7 @@ module LaunchDarkly
         features = @store.all(FEATURES)
 
         # TODO rescue if necessary
-        Hash[features.map{ |k, f| [k, evaluate(f, user, @store)[:value]] }]
+        Hash[features.map{ |k, f| [k, evaluate(f, user, @store, @config.logger)[:value]] }]
       rescue => exn
         @config.logger.warn { "[LDClient] Error evaluating all flags: #{exn.inspect}. \nTrace: #{exn.backtrace}" }
         return Hash.new
@@ -232,6 +239,20 @@ module LaunchDarkly
       end
     end
 
-    private :evaluate, :log_exception, :sanitize_user
+    def make_feature_event(flag, user, variation, value, default)
+      {
+        kind: "feature",
+        key: flag[:key],
+        user: user,
+        variation: variation,
+        value: value,
+        default: default,
+        version: flag[:version],
+        trackEvents: flag[:trackEvents],
+        debugEventsUntilDate: flag[:debugEventsUntilDate]
+      }
+    end
+
+    private :evaluate, :log_exception, :sanitize_user, :make_feature_event
   end
 end

data/lib/ldclient-rb/non_blocking_thread_pool.rb

@@ -0,0 +1,46 @@
+require "concurrent"
+require "concurrent/atomics"
+require "concurrent/executors"
+require "thread"
+
+# Simple wrapper for a FixedThreadPool that rejects new jobs if all the threads are busy, rather
+# than blocking. Also provides a way to wait for all jobs to finish without shutting down.
+
+module LaunchDarkly
+  class NonBlockingThreadPool
+    def initialize(capacity)
+      @capacity = capacity
+      @pool = Concurrent::FixedThreadPool.new(capacity)
+      @semaphore = Concurrent::Semaphore.new(capacity)
+    end
+
+    # Attempts to submit a job, but only if a worker is available. Unlike the regular post method,
+    # this returns a value: true if the job was submitted, false if all workers are busy.
+    def post
+      if !@semaphore.try_acquire(1)
+        return
+      end
+      @pool.post do
+        begin
+          yield
+        ensure
+          @semaphore.release(1)
+        end
+      end
+    end
+
+    # Waits until no jobs are executing, without shutting down the pool.
+    def wait_all
+      @semaphore.acquire(@capacity)
+      @semaphore.release(@capacity)
+    end
+
+    def shutdown
+      @pool.shutdown
+    end
+
+    def wait_for_termination
+      @pool.wait_for_termination
+    end
+  end
+end

data/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 @@ module LaunchDarkly
     #
     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]
@@ -54,15 +53,12 @@ module LaunchDarkly
       @prefix = opts[:prefix] || RedisFeatureStore.default_prefix
       @logger = opts[:logger] || Config.default_logger
 
-      @expiration_seconds = opts[:expiration] || 15
-      @capacity = opts[:capacity] || 1000
-      # We're using Moneta only to provide expiration behavior for the in-memory cache.
-      # 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)
+      expiration_seconds = opts[:expiration] || 15
+      capacity = opts[:capacity] || 1000
+      if expiration_seconds > 0
+        @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 +88,7 @@ and prefix: #{@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 +135,7 @@ and prefix: #{@prefix}")
     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 +170,7 @@ and prefix: #{@prefix}")
     def stop
       if @stopped.make_true
         @pool.shutdown { |redis| redis.close }
-        @cache.clear
+        @cache.clear if !@cache.nil?
       end
     end
 
@@ -213,7 +209,7 @@ and prefix: #{@prefix}")
     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)

data/lib/ldclient-rb/simple_lru_cache.rb

@@ -0,0 +1,24 @@
+
+module LaunchDarkly
+  # A non-thread-safe implementation of a LRU cache set with only add and reset methods.
+  # Based on https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/cache.rb
+  class SimpleLRUCacheSet
+    def initialize(capacity)
+      @values = {}
+      @capacity = capacity
+    end
+
+    # Adds a value to the cache or marks it recent if it was already there. Returns true if already there.
+    def add(value)
+      found = true
+      @values.delete(value) { found = false }
+      @values[value] = true
+      @values.shift if @values.length > @capacity
+      found
+    end
+
+    def clear
+      @values = {}
+    end
+  end
+end

data/lib/ldclient-rb/{event_serializer.rb → user_filter.rb}

@@ -1,18 +1,28 @@
 require "json"
 
 module LaunchDarkly
-  class EventSerializer
+  class UserFilter
     def initialize(config)
       @all_attributes_private = config.all_attributes_private
       @private_attribute_names = Set.new(config.private_attribute_names.map(&:to_sym))
     end
 
-    def serialize_events(events)
-      events.map { |event|
-        Hash[event.map { |key, value|
-          [key, (key.to_sym == :user) ? transform_user_props(value) : value]
-        }]
-      }.to_json
+    def transform_user_props(user_props)
+      return nil if user_props.nil?
+      
+      user_private_attrs = Set.new((user_props[:privateAttributeNames] || []).map(&:to_sym))
+
+      filtered_user_props, removed = filter_values(user_props, user_private_attrs, ALLOWED_TOP_LEVEL_KEYS, IGNORED_TOP_LEVEL_KEYS)
+      if user_props.has_key?(:custom)
+        filtered_user_props[:custom], removed_custom = filter_values(user_props[:custom], user_private_attrs)
+        removed.merge(removed_custom)
+      end
+
+      unless removed.empty?
+        # note, :privateAttributeNames is what the developer sets; :privateAttrs is what we send to the server
+        filtered_user_props[:privateAttrs] = removed.to_a.sort.map { |s| s.to_s }
+      end
+      return filtered_user_props
     end
 
     private
@@ -35,21 +45,5 @@ module LaunchDarkly
     def private_attr?(name, user_private_attrs)
       @all_attributes_private || @private_attribute_names.include?(name) || user_private_attrs.include?(name)
     end
-
-    def transform_user_props(user_props)
-      user_private_attrs = Set.new((user_props[:privateAttributeNames] || []).map(&:to_sym))
-
-      filtered_user_props, removed = filter_values(user_props, user_private_attrs, ALLOWED_TOP_LEVEL_KEYS, IGNORED_TOP_LEVEL_KEYS)
-      if user_props.has_key?(:custom)
-        filtered_user_props[:custom], removed_custom = filter_values(user_props[:custom], user_private_attrs)
-        removed.merge(removed_custom)
-      end
-
-      unless removed.empty?
-        # note, :privateAttributeNames is what the developer sets; :privateAttrs is what we send to the server
-        filtered_user_props[:privateAttrs] = removed.to_a.sort
-      end
-      return filtered_user_props
-    end
   end
 end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "3.0.3"
+  VERSION = "4.0.0"
 end

data/spec/evaluation_spec.rb

@@ -12,6 +12,8 @@ describe LaunchDarkly::Evaluation do
     }
   }
 
+  let(:logger) { LaunchDarkly::Config.default_logger }
+
   include LaunchDarkly::Evaluation
 
   describe "evaluate" do
@@ -24,7 +26,7 @@ describe LaunchDarkly::Evaluation do
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features)).to eq({value: 'b', events: []})
+      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: []})
     end
 
     it "returns nil if flag is off and off variation is unspecified" do
@@ -35,7 +37,7 @@ describe LaunchDarkly::Evaluation do
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features)).to eq({value: nil, events: []})
+      expect(evaluate(flag, user, features, logger)).to eq({variation: nil, value: nil, events: []})
     end
 
     it "returns off variation if prerequisite is not found" do
@@ -48,7 +50,34 @@ describe LaunchDarkly::Evaluation do
         variations: ['a', 'b', 'c']
       }
       user = { key: 'x' }
-      expect(evaluate(flag, user, features)).to eq({value: 'b', events: []})
+      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: []})
+    end
+
+    it "returns off variation and event if prerequisite of a prerequisite is not found" do
+      flag = {
+        key: 'feature0',
+        on: true,
+        prerequisites: [{key: 'feature1', variation: 1}],
+        fallthrough: { variation: 0 },
+        offVariation: 1,
+        variations: ['a', 'b', 'c'],
+        version: 1
+      }
+      flag1 = {
+        key: 'feature1',
+        on: true,
+        prerequisites: [{key: 'feature2', variation: 1}], # feature2 doesn't exist
+        fallthrough: { variation: 0 },
+        variations: ['d', 'e'],
+        version: 2
+      }
+      features.upsert(LaunchDarkly::FEATURES, flag1)
+      user = { key: 'x' }
+      events_should_be = [{
+        kind: 'feature', key: 'feature1', variation: nil, value: nil, version: 2, prereqOf: 'feature0',
+        trackEvents: nil, debugEventsUntilDate: nil
+      }]
+      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: events_should_be})
     end
 
     it "returns off variation and event if prerequisite is not met" do
@@ -70,8 +99,11 @@ describe LaunchDarkly::Evaluation do
       }
       features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
-      events_should_be = [{kind: 'feature', key: 'feature1', value: 'd', version: 2, prereqOf: 'feature0'}]
-      expect(evaluate(flag, user, features)).to eq({value: 'b', events: events_should_be})
+      events_should_be = [{
+        kind: 'feature', key: 'feature1', variation: 0, value: 'd', version: 2, prereqOf: 'feature0',
+        trackEvents: nil, debugEventsUntilDate: nil
+      }]
+      expect(evaluate(flag, user, features, logger)).to eq({variation: 1, value: 'b', events: events_should_be})
     end
 
     it "returns fallthrough variation and event if prerequisite is met and there are no rules" do
@@ -93,8 +125,11 @@ describe LaunchDarkly::Evaluation do
       }
       features.upsert(LaunchDarkly::FEATURES, flag1)
       user = { key: 'x' }
-      events_should_be = [{kind: 'feature', key: 'feature1', value: 'e', version: 2, prereqOf: 'feature0'}]
-      expect(evaluate(flag, user, features)).to eq({value: 'a', events: events_should_be})
+      events_should_be = [{
+        kind: 'feature', key: 'feature1', variation: 1, value: 'e', version: 2, prereqOf: 'feature0',
+        trackEvents: nil, debugEventsUntilDate: nil
+      }]
+      expect(evaluate(flag, user, features, logger)).to eq({variation: 0, value: 'a', events: events_should_be})
     end
 
     it "matches user from targets" do
@@ -109,7 +144,7 @@ describe LaunchDarkly::Evaluation do
         variations: ['a', 'b', 'c']
       }
       user = { key: 'userkey' }
-      expect(evaluate(flag, user, features)).to eq({value: 'c', events: []})
+      expect(evaluate(flag, user, features, logger)).to eq({variation: 2, value: 'c', events: []})
     end
 
     it "matches user from rules" do
@@ -133,7 +168,7 @@ describe LaunchDarkly::Evaluation do
         variations: ['a', 'b', 'c']
       }
       user = { key: 'userkey' }
-      expect(evaluate(flag, user, features)).to eq({value: 'c', events: []})
+      expect(evaluate(flag, user, features, logger)).to eq({variation: 2, value: 'c', events: []})
     end
   end