launchdarkly-server-sdk 6.2.2 → 6.3.0

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

@@ -0,0 +1,117 @@
+require "ldclient-rb/config"
+require "ldclient-rb/expiring_cache"
+require "ldclient-rb/impl/repeating_task"
+require "ldclient-rb/interfaces"
+require "ldclient-rb/util"
+
+require "digest"
+
+module LaunchDarkly
+  module Impl
+    BigSegmentMembershipResult = Struct.new(:membership, :status)
+
+    class BigSegmentStoreManager
+      # use this as a singleton whenever a membership query returns nil; it's safe to reuse it because
+      # we will never modify the membership properties after they're queried
+      EMPTY_MEMBERSHIP = {}
+
+      def initialize(big_segments_config, logger)
+        @store = big_segments_config.store
+        @stale_after_millis = big_segments_config.stale_after * 1000
+        @status_provider = BigSegmentStoreStatusProviderImpl.new(-> { get_status })
+        @logger = logger
+        @last_status = nil
+
+        if !@store.nil?
+          @cache = ExpiringCache.new(big_segments_config.user_cache_size, big_segments_config.user_cache_time)
+          @poll_worker = RepeatingTask.new(big_segments_config.status_poll_interval, 0, -> { poll_store_and_update_status }, logger)
+          @poll_worker.start
+        end
+      end
+
+      attr_reader :status_provider
+
+      def stop
+        @poll_worker.stop if !@poll_worker.nil?
+        @store.stop if !@store.nil?
+      end
+
+      def get_user_membership(user_key)
+        return nil if !@store
+        membership = @cache[user_key]
+        if !membership
+          begin
+            membership = @store.get_membership(BigSegmentStoreManager.hash_for_user_key(user_key))
+            membership = EMPTY_MEMBERSHIP if membership.nil?
+            @cache[user_key] = membership
+          rescue => e
+            LaunchDarkly::Util.log_exception(@logger, "Big Segment store membership query returned error", e)
+            return BigSegmentMembershipResult.new(nil, BigSegmentsStatus::STORE_ERROR)
+          end
+        end
+        poll_store_and_update_status if !@last_status
+        if !@last_status.available
+          return BigSegmentMembershipResult.new(membership, BigSegmentsStatus::STORE_ERROR)
+        end
+        BigSegmentMembershipResult.new(membership, @last_status.stale ? BigSegmentsStatus::STALE : BigSegmentsStatus::HEALTHY)
+      end
+
+      def get_status
+        @last_status || poll_store_and_update_status
+      end
+
+      def poll_store_and_update_status
+        new_status = Interfaces::BigSegmentStoreStatus.new(false, false) # default to "unavailable" if we don't get a new status below
+        if !@store.nil?
+          begin
+            metadata = @store.get_metadata
+            new_status = Interfaces::BigSegmentStoreStatus.new(true, !metadata || is_stale(metadata.last_up_to_date))
+          rescue => e
+            LaunchDarkly::Util.log_exception(@logger, "Big Segment store status query returned error", e)
+          end
+        end
+        @last_status = new_status
+        @status_provider.update_status(new_status)
+        
+        new_status
+      end
+
+      def is_stale(timestamp)
+        !timestamp || ((Impl::Util.current_time_millis - timestamp) >= @stale_after_millis)
+      end
+
+      def self.hash_for_user_key(user_key)
+        Digest::SHA256.base64digest(user_key)
+      end
+    end
+
+    #
+    # Default implementation of the BigSegmentStoreStatusProvider interface.
+    #
+    # There isn't much to this because the real implementation is in BigSegmentStoreManager - we pass in a lambda
+    # that allows us to get the current status from that class. Also, the standard Observer methods such as
+    # add_observer are provided for us because BigSegmentStoreStatusProvider mixes in Observer, so all we need to
+    # to do make notifications happen is to call the Observer methods "changed" and "notify_observers".
+    #
+    class BigSegmentStoreStatusProviderImpl
+      include LaunchDarkly::Interfaces::BigSegmentStoreStatusProvider
+
+      def initialize(status_fn)
+        @status_fn = status_fn
+        @last_status = nil
+      end
+
+      def status
+        @status_fn.call
+      end
+
+      def update_status(new_status)
+        if !@last_status || new_status != @last_status
+          @last_status = new_status
+          changed
+          notify_observers(new_status)
+        end
+      end
+    end
+  end
+end

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

@@ -79,7 +79,7 @@ module LaunchDarkly
           streamingDisabled: !config.stream?,
           userKeysCapacity: config.user_keys_capacity,
           userKeysFlushIntervalMillis: self.seconds_to_millis(config.user_keys_flush_interval),
