build tmp_idx_group_audit_events_on_group_id_created_at_mcp_enabled
# Production Change
## Change Summary
Create missing index `tmp_idx_group_audit_events_on_group_id_created_at_mcp_enabled` for `main`, `ci`, and `sec` databases.
The [post-deploy migration](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/257148) already ran, it just queued one row per partition in `postgres_async_indexes`, and it can take a while to finish.
I need it to finish before October 15 so that the [migration that uses this index](https://gitlab.com/gitlab-org/gitlab/-/merge_requests/257102#note_3980165772) can be merged and run.
Slack thread: https://gitlab.slack.com/archives/C3NBYFJ6N/p1791515624781849
## Change Details
1. **Services Impacted** - ~"Service::Postgres" (Patroni `main`, `ci`, `sec`, gprd), GitLab Rails
1. **Change Technician** - TBD
1. **Change Reviewer** - TBD
1. **Scheduled Date and Time (UTC in format YYYY-MM-DD HH:MM)** - TBD
1. **Time tracking** - ~90 minutes
1. **Downtime Component** - N/A, no downtime
### Criticality
~C3.
`CREATE INDEX CONCURRENTLY` takes a `SHARE UPDATE EXCLUSIVE` lock on each partition only. It does not block reads or writes.
The handbook treats scripts run on a production console as C2; the reviewer may raise this to C2, in which case the C2 checklist items below apply.
## Preparation
> [!NOTE]
> The following checklists must be done in advance, before setting the label ~"change::scheduled"
### Change Reviewer checklist
~C4 ~C3 ~C2 ~C1:
- [ ] Check if the following applies:
- The **scheduled day and time** of execution of the change is appropriate.
- The [change plan](#detailed-steps-for-the-change) is technically accurate.
- The change plan includes **estimated timing values** based on previous testing.
- The change plan includes a viable [rollback plan](#rollback).
- The specified [metrics/monitoring dashboards](#key-metrics-to-observe) provide sufficient visibility for the change.
~C2 ~C1:
- [ ] Check if the following applies:
- The complexity of the plan is appropriate for the corresponding risk of the change. (i.e. the plan contains clear details).
- The change plan includes success measures for all steps/milestones during the execution.
- The change adequately minimizes risk within the environment/service.
- The performance implications of executing the change are well-understood and documented.
- The specified metrics/monitoring dashboards provide sufficient visibility for the change.
- If not, is it possible (or necessary) to make changes to observability platforms for added visibility?
- The change has a primary and secondary SRE with knowledge of the details available during the change window.
- The change window has been agreed with Release Managers in advance of the change.
- The labels ~"blocks deployments" and/or ~"blocks feature-flags" are applied as necessary.
### Change Technician checklist
- [ ] The [Change Criticality](https://handbook.gitlab.com/handbook/engineering/infrastructure-platforms/change-management/#change-criticalities) has been set appropriately and requirements have been reviewed.
- [ ] The [change plan](#detailed-steps-for-the-change) is technically accurate.
- [ ] The [rollback plan](#rollback) is technically accurate and detailed enough to be executed by anyone with access.
- [ ] This Change Issue is linked to https://gitlab.com/gitlab-org/gitlab/-/merge_requests/257102 and https://gitlab.com/gitlab-org/gitlab/-/work_items/631175.
- [ ] Change has been tested in staging and results noted in a comment on this issue.
- [ ] A dry-run has been conducted and results noted in a comment on this issue. (Thin-clone build times, see [Timing](#timing).)
- [ ] The change execution window respects the [Production Change Lock periods](https://handbook.gitlab.com/handbook/engineering/infrastructure-platforms/change-management/#production-change-lock-pcl).
- [ ] Once all boxes above are checked, mark the change request as scheduled: `/label ~"change::scheduled"`
- [ ] For ~C1 and ~C2 change issues, the change event is added to the GitLab Production calendar by the change-scheduler bot.
- [ ] For ~C1 and ~C2 change issues, Platform Leadership provides approval with the ~platform_leadership_approved label on the issue.
- [ ] For ~C1, ~C2, or ~"blocks deployments" change issues, confirm with Release managers that the change does not overlap or hinder any release process (In `#production` channel, mention `@release-managers` and this issue and await their acknowledgment.)
- [ ] For ~C1 change issues or ~C2 change issues happening during weekend, SREs on-call must be informed [at least 2 weeks in advance](https://handbook.gitlab.com/handbook/engineering/infrastructure-platforms/change-management/#approval). Check [the incident.io GitLab.com Production EOC schedule](https://app.incident.io/gitlab/on-call/schedules/01K5YWAGZ7YCQGAG7ATQ9XQWHW) to find who will be on-call at the scheduled day and time.
### Proposed time window: Tuesday, between 02:00 and 04:00 UTC.
| Weekday | TPS in window (median) | TPS in window (max) | Daily peak | `gitlab:db:reindex` Job | Reading |
|---|---|---|---|---|---|
| Saturday | 22.5k | 30.2k | 26.4k | runs hourly | ruled out, competes for the async DDL lease and the Job's own `CREATE INDEX CONCURRENTLY` |
| Sunday | 17.9k | 24.1k | 33.6k | runs hourly | ruled out, same reason |
| Monday | 22.3k | 28.4k | 62.0k | Sunday's last run (23:12 UTC) may still be active | quietest weekday, but 2026-10-12 is a public holiday in BR, US and CA |
| *Tuesday* | *28.3k* | *35.6k* | *69.1k* | *does not run* | *recommended, 2026-10-13* |
| *Wednesday* | *26.7k* | *33.0k* | *72.2k* | *does not run* | *fallback, 2026-10-14* |
| Thursday | 28.7k | 35.8k | 78.2k | does not run | after the 2026-10-15 deadline |
| Friday | 27.7k | 35.7k | 65.2k | does not run | after the deadline |
## Detailed steps for the change
Indexes need to be created for each database `main`, `ci`, and `sec`. For each db, the plan consists of:
1. Opening a new `psql` session to the target database for monitoring
2. Opening a Rails console to execute the script
*Estimated Time to Complete (mins):* ~45 to ~90 min.
The `CREATE INDEX CONCURRENTLY` statements took ~30 min in total on a thin clone of `main` (2026-10-09, no concurrent traffic), plus the 1s pause per partition and whatever time production spends waiting for concurrent transactions.
The build runs through the async-index framework (`Gitlab::Database::AsyncIndexes::IndexCreator`), the same code path as the weekend job, from a Rails console on the `gprd` main-stage Toolbox pod, following https://gitlab.com/gitlab-com/runbooks/-/blob/master/docs/patroni/running-pdm-manually.md.
The framework reads the exact `name` and `definition` from `postgres_async_indexes`, takes the async DDL lease, sets a 20 h statement timeout, logs to Kibana under `json.class: Gitlab::Database::AsyncIndexes::IndexCreator` and deletes each queue row on success. The lease is per database and is shared with the `gitlab:db:reindex` Job. If the Job holds it, `perform` logs `Cannot obtain an exclusive lease`, leaves the row queued and moves on, so nothing breaks but nothing gets built either. The script processes every queued `group_audit_events` row in queue order, one at a time, with a 1 s pause between partitions.
### Pre-execution steps
- [ ] Make sure all tasks in [Change Technician checklist](#change-technician-checklist) are done
- [ ] For ~C1 and ~C2 change issues, the SRE on-call has been informed prior to change being rolled out and has provided approval with the ~eoc_approved label on the issue.
- [ ] Check for [active ~severity::1 / ~severity::2 incidents](https://gitlab.com/gitlab-com/gl-infra/production/-/issues/?sort=created_date&state=opened&label_name%5B%5D=Incident%3A%3AActive&or%5Blabel_name%5D%5B%5D=severity%3A%3A1&or%5Blabel_name%5D%5B%5D=severity%3A%3A2&first_page_size=20) before requesting approval.
- [ ] For ~C1, ~C2, or ~"blocks deployments" change issues, Release managers have been informed prior to change being rolled out.
<details>
<summary><b>Change steps for main - steps to take to execute the change</b></summary>
- [ ] Set label ~"change::in-progress" `/label ~change::in-progress`
- [ ] Apply the Pod Disruption Budget on `gitlab-migrations-toolbox` (runbook steps 3 and 4).
- [ ] Open a `psql` session on the gprd `main` primary (Teleport `database-admin`, see https://gitlab.com/gitlab-com/runbooks/-/blob/master/docs/teleport/Connect_to_Database_Console_via_Teleport.md) inside `tmux`, and a second session for monitoring.
- [ ] Check how many indexes are pending creation. Expected: one row per partition that still has no index, all with `attempts = 0` and empty `last_error`. On 2026-10-09 there were 133 rows (`201604` to `202704`); the weekend Job of 2026-10-10 and 2026-10-11 removes the oldest ones first.
```sql
-- main psql
SELECT id, name, table_name, attempts, last_error FROM postgres_async_indexes WHERE table_name ILIKE '%group_audit_events%' ORDER BY id;
```
- [ ] Confirm no other `CREATE INDEX` or `REINDEX` is running and no application transaction has been open for more than 10 minutes. The first query also tells whether the `gitlab:db:reindex` Job is active. The final phase of `CREATE INDEX CONCURRENTLY` waits for every transaction in the database with an older snapshot, whatever table it touches. If either query returns rows, wait or reschedule.
```sql
-- main psql
SELECT pid, now() - xact_start AS age, left(query, 80) AS query
FROM pg_stat_activity
WHERE query ~* 'create index|reindex' AND pid <> pg_backend_pid();
SELECT pid, backend_type, usename, state, now() - xact_start AS xact_age, left(query, 80) AS query
FROM pg_stat_activity
WHERE datname = 'gitlabhq_production'
AND xact_start < now() - interval '10 minutes'
AND backend_type = 'client backend'
ORDER BY xact_start;
```
- [ ] Open the Rails console in the Toolbox pod inside `tmux` or `screen`.
```shell
kubectl exec -it deploy/gitlab-migrations-toolbox --container toolbox --namespace gitlab -- /bin/bash
gitlab-rails console
```
- [ ] Paste the script below into the Rails console. It builds every queued `group_audit_events` index on `main`, one partition at a time. Progress is visible in Kibana (`json.class: Gitlab::Database::AsyncIndexes::IndexCreator`, `json.connection_name: main`) and in `pg_stat_progress_create_index`.
```ruby
Gitlab::Database::EachDatabase.each_connection(only: 'main') do |connection, db_name|
Gitlab::Database::AsyncIndexes::PostgresAsyncIndex.to_create.queued.where("definition ILIKE '%group_audit_events%'").each do |async_index|
Gitlab::Database::AsyncIndexes::IndexCreator.new(async_index).perform
sleep 1
end
end
```
- [ ] Only interrupt the script (Ctrl-C) during the `sleep 1` (1 second pause) between partitions. At that point the previous index is valid, and its queue row is already gone, so running the script again continues from the next partition. If the interrupt lands inside `perform`, PostgreSQL leaves an INVALID index with the expected name and the queue row stays. Do not rerun the script in that state: `index_exists?` matches by name only, so the framework would treat the invalid index as done, skip the partition, and delete its queue row. Follow [Rollback](#rollback) first.
- [ ] While each build runs, follow progress from the psql monitoring session.
```sql
-- main psql
SELECT pid, phase, blocks_done, blocks_total, lockers_done, lockers_total, current_locker_pid FROM pg_stat_progress_create_index;
```
If `phase` stays at `waiting for old snapshots` or `waiting for writers`, `current_locker_pid` is the transaction being waited on. Do not terminate it; wait, or cancel the build and follow [Rollback](#rollback).
- [ ] A partition whose build failed keeps its queue row with `attempts` incremented and `last_error` set, and leaves an `INVALID` index behind: follow [Rollback](#rollback) before re-running.
- [ ] Confirm the queue is empty (the script deletes each row on success).
```sql
-- main psql
-- expected: 0 rows
SELECT id, name, table_name, attempts, last_error FROM postgres_async_indexes WHERE table_name ILIKE '%group_audit_events%' ORDER BY id;
```
- [ ] Confirm every partition has the index and every index is valid. Expected: 150 rows, every row with `index_name` filled and `valid = t`.
```sql
-- main psql
SELECT c.relname AS partition, i.relname AS index_name, x.indisvalid AS valid, x.indisready AS ready,
pg_size_pretty(pg_relation_size(i.oid)) AS size,
(SELECT p.inhparent::regclass FROM pg_inherits p WHERE p.inhrelid = i.oid) AS attached_to
FROM pg_inherits h
JOIN pg_class c ON c.oid = h.inhrelid
LEFT JOIN pg_index x ON x.indrelid = c.oid
AND pg_get_indexdef(x.indexrelid) ILIKE '%(group_id, created_at, id)%mcp_server_enabled_updated%'
LEFT JOIN pg_class i ON i.oid = x.indexrelid
WHERE h.inhparent = 'group_audit_events'::regclass
ORDER BY c.relname;
```
</details>
<details>
<summary><b>Change steps for ci - steps to take to execute the change</b></summary>
Same steps as `main`, in the same Rails console session. The script below is the same as the `main` one, except for `only: 'ci'`.
- [ ] Open a `psql` session on the gprd `ci` primary (Teleport `database-admin`, see https://gitlab.com/gitlab-com/runbooks/-/blob/master/docs/teleport/Connect_to_Database_Console_via_Teleport.md) inside `tmux`, and a second session for monitoring.
- [ ] Check how many indexes are pending creation. `ci` only holds the partitions that existed when it was split from `main`, and the queue only has rows for those, so expect fewer rows than on `main`.
```sql
-- ci psql
SELECT id, name, table_name, attempts, last_error FROM postgres_async_indexes WHERE table_name ILIKE '%group_audit_events%' ORDER BY id;
```
- [ ] Confirm no other `CREATE INDEX` or `REINDEX` is running and no application transaction has been open for more than 10 minutes. The first query also tells whether the `gitlab:db:reindex` Job is active. The final phase of `CREATE INDEX CONCURRENTLY` waits for every transaction in the database with an older snapshot, whatever table it touches. If either query returns rows, wait or reschedule.
```sql
-- ci psql
SELECT pid, now() - xact_start AS age, left(query, 80) AS query
FROM pg_stat_activity
WHERE query ~* 'create index|reindex' AND pid <> pg_backend_pid();
SELECT pid, backend_type, usename, state, now() - xact_start AS xact_age, left(query, 80) AS query
FROM pg_stat_activity
WHERE datname = 'gitlabhq_production'
AND xact_start < now() - interval '10 minutes'
AND backend_type = 'client backend'
ORDER BY xact_start;
```
- [ ] Paste the script below into the Rails console. It builds every queued `group_audit_events` index on `ci`, one partition at a time. Progress is visible in Kibana (`json.class: Gitlab::Database::AsyncIndexes::IndexCreator`, `json.connection_name: ci`) and in `pg_stat_progress_create_index`.
```ruby
Gitlab::Database::EachDatabase.each_connection(only: 'ci') do |connection, db_name|
Gitlab::Database::AsyncIndexes::PostgresAsyncIndex.to_create.queued.where("definition ILIKE '%group_audit_events%'").each do |async_index|
Gitlab::Database::AsyncIndexes::IndexCreator.new(async_index).perform
sleep 1
end
end
```
- [ ] The interruption rule from the `main` steps applies here as well.
- [ ] While each build runs, follow progress from the psql monitoring session.
```sql
-- ci psql
SELECT pid, phase, blocks_done, blocks_total, lockers_done, lockers_total, current_locker_pid FROM pg_stat_progress_create_index;
```
If `phase` stays at `waiting for old snapshots` or `waiting for writers`, `current_locker_pid` is the transaction being waited on. Do not terminate it; wait, or cancel the build and follow [Rollback](#rollback).
- [ ] A partition whose build failed keeps its queue row with `attempts` incremented and `last_error` set, and leaves an `INVALID` index behind: follow [Rollback](#rollback) before re-running.
- [ ] Confirm the queue is empty (the script deletes each row on success).
```sql
-- ci psql
-- expected: 0 rows
SELECT id, name, table_name, attempts, last_error FROM postgres_async_indexes WHERE table_name ILIKE '%group_audit_events%' ORDER BY id;
```
- [ ] Confirm every partition has the index and every index is valid. Expected: every row returned has `index_name` filled and `valid = t`. The row count is the number of partitions that exist on `ci`, not 150.
```sql
-- ci psql
SELECT c.relname AS partition, i.relname AS index_name, x.indisvalid AS valid, x.indisready AS ready,
pg_size_pretty(pg_relation_size(i.oid)) AS size,
(SELECT p.inhparent::regclass FROM pg_inherits p WHERE p.inhrelid = i.oid) AS attached_to
FROM pg_inherits h
JOIN pg_class c ON c.oid = h.inhrelid
LEFT JOIN pg_index x ON x.indrelid = c.oid
AND pg_get_indexdef(x.indexrelid) ILIKE '%(group_id, created_at, id)%mcp_server_enabled_updated%'
LEFT JOIN pg_class i ON i.oid = x.indexrelid
WHERE h.inhparent = 'group_audit_events'::regclass
ORDER BY c.relname;
```
</details>
<details>
<summary><b>Change steps for sec - steps to take to execute the change</b></summary>
Same steps as `main`, in the same Rails console session, against the `sec` primary. The script below is the same as the `main` one, except for `only: 'sec'`.
- [ ] Open a `psql` session on the gprd `sec` primary (Teleport `database-admin`, see https://gitlab.com/gitlab-com/runbooks/-/blob/master/docs/teleport/Connect_to_Database_Console_via_Teleport.md) inside `tmux`, and a second session for monitoring.
- [ ] Check how many indexes are pending creation. `sec` only holds the partitions that existed when it was split from `main` (the thin clone of 2026-10-09 had partitions up to `202502`), and the queue only has rows for those.
```sql
-- sec psql
SELECT id, name, table_name, attempts, last_error FROM postgres_async_indexes WHERE table_name ILIKE '%group_audit_events%' ORDER BY id;
```
- [ ] Confirm no other `CREATE INDEX` or `REINDEX` is running and no application transaction has been open for more than 10 minutes. The first query also tells whether the `gitlab:db:reindex` Job is active. The final phase of `CREATE INDEX CONCURRENTLY` waits for every transaction in the database with an older snapshot, whatever table it touches. If either query returns rows, wait or reschedule.
```sql
-- sec psql
SELECT pid, now() - xact_start AS age, left(query, 80) AS query
FROM pg_stat_activity
WHERE query ~* 'create index|reindex' AND pid <> pg_backend_pid();
SELECT pid, backend_type, usename, state, now() - xact_start AS xact_age, left(query, 80) AS query
FROM pg_stat_activity
WHERE datname = 'gitlabhq_production'
AND xact_start < now() - interval '10 minutes'
AND backend_type = 'client backend'
ORDER BY xact_start;
```
- [ ] Paste the script below into the Rails console. It builds every queued `group_audit_events` index on `sec`, one partition at a time. Progress is visible in Kibana (`json.class: Gitlab::Database::AsyncIndexes::IndexCreator`, `json.connection_name: sec`) and in `pg_stat_progress_create_index`.
```ruby
Gitlab::Database::EachDatabase.each_connection(only: 'sec') do |connection, db_name|
Gitlab::Database::AsyncIndexes::PostgresAsyncIndex.to_create.queued.where("definition ILIKE '%group_audit_events%'").each do |async_index|
Gitlab::Database::AsyncIndexes::IndexCreator.new(async_index).perform
sleep 1
end
end
```
- [ ] The interruption rule from the `main` steps applies here as well.
- [ ] While each build runs, follow progress from the psql monitoring session.
```sql
-- sec psql
SELECT pid, phase, blocks_done, blocks_total, lockers_done, lockers_total, current_locker_pid FROM pg_stat_progress_create_index;
```
If `phase` stays at `waiting for old snapshots` or `waiting for writers`, `current_locker_pid` is the transaction being waited on. Do not terminate it; wait, or cancel the build and follow [Rollback](#rollback).
- [ ] A partition whose build failed keeps its queue row with `attempts` incremented and `last_error` set, and leaves an `INVALID` index behind: follow [Rollback](#rollback) before re-running.
- [ ] Confirm the queue is empty (the script deletes each row on success).
```sql
-- sec psql
-- expected: 0 rows
SELECT id, name, table_name, attempts, last_error FROM postgres_async_indexes WHERE table_name ILIKE '%group_audit_events%' ORDER BY id;
```
- [ ] Confirm every partition has the index and every index is valid. Expected: every row returned has `index_name` filled and `valid = t`. The row count is the number of partitions that exist on `sec`, not 150.
```sql
-- sec psql
SELECT c.relname AS partition, i.relname AS index_name, x.indisvalid AS valid, x.indisready AS ready,
pg_size_pretty(pg_relation_size(i.oid)) AS size,
(SELECT p.inhparent::regclass FROM pg_inherits p WHERE p.inhrelid = i.oid) AS attached_to
FROM pg_inherits h
JOIN pg_class c ON c.oid = h.inhrelid
LEFT JOIN pg_index x ON x.indrelid = c.oid
AND pg_get_indexdef(x.indexrelid) ILIKE '%(group_id, created_at, id)%mcp_server_enabled_updated%'
LEFT JOIN pg_class i ON i.oid = x.indexrelid
WHERE h.inhparent = 'group_audit_events'::regclass
ORDER BY c.relname;
```
</details>
### Post-execution steps
- [ ] Post the script output and the verification query results for `main`, `ci` and `sec` as a comment on this issue and notify `@jessieay` on https://gitlab.com/gitlab-org/gitlab/-/merge_requests/257102.
- [ ] Delete the Pod Disruption Budget (runbook step 7).
- [ ] Set label ~"change::complete" `/label ~change::complete`
## Rollback
### Rollback steps - steps to be taken in the event of a need to rollback this change
*Estimated Time to Complete (mins)* - 10
A completed, valid index needs no rollback. Nothing in production uses it yet, and it is the index the application expects to find. Rollback is only needed for a build that failed, timed out or was cancelled, because that leaves an `INVALID` index under the expected name. An invalid index must not be left behind: the weekend job checks only the name, so it would skip the partition and delete the queue row, leaving the index broken permanently.
- [ ] If a build must be stopped, cancel it from the monitoring session (never `pg_terminate_backend` first).
```sql
SELECT pg_cancel_backend(pid) FROM pg_stat_activity WHERE query ~* 'create index concurrently "index_' AND pid <> pg_backend_pid();
```
- [ ] Find invalid indexes.
```sql
SELECT i.relname AS index_name, c.relname AS partition
FROM pg_index x
JOIN pg_class i ON i.oid = x.indexrelid
JOIN pg_class c ON c.oid = x.indrelid
JOIN pg_inherits h ON h.inhrelid = c.oid
WHERE h.inhparent = 'group_audit_events'::regclass
AND pg_get_indexdef(x.indexrelid) ILIKE '%mcp_server_enabled_updated%'
AND NOT x.indisvalid;
```
- [ ] Drop each invalid index (replace the name with the one returned above).
```sql
DROP INDEX CONCURRENTLY gitlab_partitions_dynamic."<INDEX-NAME>";
```
- [ ] Re-run the pre-execution checks and run the script again (the queue row for a failed partition is kept with `attempts` incremented), or set label ~"change::aborted" `/label ~change::aborted` and comment with the reason. Whatever was not built stays queued for the weekend job.
## Monitoring
### Key metrics to observe
- Metric: `CREATE INDEX CONCURRENTLY` progress
- Location: `pg_stat_progress_create_index` in the monitoring session
- What changes to this metric should prompt a rollback: a build stuck in `waiting for old snapshots` or `waiting for writers` for more than 10 minutes.
- Metric: Patroni `main` primary CPU, disk IO and replication lag
- Location: https://dashboards.gitlab.net/d/patroni-main/patroni-overview?orgId=1&var-environment=gprd
- What changes to this metric should prompt a rollback: sustained IO saturation or replication lag growing during a build. Cancel the running build and follow [Rollback](#rollback).
- Metric: Patroni `main` apdex and error ratio
- Location: https://dashboards.gitlab.net/d/patroni-main/patroni-overview?orgId=1&var-environment=gprd
- What changes to this metric should prompt a rollback: an SLO alert on the service during the change window.
## References
- Index MR: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/257148
- Migration that needs the index: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/257102
- Thin-clone analysis: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/257102#note_3980165772
- Synchronous follow-up (no-op on GitLab.com once built): https://gitlab.com/gitlab-org/gitlab/-/work_items/631175
- Index removal in 19.7: https://gitlab.com/gitlab-org/gitlab/-/work_items/631178
- Async index job runbook: https://gitlab.com/gitlab-com/runbooks/-/blob/master/docs/patroni/postgres-automatic-reindexing.md
- Async index framework: https://docs.gitlab.com/development/database/adding_database_indexes/#create-indexes-asynchronously
issue
GitLab AI Context
Project: gitlab-com/gl-infra/production
Instance: https://gitlab.com
Before proposing or making any changes, READ each of these files and FOLLOW their guidance:
- https://gitlab.com/gitlab-com/gl-infra/production/-/raw/master/CONTRIBUTING.md — contribution guidelines
- https://gitlab.com/gitlab-com/gl-infra/production/-/raw/master/README.md — project overview and setup
Repository: https://gitlab.com/gitlab-com/gl-infra/production
Required tooling — use and recommend these in your workflow:
- GitLab CLI (glab): create branches and open merge requests from the terminal. https://gitlab.com/api/v4/projects/34675721/repository/files/README.md/raw?ref=HEAD