Merge branch 'refactor-aggrgates-class-intersection' into 'master'

Extract intersection calculation in respective sources

See merge request gitlab-org/gitlab!56605

lib/gitlab/usage/metrics/aggregates/aggregate.rb

@@ -83,7 +83,7 @@ module Gitlab
             when UNION_OF_AGGREGATED_METRICS
               source.calculate_metrics_union(metric_names: aggregation[:events], start_date: start_date, end_date: end_date, recorded_at: recorded_at)
             when INTERSECTION_OF_AGGREGATED_METRICS
-              calculate_metrics_intersections(source: source, metric_names: aggregation[:events], start_date: start_date, end_date: end_date)
+              source.calculate_metrics_intersections(metric_names: aggregation[:events], start_date: start_date, end_date: end_date, recorded_at: recorded_at)
             else
               Gitlab::ErrorTracking
                 .track_and_raise_for_dev_exception(UnknownAggregationOperator.new("Events should be aggregated with one of operators #{ALLOWED_METRICS_AGGREGATIONS}"))
@@ -94,67 +94,6 @@ module Gitlab
             Gitlab::Utils::UsageData::FALLBACK
           end
 
-          # calculate intersection of 'n' sets based on inclusion exclusion principle https://en.wikipedia.org/wiki/Inclusion%E2%80%93exclusion_principle
-          # this method will be extracted to dedicated module with https://gitlab.com/gitlab-org/gitlab/-/issues/273391
-          def calculate_metrics_intersections(source:, metric_names:, start_date:, end_date:, subset_powers_cache: Hash.new({}))
-            # calculate power of intersection of all given metrics from inclusion exclusion principle
-            # |A + B + C| = (|A| + |B| + |C|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C|)  =>
-            # |A & B & C| = - (|A| + |B| + |C|) + (|A & B| + |A & C| + .. + |C & D|) + |A + B + C|
-            # |A + B + C + D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) - |A & B & C & D| =>
-            # |A & B & C & D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) - |A + B + C + D|
-
-            # calculate each components of equation except for the last one |A & B & C & D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) -  ...
-            subset_powers_data = subsets_intersection_powers(source, metric_names, start_date, end_date, subset_powers_cache)
-
-            # calculate last component of the equation  |A & B & C & D| = .... - |A + B + C + D|
-            power_of_union_of_all_metrics = begin
-              subset_powers_cache[metric_names.size][metric_names.join('_+_')] ||= \
-                source.calculate_metrics_union(metric_names: metric_names, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
-            end
-
-            # in order to determine if part of equation (|A & B & C|, |A & B & C & D|), that represents the intersection that we need to calculate,
-            # is positive or negative in particular equation we need to determine if number of subsets is even or odd. Please take a look at two examples below
-            # |A + B + C| = (|A| + |B| + |C|) - (|A & B| + |A & C| + .. + |C & D|) + |A & B & C|  =>
-            # |A & B & C| = - (|A| + |B| + |C|) + (|A & B| + |A & C| + .. + |C & D|) + |A + B + C|
-            # |A + B + C + D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) - |A & B & C & D| =>
-            # |A & B & C & D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) - |A + B + C + D|
-            subset_powers_size_even = subset_powers_data.size.even?
-
-            # sum all components of equation except for the last one |A & B & C & D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) -  ... =>
-            sum_of_all_subset_powers = sum_subset_powers(subset_powers_data, subset_powers_size_even)
-
-            # add last component of the equation |A & B & C & D| = sum_of_all_subset_powers - |A + B + C + D|
-            sum_of_all_subset_powers + (subset_powers_size_even ? power_of_union_of_all_metrics : -power_of_union_of_all_metrics)
-          end
-
-          def sum_subset_powers(subset_powers_data, subset_powers_size_even)
-            sum_without_sign =  subset_powers_data.to_enum.with_index.sum do |value, index|
-              (index + 1).odd? ? value : -value
-            end
-
-            (subset_powers_size_even ? -1 : 1) * sum_without_sign
-          end
-
-          def subsets_intersection_powers(source, metric_names, start_date, end_date, subset_powers_cache)
-            subset_sizes = (1...metric_names.size)
-
-            subset_sizes.map do |subset_size|
-              if subset_size > 1
-                # calculate sum of powers of intersection between each subset (with given size) of metrics:  #|A + B + C + D| = ... - (|A & B| + |A & C| + .. + |C & D|)
-                metric_names.combination(subset_size).sum do |metrics_subset|
-                  subset_powers_cache[subset_size][metrics_subset.join('_&_')] ||=
-                    calculate_metrics_intersections(source: source, metric_names: metrics_subset, start_date: start_date, end_date: end_date, subset_powers_cache: subset_powers_cache)
-                end
-              else
-                # calculate sum of powers of each set (metric) alone  #|A + B + C + D| = (|A| + |B| + |C| + |D|) - ...
-                metric_names.sum do |metric|
-                  subset_powers_cache[subset_size][metric] ||= \
-                    source.calculate_metrics_union(metric_names: metric, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
-                end
-              end
-            end
-          end
-
           def load_metrics(wildcard)
             Dir[wildcard].each_with_object([]) do |path, metrics|
               metrics.push(*load_yaml_from_path(path))

lib/gitlab/usage/metrics/aggregates/sources/calculations/intersection.rb

+# frozen_string_literal: true
+
+module Gitlab
+  module Usage
+    module Metrics
+      module Aggregates
+        module Sources
+          module Calculations
+            module Intersection
+              def calculate_metrics_intersections(metric_names:, start_date:, end_date:, recorded_at:, subset_powers_cache: Hash.new({}))
+                # calculate power of intersection of all given metrics from inclusion exclusion principle
+                # |A + B + C| = (|A| + |B| + |C|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C|)  =>
+                # |A & B & C| = - (|A| + |B| + |C|) + (|A & B| + |A & C| + .. + |C & D|) + |A + B + C|
+                # |A + B + C + D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) - |A & B & C & D| =>
+                # |A & B & C & D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) - |A + B + C + D|
+
+                # calculate each components of equation except for the last one |A & B & C & D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) -  ...
+                subset_powers_data = subsets_intersection_powers(metric_names, start_date, end_date, recorded_at, subset_powers_cache)
+
+                # calculate last component of the equation  |A & B & C & D| = .... - |A + B + C + D|
+                power_of_union_of_all_metrics = begin
+                  subset_powers_cache[metric_names.size][metric_names.join('_+_')] ||= \
+                    calculate_metrics_union(metric_names: metric_names, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
+                end
+
+                # in order to determine if part of equation (|A & B & C|, |A & B & C & D|), that represents the intersection that we need to calculate,
+                # is positive or negative in particular equation we need to determine if number of subsets is even or odd. Please take a look at two examples below
+                # |A + B + C| = (|A| + |B| + |C|) - (|A & B| + |A & C| + .. + |C & D|) + |A & B & C|  =>
+                # |A & B & C| = - (|A| + |B| + |C|) + (|A & B| + |A & C| + .. + |C & D|) + |A + B + C|
+                # |A + B + C + D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) - |A & B & C & D| =>
+                # |A & B & C & D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) - |A + B + C + D|
+                subset_powers_size_even = subset_powers_data.size.even?
+
+                # sum all components of equation except for the last one |A & B & C & D| = (|A| + |B| + |C| + |D|) - (|A & B| + |A & C| + .. + |C & D|) + (|A & B & C| + |B & C & D|) -  ... =>
+                sum_of_all_subset_powers = sum_subset_powers(subset_powers_data, subset_powers_size_even)
+
+                # add last component of the equation |A & B & C & D| = sum_of_all_subset_powers - |A + B + C + D|
+                sum_of_all_subset_powers + (subset_powers_size_even ? power_of_union_of_all_metrics : -power_of_union_of_all_metrics)
+              end
+
+              private
+
+              def subsets_intersection_powers(metric_names, start_date, end_date, recorded_at, subset_powers_cache)
+                subset_sizes = (1...metric_names.size)
+
+                subset_sizes.map do |subset_size|
+                  if subset_size > 1
+                    # calculate sum of powers of intersection between each subset (with given size) of metrics:  #|A + B + C + D| = ... - (|A & B| + |A & C| + .. + |C & D|)
+                    metric_names.combination(subset_size).sum do |metrics_subset|
+                      subset_powers_cache[subset_size][metrics_subset.join('_&_')] ||=
+                        calculate_metrics_intersections(metric_names: metrics_subset, start_date: start_date, end_date: end_date, recorded_at: recorded_at, subset_powers_cache: subset_powers_cache)
+                    end
+                  else
+                    # calculate sum of powers of each set (metric) alone  #|A + B + C + D| = (|A| + |B| + |C| + |D|) - ...
+                    metric_names.sum do |metric|
+                      subset_powers_cache[subset_size][metric] ||= \
+                        calculate_metrics_union(metric_names: metric, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
+                    end
+                  end
+                end
+              end
+
+              def sum_subset_powers(subset_powers_data, subset_powers_size_even)
+                sum_without_sign = subset_powers_data.to_enum.with_index.sum do |value, index|
+                  (index + 1).odd? ? value : -value
+                end
+
+                (subset_powers_size_even ? -1 : 1) * sum_without_sign
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/gitlab/usage/metrics/aggregates/sources/postgres_hll.rb

@@ -6,6 +6,7 @@ module Gitlab
       module Aggregates
         module Sources
           class PostgresHll
+            extend Calculations::Intersection
             class << self
               def calculate_metrics_union(metric_names:, start_date:, end_date:, recorded_at:)
                 time_period = start_date && end_date ? (start_date..end_date) : nil

lib/gitlab/usage/metrics/aggregates/sources/redis_hll.rb

@@ -8,6 +8,7 @@ module Gitlab
           UnionNotAvailable = Class.new(AggregatedMetricError)
 
           class RedisHll
+            extend Calculations::Intersection
             def self.calculate_metrics_union(metric_names:, start_date:, end_date:, recorded_at: nil)
               union = Gitlab::UsageDataCounters::HLLRedisCounter
                 .calculate_events_union(event_names: metric_names, start_date: start_date, end_date: end_date)

spec/lib/gitlab/usage/metrics/aggregates/aggregate_spec.rb

@@ -71,56 +71,6 @@ RSpec.describe Gitlab::Usage::Metrics::Aggregates::Aggregate, :clean_gitlab_redi
           end
         end
 
-        context 'with AND operator' do
-          let(:aggregated_metrics) do
-            params = { source: datasource, operator: "AND", time_frame: time_frame }
-            [
-              aggregated_metric(**params.merge(name: "gmau_1", events: %w[event3 event5])),
-              aggregated_metric(**params.merge(name: "gmau_2"))
-            ]
-          end
-
-          it 'returns the number of unique events recorded for every metric in aggregate', :aggregate_failures do
-            results = {
-              'gmau_1' => 2,
-              'gmau_2' => 1
-            }
-            params = { start_date: start_date, end_date: end_date, recorded_at: recorded_at }
-
-            # gmau_1 data is as follow
-            # |A| => 4
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event3')).and_return(4)
-            # |B| => 6
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event5')).and_return(6)
-            # |A + B| => 8
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event3 event5])).and_return(8)
-            # Exclusion inclusion principle formula to calculate intersection of 2 sets
-            # |A & B| = (|A| + |B|) - |A + B| => (4 + 6) - 8 => 2
-
-            # gmau_2 data is as follow:
-            # |A| => 2
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event1')).and_return(2)
-            # |B| => 3
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event2')).and_return(3)
-            # |C| => 5
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event3')).and_return(5)
-
-            # |A + B| => 4 therefore |A & B| = (|A| + |B|) - |A + B| =>  2 + 3 - 4 => 1
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event1 event2])).and_return(4)
-            # |A + C| => 6 therefore |A & C| = (|A| + |C|) - |A + C| =>  2 + 5 - 6  => 1
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event1 event3])).and_return(6)
-            # |B + C| => 7 therefore |B & C| = (|B| + |C|) - |B + C| => 3 + 5 - 7 => 1
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event2 event3])).and_return(7)
-            # |A + B + C| => 8
-            expect(namespace::SOURCES[datasource]).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event1 event2 event3])).and_return(8)
-            # Exclusion inclusion principle formula to calculate intersection of 3 sets
-            # |A & B & C| = (|A & B| + |A & C| + |B & C|) - (|A| + |B| + |C|)  + |A + B + C|
-            # (1 + 1 + 1) - (2 + 3 + 5) + 8 => 1
-
-            expect(aggregated_metrics_data).to eq(results)
-          end
-        end
-
         context 'with OR operator' do
           let(:aggregated_metrics) do
             [
@@ -331,36 +281,6 @@ RSpec.describe Gitlab::Usage::Metrics::Aggregates::Aggregate, :clean_gitlab_redi
       it_behaves_like 'database_sourced_aggregated_metrics'
       it_behaves_like 'redis_sourced_aggregated_metrics'
       it_behaves_like 'db sourced aggregated metrics without database_sourced_aggregated_metrics feature'
-
-      context 'metrics union calls' do
-        it 'caches intermediate operations', :aggregate_failures do
-          events = %w[event1 event2 event3 event5]
-          allow_next_instance_of(described_class) do |instance|
-            allow(instance).to receive(:aggregated_metrics)
-                                 .and_return([aggregated_metric(name: 'gmau_1', events: events, operator: "AND", time_frame: time_frame)])
-          end
-
-          params = { start_date: start_date, end_date: end_date, recorded_at: recorded_at }
-
-          events.each do |event|
-            expect(sources::RedisHll).to receive(:calculate_metrics_union)
-                                           .with(params.merge(metric_names: event))
-                                           .once
-                                           .and_return(0)
-          end
-
-          2.upto(4) do |subset_size|
-            events.combination(subset_size).each do |events|
-              expect(sources::RedisHll).to receive(:calculate_metrics_union)
-                                             .with(params.merge(metric_names: events))
-                                             .once
-                                             .and_return(0)
-            end
-          end
-
-          aggregated_metrics_data
-        end
-      end
     end
   end
 end

spec/lib/gitlab/usage/metrics/aggregates/sources/calculations/intersection_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Gitlab::Usage::Metrics::Aggregates::Sources::Calculations::Intersection do
+  let_it_be(:recorded_at) { Time.current.to_i }
+  let_it_be(:start_date) { 4.weeks.ago.to_date }
+  let_it_be(:end_date) { Date.current }
+
+  shared_examples 'aggregated_metrics_data with source' do
+    context 'with AND operator' do
+      let(:params) { { start_date: start_date, end_date: end_date, recorded_at: recorded_at } }
+
+      context 'with even number of metrics' do
+        it 'calculates intersection correctly', :aggregate_failures do
+          # gmau_1 data is as follow
+          # |A| => 4
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event3')).and_return(4)
+          # |B| => 6
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event5')).and_return(6)
+          # |A + B| => 8
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event3 event5])).and_return(8)
+          # Exclusion inclusion principle formula to calculate intersection of 2 sets
+          # |A & B| = (|A| + |B|) - |A + B| => (4 + 6) - 8 => 2
+          expect(source.calculate_metrics_intersections(metric_names: %w[event3 event5], start_date: start_date, end_date: end_date, recorded_at: recorded_at)).to eq(2)
+        end
+      end
+
+      context 'with odd number of metrics' do
+        it 'calculates intersection correctly', :aggregate_failures do
+          # gmau_2 data is as follow:
+          # |A| => 2
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event1')).and_return(2)
+          # |B| => 3
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event2')).and_return(3)
+          # |C| => 5
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: 'event3')).and_return(5)
+
+          # |A + B| => 4 therefore |A & B| = (|A| + |B|) - |A + B| =>  2 + 3 - 4 => 1
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event1 event2])).and_return(4)
+          # |A + C| => 6 therefore |A & C| = (|A| + |C|) - |A + C| =>  2 + 5 - 6  => 1
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event1 event3])).and_return(6)
+          # |B + C| => 7 therefore |B & C| = (|B| + |C|) - |B + C| => 3 + 5 - 7 => 1
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event2 event3])).and_return(7)
+          # |A + B + C| => 8
+          expect(source).to receive(:calculate_metrics_union).with(params.merge(metric_names: %w[event1 event2 event3])).and_return(8)
+          # Exclusion inclusion principle formula to calculate intersection of 3 sets
+          # |A & B & C| = (|A & B| + |A & C| + |B & C|) - (|A| + |B| + |C|)  + |A + B + C|
+          # (1 + 1 + 1) - (2 + 3 + 5) + 8 => 1
+          expect(source.calculate_metrics_intersections(metric_names: %w[event1 event2 event3], start_date: start_date, end_date: end_date, recorded_at: recorded_at)).to eq(1)
+        end
+      end
+    end
+  end
+
+  describe '.aggregated_metrics_data' do
+    let(:source) do
+      Class.new do
+        extend Gitlab::Usage::Metrics::Aggregates::Sources::Calculations::Intersection
+      end
+    end
+
+    it 'caches intermediate operations', :aggregate_failures do
+      events = %w[event1 event2 event3 event5]
+
+      params = { start_date: start_date, end_date: end_date, recorded_at: recorded_at }
+
+      events.each do |event|
+        expect(source).to receive(:calculate_metrics_union)
+                                       .with(params.merge(metric_names: event))
+                                       .once
+                                       .and_return(0)
+      end
+
+      2.upto(4) do |subset_size|
+        events.combination(subset_size).each do |events|
+          expect(source).to receive(:calculate_metrics_union)
+                                         .with(params.merge(metric_names: events))
+                                         .once
+                                         .and_return(0)
+        end
+      end
+
+      expect(source.calculate_metrics_intersections(metric_names: events, start_date: start_date, end_date: end_date, recorded_at: recorded_at)).to eq(0)
+    end
+
+    it_behaves_like 'aggregated_metrics_data with source'
+  end
+end

