launchdarkly-server-sdk 6.2.5 → 6.3.2

data/lib/ldclient-rb/integrations/util/store_wrapper.rb

@@ -4,6 +4,11 @@ require "ldclient-rb/expiring_cache"
 
 module LaunchDarkly
   module Integrations
+    #
+    # Support code that may be helpful in creating integrations.
+    #
+    # @since 5.5.0
+    #
     module Util
       #
       # CachingStoreWrapper is a partial implementation of the {LaunchDarkly::Interfaces::FeatureStore}

data/lib/ldclient-rb/integrations.rb

@@ -1,55 +1,6 @@
 require "ldclient-rb/integrations/consul"
 require "ldclient-rb/integrations/dynamodb"
+require "ldclient-rb/integrations/file_data"
 require "ldclient-rb/integrations/redis"
+require "ldclient-rb/integrations/test_data"
 require "ldclient-rb/integrations/util/store_wrapper"
-
-module LaunchDarkly
-  #
-  # Tools for connecting the LaunchDarkly client to other software.
-  #
-  module Integrations
-    #
-    # Integration with [Consul](https://www.consul.io/).
-    #
-    # Note that in order to use this integration, you must first install the gem `diplomat`.
-    #
-    # @since 5.5.0
-    #
-    module Consul
-      # code is in ldclient-rb/impl/integrations/consul_impl
-    end
-    
-    #
-    # Integration with [DynamoDB](https://aws.amazon.com/dynamodb/).
-    #
-    # Note that in order to use this integration, you must first install one of the AWS SDK gems: either
-    # `aws-sdk-dynamodb`, or the full `aws-sdk`.
-    #
-    # @since 5.5.0
-    #
-    module DynamoDB
-      # code is in ldclient-rb/impl/integrations/dynamodb_impl
-    end
-
-    #
-    # Integration with [Redis](https://redis.io/).
-    #
-    # Note that in order to use this integration, you must first install the `redis` and `connection-pool`
-    # gems.
-    #
-    # @since 5.5.0
-    #
-    module Redis
-      # code is in ldclient-rb/impl/integrations/redis_impl
-    end
-
-    #
-    # Support code that may be helpful in creating integrations.
-    #
-    # @since 5.5.0
-    #
-    module Util
-      # code is in ldclient-rb/integrations/util/
-    end
-  end
-end

data/lib/ldclient-rb/interfaces.rb

@@ -1,3 +1,4 @@
+require "observer"
 
 module LaunchDarkly
   #
@@ -120,7 +121,8 @@ module LaunchDarkly
     #
     # The client has its own standard implementation, which uses either a streaming connection or
     # polling depending on your configuration. Normally you will not need to use another one
-    # except for testing purposes. {FileDataSource} provides one such test fixture.
+    # except for testing purposes. Two such test fixtures are {LaunchDarkly::Integrations::FileData}
+    # and {LaunchDarkly::Integrations::TestData}.
     #
     module DataSource
       #
@@ -149,5 +151,153 @@ module LaunchDarkly
       def stop
       end
     end
