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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94c8797b35ad5d1abce1827cd6eaf48961856cf8102eabe2d9de1c674c17405a
-  data.tar.gz: 7f02d923d1522f3976ee5ab457379dd5f40992539894175ce93a54083d107bca
+  metadata.gz: dc18b4c7af16130b9f7e9f7c8d0a4acd8e562d16ebb7714fc7846c9ff96d1d3f
+  data.tar.gz: 2c9bfdff939fb1f11a9bc83e707aa0e550136004c4a2870b7220fb293ad268f2
 SHA512:
-  metadata.gz: 7fde3a50440b01752b84cebe45fbcb660258252ba1d162fbfc20fb5131686751de4c917ce1e61441d0981b606f4a44091a4724792019476bf27dd852a68877b6
-  data.tar.gz: f1efa40715fb7909b2793d89de9e4f957f8ac468c5865c4fa46a0b111c0544cb627fc9ec0c0c477ea6718eac2ff18decd0d3d54b0c7edcacf7168c23d8f2343c
+  metadata.gz: 0b23cf9eda9b570844be07e71831f19734881b72d08c464b109929b17d225ac2083d78ead046418bdfec68e67db82f940c344efd3ce408ad1a1ea49e0d3dcaf2
+  data.tar.gz: ceb93287c34afbbb2301d3991267a10b1349aa126bea72c028552c431dc3493ec5f136d06b79f21641363dd9bfa87cce1a5ceb225534ff98ab8ad3088c2d7fc0

data/README.md

@@ -43,7 +43,7 @@ We encourage pull requests and other contributions from the community. Check out
 Verifying SDK build provenance with the SLSA framework
 ------------
 
