launchdarkly-server-sdk 8.14.0 → 8.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ec609a22208597d110a93cf4ea65b4b20a723cfccf5b3db743921aeb27a40a
-  data.tar.gz: 7833879176def90e31a71756cc27b90135985d2a75c305582ef3d09ad504ff72
+  metadata.gz: 06b22ffc1ba131d82969abf4c5e6b04ab80d18a5112393a41f59a3b7217e9633
+  data.tar.gz: 52e8d3a1615a43d15d9fa548db9568456409c3cbfd716f558635c7377b35987f
 SHA512:
-  metadata.gz: c607be8b3926d090a243453c39375df4892c7ea49cb8a5f6c366bd47d4299c6f9ff525f2cb8e94c535b6a1dfa54a9f348ba4a59477e8eac8a420c1ce85fae777
-  data.tar.gz: 80d5b45d30922ce0c24f3ed56b7ca9f0e0d57e98e972600161b24517e89318da43fc94ba11219558467bf4e9088114b7b3b863b420ab0f9b1a88cc4f2805b018
+  metadata.gz: b632a4958bab5ad77398d87cf3b018e0fe35c37e53b5590dc330b6c395a6fe22f0fc50ef820182b197179ac9c933356bf1a718b8f5bdcd4d8b40d3daae8367b5
+  data.tar.gz: 22284f8464984ed1de431109260354d8285ae2079a47429a62e2e8fb49abb954e4d75c220cf264a9409b20bcd0ddc2cb6ca167c8ddd481bf8d769e08b5642362

data/lib/ldclient-rb/config.rb

@@ -262,6 +262,10 @@ module LaunchDarkly
     # You can also specify the same behavior for an individual flag evaluation
     # by providing the context object with a list of private attributes.
     #
+    # Each entry is an attribute reference. A reference addresses attributes by
+    # symbol name, so it cannot make an attribute private if that attribute was
+    # given a string name. Refer to {LDContext} for the symbol requirement.
+    #
     # @see https://docs.launchdarkly.com/sdk/features/user-context-config#using-private-attributes
     #
     # @return [Array<String>]
@@ -399,6 +403,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

data/lib/ldclient-rb/context.rb

@@ -6,6 +6,17 @@ module LaunchDarkly
   # LDContext is a collection of attributes that can be referenced in flag
   # evaluations and analytics events.
   #
+  # Every attribute name must be a symbol. This applies to the built-in
+  # properties, such as :key and :kind, and to custom attributes at every level
+  # of nesting. The SDK addresses attributes by symbol, so it cannot find an
+  # attribute that has a string name. Such an attribute is invisible to flag
+  # evaluation and to private attribute redaction.
+  #
+  # Take care with data that arrives as JSON. `JSON.parse` returns string keys
+  # by default, so pass `symbolize_names: true` before you build a context from
+  # it. Note that the `"name": value` form in a hash literal already produces a
+  # symbol, so a hand-written literal is safe.
+  #
   # To create an LDContext of a single kind, such as a user, you may use
   # {LDContext#create} or {LDContext#with_key}.
   #
@@ -148,6 +159,9 @@ module LaunchDarkly
     #
     # Return an array of top level attribute keys (excluding built-in attributes)
     #
+    # The keys come back in the form the caller supplied. A string key is
+    # returned as a string, even though the SDK cannot address it.
+    #
     # @return [Array<Symbol>]
     #
     def get_custom_attribute_names
@@ -172,6 +186,9 @@ module LaunchDarkly
     # values out of JSON objects or arrays, such as "/address/street". Use
     # {#get_value_for_reference} for that purpose.
     #
+    # The lookup treats the name as a symbol. An attribute that was stored under
+    # a string name is therefore not found, and the result is nil.
+    #
     # If the value is found, the return value is the attribute value;
     # otherwise, it is nil.
     #
@@ -200,6 +217,10 @@ module LaunchDarkly
     # Use {#individual_context} to inspect a Context for a particular kind and
     # then get its attributes.
     #
