launchdarkly-server-sdk 5.7.3 → 6.0.0

data/lib/ldclient-rb/events.rb

@@ -238,10 +238,7 @@ module LaunchDarkly
         diagnostic_event_workers.shutdown
         diagnostic_event_workers.wait_for_termination
       end
-      begin
-        @client.finish
-      rescue
-      end
+      @event_sender.stop if @event_sender.respond_to?(:stop)
     end
 
     def synchronize_for_testing(flush_workers, diagnostic_event_workers)

data/lib/ldclient-rb/file_data_source.rb

@@ -51,7 +51,7 @@ module LaunchDarkly
   # output as the starting point for your file. In Linux you would do this:
   #
   # ```
-  #     curl -H "Authorization: YOUR_SDK_KEY" https://app.launchdarkly.com/sdk/latest-all
+  #     curl -H "Authorization: YOUR_SDK_KEY" https://sdk.launchdarkly.com/sdk/latest-all
   # ```
   #
   # The output will look something like this (but with many more properties):

data/lib/ldclient-rb/impl/evaluator.rb

@@ -0,0 +1,225 @@
+require "ldclient-rb/evaluation_detail"
+require "ldclient-rb/impl/evaluator_bucketing"
+require "ldclient-rb/impl/evaluator_operators"
+
+module LaunchDarkly
+  module Impl
+    # Encapsulates the feature flag evaluation logic. The Evaluator has no knowledge of the rest of the SDK environment;
+    # if it needs to retrieve flags or segments that are referenced by a flag, it does so through a simple function that
+    # is provided in the constructor. It also produces feature requests as appropriate for any referenced prerequisite
+    # flags, but does not send them.
+    class Evaluator
+      # A single Evaluator is instantiated for each client instance.
+      #
+      # @param get_flag [Function] called if the Evaluator needs to query a different flag from the one that it is
+      #   currently evaluating (i.e. a prerequisite flag); takes a single parameter, the flag key, and returns the
+      #   flag data - or nil if the flag is unknown or deleted
+      # @param get_segment [Function] similar to `get_flag`, but is used to query a user segment.
+      # @param logger [Logger] the client's logger
+      def initialize(get_flag, get_segment, logger)
+        @get_flag = get_flag
+        @get_segment = get_segment
+        @logger = logger
+      end
+
+      # Used internally to hold an evaluation result and the events that were generated from prerequisites. The
+      # `detail` property is an EvaluationDetail. The `events` property can be either an array of feature request
+      # events or nil.
+      EvalResult = Struct.new(:detail, :events)
+
+      # Helper function used internally to construct an EvaluationDetail for an error result.
+      def self.error_result(errorKind, value = nil)
+        EvaluationDetail.new(value, nil, EvaluationReason.error(errorKind))
+      end
+
+      # The client's entry point for evaluating a flag. The returned `EvalResult` contains the evaluation result and
+      # any events that were generated for prerequisite flags; its `value` will be `nil` if the flag returns the
+      # default value. Error conditions produce a result with a nil value and an error reason, not an exception.
+      #
+      # @param flag [Object] the flag
+      # @param user [Object] the user properties
+      # @param event_factory [EventFactory] called to construct a feature request event when a prerequisite flag is
+      #   evaluated; the caller is responsible for constructing the feature event for the top-level evaluation
+      # @return [EvalResult] the evaluation result 
+      def evaluate(flag, user, event_factory)
+        if user.nil? || user[:key].nil?
+          return EvalResult.new(Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED), [])
+        end
+
+        # If the flag doesn't have any prerequisites (which most flags don't) then it cannot generate any feature
+        # request events for prerequisites and we can skip allocating an array.
+        if flag[:prerequisites] && !flag[:prerequisites].empty?
+          events = []
+        else
+          events = nil
+        end
+
+        detail = eval_internal(flag, user, events, event_factory)
+        return EvalResult.new(detail, events.nil? || events.empty? ? nil : events)
+      end
+
+      private
+      
+      def eval_internal(flag, user, events, event_factory)
+        if !flag[:on]
+          return get_off_value(flag, EvaluationReason::off)
+        end
+
+        prereq_failure_reason = check_prerequisites(flag, user, events, event_factory)
+        if !prereq_failure_reason.nil?
+          return get_off_value(flag, prereq_failure_reason)
+        end
+
+        # Check user target matches
+        (flag[:targets] || []).each do |target|
+          (target[:values] || []).each do |value|
+            if value == user[:key]
+              return get_variation(flag, target[:variation], EvaluationReason::target_match)
+            end
+          end
+        end
+      
+        # Check custom rules
+        rules = flag[:rules] || []
+        rules.each_index do |i|
+          rule = rules[i]
+          if rule_match_user(rule, user)
+            reason = rule[:_reason]  # try to use cached reason for this rule
+            reason = EvaluationReason::rule_match(i, rule[:id]) if reason.nil?
+            return get_value_for_variation_or_rollout(flag, rule, user, reason)
+          end
+        end
+
+        # Check the fallthrough rule
+        if !flag[:fallthrough].nil?
+          return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user, EvaluationReason::fallthrough)
+        end
+
+        return EvaluationDetail.new(nil, nil, EvaluationReason::fallthrough)
+      end
+
+      def check_prerequisites(flag, user, events, event_factory)
+        (flag[:prerequisites] || []).each do |prerequisite|
+          prereq_ok = true
+          prereq_key = prerequisite[:key]
+          prereq_flag = @get_flag.call(prereq_key)
+
+          if prereq_flag.nil?
+            @logger.error { "[LDClient] Could not retrieve prerequisite flag \"#{prereq_key}\" when evaluating \"#{flag[:key]}\"" }
+            prereq_ok = false
+          else
+            begin
+              prereq_res = eval_internal(prereq_flag, user, events, event_factory)
+              # Note that if the prerequisite flag is off, we don't consider it a match no matter what its
+              # off variation was. But we still need to evaluate it in order to generate an event.
+              if !prereq_flag[:on] || prereq_res.variation_index != prerequisite[:variation]
+                prereq_ok = false
+              end
+              event = event_factory.new_eval_event(prereq_flag, user, prereq_res, nil, flag)
+              events.push(event)
+            rescue => exn
+              Util.log_exception(@logger, "Error evaluating prerequisite flag \"#{prereq_key}\" for flag \"#{flag[:key]}\"", exn)
+              prereq_ok = false
+            end
+          end
+          if !prereq_ok
+            reason = prerequisite[:_reason]  # try to use cached reason
+            return reason.nil? ? EvaluationReason::prerequisite_failed(prereq_key) : reason
+          end
+        end
+        nil
+      end
+
+      def rule_match_user(rule, user)
+        return false if !rule[:clauses]
+
+        (rule[:clauses] || []).each do |clause|
+          return false if !clause_match_user(clause, user)
+        end
+
+        return true
+      end
+
+      def clause_match_user(clause, user)
+        # 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
+          result = (clause[:values] || []).any? { |v|
+            segment = @get_segment.call(v)
+            !segment.nil? && segment_match_user(segment, user)
+          }
+          clause[:negate] ? !result : result
+        else
+          clause_match_user_no_segments(clause, user)
+        end
+      end
+
+      def clause_match_user_no_segments(clause, user)
+        user_val = EvaluatorOperators.user_value(user, clause[:attribute])
+        return false if user_val.nil?
+
+        op = clause[:op].to_sym
+        clause_vals = clause[:values]
+        result = if user_val.is_a? Enumerable
+          user_val.any? { |uv| clause_vals.any? { |cv| EvaluatorOperators.apply(op, uv, cv) } }
+        else
+          clause_vals.any? { |cv| EvaluatorOperators.apply(op, user_val, cv) }
+        end
+        clause[:negate] ? !result : result
+      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 = EvaluatorBucketing.bucket_user(user, segment_key, rule[:bucketBy].nil? ? "key" : rule[:bucketBy], salt)
+        weight = rule[:weight].to_f / 100000.0
+        return bucket < weight
+      end
+
+      private
+
+      def get_variation(flag, index, reason)
+        if index < 0 || index >= flag[:variations].length
+          @logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": invalid variation index")
+          return Evaluator.error_result(EvaluationReason::ERROR_MALFORMED_FLAG)
+        end
+        EvaluationDetail.new(flag[:variations][index], index, reason)
+      end
+
+      def get_off_value(flag, reason)
+        if flag[:offVariation].nil?  # off variation unspecified - return default value
+          return EvaluationDetail.new(nil, nil, reason)
+        end
+        get_variation(flag, flag[:offVariation], reason)
+      end
+
+      def get_value_for_variation_or_rollout(flag, vr, user, reason)
+        index = EvaluatorBucketing.variation_index_for_user(flag, vr, user)
+        if index.nil?
+          @logger.error("[LDClient] Data inconsistency in feature flag \"#{flag[:key]}\": variation/rollout object with no variation or rollout")
+          return Evaluator.error_result(EvaluationReason::ERROR_MALFORMED_FLAG)
+        end
+        return get_variation(flag, index, reason)
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/evaluator_bucketing.rb

