launchdarkly-server-sdk 8.13.0-java → 8.15.0-java

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

@@ -21,6 +21,60 @@ module LaunchDarkly
       LD_ENVID_HEADER = "X-LD-EnvID"
       LD_FD_FALLBACK_HEADER = "X-LD-FD-Fallback"
 
+      #
+      # Reports whether the response headers signal that the SDK should fall
+      # back to the FDv1 protocol. Lookup is case-insensitive so callers do
+      # not need to know whether the header map preserves canonical casing
+      # (e.g. {HTTP::Headers}) or has been normalized to lowercase (e.g.
+      # {HTTPPollingRequester#fetch}).
+      #
+      # @param headers [#[], Hash, nil]
+      # @return [Boolean]
+      #
+      def self.fdv1_fallback_requested?(headers)
+        return false if headers.nil?
+        value = lookup_header(headers, LD_FD_FALLBACK_HEADER)
+        # http gem returns arrays for repeated headers; normalize to a string.
+        value = value.first if value.is_a?(Array)
+        value == 'true'
+      end
+
+      #
+      # Performs a case-insensitive header lookup that works with both
+      # case-insensitive header containers (e.g. `HTTP::Headers`) and plain
+      # Ruby hashes -- including hashes whose keys we have downcased
+      # ourselves before reaching this code path.
+      #
+      # @param headers [#[], Hash]
+      # @param name [String]
+      # @return [String, Array, nil]
+      #
+      def self.lookup_header(headers, name)
+        return nil if headers.nil?
+
+        if headers.is_a?(Hash)
+          # Plain hash: try canonical case, then exact lowercase, then a
+          # case-insensitive scan as a final fallback.
+          value = headers[name]
+          return value unless value.nil?
+
+          downcased = name.downcase
+          value = headers[downcased]
+          return value unless value.nil?
+
+          headers.each_pair do |key, val|
+            return val if key.to_s.downcase == downcased
+          end
+          return nil
+        end
+
+        # Non-hash container (e.g. HTTP::Headers). Lookup via [] is
+        # already case-insensitive on those types.
+        return headers[name] if headers.respond_to?(:[])
+
+        nil
+      end
+
       #
       # PollingDataSource is a data source that can retrieve information from
       # LaunchDarkly either as an Initializer or as a Synchronizer.
@@ -46,10 +100,12 @@ module LaunchDarkly
         end
 
         #
-        # Fetch returns a Basis, or an error if the Basis could not be retrieved.
+        # Fetch returns a {LaunchDarkly::Interfaces::DataSystem::FetchResult}
+        # wrapping a Basis (or an error) and the FDv1 Fallback Directive
+        # signal carried on the server response.
         #
         # @param ss [LaunchDarkly::Interfaces::DataSystem::SelectorStore]
-        # @return [LaunchDarkly::Interfaces::DataSystem::Basis, nil]
+        # @return [LaunchDarkly::Interfaces::DataSystem::FetchResult]
         #
         def fetch(ss)
           poll(ss)
@@ -71,16 +127,10 @@ module LaunchDarkly
 
           until @stop.set?
             result = @requester.fetch(ss.selector)
+            fallback = LaunchDarkly::Impl::DataSystem.fdv1_fallback_requested?(result.headers)
+            envid = LaunchDarkly::Impl::DataSystem.lookup_header(result.headers, LD_ENVID_HEADER)
 
             if !result.success?
-              fallback = false
-              envid = nil
-
-              if result.headers
-                fallback = result.headers[LD_FD_FALLBACK_HEADER] == 'true'
-                envid = result.headers[LD_ENVID_HEADER]
-              end
-
               if result.exception.is_a?(LaunchDarkly::Impl::DataSource::UnexpectedResponseError)
                 error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
                   LaunchDarkly::Interfaces::DataSource::ErrorInfo::ERROR_RESPONSE,
@@ -99,7 +149,7 @@ module LaunchDarkly
                       state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
                       error: error_info,
                       environment_id: envid,
-                      revert_to_fdv1: true
+                      fallback_to_fdv1: true
                     )
                     break
                   end
@@ -108,7 +158,7 @@ module LaunchDarkly
                     state: LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
                     error: error_info,
                     environment_id: envid,