+
+    module BigSegmentStore
+      #
+      # Returns information about the overall state of the store. This method will be called only
+      # when the SDK needs the latest state, so it should not be cached.
+      #
+      # @return [BigSegmentStoreMetadata]
+      #
+      def get_metadata
+      end
+
+      #
+      # Queries the store for a snapshot of the current segment state for a specific user.
+      #
+      # The user_hash is a base64-encoded string produced by hashing the user key as defined by
+      # the Big Segments specification; the store implementation does not need to know the details
+      # of how this is done, because it deals only with already-hashed keys, but the string can be
+      # assumed to only contain characters that are valid in base64.
+      #
+      # The return value should be either a Hash, or nil if the user is not referenced in any big
+      # segments. Each key in the Hash is a "segment reference", which is how segments are
+      # identified in Big Segment data. This string is not identical to the segment key-- the SDK
+      # will add other information. The store implementation should not be concerned with the
+      # format of the string. Each value in the Hash is true if the user is explicitly included in
+      # the segment, false if the user is explicitly excluded from the segment-- and is not also
+      # explicitly included (that is, if both an include and an exclude existed in the data, the
+      # include would take precedence). If the user's status in a particular segment is undefined,
+      # there should be no key or value for that segment.
+      #
+      # This Hash may be cached by the SDK, so it should not be modified after it is created. It
+      # is a snapshot of the segment membership state at one point in time.
+      #
+      # @param user_hash [String]
+      # @return [Hash] true/false values for Big Segments that reference this user
+      #
+      def get_membership(user_hash)
+      end
+
+      #
+      # Performs any necessary cleanup to shut down the store when the client is being shut down.
+      #
+      # @return [void]
+      #
+      def stop
+      end
+    end
+
+    #
+    # Values returned by {BigSegmentStore#get_metadata}.
+    #
+    class BigSegmentStoreMetadata
+      def initialize(last_up_to_date)
+        @last_up_to_date = last_up_to_date
+      end
+
+      # The Unix epoch millisecond timestamp of the last update to the {BigSegmentStore}. It is
+      # nil if the store has never been updated.
+      #
+      # @return [Integer|nil]
+      attr_reader :last_up_to_date
+    end
+
+    #
+    # Information about the status of a Big Segment store, provided by {BigSegmentStoreStatusProvider}.
+    #
+    # Big Segments are a specific type of user segments. For more information, read the LaunchDarkly
+    # documentation: https://docs.launchdarkly.com/home/users/big-segments
+    #
+    class BigSegmentStoreStatus
+      def initialize(available, stale)
+        @available = available
+        @stale = stale
+      end
+
+      # True if the Big Segment store is able to respond to queries, so that the SDK can evaluate
+      # whether a user is in a segment or not.
+      #
+      # If this property is false, the store is not able to make queries (for instance, it may not have
+      # a valid database connection). In this case, the SDK will treat any reference to a Big Segment
+      # as if no users are included in that segment. Also, the {EvaluationReason} associated with
+      # with any flag evaluation that references a Big Segment when the store is not available will
+      # have a `big_segments_status` of `STORE_ERROR`.
+      #
+      # @return [Boolean]
+      attr_reader :available
+
+      # True if the Big Segment store is available, but has not been updated within the amount of time
+      # specified by {BigSegmentsConfig#stale_after}.
+      #
+      # This may indicate that the LaunchDarkly Relay Proxy, which populates the store, has stopped
+      # running or has become unable to receive fresh data from LaunchDarkly. Any feature flag
+      # evaluations that reference a Big Segment will be using the last known data, which may be out
+      # of date. Also, the {EvaluationReason} associated with those evaluations will have a
+      # `big_segments_status` of `STALE`.
+      #
+      # @return [Boolean]
+      attr_reader :stale
+
+      def ==(other)
+        self.available == other.available && self.stale == other.stale
+      end
+    end
+
+    #
+    # An interface for querying the status of a Big Segment store.
+    #
+    # The Big Segment store is the component that receives information about Big Segments, normally
+    # from a database populated by the LaunchDarkly Relay Proxy. Big Segments are a specific type
+    # of user segments. For more information, read the LaunchDarkly documentation:
+    # https://docs.launchdarkly.com/home/users/big-segments
+    #
+    # An implementation of this interface is returned by {LDClient#big_segment_store_status_provider}.
+    # Application code never needs to implement this interface.
+    #
+    # There are two ways to interact with the status. One is to simply get the current status; if its
+    # `available` property is true, then the SDK is able to evaluate user membership in Big Segments,
+    # and the `stale`` property indicates whether the data might be out of date.
+    #
+    # The other way is to subscribe to status change notifications. Applications may wish to know if
+    # there is an outage in the Big Segment store, or if it has become stale (the Relay Proxy has
+    # stopped updating it with new data), since then flag evaluations that reference a Big Segment
+    # might return incorrect values. To allow finding out about status changes as soon as possible,
+    # `BigSegmentStoreStatusProvider` mixes in Ruby's
+    # [Observable](https://docs.ruby-lang.org/en/2.5.0/Observable.html) module to provide standard
+    # methods such as `add_observer`. Observers will be called with a new {BigSegmentStoreStatus}
+    # value whenever the status changes.
+    #
+    # @example Getting the current status
+    #   status = client.big_segment_store_status_provider.status
+    #
+    # @example Subscribing to status notifications
+    #   client.big_segment_store_status_provider.add_observer(self, :big_segments_status_changed)
+    #
+    #   def big_segments_status_changed(new_status)
+    #     puts "Big segment store status is now: #{new_status}"
+    #   end
+    #
+    module BigSegmentStoreStatusProvider
+      include Observable
+      #
+      # Gets the current status of the store, if known.
+      #
+      # @return [BigSegmentStoreStatus] the status, or nil if the SDK has not yet queried the Big
+      #   Segment store status
+      #
+      def status
+      end
+    end
   end
 end

