launchdarkly-server-sdk 8.11.2-java → 8.12.0-java

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

@@ -1,9 +1,12 @@
+require "ldclient-rb/impl/model/serialization"
+
 module LaunchDarkly
   module Impl
     class DependencyTracker
-      def initialize
+      def initialize(logger = nil)
         @from = {}
         @to = {}
+        @logger = logger
       end
 
       #
@@ -11,11 +14,11 @@ module LaunchDarkly
       #
       # @param from_kind [Object] the changed item's kind
       # @param from_key [String] the changed item's key
-      # @param from_item [Object] the changed item
+      # @param from_item [Object] the changed item (can be a Hash, model object, or nil)
       #
       def update_dependencies_from(from_kind, from_key, from_item)
         from_what = { kind: from_kind, key: from_key }
-        updated_dependencies = DependencyTracker.compute_dependencies_from(from_kind, from_item)
+        updated_dependencies = DependencyTracker.compute_dependencies_from(from_kind, from_item, @logger)
 
         old_dependency_set = @from[from_what]
         unless old_dependency_set.nil?
@@ -39,7 +42,7 @@ module LaunchDarkly
       def self.segment_keys_from_clauses(clauses)
         clauses.flat_map do |clause|
           if clause.op == :segmentMatch
-            clause.values.map { |value| {kind: LaunchDarkly::SEGMENTS, key: value }}
+            clause.values.map { |value| {kind: DataStore::SEGMENTS, key: value }}
           else
             []
           end
@@ -48,19 +51,28 @@ module LaunchDarkly
 
       #
       # @param from_kind [String]
-      # @param from_item [LaunchDarkly::Impl::Model::FeatureFlag, LaunchDarkly::Impl::Model::Segment]
+      # @param from_item [Hash, LaunchDarkly::Impl::Model::FeatureFlag, LaunchDarkly::Impl::Model::Segment, nil] the item (can be a hash, model object, or nil)
+      # @param logger [Logger, nil] optional logger for deserialization
       # @return [Set]
       #
-      def self.compute_dependencies_from(from_kind, from_item)
-        return Set.new if from_item.nil?
+      def self.compute_dependencies_from(from_kind, from_item, logger = nil)
+        # Check for deleted items (matches Python: from_item.get('deleted', False))
+        return Set.new if from_item.nil? || (from_item.is_a?(Hash) && from_item[:deleted])
+
+        # Deserialize hash to model object if needed (matches Python: from_kind.decode(from_item) if isinstance(from_item, dict))
+        from_item = if from_item.is_a?(Hash)
+                      LaunchDarkly::Impl::Model.deserialize(from_kind, from_item, logger)
+                    else
+                      from_item
+                    end
 
-        if from_kind == LaunchDarkly::FEATURES
+        if from_kind == DataStore::FEATURES && from_item.is_a?(LaunchDarkly::Impl::Model::FeatureFlag)
           prereq_keys = from_item.prerequisites.map { |prereq| {kind: from_kind, key: prereq.key} }
           segment_keys = from_item.rules.flat_map { |rule| DependencyTracker.segment_keys_from_clauses(rule.clauses) }
 
           results = Set.new(prereq_keys)
           results.merge(segment_keys)
-        elsif from_kind == LaunchDarkly::SEGMENTS
+        elsif from_kind == DataStore::SEGMENTS && from_item.is_a?(LaunchDarkly::Impl::Model::Segment)
           kind_and_keys  = from_item.rules.flat_map do |rule|
             DependencyTracker.segment_keys_from_clauses(rule.clauses)
           end

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

@@ -4,6 +4,7 @@ require "ldclient-rb/impl/evaluator_helpers"
 require "ldclient-rb/impl/evaluator_operators"
 require "ldclient-rb/impl/model/feature_flag"
 require "ldclient-rb/impl/model/segment"
+require "ldclient-rb/impl/util"
 
 module LaunchDarkly
   module Impl
@@ -152,11 +153,11 @@ module LaunchDarkly
         begin
           detail = eval_internal(flag, context, result, state)
         rescue EvaluationException => exn
-          LaunchDarkly::Util.log_exception(@logger, "Unexpected error when evaluating flag #{flag.key}", exn)
+          Impl::Util.log_exception(@logger, "Unexpected error when evaluating flag #{flag.key}", exn)
           result.detail = EvaluationDetail.new(nil, nil, EvaluationReason::error(exn.error_kind))
           return result, state
         rescue => exn
-          LaunchDarkly::Util.log_exception(@logger, "Unexpected error when evaluating flag #{flag.key}", exn)
+          Impl::Util.log_exception(@logger, "Unexpected error when evaluating flag #{flag.key}", exn)
           result.detail = EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_EXCEPTION))
           return result, state
         end

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

@@ -1,4 +1,6 @@
 require "ldclient-rb/impl/unbounded_pool"
+require "ldclient-rb/impl/util"
+require "ldclient-rb/impl/data_system/http_config_options"
 
 require "securerandom"
 require "http"
@@ -13,15 +15,21 @@ module LaunchDarkly
       CURRENT_SCHEMA_VERSION = 4
       DEFAULT_RETRY_INTERVAL = 1
 
-      def initialize(sdk_key, config, http_client = nil, retry_interval = DEFAULT_RETRY_INTERVAL)
+      def initialize(sdk_key, config, retry_interval = DEFAULT_RETRY_INTERVAL)
         @sdk_key = sdk_key
         @config = config
-        @events_uri = config.events_uri + "/bulk"
-        @diagnostic_uri = config.events_uri + "/diagnostic"
+        @http_config = DataSystem::HttpConfigOptions.new(
+          base_uri: config.events_uri,
+          socket_factory: config.socket_factory,
+          read_timeout: config.read_timeout,
+          connect_timeout: config.connect_timeout
+        )
+        @events_uri = @http_config.base_uri + "/bulk"
+        @diagnostic_uri = @http_config.base_uri + "/diagnostic"
         @logger = config.logger
         @retry_interval = retry_interval
         @http_client_pool = UnboundedPool.new(
-          lambda { LaunchDarkly::Util.new_http_client(@config.events_uri, @config) },
+          lambda { Impl::Util.new_http_client(@http_config) },
           lambda { |client| client.close })
       end
 
@@ -81,9 +89,9 @@ module LaunchDarkly
               end
               return EventSenderResult.new(true, false, res_time)
             end
-            must_shutdown = !LaunchDarkly::Util.http_error_recoverable?(status)
+            must_shutdown = !Impl::Util.http_error_recoverable?(status)
             can_retry = !must_shutdown && attempt == 0
-            message = LaunchDarkly::Util.http_error_message(status, "event delivery", can_retry ? "will retry" : "some events were dropped")
+            message = Impl::Util.http_error_message(status, "event delivery", can_retry ? "will retry" : "some events were dropped")
             @logger.error { "[LDClient] #{message}" }
             if must_shutdown
               return EventSenderResult.new(false, true, nil)

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

@@ -0,0 +1,79 @@
+
+module LaunchDarkly
+  module Impl
+    # A thread-safe cache with maximum number of entries and TTL.
+    # Adapted from https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/ttl/cache.rb
+    # under MIT license with the following changes:
+    #   * made thread-safe
+    #   * removed many unused methods
+    #   * reading a key does not reset its expiration time, only writing
+    class ExpiringCache
+      def initialize(max_size, ttl)
+        @max_size = max_size
+        @ttl = ttl
+        @data_lru = {}
+        @data_ttl = {}
+        @lock = Mutex.new
+      end
+
+      def [](key)
+        @lock.synchronize do
+          ttl_evict
+          @data_lru[key]
+        end
+      end
+
+      def []=(key, val)
+        @lock.synchronize do
+          ttl_evict
+
+          @data_lru.delete(key)
+          @data_ttl.delete(key)
+
+          @data_lru[key] = val
+          @data_ttl[key] = Time.now.to_f
+
+          if @data_lru.size > @max_size
+            key, _ = @data_lru.first # hashes have a FIFO ordering in Ruby
+
+            @data_ttl.delete(key)
+            @data_lru.delete(key)
+          end
+
+          val
+        end
+      end
+
+      def delete(key)
+        @lock.synchronize do
+          ttl_evict
+
+          @data_lru.delete(key)
+          @data_ttl.delete(key)
+        end
+      end
+
+      def clear
+        @lock.synchronize do
+          @data_lru.clear
+          @data_ttl.clear
+        end
+      end
+
+      private
+
+      def ttl_evict
+        ttl_horizon = Time.now.to_f - @ttl
+        key, time = @data_ttl.first
+
+        until time.nil? || time > ttl_horizon
+          @data_ttl.delete(key)
+          @data_lru.delete(key)
+
+          key, time = @data_ttl.first
+        end
+      end
+    end
+  end
+end
+

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

@@ -1,5 +1,5 @@
 require 'ldclient-rb/in_memory_store'
-require 'ldclient-rb/util'
+require 'ldclient-rb/impl/util'
 
 require 'concurrent/atomics'
 require 'json'
@@ -75,14 +75,14 @@ module LaunchDarkly
 
         def load_all
           all_data = {
-            FEATURES => {},
-            SEGMENTS => {},
+            Impl::DataStore::FEATURES => {},
+            Impl::DataStore::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)
+              Impl::Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
               @data_source_update_sink&.update_status(
                 LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
                 LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::INVALID_DATA, 0, exn.to_s, Time.now)
@@ -105,14 +105,14 @@ module LaunchDarkly
           parsed = parse_content(File.read(path))
           (parsed[:flags] || {}).each do |key, flag|
             flag[:version] = version
-            add_item(all_data, FEATURES, flag)
+            add_item(all_data, Impl::DataStore::FEATURES, flag)
           end
           (parsed[:flagValues] || {}).each do |key, value|
-            add_item(all_data, FEATURES, make_flag_with_value(key.to_s, value, version))
+            add_item(all_data, Impl::DataStore::FEATURES, make_flag_with_value(key.to_s, value, version))
           end
           (parsed[:segments] || {}).each do |key, segment|
             segment[:version] = version
-            add_item(all_data, SEGMENTS, segment)
+            add_item(all_data, Impl::DataStore::SEGMENTS, segment)
           end
         end
 
@@ -212,7 +212,7 @@ module LaunchDarkly
                   end
                   reloader.call if changed
                 rescue => exn
-                  LaunchDarkly::Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
+                  Impl::Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
                 end
               end
             end