updated client and factory classes

lib/splitclient-rb/clients/split_client.rb

@@ -332,14 +332,14 @@ def treatment(key, feature_flag_name, attributes = {}, split_data = nil, store_i
       end
 
       feature_flag = @splits_repository.get_split(feature_flag_name)
-      treatments, impressions = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple)
+      treatments, impressions_decorator = evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple)
 
-      @impressions_manager.track(impressions) unless impressions.nil?
+      @impressions_manager.track(impressions_decorator) unless impressions_decorator.nil?
       treatments
     end
 
     def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_key, attributes, calling_method, multiple = false)
-      impressions = []
+      impressions_decorator = []
       begin
         start = Time.now
         if feature_flag.nil? && ready?
@@ -358,20 +358,20 @@ def evaluate_treatment(feature_flag, feature_flag_name, bucketing_key, matching_
         end
 
         record_latency(calling_method, start)
-        impression = @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, treatment_data, { attributes: attributes, time: nil })
-        impressions << impression unless impression.nil?
+        impression_decorator = { impression: @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, treatment_data, feature_flag[:impressionsDisabled], { attributes: attributes, time: nil }), disabled: feature_flag[:impressionsDisabled] }
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
       rescue StandardError => e
         @config.log_found_exception(__method__.to_s, e)
 
         record_exception(calling_method)
 
-        impression = @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, control_treatment, { attributes: attributes, time: nil })
-        impressions << impression unless impression.nil?
+        impression_decorator = { impression: @impressions_manager.build_impression(matching_key, bucketing_key, feature_flag_name, control_treatment, { attributes: attributes, time: nil }), disabled: false }
+        impressions_decorator << impression_decorator unless impression_decorator.nil?
 
-        return parsed_treatment(control_treatment.merge({ label: Engine::Models::Label::EXCEPTION }), multiple), impressions
+        return parsed_treatment(control_treatment.merge({ label: Engine::Models::Label::EXCEPTION }), multiple), impressions_decorator
       end
 
-      return parsed_treatment(treatment_data, multiple), impressions
+      return parsed_treatment(treatment_data, multiple), impressions_decorator
     end
 
     def control_treatment

lib/splitclient-rb/split_factory.rb

@@ -230,33 +230,22 @@ def build_telemetry_synchronizer(flag_sets, flag_sets_invalid)
     end
 
     def build_unique_keys_tracker
-      if @config.impressions_mode != :none
-        @unique_keys_tracker = Engine::Impressions::NoopUniqueKeysTracker.new
-        return
-      end
-
       bf = Cache::Filter::BloomFilter.new(30_000_000)
       filter_adapter = Cache::Filter::FilterAdapter.new(@config, bf)
       cache = Concurrent::Hash.new
       @unique_keys_tracker = Engine::Impressions::UniqueKeysTracker.new(@config, filter_adapter, @impressions_sender_adapter, cache)
     end
 
     def build_impressions_observer
-      if (@config.cache_adapter == :redis && @config.impressions_mode != :optimized) ||
-         (@config.cache_adapter == :memory && @config.impressions_mode == :none)
+      if (@config.cache_adapter == :redis && @config.impressions_mode != :optimized)
         @impression_observer = Observers::NoopImpressionObserver.new
       else
         @impression_observer = Observers::ImpressionObserver.new
       end
     end
 
     def build_impression_counter
-      case @config.impressions_mode
-      when :debug
-        @impression_counter = Engine::Common::NoopImpressionCounter.new
-      else
-        @impression_counter = Engine::Common::ImpressionCounter.new
-      end
+      @impression_counter = Engine::Common::ImpressionCounter.new
     end
 
     def build_impressions_sender_adapter

spec/splitclient/split_client_spec.rb

@@ -92,6 +92,127 @@
   end
 end
 
