launchdarkly-server-sdk 6.3.0 → 8.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)
+        index = flag.off_variation
+        index.nil? ? EvaluationDetail.new(nil, nil, reason) : evaluation_detail_for_variation(flag, index, reason)
+      end
+
+      #
+      # @param flag [LaunchDarkly::Impl::Model::FeatureFlag]
+      # @param index [Integer]
+      # @param reason [LaunchDarkly::EvaluationReason]
+      #
+      def self.evaluation_detail_for_variation(flag, index, reason)
+        vars = flag.variations
+        if index < 0 || index >= vars.length
+          EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          # This error condition has already been logged at the time we received the flag data - see model/feature_flag.rb
+        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,10 +60,11 @@ 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
+                  # Ignored
                 end
               end
               return EventSenderResult.new(true, false, res_time)
@@ -77,7 +78,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,136 @@
+require 'set'
+
+module LaunchDarkly
+  module Impl
+    class Event
+      # @param timestamp [Integer]
+      # @param context [LaunchDarkly::LDContext]
+      # @param sampling_ratio [Integer, nil]
+      # @param exclude_from_summaries [Boolean]
+      def initialize(timestamp, context, sampling_ratio = nil, exclude_from_summaries = false)
+        @timestamp = timestamp
+        @context = context
+        @sampling_ratio = sampling_ratio
+        @exclude_from_summaries = exclude_from_summaries
+      end
+
+      # @return [Integer]
+      attr_reader :timestamp
+      # @return [LaunchDarkly::LDContext]
+      attr_reader :context
+      # @return [Integer, nil]
+      attr_reader :sampling_ratio
+      # @return [Boolean]
+      attr_reader :exclude_from_summaries
+    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, sampling_ratio = nil, exclude_from_summaries = false)
+        super(timestamp, context, sampling_ratio, exclude_from_summaries)
+        @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 MigrationOpEvent < Event
+      #
+      # A migration op event represents the results of a migration-assisted read or write operation.
+      #
+      # The event includes optional measurements reporting on consistency checks, error reporting, and operation latency
+      # values.
+      #
+      # @param timestamp [Integer]
+      # @param context [LaunchDarkly::LDContext]
+      # @param key [string]
+      # @param flag [LaunchDarkly::Impl::Model::FeatureFlag, nil]
+      # @param operation [Symbol]
+      # @param default_stage [Symbol]
+      # @param evaluation [LaunchDarkly::EvaluationDetail]
+      # @param invoked [Set]
+      # @param consistency_check [Boolean, nil]
+      # @param consistency_check_ratio [Integer, nil]
+      # @param errors [Set]
+      # @param latencies [Hash<Symbol, Float>]
+      #
+      def initialize(timestamp, context, key, flag, operation, default_stage, evaluation, invoked, consistency_check, consistency_check_ratio, errors, latencies)
+        super(timestamp, context)
+        @operation = operation
+        @key = key
+        @version = flag&.version
+        @sampling_ratio = flag&.sampling_ratio
+        @default = default_stage
+        @evaluation = evaluation
+        @consistency_check = consistency_check
+        @consistency_check_ratio = consistency_check.nil? ? nil : consistency_check_ratio
+        @invoked = invoked
+        @errors = errors
+        @latencies = latencies
+      end
+
+      attr_reader :operation
+      attr_reader :key
+      attr_reader :version
+      attr_reader :sampling_ratio
+      attr_reader :default
+      attr_reader :evaluation
+      attr_reader :consistency_check
+      attr_reader :consistency_check_ratio
+      attr_reader :invoked
+      attr_reader :errors
+      attr_reader :latencies
+    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/flag_tracker.rb

@@ -0,0 +1,58 @@
+require "concurrent"
+require "ldclient-rb/interfaces"
+require "forwardable"
+
+module LaunchDarkly
+  module Impl
+    class FlagTracker
+      include LaunchDarkly::Interfaces::FlagTracker
+
+      extend Forwardable
+      def_delegators :@broadcaster, :add_listener, :remove_listener
+
+      def initialize(broadcaster, eval_fn)
+        @broadcaster = broadcaster
+        @eval_fn = eval_fn
+      end
+
+      def add_flag_value_change_listener(key, context, listener)
+        flag_change_listener = FlagValueChangeAdapter.new(key, context, listener, @eval_fn)
+        add_listener(flag_change_listener)
+
+        flag_change_listener
+      end
+
+      #
+      # An adapter which turns a normal flag change listener into a flag value change listener.
+      #
+      class FlagValueChangeAdapter
+        # @param [Symbol] flag_key
+        # @param [LaunchDarkly::LDContext] context
+        # @param [#update] listener
+        # @param [#call] eval_fn
+        def initialize(flag_key, context, listener, eval_fn)
+          @flag_key = flag_key
+          @context = context
+          @listener = listener
+          @eval_fn = eval_fn
+          @value = Concurrent::AtomicReference.new(@eval_fn.call(@flag_key, @context))
+        end
+
+        #
+        # @param [LaunchDarkly::Interfaces::FlagChange] flag_change
+        #
+        def update(flag_change)
+          return unless flag_change.key == @flag_key
+
+          new_eval = @eval_fn.call(@flag_key, @context)
+          old_eval = @value.get_and_set(new_eval)
+
+          return if new_eval == old_eval
+
+          @listener.update(
+            LaunchDarkly::Interfaces::FlagValueChange.new(@flag_key, old_eval, new_eval))
+        end
+      end
+    end
+  end
+end