launchdarkly-server-sdk 6.2.5 → 7.0.0

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

@@ -1,4 +1,3 @@
-
 module LaunchDarkly
   module Impl
     # Encapsulates the logic for percentage rollouts.
@@ -6,64 +5,64 @@ module LaunchDarkly
       # 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, false if !variation.nil? # fixed variation
-        rollout = rule[:rollout]
+      # @param vr [LaunchDarkly::Impl::Model::VariationOrRollout] the variation/rollout properties
+      # @param context [LaunchDarkly::LDContext] the context properties
+      # @return [Array<[Number, nil], Boolean>] the variation index, or nil if there is an error
+      # @raise [InvalidReferenceException]
+      def self.variation_index_for_context(flag, vr, context)
+        variation = vr.variation
+        return variation, false unless variation.nil? # fixed variation
+        rollout = vr.rollout
         return nil, false if rollout.nil?
-        variations = rollout[:variations]
+        variations = rollout.variations
         if !variations.nil? && variations.length > 0 # percentage rollout
-          bucket_by = rollout[:bucketBy].nil? ? "key" : rollout[:bucketBy]
+          rollout_is_experiment = rollout.is_experiment
+          bucket_by = rollout_is_experiment ? nil : rollout.bucket_by
+          bucket_by = 'key' if bucket_by.nil?
 
-          seed = rollout[:seed]
-          bucket = bucket_user(user, flag[:key], bucket_by, flag[:salt], seed) # may not be present
-          sum = 0;
+          seed = rollout.seed
+          bucket = bucket_context(context, rollout.context_kind, flag.key, bucket_by, flag.salt, seed) # may not be present
+          in_experiment = rollout_is_experiment && !bucket.nil?
+          sum = 0
           variations.each do |variate|
-            if rollout[:kind] == "experiment" && !variate[:untracked]
-              in_experiment = true
-            end
-
-            sum += variate[:weight].to_f / 100000.0
-            if bucket < sum
-              return variate[:variation], !!in_experiment
+            sum += variate.weight.to_f / 100000.0
+            if bucket.nil? || bucket < sum
+              return variate.variation, in_experiment && !variate.untracked
             end
           end
-          # The user's bucket value was greater than or equal to the end of the last bucket. This could happen due
+          # The context'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.
+          # this case (or changing the scaling, which would potentially change the results for *all* contexts), we
+          # will simply put the context in the last bucket.
           last_variation = variations[-1]
-          in_experiment = rollout[:kind] == "experiment" && !last_variation[:untracked]
-
-          [last_variation[:variation], in_experiment]
+          [last_variation.variation, in_experiment && !last_variation.untracked]
         else # the rule isn't well-formed
           [nil, false]
         end
       end
 
-      # Returns a user's bucket value as a floating-point value in `[0, 1)`.
+      # Returns a context's bucket value as a floating-point value in `[0, 1)`.
       #
-      # @param user [Object] the user properties
+      # @param context [LDContext] the context properties
+      # @param context_kind [String, nil] the context kind to match against
       # @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 bucket_by [String|Symbol] the name of the context 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, seed)
-        return nil unless user[:key]
+      # @return [Float, nil] the bucket value, from 0 inclusive to 1 exclusive
+      # @raise [InvalidReferenceException] Raised if the clause.attribute is an invalid reference
+      def self.bucket_context(context, context_kind, key, bucket_by, salt, seed)
+        matched_context = context.individual_context(context_kind || LaunchDarkly::LDContext::KIND_DEFAULT)
+        return nil if matched_context.nil?
 
-        id_hash = bucketable_string_value(EvaluatorOperators.user_value(user, bucket_by))
-        if id_hash.nil?
-          return 0.0
-        end
+        reference = (context_kind.nil? || context_kind.empty?) ? Reference.create_literal(bucket_by) : Reference.create(bucket_by)
+        raise InvalidReferenceException.new(reference.error) unless reference.error.nil?
 
-        if user[:secondary]
-          id_hash += "." + user[:secondary].to_s
-        end
+        context_value = matched_context.get_value_for_reference(reference)
+        return 0.0 if context_value.nil?
+
+        id_hash = bucketable_string_value(context_value)
+        return 0.0 if id_hash.nil?
 
         if seed
           hash_key = "%d.%s" % [seed, id_hash]
@@ -71,7 +70,7 @@ module LaunchDarkly
           hash_key = "%s.%s.%s" % [key, salt, id_hash]
         end
 
-        hash_val = (Digest::SHA1.hexdigest(hash_key))[0..14]
+        hash_val = Digest::SHA1.hexdigest(hash_key)[0..14]
         hash_val.to_i(16) / Float(0xFFFFFFFFFFFFFFF)
       end
 

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