@@ -0,0 +1,74 @@
+
+module LaunchDarkly
+  module Impl
+    # Encapsulates the logic for percentage rollouts.
+    module EvaluatorBucketing
+      # Applies either a fixed variation or a rollout for a rule (or the fallthrough rule).
+      #
+      # @param flag [Object] the feature flag
+      # @param rule [Object] the rule
+      # @param user [Object] the user properties
+      # @return [Number] the variation index, or nil if there is an error
+      def self.variation_index_for_user(flag, rule, user)
+        variation = rule[:variation]
+        return variation if !variation.nil? # fixed variation
+        rollout = rule[:rollout]
+        return nil if rollout.nil?
+        variations = rollout[:variations]
+        if !variations.nil? && variations.length > 0 # percentage rollout
+          rollout = rule[:rollout]
+          bucket_by = rollout[:bucketBy].nil? ? "key" : rollout[:bucketBy]
+          bucket = bucket_user(user, flag[:key], bucket_by, flag[:salt])
+          sum = 0;
+          variations.each do |variate|
+            sum += variate[:weight].to_f / 100000.0
+            if bucket < sum
+              return variate[:variation]
+            end
+          end
+          # The user's bucket value was greater than or equal to the end of the last bucket. This could happen due
+          # to a rounding error, or due to the fact that we are scaling to 100000 rather than 99999, or the flag
+          # data could contain buckets that don't actually add up to 100000. Rather than returning an error in
+          # this case (or changing the scaling, which would potentially change the results for *all* users), we
+          # will simply put the user in the last bucket.
+          variations[-1][:variation]
+        else # the rule isn't well-formed
+          nil
+        end
+      end
+
+      # Returns a user's bucket value as a floating-point value in `[0, 1)`.
+      #
+      # @param user [Object] the user properties
+      # @param key [String] the feature flag key (or segment key, if this is for a segment rule)
+      # @param bucket_by [String|Symbol] the name of the user attribute to be used for bucketing
+      # @param salt [String] the feature flag's or segment's salt value
+      # @return [Number] the bucket value, from 0 inclusive to 1 exclusive
+      def self.bucket_user(user, key, bucket_by, salt)
+        return nil unless user[:key]
+
+        id_hash = bucketable_string_value(EvaluatorOperators.user_value(user, bucket_by))
+        if id_hash.nil?
+          return 0.0
+        end
+
+        if user[:secondary]
+          id_hash += "." + user[:secondary].to_s
+        end
+
+        hash_key = "%s.%s.%s" % [key, salt, id_hash]
+
+        hash_val = (Digest::SHA1.hexdigest(hash_key))[0..14]
+        hash_val.to_i(16) / Float(0xFFFFFFFFFFFFFFF)
+      end
+
+      private
+
+      def self.bucketable_string_value(value)
+        return value if value.is_a? String
+        return value.to_s if value.is_a? Integer
+        nil
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/evaluator_operators.rb