+context 'impressions toggle' do
+  it 'optimized mode' do
+    config = SplitIoClient::SplitConfig.new(cache_adapter: :memory, impressions_mode: :optimized)
+    segments_repository = SplitIoClient::Cache::Repositories::SegmentsRepository.new(config)
+    flag_sets_repository = SplitIoClient::Cache::Repositories::MemoryFlagSetsRepository.new([])
+    flag_set_filter = SplitIoClient::Cache::Filter::FlagSetsFilter.new([])
+    splits_repository = SplitIoClient::Cache::Repositories::SplitsRepository.new(config, flag_sets_repository, flag_set_filter)
+    impressions_repository = SplitIoClient::Cache::Repositories::ImpressionsRepository.new(config)
+    runtime_producer = SplitIoClient::Telemetry::RuntimeProducer.new(config)
+    events_repository = SplitIoClient::Cache::Repositories::EventsRepository.new(config, 'sdk_key', runtime_producer)
+    impressions_counter = SplitIoClient::Engine::Common::ImpressionCounter.new
+    filter_adapter = SplitIoClient::Cache::Filter::FilterAdapter.new(config, SplitIoClient::Cache::Filter::BloomFilter.new(1_000))
+    unique_keys_tracker = SplitIoClient::Engine::Impressions::UniqueKeysTracker.new(config, filter_adapter, nil,  Concurrent::Hash.new)
+    impression_manager = SplitIoClient::Engine::Common::ImpressionManager.new(config, impressions_repository, impressions_counter, runtime_producer, SplitIoClient::Observers::ImpressionObserver.new, unique_keys_tracker)
+    evaluation_producer = SplitIoClient::Telemetry::EvaluationProducer.new(config)
+    evaluator = SplitIoClient::Engine::Parser::Evaluator.new(segments_repository, splits_repository, config)
+    split_client = SplitIoClient::SplitClient.new('sdk_key', {:splits => splits_repository, :segments => segments_repository, :impressions => impressions_repository, :events => events_repository}, nil, config, impression_manager, evaluation_producer, evaluator, SplitIoClient::Validators.new(config))
+
+    splits = File.read(File.join(SplitIoClient.root, 'spec/test_data/splits/imp-toggle.json'))
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][0]], [], -1)
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][1]], [], -1)
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][2]], [], -1)
+
+    expect(split_client.get_treatment('key1', 'with_track_disabled')).to eq('off')
+    expect(split_client.get_treatment('key2', 'with_track_enabled')).to eq('off')
+    expect(split_client.get_treatment('key3', 'without_track')).to eq('off')
+
+    imps = impressions_repository.batch
+    expect(imps.length()).to eq(2)
+    expect(imps[0][:i][:f]).to eq('with_track_enabled')
+    expect(imps[1][:i][:f]).to eq('without_track')
+
+    unique_keys = unique_keys_tracker.instance_variable_get(:@cache)
+    expect(unique_keys.key?('with_track_disabled')).to eq(true)
+    expect(unique_keys.length).to eq(1)
+    imp_count = impressions_counter.pop_all
+    expect(imp_count.keys()[0].include? ('with_track_disabled')).to eq(true)
+    expect(imp_count.length).to eq(1)
+  end
+
+  it 'debug mode' do
+    config = SplitIoClient::SplitConfig.new(cache_adapter: :memory, impressions_mode: :debug)
+    segments_repository = SplitIoClient::Cache::Repositories::SegmentsRepository.new(config)
+    flag_sets_repository = SplitIoClient::Cache::Repositories::MemoryFlagSetsRepository.new([])
+    flag_set_filter = SplitIoClient::Cache::Filter::FlagSetsFilter.new([])
+    splits_repository = SplitIoClient::Cache::Repositories::SplitsRepository.new(config, flag_sets_repository, flag_set_filter)
+    impressions_repository = SplitIoClient::Cache::Repositories::ImpressionsRepository.new(config)
+    runtime_producer = SplitIoClient::Telemetry::RuntimeProducer.new(config)
+    events_repository = SplitIoClient::Cache::Repositories::EventsRepository.new(config, 'sdk_key', runtime_producer)
+    impressions_counter = SplitIoClient::Engine::Common::ImpressionCounter.new
+    filter_adapter = SplitIoClient::Cache::Filter::FilterAdapter.new(config, SplitIoClient::Cache::Filter::BloomFilter.new(1_000))
+    unique_keys_tracker = SplitIoClient::Engine::Impressions::UniqueKeysTracker.new(config, filter_adapter, nil,  Concurrent::Hash.new)
+    impression_manager = SplitIoClient::Engine::Common::ImpressionManager.new(config, impressions_repository, impressions_counter, runtime_producer, SplitIoClient::Observers::ImpressionObserver.new, unique_keys_tracker)
+    evaluation_producer = SplitIoClient::Telemetry::EvaluationProducer.new(config)
+    evaluator = SplitIoClient::Engine::Parser::Evaluator.new(segments_repository, splits_repository, config)
+    split_client = SplitIoClient::SplitClient.new('sdk_key', {:splits => splits_repository, :segments => segments_repository, :impressions => impressions_repository, :events => events_repository}, nil, config, impression_manager, evaluation_producer, evaluator, SplitIoClient::Validators.new(config))
+
+    splits = File.read(File.join(SplitIoClient.root, 'spec/test_data/splits/imp-toggle.json'))
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][0]], [], -1)
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][1]], [], -1)
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][2]], [], -1)
+
+    expect(split_client.get_treatment('key1', 'with_track_disabled')).to eq('off')
+    expect(split_client.get_treatment('key2', 'with_track_enabled')).to eq('off')
+    expect(split_client.get_treatment('key3', 'without_track')).to eq('off')
+
+    imps = impressions_repository.batch
+    expect(imps.length()).to eq(2)
+    expect(imps[0][:i][:f]).to eq('with_track_enabled')
+    expect(imps[1][:i][:f]).to eq('without_track')
+
+    unique_keys = unique_keys_tracker.instance_variable_get(:@cache)
+    expect(unique_keys.key?('with_track_disabled')).to eq(true)
+    expect(unique_keys.length).to eq(1)
+    imp_count = impressions_counter.pop_all
+    expect(imp_count.keys()[0].include? ('with_track_disabled')).to eq(true)
+    expect(imp_count.length).to eq(1)
+  end
+
+  it 'none mode' do
+    config = SplitIoClient::SplitConfig.new(cache_adapter: :memory, impressions_mode: :none)
+    segments_repository = SplitIoClient::Cache::Repositories::SegmentsRepository.new(config)
+    flag_sets_repository = SplitIoClient::Cache::Repositories::MemoryFlagSetsRepository.new([])
+    flag_set_filter = SplitIoClient::Cache::Filter::FlagSetsFilter.new([])
+    splits_repository = SplitIoClient::Cache::Repositories::SplitsRepository.new(config, flag_sets_repository, flag_set_filter)
+    impressions_repository = SplitIoClient::Cache::Repositories::ImpressionsRepository.new(config)
+    runtime_producer = SplitIoClient::Telemetry::RuntimeProducer.new(config)
+    events_repository = SplitIoClient::Cache::Repositories::EventsRepository.new(config, 'sdk_key', runtime_producer)
+    impressions_counter = SplitIoClient::Engine::Common::ImpressionCounter.new
+    filter_adapter = SplitIoClient::Cache::Filter::FilterAdapter.new(config, SplitIoClient::Cache::Filter::BloomFilter.new(1_000))
+    unique_keys_tracker = SplitIoClient::Engine::Impressions::UniqueKeysTracker.new(config, filter_adapter, nil,  Concurrent::Hash.new)
+    impression_manager = SplitIoClient::Engine::Common::ImpressionManager.new(config, impressions_repository, impressions_counter, runtime_producer, SplitIoClient::Observers::ImpressionObserver.new, unique_keys_tracker)
+    evaluation_producer = SplitIoClient::Telemetry::EvaluationProducer.new(config)
+    evaluator = SplitIoClient::Engine::Parser::Evaluator.new(segments_repository, splits_repository, config)
+    split_client = SplitIoClient::SplitClient.new('sdk_key', {:splits => splits_repository, :segments => segments_repository, :impressions => impressions_repository, :events => events_repository}, nil, config, impression_manager, evaluation_producer, evaluator, SplitIoClient::Validators.new(config))
+
+    splits = File.read(File.join(SplitIoClient.root, 'spec/test_data/splits/imp-toggle.json'))
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][0]], [], -1)
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][1]], [], -1)
+    splits_repository.update([JSON.parse(splits,:symbolize_names => true)[:splits][2]], [], -1)
+
+    expect(split_client.get_treatment('key1', 'with_track_disabled')).to eq('off')
+    expect(split_client.get_treatment('key2', 'with_track_enabled')).to eq('off')
+    expect(split_client.get_treatment('key3', 'without_track')).to eq('off')
+
+    imps = impressions_repository.batch
+    expect(imps.length()).to eq(0)
+
+    unique_keys = unique_keys_tracker.instance_variable_get(:@cache)
+    expect(unique_keys.key?('with_track_disabled')).to eq(true)
+    expect(unique_keys.key?('with_track_enabled')).to eq(true)
+    expect(unique_keys.key?('without_track')).to eq(true)
+    expect(unique_keys.length).to eq(3)
+    imp_count = impressions_counter.pop_all
+    expect(imp_count.keys()[0].include? ('with_track_disabled')).to eq(true)
+    expect(imp_count.keys()[1].include? ('with_track_enabled')).to eq(true)
+    expect(imp_count.keys()[2].include? ('without_track')).to eq(true)
+    expect(imp_count.length).to eq(3)
+  end
+end
+
 def mock_segment_changes(segment_name, segment_json, since)
   stub_request(:get, "https://sdk.split.io/api/segmentChanges/#{segment_name}?since=#{since}")
     .to_return(status: 200, body: segment_json)

spec/test_data/splits/imp-toggle.json

@@ -0,0 +1,155 @@
+{
+  "splits": [
+    {
+      "trafficTypeName": "user",
+      "name": "with_track_disabled",
+      "impressionsDisabled": true,
+      "trafficAllocation": 100,
+      "trafficAllocationSeed": 1068038034,
+      "seed": -1053389887,
+      "status": "ACTIVE",
+      "killed": false,
+      "defaultTreatment": "off",
+      "changeNumber": 1675259356568,
+      "algo": 2,
+      "configurations": {},
+      "conditions": [
+        {
+          "conditionType": "ROLLOUT",
+          "matcherGroup": {
+            "combiner": "AND",
+            "matchers": [
+              {
+                "keySelector": {
+                  "trafficType": "user",
+                  "attribute": null
+                },
+                "matcherType": "ALL_KEYS",
+                "negate": false,
+                "userDefinedSegmentMatcherData": null,
+                "whitelistMatcherData": null,
+                "unaryNumericMatcherData": null,
+                "betweenMatcherData": null,
+                "booleanMatcherData": null,
+                "dependencyMatcherData": null,
+                "stringMatcherData": null
+              }
+            ]
+          },
+          "partitions": [
+            {
+              "treatment": "on",
+              "size": 0
+            },
+            {
+              "treatment": "off",
+              "size": 100
+            }
+          ],
+          "label": "default rule"
+        }
+      ]
+    },
+    {
+      "trafficTypeName": "user",
+      "name": "with_track_enabled",
+      "impressionsDisabled": false,
+      "trafficAllocation": 100,
+      "trafficAllocationSeed": 1068038034,
+      "seed": -1053389887,
+      "status": "ACTIVE",
+      "killed": false,
+      "defaultTreatment": "off",
+      "changeNumber": 1675259356568,
+      "algo": 2,
+      "configurations": {},
+      "conditions": [
+        {
+          "conditionType": "ROLLOUT",
+          "matcherGroup": {
+            "combiner": "AND",
+            "matchers": [
+              {
+                "keySelector": {
+                  "trafficType": "user",
+                  "attribute": null
+                },
+                "matcherType": "ALL_KEYS",
+                "negate": false,
+                "userDefinedSegmentMatcherData": null,
+                "whitelistMatcherData": null,
+                "unaryNumericMatcherData": null,
+                "betweenMatcherData": null,
+                "booleanMatcherData": null,
+                "dependencyMatcherData": null,
+                "stringMatcherData": null
+              }
+            ]
+          },
+          "partitions": [
+            {
+              "treatment": "on",
+              "size": 0
+            },
+            {
+              "treatment": "off",
+              "size": 100
+            }
+          ],
+          "label": "default rule"
+        }
+      ]
+    },
+    {
+      "trafficTypeName": "user",
+      "name": "without_track",
+      "trafficAllocation": 100,
+      "trafficAllocationSeed": 1068038034,
+      "seed": -1053389887,
+      "status": "ACTIVE",
+      "killed": false,
+      "defaultTreatment": "off",
+      "changeNumber": 1675259356568,
+      "algo": 2,
+      "configurations": {},
+      "conditions": [
+        {
+          "conditionType": "ROLLOUT",
+          "matcherGroup": {
+            "combiner": "AND",
+            "matchers": [
+              {
+                "keySelector": {
+                  "trafficType": "user",
+                  "attribute": null
+                },
+                "matcherType": "ALL_KEYS",
+                "negate": false,
+                "userDefinedSegmentMatcherData": null,
+                "whitelistMatcherData": null,
+                "unaryNumericMatcherData": null,
+                "betweenMatcherData": null,
+                "booleanMatcherData": null,
+                "dependencyMatcherData": null,
+                "stringMatcherData": null
+              }
+            ]
+          },
+          "partitions": [
+            {
+              "treatment": "on",
+              "size": 0
+            },
+            {
+              "treatment": "off",
+              "size": 100
+            }
+          ],
+          "label": "default rule"
+        }
+      ]
+    }
+  ],
+  "since": -1,
+  "till": 1675259356568
+}