ldclient-rb 2.5.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9261ef0e3f59657592492b3fe391e2096bc6eef2
-  data.tar.gz: 418f0fbd33e9ebc9afd7fff88fe79c08da5ffbed
+  metadata.gz: 5624d2c634cd8bc37ee54d2215e4150c754a2de7
+  data.tar.gz: da595a32a6ed8f80625318141639d1ddc26bed7f
 SHA512:
-  metadata.gz: 42f9a2a262c821cc0624bff69226d3ed0ffda35387c5504740b55919f732eaf874c7e2b4db698fe12697131a23a9482788379e21429a099eb94f00912bbaafd7
-  data.tar.gz: 0cb478da375473bb01ca3d733c8b85212a45c60210ad4f36ef49c8817eaadff21669e374ed990a1407ce4b6c51f9deec8fe7d9a5458079872979009359395de5
+  metadata.gz: 79f7bff1fd78fdc74370ae3604a13da553cdc9052d4a3c294470c51ca7f4969c93b8f9a317bc906f5b90f0d7d2d997e7a64738e7f209a0267ede8eedfb74b952
+  data.tar.gz: f3288d3da6869ee47c2785d34d190d63391ba0d0df59cb3b135c939589f52e6cdc9645b7cd1503d51822214888b65ba0221e2d4341513633ee9ef03caa860fc9

data/CHANGELOG.md

@@ -2,7 +2,15 @@
 
 All notable changes to the LaunchDarkly Ruby SDK will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
-2.5.0 (2018-02-12)
+## [3.0.0] - 2018-02-22
+### Added
+- Support for a new LaunchDarkly feature: reusable user segments.
+
+### Changed
+- The feature store interface has been changed to support user segment data as well as feature flags. Existing code that uses `InMemoryFeatureStore` or `RedisFeatureStore` should work as before, but custom feature store implementations will need to be updated.
+
+
+## [2.5.0] - 2018-02-12
 
 ## Added
 - Adds support for a future LaunchDarkly feature, coming soon: semantic version user attributes.
@@ -10,7 +18,6 @@ All notable changes to the LaunchDarkly Ruby SDK will be documented in this file
 ## Changed
 - It is now possible to compute rollouts based on an integer attribute of a user, not just a string attribute.
 
-
 ## [2.4.1] - 2018-01-23
 ## Changed
 - Reduce logging level for missing flags

data/circle.yml

@@ -1,21 +1,23 @@
 machine:
   environment:
-    RUBIES: "ruby-2.4.1;ruby-2.2.3;ruby-2.1.7;ruby-2.0.0;ruby-1.9.3;jruby-1.7.22"
+    RUBIES: "ruby-2.4.2 ruby-2.2.7 ruby-2.1.9 ruby-2.0.0 ruby-1.9.3 jruby-1.7.22 jruby-9.0.5.0 jruby-9.1.13.0"
   services:
     - redis
 
 dependencies:
   cache_directories:
-    - '../.rvm/rubies'
+    - '/opt/circleci/.rvm/rubies'
 
   override:
-    - >
-      rubiesArray=(${RUBIES//;/ });
-      for i in "${rubiesArray[@]}";
+    - |
+      set -e
+      for i in $RUBIES;
       do
         rvm install $i;
         rvm use $i;
-        gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
+        if [[ $i == jruby* ]]; then
+          gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
+        fi
         gem install bundler;
         bundle install;
         mv Gemfile.lock "Gemfile.lock.$i"
@@ -23,9 +25,9 @@ dependencies:
 
 test:
   override:
-    - >
-      rubiesArray=(${RUBIES//;/ });
-      for i in "${rubiesArray[@]}";
+    - |
+      set -e
+      for i in $RUBIES;
       do
         rvm use $i;
         cp "Gemfile.lock.$i" Gemfile.lock;

data/ldclient-rb.gemspec

@@ -30,8 +30,13 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "moneta", "~> 1.0.0"
 
   spec.add_runtime_dependency "json", [">= 1.8", "< 3"]
-  spec.add_runtime_dependency "faraday", [">= 0.9", "< 2"]
-  spec.add_runtime_dependency "faraday-http-cache", [">= 1.3.0", "< 3"]
+  if RUBY_VERSION >= "2.1.0"
+    spec.add_runtime_dependency "faraday", [">= 0.9", "< 2"]
+    spec.add_runtime_dependency "faraday-http-cache", [">= 1.3.0", "< 3"]
+  else
+    spec.add_runtime_dependency "faraday", [">= 0.9", "< 0.14.0"]
+    spec.add_runtime_dependency "faraday-http-cache", [">= 1.3.0", "< 2"]
+  end
   spec.add_runtime_dependency "semantic", "~> 1.6.0"
   spec.add_runtime_dependency "thread_safe", "~> 0.3"
   spec.add_runtime_dependency "net-http-persistent", "~> 2.9"

data/lib/ldclient-rb.rb

@@ -3,12 +3,12 @@ require "ldclient-rb/evaluation"
 require "ldclient-rb/ldclient"
 require "ldclient-rb/cache_store"
 require "ldclient-rb/memoized_value"
+require "ldclient-rb/in_memory_store"
 require "ldclient-rb/config"
 require "ldclient-rb/newrelic"
 require "ldclient-rb/stream"
 require "ldclient-rb/polling"
 require "ldclient-rb/event_serializer"
 require "ldclient-rb/events"
-require "ldclient-rb/feature_store"
-require "ldclient-rb/redis_feature_store"
+require "ldclient-rb/redis_store"
 require "ldclient-rb/requestor"

data/lib/ldclient-rb/config.rb

@@ -34,6 +34,8 @@ module LaunchDarkly
     # @option opts [Object] :cache_store A cache store for the Faraday HTTP caching
     #   library. Defaults to the Rails cache in a Rails environment, or a
     #   thread-safe in-memory store otherwise.
+    # @option opts [Object] :feature_store A store for feature flags and related data. Defaults to an in-memory
+    #   cache, or you can use RedisFeatureStore.
     # @option opts [Boolean] :use_ldd (false) Whether you are using the LaunchDarkly relay proxy in
     #   daemon mode. In this configuration, the client will not use a streaming connection to listen
     #   for updates, but instead will get feature state from a Redis instance. The `stream` and
@@ -171,7 +173,6 @@ module LaunchDarkly
     #
     attr_reader :feature_store
 
-    
     # The proxy configuration string
     #
     attr_reader :proxy

data/lib/ldclient-rb/evaluation.rb

@@ -22,16 +22,18 @@ module LaunchDarkly
     end
 
     SEMVER_OPERAND = lambda do |v|
+      semver = nil
       if v.is_a? String
         for _ in 0..2 do
           begin
-            return Semantic::Version.new(v)
+            semver = Semantic::Version.new(v)
+            break  # Some versions of jruby cannot properly handle a return here and return from the method that calls this lambda
           rescue ArgumentError
             v = addZeroVersionComponent(v)
           end
         end
       end
-      nil
+      semver
     end
 
     def self.addZeroVersionComponent(v)
@@ -98,7 +100,11 @@ module LaunchDarkly
       semVerLessThan:
         comparator(SEMVER_OPERAND) { |n| n < 0 },
       semVerGreaterThan:
-        comparator(SEMVER_OPERAND) { |n| n > 0 }
+        comparator(SEMVER_OPERAND) { |n| n > 0 },
+      segmentMatch:
+        lambda do |a, b|
+          false   # we should never reach this - instead we special-case this operator in clause_match_user
+        end
     }
 
     class EvaluationError < StandardError
@@ -136,54 +142,46 @@ module LaunchDarkly
     def eval_internal(flag, user, store, events)
       failed_prereq = false
       # Evaluate prerequisites, if any
-      if !flag[:prerequisites].nil?
-        flag[:prerequisites].each do |prerequisite|
-          prereq_flag = store.get(prerequisite[:key])
+      (flag[:prerequisites] || []).each do |prerequisite|
+        prereq_flag = store.get(FEATURES, prerequisite[:key])
 
-          if prereq_flag.nil? || !prereq_flag[:on]
-            failed_prereq = true
-          else
-            begin
-              prereq_res = eval_internal(prereq_flag, user, store, events)
-              variation = get_variation(prereq_flag, prerequisite[:variation])
-              events.push(kind: "feature", key: prereq_flag[:key], value: prereq_res, version: prereq_flag[:version], prereqOf: flag[:key])
-              if prereq_res.nil? || prereq_res != variation
-                failed_prereq = true
-              end
-            rescue => exn
-              @config.logger.error("[LDClient] Error evaluating prerequisite: #{exn.inspect}")
+        if prereq_flag.nil? || !prereq_flag[:on]
+          failed_prereq = true
+        else
+          begin
+            prereq_res = eval_internal(prereq_flag, user, store, events)
+            variation = get_variation(prereq_flag, prerequisite[:variation])
+            events.push(kind: "feature", key: prereq_flag[:key], value: prereq_res, version: prereq_flag[:version], prereqOf: flag[:key])
+            if prereq_res.nil? || prereq_res != variation
               failed_prereq = true
             end
+          rescue => exn
+            @config.logger.error("[LDClient] Error evaluating prerequisite: #{exn.inspect}")
+            failed_prereq = true
           end
         end
+      end
 
-        if failed_prereq
-          return nil
-        end
+      if failed_prereq
+        return nil
       end
       # The prerequisites were satisfied.
       # Now walk through the evaluation steps and get the correct
       # variation index
-      eval_rules(flag, user)
+      eval_rules(flag, user, store)
     end
 
-    def eval_rules(flag, user)
+    def eval_rules(flag, user, store)
       # Check user target matches
-      if !flag[:targets].nil?
-        flag[:targets].each do |target|
-          if !target[:values].nil?
-            target[:values].each do |value|
-              return get_variation(flag, target[:variation]) if value == user[:key]
-            end
-          end
+      (flag[:targets] || []).each do |target|
+        (target[:values] || []).each do |value|
+          return get_variation(flag, target[:variation]) if value == user[:key]
         end
       end
-
+    
       # Check custom rules
-      if !flag[:rules].nil?
-        flag[:rules].each do |rule|
-          return variation_for_user(rule, user, flag) if rule_match_user(rule, user)
-        end
+      (flag[:rules] || []).each do |rule|
+        return variation_for_user(rule, user, flag) if rule_match_user(rule, user, store)
       end
 
       # Check the fallthrough rule
@@ -202,17 +200,30 @@ module LaunchDarkly
       flag[:variations][index]
     end
 
-    def rule_match_user(rule, user)
+    def rule_match_user(rule, user, store)
       return false if !rule[:clauses]
 
-      rule[:clauses].each do |clause|
-        return false if !clause_match_user(clause, user)
+      (rule[:clauses] || []).each do |clause|
+        return false if !clause_match_user(clause, user, store)
       end
 
       return true
     end
 
-    def clause_match_user(clause, user)
+    def clause_match_user(clause, user, store)
+      # In the case of a segment match operator, we check if the user is in any of the segments,
+      # and possibly negate
+      if clause[:op].to_sym == :segmentMatch
+        (clause[:values] || []).each do |v|
+          segment = store.get(SEGMENTS, v)
+          return maybe_negate(clause, true) if !segment.nil? && segment_match_user(segment, user)
+        end
+        return maybe_negate(clause, false)
+      end
+      clause_match_user_no_segments(clause, user)
+    end
+
+    def clause_match_user_no_segments(clause, user)
       val = user_value(user, clause[:attribute])
       return false if val.nil?
 
@@ -250,6 +261,33 @@ module LaunchDarkly
       end
     end
 
+    def segment_match_user(segment, user)
+      return false unless user[:key]
+
+      return true if segment[:included].include?(user[:key])
+      return false if segment[:excluded].include?(user[:key])
+
+      (segment[:rules] || []).each do |r|
+        return true if segment_rule_match_user(r, user, segment[:key], segment[:salt])
+      end
+
+      return false
+    end
+
+    def segment_rule_match_user(rule, user, segment_key, salt)
+      (rule[:clauses] || []).each do |c|
+        return false unless clause_match_user_no_segments(c, user)
+      end
+
+      # If the weight is absent, this rule matches
+      return true if !rule[:weight]
+      
+      # All of the clauses are met. See if the user buckets in
+      bucket = bucket_user(user, segment_key, rule[:bucketBy].nil? ? "key" : rule[:bucketBy], salt)
+      weight = rule[:weight].to_f / 100000.0
+      return bucket < weight
+    end
+
     def bucket_user(user, key, bucket_by, salt)
       return nil unless user[:key]
 

data/lib/ldclient-rb/in_memory_store.rb

@@ -0,0 +1,89 @@
+require "concurrent/atomics"
+
+module LaunchDarkly
+
+  # These constants denote the types of data that can be stored in the feature store.  If
+  # we add another storable data type in the future, as long as it follows the same pattern
+  # (having "key", "version", and "deleted" properties), we only need to add a corresponding
+  # constant here and the existing store should be able to handle it.
+  FEATURES = {
+    namespace: "features"
+  }.freeze
+
+  SEGMENTS = {
+    namespace: "segments"
+  }.freeze
+
+  #
+  # Default implementation of the LaunchDarkly client's feature store, using an in-memory
+  # cache.  This object holds feature flags and related data received from the
+  # streaming API.
+  #
+  class InMemoryFeatureStore
+    def initialize
+      @items = Hash.new
+      @lock = Concurrent::ReadWriteLock.new
+      @initialized = Concurrent::AtomicBoolean.new(false)
+    end
+
+    def get(kind, key)
+      @lock.with_read_lock do
+        coll = @items[kind]
+        f = coll.nil? ? nil : coll[key.to_sym]
+        (f.nil? || f[:deleted]) ? nil : f
+      end
+    end
+
+    def all(kind)
+      @lock.with_read_lock do
+        coll = @items[kind]
+        (coll.nil? ? Hash.new : coll).select { |_k, f| not f[:deleted] }
+      end
+    end
+
+    def delete(kind, key, version)
+      @lock.with_write_lock do
+        coll = @items[kind]
+        if coll.nil?
+          coll = Hash.new
+          @items[kind] = coll
+        end
+        old = coll[key.to_sym]
+
+        if old.nil? || old[:version] < version
+          coll[key.to_sym] = { deleted: true, version: version }
+        end
+      end
+    end
+
+    def init(all_data)
+      @lock.with_write_lock do
+        @items.replace(all_data)
+        @initialized.make_true
+      end
+    end
+
+    def upsert(kind, item)
+      @lock.with_write_lock do
+        coll = @items[kind]
+        if coll.nil?
+          coll = Hash.new
+          @items[kind] = coll
+        end
+        old = coll[item[:key].to_sym]
+
+        if old.nil? || old[:version] < item[:version]
+          coll[item[:key].to_sym] = item
+        end
+      end
+    end
+
+    def initialized?
+      @initialized.value
+    end
+
+    def stop
+      # nothing to do
+    end
+  end
+end

data/lib/ldclient-rb/ldclient.rb

@@ -130,7 +130,7 @@ module LaunchDarkly
       end
 
       sanitize_user(user)
-      feature = @store.get(key)
+      feature = @store.get(FEATURES, key)
 
       if feature.nil?
         @config.logger.info("[LDClient] Unknown feature flag #{key}. Returning default value")
@@ -197,7 +197,7 @@ module LaunchDarkly
       end
 
       begin
-        features = @store.all
+        features = @store.all(FEATURES)
 
         # TODO rescue if necessary
         Hash[features.map{ |k, f| [k, evaluate(f, user, @store)[:value]] }]

data/lib/ldclient-rb/polling.rb

@@ -31,9 +31,12 @@ module LaunchDarkly
     end
 
     def poll
-      flags = @requestor.request_all_flags
-      if flags
-        @config.feature_store.init(flags)
+      all_data = @requestor.request_all_data
+      if all_data
+        @config.feature_store.init({
+          FEATURES => all_data[:flags],
+          SEGMENTS => all_data[:segments]
+        })
         if @initialized.make_true
           @config.logger.info("[LDClient] Polling connection initialized")
         end

data/lib/ldclient-rb/{redis_feature_store.rb → redis_store.rb}

@@ -5,7 +5,8 @@ require "thread_safe"
 module LaunchDarkly
   #
   # An implementation of the LaunchDarkly client's feature store that uses a Redis
-  # instance.  Feature data can also be further cached in memory to reduce overhead
+  # instance.  This object holds feature flags and related data received from the
+  # 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`
@@ -32,7 +33,7 @@ module LaunchDarkly
     # @option opts [Logger] :logger  a `Logger` instance; defaults to `Config.default_logger`
     # @option opts [Integer] :max_connections  size of the Redis connection pool
     # @option opts [Integer] :expiration  expiration time for the in-memory cache, in seconds; 0 for no local caching
-    # @option opts [Integer] :capacity  maximum number of feature flags to cache locally
+    # @option opts [Integer] :capacity  maximum number of feature flags (or related objects) to cache locally
     # @option opts [Object] :pool  custom connection pool, used for testing only
     #
     def initialize(opts = {})
@@ -52,7 +53,6 @@ module LaunchDarkly
       end
       @prefix = opts[:prefix] || RedisFeatureStore.default_prefix
       @logger = opts[:logger] || Config.default_logger
-      @features_key = @prefix + ':features'
 
       @expiration_seconds = opts[:expiration] || 15
       @capacity = opts[:capacity] || 1000
@@ -91,44 +91,44 @@ and prefix: #{@prefix}")
       'launchdarkly'
     end
 
-    def get(key)
-      f = @cache[key.to_sym]
+    def get(kind, key)
+      f = @cache[cache_key(kind, key)]
       if f.nil?
-        @logger.debug("RedisFeatureStore: no cache hit for #{key}, requesting from Redis")
+        @logger.debug("RedisFeatureStore: no cache hit for #{key} in '#{kind[:namespace]}', requesting from Redis")
         f = with_connection do |redis|
           begin
-            get_redis(redis,key.to_sym)
+            get_redis(kind, redis, key.to_sym)
           rescue => e
-            @logger.error("RedisFeatureStore: could not retrieve feature #{key} from Redis, with error: #{e}")
+            @logger.error("RedisFeatureStore: could not retrieve #{key} from Redis in '#{kind[:namespace]}', with error: #{e}")
             nil
           end
         end
         if !f.nil?
-          put_cache(key.to_sym, f)
+          put_cache(kind, key, f)
         end
       end
       if f.nil?
-        @logger.debug("RedisFeatureStore: feature #{key} not found")
+        @logger.debug("RedisFeatureStore: #{key} not found in '#{kind[:namespace]}'")
         nil
       elsif f[:deleted]
-        @logger.debug("RedisFeatureStore: feature #{key} was deleted, returning nil")
+        @logger.debug("RedisFeatureStore: #{key} was deleted in '#{kind[:namespace]}', returning nil")
         nil
       else
         f
       end
     end
 
-    def all
+    def all(kind)
       fs = {}
       with_connection do |redis|
         begin
-          hashfs = redis.hgetall(@features_key)
+          hashfs = redis.hgetall(items_key(kind))
         rescue => e
-          @logger.error("RedisFeatureStore: could not retrieve all flags from Redis with error: #{e}; returning none")
+          @logger.error("RedisFeatureStore: could not retrieve all '#{kind[:namespace]}' items from Redis with error: #{e}; returning none")
           hashfs = {}
         end
-        hashfs.each do |k, jsonFeature|
-          f = JSON.parse(jsonFeature, symbolize_names: true)
+        hashfs.each do |k, jsonItem|
+          f = JSON.parse(jsonItem, symbolize_names: true)
           if !f[:deleted]
             fs[k.to_sym] = f
           end
@@ -137,43 +137,47 @@ and prefix: #{@prefix}")
       fs
     end
 
-    def delete(key, version)
+    def delete(kind, key, version)
       with_connection do |redis|
-        f = get_redis(redis, key)
+        f = get_redis(kind, redis, key)
         if f.nil?
-          put_redis_and_cache(redis, key, { deleted: true, version: version })
+          put_redis_and_cache(kind, redis, key, { deleted: true, version: version })
         else
           if f[:version] < version
             f1 = f.clone
             f1[:deleted] = true
             f1[:version] = version
-            put_redis_and_cache(redis, key, f1)
+            put_redis_and_cache(kind, redis, key, f1)
           else
-            @logger.warn("RedisFeatureStore: attempted to delete flag: #{key} version: #{f[:version]} \
-  with a version that is the same or older: #{version}")
+            @logger.warn("RedisFeatureStore: attempted to delete #{key} version: #{f[:version]} \
+  in '#{kind[:namespace]}' with a version that is the same or older: #{version}")
           end
         end
       end
     end
 
-    def init(fs)
+    def init(all_data)
       @cache.clear
+      count = 0
       with_connection do |redis|
-        redis.multi do |multi|
-          multi.del(@features_key)
-          fs.each { |k, f| put_redis_and_cache(multi, k, f) }
+        all_data.each do |kind, items|
+          redis.multi do |multi|
+            multi.del(items_key(kind))
+            count = count + items.count
+            items.each { |k, v| put_redis_and_cache(kind, multi, k, v) }
+          end
         end
       end
       @inited.set(true)
-      @logger.info("RedisFeatureStore: initialized with #{fs.count} feature flags")
+      @logger.info("RedisFeatureStore: initialized with #{count} items")
     end
 
-    def upsert(key, feature)
+    def upsert(kind, item)
       with_connection do |redis|
-        redis.watch(@features_key) do
-          old = get_redis(redis, key)
-          if old.nil? || (old[:version] < feature[:version])
-            put_redis_and_cache(redis, key, feature)
+        redis.watch(items_key(kind)) do
+          old = get_redis(kind, redis, item[:key])
+          if old.nil? || (old[:version] < item[:version])
+            put_redis_and_cache(kind, redis, item[:key], item)
           end
           redis.unwatch
         end
@@ -198,35 +202,43 @@ and prefix: #{@prefix}")
 
     private
 
+    def items_key(kind)
+      @prefix + ":" + kind[:namespace]
+    end
+
+    def cache_key(kind, key)
+      kind[:namespace] + ":" + key.to_s
+    end
+
     def with_connection
       @pool.with { |redis| yield(redis) }
     end
 
-    def get_redis(redis, key)
+    def get_redis(kind, redis, key)
       begin
-        json_feature = redis.hget(@features_key, key)
-        JSON.parse(json_feature, symbolize_names: true) if json_feature
+        json_item = redis.hget(items_key(kind), key)
+        JSON.parse(json_item, symbolize_names: true) if json_item
       rescue => e
-        @logger.error("RedisFeatureStore: could not retrieve feature #{key} from Redis, error: #{e}")
+        @logger.error("RedisFeatureStore: could not retrieve #{key} from Redis, error: #{e}")
         nil
       end
     end
 
-    def put_cache(key, value)
-      @cache.store(key, value, expires: @expiration_seconds)
+    def put_cache(kind, key, value)
+      @cache.store(cache_key(kind, key), value, expires: @expiration_seconds)
     end
 
-    def put_redis_and_cache(redis, key, feature)
+    def put_redis_and_cache(kind, redis, key, item)
       begin
-        redis.hset(@features_key, key, feature.to_json)
+        redis.hset(items_key(kind), key, item.to_json)
       rescue => e
         @logger.error("RedisFeatureStore: could not store #{key} in Redis, error: #{e}")
       end
-      put_cache(key.to_sym, feature)
+      put_cache(kind, key.to_sym, item)
     end
 
     def query_inited
-      with_connection { |redis| redis.exists(@features_key) }
+      with_connection { |redis| redis.exists(items_key(FEATURES)) }
     end
   end
 end