@@ -0,0 +1,160 @@
+require "date"
+require "semantic"
+require "set"
+
+module LaunchDarkly
+  module Impl
+    # Defines the behavior of all operators that can be used in feature flag rules and segment rules.
+    module EvaluatorOperators
+      # Applies an operator to produce a boolean result.
+      #
+      # @param op [Symbol] one of the supported LaunchDarkly operators, as a symbol
+      # @param user_value the value of the user attribute that is referenced in the current clause (left-hand
+      #   side of the expression)
+      # @param clause_value the constant value that `user_value` is being compared to (right-hand side of the
+      #   expression)
+      # @return [Boolean] true if the expression should be considered a match; false if it is not a match, or
+      #   if the values cannot be compared because they are of the wrong types, or if the operator is unknown
+      def self.apply(op, user_value, clause_value)
+        case op
+        when :in
+          user_value == clause_value
+        when :startsWith
+          string_op(user_value, clause_value, lambda { |a, b| a.start_with? b })
+        when :endsWith
+          string_op(user_value, clause_value, lambda { |a, b| a.end_with? b })
+        when :contains
+          string_op(user_value, clause_value, lambda { |a, b| a.include? b })
+        when :matches
+          string_op(user_value, clause_value, lambda { |a, b|
+            begin
+              re = Regexp.new b
+              !re.match(a).nil?
+            rescue
+              false
+            end
+          })
+        when :lessThan
+          numeric_op(user_value, clause_value, lambda { |a, b| a < b })
+        when :lessThanOrEqual
+          numeric_op(user_value, clause_value, lambda { |a, b| a <= b })
+        when :greaterThan
+          numeric_op(user_value, clause_value, lambda { |a, b| a > b })
+        when :greaterThanOrEqual
+          numeric_op(user_value, clause_value, lambda { |a, b| a >= b })
+        when :before
+          date_op(user_value, clause_value, lambda { |a, b| a < b })
+        when :after
+          date_op(user_value, clause_value, lambda { |a, b| a > b })
+        when :semVerEqual
+          semver_op(user_value, clause_value, lambda { |a, b| a == b })
+        when :semVerLessThan
+          semver_op(user_value, clause_value, lambda { |a, b| a < b })
+        when :semVerGreaterThan
+          semver_op(user_value, clause_value, lambda { |a, b| a > b })
+        when :segmentMatch
+          # We should never reach this; it can't be evaluated based on just two parameters, because it requires
+          # looking up the segment from the data store. Instead, we special-case this operator in clause_match_user.
+          false
+        else
+          false
+        end
+      end
+
+      # Retrieves the value of a user attribute by name.
+      #
+      # Built-in attributes correspond to top-level properties in the user object. They are treated as strings and
+      # non-string values are coerced to strings, except for `anonymous` which is meant to be a boolean if present
+      # and is not currently coerced. This behavior is consistent with earlier versions of the Ruby SDK, but is not
+      # guaranteed to be consistent with other SDKs, since the evaluator specification is based on the strongly-typed
+      # SDKs where it is not possible for an attribute to have the wrong type.
+      #
+      # Custom attributes correspond to properties within the `custom` property, if any, and can be of any type.
+      #
+      # @param user [Object] the user properties
+      # @param attribute [String|Symbol] the attribute to get, for instance `:key` or `:name` or `:some_custom_attr`
+      # @return the attribute value, or nil if the attribute is unknown
+      def self.user_value(user, attribute)
+        attribute = attribute.to_sym
+        if BUILTINS.include? attribute
+          value = user[attribute]
+          return nil if value.nil?
+          (attribute == :anonymous) ? value : value.to_s
+        elsif !user[:custom].nil?
+          user[:custom][attribute]
+        else
+          nil
+        end
+      end
+
+      private
+
+      BUILTINS = Set[:key, :ip, :country, :email, :firstName, :lastName, :avatar, :name, :anonymous]
+      NUMERIC_VERSION_COMPONENTS_REGEX = Regexp.new("^[0-9.]*")
+
+      private_constant :BUILTINS
+      private_constant :NUMERIC_VERSION_COMPONENTS_REGEX
+
+      def self.string_op(user_value, clause_value, fn)
+        (user_value.is_a? String) && (clause_value.is_a? String) && fn.call(user_value, clause_value)
+      end
+
+      def self.numeric_op(user_value, clause_value, fn)
+        (user_value.is_a? Numeric) && (clause_value.is_a? Numeric) && fn.call(user_value, clause_value)
+      end
+
+      def self.date_op(user_value, clause_value, fn)
+        ud = to_date(user_value)
+        if !ud.nil?
+          cd = to_date(clause_value)
+          !cd.nil? && fn.call(ud, cd)
+        else
+          false
+        end
+      end
+
+      def self.semver_op(user_value, clause_value, fn)
+        uv = to_semver(user_value)
+        if !uv.nil?
+          cv = to_semver(clause_value)
+          !cv.nil? && fn.call(uv, cv)
+        else
+          false
+        end
+      end
+
+      def self.to_date(value)
+        if value.is_a? String
+          begin
+            DateTime.rfc3339(value).strftime("%Q").to_i
+          rescue => e
+            nil
+          end
+        elsif value.is_a? Numeric
+          value
+        else
+          nil
+        end
+      end
+
+      def self.to_semver(value)
+        if value.is_a? String
+          for _ in 0..2 do
+            begin
+              return Semantic::Version.new(value)
+            rescue ArgumentError
+              value = add_zero_version_component(value)
+            end
+          end
+        end
+        nil
+      end
+
+      def self.add_zero_version_component(v)
+        NUMERIC_VERSION_COMPONENTS_REGEX.match(v) { |m|
+          m[0] + ".0" + v[m[0].length..-1]
+        }
+      end
+    end
+  end
+end