launchdarkly-server-sdk 6.3.4 → 6.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50934709e1ee8c075c56c149f75753f87498eb9e1f06e39597d2cd4514ea7196
-  data.tar.gz: e7f153366b7b50c3951f844bf9ce1a0b81093fc733818dbb02e8f0a888d9ac26
+  metadata.gz: 147fe8142bffa0d8e754e86669f524f6d787930e8bc6b8a14d30429933a036e3
+  data.tar.gz: e4a404cb7bc911f7c156c3fe5059ee9a4a9d7ebfeacba4c52f44ceb116276835
 SHA512:
-  metadata.gz: 2469e536ca482489eb46f3ff650aeb573eb691ab6c6c2b8ed669b7f8ba799bf65d68d40f6cabc51ec4b051dd56e309430f94e5dc4fbbd70193efa5156d1d1082
-  data.tar.gz: 454219746c7b296fd8c92ee5e266f96765f72527706b7d6f7360445eb1d245e2acb37e4cb722ed48bf73dce8e307d2121771270ea9bedb71e91d67f9a79b8ea0
+  metadata.gz: '039348a1a0c9284e79e641b69f11bdc4e8ba57c4cad3320eea6f8bb8caf8fc0f52a02c427a2b4f26584945e5750b7728706855cfaf6bdc22a1863b55bcf934a6'
+  data.tar.gz: 452c574e6ff6323a74dfdcf6a5c936ff38bfaa0efc3b58ff190068322ea82e25b15dc20868eb22bf93361d3daa699bd51fa362e97f30f4fc6bcf402f9f5597d9

data/lib/ldclient-rb/config.rb

@@ -44,6 +44,7 @@ module LaunchDarkly
     # @option opts [String] :wrapper_version See {#wrapper_version}.
     # @option opts [#open] :socket_factory See {#socket_factory}.
     # @option opts [BigSegmentsConfig] :big_segments See {#big_segments}.
+    # @option opts [Hash] :application See {#application}
     #
     def initialize(opts = {})
       @base_uri = (opts[:base_uri] || Config.default_base_uri).chomp("/")
@@ -77,6 +78,7 @@ module LaunchDarkly
       @wrapper_version = opts[:wrapper_version]
       @socket_factory = opts[:socket_factory]
       @big_segments = opts[:big_segments] || BigSegmentsConfig.new(store: nil)
+      @application = LaunchDarkly::Impl::Util.validate_application_info(opts[:application] || {}, @logger)
     end
 
     #
@@ -284,6 +286,24 @@ module LaunchDarkly
     #
     attr_reader :big_segments
 
+    #
+    # An object that allows configuration of application metadata.
+    #
+    # Application metadata may be used in LaunchDarkly analytics or other product features, but does not affect feature flag evaluations.
+    #
+    # If you want to set non-default values for any of these fields, provide the appropriately configured hash to the {Config} object.
+    #
+    # @example Configuring application information
+    #   opts[:application] = {
+    #     id: "MY APPLICATION ID",
+    #     version: "MY APPLICATION VERSION"
+    #   }
+    #   config = LDConfig.new(opts)
+    #
+    # @return [Hash]
+    #
+    attr_reader :application
+
     # @deprecated This is replaced by {#data_source}.
     attr_reader :update_processor
     

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

@@ -1,5 +1,6 @@
 require "ldclient-rb/evaluation_detail"
 require "ldclient-rb/impl/evaluator_bucketing"
+require "ldclient-rb/impl/evaluator_helpers"
 require "ldclient-rb/impl/evaluator_operators"
 
 module LaunchDarkly
@@ -87,19 +88,17 @@ module LaunchDarkly
       
       def eval_internal(flag, user, state)
         if !flag[:on]
-          return get_off_value(flag, EvaluationReason::off)
+          return EvaluatorHelpers.off_result(flag)
         end
 
-        prereq_failure_reason = check_prerequisites(flag, user, state)
-        if !prereq_failure_reason.nil?
-          return get_off_value(flag, prereq_failure_reason)
-        end
+        prereq_failure_result = check_prerequisites(flag, user, state)
+        return prereq_failure_result if !prereq_failure_result.nil?
 
         # 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)
+              return EvaluatorHelpers.target_match_result(target, flag)
             end
           end
         end
