launchdarkly-server-sdk 6.3.0 → 8.0.0

data/lib/ldclient-rb/ldclient.rb

@@ -1,10 +1,15 @@
 require "ldclient-rb/impl/big_segments"
+require "ldclient-rb/impl/broadcaster"
+require "ldclient-rb/impl/data_source"
+require "ldclient-rb/impl/data_store"
 require "ldclient-rb/impl/diagnostic_events"
 require "ldclient-rb/impl/evaluator"
-require "ldclient-rb/impl/event_factory"
+require "ldclient-rb/impl/flag_tracker"
 require "ldclient-rb/impl/store_client_wrapper"
+require "ldclient-rb/impl/migrations/tracker"
 require "concurrent/atomics"
 require "digest/sha1"
+require "forwardable"
 require "logger"
 require "benchmark"
 require "json"
@@ -17,6 +22,10 @@ module LaunchDarkly
   #
   class LDClient
     include Impl
+    extend Forwardable
+
+    def_delegators :@config, :logger
+
     #
     # Creates a new client instance that connects to LaunchDarkly. A custom
     # configuration parameter can also supplied to specify advanced options,
@@ -46,26 +55,30 @@ module LaunchDarkly
 
       @sdk_key = sdk_key
 
-      @event_factory_default = EventFactory.new(false)
-      @event_factory_with_reasons = EventFactory.new(true)
+      @shared_executor = Concurrent::SingleThreadExecutor.new
+
+      data_store_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, config.logger)
+      store_sink = LaunchDarkly::Impl::DataStore::UpdateSink.new(data_store_broadcaster)
 
       # 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
       # the wrapped store.
-      @store = Impl::FeatureStoreClientWrapper.new(config.feature_store)
+      @store = Impl::FeatureStoreClientWrapper.new(config.feature_store, store_sink, config.logger)
       updated_config = config.clone
       updated_config.instance_variable_set(:@feature_store, @store)
       @config = updated_config
 
+      @data_store_status_provider = LaunchDarkly::Impl::DataStore::StatusProvider.new(@store, store_sink)
+
       @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) }
-      get_big_segments_membership = lambda { |key| @big_segment_store_manager.get_user_membership(key) }
+      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))
       else
@@ -83,6 +96,16 @@ module LaunchDarkly
         return  # requestor and update processor are not used in this mode
       end
 
+      flag_tracker_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, @config.logger)
+      @flag_tracker = LaunchDarkly::Impl::FlagTracker.new(flag_tracker_broadcaster, lambda { |key, context| variation(key, context, nil) })
+
+      data_source_broadcaster = LaunchDarkly::Impl::Broadcaster.new(@shared_executor, @config.logger)
+
+      # Make the update sink available on the config so that our data source factory can access the sink with a shared executor.
+      @config.data_source_update_sink = LaunchDarkly::Impl::DataSource::UpdateSink.new(@store, data_source_broadcaster, flag_tracker_broadcaster)
+
+      @data_source_status_provider = LaunchDarkly::Impl::DataSource::StatusProvider.new(data_source_broadcaster, @config.data_source_update_sink)
+
       data_source_or_factory = @config.data_source || self.method(:create_default_data_source)
       if data_source_or_factory.respond_to? :call
         # Currently, data source factories take two parameters unless they need to be aware of diagnostic_accumulator, in
@@ -124,26 +147,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
 
     #
@@ -169,44 +186,23 @@ 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 error
     #
-    def variation(key, user, default)
-      evaluate_internal(key, user, default, @event_factory_default).value
+    def variation(key, context, default)
+      detail, _, _, = variation_with_flag(key, context, default)
+      detail.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
@@ -222,43 +218,84 @@ 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)
+      detail, _, _ = evaluate_internal(key, context, default, true)
+      detail
     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.
+    # This method returns the migration stage of the migration feature flag for the given evaluation context.
+    #
+    # This method returns the default stage if there is an error or the flag does not exist. If the default stage is not
+    # a valid stage, then a default stage of 'off' will be used instead.
     #
-    # Calling {#variation} or {#variation_detail} also sends the user information to
+    # @param key [String]
+    # @param context [LDContext]
+    # @param default_stage [Symbol]
+    #
+    # @return [Array<Symbol, Interfaces::Migrations::OpTracker>]
+    #
+    def migration_variation(key, context, default_stage)
+      unless Migrations::VALID_STAGES.include? default_stage
+        @config.logger.error { "[LDClient] default_stage #{default_stage} is not a valid stage; continuing with 'off' as default" }
+        default_stage = Migrations::STAGE_OFF
+      end
+
+      context = Impl::Context::make_context(context)
+      detail, flag, _ = variation_with_flag(key, context, default_stage.to_s)
+
+      stage = detail.value
+      stage = stage.to_sym if stage.respond_to? :to_sym
+
+      if Migrations::VALID_STAGES.include?(stage)
+        tracker = Impl::Migrations::OpTracker.new(@config.logger, key, flag, context, detail, default_stage)
+        return stage, tracker
+      end
+
+      detail = LaunchDarkly::Impl::Evaluator.error_result(LaunchDarkly::EvaluationReason::ERROR_WRONG_TYPE, default_stage.to_s)
+      tracker = Impl::Migrations::OpTracker.new(@config.logger, key, flag, context, detail, default_stage)
+
+      [default_stage, tracker]
+    end
+
+    #
+    # 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 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
-      sanitize_user(user)
-      @event_processor.add_event(@event_factory_default.new_identify_event(user))
+
+      if context.key == ""
+        @config.logger.warn("Identify called with empty key")
+        return
+      end
+
+      @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}.
@@ -269,8 +306,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
@@ -278,52 +314,48 @@ 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!")
+    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(user)
-      @event_processor.add_event(@event_factory_default.new_custom_event(event_name, user, data, metric_value))
+
+      @event_processor.record_custom_event(context, event_name, data, metric_value)
     end
 
     #
