launchdarkly-server-sdk 6.2.5 → 7.0.0

data/lib/ldclient-rb/ldclient.rb

@@ -1,6 +1,6 @@
+require "ldclient-rb/impl/big_segments"
 require "ldclient-rb/impl/diagnostic_events"
 require "ldclient-rb/impl/evaluator"
-require "ldclient-rb/impl/event_factory"
 require "ldclient-rb/impl/store_client_wrapper"
 require "concurrent/atomics"
 require "digest/sha1"
@@ -45,9 +45,6 @@ module LaunchDarkly
 
       @sdk_key = sdk_key
 
-      @event_factory_default = EventFactory.new(false)
-      @event_factory_with_reasons = EventFactory.new(true)
-
       # We need to wrap the feature store object with a FeatureStoreClientWrapper in order to add
       # some necessary logic around updates. Unfortunately, we have code elsewhere that accesses
       # the feature store through the Config object, so we need to make a new Config that uses
@@ -57,9 +54,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_context_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))
@@ -119,26 +120,20 @@ module LaunchDarkly
     end
 
     #
-    # @param key [String] the feature flag key
-    # @param user [Hash] the user properties
-    # @param default [Boolean] (false) the value to use if the flag cannot be evaluated
-    # @return [Boolean] the flag value
-    # @deprecated Use {#variation} instead.
-    #
-    def toggle?(key, user, default = false)
-      @config.logger.warn { "[LDClient] toggle? is deprecated. Use variation instead" }
-      variation(key, user, default)
-    end
-
-    #
-    # Creates a hash string that can be used by the JavaScript SDK to identify a user.
+    # Creates a hash string that can be used by the JavaScript SDK to identify a context.
     # For more information, see [Secure mode](https://docs.launchdarkly.com/sdk/features/secure-mode#ruby).
     #
-    # @param user [Hash] the user properties
-    # @return [String] a hash string
+    # @param context [Hash, LDContext]
+    # @return [String, nil] a hash string or nil if the provided context was invalid
     #
-    def secure_mode_hash(user)
-      OpenSSL::HMAC.hexdigest("sha256", @sdk_key, user[:key].to_s)
+    def secure_mode_hash(context)
+      context = Impl::Context::make_context(context)
+      unless context.valid?
+        @config.logger.warn("secure_mode_hash called with invalid context: #{context.error}")
+        return nil
+      end
+
+      OpenSSL::HMAC.hexdigest("sha256", @sdk_key, context.fully_qualified_key)
     end
 
     #
@@ -164,44 +159,22 @@ module LaunchDarkly
     end
 
     #
-    # Determines the variation of a feature flag to present to a user.
-    #
-    # At a minimum, the user hash should contain a `:key`, which should be the unique
-    # identifier for your user (or, for an anonymous user, a session identifier or
-    # cookie).
-    #
-    # 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)
-    # can also be configured globally in {Config}.
-    #
-    # @example Basic user hash
-    #   {key: "my-user-id"}
-    #
-    # @example More complete user hash
-    #   {key: "my-user-id", ip: "127.0.0.1", country: "US", custom: {customer_rank: 1000}}
-    #
-    # @example User with a private attribute
-    #   {key: "my-user-id", email: "email@example.com", privateAttributeNames: ["email"]}
+    # Determines the variation of a feature flag to present for a context.
     #
     # @param key [String] the unique feature key for the feature flag, as shown
     #   on the LaunchDarkly dashboard
-    # @param user [Hash] a hash containing parameters for the end user requesting the flag
+    # @param context [Hash, LDContext] a hash or LDContext instance describing the context requesting the flag
     # @param default the default value of the flag; this is used if there is an error
     #   condition making it impossible to find or evaluate the flag
     #
-    # @return the variation to show the user, or the default value if there's an an error
+    # @return the variation for the provided context, or the default value if there's an an error
     #
-    def variation(key, user, default)
-      evaluate_internal(key, user, default, @event_factory_default).value
+    def variation(key, context, default)
+      evaluate_internal(key, context, default, false).value
     end
 
     #
-    # Determines the variation of a feature flag for a user, like {#variation}, but also
+    # Determines the variation of a feature flag for a context, like {#variation}, but also
     # provides additional information about how this value was calculated.
     #
     # The return value of `variation_detail` is an {EvaluationDetail} object, which has