-                    revert_to_fdv1: false
+                    fallback_to_fdv1: false
                   )
                   @interrupt_event.wait(@poll_interval)
                   next
@@ -118,7 +168,7 @@ module LaunchDarkly
                   state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
                   error: error_info,
                   environment_id: envid,
-                  revert_to_fdv1: fallback
+                  fallback_to_fdv1: fallback
                 )
                 break
               end
@@ -136,7 +186,7 @@ module LaunchDarkly
                   state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
                   error: error_info,
                   environment_id: envid,
-                  revert_to_fdv1: true
+                  fallback_to_fdv1: true
                 )
                 break
               end
@@ -145,16 +195,14 @@ module LaunchDarkly
                 state: LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
                 error: error_info,
                 environment_id: envid,
-                revert_to_fdv1: false
+                fallback_to_fdv1: false
               )
             else
-              change_set, headers = result.value
-              fallback = headers[LD_FD_FALLBACK_HEADER] == 'true'
               yield LaunchDarkly::Interfaces::DataSystem::Update.new(
                 state: LaunchDarkly::Interfaces::DataSource::Status::VALID,
-                change_set: change_set,
-                environment_id: headers[LD_ENVID_HEADER],
-                revert_to_fdv1: fallback
+                change_set: result.value,
+                environment_id: envid,
+                fallback_to_fdv1: fallback
               )
             end
 
@@ -177,10 +225,14 @@ module LaunchDarkly
 
         #
         # @param ss [LaunchDarkly::Interfaces::DataSystem::SelectorStore]
-        # @return [LaunchDarkly::Result<LaunchDarkly::Interfaces::DataSystem::Basis, String>]
+        # @return [LaunchDarkly::Interfaces::DataSystem::FetchResult]
         #
         private def poll(ss)
+          # Default to false so the rescue clause has a defined value even when an
+          # exception is raised before the header read below has had a chance to run.
+          fallback = false
           result = @requester.fetch(ss.selector)
+          fallback = LaunchDarkly::Impl::DataSystem.fdv1_fallback_requested?(result.headers)
 
           unless result.success?
             if result.exception.is_a?(LaunchDarkly::Impl::DataSource::UnexpectedResponseError)
@@ -189,15 +241,20 @@ module LaunchDarkly
                 status_code, "polling request", "will retry"
               )
               @logger.warn { "[LDClient] #{http_error_message_result}" } if Impl::Util.http_error_recoverable?(status_code)
-              return LaunchDarkly::Result.fail(http_error_message_result, result.exception)
+              return LaunchDarkly::Interfaces::DataSystem::FetchResult.new(
+                result: LaunchDarkly::Result.fail(http_error_message_result, result.exception),
+                fallback_to_fdv1: fallback
+              )
             end
 
-            return LaunchDarkly::Result.fail(result.error || 'Failed to request payload', result.exception)
+            return LaunchDarkly::Interfaces::DataSystem::FetchResult.new(
+              result: LaunchDarkly::Result.fail(result.error || 'Failed to request payload', result.exception),
+              fallback_to_fdv1: fallback
+            )
           end
 
-          change_set, headers = result.value
-
-          env_id = headers[LD_ENVID_HEADER]
+          change_set = result.value
+          env_id = LaunchDarkly::Impl::DataSystem.lookup_header(result.headers, LD_ENVID_HEADER)
           env_id = nil unless env_id.is_a?(String)
 
           basis = LaunchDarkly::Interfaces::DataSystem::Basis.new(
@@ -206,12 +263,22 @@ module LaunchDarkly
             environment_id: env_id
           )
 
-          LaunchDarkly::Result.success(basis)
+          LaunchDarkly::Interfaces::DataSystem::FetchResult.new(
+            result: LaunchDarkly::Result.success(basis),
+            fallback_to_fdv1: fallback
+          )
         rescue => e
+          # An exception can fire after we have already read the response
+          # headers (e.g. a malformed change_set whose selector is nil makes
+          # change_set.selector.defined? raise). Carry the computed fallback
+          # signal through so the directive is not silently dropped.
           msg = "Error: Exception encountered when updating flags. #{e}"
           @logger.error { "[LDClient] #{msg}" }
           @logger.debug { "[LDClient] Exception trace: #{e.backtrace}" }
