launchdarkly-server-sdk 8.18.1-java → 8.18.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 978ab174d6d432ede341e1a970e140a06ae4c07e1a377202649233e779c85bec
-  data.tar.gz: ecca2bc7c0c0067c6c6b3b12b7cd018e0457eaa0d6ff694d65a5841d72bc3f5a
+  metadata.gz: c7079a31a9e896f54f3efa14e977ca139d2bf023458ffaa247b52c0d4216a96e
+  data.tar.gz: ecb670e91dcee356c5d8427dddcc071b377cdf5e5d36d965df29a3fc8fd936a6
 SHA512:
-  metadata.gz: 52614f1147d38eaa8d2acf2fa2f4f72593a26520746bb3ed7ca8ccf5c1c13e29ef900b424e275e398867ad8590f30fb098bb40e8f51dab8bc5cac28bd8473935
-  data.tar.gz: e37a04e7d825571da84756b4b62dfb33132c2e4116101aad8cb8163a5e0cfaee8c89fb4f64fe9ab05a444724a5f5a135ba549de589e685c022056b82d867a54e
+  metadata.gz: 919d9830ecd32c8e8e0e7656839d240897c94c8059ef9dfffc5769544e5e0c9bd4317ae601d7740713537c302bc16bcbaee1920a60c9b657928fbf68a3fe2af2
+  data.tar.gz: a1749cdd89a33e8dacb30efe4d334b072ebded9c5148a2bb49434878f5aa78a634318390a6a5abbc0a132bc0f6da89fb4b0aebea41ee118ffd4ef70657c77c40

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?
@@ -185,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

@@ -463,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
@@ -517,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
@@ -532,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
 
         #
@@ -119,7 +120,7 @@ module LaunchDarkly
                 next unless update
 
                 log_connection_result(true)
-                @connection_attempt_start_time = 0
+                @connection_attempt_started_monotonic = nil
 
                 yield update
 
@@ -367,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/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/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.1" # 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.1
+  version: 8.18.2
 platform: java
 authors:
 - LaunchDarkly
 bindir: bin
 cert_chain: []
-date: 2026-10-06 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb