launchdarkly-server-sdk 8.18.0-java → 8.18.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4f54af862047f472205f2c74c5ddcd68307cf16ad7a670a00936657f4904aba
-  data.tar.gz: 1f3da02fe1782c8bead177dbc7b9dfcd5a432df508f6e3f0b834708883a651e9
+  metadata.gz: c7079a31a9e896f54f3efa14e977ca139d2bf023458ffaa247b52c0d4216a96e
+  data.tar.gz: ecb670e91dcee356c5d8427dddcc071b377cdf5e5d36d965df29a3fc8fd936a6
 SHA512:
-  metadata.gz: cef3a3c3ac786a60563ad0a580b1ed93bf404a3d92c32b0a5c9812f8ba69d8298a6fd6fc69c0005a5d7c1f0c5338855483966e7b05e2b9fbf1ac949d0d648035
-  data.tar.gz: 0fce5e4c5eb2928b44aecdb2e449a8dbb217dadb783ec1b9e2aa40bdfd82ba499079a4155160bb1b5434bb809ba7050f8e33f4c2d123ec484384cf0006e8c6e6
+  metadata.gz: 919d9830ecd32c8e8e0e7656839d240897c94c8059ef9dfffc5769544e5e0c9bd4317ae601d7740713537c302bc16bcbaee1920a60c9b657928fbf68a3fe2af2
+  data.tar.gz: a1749cdd89a33e8dacb30efe4d334b072ebded9c5148a2bb49434878f5aa78a634318390a6a5abbc0a132bc0f6da89fb4b0aebea41ee118ffd4ef70657c77c40

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

@@ -21,6 +21,7 @@ module LaunchDarkly
         @status_provider = BigSegmentStoreStatusProviderImpl.new(-> { get_status })
         @logger = logger
         @last_status = nil
+        @poll_lock = Mutex.new
 
         unless @store.nil?
           @cache = ExpiringCache.new(big_segments_config.context_cache_size, big_segments_config.context_cache_time)
@@ -49,18 +50,41 @@ module LaunchDarkly
             return BigSegmentMembershipResult.new(nil, BigSegmentsStatus::STORE_ERROR)
           end
         end
-        poll_store_and_update_status unless @last_status
-        unless @last_status.available
+        status = get_status
+        unless status.available
           return BigSegmentMembershipResult.new(membership, BigSegmentsStatus::STORE_ERROR)
         end
-        BigSegmentMembershipResult.new(membership, @last_status.stale ? BigSegmentsStatus::STALE : BigSegmentsStatus::HEALTHY)
+        BigSegmentMembershipResult.new(membership, status.stale ? BigSegmentsStatus::STALE : BigSegmentsStatus::HEALTHY)
       end
 
       def get_status
-        @last_status || poll_store_and_update_status
+        status = @last_status
+        return status if status
+
+        new_status = @poll_lock.synchronize do
+          # Another caller may have finished a poll while we waited for the lock.
+          status = @last_status
+          return status if status
+
+          query_store_status
+        end
+        @status_provider.update_status(new_status)
+
+        new_status
       end
 
       def poll_store_and_update_status
+        new_status = @poll_lock.synchronize { query_store_status }
+        @status_provider.update_status(new_status)
+
+        new_status
+      end
+
+      #
+      # Queries the store and caches the result. Callers hold @poll_lock, so this must not notify
+      # observers - a listener that calls back into the manager would deadlock on the mutex.
+      #
+      private def query_store_status
         new_status = Interfaces::BigSegmentStoreStatus.new(false, false) # default to "unavailable" if we don't get a new status below
         unless @store.nil?
           begin
@@ -71,9 +95,6 @@ module LaunchDarkly
           end
         end
         @last_status = new_status
-        @status_provider.update_status(new_status)
-
-        new_status
       end
 
       def stale?(timestamp)

data/lib/ldclient-rb/impl/data_source/polling.rb

@@ -38,14 +38,17 @@ module LaunchDarkly
           begin
             all_data, headers = request_all_data
             DataSource.record_environment_id(@config.data_source_update_sink, headers)
+            newly_initialized = false
             if all_data
               update_sink_or_data_store.init(all_data)
-              if @initialized.make_true
-                @config.logger.info { "[LDClient] Polling connection initialized" }
-                @ready.set
-              end
+              newly_initialized = @initialized.make_true
             end
             @config.data_source_update_sink&.update_status(LaunchDarkly::Interfaces::DataSource::Status::VALID, nil)
