launchdarkly-server-sdk 6.1.1 → 6.4.0

data/lib/ldclient-rb/file_data_source.rb

@@ -1,314 +1,23 @@
-require 'concurrent/atomics'
-require 'json'
-require 'yaml'
-require 'pathname'
+require "ldclient-rb/integrations/file_data"
 
 module LaunchDarkly
-  # 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.
-  # @private
-  @@have_listen = false
-  begin
-    require 'listen'
-    @@have_listen = true
-  rescue LoadError
-  end
-
-  # @private
-  def self.have_listen?
-    @@have_listen
-  end
-
-  #
-  # Provides a way to use local files as a source of feature flag state. This allows using a
-  # predetermined feature flag state without an actual LaunchDarkly connection.
-  #
-  # Reading flags from a file is only intended for pre-production environments. Production
-  # environments should always be configured to receive flag updates from LaunchDarkly.
-  #
-  # To use this component, call {FileDataSource#factory}, and store its return value in the
-  # {Config#data_source} property of your LaunchDarkly client configuration. In the options
-  # to `factory`, set `paths` to the file path(s) of your data file(s):
-  #
-  #     file_source = FileDataSource.factory(paths: [ myFilePath ])
-  #     config = LaunchDarkly::Config.new(data_source: file_source)
-  #
-  # This will cause the client not to connect to LaunchDarkly to get feature flags. The
-  # client may still make network connections to send analytics events, unless you have disabled
-  # this with {Config#send_events} or {Config#offline?}.
-  #
-  # Flag data files can be either JSON or YAML. They contain an object with three possible
-  # properties:
-  #
-  # - `flags`: Feature flag definitions.
-  # - `flagValues`: Simplified feature flags that contain only a value.
-  # - `segments`: User segment definitions.
-  #
-  # The format of the data in `flags` and `segments` is defined by the LaunchDarkly application
-  # and is subject to change. Rather than trying to construct these objects yourself, it is simpler
-  # to request existing flags directly from the LaunchDarkly server in JSON format, and use this
-  # output as the starting point for your file. In Linux you would do this:
-  #
-  # ```
-  #     curl -H "Authorization: YOUR_SDK_KEY" https://sdk.launchdarkly.com/sdk/latest-all
-  # ```
   #
-  # The output will look something like this (but with many more properties):
+  # Deprecated entry point for the file data source feature.
   #
-  #     {
-  #       "flags": {
-  #         "flag-key-1": {
-  #           "key": "flag-key-1",
-  #           "on": true,
-  #           "variations": [ "a", "b" ]
-  #         }
-  #       },
-  #       "segments": {
-  #         "segment-key-1": {
-  #           "key": "segment-key-1",
-  #           "includes": [ "user-key-1" ]
-  #         }
-  #       }
-  #     }
+  # The new preferred usage is {LaunchDarkly::Integrations::FileData#data_source}.
   #
-  # Data in this format allows the SDK to exactly duplicate all the kinds of flag behavior supported
-  # by LaunchDarkly. However, in many cases you will not need this complexity, but will just want to
-  # set specific flag keys to specific values. For that, you can use a much simpler format:
-  #
-  #     {
-  #       "flagValues": {
-  #         "my-string-flag-key": "value-1",
-  #         "my-boolean-flag-key": true,
-  #         "my-integer-flag-key": 3
-  #       }
-  #     }
-  #
-  # Or, in YAML:
-  #
-  #     flagValues:
-  #       my-string-flag-key: "value-1"
-  #       my-boolean-flag-key: true
-  #       my-integer-flag-key: 1
-  #
-  # It is also possible to specify both "flags" and "flagValues", if you want some flags
-  # to have simple values and others to have complex behavior. However, it is an error to use the
-  # same flag key or segment key more than once, either in a single file or across multiple files.
-  #
-  # If the data source encounters any error in any file-- malformed content, a missing file, or a
-  # duplicate key-- it will not load flags from any of the files.      
+  # @deprecated This is replaced by {LaunchDarkly::Integrations::FileData}.
   #
   class FileDataSource
     #
