Add latest changes from gitlab-org/gitlab@master

1 files changed, 362 insertions, 351 deletions

diff --git a/spec/lib/gitlab/usage_data_spec.rb b/spec/lib/gitlab/usage_data_spec.rb
index 3f7e412e80b..b50481a85cd 100644
--- a/spec/lib/gitlab/usage_data_spec.rb
+++ b/spec/lib/gitlab/usage_data_spec.rb
@@ -6,381 +6,392 @@ describe Gitlab::UsageData do
   let(:projects) { create_list(:project, 4) }
   let!(:board) { create(:board, project: projects[0]) }
 
-  describe '#data' do
-    before do
-      create(:jira_service, project: projects[0])
-      create(:jira_service, :without_properties_callback, project: projects[1])
-      create(:jira_service, :jira_cloud_service, project: projects[2])
-      create(:jira_service, :without_properties_callback, project: projects[3],
-             properties: { url: 'https://mysite.atlassian.net' })
-      create(:prometheus_service, project: projects[1])
-      create(:service, project: projects[0], type: 'SlackSlashCommandsService', active: true)
-      create(:service, project: projects[1], type: 'SlackService', active: true)
-      create(:service, project: projects[2], type: 'SlackService', active: true)
-      create(:service, project: projects[2], type: 'MattermostService', active: false)
-      create(:service, project: projects[2], type: 'MattermostService', active: true, template: true)
-      create(:service, project: projects[2], type: 'CustomIssueTrackerService', active: true)
-      create(:project_error_tracking_setting, project: projects[0])
-      create(:project_error_tracking_setting, project: projects[1], enabled: false)
-      create(:alerts_service, project: projects[0])
-      create(:alerts_service, :inactive, project: projects[1])
-      create_list(:issue, 2, project: projects[0], author: User.alert_bot)
-      create_list(:issue, 2, project: projects[1], author: User.alert_bot)
-      create_list(:issue, 4, project: projects[0])
-      create(:zoom_meeting, project: projects[0], issue: projects[0].issues[0], issue_status: :added)
-      create_list(:zoom_meeting, 2, project: projects[0], issue: projects[0].issues[1], issue_status: :removed)
-      create(:zoom_meeting, project: projects[0], issue: projects[0].issues[2], issue_status: :added)
-      create_list(:zoom_meeting, 2, project: projects[0], issue: projects[0].issues[2], issue_status: :removed)
-      create(:sentry_issue, issue: projects[0].issues[0])
-
-      # Enabled clusters
-      gcp_cluster = create(:cluster_provider_gcp, :created).cluster
-      create(:cluster_provider_aws, :created)
-      create(:cluster_platform_kubernetes)
-      create(:cluster, :group)
-
-      # Disabled clusters
-      create(:cluster, :disabled)
-      create(:cluster, :group, :disabled)
-      create(:cluster, :group, :disabled)
-
-      # Applications
-      create(:clusters_applications_helm, :installed, cluster: gcp_cluster)
-      create(:clusters_applications_ingress, :installed, cluster: gcp_cluster)
-      create(:clusters_applications_cert_manager, :installed, cluster: gcp_cluster)
-      create(:clusters_applications_prometheus, :installed, cluster: gcp_cluster)
-      create(:clusters_applications_crossplane, :installed, cluster: gcp_cluster)
-      create(:clusters_applications_runner, :installed, cluster: gcp_cluster)
-      create(:clusters_applications_knative, :installed, cluster: gcp_cluster)
-      create(:clusters_applications_elastic_stack, :installed, cluster: gcp_cluster)
-      create(:clusters_applications_jupyter, :installed, cluster: gcp_cluster)
-
-      create(:grafana_integration, project: projects[0], enabled: true)
-      create(:grafana_integration, project: projects[1], enabled: true)
-      create(:grafana_integration, project: projects[2], enabled: false)
-
-      allow(Gitlab::GrafanaEmbedUsageData).to receive(:issue_count).and_return(2)
-
-      ProjectFeature.first.update_attribute('repository_access_level', 0)
-    end
-
-    subject { described_class.data }
-
-    it 'gathers usage data', :aggregate_failures do
-      expect(subject.keys).to include(*%i(
-        active_user_count
-        counts
-        recorded_at
-        edition
-        version
-        installation_type
-        uuid
-        hostname
-        mattermost_enabled
-        signup_enabled
-        ldap_enabled
-        gravatar_enabled
-        omniauth_enabled
-        reply_by_email_enabled
-        container_registry_enabled
-        dependency_proxy_enabled
-        gitlab_shared_runners_enabled
-        gitlab_pages
-        git
-        gitaly
-        database
-        avg_cycle_analytics
-        influxdb_metrics_enabled
-        prometheus_metrics_enabled
-        web_ide_clientside_preview_enabled
-        ingress_modsecurity_enabled
-      ))
-    end
-
-    it 'gathers usage counts' do
-      smau_keys = %i(
-        snippet_create
-        snippet_update
-        snippet_comment
-        merge_request_comment
-        merge_request_create
-        commit_comment
-        wiki_pages_create
-        wiki_pages_update
-        wiki_pages_delete
-        web_ide_views
-        web_ide_commits
-        web_ide_merge_requests
-        web_ide_previews
-        navbar_searches
-        cycle_analytics_views
-        productivity_analytics_views
-        source_code_pushes
-      )
-
-      expected_keys = %i(
-        assignee_lists
-        boards
-        ci_builds
-        ci_internal_pipelines
-        ci_external_pipelines
-        ci_pipeline_config_auto_devops
-        ci_pipeline_config_repository
-        ci_runners
-        ci_triggers
-        ci_pipeline_schedules
-        auto_devops_enabled
-        auto_devops_disabled
-        deploy_keys
-        deployments
-        successful_deployments
-        failed_deployments
-        environments
-        clusters
-        clusters_enabled
-        project_clusters_enabled
-        group_clusters_enabled
-        clusters_disabled
-        project_clusters_disabled
-        group_clusters_disabled
-        clusters_platforms_eks
-        clusters_platforms_gke
-        clusters_platforms_user
-        clusters_applications_helm
-        clusters_applications_ingress
-        clusters_applications_cert_managers
-        clusters_applications_prometheus
-        clusters_applications_crossplane
-        clusters_applications_runner
-        clusters_applications_knative
-        clusters_applications_elastic_stack
-        clusters_applications_jupyter
-        in_review_folder
-        grafana_integrated_projects
-        groups
-        issues
-        issues_created_from_gitlab_error_tracking_ui
-        issues_with_associated_zoom_link
-        issues_using_zoom_quick_actions
-        issues_with_embedded_grafana_charts_approx
-        incident_issues
-        keys
-        label_lists
-        labels
-        lfs_objects
-        merge_requests
-        milestone_lists
-        milestones
-        notes
-        pool_repositories
-        projects
-        projects_imported_from_github
-        projects_asana_active
-        projects_jira_active
-        projects_jira_server_active
-        projects_jira_cloud_active
-        projects_slack_notifications_active
-        projects_slack_slash_active
-        projects_slack_active
-        projects_slack_slash_commands_active
-        projects_custom_issue_tracker_active
-        projects_mattermost_active
-        projects_prometheus_active
-        projects_with_repositories_enabled
-        projects_with_error_tracking_enabled
-        projects_with_alerts_service_enabled
-        pages_domains
-        protected_branches
-        releases
-        remote_mirrors
-        snippets
-        suggestions
-        todos
-        uploads
-        web_hooks
-      ).push(*smau_keys)
-
-      count_data = subject[:counts]
-
-      expect(count_data[:boards]).to eq(1)
-      expect(count_data[:projects]).to eq(4)
-      expect(count_data.values_at(*smau_keys)).to all(be_an(Integer))
-      expect(count_data.keys).to include(*expected_keys)
-      expect(expected_keys - count_data.keys).to be_empty
-    end
-
-    it 'gathers projects data correctly', :aggregate_failures do
-      count_data = subject[:counts]
-
-      expect(count_data[:projects]).to eq(4)
-      expect(count_data[:projects_asana_active]).to eq(0)
-      expect(count_data[:projects_prometheus_active]).to eq(1)
-      expect(count_data[:projects_jira_active]).to eq(4)
-      expect(count_data[:projects_jira_server_active]).to eq(2)
-      expect(count_data[:projects_jira_cloud_active]).to eq(2)
-      expect(count_data[:projects_slack_notifications_active]).to eq(2)
-      expect(count_data[:projects_slack_slash_active]).to eq(1)
-      expect(count_data[:projects_slack_active]).to eq(2)
-      expect(count_data[:projects_slack_slash_commands_active]).to eq(1)
-      expect(count_data[:projects_custom_issue_tracker_active]).to eq(1)
-      expect(count_data[:projects_mattermost_active]).to eq(0)
-      expect(count_data[:projects_with_repositories_enabled]).to eq(3)
-      expect(count_data[:projects_with_error_tracking_enabled]).to eq(1)
-      expect(count_data[:projects_with_alerts_service_enabled]).to eq(1)
-      expect(count_data[:issues_created_from_gitlab_error_tracking_ui]).to eq(1)
-      expect(count_data[:issues_with_associated_zoom_link]).to eq(2)
-      expect(count_data[:issues_using_zoom_quick_actions]).to eq(3)
-      expect(count_data[:issues_with_embedded_grafana_charts_approx]).to eq(2)
-      expect(count_data[:incident_issues]).to eq(4)
-
-      expect(count_data[:clusters_enabled]).to eq(4)
-      expect(count_data[:project_clusters_enabled]).to eq(3)
-      expect(count_data[:group_clusters_enabled]).to eq(1)
-      expect(count_data[:clusters_disabled]).to eq(3)
-      expect(count_data[:project_clusters_disabled]).to eq(1)
-      expect(count_data[:group_clusters_disabled]).to eq(2)
-      expect(count_data[:group_clusters_enabled]).to eq(1)
-      expect(count_data[:clusters_platforms_eks]).to eq(1)
-      expect(count_data[:clusters_platforms_gke]).to eq(1)
-      expect(count_data[:clusters_platforms_user]).to eq(1)
-      expect(count_data[:clusters_applications_helm]).to eq(1)
-      expect(count_data[:clusters_applications_ingress]).to eq(1)
-      expect(count_data[:clusters_applications_cert_managers]).to eq(1)
-      expect(count_data[:clusters_applications_crossplane]).to eq(1)
-      expect(count_data[:clusters_applications_prometheus]).to eq(1)
-      expect(count_data[:clusters_applications_runner]).to eq(1)
-      expect(count_data[:clusters_applications_knative]).to eq(1)
-      expect(count_data[:clusters_applications_elastic_stack]).to eq(1)
-      expect(count_data[:grafana_integrated_projects]).to eq(2)
-      expect(count_data[:clusters_applications_jupyter]).to eq(1)
-    end
+  before do
+    allow(ActiveRecord::Base.connection).to receive(:transaction_open?).and_return(false)
+  end
+  [true, false].each do |usage_ping_batch_counter_on|
+    describe "when the feature flag usage_ping_batch_counter is set to #{usage_ping_batch_counter_on}" do
+      before do
+        stub_feature_flags(usage_ping_batch_counter: usage_ping_batch_counter_on)
+      end
 