@@ -217,43 +190,48 @@ module LaunchDarkly
     #
     # @param key [String] the unique feature key for the feature flag, as shown
     #   on the LaunchDarkly dashboard
-    # @param user [Hash] a hash containing parameters for the end user requesting the flag
+    # @param context [Hash, LDContext] a hash or object describing the context requesting the flag,
     # @param default the default value of the flag; this is used if there is an error
     #   condition making it impossible to find or evaluate the flag
     #
     # @return [EvaluationDetail] an object describing the result
     #
-    def variation_detail(key, user, default)
-      evaluate_internal(key, user, default, @event_factory_with_reasons)
+    def variation_detail(key, context, default)
+      evaluate_internal(key, context, default, true)
     end
 
     #
-    # Registers the user. This method simply creates an analytics event containing the user
-    # properties, so that LaunchDarkly will know about that user if it does not already.
+    # Registers the context. This method simply creates an analytics event containing the context
+    # properties, so that LaunchDarkly will know about that context if it does not already.
     #
-    # Calling {#variation} or {#variation_detail} also sends the user information to
+    # Calling {#variation} or {#variation_detail} also sends the context information to
     # LaunchDarkly (if events are enabled), so you only need to use {#identify} if you
-    # want to identify the user without evaluating a flag.
+    # want to identify the context without evaluating a flag.
     #
     # Note that event delivery is asynchronous, so the event may not actually be sent
     # until later; see {#flush}.
     #
-    # @param user [Hash] The user to register; this can have all the same user properties
-    #   described in {#variation}
+    # @param context [Hash, LDContext] a hash or object describing the context to register
     # @return [void]
     #
-    def identify(user)
-      if !user || user[:key].nil?
-        @config.logger.warn("Identify called with nil user or nil user key!")
+    def identify(context)
+      context = LaunchDarkly::Impl::Context.make_context(context)
+      unless context.valid?
+        @config.logger.warn("Identify called with invalid context: #{context.error}")
+        return
+      end
+
+      if context.key == ""
+        @config.logger.warn("Identify called with empty key")
         return
       end
-      sanitize_user(user)
-      @event_processor.add_event(@event_factory_default.new_identify_event(user))
+
+      @event_processor.record_identify_event(context)
     end
 
     #
-    # Tracks that a user performed an event. This method creates a "custom" analytics event
-    # containing the specified event name (key), user properties, and optional data.
+    # Tracks that a context performed an event. This method creates a "custom" analytics event
+    # containing the specified event name (key), context properties, and optional data.
     #
     # Note that event delivery is asynchronous, so the event may not actually be sent
     # until later; see {#flush}.
@@ -264,8 +242,7 @@ module LaunchDarkly
     # for the latest status.
     #
     # @param event_name [String] The name of the event
-    # @param user [Hash] The user to register; this can have all the same user properties
-    #   described in {#variation}
+    # @param context [Hash, LDContext] a hash or object describing the context to track
     # @param data [Hash] An optional hash containing any additional data associated with the event
     # @param metric_value [Number] A numeric value used by the LaunchDarkly experimentation
     #   feature in numeric custom metrics. Can be omitted if this event is used by only
@@ -273,52 +250,22 @@ module LaunchDarkly
     #   for Data Export.
     # @return [void]
     #
-    def track(event_name, user, data = nil, metric_value = nil)
-      if !user || user[:key].nil?
-        @config.logger.warn("Track called with nil user or nil user key!")
-        return
-      end
-      sanitize_user(user)
-      @event_processor.add_event(@event_factory_default.new_custom_event(event_name, user, data, metric_value))
-    end
-
-    #
-    # Associates a new and old user object for analytics purposes via an alias event.
-    #
-    # @param current_context [Hash] The current version of a user.
-    # @param previous_context [Hash] The previous version of a user.
-    # @return [void]
-    #
-    def alias(current_context, previous_context)
-      if !current_context || current_context[:key].nil? || !previous_context || previous_context[:key].nil?
-        @config.logger.warn("Alias called with nil user or nil user key!")
+    def track(event_name, context, data = nil, metric_value = nil)
+      context = LaunchDarkly::Impl::Context.make_context(context)
+      unless context.valid?
+        @config.logger.warn("Track called with invalid context: #{context.error}")
         return
       end
-      sanitize_user(current_context)
-      sanitize_user(previous_context)
-      @event_processor.add_event(@event_factory_default.new_alias_event(current_context, previous_context))
-    end
 