-          usingProxy: ENV.has_key?('http_proxy') || ENV.has_key?('https_proxy') || ENV.has_key?('HTTP_PROXY'),
+          usingProxy: ENV.has_key?('http_proxy') || ENV.has_key?('https_proxy') || ENV.has_key?('HTTP_PROXY') || ENV.has_key?('HTTPS_PROXY'),
           usingRelayDaemon: config.use_ldd?,
         }
         ret

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

@@ -16,16 +16,28 @@ module LaunchDarkly
       #   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)
+      def initialize(get_flag, get_segment, get_big_segments_membership, logger)
         @get_flag = get_flag
         @get_segment = get_segment
+        @get_big_segments_membership = get_big_segments_membership
         @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)
+      # Used internally to hold an evaluation result and additional state that may be accumulated during an
+      # evaluation. It's simpler and a bit more efficient to represent these as mutable properties rather than
+      # trying to use a pure functional approach, and since we're not exposing this object to any application code
+      # or retaining it anywhere, we don't have to be quite as strict about immutability.
+      #
+      # The big_segments_status and big_segments_membership properties are not used by the caller; they are used
+      # during an evaluation to cache the result of any Big Segments query that we've done for this user, because
+      # we don't want to do multiple queries for the same user if multiple Big Segments are referenced in the same
+      # evaluation.
+      EvalResult = Struct.new(
+        :detail,  # the EvaluationDetail representing the evaluation result
+        :events,  # an array of evaluation events generated by prerequisites, or nil
+        :big_segments_status,
+        :big_segments_membership
+      )
 
       # Helper function used internally to construct an EvaluationDetail for an error result.
       def self.error_result(errorKind, value = nil)
@@ -42,30 +54,38 @@ module LaunchDarkly
       #   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)
+        result = EvalResult.new
         if user.nil? || user[:key].nil?
-          return EvalResult.new(Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED), [])
+          result.detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED)
+          return result
         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
+        
+        detail = eval_internal(flag, user, result, event_factory)
+        if !result.big_segments_status.nil?
+          # If big_segments_status is non-nil at the end of the evaluation, it means a query was done at
+          # some point and we will want to include the status in the evaluation reason.
+          detail = EvaluationDetail.new(detail.value, detail.variation_index,
+            detail.reason.with_big_segments_status(result.big_segments_status))
         end
+        result.detail = detail
+        return result
+      end
 
-        detail = eval_internal(flag, user, events, event_factory)
-        return EvalResult.new(detail, events.nil? || events.empty? ? nil : events)
+      def self.make_big_segment_ref(segment)  # method is visible for testing
+        # The format of Big Segment references is independent of what store implementation is being
+        # used; the store implementation receives only this string and does not know the details of
+        # the data model. The Relay Proxy will use the same format when writing to the store.
+        "#{segment[:key]}.g#{segment[:generation]}"
       end
 
       private
       
-      def eval_internal(flag, user, events, event_factory)
+      def eval_internal(flag, user, state, event_factory)
         if !flag[:on]
           return get_off_value(flag, EvaluationReason::off)
         end
 
-        prereq_failure_reason = check_prerequisites(flag, user, events, event_factory)
+        prereq_failure_reason = check_prerequisites(flag, user, state, event_factory)
         if !prereq_failure_reason.nil?
           return get_off_value(flag, prereq_failure_reason)
         end
@@ -83,7 +103,7 @@ module LaunchDarkly
         rules = flag[:rules] || []
         rules.each_index do |i|
           rule = rules[i]
-          if rule_match_user(rule, user)
+          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)
@@ -98,7 +118,7 @@ module LaunchDarkly
         return EvaluationDetail.new(nil, nil, EvaluationReason::fallthrough)
       end
 
-      def check_prerequisites(flag, user, events, event_factory)
+      def check_prerequisites(flag, user, state, event_factory)
         (flag[:prerequisites] || []).each do |prerequisite|
           prereq_ok = true
           prereq_key = prerequisite[:key]
@@ -109,14 +129,15 @@ module LaunchDarkly
             prereq_ok = false
           else
             begin
-              prereq_res = eval_internal(prereq_flag, user, events, event_factory)
+              prereq_res = eval_internal(prereq_flag, user, state, 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)
+              state.events = [] if state.events.nil?
+              state.events.push(event)
             rescue => exn
               Util.log_exception(@logger, "Error evaluating prerequisite flag \"#{prereq_key}\" for flag \"#{flag[:key]}\"", exn)
               prereq_ok = false