-    # Returns a factory for the file data source component.
-    #
-    # @param options [Hash] the configuration options
-    # @option options [Array] :paths  The paths of the source files for loading flag data. These
-    #   may be absolute paths or relative to the current working directory.
-    # @option options [Boolean] :auto_update  True if the data source should watch for changes to
-    #   the source file(s) and reload flags whenever there is a change. Auto-updating will only
-    #   work if all of the files you specified have valid directory paths at startup time.
-    #   Note that the default implementation of this feature is based on polling the filesystem,
-    #   which may not perform well. If you install the 'listen' gem (not included by default, to
-    #   avoid adding unwanted dependencies to the SDK), its native file watching mechanism will be
-    #   used instead. However, 'listen' will not be used in JRuby 9.1 due to a known instability.
-    # @option options [Float] :poll_interval  The minimum interval, in seconds, between checks for
-    #   file modifications - used only if auto_update is true, and if the native file-watching
-    #   mechanism from 'listen' is not being used. The default value is 1 second.
-    # @return an object that can be stored in {Config#data_source}
+    # Deprecated entry point for the file data source feature.
     #
-    def self.factory(options={})
-      return lambda { |sdk_key, config| FileDataSourceImpl.new(config.feature_store, config.logger, options) }
-    end
-  end
-
-  # @private
-  class FileDataSourceImpl
-    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 && LaunchDarkly.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
-          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
-
+    # The new preferred usage is {LaunchDarkly::Integrations::FileData#data_source}.
     #
-    # Used internally by FileDataSource to track data file changes if the 'listen' gem is not available.
+    # @deprecated This is replaced by {LaunchDarkly::Integrations::FileData#data_source}.
     #
-    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
-              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
+    def self.factory(options={})
+      LaunchDarkly::Integrations::FileData.data_source(options)
     end
   end
 end

data/lib/ldclient-rb/flags_state.rb

@@ -16,21 +16,32 @@ module LaunchDarkly
 
     # Used internally to build the state map.
     # @private
-    def add_flag(flag, value, variation, reason = nil, details_only_if_tracked = false)
-      key = flag[:key]
-      @flag_values[key] = value
+    def add_flag(flag_state, with_reasons, details_only_if_tracked)
+      key = flag_state[:key]
+      @flag_values[key] = flag_state[:value]
       meta = {}
-      with_details = !details_only_if_tracked || flag[:trackEvents]
-      if !with_details && flag[:debugEventsUntilDate]
-        with_details = flag[:debugEventsUntilDate] > Impl::Util::current_time_millis
+
+      omit_details = false
+      if details_only_if_tracked
+        if !flag_state[:trackEvents] && !flag_state[:trackReason] && !(flag_state[:debugEventsUntilDate] && flag_state[:debugEventsUntilDate] > Impl::Util::current_time_millis)
+          omit_details = true
+        end
+      end
+
+      reason = (!with_reasons and !flag_state[:trackReason]) ? nil : flag_state[:reason]
+
+      if !reason.nil? && !omit_details
+        meta[:reason] = reason
       end
-      if with_details
-        meta[:version] = flag[:version]
-        meta[:reason] = reason if !reason.nil?
+
+      if !omit_details
+        meta[:version] = flag_state[:version]
       end
-      meta[:variation] = variation if !variation.nil?
-      meta[:trackEvents] = true if flag[:trackEvents]
-      meta[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
+
+      meta[:variation] = flag_state[:variation] if !flag_state[:variation].nil?
+      meta[:trackEvents] = true if flag_state[:trackEvents]
+      meta[:trackReason] = true if flag_state[:trackReason]
+      meta[:debugEventsUntilDate] = flag_state[:debugEventsUntilDate] if flag_state[:debugEventsUntilDate]
       @flag_metadata[key] = meta
     end
 

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