@@ -111,13 +110,15 @@ module LaunchDarkly
           if rule_match_user(rule, user, state)
             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)
+            return get_value_for_variation_or_rollout(flag, rule, user, reason,
+              EvaluatorHelpers.rule_precomputed_results(rule))
           end
         end
 
         # Check the fallthrough rule
         if !flag[:fallthrough].nil?
-          return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user, EvaluationReason::fallthrough)
+          return get_value_for_variation_or_rollout(flag, flag[:fallthrough], user, EvaluationReason::fallthrough,
+            EvaluatorHelpers.fallthrough_precomputed_results(flag))
         end
 
         return EvaluationDetail.new(nil, nil, EvaluationReason::fallthrough)
@@ -149,8 +150,7 @@ module LaunchDarkly
             end
           end
           if !prereq_ok
-            reason = prerequisite[:_reason]  # try to use cached reason
-            return reason.nil? ? EvaluationReason::prerequisite_failed(prereq_key) : reason
+            return EvaluatorHelpers.prerequisite_failed_result(prerequisite, flag)
           end
         end
         nil
@@ -253,35 +253,26 @@ module LaunchDarkly
       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)
+      
+      def get_value_for_variation_or_rollout(flag, vr, user, reason, precomputed_results)
         index, in_experiment = EvaluatorBucketing.variation_index_for_user(flag, vr, user)
-        #if in experiment is true, set reason to a different reason instance/singleton with in_experiment set
-        if in_experiment && reason.kind == :FALLTHROUGH
-          reason = EvaluationReason::fallthrough(in_experiment)
-        elsif in_experiment && reason.kind == :RULE_MATCH
-          reason = EvaluationReason::rule_match(reason.rule_index, reason.rule_id, in_experiment)
-        end
         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)
+        if precomputed_results
+          return precomputed_results.for_variation(index, in_experiment)
+        else
+          #if in experiment is true, set reason to a different reason instance/singleton with in_experiment set
+          if in_experiment
+            if reason.kind == :FALLTHROUGH
+              reason = EvaluationReason::fallthrough(in_experiment)
+            elsif reason.kind == :RULE_MATCH
+              reason = EvaluationReason::rule_match(reason.rule_index, reason.rule_id, in_experiment)
+            end
+          end
+          return EvaluatorHelpers.evaluation_detail_for_variation(flag, index, reason)
+        end
       end
     end
   end

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

@@ -0,0 +1,53 @@
+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
+      def self.off_result(flag, logger = nil)
+        pre = flag[:_preprocessed]
+        pre ? pre.off_result : evaluation_detail_for_off_variation(flag, EvaluationReason::off, logger)
+      end
+
+      def self.target_match_result(target, flag, logger = nil)
+        pre = target[:_preprocessed]
+        pre ? pre.match_result : evaluation_detail_for_variation(
+          flag, target[:variation], EvaluationReason::target_match, logger)
+      end
+
+      def self.prerequisite_failed_result(prereq, flag, logger = nil)
+        pre = prereq[:_preprocessed]
+        pre ? pre.failed_result : evaluation_detail_for_off_variation(
+          flag, EvaluationReason::prerequisite_failed(prereq[:key]), logger
+        )
+      end
+
+      def self.fallthrough_precomputed_results(flag)
+        pre = flag[:_preprocessed]
+        pre ? pre.fallthrough_factory : nil
+      end
+
+      def self.rule_precomputed_results(rule)
+        pre = rule[:_preprocessed]
+        pre ? pre.all_match_results : nil
+      end
+
+      def self.evaluation_detail_for_off_variation(flag, reason, logger = nil)
+        index = flag[:offVariation]
+        index.nil? ? EvaluationDetail.new(nil, nil, reason) : evaluation_detail_for_variation(flag, index, reason, logger)
+      end
+
+      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
+    end
+  end
+end

data/lib/ldclient-rb/impl/model/preprocessed_data.rb

