Service Ping Guide (FREE SELF)

Introduced in GitLab Ultimate 11.2, more statistics.

This guide describes Service Ping's purpose and how it's implemented.

For more information about Product Intelligence, see:

More links:

What is Service Ping?

Service Ping is a process in GitLab that collects and sends a weekly payload to GitLab Inc. The payload provides important high-level data that helps our product, support, and sales teams understand how GitLab is used. For example, the data helps to:

  • Compare counts month over month (or week over week) to get a rough sense for how an instance uses different product features.
  • Collect other facts that help us classify and understand GitLab installations.
  • Calculate our Stage Monthly Active Users (SMAU), which helps to measure the success of our stages and features.

Service Ping information is not anonymous. It's linked to the instance's hostname. However, it does not contain project names, usernames, or any other specific data.

Sending a Service Ping payload is optional and can be disabled on any self-managed instance. When Service Ping is enabled, GitLab gathers data from the other instances and can show your instance's usage statistics to your users.


We use the following terminology to describe the Service Ping components:

  • Service Ping: the process that collects and generates a JSON payload.
  • Service Data: the contents of the Service Ping JSON payload. This includes metrics.
  • Metrics: primarily made up of row counts for different tables in an instance's database. Each metric has a corresponding metric definition in a YAML file.

Why should we enable Service Ping?

  • The main purpose of Service Ping is to build a better GitLab. Data about how GitLab is used is collected to better understand feature/stage adoption and usage, which helps us understand how GitLab is adding value and helps our team better understand the reasons why people use GitLab and with this knowledge we're able to make better product decisions.
  • As a benefit of having Service Ping active, GitLab lets you analyze the users' activities over time of your GitLab installation.
  • As a benefit of having Service Ping active, GitLab provides you with The DevOps Report,which gives you an overview of your entire instance's adoption of Concurrent DevOps from planning to monitoring.
  • You get better, more proactive support. (assuming that our TAMs and support organization used the data to deliver more value)
  • You get insight and advice into how to get the most value out of your investment in GitLab. Wouldn't you want to know that a number of features or values are not being adopted in your organization?
  • You get a report that illustrates how you compare against other similar organizations (anonymized), with specific advice and recommendations on how to improve your DevOps processes.
  • Service Ping is enabled by default. To disable it, see Disable Service Ping.
  • When Service Ping is enabled, you have the option to participate in our Registration Features Program and receive free paid features.

Registration Features Program

Introduced in GitLab 14.1.

Starting with GitLab version 14.1, free self-managed users running GitLab EE can receive paid features by registering with GitLab and sending us activity data via Service Ping.

The paid feature available in this offering is Email from GitLab. Administrators can use this Premium feature to streamline their workflow by emailing all or some instance users directly from the Admin Area.

NOTE: Registration is not yet required for participation, but will be added in a future milestone.


  • Service Ping does not track frontend events things like page views, link clicks, or user sessions, and only focuses on aggregated backend events.
  • Because of these limitations we recommend instrumenting your products with Snowplow for more detailed analytics on and use Service Ping to track aggregated backend events on self-managed.

View the Service Ping payload (FREE SELF)

You can view the exact JSON payload sent to GitLab Inc. in the administration panel. To view the payload:

  1. Sign in as a user with Administrator permissions.
  2. On the top bar, select Menu > {admin} Admin.
  3. On the left sidebar, select Settings > Metrics and profiling.
  4. Expand the Usage statistics section.
  5. Select Preview payload.

For an example payload, see Example Service Ping payload.

Disable Service Ping (FREE SELF)

NOTE: The method to disable Service Ping in the GitLab configuration file does not work in GitLab versions 9.3 to 13.12.3. See the troubleshooting section on how to disable it.

You can disable Service Ping either using the GitLab UI, or editing the GitLab configuration file.

Disable Service Ping using the UI

To disable Service Ping in the GitLab UI:

  1. Sign in as a user with Administrator permissions.
  2. On the top bar, select Menu > {admin} Admin.
  3. On the left sidebar, select Settings > Metrics and profiling.
  4. Expand the Usage statistics section.
  5. Clear the Enable service ping checkbox.
  6. Select Save changes.

Disable Service Ping using the configuration file

To disable Service Ping and prevent it from being configured in the future through the admin area:

For installations using the Linux package:

  1. Edit /etc/gitlab/gitlab.rb:

    gitlab_rails['usage_ping_enabled'] = false
  2. Reconfigure GitLab:

    sudo gitlab-ctl reconfigure

For installations from source:

  1. Edit /home/git/gitlab/config/gitlab.yml:

    production: &base
      # ...
        # ...
        usage_ping_enabled: false
  2. Restart GitLab:

    sudo service gitlab restart

Service Ping request flow

The following example shows a basic request/response flow between a GitLab instance, the Versions Application, the License Application, Salesforce, the GitLab S3 Bucket, the GitLab Snowflake Data Warehouse, and Sisense:

    participant GitLab Instance
    participant Versions Application
    participant Licenses Application
    participant Salesforce
    participant S3 Bucket
    participant Snowflake DW
    participant Sisense Dashboards
    GitLab Instance->>Versions Application: Send Service Ping
    loop Process usage data
        Versions Application->>Versions Application: Parse usage data
        Versions Application->>Versions Application: Write to database
        Versions Application->>Versions Application: Update license ping time
    loop Process data for Salesforce
        Versions Application-xLicenses Application: Request Zuora subscription id
        Licenses Application-xVersions Application: Zuora subscription id
        Versions Application-xSalesforce: Request Zuora account id  by Zuora subscription id
        Salesforce-xVersions Application: Zuora account id
        Versions Application-xSalesforce: Usage data for the Zuora account
    Versions Application->>S3 Bucket: Export Versions database
    S3 Bucket->>Snowflake DW: Import data
    Snowflake DW->>Snowflake DW: Transform data using dbt
    Snowflake DW->>Sisense Dashboards: Data available for querying
    Versions Application->>GitLab Instance: DevOps Report (Conversational Development Index)