-    # Associates a new and old user object for analytics purposes via an alias event.
+    # Tracks the results of a migrations operation. This event includes measurements which can be used to enhance the
+    # observability of a migration within the LaunchDarkly UI.
     #
-    # @param current_context [Hash] The current version of a user.
-    # @param previous_context [Hash] The previous version of a user.
-    # @return [void]
+    # This event should be generated through {Interfaces::Migrations::OpTracker}. If you are using the
+    # {Interfaces::Migrations::Migrator} to handle migrations, this event will be created and emitted
+    # automatically.
+    #
+    # @param tracker [LaunchDarkly::Interfaces::Migrations::OpTracker]
     #
-    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_migration_op(tracker)
+      unless tracker.is_a? LaunchDarkly::Interfaces::Migrations::OpTracker
+        @config.logger.error { "invalid op tracker received in track_migration_op" }
         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 = tracker.build
+      if event.is_a? String
+        @config.logger.error { "[LDClient] Error occurred generating migration op event; #{event}" }
+        return
+      end
+
+
+      @event_processor.record_migration_op_event(event)
     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.
@@ -335,11 +367,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
 
@@ -359,14 +401,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
@@ -382,16 +435,53 @@ module LaunchDarkly
       @event_processor.stop
       @big_segment_store_manager.stop
       @store.stop
+      @shared_executor.shutdown
     end
 
     #
     # Returns an interface for tracking the status of a Big Segment store.
     #
-    # The {BigSegmentStoreStatusProvider} has methods for checking whether the Big Segment store
+    # The {Interfaces::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
 
+    #
+    # Returns an interface for tracking the status of a persistent data store.
+    #
+    # The {LaunchDarkly::Interfaces::DataStore::StatusProvider} has methods for
+    # checking whether the data store is (as far as the SDK knows) currently
+    # operational, tracking changes in this status, and getting cache
+    # statistics. These are only relevant for a persistent data store; if you
+    # are using an in-memory data store, then this method will return a stub
+    # object that provides no information.
+    #
+    # @return [LaunchDarkly::Interfaces::DataStore::StatusProvider]
+    #
+    attr_reader :data_store_status_provider
+
+    #
+    # Returns an interface for tracking the status of the data source.
+    #
+    # The data source is the mechanism that the SDK uses to get feature flag
+    # configurations, such as a streaming connection (the default) or poll
+    # requests. The {LaunchDarkly::Interfaces::DataSource::StatusProvider} has
+    # methods for checking whether the data source is (as far as the SDK knows)
+    # currently operational and tracking changes in this status.
+    #
+    # @return [LaunchDarkly::Interfaces::DataSource::StatusProvider]
+    #
+    attr_reader :data_source_status_provider
+
+    #
+    # Returns an interface for tracking changes in feature flag configurations.
+    #
+    # The {LaunchDarkly::Interfaces::FlagTracker} contains methods for
+    # requesting notifications about feature flag changes using an event
+    # listener model.
+    #
+    attr_reader :flag_tracker
+
     private
 
     def create_default_data_source(sdk_key, config, diagnostic_accumulator)
@@ -409,69 +499,159 @@ module LaunchDarkly
       end
     end
 
-    # @return [EvaluationDetail]
-    def evaluate_internal(key, user, default, event_factory)
+    #
+    # @param key [String]
+    # @param context [Hash, LDContext]
+    # @param default [Object]
+    #
+    # @return [Array<EvaluationDetail, [LaunchDarkly::Impl::Model::FeatureFlag, nil], [String, nil]>]
+    #
+    def variation_with_flag(key, context, default)
+      evaluate_internal(key, context, default, false)
+    end
+
+    #
+    # @param key [String]
+    # @param context [Hash, LDContext]
+    # @param default [Object]
+    # @param with_reasons [Boolean]
+    #
+    # @return [Array<EvaluationDetail, [LaunchDarkly::Impl::Model::FeatureFlag, nil], [String, nil]>]
+    #
+    def evaluate_internal(key, context, default, with_reasons)
       if @config.offline?
-        return Evaluator.error_result(EvaluationReason::ERROR_CLIENT_NOT_READY, default)
+        return Evaluator.error_result(EvaluationReason::ERROR_CLIENT_NOT_READY, default), nil, nil
       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
+        return detail, nil, "no context provided"
       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 evaluation of flag '#{key}' (#{context.error}); returning default value" }
         detail = Evaluator.error_result(EvaluationReason::ERROR_USER_NOT_SPECIFIED, default)
-        return detail
+        return detail, nil, context.error
       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, nil, "client not initialized"
         end
       end
 
-      feature = @store.get(FEATURES, key)
+      begin
+        feature = @store.get(FEATURES, key)
+      rescue
+        # Ignored
+      end
 
       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))
-        return detail
+        record_unknown_flag_eval(key, context, default, detail.reason, with_reasons)
+        return detail, nil, "feature flag not found"
       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, feature, nil]
       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, feature, exn.to_s]
       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,
+        flag[:samplingRatio],
+        !!flag[:excludeFromSummaries]
+      )
+    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],
+        prereq_flag[:samplingRatio],
+        !!prereq_flag[:excludeFromSummaries]
+      )
+    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, flag[:samplingRatio], !!flag[:excludeFromSummaries])
+    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, 1, false)
+    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