@@ -130,23 +151,23 @@ module LaunchDarkly
         nil
       end
 
-      def rule_match_user(rule, user)
+      def rule_match_user(rule, user, state)
         return false if !rule[:clauses]
 
         (rule[:clauses] || []).each do |clause|
-          return false if !clause_match_user(clause, user)
+          return false if !clause_match_user(clause, user, state)
         end
 
         return true
       end
 
-      def clause_match_user(clause, user)
+      def clause_match_user(clause, user, state)
         # 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)
+            !segment.nil? && segment_match_user(segment, user, state)
           }
           clause[:negate] ? !result : result
         else
@@ -168,11 +189,42 @@ module LaunchDarkly
         clause[:negate] ? !result : result
       end
 
-      def segment_match_user(segment, user)
+      def segment_match_user(segment, user, state)
         return false unless user[:key]
+        segment[:unbounded] ? big_segment_match_user(segment, user, state) : simple_segment_match_user(segment, user, true)
+      end
 
-        return true if segment[:included].include?(user[:key])
-        return false if segment[:excluded].include?(user[:key])
+      def big_segment_match_user(segment, user, state)
+        if !segment[:generation]
+          # Big segment queries can only be done if the generation is known. If it's unset,
+          # that probably means the data store was populated by an older SDK that doesn't know
+          # about the generation property and therefore dropped it from the JSON data. We'll treat
+          # that as a "not configured" condition.
+          state.big_segments_status = BigSegmentsStatus::NOT_CONFIGURED
+          return false
+        end
+        if !state.big_segments_status
+          result = @get_big_segments_membership.nil? ? nil : @get_big_segments_membership.call(user[:key])
+          if result
+            state.big_segments_membership = result.membership
+            state.big_segments_status = result.status
+          else
+            state.big_segments_membership = nil
+            state.big_segments_status = BigSegmentsStatus::NOT_CONFIGURED
+          end
+        end
+        segment_ref = Evaluator.make_big_segment_ref(segment)
+        membership = state.big_segments_membership
+        included = membership.nil? ? nil : membership[segment_ref]
+        return included if !included.nil?
+        simple_segment_match_user(segment, user, false)
+      end
+
+      def simple_segment_match_user(segment, user, use_includes_and_excludes)
+        if use_includes_and_excludes
+          return true if segment[:included].include?(user[:key])
+          return false if segment[:excluded].include?(user[:key])
+        end
 
         (segment[:rules] || []).each do |r|
           return true if segment_rule_match_user(r, user, segment[:key], segment[:salt])

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

@@ -4,10 +4,7 @@ module LaunchDarkly
   module Impl
     module Integrations
       module DynamoDB
-        #
-        # Internal implementation of the DynamoDB feature store, intended to be used with CachingStoreWrapper.
-        #
-        class DynamoDBFeatureStoreCore
+        class DynamoDBStoreImplBase
           begin
             require "aws-sdk-dynamodb"
             AWS_SDK_ENABLED = true
@@ -19,29 +16,50 @@ module LaunchDarkly
               AWS_SDK_ENABLED = false
             end
           end
-
+  
           PARTITION_KEY = "namespace"
           SORT_KEY = "key"
 
-          VERSION_ATTRIBUTE = "version"
-          ITEM_JSON_ATTRIBUTE = "item"
-
           def initialize(table_name, opts)
             if !AWS_SDK_ENABLED
-              raise RuntimeError.new("can't use DynamoDB feature store without the aws-sdk or aws-sdk-dynamodb gem")
+              raise RuntimeError.new("can't use #{description} without the aws-sdk or aws-sdk-dynamodb gem")
             end
-
+  
             @table_name = table_name
-            @prefix = opts[:prefix]
+            @prefix = opts[:prefix] ? (opts[:prefix] + ":") : ""
             @logger = opts[:logger] || Config.default_logger
-
+  
             if !opts[:existing_client].nil?
               @client = opts[:existing_client]
             else
               @client = Aws::DynamoDB::Client.new(opts[:dynamodb_opts] || {})
             end
+  
+            @logger.info("${description}: using DynamoDB table \"#{table_name}\"")
+          end
+  
+          def stop
+            # AWS client doesn't seem to have a close method
+          end
 