@@ -0,0 +1,177 @@
+require "ldclient-rb/impl/evaluator_helpers"
+
+module LaunchDarkly
+  module Impl
+    module DataModelPreprocessing
+      #
+      # Container for a precomputed result that includes a specific variation index and value, an
+      # evaluation reason, and optionally an alternate evaluation reason that corresponds to the
+      # "in experiment" state.
+      #
+      class EvalResultsForSingleVariation
+        def initialize(value, variation_index, regular_reason, in_experiment_reason = nil)
+          @regular_result = EvaluationDetail.new(value, variation_index, regular_reason)
+          @in_experiment_result = in_experiment_reason ?
+            EvaluationDetail.new(value, variation_index, in_experiment_reason) :
+            @regular_result
+        end
+
+        # @param in_experiment [Boolean] indicates whether we want the result to include
+        #   "inExperiment: true" in the reason or not
+        # @return [EvaluationDetail]
+        def get_result(in_experiment = false)
+          in_experiment ? @in_experiment_result : @regular_result
+        end
+      end
+
+      #
+      # Container for a set of precomputed results, one for each possible flag variation.
+      #
+      class EvalResultFactoryMultiVariations
+        def initialize(variation_factories)
+          @factories = variation_factories
+        end
+
+        # @param index [Integer] the variation index
+        # @param in_experiment [Boolean] indicates whether we want the result to include
+        #   "inExperiment: true" in the reason or not
+        def for_variation(index, in_experiment)
+          if index < 0 || index >= @factories.length
+            EvaluationDetail.new(nil, nil, EvaluationReason.error(EvaluationReason::ERROR_MALFORMED_FLAG))
+          else
+            @factories[index].get_result(in_experiment)
+          end
+        end 
+      end
+
+      # Base class for all of the preprocessed data classes we embed in our data model. Using this class
+      # ensures that none of its properties will be included in JSON representations. It also overrides
+      # == to say that it is always equal with another instance of the same class; equality tests on
+      # this class are only ever done in test code, and we want the contents of these classes to be
+      # ignored in test code unless we are looking at specific attributes.
+      class PreprocessedDataBase
+        def as_json(*)
+          nil
+        end
+        
+        def to_json(*a)
+          "null"
+        end
+
+        def ==(other)
+          other.class == self.class
+        end
+      end
+
+      class FlagPreprocessed < PreprocessedDataBase
+        def initialize(off_result, fallthrough_factory)
+          @off_result = off_result
+          @fallthrough_factory = fallthrough_factory
+        end
+
+        # @return [EvalResultsForSingleVariation]
+        attr_reader :off_result
+        # @return [EvalResultFactoryMultiVariations]
+        attr_reader :fallthrough_factory
+      end
+
+      class PrerequisitePreprocessed < PreprocessedDataBase
+        def initialize(failed_result)
+          @failed_result = failed_result
+        end
+
+        # @return [EvalResultsForSingleVariation]
+        attr_reader :failed_result
+      end
+
+      class TargetPreprocessed < PreprocessedDataBase
+        def initialize(match_result)
+          @match_result = match_result
+        end
+
+        # @return [EvalResultsForSingleVariation]
+        attr_reader :match_result
+      end
+
+      class FlagRulePreprocessed < PreprocessedDataBase
+        def initialize(all_match_results)
+          @all_match_results = all_match_results
+        end
+
+        # @return [EvalResultsForSingleVariation]
+        attr_reader :all_match_results
+      end
+
+      class Preprocessor
+        def initialize(logger = nil)
+          @logger = logger
+        end
+
+        def preprocess_item!(kind, item)
+          if kind.eql? FEATURES
+            preprocess_flag!(item)
+          elsif kind.eql? SEGMENTS
+            preprocess_segment!(item)
+          end
+        end
+
+        def preprocess_all_items!(kind, items_map)
+          return items_map if !items_map
+          items_map.each do |key, item|
+            preprocess_item!(kind, item)
+          end
+        end
+
+        def preprocess_flag!(flag)
+          flag[:_preprocessed] = FlagPreprocessed.new(
+            EvaluatorHelpers.off_result(flag),
+            precompute_multi_variation_results(flag, EvaluationReason::fallthrough(false), EvaluationReason::fallthrough(true))
+          )
+          (flag[:prerequisites] || []).each do |prereq|
+            preprocess_prerequisite!(prereq, flag)
+          end
+          (flag[:targets] || []).each do |target|
+            preprocess_target!(target, flag)
+          end
+          rules = flag[:rules]
+          (rules || []).each_index do |index|
+            preprocess_flag_rule!(rules[index], index, flag)
+          end
+        end
+  
+        def preprocess_segment!(segment)
+          # nothing to do for segments currently
+        end
+  
+        private def preprocess_prerequisite!(prereq, flag)
+          prereq[:_preprocessed] = PrerequisitePreprocessed.new(
+            EvaluatorHelpers.prerequisite_failed_result(prereq, flag, @logger)
+          )
+        end
+  
+        private def preprocess_target!(target, flag)
+          target[:_preprocessed] = TargetPreprocessed.new(
+            EvaluatorHelpers.target_match_result(target, flag, @logger)
+          )
+        end
+  
+        private def preprocess_flag_rule!(rule, index, flag)
+          match_reason = EvaluationReason::rule_match(index, rule[:id])
+          match_reason_in_experiment = EvaluationReason::rule_match(index, rule[:id], true)
+          rule[:_preprocessed] = FlagRulePreprocessed.new(
+            precompute_multi_variation_results(flag, match_reason, match_reason_in_experiment)
+          )
+        end
+  
+        private def precompute_multi_variation_results(flag, regular_reason, in_experiment_reason)
+          factories = []
+          vars = flag[:variations] || []
+          vars.each_index do |index|
+            factories << EvalResultsForSingleVariation.new(vars[index], index, regular_reason, in_experiment_reason)
+          end
+          EvalResultFactoryMultiVariations.new(factories)
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/model/serialization.rb