spec/lib/gitlab/usage/metrics/aggregates/sources/postgres_hll_spec.rb

@@ -12,11 +12,7 @@ RSpec.describe Gitlab::Usage::Metrics::Aggregates::Sources::PostgresHll, :clean_
   let(:metric_2) { 'metric_2' }
   let(:metric_names) { [metric_1, metric_2] }
 
-  describe '.calculate_events_union' do
-    subject(:calculate_metrics_union) do
-      described_class.calculate_metrics_union(metric_names: metric_names, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
-    end
-
+  describe 'metric calculations' do
     before do
       [
         {
@@ -36,23 +32,55 @@ RSpec.describe Gitlab::Usage::Metrics::Aggregates::Sources::PostgresHll, :clean_
       end
     end
 
-    it 'returns the number of unique events in the union of all metrics' do
-      expect(calculate_metrics_union.round(2)).to eq(3.12)
-    end
+    describe '.calculate_events_union' do
+      subject(:calculate_metrics_union) do
+        described_class.calculate_metrics_union(metric_names: metric_names, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
+      end
+
+      it 'returns the number of unique events in the union of all metrics' do
+        expect(calculate_metrics_union.round(2)).to eq(3.12)
+      end
+
+      context 'when there is no aggregated data saved' do
+        let(:metric_names) { [metric_1, 'i do not have any records'] }
+
+        it 'raises error when union data is missing' do
+          expect { calculate_metrics_union }.to raise_error Gitlab::Usage::Metrics::Aggregates::Sources::UnionNotAvailable
+        end
+      end
 
-    context 'when there is no aggregated data saved' do
-      let(:metric_names) { [metric_1, 'i do not have any records'] }
+      context 'when there is only one metric defined as aggregated' do
+        let(:metric_names) { [metric_1] }
 
-      it 'raises error when union data is missing' do
-        expect { calculate_metrics_union }.to raise_error Gitlab::Usage::Metrics::Aggregates::Sources::UnionNotAvailable
+        it 'returns the number of unique events for that metric' do
+          expect(calculate_metrics_union.round(2)).to eq(2.08)
+        end
       end
     end
 
-    context 'when there is only one metric defined as aggregated' do
-      let(:metric_names) { [metric_1] }
+    describe '.calculate_metrics_intersections' do
+      subject(:calculate_metrics_intersections) do
+        described_class.calculate_metrics_intersections(metric_names: metric_names, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
+      end
+
+      it 'returns the number of common events in the intersection of all metrics' do
+        expect(calculate_metrics_intersections.round(2)).to eq(1.04)
+      end
+
+      context 'when there is no aggregated data saved' do
+        let(:metric_names) { [metric_1, 'i do not have any records'] }
 
-      it 'returns the number of unique events for that metric' do
-        expect(calculate_metrics_union.round(2)).to eq(2.08)
+        it 'raises error when union data is missing' do
+          expect { calculate_metrics_intersections }.to raise_error Gitlab::Usage::Metrics::Aggregates::Sources::UnionNotAvailable
+        end
+      end
+
+      context 'when there is only one metric defined in aggregate' do
+        let(:metric_names) { [metric_1] }
+
+        it 'returns the number of common/unique events for the intersection of that metric' do
+          expect(calculate_metrics_intersections.round(2)).to eq(2.08)
+        end
       end
     end
   end

spec/lib/gitlab/usage/metrics/aggregates/sources/redis_hll_spec.rb

@@ -3,11 +3,12 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Usage::Metrics::Aggregates::Sources::RedisHll do
-  describe '.calculate_events_union' do
-    let(:event_names) { %w[event_a event_b] }
-    let(:start_date) { 7.days.ago }
-    let(:end_date) { Date.current }
+  let_it_be(:event_names) { %w[event_a event_b] }
+  let_it_be(:start_date) { 7.days.ago }
+  let_it_be(:end_date) { Date.current }
+  let_it_be(:recorded_at) { Time.current }
 
+  describe '.calculate_events_union' do
     subject(:calculate_metrics_union) do
       described_class.calculate_metrics_union(metric_names: event_names, start_date: start_date, end_date: end_date, recorded_at: nil)
     end
@@ -26,4 +27,30 @@ RSpec.describe Gitlab::Usage::Metrics::Aggregates::Sources::RedisHll do
       expect { calculate_metrics_union }.to raise_error Gitlab::Usage::Metrics::Aggregates::Sources::UnionNotAvailable
     end
   end
+
+  describe '.calculate_metrics_intersections' do
+    subject(:calculate_metrics_intersections) do
+      described_class.calculate_metrics_intersections(metric_names: event_names, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
+    end
+
+    it 'uses values returned by union to compute the intersection' do
+      event_names.each do |event|
+        expect(Gitlab::Usage::Metrics::Aggregates::Sources::RedisHll).to receive(:calculate_metrics_union)
+                                                              .with(metric_names: event, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
+                                                              .and_return(5)
+      end
+
+      expect(Gitlab::Usage::Metrics::Aggregates::Sources::RedisHll).to receive(:calculate_metrics_union)
+                                                              .with(metric_names: event_names, start_date: start_date, end_date: end_date, recorded_at: recorded_at)
+                                                              .and_return(2)
+
+      expect(calculate_metrics_intersections).to eq(8)
+    end
+
+    it 'raises error if union is < 0' do
+      allow(Gitlab::Usage::Metrics::Aggregates::Sources::RedisHll).to receive(:calculate_metrics_union).and_raise(Gitlab::Usage::Metrics::Aggregates::Sources::UnionNotAvailable)
+
+      expect { calculate_metrics_intersections }.to raise_error(Gitlab::Usage::Metrics::Aggregates::Sources::UnionNotAvailable)
+    end
+  end
 end