-          LaunchDarkly::Result.fail(msg, e)
+          LaunchDarkly::Interfaces::DataSystem::FetchResult.new(
+            result: LaunchDarkly::Result.fail(msg, e),
+            fallback_to_fdv1: fallback
+          )
         end
       end
 
@@ -246,7 +313,7 @@ module LaunchDarkly
           query_params << ["filter", @config.payload_filter_key] unless @config.payload_filter_key.nil?
 
           if selector && selector.defined?
-            query_params << ["selector", selector.state]
+            query_params << ["basis", selector.state]
           end
 
           uri = @poll_uri
@@ -273,7 +340,7 @@ module LaunchDarkly
             end
 
             if status == 304
-              return LaunchDarkly::Result.success([LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder.no_changes, response_headers])
+              return LaunchDarkly::Result.success(LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder.no_changes, response_headers)
             end
 
             body = response.to_s
@@ -285,7 +352,7 @@ module LaunchDarkly
 
             changeset_result = LaunchDarkly::Impl::DataSystem.polling_payload_to_changeset(data)
             if changeset_result.success?
-              LaunchDarkly::Result.success([changeset_result.value, response_headers])
+              LaunchDarkly::Result.success(changeset_result.value, response_headers)
             else
               LaunchDarkly::Result.fail(changeset_result.error, changeset_result.exception, response_headers)
             end
@@ -361,7 +428,7 @@ module LaunchDarkly
             end
 
             if status == 304
-              return LaunchDarkly::Result.success([LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder.no_changes, response_headers])
+              return LaunchDarkly::Result.success(LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder.no_changes, response_headers)
             end
 
             body = response.to_s
@@ -373,7 +440,7 @@ module LaunchDarkly
 
             changeset_result = LaunchDarkly::Impl::DataSystem.fdv1_polling_payload_to_changeset(data)
             if changeset_result.success?
-              LaunchDarkly::Result.success([changeset_result.value, response_headers])
+              LaunchDarkly::Result.success(changeset_result.value, response_headers)
             else
               LaunchDarkly::Result.fail(changeset_result.error, changeset_result.exception, response_headers)
             end

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

@@ -12,9 +12,6 @@ module LaunchDarkly
         #
         # DeleteObject specifies the deletion of a particular object.
         #
-        # This type is not stable, and not subject to any backwards
-        # compatibility guarantees or semantic versioning. It is not suitable for production usage.
-        #
         class DeleteObject
           # @return [Integer] The version
           attr_reader :version
@@ -79,9 +76,6 @@ module LaunchDarkly
         #
         # PutObject specifies the addition of a particular object with upsert semantics.
         #
-        # This type is not stable, and not subject to any backwards
-        # compatibility guarantees or semantic versioning. It is not suitable for production usage.
-        #
         class PutObject
           # @return [Integer] The version
           attr_reader :version
@@ -153,28 +147,15 @@ module LaunchDarkly
         #
         # Goodbye represents a goodbye event.
         #
-        # This type is not stable, and not subject to any backwards
-        # compatibility guarantees or semantic versioning. It is not suitable for production usage.
-        #
         class Goodbye
           # @return [String] The reason for goodbye
           attr_reader :reason
 
-          # @return [Boolean] Whether the goodbye is silent
-          attr_reader :silent
-
-          # @return [Boolean] Whether this represents a catastrophic failure
-          attr_reader :catastrophe
-
           #
           # @param reason [String] The reason for goodbye
-          # @param silent [Boolean] Whether the goodbye is silent
-          # @param catastrophe [Boolean] Whether this represents a catastrophic failure
           #
-          def initialize(reason:, silent:, catastrophe:)
+          def initialize(reason:)
             @reason = reason
-            @silent = silent
-            @catastrophe = catastrophe
           end
 
           #
@@ -185,8 +166,6 @@ module LaunchDarkly
           def to_h
             {
               reason: @reason,
-              silent: @silent,
-              catastrophe: @catastrophe,
             }
           end
 
@@ -199,21 +178,16 @@ module LaunchDarkly
           #
           def self.from_h(data)
             reason = data[:reason]
-            silent = data[:silent]
-            catastrophe = data[:catastrophe]
 