-    it 'works when queries time out' do
-      allow_any_instance_of(ActiveRecord::Relation)
-        .to receive(:count).and_raise(ActiveRecord::StatementInvalid.new(''))
+      describe '#data' do
+        before do
+          create(:jira_service, project: projects[0])
+          create(:jira_service, :without_properties_callback, project: projects[1])
+          create(:jira_service, :jira_cloud_service, project: projects[2])
+          create(:jira_service, :without_properties_callback, project: projects[3],
+                 properties: { url: 'https://mysite.atlassian.net' })
+          create(:prometheus_service, project: projects[1])
+          create(:service, project: projects[0], type: 'SlackSlashCommandsService', active: true)
+          create(:service, project: projects[1], type: 'SlackService', active: true)
+          create(:service, project: projects[2], type: 'SlackService', active: true)
+          create(:service, project: projects[2], type: 'MattermostService', active: false)
+          create(:service, project: projects[2], type: 'MattermostService', active: true, template: true)
+          create(:service, project: projects[2], type: 'CustomIssueTrackerService', active: true)
+          create(:project_error_tracking_setting, project: projects[0])
+          create(:project_error_tracking_setting, project: projects[1], enabled: false)
+          create(:alerts_service, project: projects[0])
+          create(:alerts_service, :inactive, project: projects[1])
+          create_list(:issue, 2, project: projects[0], author: User.alert_bot)
+          create_list(:issue, 2, project: projects[1], author: User.alert_bot)
+          create_list(:issue, 4, project: projects[0])
+          create(:zoom_meeting, project: projects[0], issue: projects[0].issues[0], issue_status: :added)
+          create_list(:zoom_meeting, 2, project: projects[0], issue: projects[0].issues[1], issue_status: :removed)
+          create(:zoom_meeting, project: projects[0], issue: projects[0].issues[2], issue_status: :added)
+          create_list(:zoom_meeting, 2, project: projects[0], issue: projects[0].issues[2], issue_status: :removed)
+          create(:sentry_issue, issue: projects[0].issues[0])
+
+          # Enabled clusters
+          gcp_cluster = create(:cluster_provider_gcp, :created).cluster
+          create(:cluster_provider_aws, :created)
+          create(:cluster_platform_kubernetes)
+          create(:cluster, :group)
+
+          # Disabled clusters
+          create(:cluster, :disabled)
+          create(:cluster, :group, :disabled)
+          create(:cluster, :group, :disabled)
+
+          # Applications
+          create(:clusters_applications_helm, :installed, cluster: gcp_cluster)
+          create(:clusters_applications_ingress, :installed, cluster: gcp_cluster)
+          create(:clusters_applications_cert_manager, :installed, cluster: gcp_cluster)
+          create(:clusters_applications_prometheus, :installed, cluster: gcp_cluster)
+          create(:clusters_applications_crossplane, :installed, cluster: gcp_cluster)
+          create(:clusters_applications_runner, :installed, cluster: gcp_cluster)
+          create(:clusters_applications_knative, :installed, cluster: gcp_cluster)
+          create(:clusters_applications_elastic_stack, :installed, cluster: gcp_cluster)
+          create(:clusters_applications_jupyter, :installed, cluster: gcp_cluster)
+
+          create(:grafana_integration, project: projects[0], enabled: true)
+          create(:grafana_integration, project: projects[1], enabled: true)
+          create(:grafana_integration, project: projects[2], enabled: false)
+
+          allow(Gitlab::GrafanaEmbedUsageData).to receive(:issue_count).and_return(2)
+
+          ProjectFeature.first.update_attribute('repository_access_level', 0)
+        end
+
+        subject { described_class.data }
+
+        it 'gathers usage data', :aggregate_failures do
+          expect(subject.keys).to include(*%i(
+            active_user_count
+            counts
+            recorded_at
+            edition
+            version
+            installation_type
+            uuid
+            hostname
+            mattermost_enabled
+            signup_enabled
+            ldap_enabled
+            gravatar_enabled
+            omniauth_enabled
+            reply_by_email_enabled
+            container_registry_enabled
+            dependency_proxy_enabled
+            gitlab_shared_runners_enabled
+            gitlab_pages
+            git
+            gitaly
+            database
+            avg_cycle_analytics
+            influxdb_metrics_enabled
+            prometheus_metrics_enabled
+            web_ide_clientside_preview_enabled
+            ingress_modsecurity_enabled
+          ))
+        end
+
+        it 'gathers usage counts' do
+          smau_keys = %i(
+            snippet_create
+            snippet_update
+            snippet_comment
+            merge_request_comment
+            merge_request_create
+            commit_comment
+            wiki_pages_create
+            wiki_pages_update
+            wiki_pages_delete
+            web_ide_views
+            web_ide_commits
+            web_ide_merge_requests
+            web_ide_previews
+            navbar_searches
+            cycle_analytics_views
+            productivity_analytics_views
+            source_code_pushes
+          )
+
+          expected_keys = %i(
+            assignee_lists
+            boards
+            ci_builds
+            ci_internal_pipelines
+            ci_external_pipelines
+            ci_pipeline_config_auto_devops
+            ci_pipeline_config_repository
+            ci_runners
+            ci_triggers
+            ci_pipeline_schedules
+            auto_devops_enabled
+            auto_devops_disabled
+            deploy_keys
+            deployments
+            successful_deployments
+            failed_deployments
+            environments
+            clusters
+            clusters_enabled
+            project_clusters_enabled
+            group_clusters_enabled
+            clusters_disabled
+            project_clusters_disabled
+            group_clusters_disabled
+            clusters_platforms_eks
+            clusters_platforms_gke
+            clusters_platforms_user
+            clusters_applications_helm
+            clusters_applications_ingress
+            clusters_applications_cert_managers
+            clusters_applications_prometheus
+            clusters_applications_crossplane
+            clusters_applications_runner
+            clusters_applications_knative
+            clusters_applications_elastic_stack
+            clusters_applications_jupyter
+            in_review_folder
+            grafana_integrated_projects
+            groups
+            issues
+            issues_created_from_gitlab_error_tracking_ui
+            issues_with_associated_zoom_link
+            issues_using_zoom_quick_actions
+            issues_with_embedded_grafana_charts_approx
+            incident_issues
+            keys
+            label_lists
+            labels
+            lfs_objects
+            merge_requests
+            milestone_lists
+            milestones
+            notes
+            pool_repositories
+            projects
+            projects_imported_from_github
+            projects_asana_active
+            projects_jira_active
+            projects_jira_server_active
+            projects_jira_cloud_active
+            projects_slack_notifications_active
+            projects_slack_slash_active
+            projects_slack_active
+            projects_slack_slash_commands_active
+            projects_custom_issue_tracker_active
+            projects_mattermost_active
+            projects_prometheus_active
+            projects_with_repositories_enabled
+            projects_with_error_tracking_enabled
+            projects_with_alerts_service_enabled
+            pages_domains
+            protected_branches
+            releases
+            remote_mirrors
+            snippets
+            suggestions
+            todos
+            uploads
+            web_hooks
+          ).push(*smau_keys)
+
+          count_data = subject[:counts]
+
+          expect(count_data[:boards]).to eq(1)
+          expect(count_data[:projects]).to eq(4)
+          expect(count_data.values_at(*smau_keys)).to all(be_an(Integer))
+          expect(count_data.keys).to include(*expected_keys)
+          expect(expected_keys - count_data.keys).to be_empty
+        end
+
+        it 'gathers projects data correctly', :aggregate_failures do
+          count_data = subject[:counts]
+
+          expect(count_data[:projects]).to eq(4)
+          expect(count_data[:projects_asana_active]).to eq(0)
+          expect(count_data[:projects_prometheus_active]).to eq(1)
+          expect(count_data[:projects_jira_active]).to eq(4)
+          expect(count_data[:projects_jira_server_active]).to eq(2)
+          expect(count_data[:projects_jira_cloud_active]).to eq(2)
+          expect(count_data[:projects_slack_notifications_active]).to eq(2)
+          expect(count_data[:projects_slack_slash_active]).to eq(1)
+          expect(count_data[:projects_slack_active]).to eq(2)
+          expect(count_data[:projects_slack_slash_commands_active]).to eq(1)
+          expect(count_data[:projects_custom_issue_tracker_active]).to eq(1)
+          expect(count_data[:projects_mattermost_active]).to eq(0)
+          expect(count_data[:projects_with_repositories_enabled]).to eq(3)
+          expect(count_data[:projects_with_error_tracking_enabled]).to eq(1)
+          expect(count_data[:projects_with_alerts_service_enabled]).to eq(1)
+          expect(count_data[:issues_created_from_gitlab_error_tracking_ui]).to eq(1)
+          expect(count_data[:issues_with_associated_zoom_link]).to eq(2)
+          expect(count_data[:issues_using_zoom_quick_actions]).to eq(3)
+          expect(count_data[:issues_with_embedded_grafana_charts_approx]).to eq(2)
+          expect(count_data[:incident_issues]).to eq(4)
+
+          expect(count_data[:clusters_enabled]).to eq(4)
+          expect(count_data[:project_clusters_enabled]).to eq(3)
+          expect(count_data[:group_clusters_enabled]).to eq(1)
+          expect(count_data[:clusters_disabled]).to eq(3)
+          expect(count_data[:project_clusters_disabled]).to eq(1)
+          expect(count_data[:group_clusters_disabled]).to eq(2)
+          expect(count_data[:group_clusters_enabled]).to eq(1)
+          expect(count_data[:clusters_platforms_eks]).to eq(1)
+          expect(count_data[:clusters_platforms_gke]).to eq(1)
+          expect(count_data[:clusters_platforms_user]).to eq(1)
+          expect(count_data[:clusters_applications_helm]).to eq(1)
+          expect(count_data[:clusters_applications_ingress]).to eq(1)
+          expect(count_data[:clusters_applications_cert_managers]).to eq(1)
+          expect(count_data[:clusters_applications_crossplane]).to eq(1)
+          expect(count_data[:clusters_applications_prometheus]).to eq(1)
+          expect(count_data[:clusters_applications_runner]).to eq(1)
+          expect(count_data[:clusters_applications_knative]).to eq(1)
+          expect(count_data[:clusters_applications_elastic_stack]).to eq(1)
+          expect(count_data[:grafana_integrated_projects]).to eq(2)
+          expect(count_data[:clusters_applications_jupyter]).to eq(1)
+        end
+
+        it 'works when queries time out' do
+          allow_any_instance_of(ActiveRecord::Relation)
+            .to receive(:count).and_raise(ActiveRecord::StatementInvalid.new(''))
+
+          expect { subject }.not_to raise_error
+        end
+      end
 
-      expect { subject }.not_to raise_error
-    end
-  end
+      describe '#usage_data_counters' do
+        subject { described_class.usage_data_counters }
 
-  describe '#usage_data_counters' do
-    subject { described_class.usage_data_counters }
+        it { is_expected.to all(respond_to :totals) }
 
-    it { is_expected.to all(respond_to :totals) }
+        describe 'the results of calling #totals on all objects in the array' do
+          subject { described_class.usage_data_counters.map(&:totals) }
 
-    describe 'the results of calling #totals on all objects in the array' do
-      subject { described_class.usage_data_counters.map(&:totals) }
+          it { is_expected.to all(be_a Hash) }
+          it { is_expected.to all(have_attributes(keys: all(be_a Symbol), values: all(be_a Integer))) }
+        end
 
-      it { is_expected.to all(be_a Hash) }
-      it { is_expected.to all(have_attributes(keys: all(be_a Symbol), values: all(be_a Integer))) }
-    end
+        it 'does not have any conflicts' do
+          all_keys = subject.flat_map { |counter| counter.totals.keys }
 
-    it 'does not have any conflicts' do
-      all_keys = subject.flat_map { |counter| counter.totals.keys }
+          expect(all_keys.size).to eq all_keys.to_set.size
+        end
+      end
 