-LaunchDarkly uses the [SLSA framework](https://slsa.dev/spec/v1.0/about) (Supply-chain Levels for Software Artifacts) to help developers make their supply chain more secure by ensuring the authenticity and build integrity of our published SDK packages. To learn more, see the [provenance guide](PROVENANCE.md). 
+LaunchDarkly uses the [SLSA framework](https://slsa.dev/spec/v1.0/about) (Supply-chain Levels for Software Artifacts) to help developers make their supply chain more secure by ensuring the authenticity and build integrity of our published SDK packages. To learn more, see the [provenance guide](PROVENANCE.md).
 
 About LaunchDarkly
 -----------

data/lib/ldclient-rb/config.rb

@@ -399,6 +399,30 @@ module LaunchDarkly
     #
     attr_reader :wrapper_version
 
+    #
+    # Returns a copy of this configuration with different wrapper information.
+    #
+    # This is intended for use by wrapper libraries, such as the LaunchDarkly OpenFeature provider, which need to
+    # identify themselves rather than the application which created the configuration.
+    #
+    # The copy is shallow: it shares the objects the original configuration references, such as the feature store,
+    # the logger, and the socket factory. Mutating one of those objects affects both configurations.
+    #
+    # @param wrapper_name [String, nil] see {#wrapper_name}
+    # @param wrapper_version [String, nil] see {#wrapper_version}
+    #
+    # @return [LaunchDarkly::Config]
+    #
+    def with_wrapper_information(wrapper_name, wrapper_version = nil)
+      updated = dup
+      updated.wrapper_name = wrapper_name
+      updated.wrapper_version = wrapper_version
+
+      updated
+    end
+
+    protected attr_writer :wrapper_name, :wrapper_version
+
     #
     # The factory used to construct sockets for HTTP operations. The factory must
     # provide the method `open(uri, timeout)`. The `open` method must return a
@@ -697,9 +721,6 @@ module LaunchDarkly
   #
   # Configuration for LaunchDarkly's data acquisition strategy.
   #
-  # This is not stable and is not subject to any backwards compatibility guarantees
-  # or semantic versioning. It is not suitable for production usage.
-  #
   class DataSystemConfig
     #
     # @param initializers [Array<#build(String, Config)>, nil] The (optional) array of builders

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

@@ -21,9 +21,9 @@ module LaunchDarkly
     #     include LaunchDarkly::DataSystem::Requester
     #
     #     def fetch(selector)
-    #       # Fetch data and return a Result containing [ChangeSet, headers]
-    #       # ...
-    #       LaunchDarkly::Result.success([change_set, {}])
+    #       # Fetch data and return a Result whose value is a ChangeSet and
+    #       # whose headers carry any response metadata (e.g. directives).
+    #       LaunchDarkly::Result.success(change_set, response_headers)
     #     end
     #
     #     def stop
@@ -43,8 +43,10 @@ module LaunchDarkly
       # @param selector [LaunchDarkly::Interfaces::DataSystem::Selector, nil]
       #   The selector describing what data to fetch. May be nil if no
       #   selector is available (e.g., on the first request).
-      # @return [LaunchDarkly::Result] A Result containing a tuple of
-      #   [ChangeSet, headers] on success, or an error message on failure.
+      # @return [LaunchDarkly::Result] A Result whose `value` is a
+      #   {LaunchDarkly::Interfaces::DataSystem::ChangeSet} on success and
+      #   whose `headers` carry response headers in either case (so callers
+      #   can inspect directives such as `X-LD-FD-Fallback`).
       #
       def fetch(selector)
         raise NotImplementedError

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

@@ -70,15 +70,15 @@ module LaunchDarkly
         filtered[:anonymous] = true if anonymous
 
         redacted = []
-        private_attributes = @private_attributes.concat(context.private_attributes)
+        private_attributes = @private_attributes + context.private_attributes
 
         name = context.get_value(:name)
-        if !name.nil? && !check_whole_attribute_private(:name, private_attributes, redacted, anonymous && redact_anonymous)
+        if !name.nil? && !check_whole_attribute_private(Reference.create_literal(:name), private_attributes, redacted, anonymous && redact_anonymous)
           filtered[:name] = name
         end
 
         context.get_custom_attribute_names.each do |attribute|
-          unless check_whole_attribute_private(attribute, private_attributes, redacted, anonymous && redact_anonymous)
+          unless check_whole_attribute_private(Reference.create_literal(attribute), private_attributes, redacted, anonymous && redact_anonymous)
             value = context.get_value(attribute)
             filtered[attribute] = redact_json_value(nil, attribute, value, private_attributes, redacted)
           end
@@ -92,7 +92,7 @@ module LaunchDarkly
       #
       # Check if an entire attribute should be redacted.
       #
-      # @param attribute [Symbol]
+      # @param attribute [Reference]
       # @param private_attributes [Array<Reference>]
       # @param redacted [Array<Symbol>]
       # @param redact_all [Boolean]
@@ -100,13 +100,13 @@ module LaunchDarkly
       #
       private def check_whole_attribute_private(attribute, private_attributes, redacted, redact_all)
         if @all_attributes_private || redact_all
-          redacted << attribute
+          redacted << attribute.raw_path.to_sym
           return true
         end
 
         private_attributes.each do |private_attribute|
-          if private_attribute.component(0) == attribute && private_attribute.depth == 1
-            redacted << attribute
+          if private_attribute.component(0) == attribute.component(0) && private_attribute.depth == 1
+            redacted << attribute.raw_path.to_sym
             return true
           end
         end

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

@@ -1,3 +1,4 @@
+require "ldclient-rb/impl/data_source"
 require "ldclient-rb/impl/repeating_task"
 require "ldclient-rb/impl/util"
 
@@ -35,7 +36,8 @@ module LaunchDarkly
 
         def poll
           begin
-            all_data = @requestor.request_all_data
+            all_data, headers = request_all_data
+            DataSource.record_environment_id(@config.data_source_update_sink, headers)
             if all_data
               update_sink_or_data_store.init(all_data)
               if @initialized.make_true
@@ -92,6 +94,17 @@ module LaunchDarkly
           @config.data_source_update_sink || @config.feature_store
         end
 
+        #
+        # Requestors provided by application code may not be able to report the response headers.
+        #
+        # @return [Array(Hash, HTTP::Headers, nil)]
+        #
+        private def request_all_data
+          return @requestor.request_all_data_with_headers if @requestor.respond_to?(:request_all_data_with_headers)
+
+          [@requestor.request_all_data, nil]
+        end
+
         #
         # @param [LaunchDarkly::Interfaces::DataSource::ErrorInfo, nil] error_info
         #

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

@@ -40,8 +40,18 @@ module LaunchDarkly
         end
 
         def request_all_data()
-          all_data = JSON.parse(make_request("/sdk/latest-all"), symbolize_names: true)
-          Impl::Model.make_all_store_data(all_data, @config.logger)
+          request_all_data_with_headers.first
+        end
+
+        #
+        # Requests the full data set, also returning the headers of the response it was retrieved from.
+        #
+        # @return [Array(Hash, HTTP::Headers)]
+        #
+        def request_all_data_with_headers
+          body, headers = make_request("/sdk/latest-all")
+          all_data = JSON.parse(body, symbolize_names: true)
+          [Impl::Model.make_all_store_data(all_data, @config.logger), headers]
         end
 
         def stop
@@ -80,7 +90,7 @@ module LaunchDarkly
             etag = response.headers["etag"]
             @cache.write(uri, CacheEntry.new(etag, body)) unless etag.nil?
           end
-          body
+          [body, response.headers]
         end
 
         def fix_encoding(body, content_type)

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

@@ -1,3 +1,4 @@
+require "ldclient-rb/impl/data_source"
 require "ldclient-rb/impl/model/serialization"
 require "ldclient-rb/impl/util"
 require "ldclient-rb/in_memory_store"
@@ -54,6 +55,7 @@ module LaunchDarkly
 
           uri = Impl::Util.add_payload_filter_key(@config.stream_uri + "/all", @config)
           @es = SSE::Client.new(uri, **opts) do |conn|
+            conn.on_connect { |response_headers| DataSource.record_environment_id(@data_source_update_sink, response_headers) }
             conn.on_event { |event| process_message(event) }
             conn.on_error { |err|
               log_connection_result(false)

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

@@ -7,6 +7,27 @@ require "set"
 module LaunchDarkly
   module Impl
     module DataSource
+      LD_ENVID_HEADER = "X-LD-EnvID"
+
+      #
+      # Records the environment ID reported by LaunchDarkly, when the response headers provide one and the sink is
+      # able to hold it. Externally implemented sinks are not required to support this.
+      #
+      # @param sink [LaunchDarkly::Interfaces::DataSource::UpdateSink, nil]
+      # @param headers [#[], nil]
+      # @return [void]
+      #
+      def self.record_environment_id(sink, headers)
+        return if headers.nil? || !sink.respond_to?(:set_environment_id)
+
+        environment_id = headers[LD_ENVID_HEADER]
+        # The http gem returns arrays for repeated headers; normalize to a string.
+        environment_id = environment_id.first if environment_id.is_a?(Array)
+        return unless environment_id.is_a?(String) && !environment_id.empty?
+
+        sink.set_environment_id(environment_id)
+      end
+
       class StatusProvider
         include LaunchDarkly::Interfaces::DataSource::StatusProvider
 
@@ -41,12 +62,28 @@ module LaunchDarkly
           @dependency_tracker = LaunchDarkly::Impl::DependencyTracker.new
 
           @mutex = Mutex.new
+          @environment_id = nil
           @current_status = LaunchDarkly::Interfaces::DataSource::Status.new(
             LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING,
             Time.now,
             nil)
         end
 
+        #
+        # @return [String, nil] The environment ID reported by LaunchDarkly, if known
+        #
+        def environment_id
+          @mutex.synchronize { @environment_id }
+        end
+
+        #
+        # @param environment_id [String]
+        # @return [void]
+        #
+        def set_environment_id(environment_id)
+          @mutex.synchronize { @environment_id = environment_id }
+        end
+
         def init(all_data)
           old_data = nil
           monitor_store_update do

data/lib/ldclient-rb/impl/data_store/feature_store_client_wrapper.rb

@@ -65,6 +65,18 @@ module LaunchDarkly
           @store.initialized?
         end
 
+        #
+        # Passthrough for the FDv2 store coordinator. If the wrapped store supports
+        # disabling its cache (e.g. {LaunchDarkly::Integrations::Util::CachingStoreWrapper}),
+        # forward the call; otherwise no-op.
+        #
+        # @return [void]
+        #
+        def disable_cache
+          return unless @store.respond_to?(:disable_cache)
+          wrapper { @store.disable_cache }
+        end
+
         # (see LaunchDarkly::Interfaces::FeatureStore#stop)
         def stop
           poller_to_stop = nil

data/lib/ldclient-rb/impl/data_store/store.rb

@@ -221,6 +221,12 @@ module LaunchDarkly
           # Switch to memory store as active
           @active_store = @memory_store
 
+          # In-memory store is now authoritative. Disable the persistent-store cache
+          # so we don't hold a duplicate copy of every flag. Done before the
+          # persistent_store.init below so the wrapper can skip its cache-population
+          # loop on this very call.
+          disable_persistent_cache
+
           # Persist to persistent store if configured and writable
           @persistent_store.init(collections) if should_persist?
 
@@ -271,6 +277,24 @@ module LaunchDarkly
           send_change_events(affected_items) unless affected_items.empty?
         end
 
+        #
+        # Disable the persistent store's in-memory cache, if it has one. The FDv2 in-memory
+        # store is now the source of truth, so the cache is dead weight and would just
+        # hold a duplicate copy of every flag.
+        #
+        # @return [void]
+        #
+        private def disable_persistent_cache
+          return if @persistent_store.nil?
+          return unless @persistent_store.respond_to?(:disable_cache)
+
+          begin
+            @persistent_store.disable_cache
+          rescue => e
+            @logger.warn { "[LDClient] Failed to disable persistent store cache: #{e.message}" }
+          end
+        end
+
         #
         # Returns whether data should be persisted to the persistent store.
         #

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

@@ -121,6 +121,11 @@ module LaunchDarkly
           @flag_change_broadcaster
         end
 
+        # (see DataSystem#environment_id)
+        def environment_id
+          @data_source_update_sink.environment_id
+        end
+
         #
         # (see DataSystem#data_availability)
         #

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

@@ -100,6 +100,9 @@ module LaunchDarkly
             @store.with_persistence(wrapper, writable, @data_store_status_provider)
           end
 
+          @environment_id = nil
+          @environment_id_lock = Mutex.new
+
           # Threading
           @stop_event = Concurrent::Event.new
           @ready_event = Concurrent::Event.new
@@ -185,6 +188,11 @@ module LaunchDarkly
           @flag_change_broadcaster
         end
 
+        # (see DataSystem#environment_id)
+        def environment_id
+          @environment_id_lock.synchronize { @environment_id }
+        end
+
         # (see DataSystem#data_availability)
         def data_availability
           return DataAvailability::REFRESHED if @store.selector.defined?
@@ -214,8 +222,23 @@ module LaunchDarkly
               nil
             )
 
-            # Run initializers first
-            run_initializers
+            # Run initializers first. If an initializer signals the
+            # server-directed FDv1 Fallback Directive, switch terminally to
+            # the FDv1 Fallback Synchronizer (or transition to OFF if none
+            # is configured) before entering the synchronizer phase.
+            if run_initializers
+              if @fdv1_fallback_synchronizer_builder
+                @logger.warn { "[LDClient] Falling back to FDv1 protocol" }
+                @synchronizer_builders = [@fdv1_fallback_synchronizer_builder]
+              else
+                @logger.warn { "[LDClient] Initializer requested FDv1 fallback but none configured" }
+                @synchronizer_builders = []
+                @data_source_status_provider.update_status(
+                  LaunchDarkly::Interfaces::DataSource::Status::OFF,
+                  @data_source_status_provider.status.last_error
+                )
+              end
+            end
 
             # Run synchronizers
             run_synchronizers
@@ -228,39 +251,71 @@ module LaunchDarkly
         #
         # Run initializers to get initial data.
         #
-        # @return [void]
+        # Each initializer is tried in order until one succeeds, the system
+        # is stopped, or an initializer signals the server-directed FDv1
+        # Fallback Directive. When fallback is signalled alongside a valid
+        # payload, that payload is applied before returning so evaluations
+        # can serve the server-provided data while the FDv1 synchronizer
+        # spins up. The method returns true when fallback was requested so
+        # that the caller can switch the synchronizer list.
+        #
+        # @return [Boolean] true when an initializer requested FDv1 fallback.
         #
         def run_initializers
-          return unless @data_system_config.initializers
+          return false unless @data_system_config.initializers
 
           @data_system_config.initializers.each do |initializer_builder|
-            return if @stop_event.set?
+            return false if @stop_event.set?
 
             begin
               initializer = initializer_builder.build(@sdk_key, @config)
               @logger.info { "[LDClient] Attempting to initialize via #{initializer.name}" }
 
-              basis_result = initializer.fetch(@store)
+              fetch_result = initializer.fetch(@store)
+              fallback = fetch_result.fallback_to_fdv1
+              basis_result = fetch_result.result
 
               if basis_result.success?
                 basis = basis_result.value
                 @logger.info { "[LDClient] Initialized via #{initializer.name}" }
+                record_environment_id(basis.environment_id)
 
-                # Apply the basis to the store
+                # Apply the basis to the store regardless of whether fallback was signalled.
+                # If the server returned a valid payload alongside the directive we still want
+                # evaluations to serve that data while the FDv1 synchronizer spins up.
                 @store.apply(basis.change_set, basis.persist)
 
-                # Set ready event if and only if a selector is defined for the changeset
+                # Set ready event if and only if a selector is defined for the changeset.
                 if basis.change_set.selector && basis.change_set.selector.defined?
                   @ready_event.set
-                  return
+                  return fallback
                 end
               else
                 @logger.warn { "[LDClient] Initializer #{initializer.name} failed: #{basis_result.error}" }
+                if fallback
+                  # Record the underlying initializer error so that, if no FDv1 fallback is
+                  # configured, the subsequent transition to OFF carries it as last_error.
+                  @data_source_status_provider.update_status(
+                    LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING,
+                    LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(
+                      LaunchDarkly::Interfaces::DataSource::ErrorInfo::UNKNOWN,
+                      0,
+                      basis_result.error || "",
+                      Time.now
+                    )
+                  )
+                end
               end
+
+              # The fallback directive takes precedence over the regular failover algorithm,
+              # so do not fall through to the next initializer when it is set.
+              return true if fallback
             rescue => e
               @logger.error { "[LDClient] Initializer failed with exception: #{e.message}" }
             end
           end
+
+          false
         end
 
         #
@@ -313,12 +368,21 @@ module LaunchDarkly
                 case sync_result
                 when SyncResult::FDV1
                   if @fdv1_fallback_synchronizer_builder
+                    @logger.warn { "[LDClient] Falling back to FDv1 protocol" }
                     @synchronizer_builders = [@fdv1_fallback_synchronizer_builder]
                     current_index = 0
                     next
                   end
-                  # No FDv1 fallback configured, treat as regular fallback
-                  current_index += 1
+                  # No FDv1 fallback configured: the data system must HALT
+                  # rather than fall through to the next FDv2 synchronizer.
+                  # Continuing to retry would reopen the connection that just
+                  # delivered the directive.
+                  @logger.warn { "[LDClient] Synchronizer requested FDv1 fallback but none configured; halting data system" }
+                  @data_source_status_provider.update_status(
+                    LaunchDarkly::Interfaces::DataSource::Status::OFF,
+                    @data_source_status_provider.status.last_error
+                  )
+                  break
                 when SyncResult::RECOVER
                   @logger.info { "[LDClient] Recovery condition met, returning to primary synchronizer" }
                   current_index = 0
@@ -405,12 +469,15 @@ module LaunchDarkly
               @store.apply(update.change_set, true) if update.change_set
 
               # Set ready event on valid update
-              @ready_event.set if update.state == LaunchDarkly::Interfaces::DataSource::Status::VALID
+              if update.state == LaunchDarkly::Interfaces::DataSource::Status::VALID
+                @ready_event.set
+                record_environment_id(update.environment_id)
+              end
 
               # Update status
               @data_source_status_provider.update_status(update.state, update.error)
 
-              return SyncResult::FDV1 if update.revert_to_fdv1
+              return SyncResult::FDV1 if update.fallback_to_fdv1
 
               return SyncResult::REMOVE if update.state == LaunchDarkly::Interfaces::DataSource::Status::OFF
             end
@@ -426,6 +493,18 @@ module LaunchDarkly
           SyncResult::REMOVE
         end
 
+        #
+        # Retains the environment ID reported by a successful connection to LaunchDarkly.
+        #
+        # @param environment_id [String, nil]
+        # @return [void]
+        #
+        def record_environment_id(environment_id)
+          return unless environment_id.is_a?(String) && !environment_id.empty?
+
+          @environment_id_lock.synchronize { @environment_id = environment_id }
+        end
+
         #
         # Determine if we should fallback to the next synchronizer.
         #