-            raise ArgumentError, "Missing required fields in Goodbye" if reason.nil? || silent.nil? || catastrophe.nil?
+            raise ArgumentError, "Missing required fields in Goodbye" if reason.nil?
 
-            new(reason: reason, silent: silent, catastrophe: catastrophe)
+            new(reason: reason)
           end
         end
 
         #
         # Error represents an error event.
         #
-        # This type is not stable, and not subject to any backwards
-        # compatibility guarantees or semantic versioning. It is not suitable for production usage.
-        #
         class Error
           # @return [String] The payload ID
           attr_reader :payload_id

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

@@ -72,6 +72,25 @@ module LaunchDarkly
 
           change_set_builder = LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder.new
           envid = nil
+          # The FDv1 Fallback Directive is one-way and terminal: once any
+          # connect handshake within this sync invocation carries it, the SDK
+          # is committed to engaging FDv1 as soon as the next full payload
+          # has been applied. We therefore latch this flag to true on first
+          # observation and never reset it -- a mid-sync reconnect whose
+          # response no longer carries the directive does NOT cancel a
+          # directive seen earlier. This matches the Go and Python SDK
+          # implementations, both of which use the same latch pattern.
+          #
+          # The flag has to bridge two callbacks: on_connect sees the response
+          # headers but on_event does not. A local closed over by both blocks
+          # is correct because:
+          #   1. Scope -- bound to a single sync invocation, so a future sync
+          #      starts fresh. (Within this invocation, persistence across
+          #      reconnects is the intended semantics, per above.)
+          #   2. Thread safety -- ld-eventsource dispatches on_connect,
+          #      on_event, and on_error on the same SSE worker thread, so
+          #      reads and writes here are single-threaded by construction.
+          fdv1_fallback_pending = false
 
           base_uri = @http_config.base_uri + FDV2_STREAMING_ENDPOINT
           headers = Impl::Util.default_http_headers(@sdk_key, @config)
@@ -85,30 +104,32 @@ module LaunchDarkly
 
           @sse = SSE::Client.new(base_uri, **opts) do |client|
             client.on_connect do |headers|
-              # Extract environment ID and check for fallback on successful connection
               if headers
-                envid = headers[LD_ENVID_HEADER] || envid
-
-                # Check for fallback header on connection
-                if headers[LD_FD_FALLBACK_HEADER] == 'true'
-                  log_connection_result(true)
-                  yield LaunchDarkly::Interfaces::DataSystem::Update.new(
-                    state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
-                    revert_to_fdv1: true,
-                    environment_id: envid
-                  )
-                  stop
-                end
+                # Per-environment identifier: server sends it on every connect,
+                # but it never changes once known so only assign once.
+                envid ||= LaunchDarkly::Impl::DataSystem.lookup_header(headers, LD_ENVID_HEADER)
+                fdv1_fallback_pending = true if LaunchDarkly::Impl::DataSystem.fdv1_fallback_requested?(headers)
               end
             end
 
             client.on_event do |event|
               begin
-                update = process_message(event, change_set_builder, envid)
-                if update
-                  log_connection_result(true)
-                  @connection_attempt_start_time = 0
-                  yield update
+                update = process_message(event, change_set_builder, envid, fdv1_fallback_pending: fdv1_fallback_pending)
+                next unless update
+
+                log_connection_result(true)
+                @connection_attempt_start_time = 0
+
+                yield update
+
+                # When the FDv1 Fallback Directive rode along on a Valid update, close
+                # the stream so the primary synchronizer is stopped once the directive
+                # engages. process_message marks the Update with fallback_to_fdv1 only
+                # on payloads that complete a transfer, so the consumer has already
+                # applied the ChangeSet by the time we get here.
+                if update.fallback_to_fdv1
+                  fdv1_fallback_pending = false
+                  stop
                 end
               rescue JSON::ParserError => e
                 @logger.info { "[LDClient] Error parsing stream event; will restart stream: #{e}" }
@@ -147,13 +168,9 @@ module LaunchDarkly
               log_connection_result(false)
               fallback = false
 
-              # Extract envid and fallback from error headers if available
               if error.respond_to?(:headers) && error.headers