-    #
-    # Returns all feature flag values for the given user.
-    #
-    # @deprecated Please use {#all_flags_state} instead. Current versions of the
-    #   client-side SDK will not generate analytics events correctly if you pass the
-    #   result of `all_flags`.
-    #
-    # @param user [Hash] The end user requesting the feature flags
-    # @return [Hash] a hash of feature flag keys to values
-    #
-    def all_flags(user)
-      all_flags_state(user).values_map
+      @event_processor.record_custom_event(context, event_name, data, metric_value)
     end
 
     #
-    # Returns a {FeatureFlagsState} object that encapsulates the state of all feature flags for a given user,
+    # Returns a {FeatureFlagsState} object that encapsulates the state of all feature flags for a given context,
     # including the flag values and also metadata that can be used on the front end. This method does not
     # send analytics events back to LaunchDarkly.
     #
-    # @param user [Hash] The end user requesting the feature flags
+    # @param context [Hash, LDContext] a hash or object describing the context requesting the flags,
     # @param options [Hash] Optional parameters to control how the state is generated
     # @option options [Boolean] :client_side_only (false) True if only flags marked for use with the
     #   client-side SDK should be included in the state. By default, all flags are included.
@@ -330,11 +277,21 @@ module LaunchDarkly
     #   of the JSON data if you are passing the flag state to the front end.
     # @return [FeatureFlagsState] a {FeatureFlagsState} object which can be serialized to JSON
     #
-    def all_flags_state(user, options={})
+    def all_flags_state(context, options={})
       return FeatureFlagsState.new(false) if @config.offline?
 
-      unless user && !user[:key].nil?
-        @config.logger.error { "[LDClient] User and user key must be specified in all_flags_state" }
+      unless 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
+
+      context = Impl::Context::make_context(context)
+      unless context.valid?
+        @config.logger.error { "[LDClient] Context was invalid for all_flags_state (#{context.error})" }
         return FeatureFlagsState.new(false)
       end
 
@@ -354,14 +311,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, context).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 = 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 +343,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)
@@ -395,32 +372,34 @@ module LaunchDarkly
       end
     end
 
+    # @param context [Hash, LDContext]
     # @return [EvaluationDetail]
-    def evaluate_internal(key, user, default, event_factory)
+    def evaluate_internal(key, context, default, with_reasons)
       if @config.offline?
         return Evaluator.error_result(EvaluationReason::ERROR_CLIENT_NOT_READY, default)
       end
 
-      unless user
-        @config.logger.error { "[LDClient] Must specify user" }
+      if context.nil?
+        @config.logger.error { "[LDClient] Must specify context" }
         detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED, default)
         return detail
       end
 
-      if user[:key].nil?
-        @config.logger.warn { "[LDClient] Variation called with nil user key; returning default value" }
+      context = Impl::Context::make_context(context)
+      unless context.valid?
+        @config.logger.error { "[LDClient] Context was invalid for flag evaluation (#{context.error}); returning default value" }
         detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED, default)
         return detail
       end
 
-      if !initialized?
+      unless initialized?
         if @store.initialized?
           @config.logger.warn { "[LDClient] Client has not finished initializing; using last known values from feature store" }
         else
           @config.logger.error { "[LDClient] Client has not finished initializing; feature store unavailable, returning default value" }
           detail = Evaluator.error_result(EvaluationReason::ERROR_CLIENT_NOT_READY, default)
-          @event_processor.add_event(event_factory.new_unknown_flag_event(key, user, default, detail.reason))
-          return  detail
+          record_unknown_flag_eval(key, context, default, detail.reason, with_reasons)
+          return detail
         end
       end
 
@@ -429,35 +408,98 @@ module LaunchDarkly
       if feature.nil?
         @config.logger.info { "[LDClient] Unknown feature flag \"#{key}\". Returning default value" }
         detail = Evaluator.error_result(EvaluationReason::ERROR_FLAG_NOT_FOUND, default)
-        @event_processor.add_event(event_factory.new_unknown_flag_event(key, user, default, detail.reason))
+        record_unknown_flag_eval(key, context, default, detail.reason, with_reasons)
         return detail
       end
 
       begin