@@ -1,13 +1,14 @@
+require "ldclient-rb/impl/model/preprocessed_data"
 
 module LaunchDarkly
   module Impl
     module Model
       # Abstraction of deserializing a feature flag or segment that was read from a data store or
       # received from LaunchDarkly.
-      def self.deserialize(kind, json)
+      def self.deserialize(kind, json, logger = nil)
         return nil if json.nil?
         item = JSON.parse(json, symbolize_names: true)
-        postprocess_item_after_deserializing!(kind, item)
+        DataModelPreprocessing::Preprocessor.new(logger).preprocess_item!(kind, item)
         item
       end
 
@@ -18,45 +19,14 @@ module LaunchDarkly
       end
 
       # Translates a { flags: ..., segments: ... } object received from LaunchDarkly to the data store format.
-      def self.make_all_store_data(received_data)
+      def self.make_all_store_data(received_data, logger = nil)
+        preprocessor = DataModelPreprocessing::Preprocessor.new(logger)
         flags = received_data[:flags]
-        postprocess_items_after_deserializing!(FEATURES, flags)
+        preprocessor.preprocess_all_items!(FEATURES, flags)
         segments = received_data[:segments]
-        postprocess_items_after_deserializing!(SEGMENTS, segments)
+        preprocessor.preprocess_all_items!(SEGMENTS, segments)
         { FEATURES => flags, SEGMENTS => segments }
       end
-
-      # Called after we have deserialized a model item from JSON (because we received it from LaunchDarkly,
-      # or read it from a persistent data store). This allows us to precompute some derived attributes that
-      # will never change during the lifetime of that item.
-      def self.postprocess_item_after_deserializing!(kind, item)
-        return if !item
-        # Currently we are special-casing this for FEATURES; eventually it will be handled by delegating
-        # to the "kind" object or the item class.
-        if kind.eql? FEATURES
-          # For feature flags, we precompute all possible parameterized EvaluationReason instances.
-          prereqs = item[:prerequisites]
-          if !prereqs.nil?
-            prereqs.each do |prereq|
-              prereq[:_reason] = EvaluationReason::prerequisite_failed(prereq[:key])
-            end
-          end
-          rules = item[:rules]
-          if !rules.nil?
-            rules.each_index do |i|
-              rule = rules[i]
-              rule[:_reason] = EvaluationReason::rule_match(i, rule[:id])
-            end
-          end
-        end
-      end
-
-      def self.postprocess_items_after_deserializing!(kind, items_map)
-        return items_map if !items_map
-        items_map.each do |key, item|
-          postprocess_item_after_deserializing!(kind, item)
-        end
-      end
     end
   end
 end

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

@@ -15,8 +15,66 @@ module LaunchDarkly
           ret["X-LaunchDarkly-Wrapper"] = config.wrapper_name +
             (config.wrapper_version ? "/" + config.wrapper_version : "")
         end
+
+        app_value = application_header_value config.application
+        ret["X-LaunchDarkly-Tags"] = app_value unless app_value.nil? || app_value.empty?
+
         ret
       end