-      expect(all_keys.size).to eq all_keys.to_set.size
-    end
-  end
+      describe '#features_usage_data_ce' do
+        subject { described_class.features_usage_data_ce }
+
+        it 'gathers feature usage data', :aggregate_failures do
+          expect(subject[:mattermost_enabled]).to eq(Gitlab.config.mattermost.enabled)
+          expect(subject[:signup_enabled]).to eq(Gitlab::CurrentSettings.allow_signup?)
+          expect(subject[:ldap_enabled]).to eq(Gitlab.config.ldap.enabled)
+          expect(subject[:gravatar_enabled]).to eq(Gitlab::CurrentSettings.gravatar_enabled?)
+          expect(subject[:omniauth_enabled]).to eq(Gitlab::Auth.omniauth_enabled?)
+          expect(subject[:reply_by_email_enabled]).to eq(Gitlab::IncomingEmail.enabled?)
+          expect(subject[:container_registry_enabled]).to eq(Gitlab.config.registry.enabled)
+          expect(subject[:dependency_proxy_enabled]).to eq(Gitlab.config.dependency_proxy.enabled)
+          expect(subject[:gitlab_shared_runners_enabled]).to eq(Gitlab.config.gitlab_ci.shared_runners_enabled)
+          expect(subject[:web_ide_clientside_preview_enabled]).to eq(Gitlab::CurrentSettings.web_ide_clientside_preview_enabled?)
+        end
+      end
 
