Add combined events to usage ping

Include calculated events combination to usage ping payload

lib/gitlab/usage_data.rb

@@ -217,7 +217,8 @@ module Gitlab
             personal_snippets: count(PersonalSnippet.where(last_28_days_time_period)),
             project_snippets: count(ProjectSnippet.where(last_28_days_time_period))
           }.merge(
-            snowplow_event_counts(last_28_days_time_period(column: :collector_tstamp))
+            snowplow_event_counts(last_28_days_time_period(column: :collector_tstamp)),
+            aggregated_metrics_monthly
           ).tap do |data|
             data[:snippets] = data[:personal_snippets] + data[:project_snippets]
           end
@@ -239,7 +240,10 @@ module Gitlab
 
       def system_usage_data_weekly
         {
-          counts_weekly: {}
+          counts_weekly: {
+          }.merge(
+            aggregated_metrics_weekly
+          )
         }
       end
 
@@ -690,11 +694,19 @@ module Gitlab
         { redis_hll_counters: ::Gitlab::UsageDataCounters::HLLRedisCounter.unique_events_data }
       end
 
-      def aggregated_metrics
+      def aggregated_metrics_monthly
+        return {} unless Feature.enabled?(:product_analytics_aggregated_metrics)
+
+        {
+          aggregated_metrics: ::Gitlab::UsageDataCounters::HLLRedisCounter.aggregated_metrics_monthly_data
+        }
+      end
+
+      def aggregated_metrics_weekly
         return {} unless Feature.enabled?(:product_analytics_aggregated_metrics)
 
         {
-          aggregated_metrics: ::Gitlab::UsageDataCounters::HLLRedisCounter.aggregated_metrics_data
+          aggregated_metrics: ::Gitlab::UsageDataCounters::HLLRedisCounter.aggregated_metrics_weekly_data
         }
       end
 

lib/gitlab/usage_data_counters/hll_redis_counter.rb

@@ -90,18 +90,24 @@ module Gitlab
           event_for(event_name).present?
         end
 
-        def aggregated_metrics_data
+        def aggregated_metrics_monthly_data
           aggregated_metrics.to_h do |aggregation|
-            [aggregation[:name], calculate_count_for_aggregation(aggregation)]
+            [aggregation[:name], calculate_count_for_aggregation(aggregation, start_date: 4.weeks.ago.to_date, end_date: Date.current)]
+          end
+        end
+
+        def aggregated_metrics_weekly_data
+          aggregated_metrics.to_h do |aggregation|
+            [aggregation[:name], calculate_count_for_aggregation(aggregation, start_date: 7.days.ago.to_date, end_date: Date.current)]
           end
         end
 
         private
 
-        def calculate_count_for_aggregation(aggregation)
+        def calculate_count_for_aggregation(aggregation, start_date:, end_date:)
           validate_aggregation_operator!(aggregation[:operator])
 
-          count_unique_events(event_names: aggregation[:events], start_date: 4.weeks.ago.to_date, end_date: Date.current) do |events|
+          count_unique_events(event_names: aggregation[:events], start_date: start_date, end_date: end_date) do |events|
             raise SlotMismatch, events unless events_in_same_slot?(events)
             raise AggregationMismatch, events unless events_same_aggregation?(events)
           end

spec/lib/gitlab/usage_data_counters/hll_redis_counter_spec.rb

@@ -274,53 +274,86 @@ RSpec.describe Gitlab::UsageDataCounters::HLLRedisCounter, :clean_gitlab_redis_s
     end
   end
 
-  describe '.aggregated_metrics_data' do
-    context 'no combination is tracked' do
-      it 'returns empty hash' do
-        allow(described_class).to receive(:aggregated_metrics).and_return([])
+  context 'aggregated metrics' do
+    let(:known_events) do
+      [
+        { name: 'event1_slot', redis_slot: "slot", category: 'category1', aggregation: "weekly" },
+        { name: 'event2_slot', redis_slot: "slot", category: 'category2', aggregation: "weekly" },
+        { name: 'event3', category: 'category2', aggregation: "weekly" }
+      ].map(&:with_indifferent_access)
+    end
 
-        expect(subject.aggregated_metrics_data).to eq({})
-      end
+    let(:aggregated_metrics) do
+      [
+        { name: 'gmau_1', events: %w[event1_slot event2_slot], operator: "ANY" },
+        { name: 'gmau_2', events: %w[event3], operator: "ANY" }
+      ].map(&:with_indifferent_access)
     end
 
-    context 'there are some combinations defined' do
-      let(:known_events) do
-        [
-          { name: 'event1_slot', redis_slot: "slot", category: 'category1', aggregation: "weekly" },
-          { name: 'event2_slot', redis_slot: "slot", category: 'category2', aggregation: "weekly" },
-          { name: 'event3', category: 'category2', aggregation: "weekly" }
-        ].map(&:with_indifferent_access)
+    before do
+      allow(described_class).to receive(:known_events).and_return(known_events)
+      allow(described_class).to receive(:aggregated_metrics).and_return(aggregated_metrics)
+    end
+
+    shared_examples 'aggregated_metrics_data' do
+      context 'no combination is tracked' do
+        it 'returns empty hash' do
+          allow(described_class).to receive(:aggregated_metrics).and_return([])
+
+          expect(aggregated_metrics_data).to eq({})
+        end
       end
 
-      let(:aggregated_metrics) do
-        [
-          { name: 'gmau_1', events: %w[event1_slot event2_slot], operator: "ANY" },
-          { name: 'gmau_2', events: %w[event3], operator: "ANY" }
-        ].map(&:with_indifferent_access)
+      context 'there are some combinations defined' do
+        it 'returns the number of unique events for all known events' do
+          results = {
+            'gmau_1' => 2,
+            'gmau_2' => 3
+          }
+
+          expect(aggregated_metrics_data).to eq(results)
+        end
       end