+    # A Reference holds its path components as symbols, so each step of the
+    # lookup matches a symbol key. A path that crosses an attribute with a
+    # string name resolves to nil.
+    #
     # If the value is found, the return value is the attribute value;
     # otherwise, it is nil.
     #
@@ -440,6 +461,14 @@ module LaunchDarkly
     # {https://docs.launchdarkly.com/sdk/features/user-config SDK
     # documentation}.
     #
+    # Every key in the hash must be a symbol, at the top level and inside any
+    # nested attribute value. Refer to the {LDContext} class documentation for
+    # why, and for the JSON.parse caveat.
+    #
+    # A string key does not make the context invalid, with two exceptions. The
+    # context requires a symbol :kind and a symbol :key, so a hash that supplies
+    # those as strings is invalid.
+    #
     # @param data [Hash]
     # @return [LDContext]
     #

data/lib/ldclient-rb/events.rb

@@ -487,7 +487,7 @@ module LaunchDarkly
     SUMMARY_KIND = 'summary'
 
     def initialize(config)
-      @context_filter = LaunchDarkly::Impl::ContextFilter.new(config.all_attributes_private, config.private_attributes)
+      @context_filter = LaunchDarkly::Impl::ContextFilter.new(config.all_attributes_private, config.private_attributes, config.logger)
     end
 
     # Transforms events into the format used for event sending.

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

@@ -1,12 +1,17 @@
+require "concurrent/atomics"
+
 module LaunchDarkly
   module Impl
     class ContextFilter
       #
       # @param all_attributes_private [Boolean]
       # @param private_attributes [Array<String>]
+      # @param logger [Logger, nil]
       #
-      def initialize(all_attributes_private, private_attributes)
+      def initialize(all_attributes_private, private_attributes, logger = nil)
         @all_attributes_private = all_attributes_private
+        @logger = logger
+        @non_symbol_name_logged = Concurrent::AtomicBoolean.new(false)
 
         @private_attributes = []
         private_attributes.each do |attribute|
@@ -70,17 +75,22 @@ 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 attribute.is_a?(Symbol)
+            log_non_symbol_name(attribute)
+            next
+          end
+
+          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)
+            filtered[attribute] = redact_json_value(nil, attribute, value, private_attributes, redacted, [])
           end
         end
 
@@ -92,7 +102,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 +110,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
@@ -122,16 +132,34 @@ module LaunchDarkly
       # @param value [any]
       # @param private_attributes [Array<Reference>]
       # @param redacted [Array<Symbol>]
+      # @param visited [Array<Hash>]
       # @return [any]
       #
-      private def redact_json_value(parent_path, name, value, private_attributes, redacted)
+      private def redact_json_value(parent_path, name, value, private_attributes, redacted, visited)
         return value unless value.is_a?(Hash)
 
         ret = {}
         current_path = parent_path.clone || []
         current_path << name
 
+        # The chain of hashes from the attribute root down to this value. A
+        # nested value that points back into this chain is a cycle and is
+        # omitted.
+        #
+        # The comparison is by object identity, which keeps the check cheap.
+        # Context creation copies each top-level attribute value, so a cycle
+        # through that value appears once in the output before it is cut.
+        # Private attribute references match the paths that appear in the
+        # output. Cyclic values are not valid context data; this check only
+        # prevents unbounded recursion.
+        branch = visited + [value]
+
         value.each do |k, v|
+          unless k.is_a?(Symbol)
+            log_non_symbol_name(k)
+            next
+          end
+
           was_redacted = false
           private_attributes.each do |private_attribute|
             next unless private_attribute.depth == (current_path.count + 1)
@@ -155,12 +183,34 @@ module LaunchDarkly
           end
 
           unless was_redacted
-            ret[k] = redact_json_value(current_path, k, v, private_attributes, redacted)
+            next if v.is_a?(Hash) && branch.any? { |seen| seen.equal?(v) }
+
+            ret[k] = redact_json_value(current_path, k, v, private_attributes, redacted, branch)
           end
         end
 
         ret
       end