-                envid = error.headers[LD_ENVID_HEADER] || envid
-
-                if error.headers[LD_FD_FALLBACK_HEADER] == 'true'
-                  fallback = true
-                end
+                envid ||= LaunchDarkly::Impl::DataSystem.lookup_header(error.headers, LD_ENVID_HEADER)
+                fallback = true if LaunchDarkly::Impl::DataSystem.fdv1_fallback_requested?(error.headers)
               end
 
               update = handle_error(error, envid, fallback)
@@ -193,9 +210,15 @@ module LaunchDarkly
         # @param message [SSE::StreamEvent]
         # @param change_set_builder [LaunchDarkly::Interfaces::DataSystem::ChangeSetBuilder]
         # @param envid [String, nil]
+        # @param fdv1_fallback_pending [Boolean] true when the connect-time
+        #   response headers carried the FDv1 Fallback Directive. When set,
+        #   the next Update that completes a payload transfer (TRANSFER_NONE
+        #   or PAYLOAD_TRANSFERRED) is marked with fallback_to_fdv1: true so
+        #   the consumer can engage the FDv1 Fallback Synchronizer after
+        #   applying the in-flight ChangeSet.
         # @return [LaunchDarkly::Interfaces::DataSystem::Update, nil]
         #
-        private def process_message(message, change_set_builder, envid)
+        private def process_message(message, change_set_builder, envid, fdv1_fallback_pending: false)
           event_type = message.type
 
           # Handle heartbeat
@@ -214,7 +237,8 @@ module LaunchDarkly
               change_set_builder.expect_changes
               return LaunchDarkly::Interfaces::DataSystem::Update.new(
                 state: LaunchDarkly::Interfaces::DataSource::Status::VALID,
-                environment_id: envid
+                environment_id: envid,
+                fallback_to_fdv1: fdv1_fallback_pending
               )
             end
             nil
@@ -231,9 +255,7 @@ module LaunchDarkly
 
           when LaunchDarkly::Interfaces::DataSystem::EventName::GOODBYE
             goodbye = LaunchDarkly::Impl::DataSystem::ProtocolV2::Goodbye.from_h(JSON.parse(message.data, symbolize_names: true))
-            unless goodbye.silent
-              @logger.error { "[LDClient] SSE server received error: #{goodbye.reason} (catastrophe: #{goodbye.catastrophe})" }
-            end
+            @logger.info { "[LDClient] SSE server received goodbye: #{goodbye.reason}" }
             nil
 
           when LaunchDarkly::Interfaces::DataSystem::EventName::ERROR
@@ -251,7 +273,8 @@ module LaunchDarkly
             LaunchDarkly::Interfaces::DataSystem::Update.new(
               state: LaunchDarkly::Interfaces::DataSource::Status::VALID,
               change_set: change_set,
-              environment_id: envid
+              environment_id: envid,
+              fallback_to_fdv1: fdv1_fallback_pending
             )
 
           else
@@ -286,7 +309,7 @@ module LaunchDarkly
               update = LaunchDarkly::Interfaces::DataSystem::Update.new(
                 state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
                 error: error_info,
-                revert_to_fdv1: true,
+                fallback_to_fdv1: true,
                 environment_id: envid
               )
               stop

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

@@ -119,6 +119,15 @@ module LaunchDarkly
         raise NotImplementedError, "#{self.class} must implement #set_diagnostic_accumulator"
       end
 
+      #
+      # Returns the ID of the environment the SDK is connected to, if LaunchDarkly has reported one.
+      #
+      # @return [String, nil]
+      #
+      def environment_id
+        raise NotImplementedError, "#{self.class} must implement #environment_id"
+      end
+
       #
       # Represents the availability of data in the SDK.
       #
@@ -247,8 +256,9 @@ module LaunchDarkly
         # @return [LaunchDarkly::Interfaces::DataSource::ErrorInfo, nil] Error information if applicable
         attr_reader :error
 
-        # @return [Boolean] Whether to revert to FDv1
-        attr_reader :revert_to_fdv1
+        # @return [Boolean] Whether the LaunchDarkly server has instructed the SDK to
+        #   fall back to the FDv1 protocol.
+        attr_reader :fallback_to_fdv1
 
         # @return [String, nil] The environment ID if available
         attr_reader :environment_id