+    end
 
-      before do
-        allow(described_class).to receive(:known_events).and_return(known_events)
-        allow(described_class).to receive(:aggregated_metrics).and_return(aggregated_metrics)
+    describe '.aggregated_metrics_weekly_data' do
+      subject(:aggregated_metrics_data) { described_class.aggregated_metrics_weekly_data }
 
+      before do
         described_class.track_event(entity1, 'event1_slot', 2.days.ago)
         described_class.track_event(entity1, 'event2_slot', 2.days.ago)
         described_class.track_event(entity3, 'event2_slot', 3.days.ago)
 
+        # events out of time scope
+        described_class.track_event(entity3, 'event2_slot', 8.days.ago)
+
         # events in different slots
         described_class.track_event(entity1, 'event3', 2.days.ago)
         described_class.track_event(entity2, 'event3', 2.days.ago)
         described_class.track_event(entity4, 'event3', 2.days.ago)
       end
 
-      it 'returns the number of unique events for all known events' do
-        results = {
-          'gmau_1' => 2,
-          'gmau_2' => 3
-        }
+      it_behaves_like 'aggregated_metrics_data'
+    end
+
+    describe '.aggregated_metrics_monthly_data' do
+      subject(:aggregated_metrics_data) { described_class.aggregated_metrics_monthly_data }
+
+      before do
+        described_class.track_event(entity1, 'event1_slot', 2.days.ago)
+        described_class.track_event(entity1, 'event2_slot', 10.days.ago)
+        described_class.track_event(entity3, 'event2_slot', 4.weeks.ago.advance(days: 1))
 
-        expect(subject.aggregated_metrics_data).to eq(results)
+        # events out of time scope
+        described_class.track_event(entity3, 'event2_slot', 4.weeks.ago.advance(days: -1))
+
+        # events in different slots
+        described_class.track_event(entity1, 'event3', 2.days.ago)
+        described_class.track_event(entity2, 'event3', 2.days.ago)
+        described_class.track_event(entity4, 'event3', 2.days.ago)
       end
+
+      it_behaves_like 'aggregated_metrics_data'
     end
   end
 end

spec/lib/gitlab/usage_data_spec.rb

@@ -32,6 +32,8 @@ RSpec.describe Gitlab::UsageData, :aggregate_failures do
         .not_to include(:merge_requests_users)
       expect(subject[:usage_activity_by_stage_monthly][:create])
         .to include(:merge_requests_users)
+      expect(subject[:counts_weekly]).to include(:aggregated_metrics)
+      expect(subject[:counts_monthly]).to include(:aggregated_metrics)
     end
 
     it 'clears memoized values' do
@@ -1238,28 +1240,44 @@ RSpec.describe Gitlab::UsageData, :aggregate_failures do
   end
 
   describe 'aggregated_metrics' do
-    subject(:aggregated_metrics) { described_class.aggregated_metrics }
+    shared_examples 'aggregated_metrics_for_time_range' do
+      context 'with product_analytics_aggregated_metrics feature flag on' do
+        before do
+          stub_feature_flags(product_analytics_aggregated_metrics: true)
+        end
 
-    context 'with product_analytics_aggregated_metrics feature flag on' do
-      before do
-        stub_feature_flags(product_analytics_aggregated_metrics: true)
+        it 'uses ::Gitlab::UsageDataCounters::HLLRedisCounter#aggregated_metrics_data', :aggregate_failures do
+          expect(::Gitlab::UsageDataCounters::HLLRedisCounter).to receive(aggregated_metrics_data_method).and_return(global_search_gmau: 123)
+          expect(aggregated_metrics_payload).to eq(aggregated_metrics: { global_search_gmau: 123 })
+        end
       end
 
-      it 'uses ::Gitlab::UsageDataCounters::HLLRedisCounter#aggregated_metrics_data', :aggregate_failures do
-        expect(::Gitlab::UsageDataCounters::HLLRedisCounter).to receive(:aggregated_metrics_data).and_return(global_search_gmau: 123)
-        expect(aggregated_metrics).to eq(aggregated_metrics: { global_search_gmau: 123 })
+      context 'with product_analytics_aggregated_metrics feature flag off' do
+        before do
+          stub_feature_flags(product_analytics_aggregated_metrics: false)
+        end
+
+        it 'returns empty hash', :aggregate_failures do
+          expect(::Gitlab::UsageDataCounters::HLLRedisCounter).not_to receive(aggregated_metrics_data_method)
+          expect(aggregated_metrics_payload).to be {}
+        end
       end
     end
 
-    context 'with product_analytics_aggregated_metrics feature flag off' do
-      before do
-        stub_feature_flags(product_analytics_aggregated_metrics: false)
-      end
+    describe '.aggregated_metrics_weekly' do
+      subject(:aggregated_metrics_payload) { described_class.aggregated_metrics_weekly }
 
-      it 'returns empty hash', :aggregate_failures do
-        expect(::Gitlab::UsageDataCounters::HLLRedisCounter).not_to receive(:aggregated_metrics_data)
-        expect(aggregated_metrics).to be {}
-      end
+      let(:aggregated_metrics_data_method) { :aggregated_metrics_weekly_data }
+
+      it_behaves_like 'aggregated_metrics_for_time_range'
+    end
+
+    describe '.aggregated_metrics_monthly' do
+      subject(:aggregated_metrics_payload) { described_class.aggregated_metrics_monthly }
+
+      let(:aggregated_metrics_data_method) { :aggregated_metrics_monthly_data }
+
+      it_behaves_like 'aggregated_metrics_for_time_range'
     end
   end