-            @logger.info("DynamoDBFeatureStore: using DynamoDB table \"#{table_name}\"")
+          protected def description
+            "DynamoDB"
+          end
+        end
+  
+        #
+        # Internal implementation of the DynamoDB feature store, intended to be used with CachingStoreWrapper.
+        #
+        class DynamoDBFeatureStoreCore < DynamoDBStoreImplBase
+          VERSION_ATTRIBUTE = "version"
+          ITEM_JSON_ATTRIBUTE = "item"
+
+          def initialize(table_name, opts)
+            super(table_name, opts)
+          end
+
+          def description
+            "DynamoDBFeatureStore"
           end
 
           def init_internal(all_data)
@@ -124,14 +142,10 @@ module LaunchDarkly
             !resp.item.nil? && resp.item.length > 0
           end
 
-          def stop
-            # AWS client doesn't seem to have a close method
-          end
-
           private
 
           def prefixed_namespace(base_str)
-            (@prefix.nil? || @prefix == "") ? base_str : "#{@prefix}:#{base_str}"
+            @prefix + base_str
           end
 
           def namespace_for_kind(kind)
@@ -208,6 +222,56 @@ module LaunchDarkly
           end
         end
 
+        class DynamoDBBigSegmentStore < DynamoDBStoreImplBase
+          KEY_METADATA = 'big_segments_metadata';
+          KEY_USER_DATA = 'big_segments_user';
+          ATTR_SYNC_TIME = 'synchronizedOn';
+          ATTR_INCLUDED = 'included';
+          ATTR_EXCLUDED = 'excluded';
+
+          def initialize(table_name, opts)
+            super(table_name, opts)
+          end
+
+          def description
+            "DynamoDBBigSegmentStore"
+          end
+
+          def get_metadata
+            key = @prefix + KEY_METADATA
+            data = @client.get_item(
+              table_name: @table_name,
+              key: {
+                PARTITION_KEY => key,
+                SORT_KEY => key
+              }
+            )
+            timestamp = data.item && data.item[ATTR_SYNC_TIME] ?
+              data.item[ATTR_SYNC_TIME] : nil
+            LaunchDarkly::Interfaces::BigSegmentStoreMetadata.new(timestamp)
+          end
+
+          def get_membership(user_hash)
+            data = @client.get_item(
+              table_name: @table_name,
+              key: {
+                PARTITION_KEY => @prefix + KEY_USER_DATA,
+                SORT_KEY => user_hash
+              })
+            return nil if !data.item
+            excluded_refs = data.item[ATTR_EXCLUDED] || []
+            included_refs = data.item[ATTR_INCLUDED] || []
+            if excluded_refs.empty? && included_refs.empty?
+              nil
+            else
+              membership = {}
+              excluded_refs.each { |ref| membership[ref] = false }
+              included_refs.each { |ref| membership[ref] = true }
+              membership
+            end
+          end
+        end
+
         class DynamoDBUtil
           #
           # Calls client.batch_write_item as many times as necessary to submit all of the given requests.

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