-  describe '#features_usage_data_ce' do
-    subject { described_class.features_usage_data_ce }
-
-    it 'gathers feature usage data', :aggregate_failures do
-      expect(subject[:mattermost_enabled]).to eq(Gitlab.config.mattermost.enabled)
-      expect(subject[:signup_enabled]).to eq(Gitlab::CurrentSettings.allow_signup?)
-      expect(subject[:ldap_enabled]).to eq(Gitlab.config.ldap.enabled)
-      expect(subject[:gravatar_enabled]).to eq(Gitlab::CurrentSettings.gravatar_enabled?)
-      expect(subject[:omniauth_enabled]).to eq(Gitlab::Auth.omniauth_enabled?)
-      expect(subject[:reply_by_email_enabled]).to eq(Gitlab::IncomingEmail.enabled?)
-      expect(subject[:container_registry_enabled]).to eq(Gitlab.config.registry.enabled)
-      expect(subject[:dependency_proxy_enabled]).to eq(Gitlab.config.dependency_proxy.enabled)
-      expect(subject[:gitlab_shared_runners_enabled]).to eq(Gitlab.config.gitlab_ci.shared_runners_enabled)
-      expect(subject[:web_ide_clientside_preview_enabled]).to eq(Gitlab::CurrentSettings.web_ide_clientside_preview_enabled?)
-    end
-  end
+      describe '#components_usage_data' do
+        subject { described_class.components_usage_data }
+
+        it 'gathers components usage data', :aggregate_failures do
+          expect(subject[:gitlab_pages][:enabled]).to eq(Gitlab.config.pages.enabled)
+          expect(subject[:gitlab_pages][:version]).to eq(Gitlab::Pages::VERSION)
+          expect(subject[:git][:version]).to eq(Gitlab::Git.version)
+          expect(subject[:database][:adapter]).to eq(Gitlab::Database.adapter_name)
+          expect(subject[:database][:version]).to eq(Gitlab::Database.version)
+          expect(subject[:gitaly][:version]).to be_present
+          expect(subject[:gitaly][:servers]).to be >= 1
+          expect(subject[:gitaly][:filesystems]).to be_an(Array)
+          expect(subject[:gitaly][:filesystems].first).to be_a(String)
+        end
+      end
 
-  describe '#components_usage_data' do
-    subject { described_class.components_usage_data }
-
-    it 'gathers components usage data', :aggregate_failures do
-      expect(subject[:gitlab_pages][:enabled]).to eq(Gitlab.config.pages.enabled)
-      expect(subject[:gitlab_pages][:version]).to eq(Gitlab::Pages::VERSION)
-      expect(subject[:git][:version]).to eq(Gitlab::Git.version)
-      expect(subject[:database][:adapter]).to eq(Gitlab::Database.adapter_name)
-      expect(subject[:database][:version]).to eq(Gitlab::Database.version)
-      expect(subject[:gitaly][:version]).to be_present
-      expect(subject[:gitaly][:servers]).to be >= 1
-      expect(subject[:gitaly][:filesystems]).to be_an(Array)
-      expect(subject[:gitaly][:filesystems].first).to be_a(String)
-    end
-  end
+      describe '#ingress_modsecurity_usage' do
+        subject { described_class.ingress_modsecurity_usage }
+
+        it 'gathers variable data' do
+          allow_any_instance_of(
+            ::Clusters::Applications::IngressModsecurityUsageService
+          ).to receive(:execute).and_return(
+            {
+              ingress_modsecurity_blocking: 1,
+              ingress_modsecurity_disabled: 2
+            }
+          )
+
+          expect(subject[:ingress_modsecurity_blocking]).to eq(1)
+          expect(subject[:ingress_modsecurity_disabled]).to eq(2)
+        end
+      end
 
-  describe '#ingress_modsecurity_usage' do
-    subject { described_class.ingress_modsecurity_usage }
-
-    it 'gathers variable data' do
-      allow_any_instance_of(
-        ::Clusters::Applications::IngressModsecurityUsageService
-      ).to receive(:execute).and_return(
-        {
-          ingress_modsecurity_blocking: 1,
-          ingress_modsecurity_disabled: 2
-        }
-      )
-
-      expect(subject[:ingress_modsecurity_blocking]).to eq(1)
-      expect(subject[:ingress_modsecurity_disabled]).to eq(2)
-    end
-  end
+      describe '#license_usage_data' do
+        subject { described_class.license_usage_data }
 
-  describe '#license_usage_data' do
-    subject { described_class.license_usage_data }
+        it 'gathers license data', :aggregate_failures do
+          expect(subject[:uuid]).to eq(Gitlab::CurrentSettings.uuid)
+          expect(subject[:version]).to eq(Gitlab::VERSION)
+          expect(subject[:installation_type]).to eq('gitlab-development-kit')
+          expect(subject[:active_user_count]).to eq(User.active.count)
+          expect(subject[:recorded_at]).to be_a(Time)
+        end
+      end
 
-    it 'gathers license data', :aggregate_failures do
-      expect(subject[:uuid]).to eq(Gitlab::CurrentSettings.uuid)
-      expect(subject[:version]).to eq(Gitlab::VERSION)
-      expect(subject[:installation_type]).to eq('gitlab-development-kit')
-      expect(subject[:active_user_count]).to eq(User.active.count)
-      expect(subject[:recorded_at]).to be_a(Time)
-    end
-  end
+      describe '#count' do
+        let(:relation) { double(:relation) }
 
-  describe '#count' do
-    let(:relation) { double(:relation) }
+        it 'returns the count when counting succeeds' do
+          allow(relation).to receive(:count).and_return(1)
 
-    it 'returns the count when counting succeeds' do
-      allow(relation).to receive(:count).and_return(1)
+          expect(described_class.count(relation, batch: false)).to eq(1)
+        end
 
-      expect(described_class.count(relation)).to eq(1)
-    end
+        it 'returns the fallback value when counting fails' do
+          allow(relation).to receive(:count).and_raise(ActiveRecord::StatementInvalid.new(''))
 
-    it 'returns the fallback value when counting fails' do
-      allow(relation).to receive(:count).and_raise(ActiveRecord::StatementInvalid.new(''))
+          expect(described_class.count(relation, fallback: 15, batch: false)).to eq(15)
+        end
+      end
 
-      expect(described_class.count(relation, fallback: 15)).to eq(15)
-    end
-  end
+      describe '#approximate_counts' do
+        it 'gets approximate counts for selected models', :aggregate_failures do
+          create(:label)
 
-  describe '#approximate_counts' do
-    it 'gets approximate counts for selected models', :aggregate_failures do
-      create(:label)
+          expect(Gitlab::Database::Count).to receive(:approximate_counts)
+                                               .with(described_class::APPROXIMATE_COUNT_MODELS).once.and_call_original
 
-      expect(Gitlab::Database::Count).to receive(:approximate_counts)
-                                           .with(described_class::APPROXIMATE_COUNT_MODELS).once.and_call_original
+          counts = described_class.approximate_counts.values
 
-      counts = described_class.approximate_counts.values
+          expect(counts.count).to eq(described_class::APPROXIMATE_COUNT_MODELS.count)
+          expect(counts.any? { |count| count < 0 }).to be_falsey
+        end
 
-      expect(counts.count).to eq(described_class::APPROXIMATE_COUNT_MODELS.count)
-      expect(counts.any? { |count| count < 0 }).to be_falsey
-    end
+        it 'returns default values if counts can not be retrieved', :aggregate_failures do
+          described_class::APPROXIMATE_COUNT_MODELS.map do |model|
+            model.name.underscore.pluralize.to_sym
+          end
 
-    it 'returns default values if counts can not be retrieved', :aggregate_failures do
-      described_class::APPROXIMATE_COUNT_MODELS.map do |model|
-        model.name.underscore.pluralize.to_sym
+          expect(Gitlab::Database::Count).to receive(:approximate_counts).and_return({})
+          expect(described_class.approximate_counts.values.uniq).to eq([-1])
+        end
       end
-
-      expect(Gitlab::Database::Count).to receive(:approximate_counts).and_return({})
-      expect(described_class.approximate_counts.values.uniq).to eq([-1])
     end
   end
 end