@@ -257,14 +267,14 @@ module LaunchDarkly
         # @param state [Symbol] The state of the data source
         # @param change_set [ChangeSet, nil] The change set if available
         # @param error [LaunchDarkly::Interfaces::DataSource::ErrorInfo, nil] Error information if applicable
-        # @param revert_to_fdv1 [Boolean] Whether to revert to FDv1
+        # @param fallback_to_fdv1 [Boolean] Whether to fall back to FDv1
         # @param environment_id [String, nil] The environment ID if available
         #
-        def initialize(state:, change_set: nil, error: nil, revert_to_fdv1: false, environment_id: nil)
+        def initialize(state:, change_set: nil, error: nil, fallback_to_fdv1: false, environment_id: nil)
           @state = state
           @change_set = change_set
           @error = error
-          @revert_to_fdv1 = revert_to_fdv1
+          @fallback_to_fdv1 = fallback_to_fdv1
           @environment_id = environment_id
         end
       end

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

@@ -71,31 +71,38 @@ module LaunchDarkly
         # Implementation of the Initializer.fetch method.
         #
         # Reads all configured files once and returns their contents as a Basis.
+        # File-based data sources never request the FDv1 Fallback Directive,
+        # so the returned {FetchResult} always reports `fallback_to_fdv1: false`.
         #
         # @param selector_store [LaunchDarkly::Interfaces::DataSystem::SelectorStore] Provides the Selector (unused for file data)
-        # @return [LaunchDarkly::Result] A Result containing either a Basis or an error message
+        # @return [LaunchDarkly::Interfaces::DataSystem::FetchResult]
         #
         def fetch(selector_store)
-          @lock.synchronize do
-            if @closed
-              return LaunchDarkly::Result.fail('FileDataV2 source has been closed')
-            end
+          result =
+            begin
+              @lock.synchronize do
+                if @closed
+                  next LaunchDarkly::Result.fail('FileDataV2 source has been closed')
+                end
 
-            result = load_all_to_changeset
-            return result unless result.success?
+                load_result = load_all_to_changeset
+                next load_result unless load_result.success?
 
-            change_set = result.value
-            basis = LaunchDarkly::Interfaces::DataSystem::Basis.new(
-              change_set: change_set,
-              persist: false,
-              environment_id: nil
-            )
+                change_set = load_result.value
+                basis = LaunchDarkly::Interfaces::DataSystem::Basis.new(
+                  change_set: change_set,
+                  persist: false,
+                  environment_id: nil
+                )
 
-            LaunchDarkly::Result.success(basis)
-          end
-        rescue => e
-          @logger.error { "[LDClient] Error fetching file data: #{e.message}" }
-          LaunchDarkly::Result.fail("Error fetching file data: #{e.message}", e)
+                LaunchDarkly::Result.success(basis)
+              end
+            rescue => e
+              @logger.error { "[LDClient] Error fetching file data: #{e.message}" }
+              LaunchDarkly::Result.fail("Error fetching file data: #{e.message}", e)
+            end
+
+          LaunchDarkly::Interfaces::DataSystem::FetchResult.new(result: result, fallback_to_fdv1: false)
         end
 
         #
@@ -110,14 +117,14 @@ module LaunchDarkly
         #
         def sync(selector_store)
           # First yield initial data
-          initial_result = fetch(selector_store)
-          unless initial_result.success?
+          initial_fetch = fetch(selector_store)
+          unless initial_fetch.success?
             yield LaunchDarkly::Interfaces::DataSystem::Update.new(
               state: LaunchDarkly::Interfaces::DataSource::Status::OFF,
               error: LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
                 LaunchDarkly::Interfaces::DataSource::ErrorInfo::INVALID_DATA,
                 0,
-                initial_result.error,
+                initial_fetch.error,
                 Time.now
               )
             )
@@ -126,7 +133,7 @@ module LaunchDarkly
 
           yield LaunchDarkly::Interfaces::DataSystem::Update.new(
             state: LaunchDarkly::Interfaces::DataSource::Status::VALID,
-            change_set: initial_result.value.change_set
+            change_set: initial_fetch.value.change_set
           )
 
           # Start watching for file changes

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

@@ -93,6 +93,10 @@ module LaunchDarkly
           def stop
             @wrapper.stop
           end
+
+          def disable_cache
+            @wrapper.disable_cache
+          end
         end
 
         class RedisStoreImplBase