prepare 5.6.0 release (#142)

Author: LaunchDarklyCI

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    launchdarkly-server-sdk (5.5.7)
+    launchdarkly-server-sdk (5.5.12)
       concurrent-ruby (~> 1.0)
       json (>= 1.8, < 3)
       ld-eventsource (= 1.0.1)
@@ -35,7 +35,6 @@ GEM
     ffi (1.9.25)
     ffi (1.9.25-java)
     hitimes (1.3.1)
-    hitimes (1.3.1-java)
     http_tools (0.4.5)
     jmespath (1.4.0)
     json (1.8.6)

lib/ldclient-rb/evaluation.rb

@@ -199,24 +199,24 @@ def error_result(errorKind, value = nil)
 
     # Evaluates a feature flag and returns an EvalResult. The result.value will be nil if the flag returns
     # the default value. Error conditions produce a result with an error reason, not an exception.
-    def evaluate(flag, user, store, logger)
+    def evaluate(flag, user, store, logger, event_factory)
       if user.nil? || user[:key].nil?
         return EvalResult.new(error_result('USER_NOT_SPECIFIED'), [])
       end
 
       sanitized_user = Util.stringify_attrs(user, USER_ATTRS_TO_STRINGIFY_FOR_EVALUATION)
 
       events = []
-      detail = eval_internal(flag, sanitized_user, store, events, logger)
+      detail = eval_internal(flag, sanitized_user, store, events, logger, event_factory)
       return EvalResult.new(detail, events)
     end
 
-    def eval_internal(flag, user, store, events, logger)
+    def eval_internal(flag, user, store, events, logger, event_factory)
       if !flag[:on]
         return get_off_value(flag, { kind: 'OFF' }, logger)
       end
 
-      prereq_failure_reason = check_prerequisites(flag, user, store, events, logger)
+      prereq_failure_reason = check_prerequisites(flag, user, store, events, logger, event_factory)
       if !prereq_failure_reason.nil?
         return get_off_value(flag, prereq_failure_reason, logger)
       end
@@ -249,7 +249,7 @@ def eval_internal(flag, user, store, events, logger)
       return EvaluationDetail.new(nil, nil, { kind: 'FALLTHROUGH' })
     end
 
-    def check_prerequisites(flag, user, store, events, logger)
+    def check_prerequisites(flag, user, store, events, logger, event_factory)
       (flag[:prerequisites] || []).each do |prerequisite|
         prereq_ok = true
         prereq_key = prerequisite[:key]
@@ -260,23 +260,13 @@ def check_prerequisites(flag, user, store, events, logger)
           prereq_ok = false
         else
           begin
-            prereq_res = eval_internal(prereq_flag, user, store, events, logger)
+            prereq_res = eval_internal(prereq_flag, user, store, events, logger, event_factory)
             # Note that if the prerequisite flag is off, we don't consider it a match no matter what its
             # off variation was. But we still need to evaluate it in order to generate an event.
             if !prereq_flag[:on] || prereq_res.variation_index != prerequisite[:variation]
               prereq_ok = false
             end
-            event = {
-              kind: "feature",
-              key: prereq_key,
-              user: user,
-              variation: prereq_res.variation_index,
-              value: prereq_res.value,
-              version: prereq_flag[:version],
-              prereqOf: flag[:key],
-              trackEvents: prereq_flag[:trackEvents],
-              debugEventsUntilDate: prereq_flag[:debugEventsUntilDate]
-            }
+            event = event_factory.new_eval_event(prereq_flag, user, prereq_res, nil, flag)
             events.push(event)
           rescue => exn
             Util.log_exception(logger, "Error evaluating prerequisite flag \"#{prereq_key}\" for flag \"#{flag[:key]}\"", exn)

lib/ldclient-rb/events.rb

@@ -456,6 +456,7 @@ def make_output_event(event)
         else
           out[:userKey] = event[:user].nil? ? nil : event[:user][:key]
         end
+        out[:metricValue] = event[:metricValue] if event.has_key?(:metricValue)
         out
       when "index"
         {

lib/ldclient-rb/impl/event_factory.rb

@@ -0,0 +1,98 @@
+
+module LaunchDarkly
+  module Impl
+    # Event constructors are centralized here to avoid mistakes and repetitive logic.
+    # The LDClient owns two instances of EventFactory: one that always embeds evaluation reasons
+    # in the events (for when variation_detail is called) and one that doesn't.
+    #
+    # Note that these methods do not set the "creationDate" property, because in the Ruby client,
+    # that is done by EventProcessor.add_event().
+    class EventFactory
+      def initialize(with_reasons)
+        @with_reasons = with_reasons
+      end
+
+      def new_eval_event(flag, user, detail, default_value, prereq_of_flag = nil)
+        add_experiment_data = is_experiment(flag, detail.reason)
+        e = {
+          kind: 'feature',
+          key: flag[:key],
+          user: user,
+          variation: detail.variation_index,
+          value: detail.value,
+          default: default_value,
+          version: flag[:version]
+        }
+        # the following properties are handled separately so we don't waste bandwidth on unused keys
+        e[:trackEvents] = true if add_experiment_data || flag[:trackEvents]
+        e[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
+        e[:prereqOf] = prereq_of_flag[:key] if !prereq_of_flag.nil?
+        e[:reason] = detail.reason if add_experiment_data || @with_reasons
+        e
+      end
+
+      def new_default_event(flag, user, default_value, reason)
+        e = {
+          kind: 'feature',
+          key: flag[:key],
+          user: user,
+          value: default_value,
+          default: default_value,
+          version: flag[:version]
+        }
+        e[:trackEvents] = true if flag[:trackEvents]
+        e[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
+        e[:reason] = reason if @with_reasons
+        e
+      end
+
+      def new_unknown_flag_event(key, user, default_value, reason)
+        e = {
+          kind: 'feature',
+          key: key,
+          user: user,
+          value: default_value,
+          default: default_value
+        }
+        e[:reason] = reason if @with_reasons
+        e
+      end
+
+      def new_identify_event(user)
+        {
+          kind: 'identify',
+          key: user[:key],
+          user: user
+        }
+      end
+
+      def new_custom_event(event_name, user, data, metric_value)
+        e = {
+          kind: 'custom',
+          key: event_name,
+          user: user
+        }
+        e[:data] = data if !data.nil?
+        e[:metricValue] = metric_value if !metric_value.nil?
+        e
+      end
+
+      private
+
+      def is_experiment(flag, reason)
+        return false if !reason
+        case reason[:kind]
+        when 'RULE_MATCH'
+          index = reason[:ruleIndex]
+          if !index.nil?
+            rules = flag[:rules] || []
+            return index >= 0 && index < rules.length && rules[index][:trackEvents]
+          end
+        when 'FALLTHROUGH'
+          return !!flag[:trackEventsFallthrough]
+        end
+        false
+      end
+    end
+  end
+end

lib/ldclient-rb/ldclient.rb

@@ -1,3 +1,4 @@
+require "ldclient-rb/impl/event_factory"
 require "ldclient-rb/impl/store_client_wrapper"
 require "concurrent/atomics"
 require "digest/sha1"
@@ -13,6 +14,7 @@ module LaunchDarkly
   #
   class LDClient
     include Evaluation
+    include Impl
     #
     # Creates a new client instance that connects to LaunchDarkly. A custom
     # configuration parameter can also supplied to specify advanced options,
@@ -32,6 +34,9 @@ class LDClient
     def initialize(sdk_key, config = Config.default, wait_for_sec = 5)
       @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
@@ -165,7 +170,7 @@ def initialized?
     # @return the variation to show the user, or the default value if there's an an error
     #
     def variation(key, user, default)
-      evaluate_internal(key, user, default, false).value
+      evaluate_internal(key, user, default, @event_factory_default).value
     end
 
     #
@@ -192,7 +197,7 @@ def variation(key, user, default)
     # @return [EvaluationDetail] an object describing the result
     #
     def variation_detail(key, user, default)
-      evaluate_internal(key, user, default, true)
+      evaluate_internal(key, user, default, @event_factory_with_reasons)
     end
 
     #
@@ -215,7 +220,8 @@ def identify(user)
         @config.logger.warn("Identify called with nil user or nil user key!")
         return
       end
-      @event_processor.add_event(kind: "identify", key: user[:key], user: user)
+      sanitize_user(user)
+      @event_processor.add_event(@event_factory_default.new_identify_event(user))
     end
 
     #
@@ -225,18 +231,28 @@ def identify(user)
     # Note that event delivery is asynchronous, so the event may not actually be sent
     # until later; see {#flush}.
     #
+    # As of this version’s release date, the LaunchDarkly service does not support the `metricValue`
+    # parameter. As a result, specifying `metricValue` will not yet produce any different behavior
+    # from omitting it. Refer to the [SDK reference guide](https://docs.launchdarkly.com/docs/ruby-sdk-reference#section-track)
+    # 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 data [Hash] A hash containing any additional data associated with the event
+    # @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
+    #   non-numeric metrics. This field will also be returned as part of the custom event
+    #   for Data Export.
     # @return [void]
     #
-    def track(event_name, user, data)
+    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
-      @event_processor.add_event(kind: "custom", key: event_name, user: user, data: data)
+      sanitize_user(user)
+      @event_processor.add_event(@event_factory_default.new_custom_event(event_name, user, data, metric_value))
     end
 
     #
@@ -294,7 +310,7 @@ def all_flags_state(user, options={})
           next
         end
         begin
-          result = evaluate(f, user, @store, @config.logger)
+          result = evaluate(f, user, @store, @config.logger, @event_factory_default)
           state.add_flag(f, result.detail.value, result.detail.variation_index, with_reasons ? result.detail.reason : nil,
             details_only_if_tracked)
         rescue => exn
@@ -334,7 +350,7 @@ def create_default_data_source(sdk_key, config)
     end
 
     # @return [EvaluationDetail]
-    def evaluate_internal(key, user, default, include_reasons_in_events)
+    def evaluate_internal(key, user, default, event_factory)
       if @config.offline?
         return error_result('CLIENT_NOT_READY', default)
       end
@@ -344,8 +360,9 @@ def evaluate_internal(key, user, default, include_reasons_in_events)
           @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" }
-          @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user)
-          return error_result('CLIENT_NOT_READY', default)
+          detail = error_result('CLIENT_NOT_READY', default)
+          @event_processor.add_event(event_factory.new_unknown_flag_event(key, user, default, detail.reason))
+          return  detail
         end
       end
 
@@ -354,20 +371,19 @@ def evaluate_internal(key, user, default, include_reasons_in_events)
       if feature.nil?
         @config.logger.info { "[LDClient] Unknown feature flag \"#{key}\". Returning default value" }
         detail = error_result('FLAG_NOT_FOUND', default)
-        @event_processor.add_event(kind: "feature", key: key, value: default, default: default, user: user,
-          reason: include_reasons_in_events ? detail.reason : nil)
+        @event_processor.add_event(event_factory.new_unknown_flag_event(key, user, default, detail.reason))
         return detail
       end
 
       unless user
         @config.logger.error { "[LDClient] Must specify user" }
         detail = error_result('USER_NOT_SPECIFIED', default)
-        @event_processor.add_event(make_feature_event(feature, nil, detail, default, include_reasons_in_events))
+        @event_processor.add_event(event_factory.new_default_event(feature, user, default, detail.reason))
         return detail
       end
 
       begin
-        res = evaluate(feature, user, @store, @config.logger)  # note, evaluate will do its own sanitization
+        res = evaluate(feature, user, @store, @config.logger, event_factory)
         if !res.events.nil?
           res.events.each do |event|
             @event_processor.add_event(event)
@@ -377,29 +393,20 @@ def evaluate_internal(key, user, default, include_reasons_in_events)
         if detail.default_value?
           detail = EvaluationDetail.new(default, nil, detail.reason)
         end
-        @event_processor.add_event(make_feature_event(feature, user, detail, default, include_reasons_in_events))
+        @event_processor.add_event(event_factory.new_eval_event(feature, user, detail, default))
         return detail
       rescue => exn
         Util.log_exception(@config.logger, "Error evaluating feature flag \"#{key}\"", exn)
         detail = error_result('EXCEPTION', default)
-        @event_processor.add_event(make_feature_event(feature, user, detail, default, include_reasons_in_events))
+        @event_processor.add_event(event_factory.new_default_event(feature, user, default, detail.reason))
         return detail
       end
     end
 
-    def make_feature_event(flag, user, detail, default, with_reasons)
-      {
-        kind: "feature",
-        key: flag[:key],
-        user: user,
-        variation: detail.variation_index,
-        value: detail.value,
-        default: default,
-        version: flag[:version],
-        trackEvents: flag[:trackEvents],
-        debugEventsUntilDate: flag[:debugEventsUntilDate],
-        reason: with_reasons ? detail.reason : nil
-      }
+    def sanitize_user(user)
+      if user[:key]
+        user[:key] = user[:key].to_s
+      end
     end
   end