data/lib/ldclient-rb/ldclient.rb

@@ -1,3 +1,4 @@
+require "ldclient-rb/impl/big_segments"
 require "ldclient-rb/impl/diagnostic_events"
 require "ldclient-rb/impl/evaluator"
 require "ldclient-rb/impl/event_factory"
@@ -57,9 +58,13 @@ module LaunchDarkly
       updated_config.instance_variable_set(:@feature_store, @store)
       @config = updated_config
 
+      @big_segment_store_manager = Impl::BigSegmentStoreManager.new(config.big_segments, @config.logger)
+      @big_segment_store_status_provider = @big_segment_store_manager.status_provider
+
       get_flag = lambda { |key| @store.get(FEATURES, key) }
       get_segment = lambda { |key| @store.get(SEGMENTS, key) }
-      @evaluator = LaunchDarkly::Impl::Evaluator.new(get_flag, get_segment, @config.logger)
+      get_big_segments_membership = lambda { |key| @big_segment_store_manager.get_user_membership(key) }
+      @evaluator = LaunchDarkly::Impl::Evaluator.new(get_flag, get_segment, get_big_segments_membership, @config.logger)
 
       if !@config.offline? && @config.send_events && !@config.diagnostic_opt_out?
         diagnostic_accumulator = Impl::DiagnosticAccumulator.new(Impl::DiagnosticAccumulator.create_diagnostic_id(sdk_key))
@@ -173,7 +178,7 @@ module LaunchDarkly
     # Other supported user attributes include IP address, country code, and an arbitrary hash of
     # custom attributes. For more about the supported user properties and how they work in
     # LaunchDarkly, see [Targeting users](https://docs.launchdarkly.com/home/flags/targeting-users).
-    # 
+    #
     # The optional `:privateAttributeNames` user property allows you to specify a list of
     # attribute names that should not be sent back to LaunchDarkly.
     # [Private attributes](https://docs.launchdarkly.com/home/users/attributes#creating-private-user-attributes)
@@ -243,8 +248,8 @@ module LaunchDarkly
     # @return [void]
     #
     def identify(user)
-      if !user || user[:key].nil?
-        @config.logger.warn("Identify called with nil user or nil user key!")
+      if !user || user[:key].nil? || user[:key].empty?
+        @config.logger.warn("Identify called with nil user or empty user key!")
         return
       end
       sanitize_user(user)
@@ -333,6 +338,15 @@ module LaunchDarkly
     def all_flags_state(user, options={})
       return FeatureFlagsState.new(false) if @config.offline?
 
+      if !initialized?
+        if @store.initialized?
+            @config.logger.warn { "Called all_flags_state before client initialization; using last known values from data store" }
+        else
+            @config.logger.warn { "Called all_flags_state before client initialization. Data store not available; returning empty state" }
+            return FeatureFlagsState.new(false)
+        end
+      end
+
       unless user && !user[:key].nil?
         @config.logger.error { "[LDClient] User and user key must be specified in all_flags_state" }
         return FeatureFlagsState.new(false)
@@ -354,14 +368,25 @@ module LaunchDarkly
           next
         end
         begin
-          result = @evaluator.evaluate(f, user, @event_factory_default)
-          state.add_flag(f, result.detail.value, result.detail.variation_index, with_reasons ? result.detail.reason : nil,
-            details_only_if_tracked)
+          detail = @evaluator.evaluate(f, user, @event_factory_default).detail
         rescue => exn
+          detail = EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_EXCEPTION))
           Util.log_exception(@config.logger, "Error evaluating flag \"#{k}\" in all_flags_state", exn)
-          state.add_flag(f, nil, nil, with_reasons ? EvaluationReason::error(EvaluationReason::ERROR_EXCEPTION) : nil,
-            details_only_if_tracked)
         end
+
+        requires_experiment_data = EventFactory.is_experiment(f, detail.reason)
+        flag_state = {
+          key: f[:key],
+          value: detail.value,
+          variation: detail.variation_index,
+          reason: detail.reason,
+          version: f[:version],
+          trackEvents: f[:trackEvents] || requires_experiment_data,
+          trackReason: requires_experiment_data,
+          debugEventsUntilDate: f[:debugEventsUntilDate],
+        }
+
+        state.add_flag(flag_state, with_reasons, details_only_if_tracked)
       end
 
       state
@@ -375,9 +400,18 @@ module LaunchDarkly
       @config.logger.info { "[LDClient] Closing LaunchDarkly client..." }
       @data_source.stop
       @event_processor.stop
+      @big_segment_store_manager.stop
       @store.stop
     end
 
+    #
+    # Returns an interface for tracking the status of a Big Segment store.
+    #
+    # The {BigSegmentStoreStatusProvider} has methods for checking whether the Big Segment store
+    # is (as far as the SDK knows) currently operational and tracking changes in this status.
+    #
+    attr_reader :big_segment_store_status_provider
+
     private
 
     def create_default_data_source(sdk_key, config, diagnostic_accumulator)

data/lib/ldclient-rb/polling.rb

@@ -1,3 +1,5 @@
+require "ldclient-rb/impl/repeating_task"
+
 require "concurrent/atomics"
 require "thread"
 
@@ -9,8 +11,8 @@ module LaunchDarkly
       @requestor = requestor
       @initialized = Concurrent::AtomicBoolean.new(false)
       @started = Concurrent::AtomicBoolean.new(false)
-      @stopped = Concurrent::AtomicBoolean.new(false)
       @ready = Concurrent::Event.new
+      @task = Impl::RepeatingTask.new(@config.poll_interval, 0, -> { self.poll }, @config.logger)
     end
 
     def initialized?
@@ -20,56 +22,35 @@ module LaunchDarkly
     def start
       return @ready unless @started.make_true
       @config.logger.info { "[LDClient] Initializing polling connection" }
-      create_worker
+      @task.start
       @ready
     end
 
     def stop
-      if @stopped.make_true
-        if @worker && @worker.alive? && @worker != Thread.current
-          @worker.run  # causes the thread to wake up if it's currently in a sleep
-          @worker.join
-        end
-        @config.logger.info { "[LDClient] Polling connection stopped" }
-      end
+      @task.stop
+      @config.logger.info { "[LDClient] Polling connection stopped" }
     end
 
     def poll
-      all_data = @requestor.request_all_data
-      if all_data
-        @config.feature_store.init(all_data)
-        if @initialized.make_true
-          @config.logger.info { "[LDClient] Polling connection initialized" }
-          @ready.set
-        end
-      end
-    end
-
-    def create_worker
-      @worker = Thread.new do
-        @config.logger.debug { "[LDClient] Starting polling worker" }
-        while !@stopped.value do
-          started_at = Time.now
-          begin
-            poll
-          rescue UnexpectedResponseError => e
-            message = Util.http_error_message(e.status, "polling request", "will retry")
-            @config.logger.error { "[LDClient] #{message}" };
-            if !Util.http_error_recoverable?(e.status)
-              @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
-              stop
-            end
-          rescue StandardError => exn
-            Util.log_exception(@config.logger, "Exception while polling", exn)
-          end
-          delta = @config.poll_interval - (Time.now - started_at)
-          if delta > 0
-            sleep(delta)
+      begin
+        all_data = @requestor.request_all_data
+        if all_data
+          @config.feature_store.init(all_data)
+          if @initialized.make_true
+            @config.logger.info { "[LDClient] Polling connection initialized" }
+            @ready.set
           end
         end
