Check for usage ping enabled when tracking using Redis HLL

changelogs/unreleased/245247-check-for-usage-ping-enabled-when-tracking-using-redis-hll.yml

+---
+title: Check if usage ping enabled for all tracking using Redis HLL
+merge_request: 41562
+author:
+type: added

lib/gitlab/usage_data_counters/hll_redis_counter.rb

@@ -34,6 +34,8 @@ module Gitlab
       # * Get unique counts per user: Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(event_names: 'g_compliance_dashboard', start_date: 28.days.ago, end_date: Date.current)
       class << self
         def track_event(entity_id, event_name, time = Time.zone.now)
+          return unless Gitlab::CurrentSettings.usage_ping_enabled?
+
           event = event_for(event_name)
 
           raise UnknownEvent.new("Unknown event #{event_name}") unless event.present?

spec/lib/gitlab/usage_data_counters/hll_redis_counter_spec.rb

@@ -62,65 +62,81 @@ RSpec.describe Gitlab::UsageDataCounters::HLLRedisCounter, :clean_gitlab_redis_s
     end
 
     describe '.track_event' do
-      it "raise error if metrics don't have same aggregation" do
-        expect { described_class.track_event(entity1, different_aggregation, Date.current) } .to raise_error(Gitlab::UsageDataCounters::HLLRedisCounter::UnknownAggregation)
-      end
+      context 'when usage_ping is disabled' do
+        it 'does not track the event' do
+          stub_application_setting(usage_ping_enabled: false)
 
-      it 'raise error if metrics of unknown aggregation' do
-        expect { described_class.track_event(entity1, 'unknown', Date.current) } .to raise_error(Gitlab::UsageDataCounters::HLLRedisCounter::UnknownEvent)
+          described_class.track_event(entity1, weekly_event, Date.current)
+
+          expect(Gitlab::Redis::HLL).not_to receive(:add)
+        end
       end
 
-      context 'for weekly events' do
-        it 'sets the keys in Redis to expire automatically after the given expiry time' do
-          described_class.track_event(entity1, "g_analytics_contribution")
+      context 'when usage_ping is enabled' do
+        before do
+          stub_application_setting(usage_ping_enabled: true)
+        end
 
-          Gitlab::Redis::SharedState.with do |redis|
-            keys = redis.scan_each(match: "g_{analytics}_contribution-*").to_a
-            expect(keys).not_to be_empty
+        it "raise error if metrics don't have same aggregation" do
+          expect { described_class.track_event(entity1, different_aggregation, Date.current) } .to raise_error(Gitlab::UsageDataCounters::HLLRedisCounter::UnknownAggregation)
+        end
 
-            keys.each do |key|
-              expect(redis.ttl(key)).to be_within(5.seconds).of(12.weeks)
+        it 'raise error if metrics of unknown aggregation' do
+          expect { described_class.track_event(entity1, 'unknown', Date.current) } .to raise_error(Gitlab::UsageDataCounters::HLLRedisCounter::UnknownEvent)
+        end
+
+        context 'for weekly events' do
+          it 'sets the keys in Redis to expire automatically after the given expiry time' do
+            described_class.track_event(entity1, "g_analytics_contribution")
+
+            Gitlab::Redis::SharedState.with do |redis|
+              keys = redis.scan_each(match: "g_{analytics}_contribution-*").to_a
+              expect(keys).not_to be_empty
+
+              keys.each do |key|
+                expect(redis.ttl(key)).to be_within(5.seconds).of(12.weeks)
+              end
             end
           end
-        end
 
-        it 'sets the keys in Redis to expire automatically after 6 weeks by default' do
-          described_class.track_event(entity1, "g_compliance_dashboard")
+          it 'sets the keys in Redis to expire automatically after 6 weeks by default' do
+            described_class.track_event(entity1, "g_compliance_dashboard")
 
-          Gitlab::Redis::SharedState.with do |redis|
-            keys = redis.scan_each(match: "g_{compliance}_dashboard-*").to_a
-            expect(keys).not_to be_empty
+            Gitlab::Redis::SharedState.with do |redis|
+              keys = redis.scan_each(match: "g_{compliance}_dashboard-*").to_a
+              expect(keys).not_to be_empty
 
-            keys.each do |key|
-              expect(redis.ttl(key)).to be_within(5.seconds).of(6.weeks)
+              keys.each do |key|
+                expect(redis.ttl(key)).to be_within(5.seconds).of(6.weeks)
+              end
             end
           end
         end
-      end
 
-      context 'for daily events' do
-        it 'sets the keys in Redis to expire after the given expiry time' do
-          described_class.track_event(entity1, "g_analytics_search")
+        context 'for daily events' do
+          it 'sets the keys in Redis to expire after the given expiry time' do
+            described_class.track_event(entity1, "g_analytics_search")
 
-          Gitlab::Redis::SharedState.with do |redis|
-            keys = redis.scan_each(match: "*-g_{analytics}_search").to_a
-            expect(keys).not_to be_empty
+            Gitlab::Redis::SharedState.with do |redis|
+              keys = redis.scan_each(match: "*-g_{analytics}_search").to_a
+              expect(keys).not_to be_empty
 
-            keys.each do |key|
-              expect(redis.ttl(key)).to be_within(5.seconds).of(84.days)
+              keys.each do |key|
+                expect(redis.ttl(key)).to be_within(5.seconds).of(84.days)
+              end
             end
           end
-        end
 
-        it 'sets the keys in Redis to expire after 29 days by default' do
-          described_class.track_event(entity1, "no_slot")
+          it 'sets the keys in Redis to expire after 29 days by default' do
+            described_class.track_event(entity1, "no_slot")
 
-          Gitlab::Redis::SharedState.with do |redis|
-            keys = redis.scan_each(match: "*-{no_slot}").to_a
-            expect(keys).not_to be_empty
+            Gitlab::Redis::SharedState.with do |redis|
+              keys = redis.scan_each(match: "*-{no_slot}").to_a
+              expect(keys).not_to be_empty
 
-            keys.each do |key|
-              expect(redis.ttl(key)).to be_within(5.seconds).of(29.days)
+              keys.each do |key|
+                expect(redis.ttl(key)).to be_within(5.seconds).of(29.days)
+              end
             end
           end
         end