@@ -0,0 +1,212 @@
+require 'ldclient-rb/in_memory_store'
+require 'ldclient-rb/util'
+
+require 'concurrent/atomics'
+require 'json'
+require 'yaml'
+require 'pathname'
+
+module LaunchDarkly
+  module Impl
+    module Integrations
+      class FileDataSourceImpl
+        # To avoid pulling in 'listen' and its transitive dependencies for people who aren't using the
+        # file data source or who don't need auto-updating, we only enable auto-update if the 'listen'
+        # gem has been provided by the host app.
+        @@have_listen = false
+        begin
+          require 'listen'
+          @@have_listen = true
+        rescue LoadError
+        end
+
+        def initialize(feature_store, logger, options={})
+          @feature_store = feature_store
+          @logger = logger
+          @paths = options[:paths] || []
+          if @paths.is_a? String
+            @paths = [ @paths ]
+          end
+          @auto_update = options[:auto_update]
+          if @auto_update && @@have_listen && !options[:force_polling] # force_polling is used only for tests
+            # We have seen unreliable behavior in the 'listen' gem in JRuby 9.1 (https://github.com/guard/listen/issues/449).
+            # Therefore, on that platform we'll fall back to file polling instead.
+            if defined?(JRUBY_VERSION) && JRUBY_VERSION.start_with?("9.1.")
+              @use_listen = false
+            else
+              @use_listen = true
+            end
+          end
+          @poll_interval = options[:poll_interval] || 1
+          @initialized = Concurrent::AtomicBoolean.new(false)
+          @ready = Concurrent::Event.new
+        end
+
+        def initialized?
+          @initialized.value
+        end
+
+        def start
+          ready = Concurrent::Event.new
+          
+          # We will return immediately regardless of whether the file load succeeded or failed -
+          # the difference can be detected by checking "initialized?"
+          ready.set
+
+          load_all
+
+          if @auto_update
+            # If we're going to watch files, then the start event will be set the first time we get
+            # a successful load.
+            @listener = start_listener
+          end
+
+          ready
+        end
+        
+        def stop
+          @listener.stop if !@listener.nil?
+        end
+
+        private
+
+        def load_all
+          all_data = {
+            FEATURES => {},
+            SEGMENTS => {}
+          }
+          @paths.each do |path|
+            begin
+              load_file(path, all_data)
+            rescue => exn
+              LaunchDarkly::Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
+              return
+            end
+          end
+          @feature_store.init(all_data)
+          @initialized.make_true
+        end
+
+        def load_file(path, all_data)
+          parsed = parse_content(IO.read(path))
+          (parsed[:flags] || {}).each do |key, flag|
+            add_item(all_data, FEATURES, flag)
+          end
+          (parsed[:flagValues] || {}).each do |key, value|
+            add_item(all_data, FEATURES, make_flag_with_value(key.to_s, value))
+          end
+          (parsed[:segments] || {}).each do |key, segment|
+            add_item(all_data, SEGMENTS, segment)
+          end
+        end
+
+        def parse_content(content)
+          # We can use the Ruby YAML parser for both YAML and JSON (JSON is a subset of YAML and while
+          # not all YAML parsers handle it correctly, we have verified that the Ruby one does, at least
+          # for all the samples of actual flag data that we've tested).
+          symbolize_all_keys(YAML.safe_load(content))
+        end
+
+        def symbolize_all_keys(value)
+          # This is necessary because YAML.load doesn't have an option for parsing keys as symbols, and
+          # the SDK expects all objects to be formatted that way.
+          if value.is_a?(Hash)
+            value.map{ |k, v| [k.to_sym, symbolize_all_keys(v)] }.to_h
+          elsif value.is_a?(Array)
+            value.map{ |v| symbolize_all_keys(v) }
+          else
+            value
+          end
+        end
+
+        def add_item(all_data, kind, item)
+          items = all_data[kind]
+          raise ArgumentError, "Received unknown item kind #{kind} in add_data" if items.nil? # shouldn't be possible since we preinitialize the hash
+          key = item[:key].to_sym
+          if !items[key].nil?
+            raise ArgumentError, "#{kind[:namespace]} key \"#{item[:key]}\" was used more than once"
+          end
+          items[key] = item
+        end
+
+        def make_flag_with_value(key, value)
+          {
+            key: key,
+            on: true,
+            fallthrough: { variation: 0 },
+            variations: [ value ]
+          }
+        end
+
+        def start_listener
+          resolved_paths = @paths.map { |p| Pathname.new(File.absolute_path(p)).realpath.to_s }
+          if @use_listen
+            start_listener_with_listen_gem(resolved_paths)
+          else
+            FileDataSourcePoller.new(resolved_paths, @poll_interval, self.method(:load_all), @logger)
+          end
+        end
+
+        def start_listener_with_listen_gem(resolved_paths)
+          path_set = resolved_paths.to_set
+          dir_paths = resolved_paths.map{ |p| File.dirname(p) }.uniq
+          opts = { latency: @poll_interval }
+          l = Listen.to(*dir_paths, opts) do |modified, added, removed|
+            paths = modified + added + removed
+            if paths.any? { |p| path_set.include?(p) }
+              load_all
+            end
+          end
+          l.start
+          l
+        end
+
+        #
+        # Used internally by FileDataSource to track data file changes if the 'listen' gem is not available.
+        #
+        class FileDataSourcePoller
+          def initialize(resolved_paths, interval, reloader, logger)
+            @stopped = Concurrent::AtomicBoolean.new(false)
+            get_file_times = Proc.new do
+              ret = {}
+              resolved_paths.each do |path|
+                begin
+                  ret[path] = File.mtime(path)
+                rescue Errno::ENOENT
+                  ret[path] = nil
+                end
+              end
+              ret
+            end
+            last_times = get_file_times.call
+            @thread = Thread.new do
+              while true
+                sleep interval
+                break if @stopped.value
+                begin
+                  new_times = get_file_times.call
+                  changed = false
+                  last_times.each do |path, old_time|
+                    new_time = new_times[path]
+                    if !new_time.nil? && new_time != old_time
+                      changed = true
+                      break
+                    end
+                  end
+                  reloader.call if changed
+                rescue => exn
+                  LaunchDarkly::Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
+                end
+              end
+            end
+          end
+
+          def stop
+            @stopped.make_true
+            @thread.run  # wakes it up if it's sleeping
+          end
+        end
+      end
+    end
+  end
+end