1 files changed, 40 insertions, 16 deletions

diff --git a/lib/gitlab/usage_data_counters/hll_redis_counter.rb b/lib/gitlab/usage_data_counters/hll_redis_counter.rb
index 137b6f90545..97039a58e92 100644
--- a/lib/gitlab/usage_data_counters/hll_redis_counter.rb
+++ b/lib/gitlab/usage_data_counters/hll_redis_counter.rb
@@ -29,18 +29,20 @@ module Gitlab
         #
         # event_name - The event name.
         # values - One or multiple values counted.
+        # property_name - Name of the values counted.
         # time - Time of the action, set to Time.current.
-        def track_event(event_name, values:, time: Time.current)
-          track(values, event_name, time: time)
+        def track_event(event_name, values:, property_name: nil, time: Time.current)
+          track(values, event_name, property_name: property_name, time: time)
         end
 
         # Count unique events for a given time range.
         #
         # event_names - The list of the events to count.
+        # property_names - The list of the values for which the events are to be counted.
         # start_date  - The start date of the time range.
         # end_date  - The end date of the time range.
-        def unique_events(event_names:, start_date:, end_date:)
-          count_unique_events(event_names: event_names, start_date: start_date, end_date: end_date)
+        def unique_events(event_names:, start_date:, end_date:, property_name: nil)
+          count_unique_events(event_names: event_names, property_name: property_name, start_date: start_date, end_date: end_date)
         end
 
         def known_event?(event_name)
@@ -52,19 +54,19 @@ module Gitlab
         end
 
         def calculate_events_union(event_names:, start_date:, end_date:)
-          count_unique_events(event_names: event_names, start_date: start_date, end_date: end_date)
+          count_unique_events(event_names: event_names, property_name: nil, start_date: start_date, end_date: end_date)
         end
 
         private
 
-        def track(values, event_name, time: Time.zone.now)
+        def track(values, event_name, property_name:, time: Time.zone.now)
           event = event_for(event_name)
           Gitlab::ErrorTracking.track_and_raise_for_dev_exception(UnknownEvent.new("Unknown event #{event_name}")) unless event.present?
 
           return if event.blank?
           return unless Feature.enabled?(:redis_hll_tracking, type: :ops)
 
-          Gitlab::Redis::HLL.add(key: redis_key(event, time), value: values, expiry: KEY_EXPIRY_LENGTH)
+          Gitlab::Redis::HLL.add(key: redis_key(event_with_property_name(event, property_name), time), value: values, expiry: KEY_EXPIRY_LENGTH)
 
         rescue StandardError => e
           # Ignore any exceptions unless is dev or test env
@@ -72,8 +74,8 @@ module Gitlab
           Gitlab::ErrorTracking.track_and_raise_for_dev_exception(e)
         end
 
-        def count_unique_events(event_names:, start_date:, end_date:)
-          events = events_for(Array(event_names).map(&:to_s))
+        def count_unique_events(event_names:, start_date:, end_date:, property_name:)
+          events = events_with_property_names(event_names, property_name)
 
           keys = keys_for_aggregation(events: events, start_date: start_date, end_date: end_date)
 
@@ -82,6 +84,19 @@ module Gitlab
           redis_usage_data { Gitlab::Redis::HLL.count(keys: keys) }
         end
 
+        def events_with_property_names(event_names, property_name)
+          event_names = Array(event_names).map(&:to_s)
+          known_events.filter_map do |event|
+            next unless event_names.include?(event[:name])
+
+            property_name ? event_with_property_name(event, property_name) : event
+          end
+        end
+
+        def event_with_property_name(event, property_name)
+          event.merge(property_name: property_name)
+        end
+
         def load_events
           events = Gitlab::Usage::MetricDefinition.all.map do |d|
             next unless d.available?
@@ -102,21 +117,30 @@ module Gitlab
           known_events.find { |event| event[:name] == event_name.to_s }
         end
 
-        def events_for(event_names)
-          known_events.select { |event| event_names.include?(event[:name]) }
-        end
-
         def redis_key(event, time)
-          key = redis_key_base(event[:name])
+          key = redis_key_base(event)
 
           year_week = time.strftime('%G-%V')
           "{#{REDIS_SLOT}}_#{key}-#{year_week}"
         end
 
-        def redis_key_base(event_name)
+        def redis_key_base(event)
+          event_name = event[:name]
+
           raise UnknownEvent, "Unknown event #{event_name}" unless known_events_names.include?(event_name.to_s)
 
-          key_overrides.fetch(event_name, event_name)
+          property_name = event[:property_name]
+          key = event_name
+          if Feature.enabled?(:redis_hll_property_name_tracking, type: :wip) && property_name
+            key = "#{key}-#{formatted_property_name(property_name)}"
+          end
+
+          key_overrides.fetch(key, key)
+        end
+
+        def formatted_property_name(property_name)
+          # simplify to format from EventDefinitions.unique_properties
+          property_name.to_s.split('.').first.to_sym
         end
 
         def key_overrides