launchdarkly-server-sdk 8.8.3-java

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

@@ -0,0 +1,72 @@
+require "ldclient-rb/impl/model/feature_flag"
+require "ldclient-rb/impl/model/preprocessed_data"
+require "ldclient-rb/impl/model/segment"
+
+# General implementation notes about the data model classes in LaunchDarkly::Impl::Model--
+#
+# As soon as we receive flag/segment JSON data from LaunchDarkly (or, read it from a database), we
+# transform it into the model classes FeatureFlag, Segment, etc. The constructor of each of these
+# classes takes a hash (the parsed JSON), and transforms it into an internal representation that
+# is more efficient for evaluations.
+#
+# Validation works as follows:
+# - A property value that is of the correct type, but is invalid for other reasons (for example,
+# if a flag rule refers to variation index 5, but there are only 2 variations in the flag), does
+# not prevent the flag from being parsed and stored. It does cause a warning to be logged, if a
+# logger was passed to the constructor.
+# - If a value is completely invalid for the schema, the constructor may throw an
+# exception, causing the whole data set to be rejected. This is consistent with the behavior of
+# the strongly-typed SDKs.
+#
+# Currently, the model classes also retain the original hash of the parsed JSON. This is because
+# we may need to re-serialize them to JSON, and building the JSON on the fly would be very
+# inefficient, so each model class has a to_json method that just returns the same Hash. If we
+# are able in the future to either use a custom streaming serializer, or pass the JSON data
+# straight through from LaunchDarkly to a database instead of re-serializing, we could stop
+# retaining this 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.
+      #
+      # SDK code outside of Impl::Model should use this method instead of calling the model class
+      # constructors directly, so as not to rely on implementation details.
+      #
+      # @param kind [Hash] normally either FEATURES or SEGMENTS
+      # @param input [object] a JSON string or a parsed hash (or a data model object, in which case
+      #  we'll just return the original object)
+      # @param logger [Logger|nil] logs errors if there are any data validation problems
+      # @return [Object] the flag or segment (or, for an unknown data kind, the data as a hash)
+      def self.deserialize(kind, input, logger = nil)
+        return nil if input.nil?
+        return input if !input.is_a?(String) && !input.is_a?(Hash)
+        data = input.is_a?(Hash) ? input : JSON.parse(input, symbolize_names: true)
+        case kind
+        when FEATURES
+          FeatureFlag.new(data, logger)
+        when SEGMENTS
+          Segment.new(data, logger)
+        else
+          data
+        end
+      end
+
+      # Abstraction of serializing a feature flag or segment that will be written to a data store.
+      # Currently we just call to_json, but SDK code outside of Impl::Model should use this method
+      # instead of to_json, so as not to rely on implementation details.
+      def self.serialize(kind, item)
+        item.to_json
+      end
+
+      # Translates a { flags: ..., segments: ... } object received from LaunchDarkly to the data store format.
+      def self.make_all_store_data(received_data, logger = nil)
+        {
+          FEATURES => (received_data[:flags] || {}).transform_values { |data| FeatureFlag.new(data, logger) },
+          SEGMENTS => (received_data[:segments] || {}).transform_values { |data| Segment.new(data, logger) },
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require "ldclient-rb/util"
+
+require "concurrent/atomics"
+
+module LaunchDarkly
+  module Impl
+    class RepeatingTask
+      def initialize(interval, start_delay, task, logger)
+        @interval = interval
+        @start_delay = start_delay
+        @task = task
+        @logger = logger
+        @stopped = Concurrent::AtomicBoolean.new(false)
+        @worker = nil
+      end
+
+      def start
+        @worker = Thread.new do
+          sleep(@start_delay) unless @start_delay.nil? || @start_delay == 0
+
+          until @stopped.value do
+            started_at = Time.now
+            begin
+              @task.call
+            rescue => e
+              LaunchDarkly::Util.log_exception(@logger, "Uncaught exception from repeating task", e)
+            end
+            delta = @interval - (Time.now - started_at)
+            if delta > 0
+              sleep(delta)
+            end
+          end
+        end
+      end
+
+      def stop
+        if @stopped.make_true
+          if @worker && @worker.alive? && @worker != Thread.current
+            @worker.run  # causes the thread to wake up if it's currently in a sleep
+            @worker.join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module LaunchDarkly
+  module Impl
+    class Sampler
+      #
+      # @param random [Random]
+      #
+      def initialize(random)
+        @random = random
+      end
+
+      #
+      # @param ratio [Int]
+      #
+      # @return [Boolean]
+      #
+      def sample(ratio)
+        return false unless ratio.is_a? Integer
+        return false if ratio <= 0
+        return true if ratio == 1
+
+        @random.rand(1.0) < 1.0 / ratio
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require "concurrent"
+require "ldclient-rb/interfaces"
+require "ldclient-rb/impl/store_data_set_sorter"
+
+module LaunchDarkly
+  module Impl
+    #
+    # Provides additional behavior that the client requires before or after feature store operations.
+    # This just means sorting the data set for init() and dealing with data store status listeners.
+    #
+    class FeatureStoreClientWrapper
+      include Interfaces::FeatureStore
+
+      def initialize(store, store_update_sink, logger)
+        # @type [LaunchDarkly::Interfaces::FeatureStore]
+        @store = store
+
+        @monitoring_enabled = does_store_support_monitoring?
+
+        # @type [LaunchDarkly::Impl::DataStore::UpdateSink]
+        @store_update_sink = store_update_sink
+        @logger = logger
+
+        @mutex = Mutex.new # Covers the following variables
+        @last_available = true
+        # @type [LaunchDarkly::Impl::RepeatingTask, nil]
+        @poller = nil
+      end
+
+      def init(all_data)
+        wrapper { @store.init(FeatureStoreDataSetSorter.sort_all_collections(all_data)) }
+      end
+
+      def get(kind, key)
+        wrapper { @store.get(kind, key) }
+      end
+
+      def all(kind)
+        wrapper { @store.all(kind) }
+      end
+
+      def upsert(kind, item)
+        wrapper { @store.upsert(kind, item) }
+      end
+
+      def delete(kind, key, version)
+        wrapper { @store.delete(kind, key, version) }
+      end
+
+      def initialized?
+        @store.initialized?
+      end
+
+      def stop
+        @store.stop
+        @mutex.synchronize do
+          return if @poller.nil?
+
+          @poller.stop
+          @poller = nil
+        end
+      end
+
+      def monitoring_enabled?
+        @monitoring_enabled
+      end
+
+      private def wrapper()
+        begin
+          yield
+        rescue => e
+          update_availability(false) if @monitoring_enabled
+          raise
+        end
+      end
+
+      private def update_availability(available)
+        @mutex.synchronize do
+          return if available == @last_available
+          @last_available = available
+        end
+
+        status = LaunchDarkly::Interfaces::DataStore::Status.new(available, false)
+
+        @logger.warn("Persistent store is available again") if available
+
+        @store_update_sink.update_status(status)
+
+        if available
+          @mutex.synchronize do
+            return if @poller.nil?
+
+            @poller.stop
+            @poller = nil
+          end
+
+          return
+        end
+
+        @logger.warn("Detected persistent store unavailability; updates will be cached until it recovers.")
+
+        task = Impl::RepeatingTask.new(0.5, 0, -> { self.check_availability }, @logger)
+
+        @mutex.synchronize do
+          @poller = task
+          @poller.start
+        end
+      end
+
+      private def check_availability
+        begin
+          update_availability(true) if @store.available?
+        rescue => e
+          @logger.error("Unexpected error from data store status function: #{e}")
+        end
+      end
+
+      # This methods determines whether the wrapped store can support enabling monitoring.
+      #
+      # The wrapped store must provide a monitoring_enabled method, which must
+      # be true. But this alone is not sufficient.
+      #
+      # Because this class wraps all interactions with a provided store, it can
+      # technically "monitor" any store. However, monitoring also requires that
+      # we notify listeners when the store is available again.
+      #
+      # We determine this by checking the store's `available?` method, so this
+      # is also a requirement for monitoring support.
+      #
+      # These extra checks won't be necessary once `available` becomes a part
+      # of the core interface requirements and this class no longer wraps every
+      # feature store.
+      private def does_store_support_monitoring?
+        return false unless @store.respond_to? :monitoring_enabled?
+        return false unless @store.respond_to? :available?
+
+        @store.monitoring_enabled?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+
+module LaunchDarkly
+  module Impl
+    #
+    # Implements a dependency graph ordering for data to be stored in a feature store. We must use this
+    # on every data set that will be passed to the feature store's init() method.
+    #
+    class FeatureStoreDataSetSorter
+      #
+      # Returns a copy of the input hash that has the following guarantees: the iteration order of the outer
+      # hash will be in ascending order by the VersionDataKind's :priority property (if any), and for each
+      # data kind that has a :get_dependency_keys function, the inner hash will have an iteration order
+      # where B is before A if A has a dependency on B.
+      #
+      # This implementation relies on the fact that hashes in Ruby have an iteration order that is the same
+      # as the insertion order. Also, due to the way we deserialize JSON received from LaunchDarkly, the
+      # keys in the inner hash will always be symbols.
+      #
+      def self.sort_all_collections(all_data)
+        outer_hash = {}
+        kinds = all_data.keys.sort_by { |k|
+          k[:priority].nil? ? k[:namespace].length : k[:priority]  # arbitrary order if priority is unknown
+        }
+        kinds.each do |kind|
+          items = all_data[kind]
+          outer_hash[kind] = self.sort_collection(kind, items)
+        end
+        outer_hash
+      end
+
+      def self.sort_collection(kind, input)
+        dependency_fn = kind[:get_dependency_keys]
+        return input if dependency_fn.nil? || input.empty?
+        remaining_items = input.clone
+        items_out = {}
+        until remaining_items.empty?
+          # pick a random item that hasn't been updated yet
+          key, item = remaining_items.first
+          self.add_with_dependencies_first(item, dependency_fn, remaining_items, items_out)
+        end
+        items_out
+      end
+
+      def self.add_with_dependencies_first(item, dependency_fn, remaining_items, items_out)
+        item_key = item[:key].to_sym
+        remaining_items.delete(item_key)  # we won't need to visit this item again
+        dependency_fn.call(item).each do |dep_key|
+          dep_item = remaining_items[dep_key.to_sym]
+          self.add_with_dependencies_first(dep_item, dependency_fn, remaining_items, items_out) unless dep_item.nil?
+        end
+        items_out[item_key] = item
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module LaunchDarkly
+  module Impl
+    # A simple thread safe generic unbounded resource pool abstraction
+    class UnboundedPool
+      def initialize(instance_creator, instance_destructor)
+        @pool = Array.new
+        @lock = Mutex.new
+        @instance_creator = instance_creator
+        @instance_destructor = instance_destructor
+      end
+
+      def acquire
+        @lock.synchronize {
+          if @pool.length == 0
+            @instance_creator.call()
+          else
+            @pool.pop()
+          end
+        }
+      end
+
+      def release(instance)
+        @lock.synchronize { @pool.push(instance) }
+      end
+
+      def dispose_all
+        @lock.synchronize {
+          @pool.map { |instance| @instance_destructor.call(instance) } unless @instance_destructor.nil?
+          @pool.clear()
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module LaunchDarkly
+  module Impl
+    module Util
+      def self.bool?(aObject)
+         [true,false].include? aObject
+      end
+
+      def self.current_time_millis
+        (Time.now.to_f * 1000).to_i
+      end
+
+      def self.default_http_headers(sdk_key, config)
+        ret = { "Authorization" => sdk_key, "User-Agent" => "RubyClient/" + LaunchDarkly::VERSION }
+        if config.wrapper_name
+          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 /[^a-zA-Z0-9._-]/.match?(value)
+          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
+
+      #
+      # @param value [String, nil]
+      # @param logger [Logger]
+      # @return [String, nil]
+      #
+      def self.validate_payload_filter_key(value, logger)
+        return nil if value.nil?
+        return value if value.is_a?(String) && /^[a-zA-Z0-9][._\-a-zA-Z0-9]*$/.match?(value)
+
+        logger.warn {
+          "Invalid payload filter configured, full environment will be fetched. Ensure the filter key is not empty and was copied correctly from LaunchDarkly settings."
+        }
+        nil
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl.rb

@@ -0,0 +1,13 @@
+
+module LaunchDarkly
+  #
+  # Internal implementation classes. Everything in this module should be considered unsupported
+  # and subject to change.
+  #
+  # @since 5.5.0
+  # @private
+  #
+  module Impl
+    # code is in ldclient-rb/impl/
+  end
+end

data/lib/ldclient-rb/in_memory_store.rb

@@ -0,0 +1,100 @@
+require "concurrent/atomics"
+
+module LaunchDarkly
+
+  # These constants denote the types of data that can be stored in the feature store.  If
+  # we add another storable data type in the future, as long as it follows the same pattern
+  # (having "key", "version", and "deleted" properties), we only need to add a corresponding
+  # constant here and the existing store should be able to handle it.
+  #
+  # The :priority and :get_dependency_keys properties are used by FeatureStoreDataSetSorter
+  # to ensure data consistency during non-atomic updates.
+
+  # @private
+  FEATURES = Impl::DataStore::DataKind.new(namespace: "features", priority: 1).freeze
+
+  # @private
+  SEGMENTS = Impl::DataStore::DataKind.new(namespace: "segments", priority: 0).freeze
+
+  # @private
+  ALL_KINDS = [FEATURES, SEGMENTS].freeze
+
+  #
+  # Default implementation of the LaunchDarkly client's feature store, using an in-memory
+  # cache.  This object holds feature flags and related data received from LaunchDarkly.
+  # Database-backed implementations are available in {LaunchDarkly::Integrations}.
+  #
+  class InMemoryFeatureStore
+    include LaunchDarkly::Interfaces::FeatureStore
+
+    def initialize
+      @items = Hash.new
+      @lock = Concurrent::ReadWriteLock.new
+      @initialized = Concurrent::AtomicBoolean.new(false)
+    end
+
+    def monitoring_enabled?
+      false
+    end
+
+    def get(kind, key)
+      @lock.with_read_lock do
+        coll = @items[kind]
+        f = coll.nil? ? nil : coll[key.to_sym]
+        (f.nil? || f[:deleted]) ? nil : f
+      end
+    end
+
+    def all(kind)
+      @lock.with_read_lock do
+        coll = @items[kind]
+        (coll.nil? ? Hash.new : coll).select { |_k, f| not f[:deleted] }
+      end
+    end
+
+    def delete(kind, key, version)
+      @lock.with_write_lock do
+        coll = @items[kind]
+        if coll.nil?
+          coll = Hash.new
+          @items[kind] = coll
+        end
+        old = coll[key.to_sym]
+
+        if old.nil? || old[:version] < version
+          coll[key.to_sym] = { deleted: true, version: version }
+        end
+      end
+    end
+
+    def init(all_data)
+      @lock.with_write_lock do
+        @items.replace(all_data)
+        @initialized.make_true
+      end
+    end
+
+    def upsert(kind, item)
+      @lock.with_write_lock do
+        coll = @items[kind]
+        if coll.nil?
+          coll = Hash.new
+          @items[kind] = coll
+        end
+        old = coll[item[:key].to_sym]
+
+        if old.nil? || old[:version] < item[:version]
+          coll[item[:key].to_sym] = item
+        end
+      end
+    end
+
+    def initialized?
+      @initialized.value
+    end
+
+    def stop
+      # nothing to do
+    end
+  end
+end

data/lib/ldclient-rb/integrations/consul.rb

@@ -0,0 +1,45 @@
+require "ldclient-rb/impl/integrations/consul_impl"
+require "ldclient-rb/integrations/util/store_wrapper"
+
+module LaunchDarkly
+  module Integrations
+    #
+    # Integration with [Consul](https://www.consul.io/).
+    #
+    # Note that in order to use this integration, you must first install the gem `diplomat`.
+    #
+    # @since 5.5.0
+    #
+    module Consul
+      #
+      # Default value for the `prefix` option for {new_feature_store}.
+      #
+      # @return [String]  the default key prefix
+      #
+      def self.default_prefix
+        'launchdarkly'
+      end
+
+      #
+      # Creates a Consul-backed persistent feature store.
+      #
+      # To use this method, you must first install the gem `diplomat`. Then, put the object returned by
+      # this method into the `feature_store` property of your client configuration ({LaunchDarkly::Config}).
+      #
+      # @param opts [Hash] the configuration options
+      # @option opts [Hash] :consul_config  an instance of `Diplomat::Configuration` to replace the default
+      #   Consul client configuration (note that this is exactly the same as modifying `Diplomat.configuration`)
+      # @option opts [String] :url   shortcut for setting the `url` property of the Consul client configuration
+      # @option opts [String] :prefix  namespace prefix to add to all keys used by LaunchDarkly
+      # @option opts [Logger] :logger  a `Logger` instance; defaults to `Config.default_logger`
+      # @option opts [Integer] :expiration (15)  expiration time for the in-memory cache, in seconds; 0 for no local caching
+      # @option opts [Integer] :capacity (1000)  maximum number of items in the cache
+      # @return [LaunchDarkly::Interfaces::FeatureStore]  a feature store object
+      #
+      def self.new_feature_store(opts = {})
+        core = LaunchDarkly::Impl::Integrations::Consul::ConsulFeatureStoreCore.new(opts)
+        LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
+      end
+    end
+  end
+end