debian-mirror-gitlab/lib/gitlab/usage_data.rb

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

915 lines
45 KiB
Ruby
Raw Normal View History

2018-12-13 13:39:08 +05:30
# frozen_string_literal: true
2020-06-23 00:09:42 +05:30
# When developing usage data metrics use the below usage data interface methods
# unless you have good reasons to implement custom usage data
# See `lib/gitlab/utils/usage_data.rb`
2020-04-22 19:07:51 +05:30
#
2020-06-23 00:09:42 +05:30
# Examples
# issues_using_zoom_quick_actions: distinct_count(ZoomMeeting, :issue_id),
# active_user_count: count(User.active)
# alt_usage_data { Gitlab::VERSION }
# redis_usage_data(Gitlab::UsageDataCounters::WikiPageCounter)
2022-07-16 23:28:13 +05:30
# redis_usage_data { Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(event_names: 'users_expanding_vulnerabilities', start_date: 28.days.ago, end_date: Date.current) }
2022-01-26 12:08:38 +05:30
# NOTE:
# Implementing metrics direct in `usage_data.rb` is deprecated,
# please add new instrumentation class and use add_metric method.
# For more information, see https://docs.gitlab.com/ee/development/service_ping/metrics_instrumentation.html
2017-08-17 22:00:37 +05:30
module Gitlab
class UsageData
2021-03-11 19:13:27 +05:30
MAX_GENERATION_TIME_FOR_SAAS = 40.hours
2021-01-03 14:25:43 +05:30
CE_MEMOIZED_VALUES = %i(
issue_minimum_id
issue_maximum_id
project_minimum_id
project_maximum_id
user_minimum_id
user_maximum_id
deployment_minimum_id
deployment_maximum_id
auth_providers
2021-03-11 19:13:27 +05:30
aggregated_metrics
recorded_at
2021-01-03 14:25:43 +05:30
).freeze
2017-08-17 22:00:37 +05:30
class << self
2020-06-23 00:09:42 +05:30
include Gitlab::Utils::UsageData
include Gitlab::Utils::StrongMemoize
2021-09-04 01:27:46 +05:30
include Gitlab::Usage::TimeFrame
2020-06-23 00:09:42 +05:30
2022-04-04 11:22:00 +05:30
def data
2020-07-28 23:09:34 +05:30
clear_memoized
with_finished_at(:recording_ce_finished_at) do
2022-01-26 12:08:38 +05:30
usage_data_metrics
2020-07-28 23:09:34 +05:30
end
2017-08-17 22:00:37 +05:30
end
2018-03-17 18:26:18 +05:30
def license_usage_data
2020-04-22 19:07:51 +05:30
{
2020-06-23 00:09:42 +05:30
recorded_at: recorded_at,
2021-10-27 15:23:28 +05:30
uuid: add_metric('UuidMetric'),
hostname: add_metric('HostnameMetric'),
2020-04-22 19:07:51 +05:30
version: alt_usage_data { Gitlab::VERSION },
installation_type: alt_usage_data { installation_type },
2021-11-18 22:05:49 +05:30
active_user_count: add_metric('ActiveUserCountMetric'),
2018-03-17 18:26:18 +05:30
edition: 'CE'
}
end
2020-06-23 00:09:42 +05:30
def recorded_at
2021-03-11 19:13:27 +05:30
@recorded_at ||= Time.current
2020-06-23 00:09:42 +05:30
end
2019-12-21 20:55:43 +05:30
# rubocop: disable Metrics/AbcSize
2018-12-05 23:21:45 +05:30
# rubocop: disable CodeReuse/ActiveRecord
2017-08-17 22:00:37 +05:30
def system_usage_data
2022-07-23 23:45:48 +05:30
issues_created_manually_from_alerts = if Gitlab.com?
FALLBACK
else
count(Issue.with_alert_management_alerts.not_authored_by(::User.alert_bot), start: minimum_id(Issue), finish: maximum_id(Issue))
end
2020-05-24 23:13:21 +05:30
2022-06-21 17:19:12 +05:30
{
2017-08-17 22:00:37 +05:30
counts: {
2018-11-20 20:47:30 +05:30
assignee_lists: count(List.assignee),
ci_builds: count(::Ci::Build),
2022-07-23 23:45:48 +05:30
ci_internal_pipelines: Gitlab.com? ? FALLBACK : count(::Ci::Pipeline.internal),
2018-11-20 20:47:30 +05:30
ci_external_pipelines: count(::Ci::Pipeline.external),
ci_pipeline_config_auto_devops: count(::Ci::Pipeline.auto_devops_source),
ci_pipeline_config_repository: count(::Ci::Pipeline.repository_source),
ci_triggers: count(::Ci::Trigger),
ci_pipeline_schedules: count(::Ci::PipelineSchedule),
auto_devops_enabled: count(::ProjectAutoDevops.enabled),
auto_devops_disabled: count(::ProjectAutoDevops.disabled),
deploy_keys: count(DeployKey),
2020-10-24 23:57:45 +05:30
# rubocop: disable UsageData/LargeTable:
2020-07-28 23:09:34 +05:30
deployments: deployment_count(Deployment),
successful_deployments: deployment_count(Deployment.success),
failed_deployments: deployment_count(Deployment.failed),
2021-10-27 15:23:28 +05:30
feature_flags: count(Operations::FeatureFlag),
2020-10-24 23:57:45 +05:30
# rubocop: enable UsageData/LargeTable:
2018-11-20 20:47:30 +05:30
environments: count(::Environment),
clusters: count(::Clusters::Cluster),
clusters_enabled: count(::Clusters::Cluster.enabled),
2019-02-15 15:39:39 +05:30
project_clusters_enabled: count(::Clusters::Cluster.enabled.project_type),
group_clusters_enabled: count(::Clusters::Cluster.enabled.group_type),
2020-04-22 19:07:51 +05:30
instance_clusters_enabled: count(::Clusters::Cluster.enabled.instance_type),
2018-11-20 20:47:30 +05:30
clusters_disabled: count(::Clusters::Cluster.disabled),
2019-02-15 15:39:39 +05:30
project_clusters_disabled: count(::Clusters::Cluster.disabled.project_type),
group_clusters_disabled: count(::Clusters::Cluster.disabled.group_type),
2020-04-22 19:07:51 +05:30
instance_clusters_disabled: count(::Clusters::Cluster.disabled.instance_type),
2020-04-08 14:13:33 +05:30
clusters_platforms_eks: count(::Clusters::Cluster.aws_installed.enabled),
clusters_platforms_gke: count(::Clusters::Cluster.gcp_installed.enabled),
2018-11-20 20:47:30 +05:30
clusters_platforms_user: count(::Clusters::Cluster.user_provided.enabled),
2020-04-22 19:07:51 +05:30
clusters_management_project: count(::Clusters::Cluster.with_management_project),
2021-11-18 22:05:49 +05:30
clusters_integrations_prometheus: count(::Clusters::Integrations::Prometheus.enabled),
2020-11-24 15:15:51 +05:30
kubernetes_agents: count(::Clusters::Agent),
kubernetes_agents_with_token: distinct_count(::Clusters::AgentToken, :agent_id),
2018-11-20 20:47:30 +05:30
in_review_folder: count(::Environment.in_review_folder),
2019-12-26 22:10:19 +05:30
grafana_integrated_projects: count(GrafanaIntegration.enabled),
2018-11-20 20:47:30 +05:30
groups: count(Group),
2021-10-27 15:23:28 +05:30
issues: add_metric('CountIssuesMetric', time_frame: 'all'),
2020-01-01 13:55:28 +05:30
issues_created_from_gitlab_error_tracking_ui: count(SentryIssue),
2019-12-26 22:10:19 +05:30
issues_with_associated_zoom_link: count(ZoomMeeting.added_to_issue),
2020-04-08 14:13:33 +05:30
issues_using_zoom_quick_actions: distinct_count(ZoomMeeting, :issue_id),
2020-04-22 19:07:51 +05:30
issues_with_embedded_grafana_charts_approx: grafana_embed_usage_data,
2020-06-23 00:09:42 +05:30
issues_created_from_alerts: total_alert_issues,
issues_created_gitlab_alerts: issues_created_manually_from_alerts,
issues_created_manually_from_alerts: issues_created_manually_from_alerts,
2021-04-29 21:17:54 +05:30
incident_issues: count(::Issue.incident, start: minimum_id(Issue), finish: maximum_id(Issue)),
alert_bot_incident_issues: count(::Issue.authored(::User.alert_bot), start: minimum_id(Issue), finish: maximum_id(Issue)),
2018-11-20 20:47:30 +05:30
keys: count(Key),
label_lists: count(List.label),
lfs_objects: count(LfsObject),
milestone_lists: count(List.milestone),
milestones: count(Milestone),
2020-11-24 15:15:51 +05:30
projects_with_packages: distinct_count(::Packages::Package, :project_id),
packages: count(::Packages::Package),
2018-11-20 20:47:30 +05:30
pages_domains: count(PagesDomain),
2019-09-04 21:01:54 +05:30
pool_repositories: count(PoolRepository),
2018-11-20 20:47:30 +05:30
projects: count(Project),
2021-01-03 14:25:43 +05:30
projects_creating_incidents: distinct_count(Issue.incident, :project_id),
2018-11-20 20:47:30 +05:30
projects_imported_from_github: count(Project.where(import_type: 'github')),
2019-03-02 22:35:43 +05:30
projects_with_repositories_enabled: count(ProjectFeature.where('repository_access_level > ?', ProjectFeature::DISABLED)),
2019-07-07 11:18:12 +05:30
projects_with_error_tracking_enabled: count(::ErrorTracking::ProjectErrorTrackingSetting.where(enabled: true)),
2021-01-29 00:20:46 +05:30
projects_with_alerts_created: distinct_count(::AlertManagement::Alert, :project_id),
projects_with_enabled_alert_integrations: distinct_count(::AlertManagement::HttpIntegration.active, :project_id),
2020-06-23 00:09:42 +05:30
projects_with_terraform_reports: distinct_count(::Ci::JobArtifact.terraform_reports, :project_id),
projects_with_terraform_states: distinct_count(::Terraform::State, :project_id),
2018-11-20 20:47:30 +05:30
protected_branches: count(ProtectedBranch),
2020-10-24 23:57:45 +05:30
protected_branches_except_default: count(ProtectedBranch.where.not(name: ['main', 'master', Gitlab::CurrentSettings.default_branch_name])),
2018-11-20 20:47:30 +05:30
releases: count(Release),
remote_mirrors: count(RemoteMirror),
2020-06-23 00:09:42 +05:30
personal_snippets: count(PersonalSnippet),
project_snippets: count(ProjectSnippet),
2019-02-15 15:39:39 +05:30
suggestions: count(Suggestion),
2020-06-23 00:09:42 +05:30
terraform_reports: count(::Ci::JobArtifact.terraform_reports),
terraform_states: count(::Terraform::State),
2018-11-20 20:47:30 +05:30
todos: count(Todo),
uploads: count(Upload),
2020-04-08 14:13:33 +05:30
web_hooks: count(WebHook),
labels: count(Label),
merge_requests: count(MergeRequest),
notes: count(Note)
2019-12-21 20:55:43 +05:30
}.merge(
2021-06-08 01:23:25 +05:30
runners_usage,
2022-07-23 23:45:48 +05:30
integrations_usage,
2019-12-21 20:55:43 +05:30
usage_counters,
2020-01-01 13:55:28 +05:30
user_preferences_usage,
2020-10-24 23:57:45 +05:30
container_expiration_policies_usage,
2021-06-08 01:23:25 +05:30
service_desk_counts,
email_campaign_counts
2020-07-28 23:09:34 +05:30
).tap do |data|
2021-04-17 20:07:23 +05:30
data[:snippets] = add(data[:personal_snippets], data[:project_snippets])
2020-07-28 23:09:34 +05:30
end
2019-12-21 20:55:43 +05:30
}
2017-08-17 22:00:37 +05:30
end
2019-12-21 20:55:43 +05:30
# rubocop: enable Metrics/AbcSize
2017-08-17 22:00:37 +05:30
2021-06-08 01:23:25 +05:30
def runners_usage
{
ci_runners: count(::Ci::Runner),
ci_runners_instance_type_active: count(::Ci::Runner.instance_type.active),
ci_runners_group_type_active: count(::Ci::Runner.group_type.active),
ci_runners_project_type_active: count(::Ci::Runner.project_type.active),
ci_runners_instance_type_active_online: count(::Ci::Runner.instance_type.active.online),
ci_runners_group_type_active_online: count(::Ci::Runner.group_type.active.online),
ci_runners_project_type_active_online: count(::Ci::Runner.project_type.active.online)
}
end
2020-07-28 23:09:34 +05:30
def system_usage_data_monthly
{
counts_monthly: {
2020-10-24 23:57:45 +05:30
# rubocop: disable UsageData/LargeTable:
2021-09-04 01:27:46 +05:30
deployments: deployment_count(Deployment.where(monthly_time_range_db_params)),
successful_deployments: deployment_count(Deployment.success.where(monthly_time_range_db_params)),
failed_deployments: deployment_count(Deployment.failed.where(monthly_time_range_db_params)),
2020-10-24 23:57:45 +05:30
# rubocop: enable UsageData/LargeTable:
2021-09-04 01:27:46 +05:30
projects: count(Project.where(monthly_time_range_db_params), start: minimum_id(Project), finish: maximum_id(Project)),
packages: count(::Packages::Package.where(monthly_time_range_db_params)),
personal_snippets: count(PersonalSnippet.where(monthly_time_range_db_params)),
project_snippets: count(ProjectSnippet.where(monthly_time_range_db_params)),
2022-07-23 23:45:48 +05:30
projects_with_alerts_created: distinct_count(::AlertManagement::Alert.where(monthly_time_range_db_params), :project_id)
2021-11-18 22:05:49 +05:30
}.tap do |data|
2021-04-17 20:07:23 +05:30
data[:snippets] = add(data[:personal_snippets], data[:project_snippets])
2020-07-28 23:09:34 +05:30
end
}
end
# rubocop: enable CodeReuse/ActiveRecord
2021-01-29 00:20:46 +05:30
def system_usage_data_license
{
license: {}
}
end
def system_usage_data_settings
{
2021-02-22 17:27:13 +05:30
settings: {
2021-04-17 20:07:23 +05:30
ldap_encrypted_secrets_enabled: alt_usage_data(fallback: nil) { Gitlab::Auth::Ldap::Config.encrypted_secrets.active? },
2021-10-27 15:23:28 +05:30
smtp_encrypted_secrets_enabled: alt_usage_data(fallback: nil) { Gitlab::Email::SmtpConfig.encrypted_secrets.active? },
2021-06-08 01:23:25 +05:30
operating_system: alt_usage_data(fallback: nil) { operating_system },
2021-09-30 23:02:18 +05:30
gitaly_apdex: alt_usage_data { gitaly_apdex },
2021-11-11 11:23:49 +05:30
collected_data_categories: add_metric('CollectedDataCategoriesMetric', time_frame: 'none'),
2022-01-26 12:08:38 +05:30
service_ping_features_enabled: add_metric('ServicePingFeaturesMetric', time_frame: 'none'),
snowplow_enabled: add_metric('SnowplowEnabledMetric', time_frame: 'none'),
2022-05-07 20:08:51 +05:30
snowplow_configured_to_gitlab_collector: add_metric('SnowplowConfiguredToGitlabCollectorMetric', time_frame: 'none'),
certificate_based_clusters_ff: add_metric('CertBasedClustersFfMetric')
2021-02-22 17:27:13 +05:30
}
2021-01-29 00:20:46 +05:30
}
end
def system_usage_data_weekly
{
2021-04-17 20:07:23 +05:30
counts_weekly: {}
2021-01-29 00:20:46 +05:30
}
end
2020-04-22 19:07:51 +05:30
# rubocop:disable CodeReuse/ActiveRecord
def grafana_embed_usage_data
count(Issue.joins('JOIN grafana_integrations USING (project_id)')
.where("issues.description LIKE '%' || grafana_integrations.grafana_url || '%'")
.where(grafana_integrations: { enabled: true }))
end
# rubocop: enable CodeReuse/ActiveRecord
2018-03-17 18:26:18 +05:30
def features_usage_data
features_usage_data_ce
end
def features_usage_data_ce
{
2020-06-23 00:09:42 +05:30
instance_auto_devops_enabled: alt_usage_data(fallback: nil) { Gitlab::CurrentSettings.auto_devops_enabled? },
container_registry_enabled: alt_usage_data(fallback: nil) { Gitlab.config.registry.enabled },
2019-12-21 20:55:43 +05:30
dependency_proxy_enabled: Gitlab.config.try(:dependency_proxy)&.enabled,
2020-06-23 00:09:42 +05:30
gitlab_shared_runners_enabled: alt_usage_data(fallback: nil) { Gitlab.config.gitlab_ci.shared_runners_enabled },
gravatar_enabled: alt_usage_data(fallback: nil) { Gitlab::CurrentSettings.gravatar_enabled? },
ldap_enabled: alt_usage_data(fallback: nil) { Gitlab.config.ldap.enabled },
mattermost_enabled: alt_usage_data(fallback: nil) { Gitlab.config.mattermost.enabled },
omniauth_enabled: alt_usage_data(fallback: nil) { Gitlab::Auth.omniauth_enabled? },
2020-07-28 23:09:34 +05:30
prometheus_enabled: alt_usage_data(fallback: nil) { Gitlab::Prometheus::Internal.prometheus_enabled? },
2020-06-23 00:09:42 +05:30
prometheus_metrics_enabled: alt_usage_data(fallback: nil) { Gitlab::Metrics.prometheus_metrics_enabled? },
reply_by_email_enabled: alt_usage_data(fallback: nil) { Gitlab::IncomingEmail.enabled? },
signup_enabled: alt_usage_data(fallback: nil) { Gitlab::CurrentSettings.allow_signup? },
web_ide_clientside_preview_enabled: alt_usage_data(fallback: nil) { Gitlab::CurrentSettings.web_ide_clientside_preview_enabled? },
2021-01-03 14:25:43 +05:30
grafana_link_enabled: alt_usage_data(fallback: nil) { Gitlab::CurrentSettings.grafana_enabled? },
gitpod_enabled: alt_usage_data(fallback: nil) { Gitlab::CurrentSettings.gitpod_enabled? }
2020-05-24 23:13:21 +05:30
}
2020-04-22 19:07:51 +05:30
end
2019-10-12 21:52:04 +05:30
# @return [Hash<Symbol, Integer>]
2018-12-05 23:21:45 +05:30
def usage_counters
2020-05-24 23:13:21 +05:30
usage_data_counters.map { |counter| redis_usage_data(counter) }.reduce({}, :merge)
2019-10-12 21:52:04 +05:30
end
# @return [Array<#totals>] An array of objects that respond to `#totals`
def usage_data_counters
2021-02-22 17:27:13 +05:30
Gitlab::UsageDataCounters.counters
2018-12-05 23:21:45 +05:30
end
2018-03-17 18:26:18 +05:30
def components_usage_data
{
2020-06-23 00:09:42 +05:30
git: { version: alt_usage_data(fallback: { major: -1 }) { Gitlab::Git.version } },
2020-04-22 19:07:51 +05:30
gitaly: {
version: alt_usage_data { Gitaly::Server.all.first.server_version },
servers: alt_usage_data { Gitaly::Server.count },
2020-06-23 00:09:42 +05:30
clusters: alt_usage_data { Gitaly::Server.gitaly_clusters },
filesystems: alt_usage_data(fallback: ["-1"]) { Gitaly::Server.filesystems }
2020-04-22 19:07:51 +05:30
},
gitlab_pages: {
2020-06-23 00:09:42 +05:30
enabled: alt_usage_data(fallback: nil) { Gitlab.config.pages.enabled },
2020-04-22 19:07:51 +05:30
version: alt_usage_data { Gitlab::Pages::VERSION }
},
2020-10-24 23:57:45 +05:30
container_registry_server: {
vendor: alt_usage_data(fallback: nil) { Gitlab::CurrentSettings.container_registry_vendor },
version: alt_usage_data(fallback: nil) { Gitlab::CurrentSettings.container_registry_version }
},
2020-04-22 19:07:51 +05:30
database: {
2021-12-11 22:18:48 +05:30
# rubocop: disable UsageData/LargeTable
adapter: alt_usage_data { ApplicationRecord.database.adapter_name },
version: alt_usage_data { ApplicationRecord.database.version },
2022-03-02 08:16:31 +05:30
pg_system_id: alt_usage_data { ApplicationRecord.database.system_id },
flavor: alt_usage_data { ApplicationRecord.database.flavor }
2021-12-11 22:18:48 +05:30
# rubocop: enable UsageData/LargeTable
2020-11-24 15:15:51 +05:30
},
mail: {
smtp_server: alt_usage_data { ActionMailer::Base.smtp_settings[:address] }
2020-10-24 23:57:45 +05:30
}
2018-03-17 18:26:18 +05:30
}
2017-08-17 22:00:37 +05:30
end
2017-09-10 17:25:29 +05:30
2020-05-24 23:13:21 +05:30
def object_store_config(component)
config = alt_usage_data(fallback: nil) do
Settings[component]['object_store']
end
2022-07-16 23:28:13 +05:30
if config.present?
2020-05-24 23:13:21 +05:30
{
enabled: alt_usage_data { Settings[component]['enabled'] },
object_store: {
enabled: alt_usage_data { config['enabled'] },
direct_upload: alt_usage_data { config['direct_upload'] },
background_upload: alt_usage_data { config['background_upload'] },
provider: alt_usage_data { config['connection']['provider'] }
}
}
else
{
enabled: alt_usage_data { Settings[component]['enabled'] }
}
end
end
def object_store_usage_data
{
object_store: {
artifacts: object_store_config('artifacts'),
external_diffs: object_store_config('external_diffs'),
lfs: object_store_config('lfs'),
uploads: object_store_config('uploads'),
packages: object_store_config('packages')
}
}
end
2020-07-28 23:09:34 +05:30
def topology_usage_data
Gitlab::UsageData::Topology.new.topology_usage_data
end
2020-05-24 23:13:21 +05:30
# rubocop: disable CodeReuse/ActiveRecord
def container_expiration_policies_usage
results = {}
2021-04-29 21:17:54 +05:30
start = minimum_id(Project)
finish = maximum_id(Project)
2020-05-24 23:13:21 +05:30
results[:projects_with_expiration_policy_disabled] = distinct_count(::ContainerExpirationPolicy.where(enabled: false), :project_id, start: start, finish: finish)
2020-10-24 23:57:45 +05:30
# rubocop: disable UsageData/LargeTable
2020-05-24 23:13:21 +05:30
base = ::ContainerExpirationPolicy.active
2020-10-24 23:57:45 +05:30
# rubocop: enable UsageData/LargeTable
2020-05-24 23:13:21 +05:30
results[:projects_with_expiration_policy_enabled] = distinct_count(base, :project_id, start: start, finish: finish)
2020-10-24 23:57:45 +05:30
# rubocop: disable UsageData/LargeTable
2020-05-24 23:13:21 +05:30
%i[keep_n cadence older_than].each do |option|
::ContainerExpirationPolicy.public_send("#{option}_options").keys.each do |value| # rubocop: disable GitlabSecurity/PublicSend
results["projects_with_expiration_policy_enabled_with_#{option}_set_to_#{value}".to_sym] = distinct_count(base.where(option => value), :project_id, start: start, finish: finish)
end
end
2020-10-24 23:57:45 +05:30
# rubocop: enable UsageData/LargeTable
2020-05-24 23:13:21 +05:30
results[:projects_with_expiration_policy_enabled_with_keep_n_unset] = distinct_count(base.where(keep_n: nil), :project_id, start: start, finish: finish)
results[:projects_with_expiration_policy_enabled_with_older_than_unset] = distinct_count(base.where(older_than: nil), :project_id, start: start, finish: finish)
results
2020-01-01 13:55:28 +05:30
end
2022-07-23 23:45:48 +05:30
def integrations_usage
2020-10-24 23:57:45 +05:30
# rubocop: disable UsageData/LargeTable:
2021-09-30 23:02:18 +05:30
Integration.available_integration_names(include_dev: false).each_with_object({}) do |name, response|
2021-09-04 01:27:46 +05:30
type = Integration.integration_name_to_type(name)
response[:"projects_#{name}_active"] = count(Integration.active.where.not(project: nil).where(type: type))
response[:"groups_#{name}_active"] = count(Integration.active.where.not(group: nil).where(type: type))
response[:"instances_#{name}_active"] = count(Integration.active.where(instance: true, type: type))
response[:"projects_inheriting_#{name}_active"] = count(Integration.active.where.not(project: nil).where.not(inherit_from_id: nil).where(type: type))
response[:"groups_inheriting_#{name}_active"] = count(Integration.active.where.not(group: nil).where.not(inherit_from_id: nil).where(type: type))
2020-10-24 23:57:45 +05:30
end.merge(jira_usage, jira_import_usage)
# rubocop: enable UsageData/LargeTable:
2018-12-13 13:39:08 +05:30
end
def jira_usage
# Jira Cloud does not support custom domains as per https://jira.atlassian.com/browse/CLOUD-6999
# so we can just check for subdomains of atlassian.net
2019-12-04 20:38:33 +05:30
results = {
projects_jira_server_active: 0,
2020-11-24 15:15:51 +05:30
projects_jira_cloud_active: 0,
projects_jira_dvcs_cloud_active: count(ProjectFeatureUsage.with_jira_dvcs_integration_enabled),
projects_jira_dvcs_server_active: count(ProjectFeatureUsage.with_jira_dvcs_integration_enabled(cloud: false))
2018-12-13 13:39:08 +05:30
}
2019-12-04 20:38:33 +05:30
2021-09-30 23:02:18 +05:30
jira_integration_data_hash = jira_integration_data
results[:projects_jira_server_active] = jira_integration_data_hash[:projects_jira_server_active]
results[:projects_jira_cloud_active] = jira_integration_data_hash[:projects_jira_cloud_active]
2019-12-04 20:38:33 +05:30
results
2022-01-26 12:08:38 +05:30
rescue ActiveRecord::StatementInvalid => error
Gitlab::ErrorTracking.track_and_raise_for_dev_exception(error)
2020-10-24 23:57:45 +05:30
{ projects_jira_server_active: FALLBACK, projects_jira_cloud_active: FALLBACK }
2018-11-20 20:47:30 +05:30
end
2020-03-13 15:44:24 +05:30
# rubocop: enable CodeReuse/ActiveRecord
2018-11-20 20:47:30 +05:30
2020-05-24 23:13:21 +05:30
def jira_import_usage
2020-10-24 23:57:45 +05:30
# rubocop: disable UsageData/LargeTable
2020-05-24 23:13:21 +05:30
finished_jira_imports = JiraImportState.finished
{
jira_imports_total_imported_count: count(finished_jira_imports),
jira_imports_projects_count: distinct_count(finished_jira_imports, :project_id),
2022-07-23 23:45:48 +05:30
jira_imports_total_imported_issues_count: add_metric('JiraImportsTotalImportedIssuesCountMetric')
2020-05-24 23:13:21 +05:30
}
2020-10-24 23:57:45 +05:30
# rubocop: enable UsageData/LargeTable
2020-05-24 23:13:21 +05:30
end
2020-10-24 23:57:45 +05:30
# rubocop: disable CodeReuse/ActiveRecord
# rubocop: disable UsageData/LargeTable
def successful_deployments_with_cluster(scope)
scope
.joins(cluster: :deployments)
2020-11-24 15:15:51 +05:30
.merge(::Clusters::Cluster.enabled)
2020-10-24 23:57:45 +05:30
.merge(Deployment.success)
end
# rubocop: enable UsageData/LargeTable
# rubocop: enable CodeReuse/ActiveRecord
2021-01-03 14:25:43 +05:30
# augmented in EE
2019-03-02 22:35:43 +05:30
def user_preferences_usage
2021-01-03 14:25:43 +05:30
{
user_preferences_user_gitpod_enabled: count(UserPreference.with_user.gitpod_enabled.merge(User.active))
}
2019-03-02 22:35:43 +05:30
end
2020-07-28 23:09:34 +05:30
def merge_requests_users(time_period)
2020-11-24 15:15:51 +05:30
counter = Gitlab::UsageDataCounters::TrackUniqueEvents
redis_usage_data do
counter.count_unique_events(
event_action: Gitlab::UsageDataCounters::TrackUniqueEvents::MERGE_REQUEST_ACTION,
date_from: time_period[:created_at].first,
date_to: time_period[:created_at].last
)
end
2017-09-10 17:25:29 +05:30
end
2019-02-15 15:39:39 +05:30
2020-06-23 00:09:42 +05:30
def installation_type
if Rails.env.production?
Gitlab::INSTALLATION_TYPE
2020-04-22 19:07:51 +05:30
else
2020-06-23 00:09:42 +05:30
"gitlab-development-kit"
2020-04-22 19:07:51 +05:30
end
end
2021-04-17 20:07:23 +05:30
def operating_system
ohai_data = Ohai::System.new.tap do |oh|
oh.all_plugins(['platform'])
end.data
platform = ohai_data['platform']
platform = 'raspbian' if ohai_data['platform'] == 'debian' && /armv/.match?(ohai_data['kernel']['machine'])
"#{platform}-#{ohai_data['platform_version']}"
end
2020-07-28 23:09:34 +05:30
# Source: https://gitlab.com/gitlab-data/analytics/blob/master/transform/snowflake-dbt/data/ping_metrics_to_stage_mapping_data.csv
def usage_activity_by_stage(key = :usage_activity_by_stage, time_period = {})
{
key => {
configure: usage_activity_by_stage_configure(time_period),
create: usage_activity_by_stage_create(time_period),
2021-01-29 00:20:46 +05:30
enablement: usage_activity_by_stage_enablement(time_period),
2020-07-28 23:09:34 +05:30
manage: usage_activity_by_stage_manage(time_period),
monitor: usage_activity_by_stage_monitor(time_period),
package: usage_activity_by_stage_package(time_period),
plan: usage_activity_by_stage_plan(time_period),
release: usage_activity_by_stage_release(time_period),
secure: usage_activity_by_stage_secure(time_period),
verify: usage_activity_by_stage_verify(time_period)
}
}
end
# rubocop: disable CodeReuse/ActiveRecord
2020-10-24 23:57:45 +05:30
# rubocop: disable UsageData/LargeTable
2020-07-28 23:09:34 +05:30
def usage_activity_by_stage_configure(time_period)
{
clusters_management_project: clusters_user_distinct_count(::Clusters::Cluster.with_management_project, time_period),
clusters_disabled: clusters_user_distinct_count(::Clusters::Cluster.disabled, time_period),
clusters_enabled: clusters_user_distinct_count(::Clusters::Cluster.enabled, time_period),
clusters_platforms_gke: clusters_user_distinct_count(::Clusters::Cluster.gcp_installed.enabled, time_period),
clusters_platforms_eks: clusters_user_distinct_count(::Clusters::Cluster.aws_installed.enabled, time_period),
clusters_platforms_user: clusters_user_distinct_count(::Clusters::Cluster.user_provided.enabled, time_period),
instance_clusters_disabled: clusters_user_distinct_count(::Clusters::Cluster.disabled.instance_type, time_period),
instance_clusters_enabled: clusters_user_distinct_count(::Clusters::Cluster.enabled.instance_type, time_period),
group_clusters_disabled: clusters_user_distinct_count(::Clusters::Cluster.disabled.group_type, time_period),
group_clusters_enabled: clusters_user_distinct_count(::Clusters::Cluster.enabled.group_type, time_period),
project_clusters_disabled: clusters_user_distinct_count(::Clusters::Cluster.disabled.project_type, time_period),
project_clusters_enabled: clusters_user_distinct_count(::Clusters::Cluster.enabled.project_type, time_period)
}
end
2020-10-24 23:57:45 +05:30
# rubocop: enable UsageData/LargeTable
2020-07-28 23:09:34 +05:30
# rubocop: enable CodeReuse/ActiveRecord
# rubocop: disable CodeReuse/ActiveRecord
def usage_activity_by_stage_create(time_period)
{
deploy_keys: distinct_count(::DeployKey.where(time_period), :user_id),
keys: distinct_count(::Key.regular_keys.where(time_period), :user_id),
projects_with_disable_overriding_approvers_per_merge_request: count(::Project.where(time_period.merge(disable_overriding_approvers_per_merge_request: true))),
projects_without_disable_overriding_approvers_per_merge_request: count(::Project.where(time_period.merge(disable_overriding_approvers_per_merge_request: [false, nil]))),
remote_mirrors: distinct_count(::Project.with_remote_mirrors.where(time_period), :creator_id),
2022-03-02 08:16:31 +05:30
snippets: distinct_count(::Snippet.where(time_period), :author_id)
2020-07-28 23:09:34 +05:30
}.tap do |h|
if time_period.present?
h[:merge_requests_users] = merge_requests_users(time_period)
h.merge!(action_monthly_active_users(time_period))
end
end
end
# rubocop: enable CodeReuse/ActiveRecord
2021-01-29 00:20:46 +05:30
# Empty placeholder allows this to match the pattern used by other sections
def usage_activity_by_stage_enablement(time_period)
{}
end
2020-07-28 23:09:34 +05:30
# Omitted because no user, creator or author associated: `campaigns_imported_from_github`, `ldap_group_links`
# rubocop: disable CodeReuse/ActiveRecord
def usage_activity_by_stage_manage(time_period)
{
2021-12-11 22:18:48 +05:30
# rubocop: disable UsageData/LargeTable
events: stage_manage_events(time_period),
2020-07-28 23:09:34 +05:30
groups: distinct_count(::GroupMember.where(time_period), :user_id),
2021-04-29 21:17:54 +05:30
users_created: count(::User.where(time_period), start: minimum_id(User), finish: maximum_id(User)),
2020-11-24 15:15:51 +05:30
omniauth_providers: filtered_omniauth_provider_names.reject { |name| name == 'group_saml' },
2021-01-03 14:25:43 +05:30
user_auth_by_provider: distinct_count_user_auth_by_provider(time_period),
2021-03-11 19:13:27 +05:30
unique_users_all_imports: unique_users_all_imports(time_period),
2021-01-29 00:20:46 +05:30
bulk_imports: {
2021-06-08 01:23:25 +05:30
gitlab_v1: count(::BulkImport.where(**time_period, source_type: :gitlab))
2021-01-29 00:20:46 +05:30
},
2021-03-11 19:13:27 +05:30
project_imports: project_imports(time_period),
issue_imports: issue_imports(time_period),
2022-03-02 08:16:31 +05:30
group_imports: group_imports(time_period)
2020-07-28 23:09:34 +05:30
}
end
# rubocop: enable CodeReuse/ActiveRecord
# rubocop: disable CodeReuse/ActiveRecord
def usage_activity_by_stage_monitor(time_period)
2021-04-17 20:07:23 +05:30
# Calculate histogram only for overall as other time periods aren't available/useful here.
integrations_histogram = time_period.empty? ? histogram(::AlertManagement::HttpIntegration.active, :project_id, buckets: 1..100) : nil
2020-07-28 23:09:34 +05:30
{
clusters: distinct_count(::Clusters::Cluster.where(time_period), :user_id),
2021-11-18 22:05:49 +05:30
clusters_integrations_prometheus: cluster_integrations_user_distinct_count(::Clusters::Integrations::Prometheus, time_period),
2020-07-28 23:09:34 +05:30
operations_dashboard_default_dashboard: count(::User.active.with_dashboard('operations').where(time_period),
2021-04-29 21:17:54 +05:30
start: minimum_id(User),
finish: maximum_id(User)),
2021-01-29 00:20:46 +05:30
projects_with_error_tracking_enabled: distinct_count(::Project.with_enabled_error_tracking.where(time_period), :creator_id),
projects_with_incidents: distinct_count(::Issue.incident.where(time_period), :project_id),
2021-04-17 20:07:23 +05:30
projects_with_alert_incidents: distinct_count(::Issue.incident.with_alert_management_alerts.where(time_period), :project_id),
projects_with_enabled_alert_integrations_histogram: integrations_histogram
}.compact
2020-07-28 23:09:34 +05:30
end
# rubocop: enable CodeReuse/ActiveRecord
2020-11-24 15:15:51 +05:30
# rubocop: disable CodeReuse/ActiveRecord
2020-07-28 23:09:34 +05:30
def usage_activity_by_stage_package(time_period)
2020-11-24 15:15:51 +05:30
{
projects_with_packages: distinct_count(::Project.with_packages.where(time_period), :creator_id)
}
2020-07-28 23:09:34 +05:30
end
2020-11-24 15:15:51 +05:30
# rubocop: enable CodeReuse/ActiveRecord
2020-07-28 23:09:34 +05:30
# Omitted because no user, creator or author associated: `boards`, `labels`, `milestones`, `uploads`
# Omitted because too expensive: `epics_deepest_relationship_level`
# Omitted because of encrypted properties: `projects_jira_cloud_active`, `projects_jira_server_active`
# rubocop: disable CodeReuse/ActiveRecord
def usage_activity_by_stage_plan(time_period)
2021-11-18 22:05:49 +05:30
time_frame = metric_time_period(time_period)
2020-07-28 23:09:34 +05:30
{
2021-10-27 15:23:28 +05:30
issues: add_metric('CountUsersCreatingIssuesMetric', time_frame: time_frame),
2020-07-28 23:09:34 +05:30
notes: distinct_count(::Note.where(time_period), :author_id),
projects: distinct_count(::Project.where(time_period), :creator_id),
2020-10-24 23:57:45 +05:30
todos: distinct_count(::Todo.where(time_period), :author_id),
service_desk_enabled_projects: distinct_count_service_desk_enabled_projects(time_period),
2020-11-24 15:15:51 +05:30
service_desk_issues: count(::Issue.service_desk.where(time_period)),
2021-12-11 22:18:48 +05:30
projects_jira_active: distinct_count(::Project.with_active_integration(::Integrations::Jira).where(time_period), :creator_id),
projects_jira_dvcs_cloud_active: distinct_count(::Project.with_active_integration(::Integrations::Jira).with_jira_dvcs_cloud.where(time_period), :creator_id),
projects_jira_dvcs_server_active: distinct_count(::Project.with_active_integration(::Integrations::Jira).with_jira_dvcs_server.where(time_period), :creator_id)
2020-07-28 23:09:34 +05:30
}
end
# rubocop: enable CodeReuse/ActiveRecord
# Omitted because no user, creator or author associated: `environments`, `feature_flags`, `in_review_folder`, `pages_domains`
# rubocop: disable CodeReuse/ActiveRecord
def usage_activity_by_stage_release(time_period)
2021-11-18 22:05:49 +05:30
time_frame = metric_time_period(time_period)
2020-07-28 23:09:34 +05:30
{
deployments: distinct_count(::Deployment.where(time_period), :user_id),
failed_deployments: distinct_count(::Deployment.failed.where(time_period), :user_id),
releases: distinct_count(::Release.where(time_period), :author_id),
2021-11-18 22:05:49 +05:30
successful_deployments: distinct_count(::Deployment.success.where(time_period), :user_id),
releases_with_milestones: add_metric('CountUsersAssociatingMilestonesToReleasesMetric', time_frame: time_frame)
2020-07-28 23:09:34 +05:30
}
end
# rubocop: enable CodeReuse/ActiveRecord
# Omitted because no user, creator or author associated: `ci_runners`
# rubocop: disable CodeReuse/ActiveRecord
def usage_activity_by_stage_verify(time_period)
{
ci_builds: distinct_count(::Ci::Build.where(time_period), :user_id),
2021-04-29 21:17:54 +05:30
ci_external_pipelines: distinct_count(::Ci::Pipeline.external.where(time_period), :user_id, start: minimum_id(User), finish: maximum_id(User)),
ci_internal_pipelines: distinct_count(::Ci::Pipeline.internal.where(time_period), :user_id, start: minimum_id(User), finish: maximum_id(User)),
ci_pipeline_config_auto_devops: distinct_count(::Ci::Pipeline.auto_devops_source.where(time_period), :user_id, start: minimum_id(User), finish: maximum_id(User)),
ci_pipeline_config_repository: distinct_count(::Ci::Pipeline.repository_source.where(time_period), :user_id, start: minimum_id(User), finish: maximum_id(User)),
2020-07-28 23:09:34 +05:30
ci_pipeline_schedules: distinct_count(::Ci::PipelineSchedule.where(time_period), :owner_id),
2021-04-29 21:17:54 +05:30
ci_pipelines: distinct_count(::Ci::Pipeline.where(time_period), :user_id, start: minimum_id(User), finish: maximum_id(User)),
2021-11-18 22:05:49 +05:30
ci_triggers: distinct_count(::Ci::Trigger.where(time_period), :owner_id)
2020-07-28 23:09:34 +05:30
}
end
# rubocop: enable CodeReuse/ActiveRecord
# Currently too complicated and to get reliable counts for these stats:
# container_scanning_jobs, dast_jobs, dependency_scanning_jobs, license_management_jobs, sast_jobs, secret_detection_jobs
# Once https://gitlab.com/gitlab-org/gitlab/merge_requests/17568 is merged, this might be doable
def usage_activity_by_stage_secure(time_period)
{}
end
2020-11-24 15:15:51 +05:30
def redis_hll_counters
{ redis_hll_counters: ::Gitlab::UsageDataCounters::HLLRedisCounter.unique_events_data }
end
2021-04-17 20:07:23 +05:30
def aggregated_metrics_data
2021-01-29 00:20:46 +05:30
{
2021-04-17 20:07:23 +05:30
counts_weekly: { aggregated_metrics: aggregated_metrics.weekly_data },
counts_monthly: { aggregated_metrics: aggregated_metrics.monthly_data },
counts: aggregated_metrics
.all_time_data
.to_h { |key, value| ["aggregate_#{key}".to_sym, value.round] }
2021-01-29 00:20:46 +05:30
}
end
2020-10-24 23:57:45 +05:30
def action_monthly_active_users(time_period)
2020-11-24 15:15:51 +05:30
date_range = { date_from: time_period[:created_at].first, date_to: time_period[:created_at].last }
2020-07-28 23:09:34 +05:30
2020-11-24 15:15:51 +05:30
event_monthly_active_users(date_range)
.merge!(ide_monthly_active_users(date_range))
end
2020-07-28 23:09:34 +05:30
2022-07-16 23:28:13 +05:30
def with_duration
result = nil
duration = Benchmark.realtime do
result = yield
end
::Gitlab::Usage::ServicePing::LegacyMetricTimingDecorator.new(result, duration)
end
2020-11-24 15:15:51 +05:30
private
2020-07-28 23:09:34 +05:30
2021-12-11 22:18:48 +05:30
def stage_manage_events(time_period)
if time_period.empty?
Gitlab::Utils::UsageData::FALLBACK
else
# rubocop: disable CodeReuse/ActiveRecord
# rubocop: disable UsageData/LargeTable
start = ::Event.where(time_period).select(:id).order(created_at: :asc).first&.id
2022-01-26 12:08:38 +05:30
finish = ::Event.where(time_period).select(:id).order(created_at: :desc).first&.id
2021-12-11 22:18:48 +05:30
estimate_batch_distinct_count(::Event.where(time_period), :author_id, start: start, finish: finish)
# rubocop: enable UsageData/LargeTable
# rubocop: enable CodeReuse/ActiveRecord
end
end
def usage_data_metrics
license_usage_data
.merge(system_usage_data_license)
.merge(system_usage_data_settings)
.merge(system_usage_data)
.merge(system_usage_data_monthly)
.merge(system_usage_data_weekly)
.merge(features_usage_data)
.merge(components_usage_data)
.merge(object_store_usage_data)
.merge(topology_usage_data)
.merge(usage_activity_by_stage)
.merge(usage_activity_by_stage(:usage_activity_by_stage_monthly, monthly_time_range_db_params))
.merge(redis_hll_counters)
.deep_merge(aggregated_metrics_data)
end
2021-11-18 22:05:49 +05:30
def metric_time_period(time_period)
time_period.present? ? '28d' : 'none'
end
2021-06-08 01:23:25 +05:30
def gitaly_apdex
with_prometheus_client(verify: false, fallback: FALLBACK) do |client|
result = client.query('avg_over_time(gitlab_usage_ping:gitaly_apdex:ratio_avg_over_time_5m[1w])').first
break FALLBACK unless result
result['value'].last.to_f
end
end
2021-03-11 19:13:27 +05:30
def aggregated_metrics
@aggregated_metrics ||= ::Gitlab::Usage::Metrics::Aggregates::Aggregate.new(recorded_at)
end
2020-11-24 15:15:51 +05:30
def event_monthly_active_users(date_range)
data = {
action_monthly_active_users_project_repo: Gitlab::UsageDataCounters::TrackUniqueEvents::PUSH_ACTION,
action_monthly_active_users_design_management: Gitlab::UsageDataCounters::TrackUniqueEvents::DESIGN_ACTION,
2021-01-29 00:20:46 +05:30
action_monthly_active_users_wiki_repo: Gitlab::UsageDataCounters::TrackUniqueEvents::WIKI_ACTION,
action_monthly_active_users_git_write: Gitlab::UsageDataCounters::TrackUniqueEvents::GIT_WRITE_ACTION
2020-11-24 15:15:51 +05:30
}
data.each do |key, event|
data[key] = redis_usage_data { Gitlab::UsageDataCounters::TrackUniqueEvents.count_unique_events(event_action: event, **date_range) }
2020-07-28 23:09:34 +05:30
end
2020-11-24 15:15:51 +05:30
end
def ide_monthly_active_users(date_range)
counter = Gitlab::UsageDataCounters::EditorUniqueCounter
2020-07-28 23:09:34 +05:30
{
2021-01-03 14:25:43 +05:30
action_monthly_active_users_web_ide_edit: redis_usage_data { counter.count_web_ide_edit_actions(**date_range) },
action_monthly_active_users_sfe_edit: redis_usage_data { counter.count_sfe_edit_actions(**date_range) },
action_monthly_active_users_snippet_editor_edit: redis_usage_data { counter.count_snippet_editor_edit_actions(**date_range) },
action_monthly_active_users_ide_edit: redis_usage_data { counter.count_edit_using_editor(**date_range) }
2020-07-28 23:09:34 +05:30
}
end
2020-10-24 23:57:45 +05:30
def distinct_count_service_desk_enabled_projects(time_period)
2021-04-29 21:17:54 +05:30
project_creator_id_start = minimum_id(User)
project_creator_id_finish = maximum_id(User)
2020-10-24 23:57:45 +05:30
distinct_count(::Project.service_desk_enabled.where(time_period), :creator_id, start: project_creator_id_start, finish: project_creator_id_finish) # rubocop: disable CodeReuse/ActiveRecord
end
# rubocop: disable CodeReuse/ActiveRecord
def service_desk_counts
# rubocop: disable UsageData/LargeTable:
projects_with_service_desk = ::Project.where(service_desk_enabled: true)
# rubocop: enable UsageData/LargeTable:
{
service_desk_enabled_projects: count(projects_with_service_desk),
service_desk_issues: count(
::Issue.where(
project: projects_with_service_desk,
author: ::User.support_bot,
confidential: true
)
)
}
end
# rubocop: enable CodeReuse/ActiveRecord
2021-06-08 01:23:25 +05:30
# rubocop: disable CodeReuse/ActiveRecord
def email_campaign_counts
# rubocop:disable UsageData/LargeTable
sent_emails = count(Users::InProductMarketingEmail.group(:track, :series))
clicked_emails = count(Users::InProductMarketingEmail.where.not(cta_clicked_at: nil).group(:track, :series))
2022-06-21 17:19:12 +05:30
Users::InProductMarketingEmail::ACTIVE_TRACKS.keys.each_with_object({}) do |track, result|
series_amount = Namespaces::InProductMarketingEmailsService.email_count_for_track(track)
2021-06-08 01:23:25 +05:30
# rubocop: enable UsageData/LargeTable:
2021-12-11 22:18:48 +05:30
2021-06-08 01:23:25 +05:30
0.upto(series_amount - 1).map do |series|
2022-07-23 23:45:48 +05:30
sent_count = sent_in_product_marketing_email_count(sent_emails, track, series)
clicked_count = clicked_in_product_marketing_email_count(clicked_emails, track, series)
2021-06-08 01:23:25 +05:30
result["in_product_marketing_email_#{track}_#{series}_sent"] = sent_count
2021-09-04 01:27:46 +05:30
result["in_product_marketing_email_#{track}_#{series}_cta_clicked"] = clicked_count unless track == 'experience'
2021-06-08 01:23:25 +05:30
end
end
end
# rubocop: enable CodeReuse/ActiveRecord
2022-07-23 23:45:48 +05:30
def sent_in_product_marketing_email_count(sent_emails, track, series)
# When there is an error with the query and it's not the Hash we expect, we return what we got from `count`.
sent_emails.is_a?(Hash) ? sent_emails.fetch([track, series], 0) : sent_emails
end
def clicked_in_product_marketing_email_count(clicked_emails, track, series)
# When there is an error with the query and it's not the Hash we expect, we return what we got from `count`.
clicked_emails.is_a?(Hash) ? clicked_emails.fetch([track, series], 0) : clicked_emails
2020-07-28 23:09:34 +05:30
end
2020-06-23 00:09:42 +05:30
def total_alert_issues
# Remove prometheus table queries once they are deprecated
# To be removed with https://gitlab.com/gitlab-org/gitlab/-/issues/217407.
2022-07-23 23:45:48 +05:30
add_metric('IssuesCreatedFromAlertsMetric')
2020-11-24 15:15:51 +05:30
end
2020-07-28 23:09:34 +05:30
def clear_memoized
2021-01-03 14:25:43 +05:30
CE_MEMOIZED_VALUES.each { |v| clear_memoization(v) }
2020-07-28 23:09:34 +05:30
end
# rubocop: disable CodeReuse/ActiveRecord
2021-11-18 22:05:49 +05:30
def cluster_integrations_user_distinct_count(integrations, time_period)
distinct_count(integrations.where(time_period).enabled.joins(:cluster), 'clusters.user_id')
2020-07-28 23:09:34 +05:30
end
def clusters_user_distinct_count(clusters, time_period)
distinct_count(clusters.where(time_period), :user_id)
end
# rubocop: enable CodeReuse/ActiveRecord
def omniauth_provider_names
::Gitlab.config.omniauth.providers.map(&:name)
end
# LDAP provider names are set by customers and could include
# sensitive info (server names, etc). LDAP providers normally
# don't appear in omniauth providers but filter to ensure
# no internal details leak via usage ping.
def filtered_omniauth_provider_names
omniauth_provider_names.reject { |name| name.starts_with?('ldap') }
end
def deployment_count(relation)
2021-04-29 21:17:54 +05:30
count relation, start: minimum_id(Deployment), finish: maximum_id(Deployment)
2020-06-23 00:09:42 +05:30
end
2020-11-24 15:15:51 +05:30
2021-03-11 19:13:27 +05:30
def project_imports(time_period)
2022-07-16 23:28:13 +05:30
time_frame = metric_time_period(time_period)
2021-09-04 01:27:46 +05:30
counters = {
2022-07-16 23:28:13 +05:30
gitlab_project: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'gitlab_project' }),
gitlab: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'gitlab' }),
github: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'github' }),
bitbucket: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'bitbucket' }),
bitbucket_server: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'bitbucket_server' }),
gitea: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'gitea' }),
git: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'git' }),
manifest: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'manifest' }),
gitlab_migration: add_metric('CountBulkImportsEntitiesMetric', time_frame: time_frame, options: { source_type: :project_entity })
2021-03-11 19:13:27 +05:30
}
2021-09-04 01:27:46 +05:30
2022-07-23 23:45:48 +05:30
counters[:total] = add_metric('CountImportedProjectsTotalMetric', time_frame: time_frame)
2021-09-04 01:27:46 +05:30
counters
2021-03-11 19:13:27 +05:30
end
def issue_imports(time_period)
2022-07-16 23:28:13 +05:30
time_frame = metric_time_period(time_period)
2021-03-11 19:13:27 +05:30
{
jira: count(::JiraImportState.where(time_period)), # rubocop: disable CodeReuse/ActiveRecord
2022-07-16 23:28:13 +05:30
fogbugz: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'fogbugz' }),
phabricator: add_metric('CountImportedProjectsMetric', time_frame: time_frame, options: { import_type: 'phabricator' }),
2021-11-11 11:23:49 +05:30
csv: count(::Issues::CsvImport.where(time_period)) # rubocop: disable CodeReuse/ActiveRecord
2021-03-11 19:13:27 +05:30
}
end
def group_imports(time_period)
2022-07-16 23:28:13 +05:30
time_frame = metric_time_period(time_period)
2021-03-11 19:13:27 +05:30
{
group_import: count(::GroupImportState.where(time_period)), # rubocop: disable CodeReuse/ActiveRecord
2022-07-16 23:28:13 +05:30
gitlab_migration: add_metric('CountBulkImportsEntitiesMetric', time_frame: time_frame, options: { source_type: :group_entity })
2021-03-11 19:13:27 +05:30
}
end
# rubocop:disable CodeReuse/ActiveRecord
def unique_users_all_imports(time_period)
project_imports = distinct_count(::Project.where(time_period).where.not(import_type: nil), :creator_id)
bulk_imports = distinct_count(::BulkImport.where(time_period), :user_id)
jira_issue_imports = distinct_count(::JiraImportState.where(time_period), :user_id)
2021-11-11 11:23:49 +05:30
csv_issue_imports = distinct_count(::Issues::CsvImport.where(time_period), :user_id)
2021-03-11 19:13:27 +05:30
group_imports = distinct_count(::GroupImportState.where(time_period), :user_id)
2021-04-17 20:07:23 +05:30
add(project_imports, bulk_imports, jira_issue_imports, csv_issue_imports, group_imports)
2020-11-24 15:15:51 +05:30
end
2021-03-11 19:13:27 +05:30
# rubocop:enable CodeReuse/ActiveRecord
2021-01-03 14:25:43 +05:30
# rubocop:disable CodeReuse/ActiveRecord
def distinct_count_user_auth_by_provider(time_period)
counts = auth_providers_except_ldap.each_with_object({}) do |provider, hash|
hash[provider] = distinct_count(
::AuthenticationEvent.success.for_provider(provider).where(time_period), :user_id)
end
if any_ldap_auth_providers?
counts['ldap'] = distinct_count(
::AuthenticationEvent.success.ldap.where(time_period), :user_id
)
end
counts
end
# rubocop:enable CodeReuse/ActiveRecord
# rubocop:disable UsageData/LargeTable
def auth_providers
strong_memoize(:auth_providers) do
::AuthenticationEvent.providers
end
end
# rubocop:enable UsageData/LargeTable
def auth_providers_except_ldap
auth_providers.reject { |provider| provider.starts_with?('ldap') }
end
def any_ldap_auth_providers?
auth_providers.any? { |provider| provider.starts_with?('ldap') }
end
2017-08-17 22:00:37 +05:30
end
end
end
2019-12-04 20:38:33 +05:30
2021-06-08 01:23:25 +05:30
Gitlab::UsageData.prepend_mod_with('Gitlab::UsageData')