launchdarkly-server-sdk 8.18.0 → 8.18.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04cc3611f092210f59ccf789aea80c573089e6c19884dd878a15695bb8affb24
-  data.tar.gz: 634641b8caf1b66a28e11e8e4d7321e0ab3e6fb4b6d8608f69a573c8e1ce56f4
+  metadata.gz: bda19fb6334d96931ca31147df9221684aeaf91f6093b8ea29a3f7abc9437f2b
+  data.tar.gz: a419f8ad70cf484c1d2c5d82dd6c475a052cc253aacc3b93452da4efc4986438
 SHA512:
-  metadata.gz: 4602b9a3639878f3120e968fee5473f4f4abbdec95a0e4dd25e4bcfada163f04da868d8a258f51febc9890c36665520ac471523030e7015e065daef9d9e0180f
-  data.tar.gz: c536b25da3dc94de793d0114a07274ca00851caa2f73c4057ac707456bb77378ab2c5b21e9ccc805e68f1ee61ff1f52c6e4849c649139cab2e16a5bd3b1a13dd
+  metadata.gz: 136cd5c90b0ed9f3d8a2e2c6c7232e097e820ecb7c3c39bdbfb527de7233d3d58dbedf84eca06e1315d0e8164da9f8a2fbf6b89db4c6d04646da0ffb82bbface
+  data.tar.gz: fd15cd49b22cd81d7f2479b97befd138f717055f64b540da47d892f604552589dc38b79eaf60c50a2b4a76b9f2b7cb38252492e2af2caeab9eeffdce0882404c

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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 8.18.0
+  version: 8.18.2
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire:
 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