prepare 5.3.0 release

lib/ldclient-rb/flags_state.rb

@@ -15,13 +15,21 @@ def initialize(valid)
     end
 
     # Used internally to build the state map.
-    def add_flag(flag, value, variation, reason = nil)
+    def add_flag(flag, value, variation, reason = nil, details_only_if_tracked = false)
       key = flag[:key]
       @flag_values[key] = value
-      meta = { version: flag[:version], trackEvents: flag[:trackEvents] }
+      meta = {}
+      with_details = !details_only_if_tracked || flag[:trackEvents]
+      if !with_details && flag[:debugEventsUntilDate]
+        with_details = flag[:debugEventsUntilDate] > (Time.now.to_f * 1000).to_i
+      end
+      if with_details
+        meta[:version] = flag[:version]
+        meta[:reason] = reason if !reason.nil?
+      end
       meta[:variation] = variation if !variation.nil?
+      meta[:trackEvents] = true if flag[:trackEvents]
       meta[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
-      meta[:reason] = reason if !reason.nil?
       @flag_metadata[key] = meta
     end
 

lib/ldclient-rb/ldclient.rb

@@ -212,6 +212,10 @@ def all_flags(user)
     #   client-side SDK should be included in the state. By default, all flags are included.
     # @option options [Boolean] :with_reasons (false) True if evaluation reasons should be included
     #   in the state (see `variation_detail`). By default, they are not included.
+    # @option options [Boolean] :details_only_for_tracked_flags (false) True if any flag metadata that is
+    # normally only used for event generation - such as flag versions and evaluation reasons - should be
+    # omitted for any flag that does not have event tracking or debugging turned on. This reduces the size
+    # 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={})
@@ -234,16 +238,18 @@ def all_flags_state(user, options={})
       state = FeatureFlagsState.new(true)
       client_only = options[:client_side_only] || false
       with_reasons = options[:with_reasons] || false
+      details_only_if_tracked = options[:details_only_for_tracked_flags] || false
       features.each do |k, f|
         if client_only && !f[:clientSide]
           next
         end
         begin
           result = evaluate(f, user, @store, @config.logger)
-          state.add_flag(f, result.detail.value, result.detail.variation_index, with_reasons ? result.detail.reason : nil)
+          state.add_flag(f, result.detail.value, result.detail.variation_index, with_reasons ? result.detail.reason : nil,
+            details_only_if_tracked)
         rescue => exn
           Util.log_exception(@config.logger, "Error evaluating flag \"#{k}\" in all_flags_state", exn)
-          state.add_flag(f, nil, nil, with_reasons ? { kind: 'ERROR', errorKind: 'EXCEPTION' } : nil)
+          state.add_flag(f, nil, nil, with_reasons ? { kind: 'ERROR', errorKind: 'EXCEPTION' } : nil, details_only_if_tracked)
         end
       end
 

spec/flags_state_spec.rb

@@ -42,8 +42,7 @@
       '$flagsState' => {
         'key1' => {
           :variation => 0,
-          :version => 100,
-          :trackEvents => false
+          :version => 100
         },
         'key2' => {
           :variation => 1,

spec/ldclient_spec.rb

@@ -233,8 +233,7 @@ def event_processor
         '$flagsState' => {
           'key1' => {
             :variation => 0,
-            :version => 100,
-            :trackEvents => false
+            :version => 100
           },
           'key2' => {
             :variation => 1,
@@ -263,6 +262,44 @@ def event_processor
       expect(values).to eq({ 'client-side-1' => 'value1', 'client-side-2' => 'value2' })
     end
 
+    it "can omit details for untracked flags" do
+      future_time = (Time.now.to_f * 1000).to_i + 100000
+      flag1 = { key: "key1", version: 100, offVariation: 0, variations: [ 'value1' ], trackEvents: false }
+      flag2 = { key: "key2", version: 200, offVariation: 1, variations: [ 'x', 'value2' ], trackEvents: true }
+      flag3 = { key: "key3", version: 300, offVariation: 1, variations: [ 'x', 'value3' ], debugEventsUntilDate: future_time }
+
+      config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2, 'key3' => flag3 } })
+
+      state = client.all_flags_state({ key: 'userkey' }, { details_only_for_tracked_flags: true })
+      expect(state.valid?).to be true
+
+      values = state.values_map
+      expect(values).to eq({ 'key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3' })
+
+      result = state.as_json
+      expect(result).to eq({
+        'key1' => 'value1',
+        'key2' => 'value2',
+        'key3' => 'value3',
+        '$flagsState' => {
+          'key1' => {
+            :variation => 0
+          },
+          'key2' => {
+            :variation => 1,
+            :version => 200,
+            :trackEvents => true
+          },
+          'key3' => {
+            :variation => 1,
+            :version => 300,
+            :debugEventsUntilDate => future_time
+          }
+        },
+        '$valid' => true
+      })
+    end
+
     it "returns empty state for nil user" do
       config.feature_store.init({ LaunchDarkly::FEATURES => { 'key1' => flag1, 'key2' => flag2 } })