How Service Ping works

  1. The Service Ping cron job is set in Sidekiq to run weekly.
  2. When the cron job runs, it calls Gitlab::UsageData.to_json.
  3. Gitlab::UsageData.to_json cascades down to ~400+ other counter method calls.
  4. The response of all methods calls are merged together into a single JSON payload in Gitlab::UsageData.to_json.
  5. The JSON payload is then posted to the Versions application If a firewall exception is needed, the required URL depends on several things. If the hostname is, the protocol is TCP, and the port number is 443, the required URL is

Service Ping Metric Life cycle

1. New metrics addition

Please follow the Implementing Service Ping guide.

2. Existing metric change

Because we do not control when customers update their self-managed instances of GitLab, we STRONGLY DISCOURAGE changes to the logic used to calculate any metric. Any such changes lead to inconsistent reports from multiple GitLab instances. If there is a problem with an existing metric, it's best to deprecate the existing metric, and use it, side by side, with the desired new metric.

Example: Consider following change. Before GitLab 12.6, the example_metric was implemented as:

  example_metric: distinct_count(Project, :creator_id)

For GitLab 12.6, the metric was changed to filter out archived projects:

  example_metric: distinct_count(Project.non_archived, :creator_id)

In this scenario all instances running up to GitLab 12.5 continue to report example_metric, including all archived projects, while all instances running GitLab 12.6 and higher filters out such projects. As Service Ping data is collected from all reporting instances, the resulting dataset includes mixed data, which distorts any following business analysis.

The correct approach is to add a new metric for GitLab 12.6 release with updated logic:

  example_metric_without_archived: distinct_count(Project.non_archived, :creator_id)

and update existing business analysis artefacts to use example_metric_without_archived instead of example_metric

3. Deprecate a metric

If a metric is obsolete and you no longer use it, you can mark it as deprecated.

For an example of the metric deprecation process take a look at this example merge request

To deprecate a metric:

  1. Check the following YAML files and verify the metric is not used in an aggregate:

  2. Create an issue in the GitLab Data Team project. Ask for confirmation that the metric is not used by other teams, or in any of the SiSense dashboards.

  3. Verify the metric is not used to calculate the conversational index. The conversational index is a measure that reports back to self-managed instances to inform administrators of the progress of DevOps adoption for the instance.

    You can check CalculateConvIndexService to view the metrics that are used. The metrics are represented as the keys that are passed as a field argument into the get_value method.

  4. Document the deprecation in the metric's YAML definition. Set the status: attribute to deprecated, for example:

    key_path: analytics_unique_visits.analytics_unique_visits_for_any_target_monthly
    description: Visits to any of the pages listed above per month
    product_section: dev
    product_stage: manage
    product_group: group::analytics
    value_type: number
    status: deprecated
    time_frame: 28d
    - ce
    - free
  5. Replace the metric's instrumentation with a fixed value. This avoids wasting resources to calculate the deprecated metric. In lib/gitlab/usage_data.rb or ee/lib/ee/gitlab/usage_data.rb, replace the code that calculates the metric's value with a fixed value that indicates it's deprecated:

    module Gitlab
      class UsageData
        DEPRECATED_VALUE = -1000
        def analytics_unique_visits_data
          results['analytics_unique_visits_for_any_target'] = redis_usage_data { unique_visit_service.unique_visits_for(targets: :analytics) }
          results['analytics_unique_visits_for_any_target_monthly'] = DEPRECATED_VALUE
          { analytics_unique_visits: results }
      # ...
  6. Update the Metrics Dictionary following guidelines instructions.

4. Remove a metric

Only deprecated metrics can be removed from Service Ping.

For an example of the metric removal process take a look at this example issue

To remove a deprecated metric:

  1. Verify that removing the metric from the Service Ping payload does not cause errors in Version App when the updated payload is collected and processed. Version App collects and persists all Service Ping reports. To do that you can modify fixtures used to test UsageDataController#create endpoint, and assure that test suite does not fail when metric that you wish to remove is not included into test payload.

  2. Create an issue in the GitLab Data Team project. Ask for confirmation that the metric is not referred to in any SiSense dashboards and can be safely removed from Service Ping. Use this example issue for guidance. This step can be skipped if verification done during deprecation process reported that metric is not required by any data transformation in Snowflake data warehouse nor it is used by any of SiSense dashboards.

  3. After you verify the metric can be safely removed, update the attributes of the metric's YAML definition:

    • Set the status: to removed.
    • Set milestone_removed: to the number of the milestone in which the metric was removed.

    Do not remove the metric's YAML definition altogether. Some self-managed instances might not immediately update to the latest version of GitLab, and therefore continue to report the removed metric. The Product Intelligence team requires a record of all removed metrics in order to identify and filter them.

    For example please take a look at this merge request.

  4. After you verify the metric can be safely removed, remove the metric's instrumentation from lib/gitlab/usage_data.rb or ee/lib/ee/gitlab/usage_data.rb.

    For example please take a look at this merge request.

  5. Remove any other records related to the metric:

  6. Update the Metrics Dictionary following guidelines instructions.

Implementing Service Ping

Service Ping consists of two kinds of data, counters and observations. Counters track how often a certain event happened over time, such as how many CI pipelines have run. They are monotonic and always trend up. Observations are facts collected from one or more GitLab instances and can carry arbitrary data. There are no general guidelines around how to collect those, due to the individual nature of that data.

There are several types of counters which are all found in usage_data.rb:

  • Ordinary Batch Counters: Simple count of a given ActiveRecord_Relation
  • Distinct Batch Counters: Distinct count of a given ActiveRecord_Relation in a given column
  • Sum Batch Counters: Sum the values of a given ActiveRecord_Relation in a given column
  • Alternative Counters: Used for settings and configurations
  • Redis Counters: Used for in-memory counts.

NOTE: Only use the provided counter methods. Each counter method contains a built in fail safe to isolate each counter to avoid breaking the entire Service Ping.

Why batch counting

For large tables, PostgreSQL can take a long time to count rows due to MVCC (Multi-version Concurrency Control). Batch counting is a counting method where a single large query is broken into multiple smaller queries. For example, instead of a single query querying 1,000,000 records, with batch counting, you can execute 100 queries of 10,000 records each. Batch counting is useful for avoiding database timeouts as each batch query is significantly shorter than one single long running query.

For, there are extremely large tables with 15 second query timeouts, so we use batch counting to avoid encountering timeouts. Here are the sizes of some tables:

Table Row counts in millions
merge_request_diff_commits 2280
ci_build_trace_sections 1764
merge_request_diff_files 1082
events 514

The following operation methods are available for your use:

Batch counting requires indexes on columns to calculate max, min, and range queries. In some cases, you may need to add a specialized index on the columns involved in a counter.

Ordinary Batch Counters

Handles ActiveRecord::StatementInvalid error

Simple count of a given ActiveRecord_Relation, does a non-distinct batch count, smartly reduces batch_size, and handles errors.

Method: count(relation, column = nil, batch: true, start: nil, finish: nil)


  • relation the ActiveRecord_Relation to perform the count
  • column the column to perform the count on, by default is the primary key
  • batch: default true to use batch counting
  • start: custom start of the batch counting to avoid complex min calculations
  • end: custom end of the batch counting to avoid complex min calculations


count(::Clusters::Cluster.aws_installed.enabled, :cluster_id)
count(::Clusters::Cluster.aws_installed.enabled, :cluster_id, start: ::Clusters::Cluster.minimum(:id), finish: ::Clusters::Cluster.maximum(:id))

Distinct Batch Counters

Handles ActiveRecord::StatementInvalid error

Distinct count of a given ActiveRecord_Relation on given column, a distinct batch count, smartly reduces batch_size, and handles errors.

Method: distinct_count(relation, column = nil, batch: true, batch_size: nil, start: nil, finish: nil)


  • relation the ActiveRecord_Relation to perform the count
  • column the column to perform the distinct count, by default is the primary key
  • batch: default true to use batch counting
  • batch_size: if none set it uses default value 10000 from Gitlab::Database::BatchCounter
  • start: custom start of the batch counting to avoid complex min calculations
  • end: custom end of the batch counting to avoid complex min calculations

WARNING: Counting over non-unique columns can lead to performance issues. Take a look at the iterating tables in batches guide for more details.


distinct_count(::Project, :creator_id)
distinct_count(::Note.with_suggestions.where(time_period), :author_id, start: ::User.minimum(:id), finish: ::User.maximum(:id))
distinct_count(::Clusters::Applications::CertManager.where(time_period).available.joins(:cluster), 'clusters.user_id')

Sum Batch Operation

Handles ActiveRecord::StatementInvalid error

Sum the values of a given ActiveRecord_Relation on given column and handles errors.

Method: sum(relation, column, batch_size: nil, start: nil, finish: nil)


  • relation the ActiveRecord_Relation to perform the operation
  • column the column to sum on
  • batch_size: if none set it uses default value 1000 from Gitlab::Database::BatchCounter
  • start: custom start of the batch counting to avoid complex min calculations
  • end: custom end of the batch counting to avoid complex min calculations


sum(JiraImportState.finished, :imported_issues_count)

Grouping & Batch Operations

The count, distinct_count, and sum batch counters can accept an ActiveRecord::Relation object, which groups by a specified column. With a grouped relation, the methods do batch counting, handle errors, and returns a hash table of key-value pairs.


# returns => {nil=>179, "Group"=>54}

distinct_count(, :creator_id)
# returns => {0=>1, 10=>1, 20=>11}

sum(, :weight))
# returns => {1=>3542, 2=>6820}

Add Operation

Handles StandardError.

Returns -1 if any of the arguments are -1.

Sum the values given as parameters.

Method: add(*args)


project_imports = distinct_count(::Project.where.not(import_type: nil), :creator_id)
bulk_imports = distinct_count(::BulkImport, :user_id)

 add(project_imports, bulk_imports)

Estimated Batch Counters

Estimated batch counter functionality handles ActiveRecord::StatementInvalid errors when used through the provided estimate_batch_distinct_count method. Errors return a value of -1.

WARNING: This functionality estimates a distinct count of a specific ActiveRecord_Relation in a given column, which uses the HyperLogLog algorithm. As the HyperLogLog algorithm is probabilistic, the results always include error. The highest encountered error rate is 4.9%.

When correctly used, the estimate_batch_distinct_count method enables efficient counting over columns that contain non-unique values, which can not be assured by other counters.

estimate_batch_distinct_count method

Method: estimate_batch_distinct_count(relation, column = nil, batch_size: nil, start: nil, finish: nil)

The method includes the following arguments:

  • relation: The ActiveRecord_Relation to perform the count.
  • column: The column to perform the distinct count. The default is the primary key.
  • batch_size: From Gitlab::Database::PostgresHll::BatchDistinctCounter::DEFAULT_BATCH_SIZE. Default value: 10,000.
  • start: The custom start of the batch count, to avoid complex minimum calculations.
  • finish: The custom end of the batch count to avoid complex maximum calculations.

The method includes the following prerequisites:

  1. The supplied relation must include the primary key defined as the numeric column. For example: id bigint NOT NULL.

  2. The estimate_batch_distinct_count can handle a joined relation. To use its ability to count non-unique columns, the joined relation must NOT have a one-to-many relationship, such as has_many :boards.

  3. Both start and finish arguments should always represent primary key relationship values, even if the estimated count refers to another column, for example:

      estimate_batch_distinct_count(::Note, :author_id, start: ::Note.minimum(:id), finish: ::Note.maximum(:id))


  1. Simple execution of estimated batch counter, with only relation provided, returned value represents estimated number of unique values in id column (which is the primary key) of Project relation:

  2. Execution of estimated batch counter, where provided relation has applied additional filter (.where(time_period)), number of unique values estimated in custom column (:author_id), and parameters: start and finish together apply boundaries that defines range of provided relation to analyze:

      estimate_batch_distinct_count(::Note.with_suggestions.where(time_period), :author_id, start: ::Note.minimum(:id), finish: ::Note.maximum(:id))
  3. Execution of estimated batch counter with joined relation (joins(:cluster)), for a custom column ('clusters.user_id'):

      estimate_batch_distinct_count(::Clusters::Applications::CertManager.where(time_period).available.joins(:cluster), 'clusters.user_id')

When instrumenting metric with usage of estimated batch counter please add _estimated suffix to its name, for example:

  "counts": {
    "ci_builds_estimated": estimate_batch_distinct_count(Ci::Build),

Redis Counters

Handles ::Redis::CommandError and Gitlab::UsageDataCounters::BaseCounter::UnknownEvent returns -1 when a block is sent or hash with all values -1 when a counter(Gitlab::UsageDataCounters) is sent different behavior due to 2 different implementations of Redis counter

Method: redis_usage_data(counter, &block)


  • counter: a counter from Gitlab::UsageDataCounters, that has fallback_totals method implemented
  • or a block: which is evaluated

Ordinary Redis Counters

Examples of implementation:

UsageData API Tracking
  1. Track event using UsageData API

    Increment event count using ordinary Redis counter, for given event name.

    Tracking events using the UsageData API requires the usage_data_api feature flag to be enabled, which is enabled by default.

    API requests are protected by checking for a valid CSRF token.

    To be able to increment the values, the related feature usage_data_<event_name> should be enabled.

    POST /usage_data/increment_counter
    Attribute Type Required Description
    event string yes The event name it should be tracked


    • 200 if event was tracked
    • 400 Bad request if event parameter is missing
    • 401 Unauthorized if user is not authenticated
    • 403 Forbidden for invalid CSRF token provided
  2. Track events using JavaScript/Vue API helper which calls the API above

    Note that usage_data_api and usage_data_#{event_name} should be enabled to be able to track events

    import api from '~/api';

Redis HLL Counters

WARNING: HyperLogLog (HLL) is a probabilistic algorithm and its results always includes some small error. According to Redis documentation, data from used HLL implementation is "approximated with a standard error of 0.81%".

With Gitlab::UsageDataCounters::HLLRedisCounter we have available data structures used to count unique values.

Implemented using Redis methods PFADD and PFCOUNT.

Adding new events
  1. Define events in known_events.

    Example event:

    - name: users_creating_epics
      category: epics_usage
      redis_slot: users
      aggregation: weekly
      feature_flag: track_epics_activity


    • name: unique event name.

      Name format for Redis HLL events <name>_<redis_slot>.

      See Metric name for a complete guide on metric naming suggestion.

      Consider including in the event's name the Redis slot to be able to count totals for a specific category.

      Example names: users_creating_epics, users_triggering_security_scans.

    • category: event category. Used for getting total counts for events in a category, for easier access to a group of events.

    • redis_slot: optional Redis slot. Default value: event name. Only event data that is stored in the same slot can be aggregated. Ensure keys are in the same slot. For example: users_creating_epics with redis_slot: 'users' builds Redis key {users}_creating_epics-2020-34. If redis_slot is not defined the Redis key will be {users_creating_epics}-2020-34. Recommended slots to use are: users, projects. This is the value we count.

    • expiry: expiry time in days. Default: 29 days for daily aggregation and 6 weeks for weekly aggregation.

    • aggregation: may be set to a :daily or :weekly key. Defines how counting data is stored in Redis. Aggregation on a daily basis does not pull more fine grained data.

    • feature_flag: optional default_enabled: :yaml. If no feature flag is set then the tracking is enabled. One feature flag can be used for multiple events. For details, see our GitLab internal Feature flags documentation. The feature flags are owned by the group adding the event tracking.

  2. Use one of the following methods to track the event:

    • In the controller using the RedisTracking module and the following format:

      track_redis_hll_event(*controller_actions, name:, if: nil, &block)


      • controller_actions: the controller actions to track.
      • name: the event name.
      • if: optional custom conditions. Uses the same format as Rails callbacks.
      • &block: optional block that computes and returns the custom_id that we want to track. This overrides the visitor_id.


      # controller
      class ProjectsController < Projects::ApplicationController
        include RedisTracking
        skip_before_action :authenticate_user!, only: :show
        track_redis_hll_event :index, :show, name: 'users_visiting_projects'
        def index
          render html: 'index'
       def new
         render html: 'new'
       def show
         render html: 'show'
    • In the API using the increment_unique_values(event_name, values) helper method.


      • event_name: the event name.
      • values: the values counted. Can be one value or an array of values.


      get ':id/registry/repositories' do
        repositories =
          user: current_user, subject: user_group
        present paginate(repositories), with: Entities::ContainerRegistry::Repository, tags: params[:tags], tags_count: params[:tags_count]
    • Using track_usage_event(event_name, values) in services and GraphQL.

      Increment unique values count using Redis HLL, for a given event name.


    • Using the UsageData API.

      Increment unique users count using Redis HLL, for a given event name.

      To track events using the UsageData API, ensure the usage_data_api feature flag is set to default_enabled: true. Enabled by default in GitLab 13.7 and later.

      API requests are protected by checking for a valid CSRF token.

      POST /usage_data/increment_unique_users
      Attribute Type Required Description
      event string yes The event name to track


      • 200 if the event was tracked, or if tracking failed for any reason.
      • 400 Bad request if an event parameter is missing.
      • 401 Unauthorized if the user is not authenticated.
      • 403 Forbidden if an invalid CSRF token is provided.
    • Using the JavaScript/Vue API helper, which calls the UsageData API.

      To track events using the UsageData API, ensure the usage_data_api feature flag is set to default_enabled: true. Enabled by default in GitLab 13.7 and later.

      Example for an existing event already defined in known events:

      import api from '~/api';
  3. Get event data using Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(event_names:, start_date:, end_date:, context: '').


    • event_names: the list of event names.
    • start_date: start date of the period for which we want to get event data.
    • end_date: end date of the period for which we want to get event data.
    • context: context of the event. Allowed values are default, free, bronze, silver, gold, starter, premium, ultimate.
  4. Testing tracking and getting unique events

Trigger events in rails console by using track_event method

Gitlab::UsageDataCounters::HLLRedisCounter.track_event('users_viewing_compliance_audit_events', values: 1)
Gitlab::UsageDataCounters::HLLRedisCounter.track_event('users_viewing_compliance_audit_events', values: [2, 3])

Next, get the unique events for the current week.

# Get unique events for metric for current_week
Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(event_names: 'users_viewing_compliance_audit_events',
start_date: Date.current.beginning_of_week, end_date: Date.current.next_week)

We have the following recommendations for Adding new events:

  • Event aggregation: weekly.
  • Key expiry time:
    • Daily: 29 days.
    • Weekly: 42 days.
  • When adding new metrics, use a feature flag to control the impact.
  • For feature flags triggered by another service, set default_enabled: false,
    • Events can be triggered using the UsageData API, which helps when there are > 10 events per change
Enable/Disable Redis HLL tracking

Events are tracked behind optional feature flags due to concerns for Redis performance and scalability.

For a full list of events and corresponding feature flags see, known_events files.

To enable or disable tracking for specific event in or, run commands such as the following to enable or disable the corresponding feature.

/chatops run feature set <feature_name> true
/chatops run feature set <feature_name> false

We can also disable tracking completely by using the global flag:

/chatops run feature set redis_hll_tracking true
/chatops run feature set redis_hll_tracking false
Known events are added automatically in Service Data payload

All events added in known_events/common.yml are automatically added to Service Data generation under the redis_hll_counters key. This column is stored in version-app as a JSON. For each event we add metrics for the weekly and monthly time frames, and totals for each where applicable:

  • #{event_name}_weekly: Data for 7 days for daily aggregation events and data for the last complete week for weekly aggregation events.
  • #{event_name}_monthly: Data for 28 days for daily aggregation events and data for the last 4 complete weeks for weekly aggregation events.

Redis HLL implementation calculates automatic total metrics, if there are more than one metric for the same category, aggregation, and Redis slot.

  • #{category}_total_unique_counts_weekly: Total unique counts for events in the same category for the last 7 days or the last complete week, if events are in the same Redis slot and we have more than one metric.
  • #{category}_total_unique_counts_monthly: Total unique counts for events in same category for the last 28 days or the last 4 complete weeks, if events are in the same Redis slot and we have more than one metric.

Example of redis_hll_counters data:


Example usage:

# Redis Counters
redis_usage_data { ::Gitlab::UsageCounters::PodLogs.usage_totals[:total] }

# Define events in common.yml

# Tracking events
Gitlab::UsageDataCounters::HLLRedisCounter.track_event('users_expanding_vulnerabilities', values: visitor_id)

# Get unique events for metric
redis_usage_data { Gitlab::UsageDataCounters::HLLRedisCounter.unique_events(event_names: 'users_expanding_vulnerabilities', start_date: 28.days.ago, end_date: Date.current) }

Alternative Counters

Handles StandardError and fallbacks into -1 this way not all measures fail if we encounter one exception. Mainly used for settings and configurations.

Method: alt_usage_data(value = nil, fallback: -1, &block)


  • value: a simple static value in which case the value is simply returned.
  • or a block: which is evaluated
  • fallback: -1: the common value used for any metrics that are failing.


alt_usage_data { Gitlab::VERSION }
alt_usage_data { Gitlab::CurrentSettings.uuid }

Adding counters to build new metrics

When adding the results of two counters, use the add Service Data method that handles fallback values and exceptions. It also generates a valid SQL export.

Example usage:


Prometheus Queries

In those cases where operational metrics should be part of Service Ping, a database or Redis query is unlikely to provide useful data. Instead, Prometheus might be more appropriate, because most GitLab architectural components publish metrics to it that can be queried back, aggregated, and included as Service Data.

NOTE: Prometheus as a data source for Service Ping is currently only available for single-node Omnibus installations that are running the bundled Prometheus instance.

To query Prometheus for metrics, a helper method is available to yield a fully configured PrometheusClient, given it is available as per the note above:

with_prometheus_client do |client|
  response = client.query('<your query>')

Please refer to the PrometheusClient definition for how to use its API to query for data.

Fallback values for UsagePing

We return fallback values in these cases:

Case Value
Deprecated Metric -1000
Timeouts, general failures -1
Standard errors in counters -2

Developing and testing Service Ping

1. Naming and placing the metrics

Add the metric in one of the top level keys

  • settings: for settings related metrics.
  • counts_weekly: for counters that have data for the most recent 7 days.
  • counts_monthly: for counters that have data for the most recent 28 days.
  • counts: for counters that have data for all time.

2. Use your Rails console to manually test counters

# count
Gitlab::UsageData.count(::Clusters::Cluster.aws_installed.enabled, :cluster_id)

# count distinct
Gitlab::UsageData.distinct_count(::Project, :creator_id)
Gitlab::UsageData.distinct_count(::Note.with_suggestions.where(time_period), :author_id, start: ::User.minimum(:id), finish: ::User.maximum(:id))

3. Generate the SQL query

Your Rails console returns the generated SQL queries.


pry(main)> Gitlab::UsageData.count(
   (2.6ms)  SELECT "features"."key" FROM "features"
   (15.3ms)  SELECT MIN("users"."id") FROM "users" WHERE ("users"."state" IN ('active')) AND ("users"."user_type" IS NULL OR "users"."user_type" IN (6, 4))
   (2.4ms)  SELECT MAX("users"."id") FROM "users" WHERE ("users"."state" IN ('active')) AND ("users"."user_type" IS NULL OR "users"."user_type" IN (6, 4))
   (1.9ms)  SELECT COUNT("users"."id") FROM "users" WHERE ("users"."state" IN ('active')) AND ("users"."user_type" IS NULL OR "users"."user_type" IN (6, 4)) AND "users"."id" BETWEEN 1 AND 100000

4. Optimize queries with #database-lab

Paste the SQL query into #database-lab to see how the query performs at scale.

  • #database-lab is a Slack channel which uses a production-sized environment to test your queries.
  •'s production database has a 15 second timeout.
  • Any single query must stay below 1 second execution time with cold caches.
  • Add a specialized index on columns involved to reduce the execution time.

To have an understanding of the query's execution we add in the MR description the following information:

  • For counters that have a time_period test we add information for both cases:
    • time_period = {} for all time periods
    • time_period = { created_at: 28.days.ago..Time.current } for last 28 days period
  • Execution plan and query time before and after optimization
  • Query generated for the index and time
  • Migration output for up and down execution

We also use #database-lab and For more details, see the database review guide.

Optimization recommendations and examples

  • Use specialized indexes example 1, example 2.
  • Use defined start and finish, and simple queries. These values can be memoized and reused, example.
  • Avoid joins and write the queries as simply as possible, example.
  • Set a custom batch_size for distinct_count, example.

5. Add the metric definition

Check Metrics Dictionary Guide

When adding, updating, or removing metrics, please update the Metrics Dictionary.

6. Add new metric to Versions Application

Check if new metrics need to be added to the Versions Application. See usage_data schema and Service Data parameters accepted. Any metrics added under the counts key are saved in the stats column.

7. Add the feature label

Add the feature label to the Merge Request for new Service Ping metrics. These are user-facing changes and are part of expanding the Service Ping feature.

8. Add a changelog

Ensure you comply with the Changelog entries guide.

9. Ask for a Product Intelligence Review

On, we have DangerBot set up to monitor Product Intelligence related files and DangerBot recommends a Product Intelligence review.

10. Verify your metric

On, the Product Intelligence team regularly monitors Service Ping. They may alert you that your metrics need further optimization to run quicker and with greater success.

The Service Ping JSON payload for is shared in the #g_product_intelligence Slack channel every week.

You may also use the Service Ping QA dashboard to check how well your metric performs. The dashboard allows filtering by GitLab version, by "Self-managed" & "SaaS" and shows you how many failures have occurred for each metric. Whenever you notice a high failure rate, you may re-optimize your metric.

Service Ping local setup

To set up Service Ping locally, you must:

  1. Set up local repositories.
  2. Test local setup.
  3. (Optional) Test Prometheus-based Service Ping.

Set up local repositories

  1. Clone and start GitLab.
  2. Clone and start Versions Application. Make sure to run docker-compose up to start a PostgreSQL and Redis instance.
  3. Point GitLab to the Versions Application endpoint instead of the default endpoint:
    1. Open submit_usage_ping_service.rb in your local and modified PRODUCTION_URL.
    2. Set it to the local Versions Application URL http://localhost:3000/usage_data.

Test local setup

  1. Using the gitlab Rails console, manually trigger Service Ping:
  2. Use the versions Rails console to check the Service Ping was successfully received, parsed, and stored in the Versions database:


Test Prometheus-based Service Ping

If the data submitted includes metrics queried from Prometheus you want to inspect and verify, you must:

  • Ensure that a Prometheus server is running locally.
  • Ensure the respective GitLab components are exporting metrics to the Prometheus server.

If you do not need to test data coming from Prometheus, no further action is necessary. Service Ping should degrade gracefully in the absence of a running Prometheus server.

Three kinds of components may export data to Prometheus, and are included in Service Ping:

  • node_exporter: Exports node metrics from the host machine.
  • gitlab-exporter: Exports process metrics from various GitLab components.
  • Other various GitLab services, such as Sidekiq and the Rails server, which export their own metrics.

Test with an Omnibus container

This is the recommended approach to test Prometheus based Service Ping.

The easiest way to verify your changes is to build a new Omnibus image from your code branch by using CI, then download the image and run a local container instance:

  1. From your merge request, click on the qa stage, then trigger the package-and-qa job. This job triggers an Omnibus build in a downstream pipeline of the omnibus-gitlab-mirror project.
  2. In the downstream pipeline, wait for the gitlab-docker job to finish.
  3. Open the job logs and locate the full container name including the version. It takes the following form:<VERSION>.
  4. On your local machine, make sure you are signed in to the GitLab Docker registry. You can find the instructions for this in Authenticate to the GitLab Container Registry.
  5. Once signed in, download the new image by using docker pull<VERSION>
  6. For more information about working with and running Omnibus GitLab containers in Docker, please refer to GitLab Docker images in the Omnibus documentation.

Test with GitLab development toolkits

This is the less recommended approach, because it comes with a number of difficulties when emulating a real GitLab deployment.

The GDK is not set up to run a Prometheus server or node_exporter alongside other GitLab components. If you would like to do so, Monitoring the GDK with Prometheus is a good start.

The GCK has limited support for testing Prometheus based Service Ping. By default, it already comes with a fully configured Prometheus service that is set up to scrape a number of components, but with the following limitations:

  • It does not run a gitlab-exporter instance, so several process_* metrics from services such as Gitaly may be missing.
  • While it runs a node_exporter, docker-compose services emulate hosts, meaning that it would normally report itself to not be associated with any of the other services that are running. That is not how node metrics are reported in a production setup, where node_exporter always runs as a process alongside other GitLab components on any given node. From Service Ping's perspective none of the node data would therefore appear to be associated to any of the services running, because they all appear to be running on different hosts. To alleviate this problem, the node_exporter in GCK was arbitrarily "assigned" to the web service, meaning only for this service node_* metrics appears in Service Ping.

Aggregated metrics

WARNING: This feature is intended solely for internal GitLab use.

To add data for aggregated metrics into Service Ping payload you should add corresponding definition at config/metrics/aggregates/*.yaml for metrics available at Community Edition and at ee/config/metrics/aggregates/*.yaml for Enterprise Edition ones.

Each aggregate definition includes following parts:

  • name: Unique name under which the aggregate metric is added to the Service Ping payload.
  • operator: Operator that defines how the aggregated metric data is counted. Available operators are:
    • OR: Removes duplicates and counts all entries that triggered any of listed events.
    • AND: Removes duplicates and counts all elements that were observed triggering all of following events.
  • time_frame: One or more valid time frames. Use these to limit the data included in aggregated metric to events within a specific date-range. Valid time frames are:
    • 7d: Last seven days of data.
    • 28d: Last twenty eight days of data.
    • all: All historical data, only available for database sourced aggregated metrics.
  • source: Data source used to collect all events data included in aggregated metric. Valid data sources are:
  • events: list of events names to aggregate into metric. All events in this list must relay on the same data source. Additional data source requirements are described in the Database sourced aggregated metrics and Redis sourced aggregated metrics sections.
  • feature_flag: Name of development feature flag that is checked before metrics aggregation is performed. Corresponding feature flag should have default_enabled attribute set to false. The feature_flag attribute is optional and can be omitted. When feature_flag is missing, no feature flag is checked.

Example aggregated metric entries:

- name: example_metrics_union
  operator: OR
    - 'users_expanding_secure_security_report'
    - 'users_expanding_testing_code_quality_report'
    - 'users_expanding_testing_accessibility_report'
  source: redis
    - 7d
    - 28d
- name: example_metrics_intersection
  operator: AND
  source: database
    - 28d
    - all
    - 'dependency_scanning_pipeline_all_time'
    - 'container_scanning_pipeline_all_time'
  feature_flag: example_aggregated_metric

Aggregated metrics collected in 7d and 28d time frames are added into Service Ping payload under the aggregated_metrics sub-key in the counts_weekly and counts_monthly top level keys.

  :counts_monthly => {
    :deployments => 1003,
    :successful_deployments => 78,
    :failed_deployments => 275,
    :packages => 155,
    :personal_snippets => 2106,
    :project_snippets => 407,
    :promoted_issues => 719,
    :aggregated_metrics => {
      :example_metrics_union => 7,
      :example_metrics_intersection => 2
    :snippets => 2513

Aggregated metrics for all time frame are present in the count top level key, with the aggregate_ prefix added to their name.

For example:




  :counts => {
    :deployments => 11003,
    :successful_deployments => 178,
    :failed_deployments => 1275,
    :aggregate_example_metrics_intersection => 12

Redis sourced aggregated metrics

To declare the aggregate of events collected with Redis HLL Counters, you must fulfill the following requirements:

  1. All events listed at events attribute must come from known_events/*.yml files.
  2. All events listed at events attribute must have the same redis_slot attribute.
  3. All events listed at events attribute must have the same aggregation attribute.
  4. time_frame does not include all value, which is unavailable for Redis sourced aggregated metrics.

Database sourced aggregated metrics

To declare an aggregate of metrics based on events collected from database, follow these steps:

  1. Persist the metrics for aggregation.
  2. Add new aggregated metric definition.

Persist metrics for aggregation

Only metrics calculated with Estimated Batch Counters can be persisted for database sourced aggregated metrics. To persist a metric, inject a Ruby block into the estimate_batch_distinct_count method. This block should invoke the Gitlab::Usage::Metrics::Aggregates::Sources::PostgresHll.save_aggregated_metrics method, which stores estimate_batch_distinct_count results for future use in aggregated metrics.

The Gitlab::Usage::Metrics::Aggregates::Sources::PostgresHll.save_aggregated_metrics method accepts the following arguments:

  • metric_name: The name of metric to use for aggregations. Should be the same as the key under which the metric is added into Service Ping.
  • recorded_at_timestamp: The timestamp representing the moment when a given Service Ping payload was collected. You should use the convenience method recorded_at to fill recorded_at_timestamp argument, like this: recorded_at_timestamp: recorded_at
  • time_period: The time period used to build the relation argument passed into estimate_batch_distinct_count. To collect the metric with all available historical data, set a nil value as time period: time_period: nil.
  • data: HyperLogLog buckets structure representing unique entries in relation. The estimate_batch_distinct_count method always passes the correct argument into the block, so data argument must always have a value equal to block argument, like this: data: result

Example metrics persistence:

class UsageData
  def count_secure_pipelines(time_period)
    relation = ::Security::Scan.latest_successful_by_build.by_scan_types(scan_type).where(security_scans: time_period)

    pipelines_with_secure_jobs['dependency_scanning_pipeline'] = estimate_batch_distinct_count(relation, :commit_id, batch_size: 1000, start: start_id, finish: finish_id) do |result|
        .save_aggregated_metrics(metric_name: 'dependency_scanning_pipeline', recorded_at_timestamp: recorded_at, time_period: time_period, data: result)

Add new aggregated metric definition

After all metrics are persisted, you can add an aggregated metric definition at aggregated_metrics/.

To declare the aggregate of metrics collected with Estimated Batch Counters, you must fulfill the following requirements:

  • Metrics names listed in the events: attribute, have to use the same names you passed in the metric_name argument while persisting metrics in previous step.
  • Every metric listed in the events: attribute, has to be persisted for every selected time_frame: value.

Example definition:

- name: example_metrics_intersection_database_sourced
  operator: AND
  source: database
    - 'dependency_scanning_pipeline'
    - 'container_scanning_pipeline'
    - 28d
    - all

Example Service Ping payload

The following is example content of the Service Ping payload.

  "uuid": "0000000-0000-0000-0000-000000000000",
  "hostname": "",
  "version": "12.10.0-pre",
  "installation_type": "omnibus-gitlab",
  "active_user_count": 999,
  "recorded_at": "2020-04-17T07:43:54.162+00:00",
  "edition": "EEU",
  "license_md5": "00000000000000000000000000000000",
  "license_id": null,
  "historical_max_users": 999,
  "licensee": {
    "Name": "ABC, Inc.",
    "Email": "",
    "Company": "ABC, Inc."
  "license_user_count": 999,
  "license_starts_at": "2020-01-01",
  "license_expires_at": "2021-01-01",
  "license_plan": "ultimate",
  "license_add_ons": {
  "license_trial": false,
  "counts": {
    "assignee_lists": 999,
    "boards": 999,
    "ci_builds": 999,
  "container_registry_enabled": true,
  "dependency_proxy_enabled": false,
  "gitlab_shared_runners_enabled": true,
  "gravatar_enabled": true,
  "influxdb_metrics_enabled": true,
  "ldap_enabled": false,
  "mattermost_enabled": false,
  "omniauth_enabled": true,
  "prometheus_enabled": false,
  "prometheus_metrics_enabled": false,
  "reply_by_email_enabled": "incoming+%{key}",
  "signup_enabled": true,
  "web_ide_clientside_preview_enabled": true,
  "projects_with_expiration_policy_disabled": 999,
  "projects_with_expiration_policy_enabled": 999,
  "elasticsearch_enabled": true,
  "license_trial_ends_on": null,
  "geo_enabled": false,
  "git": {
    "version": {
      "major": 2,
      "minor": 26,
      "patch": 1
  "gitaly": {
    "version": "12.10.0-rc1-93-g40980d40",
    "servers": 56,
    "clusters": 14,
    "filesystems": [
  "gitlab_pages": {
    "enabled": true,
    "version": "1.17.0"
  "container_registry_server": {
    "vendor": "gitlab",
    "version": "2.9.1-gitlab"
  "database": {
    "adapter": "postgresql",
    "version": "9.6.15",
    "pg_system_id": 6842684531675334351
  "analytics_unique_visits": {
    "g_analytics_contribution": 999,
  "usage_activity_by_stage": {
    "configure": {
      "project_clusters_enabled": 999,
    "create": {
      "merge_requests": 999,
    "manage": {
      "events": 999,
    "monitor": {
      "clusters": 999,
    "package": {
      "projects_with_packages": 999
    "plan": {
      "issues": 999,
    "release": {
      "deployments": 999,
    "secure": {
      "user_container_scanning_jobs": 999,
    "verify": {
      "ci_builds": 999,
  "usage_activity_by_stage_monthly": {
    "configure": {
      "project_clusters_enabled": 999,
    "create": {
      "merge_requests": 999,
    "manage": {
      "events": 999,
    "monitor": {
      "clusters": 999,
    "package": {
      "projects_with_packages": 999
    "plan": {
      "issues": 999,
    "release": {
      "deployments": 999,
    "secure": {
      "user_container_scanning_jobs": 999,
    "verify": {
      "ci_builds": 999,
  "topology": {
    "duration_s": 0.013836685999194742,
    "application_requests_per_hour": 4224,
    "query_apdex_weekly_average": 0.996,
    "failures": [],
    "nodes": [
        "node_memory_total_bytes": 33269903360,
        "node_memory_utilization": 0.35,
        "node_cpus": 16,
        "node_cpu_utilization": 0.2,
        "node_uname_info": {
          "machine": "x86_64",
          "sysname": "Linux",
          "release": "4.19.76-linuxkit"
        "node_services": [
            "name": "web",
            "process_count": 16,
            "process_memory_pss": 233349888,
            "process_memory_rss": 788220927,
            "process_memory_uss": 195295487,
            "server": "puma"
            "name": "sidekiq",
            "process_count": 1,
            "process_memory_pss": 734080000,
            "process_memory_rss": 750051328,
            "process_memory_uss": 731533312

Notable changes

In GitLab 13.5, pg_system_id was added to send the PostgreSQL system identifier.

Exporting Service Ping SQL queries and definitions

Two Rake tasks exist to export Service Ping definitions.

  • The Rake tasks export the raw SQL queries for count, distinct_count, sum.
  • The Rake tasks export the Redis counter class or the line of the Redis block for redis_usage_data.
  • The Rake tasks calculate the alt_usage_data metrics.

In the home directory of your local GitLab installation run the following Rake tasks for the YAML and JSON versions respectively:

# for YAML export
bin/rake gitlab:usage_data:dump_sql_in_yaml

# for JSON export
bin/rake gitlab:usage_data:dump_sql_in_json

# You may pipe the output into a file
bin/rake gitlab:usage_data:dump_sql_in_yaml > ~/Desktop/usage-metrics-2020-09-02.yaml

Generating and troubleshooting Service Ping

This activity is to be done via a detached screen session on a remote server.

Before you begin these steps, make sure the key is added to the SSH agent locally with the ssh-add command.


  1. Connect to bastion with agent forwarding: $ ssh -A
  2. Create named screen: $ screen -S <username>_usage_ping_<date>
  3. Connect to console host: $ ssh $USER-rails@console-01-sv-gprd.c.gitlab-production.internal
  4. Run
  5. Detach from screen: ctrl + a, ctrl + d
  6. Exit from bastion: $ exit

Verification (After approx 30 hours)

  1. Reconnect to bastion: $ ssh -A
  2. Find your screen session: $ screen -ls
  3. Attach to your screen session: $ screen -x 14226.mwawrzyniak_usage_ping_2021_01_22
  4. Check the last payload in raw_usage_data table: RawUsageData.last.payload
  5. Check the when the payload was sent: RawUsageData.last.sent_at


Cannot disable Service Ping using the configuration file

The method to disable Service Ping using the GitLab configuration file does not work in GitLab versions 9.3.0 to 13.12.3. To disable it, you need to use the Admin Area in the GitLab UI instead. For more information, see this issue.

GitLab functionality and application settings cannot override or circumvent restrictions at the network layer. If Service Ping is blocked by your firewall, you are not impacted by this bug.

Check if you are affected

You can check if you were affected by this bug by using the Admin area or by checking the configuration file of your GitLab instance:

  • Using the Admin area:

    1. On the top bar, go to the admin area ({admin}).

    2. On the left sidebar, select Settings > Metrics and profiling.

    3. Expand Usage Statistics.

    4. Are you able to check/uncheck the checkbox to disable Service Ping?

      • If yes, your GitLab instance is not affected by this bug.
      • If you can't check/uncheck the checkbox, you are affected by this bug. Read below how to fix this.
  • Checking your GitLab instance configuration file:

    To check whether you're impacted by this bug, check your instance configuration settings. The configuration file in which Service Ping can be disabled will depend on your installation and deployment method, but it will typically be one of the following:

    • /etc/gitlab/gitlab.rb for Omnibus GitLab Linux Package and Docker.
    • charts.yaml for GitLab Helm and cloud-native Kubernetes deployments.
    • gitlab.yml for GitLab installations from source.

    To check the relevant configuration file for strings that indicate whether Service Ping is disabled, you can use grep:

    # Linux package
    grep "usage_ping_enabled'\] = false" /etc/gitlab/gitlab.rb
    # Kubernetes charts
    grep "enableUsagePing: false" values.yaml
    # From source
    grep "usage_ping_enabled'\] = false" gitlab/config.yml

    If you see any output after running the relevant command, your GitLab instance may be affected by the bug. Otherwise, your instance is not affected.

How to fix the "Cannot disable Service Ping" bug

To work around this bug, you have two options:

  • Update to GitLab 13.12.4 or newer to fix this bug.

  • If you can't update to GitLab 13.12.4 or newer, enable Service Ping in the configuration file, then disable Service Ping in the UI. For example, if you're using the Linux package:

    1. Edit /etc/gitlab/gitlab.rb:

      gitlab_rails['usage_ping_enabled'] = true
    2. Reconfigure GitLab:

      sudo gitlab-ctl reconfigure
    3. In GitLab, on the top bar, go to the admin area ({admin}).

    4. On the left sidebar, select Settings > Metrics and profiling.

    5. Expand Usage Statistics.

    6. Clear the Enable service ping checkbox.

    7. Select Save Changes.