-        res = @evaluator.evaluate(feature, user, event_factory)
-        if !res.events.nil?
-          res.events.each do |event|
-            @event_processor.add_event(event)
+        res = @evaluator.evaluate(feature, context)
+        unless res.prereq_evals.nil?
+          res.prereq_evals.each do |prereq_eval|
+            record_prereq_flag_eval(prereq_eval.prereq_flag, prereq_eval.prereq_of_flag, context, prereq_eval.detail, with_reasons)
           end
         end
         detail = res.detail
         if detail.default_value?
           detail = EvaluationDetail.new(default, nil, detail.reason)
         end
-        @event_processor.add_event(event_factory.new_eval_event(feature, user, detail, default))
-        return detail
+        record_flag_eval(feature, context, detail, default, with_reasons)
+        detail
       rescue => exn
         Util.log_exception(@config.logger, "Error evaluating feature flag \"#{key}\"", exn)
         detail = Evaluator.error_result(EvaluationReason::ERROR_EXCEPTION, default)
-        @event_processor.add_event(event_factory.new_default_event(feature, user, default, detail.reason))
-        return detail
+        record_flag_eval_error(feature, context, default, detail.reason, with_reasons)
+        detail
       end
     end
 
-    def sanitize_user(user)
-      if user[:key]
-        user[:key] = user[:key].to_s
+    private def record_flag_eval(flag, context, detail, default, with_reasons)
+      add_experiment_data = experiment?(flag, detail.reason)
+      @event_processor.record_eval_event(
+        context,
+        flag[:key],
+        flag[:version],
+        detail.variation_index,
+        detail.value,
+        (add_experiment_data || with_reasons) ? detail.reason : nil,
+        default,
+        add_experiment_data || flag[:trackEvents] || false,
+        flag[:debugEventsUntilDate],
+        nil
+      )
+    end
+
+    private def record_prereq_flag_eval(prereq_flag, prereq_of_flag, context, detail, with_reasons)
+      add_experiment_data = experiment?(prereq_flag, detail.reason)
+      @event_processor.record_eval_event(
+        context,
+        prereq_flag[:key],
+        prereq_flag[:version],
+        detail.variation_index,
+        detail.value,
+        (add_experiment_data || with_reasons) ? detail.reason : nil,
+        nil,
+        add_experiment_data || prereq_flag[:trackEvents] || false,
+        prereq_flag[:debugEventsUntilDate],
+        prereq_of_flag[:key]
+      )
+    end
+
+    private def record_flag_eval_error(flag, context, default, reason, with_reasons)
+      @event_processor.record_eval_event(context, flag[:key], flag[:version], nil, default, with_reasons ? reason : nil, default,
+        flag[:trackEvents], flag[:debugEventsUntilDate], nil)
+    end
+
+    #
+    # @param flag_key [String]
+    # @param context [LaunchDarkly::LDContext]
+    # @param default [any]
+    # @param reason [LaunchDarkly::EvaluationReason]
+    # @param with_reasons [Boolean]
+    #
+    private def record_unknown_flag_eval(flag_key, context, default, reason, with_reasons)
+      @event_processor.record_eval_event(context, flag_key, nil, nil, default, with_reasons ? reason : nil, default,
+        false, nil, nil)
+    end
+
+    private def experiment?(flag, reason)
+      return false unless reason
+
+      if reason.in_experiment
+        return true
+      end
+
+      case reason[:kind]
+      when 'RULE_MATCH'
+        index = reason[:ruleIndex]
+        unless index.nil?
+          rules = flag[:rules] || []
+          return index >= 0 && index < rules.length && rules[index][:trackEvents]
+        end
+      when 'FALLTHROUGH'
+        return !!flag[:trackEventsFallthrough]
       end
+      false
     end
   end
 

data/lib/ldclient-rb/memoized_value.rb

@@ -14,7 +14,7 @@ module LaunchDarkly
 
     def get
       @mutex.synchronize do
-        if !@inited
+        unless @inited
           @value = @generator.call
           @inited = true
         end

data/lib/ldclient-rb/non_blocking_thread_pool.rb

@@ -17,7 +17,7 @@ module LaunchDarkly
     # Attempts to submit a job, but only if a worker is available. Unlike the regular post method,
     # this returns a value: true if the job was submitted, false if all workers are busy.
     def post
-      if !@semaphore.try_acquire(1)
+      unless @semaphore.try_acquire(1)
         return
       end
       @pool.post do

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}" }
+        unless 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