@@ -0,0 +1,50 @@
+require "ldclient-rb/evaluation_detail"
+
+# This file contains any pieces of low-level evaluation logic that don't need to be inside the Evaluator
+# class, because they don't depend on any SDK state outside of their input parameters.
+
+module LaunchDarkly
+  module Impl
+    module EvaluatorHelpers
+      #
+      # @param flag [LaunchDarkly::Impl::Model::FeatureFlag]
+      # @param reason [LaunchDarkly::EvaluationReason]
+      #
+      def self.evaluation_detail_for_off_variation(flag, reason, logger = nil)
+        index = flag.off_variation
+        index.nil? ? EvaluationDetail.new(nil, nil, reason) : evaluation_detail_for_variation(flag, index, reason, logger)
+      end
+
+      #
+      # @param flag [LaunchDarkly::Impl::Model::FeatureFlag]
+      # @param index [Integer]
+      # @param reason [LaunchDarkly::EvaluationReason]
+      #
+      def self.evaluation_detail_for_variation(flag, index, reason, logger = nil)
+        vars = flag.variations
+        if index < 0 || index >= vars.length
+          logger.error("[LDClient] Data inconsistency in feature flag \"#{flag.key}\": invalid variation index") unless logger.nil?
+          EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+        else
+          EvaluationDetail.new(vars[index], index, reason)
+        end
+      end
+
+      #
+      # @param context [LaunchDarkly::LDContext]
+      # @param kind [String, nil]
+      # @param keys [Enumerable<String>]
+      # @return [Boolean]
+      #
+      def self.context_key_in_target_list(context, kind, keys)
+        return false unless keys.is_a? Enumerable
+        return false if keys.empty?
+
+        matched_context = context.individual_context(kind || LaunchDarkly::LDContext::KIND_DEFAULT)
+        return false if matched_context.nil?
+
+        keys.include? matched_context.key
+      end
+    end
+  end
+end

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

@@ -9,24 +9,24 @@ module LaunchDarkly
       # 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
+      # @param context_value the value of the context 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
+      # @param clause_value the constant value that `context_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)
+      def self.apply(op, context_value, clause_value)
         case op
         when :in
-          user_value == clause_value
+          context_value == clause_value
         when :startsWith
-          string_op(user_value, clause_value, lambda { |a, b| a.start_with? b })
+          string_op(context_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 })
+          string_op(context_value, clause_value, lambda { |a, b| a.end_with? b })
         when :contains
-          string_op(user_value, clause_value, lambda { |a, b| a.include? b })
+          string_op(context_value, clause_value, lambda { |a, b| a.include? b })
         when :matches
-          string_op(user_value, clause_value, lambda { |a, b|
+          string_op(context_value, clause_value, lambda { |a, b|
             begin
               re = Regexp.new b
               !re.match(a).nil?
@@ -35,76 +35,47 @@ module LaunchDarkly
             end
           })
         when :lessThan
-          numeric_op(user_value, clause_value, lambda { |a, b| a < b })
+          numeric_op(context_value, clause_value, lambda { |a, b| a < b })
         when :lessThanOrEqual
-          numeric_op(user_value, clause_value, lambda { |a, b| a <= b })
+          numeric_op(context_value, clause_value, lambda { |a, b| a <= b })
         when :greaterThan
-          numeric_op(user_value, clause_value, lambda { |a, b| a > b })
+          numeric_op(context_value, clause_value, lambda { |a, b| a > b })
         when :greaterThanOrEqual
-          numeric_op(user_value, clause_value, lambda { |a, b| a >= b })
+          numeric_op(context_value, clause_value, lambda { |a, b| a >= b })
         when :before
-          date_op(user_value, clause_value, lambda { |a, b| a < b })
+          date_op(context_value, clause_value, lambda { |a, b| a < b })
         when :after
-          date_op(user_value, clause_value, lambda { |a, b| a > b })
+          date_op(context_value, clause_value, lambda { |a, b| a > b })
         when :semVerEqual
-          semver_op(user_value, clause_value, lambda { |a, b| a == b })
+          semver_op(context_value, clause_value, lambda { |a, b| a == b })
         when :semVerLessThan
-          semver_op(user_value, clause_value, lambda { |a, b| a < b })
+          semver_op(context_value, clause_value, lambda { |a, b| a < b })
         when :semVerGreaterThan
-          semver_op(user_value, clause_value, lambda { |a, b| a > b })
+          semver_op(context_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.
+          # looking up the segment from the data store. Instead, we special-case this operator in clause_match_context.
           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)
+      def self.string_op(context_value, clause_value, fn)
+        (context_value.is_a? String) && (clause_value.is_a? String) && fn.call(context_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)
+      def self.numeric_op(context_value, clause_value, fn)
+        (context_value.is_a? Numeric) && (clause_value.is_a? Numeric) && fn.call(context_value, clause_value)
       end
 
-      def self.date_op(user_value, clause_value, fn)
-        ud = to_date(user_value)
+      def self.date_op(context_value, clause_value, fn)
+        ud = to_date(context_value)
         if !ud.nil?
           cd = to_date(clause_value)
           !cd.nil? && fn.call(ud, cd)
@@ -113,8 +84,8 @@ module LaunchDarkly
         end
       end
 
-      def self.semver_op(user_value, clause_value, fn)
-        uv = to_semver(user_value)
+      def self.semver_op(context_value, clause_value, fn)
+        uv = to_semver(context_value)
         if !uv.nil?
           cv = to_semver(clause_value)
           !cv.nil? && fn.call(uv, cv)

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

@@ -8,7 +8,7 @@ module LaunchDarkly
     EventSenderResult = Struct.new(:success, :must_shutdown, :time_from_server)
 
     class EventSender
-      CURRENT_SCHEMA_VERSION = 3
+      CURRENT_SCHEMA_VERSION = 4
       DEFAULT_RETRY_INTERVAL = 1
 
       def initialize(sdk_key, config, http_client = nil, retry_interval = DEFAULT_RETRY_INTERVAL)
@@ -33,7 +33,7 @@ module LaunchDarkly
         begin
           http_client = @http_client_pool.acquire()
           response = nil
-          (0..1).each do |attempt|
+          2.times do |attempt|
             if attempt > 0
               @logger.warn { "[LDClient] Will retry posting events after #{@retry_interval} second" }
               sleep(@retry_interval)
@@ -43,13 +43,13 @@ module LaunchDarkly
               headers = {}
               headers["content-type"] = "application/json"
               Impl::Util.default_http_headers(@sdk_key, @config).each { |k, v| headers[k] = v }
-              if !is_diagnostic
+              unless is_diagnostic
                 headers["X-LaunchDarkly-Event-Schema"] = CURRENT_SCHEMA_VERSION.to_s
                 headers["X-LaunchDarkly-Payload-ID"] = payload_id
               end
               response = http_client.request("POST", uri, {
                 headers: headers,
-                body: event_data
+                body: event_data,
               })
             rescue StandardError => exn
               @logger.warn { "[LDClient] Error sending events: #{exn.inspect}." }
@@ -60,7 +60,7 @@ module LaunchDarkly
             body = response.to_s
             if status >= 200 && status < 300
               res_time = nil
-              if !response.headers["date"].nil?
+              unless response.headers["date"].nil?
                 begin
                   res_time = Time.httpdate(response.headers["date"])
                 rescue ArgumentError
@@ -77,7 +77,7 @@ module LaunchDarkly
             end
           end
           # used up our retries
-          return EventSenderResult.new(false, false, nil)
+          EventSenderResult.new(false, false, nil)
         ensure
           @http_client_pool.release(http_client)
         end

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

@@ -0,0 +1,68 @@
+require "ldclient-rb/impl/event_types"
+require "set"
+
+module LaunchDarkly
+  module Impl
+    EventSummary = Struct.new(:start_date, :end_date, :counters)
+
+    EventSummaryFlagInfo = Struct.new(:default, :versions, :context_kinds)
+
+    EventSummaryFlagVariationCounter = Struct.new(:value, :count)
+
+    # Manages the state of summarizable information for the EventProcessor, including the
+    # event counters and context deduplication. Note that the methods of this class are
+    # deliberately not thread-safe; the EventProcessor is responsible for enforcing
+    # synchronization across both the summarizer and the event queue.
+    class EventSummarizer
+      class Counter
+      end
+
+      def initialize
+        clear
+      end
+
+      # Adds this event to our counters, if it is a type of event we need to count.
+      def summarize_event(event)
+        return unless event.is_a?(LaunchDarkly::Impl::EvalEvent)
+
+        counters_for_flag = @counters[event.key]
+        if counters_for_flag.nil?
+          counters_for_flag = EventSummaryFlagInfo.new(event.default, Hash.new, Set.new)
+          @counters[event.key] = counters_for_flag
+        end
+
+        counters_for_flag_version = counters_for_flag.versions[event.version]
+        if counters_for_flag_version.nil?
+          counters_for_flag_version = Hash.new
+          counters_for_flag.versions[event.version] = counters_for_flag_version
+        end
+
+        counters_for_flag.context_kinds.merge(event.context.kinds)
+
+        variation_counter = counters_for_flag_version[event.variation]
+        if variation_counter.nil?
+          counters_for_flag_version[event.variation] = EventSummaryFlagVariationCounter.new(event.value, 1)
+        else
+          variation_counter.count = variation_counter.count + 1
+        end
+
+        time = event.timestamp
+        unless time.nil?
+          @start_date = time if @start_date == 0 || time < @start_date
+          @end_date = time if time > @end_date
+        end
+      end
+
+      # Returns a snapshot of the current summarized event data, and resets this state.
+      def snapshot
+        EventSummary.new(@start_date, @end_date, @counters)
+      end
+
+      def clear
+        @start_date = 0
+        @end_date = 0
+        @counters = {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module LaunchDarkly
+  module Impl
+    class Event
+      # @param timestamp [Integer]
+      # @param context [LaunchDarkly::LDContext]
+      def initialize(timestamp, context)
+        @timestamp = timestamp
+        @context = context
+      end
+
+      # @return [Integer]
+      attr_reader :timestamp
+      # @return [LaunchDarkly::LDContext]
+      attr_reader :context
+    end
+
+    class EvalEvent < Event
+      def initialize(timestamp, context, key, version = nil, variation = nil, value = nil, reason = nil, default = nil,
+        track_events = false, debug_until = nil, prereq_of = nil)
+        super(timestamp, context)
+        @key = key
+        @version = version
+        @variation = variation
+        @value = value
+        @reason = reason
+        @default = default
+        # avoid setting rarely-used attributes if they have no value - this saves a little space per instance
+        @track_events = track_events if track_events
+        @debug_until = debug_until if debug_until
+        @prereq_of = prereq_of if prereq_of
+      end
+
+      attr_reader :key
+      attr_reader :version
+      attr_reader :variation
+      attr_reader :value
+      attr_reader :reason
+      attr_reader :default
+      attr_reader :track_events
+      attr_reader :debug_until
+      attr_reader :prereq_of
+    end
+
+    class IdentifyEvent < Event
+      def initialize(timestamp, context)
+        super(timestamp, context)
+      end
+    end
+
+    class CustomEvent < Event
+      def initialize(timestamp, context, key, data = nil, metric_value = nil)
+        super(timestamp, context)
+        @key = key
+        @data = data unless data.nil?
+        @metric_value = metric_value unless metric_value.nil?
+      end
+
+      attr_reader :key
+      attr_reader :data
+      attr_reader :metric_value
+    end
+
+    class IndexEvent < Event
+      def initialize(timestamp, context)
+        super(timestamp, context)
+      end
+    end
+
+    class DebugEvent < Event
+      def initialize(eval_event)
+        super(eval_event.timestamp, eval_event.context)
+        @eval_event = eval_event
+      end
+
+      attr_reader :eval_event
+    end
+  end
+end

data/lib/ldclient-rb/impl/integrations/consul_impl.rb

@@ -16,14 +16,14 @@ module LaunchDarkly
           end
 
           def initialize(opts)
-            if !CONSUL_ENABLED
+            unless CONSUL_ENABLED
               raise RuntimeError.new("can't use Consul feature store without the 'diplomat' gem")
             end
 
             @prefix = (opts[:prefix] || LaunchDarkly::Integrations::Consul.default_prefix) + '/'
             @logger = opts[:logger] || Config.default_logger
-            Diplomat.configuration = opts[:consul_config] if !opts[:consul_config].nil?
-            Diplomat.configuration.url = opts[:url] if !opts[:url].nil?
+            Diplomat.configuration = opts[:consul_config] unless opts[:consul_config].nil?
+            Diplomat.configuration.url = opts[:url] unless opts[:url].nil?
             @logger.info("ConsulFeatureStore: using Consul host at #{Diplomat.configuration.url}")
           end
 
@@ -51,10 +51,10 @@ module LaunchDarkly
             unused_old_keys.each do |key|
               ops.push({ 'KV' => { 'Verb' => 'delete', 'Key' => key } })
             end
-    
+
             # Now set the special key that we check in initialized_internal?
             ops.push({ 'KV' => { 'Verb' => 'set', 'Key' => inited_key, 'Value' => '' } })
-            
+
             ConsulUtil.batch_operations(ops)
 
             @logger.info { "Initialized database with #{num_items} items" }
@@ -70,7 +70,7 @@ module LaunchDarkly
             results = Diplomat::Kv.get(kind_key(kind), { recurse: true }, :return)
             (results == "" ? [] : results).each do |result|
               value = result[:value]
-              if !value.nil?
+              unless value.nil?
                 item = Model.deserialize(kind, value)
                 items_out[item[:key].to_sym] = item
               end
@@ -132,7 +132,7 @@ module LaunchDarkly
           def kind_key(kind)
             @prefix + kind[:namespace] + '/'
           end
-          
+
           def inited_key
             @prefix + '$inited'
           end