+      rescue UnexpectedResponseError => e
+        message = Util.http_error_message(e.status, "polling request", "will retry")
+        @config.logger.error { "[LDClient] #{message}" };
+        if !Util.http_error_recoverable?(e.status)
+          @ready.set  # if client was waiting on us, make it stop waiting - has no effect if already set
+          stop
+        end
+      rescue StandardError => e
+        Util.log_exception(@config.logger, "Exception while polling", e)
       end
     end
-
-    private :poll, :create_worker
   end
 end

data/lib/ldclient-rb/stream.rb

@@ -47,7 +47,8 @@ module LaunchDarkly
         headers: headers,
         read_timeout: READ_TIMEOUT_SECONDS,
         logger: @config.logger,
-        socket_factory: @config.socket_factory
+        socket_factory: @config.socket_factory,
+        reconnect_time: @config.initial_reconnect_delay
       }
       log_connection_started
       @es = SSE::Client.new(@config.stream_uri + "/all", **opts) do |conn|

data/lib/ldclient-rb/util.rb

@@ -18,12 +18,21 @@ module LaunchDarkly
       end
       ret
     end
-    
+
     def self.new_http_client(uri_s, config)
       http_client_options = {}
       if config.socket_factory
         http_client_options["socket_class"] = config.socket_factory
       end
+      proxy = URI.parse(uri_s).find_proxy
+      if !proxy.nil?
+        http_client_options["proxy"] = {
+          proxy_address: proxy.host,
+          proxy_port: proxy.port,
+          proxy_username: proxy.user,
+          proxy_password: proxy.password
+        }
+      end
       return HTTP::Client.new(http_client_options)
         .timeout({
           read: config.read_timeout,

data/lib/ldclient-rb/version.rb

@@ -1,3 +1,3 @@
 module LaunchDarkly
-  VERSION = "6.2.5"
+  VERSION = "6.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: launchdarkly-server-sdk
 version: !ruby/object:Gem::Version
-  version: 6.2.5
+  version: 6.3.2
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-12 00:00:00.000000000 Z
+date: 2022-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-dynamodb
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.2.33
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.2.10
+        version: 2.2.33
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -198,14 +198,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.1.1
+        version: 2.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.1.1
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -260,6 +260,7 @@ files:
 - lib/ldclient-rb/file_data_source.rb
 - lib/ldclient-rb/flags_state.rb
 - lib/ldclient-rb/impl.rb
+- lib/ldclient-rb/impl/big_segments.rb
 - lib/ldclient-rb/impl/diagnostic_events.rb
 - lib/ldclient-rb/impl/evaluator.rb
 - lib/ldclient-rb/impl/evaluator_bucketing.rb
@@ -268,8 +269,11 @@ files:
 - lib/ldclient-rb/impl/event_sender.rb
 - lib/ldclient-rb/impl/integrations/consul_impl.rb
 - lib/ldclient-rb/impl/integrations/dynamodb_impl.rb
+- lib/ldclient-rb/impl/integrations/file_data_source.rb
 - lib/ldclient-rb/impl/integrations/redis_impl.rb
+- lib/ldclient-rb/impl/integrations/test_data/test_data_source.rb
 - lib/ldclient-rb/impl/model/serialization.rb
+- lib/ldclient-rb/impl/repeating_task.rb
 - lib/ldclient-rb/impl/store_client_wrapper.rb
 - lib/ldclient-rb/impl/store_data_set_sorter.rb
 - lib/ldclient-rb/impl/unbounded_pool.rb
@@ -278,7 +282,10 @@ files:
 - lib/ldclient-rb/integrations.rb
 - lib/ldclient-rb/integrations/consul.rb
 - lib/ldclient-rb/integrations/dynamodb.rb
+- lib/ldclient-rb/integrations/file_data.rb
 - lib/ldclient-rb/integrations/redis.rb
+- lib/ldclient-rb/integrations/test_data.rb
+- lib/ldclient-rb/integrations/test_data/flag_builder.rb
 - lib/ldclient-rb/integrations/util/store_wrapper.rb
 - lib/ldclient-rb/interfaces.rb
 - lib/ldclient-rb/ldclient.rb
@@ -312,7 +319,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.29
+rubygems_version: 3.3.9
 signing_key: 
 specification_version: 4
 summary: LaunchDarkly SDK for Ruby