+
+      #
+      # Generate an HTTP Header value containing the application meta information (@see #application).
+      #
+      # @return [String]
+      #
+      def self.application_header_value(application)
+        parts = []
+        unless  application[:id].empty?
+          parts << "application-id/#{application[:id]}"
+        end
+
+        unless  application[:version].empty?
+          parts << "application-version/#{application[:version]}"
+        end
+
+        parts.join(" ")
+      end
+
+      #
+      # @param value [String]
+      # @param name [Symbol]
+      # @param logger [Logger]
+      # @return [String]
+      #
+      def self.validate_application_value(value, name, logger)
+        value = value.to_s
+
+        return "" if value.empty?
+
+        if value.length > 64
+          logger.warn { "Value of application[#{name}] was longer than 64 characters and was discarded" }
+          return ""
+        end
+
+        if value.match(/[^a-zA-Z0-9._-]/)
+          logger.warn { "Value of application[#{name}] contained invalid characters and was discarded" }
+          return ""
+        end
+
+        value
+      end
+
+      #
+      # @param app [Hash]
+      # @param logger [Logger]
+      # @return [Hash]
+      #
+      def self.validate_application_info(app, logger)
+        {
+          id: validate_application_value(app[:id], :id, logger),
+          version: validate_application_value(app[:version], :version, logger),
+        }
+      end
     end
   end
 end

data/lib/ldclient-rb/requestor.rb

@@ -31,7 +31,7 @@ module LaunchDarkly
 
     def request_all_data()
       all_data = JSON.parse(make_request("/sdk/latest-all"), symbolize_names: true)
-      Impl::Model.make_all_store_data(all_data)
+      Impl::Model.make_all_store_data(all_data, @config.logger)
     end
     
     def stop
@@ -44,7 +44,7 @@ module LaunchDarkly
     private
 
     def request_single_item(kind, path)
-      Impl::Model.deserialize(kind, make_request(path))
+      Impl::Model.deserialize(kind, make_request(path), @config.logger)
     end
 
     def make_request(path)

data/lib/ldclient-rb/stream.rb

@@ -86,7 +86,7 @@ module LaunchDarkly
       @config.logger.debug { "[LDClient] Stream received #{method} message: #{message.data}" }
       if method == PUT
         message = JSON.parse(message.data, symbolize_names: true)
-        all_data = Impl::Model.make_all_store_data(message[:data])
+        all_data = Impl::Model.make_all_store_data(message[:data], @config.logger)
         @feature_store.init(all_data)
         @initialized.make_true
         @config.logger.info { "[LDClient] Stream initialized" }
@@ -97,7 +97,7 @@ module LaunchDarkly
           key = key_for_path(kind, data[:path])
           if key
             data = data[:data]
-            Impl::Model.postprocess_item_after_deserializing!(kind, data)
+            Impl::DataModelPreprocessing::Preprocessor.new(@config.logger).preprocess_item!(kind, data)
             @feature_store.upsert(kind, data)
             break
           end

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "6.3.4"
+  VERSION = "6.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 6.3.4
+  version: 6.4.0
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-30 00:00:00.000000000 Z
+date: 2022-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -263,6 +263,7 @@ files:
 - lib/ldclient-rb/impl/diagnostic_events.rb
 - lib/ldclient-rb/impl/evaluator.rb
 - lib/ldclient-rb/impl/evaluator_bucketing.rb
+- lib/ldclient-rb/impl/evaluator_helpers.rb
 - lib/ldclient-rb/impl/evaluator_operators.rb
 - lib/ldclient-rb/impl/event_sender.rb
 - lib/ldclient-rb/impl/event_summarizer.rb
@@ -272,6 +273,7 @@ files:
 - lib/ldclient-rb/impl/integrations/file_data_source.rb
 - lib/ldclient-rb/impl/integrations/redis_impl.rb
 - lib/ldclient-rb/impl/integrations/test_data/test_data_source.rb
+- lib/ldclient-rb/impl/model/preprocessed_data.rb
 - lib/ldclient-rb/impl/model/serialization.rb
 - lib/ldclient-rb/impl/repeating_task.rb
 - lib/ldclient-rb/impl/store_client_wrapper.rb
@@ -319,7 +321,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.17
+rubygems_version: 3.3.22
 signing_key: 
 specification_version: 4
 summary: LaunchDarkly SDK for Ruby