+
+            if newly_initialized
+              @config.logger.info { "[LDClient] Polling connection initialized" }
+              @ready.set
+            end
           rescue JSON::ParserError => e
             @config.logger.error { "[LDClient] JSON parsing failed for polling response." }
             error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(

data/lib/ldclient-rb/impl/data_source/status_provider.rb

@@ -2,6 +2,7 @@
 
 require "concurrent"
 require "forwardable"
+require "ldclient-rb/impl/util"
 require "ldclient-rb/interfaces"
 
 module LaunchDarkly
@@ -19,18 +20,24 @@ module LaunchDarkly
         extend Forwardable
         def_delegators :@status_broadcaster, :add_listener, :remove_listener
 
+        MONOTONIC_CLOCK = -> { Impl::Util.monotonic_seconds }
+        private_constant :MONOTONIC_CLOCK
+
         #
         # Creates a new status provider.
         #
         # @param status_broadcaster [LaunchDarkly::Impl::Broadcaster] Broadcaster for status changes
+        # @param clock [#call] returns seconds on a monotonic clock; injectable for tests
         #
-        def initialize(status_broadcaster)
+        def initialize(status_broadcaster, clock: MONOTONIC_CLOCK)
           @status_broadcaster = status_broadcaster
+          @clock = clock
           @status = LaunchDarkly::Interfaces::DataSource::Status.new(
             LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING,
             Time.now,
             nil
           )
+          @state_since_monotonic = @clock.call
           @lock = Concurrent::ReadWriteLock.new
         end
 
@@ -41,8 +48,29 @@ module LaunchDarkly
           end
         end
 
+        #
+        # The current status together with the seconds the data source has spent
+        # in its current state, read atomically under one lock acquisition so the
+        # duration can never be paired with a stale state.
+        #
+        # The duration is measured on the monotonic clock, so a wall-clock step
+        # cannot distort it. `status.state_since` remains the wall-clock time
+        # reported to applications; this duration is the value to use when it
+        # decides behavior.
+        #
+        # @private
+        # @return [Array(LaunchDarkly::Interfaces::DataSource::Status, Float)]
+        #
+        def status_and_seconds_in_state
+          @lock.with_read_lock do
+            [@status, @clock.call - @state_since_monotonic]
+          end
+        end
+
         # (see LaunchDarkly::Interfaces::DataSource::UpdateSink#update_status)
         def update_status(new_state, new_error)
+          return if new_state.nil?
+
           status_to_broadcast = nil
 
           @lock.with_write_lock do
@@ -62,7 +90,12 @@ module LaunchDarkly
             # No change if state is the same and no error
             return if new_state == old_status.state && new_error.nil?
 
-            new_since = new_state == old_status.state ? @status.state_since : Time.now
+            if new_state == old_status.state
+              new_since = @status.state_since
+            else
+              new_since = Time.now
+              @state_since_monotonic = @clock.call
+            end
             new_error = @status.last_error if new_error.nil?
 
             @status = LaunchDarkly::Interfaces::DataSource::Status.new(

data/lib/ldclient-rb/impl/data_source/stream.rb

@@ -32,6 +32,7 @@ module LaunchDarkly
           @stopped = Concurrent::AtomicBoolean.new(false)
           @ready = Concurrent::Event.new
           @connection_attempt_start_time = 0
+          @connection_attempt_started_monotonic = nil
         end
 
         def initialized?
@@ -47,6 +48,7 @@ module LaunchDarkly
           opts = {
             headers: headers,
             read_timeout: READ_TIMEOUT_SECONDS,
+            connect_timeout: @config.connect_timeout,
             logger: @config.logger,
             socket_factory: @config.socket_factory,
             reconnect_time: @config.initial_reconnect_delay,
@@ -184,13 +186,16 @@ module LaunchDarkly
 
         def log_connection_started
           @connection_attempt_start_time = Impl::Util::current_time_millis
+          @connection_attempt_started_monotonic = Impl::Util.monotonic_seconds
         end
 
         def log_connection_result(is_success)
-          if !@diagnostic_accumulator.nil? && @connection_attempt_start_time > 0
-            @diagnostic_accumulator.record_stream_init(@connection_attempt_start_time, !is_success,
-              Impl::Util::current_time_millis - @connection_attempt_start_time)
-            @connection_attempt_start_time = 0
+          if !@diagnostic_accumulator.nil? && !@connection_attempt_started_monotonic.nil?
+            # The monotonic stamp is both the "attempt in flight" sentinel and the
+            # duration base; the wall-clock value is only the reported timestamp.
+            duration_millis = ((Impl::Util.monotonic_seconds - @connection_attempt_started_monotonic) * 1_000).to_i
+            @diagnostic_accumulator.record_stream_init(@connection_attempt_start_time, !is_success, duration_millis)
+            @connection_attempt_started_monotonic = nil
           end
         end
       end

data/lib/ldclient-rb/impl/data_system/fdv2.rb

@@ -292,6 +292,10 @@ module LaunchDarkly
 
                 # Set ready event if and only if a selector is defined for the changeset.
                 if basis.change_set.selector && basis.change_set.selector.defined?
+                  @data_source_status_provider.update_status(
+                    LaunchDarkly::Interfaces::DataSource::Status::VALID,
+                    nil
+                  )
                   @ready_event.set
                   return fallback
                 end
@@ -459,10 +463,12 @@ module LaunchDarkly
                 break if update == "quit"
 
                 if update == "check"
-                  # Check condition periodically
-                  current_status = @data_source_status_provider.status
-                  return SyncResult::RECOVER if check_recovery && recovery_condition(current_status)
-                  return SyncResult::FALLBACK if fallback_condition(current_status)
+                  # Check condition periodically. One atomic read pairs the status with
+                  # its monotonic time-in-state, so a verdict can never pair a stale
+                  # state with a fresh duration.
+                  current_status, seconds_in_state = @data_source_status_provider.status_and_seconds_in_state
+                  return SyncResult::RECOVER if check_recovery && recovery_condition(current_status, seconds_in_state)
+                  return SyncResult::FALLBACK if fallback_condition(current_status, seconds_in_state)
                 end
                 next
               end
@@ -473,15 +479,14 @@ module LaunchDarkly
               # Handle the update
               @store.apply(update.change_set, true) if update.change_set
 
-              # Set ready event on valid update
-              if update.state == LaunchDarkly::Interfaces::DataSource::Status::VALID
-                @ready_event.set
-                record_environment_id(update.environment_id)
-              end
+              valid = update.state == LaunchDarkly::Interfaces::DataSource::Status::VALID
+              record_environment_id(update.environment_id) if valid
 
               # Update status
               @data_source_status_provider.update_status(update.state, update.error)
 
+              @ready_event.set if valid
+
               return SyncResult::FDV1 if update.fallback_to_fdv1
 
               return SyncResult::REMOVE if update.state == LaunchDarkly::Interfaces::DataSource::Status::OFF
@@ -514,13 +519,14 @@ module LaunchDarkly
         # Determine if we should fallback to the next synchronizer.
         #
         # @param status [LaunchDarkly::Interfaces::DataSource::Status] Current data source status
+        # @param seconds_in_state [Float] monotonic seconds spent in status.state
         # @return [Boolean] true if fallback condition is met
         #
-        def fallback_condition(status)
+        def fallback_condition(status, seconds_in_state)
           interrupted_at_runtime = status.state == LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED &&
-            Time.now - status.state_since > 60  # 1 minute
+            seconds_in_state > 60  # 1 minute
           cannot_initialize = status.state == LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING &&
-            Time.now - status.state_since > 10  # 10 seconds
+            seconds_in_state > 10  # 10 seconds
 
           interrupted_at_runtime || cannot_initialize
         end
@@ -529,11 +535,12 @@ module LaunchDarkly
         # Determine if we should recover to the primary synchronizer.
         #
         # @param status [LaunchDarkly::Interfaces::DataSource::Status] Current data source status
+        # @param seconds_in_state [Float] monotonic seconds spent in status.state
         # @return [Boolean] true if recovery condition is met (healthy for too long)
         #
-        def recovery_condition(status)
+        def recovery_condition(status, seconds_in_state)
           status.state == LaunchDarkly::Interfaces::DataSource::Status::VALID &&
-            Time.now - status.state_since > 300  # 5 minutes
+            seconds_in_state > 300  # 5 minutes
         end
 
         #

data/lib/ldclient-rb/impl/data_system/streaming.rb

@@ -47,6 +47,7 @@ module LaunchDarkly
           @stopped = Concurrent::Event.new
           @diagnostic_accumulator = nil
           @connection_attempt_start_time = 0
+          @connection_attempt_started_monotonic = nil
         end
 
         #
@@ -97,6 +98,7 @@ module LaunchDarkly
           opts = {
             headers: headers,
             read_timeout: STREAM_READ_TIMEOUT,
+            connect_timeout: @http_config.connect_timeout,
             logger: @logger,
             socket_factory: @http_config.socket_factory,
             reconnect_time: @initial_reconnect_delay,
@@ -118,7 +120,7 @@ module LaunchDarkly
                 next unless update
 
                 log_connection_result(true)
-                @connection_attempt_start_time = 0
+                @connection_attempt_started_monotonic = nil
 
                 yield update
 
@@ -366,16 +368,18 @@ module LaunchDarkly
 
         private def log_connection_started
           @connection_attempt_start_time = Impl::Util.current_time_millis
+          @connection_attempt_started_monotonic = Impl::Util.monotonic_seconds
         end
 
         private def log_connection_result(is_success)
           return unless @diagnostic_accumulator
-          return unless @connection_attempt_start_time > 0
+          return if @connection_attempt_started_monotonic.nil?
 
-          current_time = Impl::Util.current_time_millis
-          elapsed = current_time - @connection_attempt_start_time
-          @diagnostic_accumulator.record_stream_init(@connection_attempt_start_time, !is_success, elapsed >= 0 ? elapsed : 0)
-          @connection_attempt_start_time = 0
+          # The monotonic stamp is both the "attempt in flight" sentinel and the
+          # duration base; the wall-clock value is only the reported timestamp.
+          elapsed = ((Impl::Util.monotonic_seconds - @connection_attempt_started_monotonic) * 1_000).to_i
+          @diagnostic_accumulator.record_stream_init(@connection_attempt_start_time, !is_success, elapsed)
+          @connection_attempt_started_monotonic = nil
         end
       end
 

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

@@ -1,3 +1,4 @@
+require "ldclient-rb/impl/util"
 
 module LaunchDarkly
   module Impl
@@ -7,10 +8,17 @@ module LaunchDarkly
     #   * made thread-safe
     #   * removed many unused methods
     #   * reading a key does not reset its expiration time, only writing
+    #   * expiration is measured on a monotonic clock, so wall-clock steps cannot
+    #     retain entries past their TTL or evict them early
     class ExpiringCache
-      def initialize(max_size, ttl)
+      MONOTONIC_CLOCK = -> { Impl::Util.monotonic_seconds }
+      private_constant :MONOTONIC_CLOCK
+
+      # @param clock [#call] returns seconds on a monotonic clock; injectable for tests
+      def initialize(max_size, ttl, clock: MONOTONIC_CLOCK)
         @max_size = max_size
         @ttl = ttl
+        @clock = clock
         @data_lru = {}
         @data_ttl = {}
         @lock = Mutex.new
@@ -31,7 +39,7 @@ module LaunchDarkly
           @data_ttl.delete(key)
 
           @data_lru[key] = val
-          @data_ttl[key] = Time.now.to_f
+          @data_ttl[key] = @clock.call
 
           if @data_lru.size > @max_size
             key, _ = @data_lru.first # hashes have a FIFO ordering in Ruby
@@ -63,7 +71,7 @@ module LaunchDarkly
       private
 
       def ttl_evict
-        ttl_horizon = Time.now.to_f - @ttl
+        ttl_horizon = @clock.call - @ttl
         key, time = @data_ttl.first
 
         until time.nil? || time > ttl_horizon

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

@@ -68,13 +68,15 @@ module LaunchDarkly
 
           def get_all_internal(kind)
             items_out = {}
-            results = Diplomat::Kv.get(kind_key(kind), { recurse: true }, :return)
-            (results == "" ? [] : results).each do |result|
+            prefix = kind_key(kind)
+            Diplomat::Kv.get_all(prefix, {}, :return).each do |result|
               value = result[:value]
-              unless value.nil?
-                item = Model.deserialize(kind, value)
-                items_out[item[:key].to_sym] = item
-              end
+              next if value.nil?
+              db_key = result[:key].to_s
+              next unless db_key.start_with?(prefix)
+              # Use the key that the item is stored under, not the key inside the item. A deleted
+              # item (a "tombstone") is not guaranteed to carry a key of its own.
+              items_out[db_key[prefix.length..].to_sym] = Model.deserialize(kind, value)
             end
             items_out
           end

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

@@ -113,7 +113,10 @@ module LaunchDarkly
               resp = @client.query(req)
               resp.items.each do |item|
                 item_out = unmarshal_item(kind, item)
-                items_out[item_out[:key].to_sym] = item_out
+                next if item_out.nil?
+                # Use the sort key that the item is stored under, not the key inside the item. A
+                # deleted item (a "tombstone") is not guaranteed to carry a key of its own.
+                items_out[item[SORT_KEY].to_sym] = item_out
               end
               break if resp.last_evaluated_key.nil? || resp.last_evaluated_key.length == 0
               req.exclusive_start_key = resp.last_evaluated_key

data/lib/ldclient-rb/impl/migrations/migrator.rb

@@ -270,7 +270,7 @@ module LaunchDarkly
         # @return [LaunchDarkly::Migrations::OperationResult]
         #
         def run()
-          start = Time.now
+          start = Impl::Util.monotonic_seconds
 
           begin
             result = @fn.call(@payload)
@@ -279,7 +279,7 @@ module LaunchDarkly
             result = LaunchDarkly::Result.fail("'#{origin}' operation raised an exception", e)
           end
 
-          @tracker.latency(@origin, (Time.now - start) * 1_000) if @measure_latency
+          @tracker.latency(@origin, (Impl::Util.monotonic_seconds - start) * 1_000) if @measure_latency
           @tracker.error(@origin) if @measure_errors && !result.success?
           @tracker.invoked(@origin)
 

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

@@ -39,13 +39,15 @@ module LaunchDarkly
           @stop_event.wait(@start_delay) unless @start_delay.nil? || @start_delay == 0
 
           until @stopped.value do
-            started_at = Time.now
+            started_at = Impl::Util.monotonic_seconds
             begin
               @task.call
             rescue => e
               Impl::Util.log_exception(@logger, "Uncaught exception from repeating task", e)
             end
-            delta = @interval - (Time.now - started_at)
+            # The run must be measured on the monotonic clock: a wall-clock step would
+            # make this wait negative (immediate re-run) or stretch it by the step size.
+            delta = @interval - (Impl::Util.monotonic_seconds - started_at)
             @stop_event.wait(delta) if delta > 0
           end
         end

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

@@ -23,6 +23,7 @@ module LaunchDarkly
 
         @mutex = Mutex.new # Covers the following variables
         @last_available = true
+        @stopped = false
         # @type [LaunchDarkly::Impl::RepeatingTask, nil]
         @poller = nil
       end
@@ -53,12 +54,14 @@ module LaunchDarkly
 
       def stop
         @store.stop
-        @mutex.synchronize do
-          return if @poller.nil?
 
-          @poller.stop
+        poller = @mutex.synchronize do
+          @stopped = true
+          task = @poller
           @poller = nil
+          task
         end
+        poller&.stop
       end
 
       def monitoring_enabled?
@@ -87,12 +90,12 @@ module LaunchDarkly
         @store_update_sink.update_status(status)
 
         if available
-          @mutex.synchronize do
-            return if @poller.nil?
-
-            @poller.stop
+          poller = @mutex.synchronize do
+            task = @poller
             @poller = nil
+            task
           end
+          poller&.stop
 
           return
         end
@@ -102,6 +105,9 @@ module LaunchDarkly
         task = Impl::RepeatingTask.new(0.5, 0, -> { self.check_availability }, @logger, 'LD/StoreWrapper#check_availability')
 
         @mutex.synchronize do
+          # A read can fail after stop, and a poller started then would never be stopped.
+          next if @stopped
+
           @poller = task
           @poller.start
         end

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

@@ -12,6 +12,17 @@ module LaunchDarkly
         (Time.now.to_f * 1000).to_i
       end
 
+      #
+      # Seconds on the monotonic clock. Use this for measuring intervals and
+      # durations; use the wall clock only for values reported outside the
+      # process.
+      #
+      # @return [Float]
+      #
+      def self.monotonic_seconds
+        Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second)
+      end
+
       def self.default_http_headers(sdk_key, config)
         ret = { "Authorization" => sdk_key, "User-Agent" => "RubyClient/" + LaunchDarkly::VERSION }
 

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "8.18.0" # x-release-please-version
+  VERSION = "8.18.2" # x-release-please-version
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 8.18.0
+  version: 8.18.2
 platform: java
 authors:
 - LaunchDarkly
 bindir: bin
 cert_chain: []
-date: 2026-09-16 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb