launchdarkly-server-sdk 6.3.0 → 8.0.0

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

@@ -1,3 +1,4 @@
+require "concurrent"
 require "ldclient-rb/interfaces"
 require "ldclient-rb/impl/store_data_set_sorter"
 
@@ -5,34 +6,45 @@ module LaunchDarkly
   module Impl
     #
     # Provides additional behavior that the client requires before or after feature store operations.
-    # Currently this just means sorting the data set for init(). In the future we may also use this
-    # to provide an update listener capability.
+    # This just means sorting the data set for init() and dealing with data store status listeners.
     #
     class FeatureStoreClientWrapper
       include Interfaces::FeatureStore
 
-      def initialize(store)
+      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)
-        @store.init(FeatureStoreDataSetSorter.sort_all_collections(all_data))
+        wrapper { @store.init(FeatureStoreDataSetSorter.sort_all_collections(all_data)) }
       end
 
       def get(kind, key)
-        @store.get(kind, key)
+        wrapper { @store.get(kind, key) }
       end
 
       def all(kind)
-        @store.all(kind)
+        wrapper { @store.all(kind) }
       end
 
       def upsert(kind, item)
-        @store.upsert(kind, item)
+        wrapper { @store.upsert(kind, item) }
       end
 
       def delete(kind, key, version)
-        @store.delete(kind, key, version)
+        wrapper { @store.delete(kind, key, version) }
       end
 
       def initialized?
@@ -41,6 +53,88 @@ module LaunchDarkly
 
       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

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

@@ -33,7 +33,7 @@ module LaunchDarkly
         return input if dependency_fn.nil? || input.empty?
         remaining_items = input.clone
         items_out = {}
-        while !remaining_items.empty?
+        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)
@@ -46,7 +46,7 @@ module LaunchDarkly
         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) if !dep_item.nil?
+          self.add_with_dependencies_first(dep_item, dependency_fn, remaining_items, items_out) unless dep_item.nil?
         end
         items_out[item_key] = item
       end

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

@@ -25,7 +25,7 @@ module LaunchDarkly
 
       def dispose_all
         @lock.synchronize {
-          @pool.map { |instance| @instance_destructor.call(instance) } if !@instance_destructor.nil?
+          @pool.map { |instance| @instance_destructor.call(instance) } unless @instance_destructor.nil?
           @pool.clear()
         }
       end

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

@@ -1,7 +1,7 @@
 module LaunchDarkly
   module Impl
     module Util
-      def self.is_bool(aObject)
+      def self.bool?(aObject)
          [true,false].include? aObject
       end
 
@@ -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 /[^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
     end
   end
 end

data/lib/ldclient-rb/in_memory_store.rb

@@ -14,15 +14,18 @@ module LaunchDarkly
   FEATURES = {
     namespace: "features",
     priority: 1,  # that is, features should be stored after segments
-    get_dependency_keys: lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } }
+    get_dependency_keys: lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } },
   }.freeze
 
   # @private
   SEGMENTS = {
     namespace: "segments",
-    priority: 0
+    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.
@@ -37,6 +40,10 @@ module LaunchDarkly
       @initialized = Concurrent::AtomicBoolean.new(false)
     end
 
+    def monitoring_enabled?
+      false
+    end
+
     def get(kind, key)
       @lock.with_read_lock do
         coll = @items[kind]

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

@@ -36,9 +36,9 @@ module LaunchDarkly
       # @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, &block)
+      def self.new_feature_store(opts = {})
         core = LaunchDarkly::Impl::Integrations::Consul::ConsulFeatureStoreCore.new(opts)
-        return LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
+        LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
       end
     end
   end

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

@@ -46,7 +46,7 @@ module LaunchDarkly
       # @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(table_name, opts)
+      def self.new_feature_store(table_name, opts = {})
         core = LaunchDarkly::Impl::Integrations::DynamoDB::DynamoDBFeatureStoreCore.new(table_name, opts)
         LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
       end
@@ -54,7 +54,7 @@ module LaunchDarkly
       #
       # Creates a DynamoDB-backed Big Segment store.
       #
-      # Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+      # Big Segments are a specific type of segments. For more information, read the LaunchDarkly
       # documentation: https://docs.launchdarkly.com/home/users/big-segments
       #
       # To use this method, you must first install one of the AWS SDK gems: either `aws-sdk-dynamodb`, or

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

@@ -25,7 +25,7 @@ module LaunchDarkly
     #
     # - `flags`: Feature flag definitions.
     # - `flagValues`: Simplified feature flags that contain only a value.
-    # - `segments`: User segment definitions.
+    # - `segments`: Context 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
@@ -78,7 +78,7 @@ module LaunchDarkly
     # 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.      
+    # duplicate key-- it will not load flags from any of the files.
     #
     module FileData
       #
@@ -100,8 +100,8 @@ module LaunchDarkly
       # @return an object that can be stored in {Config#data_source}
       #
       def self.data_source(options={})
-        return lambda { |sdk_key, config|
-          Impl::Integrations::FileDataSourceImpl.new(config.feature_store, config.logger, options) }
+        lambda { |sdk_key, config|
+          Impl::Integrations::FileDataSourceImpl.new(config.feature_store, config.data_source_update_sink, config.logger, options) }
       end
     end
   end

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

@@ -1,4 +1,4 @@
-require "ldclient-rb/redis_store"  # eventually we will just refer to impl/integrations/redis_impl directly
+require "ldclient-rb/impl/integrations/redis_impl"
 
 module LaunchDarkly
   module Integrations
@@ -58,14 +58,14 @@ module LaunchDarkly
       #   lifecycle to be independent of the SDK client
       # @return [LaunchDarkly::Interfaces::FeatureStore]  a feature store object
       #
-      def self.new_feature_store(opts)
-        return RedisFeatureStore.new(opts)
+      def self.new_feature_store(opts = {})
+        LaunchDarkly::Impl::Integrations::Redis::RedisFeatureStore.new(opts)
       end
 
       #
       # Creates a Redis-backed Big Segment store.
       #
-      # Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+      # Big Segments are a specific type of segments. For more information, read the LaunchDarkly
       # documentation: https://docs.launchdarkly.com/home/users/big-segments
       #
       # To use this method, you must first have the `redis` and `connection-pool` gems installed. Then,
@@ -91,7 +91,7 @@ module LaunchDarkly
       # @return [LaunchDarkly::Interfaces::BigSegmentStore]  a Big Segment store object
       #
       def self.new_big_segment_store(opts)
-        return LaunchDarkly::Impl::Integrations::Redis::RedisBigSegmentStore.new(opts)
+        LaunchDarkly::Impl::Integrations::Redis::RedisBigSegmentStore.new(opts)
       end
     end
   end