+
+      #
+      # Log the first attribute found with a non-symbol name. Later
+      # occurrences are not logged to prevent log spam.
+      #
+      # Attribute references cannot address non-symbol names, so these
+      # attributes cannot be evaluated or redacted. They are omitted from
+      # analytics events.
+      #
+      # @param name [any]
+      #
+      private def log_non_symbol_name(name)
+        return if @logger.nil?
+        return unless @non_symbol_name_logged.make_true
+
+        @logger.error do
+          "[LDClient] Context attributes with non-symbol names cannot be evaluated or redacted, " \
+            "so they are omitted from analytics events (first occurrence: #{name.inspect}). This message is logged once."
+        end
+      end
     end
   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
@@ -65,8 +67,11 @@ module LaunchDarkly
                 error_info
               )
             else
-              @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
+              # Publish the OFF status before releasing anyone waiting on the
+              # ready event, so a client that returns from start can rely on the
+              # data source status already reflecting the failure.
               stop_with_error_info error_info
+              @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
             end
           rescue StandardError => e
             Impl::Util.log_exception(@config.logger, "Exception while polling", e)
@@ -92,6 +97,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_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?
@@ -270,6 +278,7 @@ module LaunchDarkly
               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 regardless of whether fallback was signalled.
                 # If the server returned a valid payload alongside the directive we still want
@@ -460,7 +469,10 @@ 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)
@@ -481,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.
         #

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

@@ -313,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

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.
       #

data/lib/ldclient-rb/integrations/file_data.rb

@@ -50,7 +50,7 @@ module LaunchDarkly
     #       "segments": {
     #         "segment-key-1": {
     #           "key": "segment-key-1",
-    #           "includes": [ "user-key-1" ]
+    #           "included": [ "user-key-1" ]
     #         }
     #       }
     #     }

data/lib/ldclient-rb/interfaces/hooks.rb

@@ -70,17 +70,27 @@ module LaunchDarkly
         attr_reader :default_value
         attr_reader :method
 
+        #
+        # The ID of the LaunchDarkly environment the SDK is connected to, if known. This is only available once the
+        # SDK has received data from LaunchDarkly.
+        #
+        # @return [String, nil]
+        #
+        attr_reader :environment_id
+
         #
         # @param key [String]
         # @param context [LaunchDarkly::LDContext]
         # @param default_value [any]
         # @param method [Symbol]
+        # @param environment_id [String, nil]
         #
-        def initialize(key, context, default_value, method)
+        def initialize(key, context, default_value, method, environment_id = nil)
           @key = key
           @context = context
           @default_value = default_value
           @method = method
+          @environment_id = environment_id
         end
       end
     end

data/lib/ldclient-rb/ldclient.rb

@@ -421,7 +421,7 @@ module LaunchDarkly
       # Hooks can be added and we want to ensure all correct stages for a given hook execute. For example, we do not
       # want to trigger the after_evaluation method without also triggering the before_evaluation method.
       hooks = @hooks.dup
-      evaluation_series_context = Interfaces::Hooks::EvaluationSeriesContext.new(key, context, default, method)
+      evaluation_series_context = Interfaces::Hooks::EvaluationSeriesContext.new(key, context, default, method, @data_system.environment_id)
 
       [hooks, evaluation_series_context]
     end

data/lib/ldclient-rb/reference.rb

@@ -12,6 +12,10 @@ module LaunchDarkly
   # or to identify an attribute or nested value that should be considered
   # private.
   #
+  # A Reference holds its path components as symbols, whichever form the input
+  # string used. It therefore addresses only context attributes that have symbol
+  # names, which is the form a context requires.
+  #
   # Parsing and validation are done at the time that the Reference is
   # constructed. If a Reference instance was created from an invalid string, it
   # is considered invalid and its {Reference#error} attribute will return a

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "8.14.0" # x-release-please-version
+  VERSION = "8.15.1" # 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.14.0
+  version: 8.15.1
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-01 00:00:00.000000000 Z
+date: 2026-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb