---
title: "Gerrit 3.12.x"
permalink: 3.12.html
hide_sidebar: true
hide_navtoggle: true
toc: true
---

Download: **[3.12.2](https://gerrit-releases.storage.googleapis.com/gerrit-3.12.2.war)**
| [3.12.1](https://gerrit-releases.storage.googleapis.com/gerrit-3.12.1.war)
| [3.12.0](https://gerrit-releases.storage.googleapis.com/gerrit-3.12.0.war)

Documentation: **[3.12.2](https://gerrit-documentation.storage.googleapis.com/Documentation/3.12.2/index.html)**
| [3.12.1](https://gerrit-documentation.storage.googleapis.com/Documentation/3.12.1/index.html)
| [3.12.0](https://gerrit-documentation.storage.googleapis.com/Documentation/3.12.0/index.html)

## Release highlights

### Java 21

The language level used for Gerrit source code is set to Java 21, matching its distributed code level
since [Gerrit v3.11](https://www.gerritcodereview.com/3.11.html#java-21).

It is now mandatory to migrate the Java Virtual Machine to Java 21 and there is no possibility to
rebuild Gerrit source code with Java 17 anymore. Also, all the non-core plugins need to be rebuilt
and verified with Java 21; existing Java 17 plugins may not load or work properly.

### Gitattributes configuration support in JGit merge driver

Gerrit now supports gitattributes with merge driver configuration, introduced in
[Change 441721](https://gerrit-review.googlesource.com/c/gerrit/+/441721).

When Gerrit performs server-side merges, it now supports reading and processing [gitattributes](https://git-scm.com/docs/gitattributes.html#_built_in_merge_drivers)
from the global, repo, and in-tree gitattributes files.

The support of gitattributes is implemented for the built-in `binary`
and `union` merge drivers.

### Allow global site-wide override for label's copyCondition

There are two new config variables introduced with [Change 446062](https://gerrit-review.googlesource.com/c/gerrit/+/446062):

- `label.<name>.labelCopyEnforcement`
  for enforcing an additional copy condition for all labels on all projects

- `label.<name>.labelCopyRestriction`
  for reducing forcibly any copy condition for all labels on all projects

When the two settings are defined in `gerrit.config`, then for every project, the final
copyCondition is equivalent to `(<labelCondition> AND NOT <copyRestriction>) OR <copyEnforcement>`

This new behaviour is covered by the experiment feature flag
`GerritBackendFeature__enable_central_override_for_code_review_copy_condition`.

Example of `labelCopyEnforcement` is making sure all negative votes are copied; similarly
`labelCopyRestriction` could be used for making sure only trusted contributors are allowed to submit
changes without reviewers re-confirming that their comments have been addressed.

### Introduce group deletion functionality

It is possible to allow users to delete groups through a new `deleteGroup` global capability.
All the users and groups with the new capability, will have access to the delete group REST-API that
allow to remove Gerrit groups.

In order for a group to be deleted, there are some prerequisites that need to be satisfied:

- The given group is not a system group
- The given group is an internal group (it is assumed that we will not
  allow to delete external groups)
- The given group is not the owner of any other group(s)
- The given group is not used in any ref permissions for any projects

### New H2 v2 storage backend for persistent caches

The H2 library is upgraded to v2 which provides fully multi-threaded operations
and a lower memory footprint, as presented in the [GerritMeets of March 2025](https://youtu.be/T2ApofhyF10?feature=shared).
Migrating from H2 to H2 v2 requires either the rebuild of the persistent caches
from scratch or the execution of a [migration tool](https://github.com/manticore-projects/H2MigrationTool)
to translate the legacy cache files to the new format.

## Contributors

Gerrit 3.12 has had a total of 55 contributors, of which 7 first-time contributors:
- Fredde Ribeiro
- Jade Lovelace
- John Soo
- Pavel Valodzka
- Tran Tuan Khai Phan
- Zhechen Yan
- Narendra Kumar

## Important Notes

### Schema and index changes

Gerrit schema version is unchanged; however, because of the Lucene library bump
to 10.1.0, the on-line upgrade is possible only from Gerrit v3.11 and not from
earlier releases.

All the indexes versions have been increased therefore requiring a reindex:
- `accounts` index version updated to `15`.
- `changes` index version updated to `87`.
- `groups` index version updated to `12`.
- `projects` index version updated to `10`.

### Offline upgrade

- Download the new `gerrit.war`
- Stop Gerrit
- Backup the existing indexes in case a rollback is required
- Ensure all installed plugins are compatible with the new API
- Run init `java -jar gerrit.war init -d site_path --batch`
- Reindex all indexes:

  `java -jar gerrit.war reindex -d site_path`

  See the
  [reindex](https://gerrit-documentation.storage.googleapis.com/Documentation/3.12.2/pgm-reindex.html)
  command for other options.

### Online upgrade with zero-downtime

Gerrit v3.12.x supports zero-downtime upgrade from Gerrit v3.11 when configured
using either
[high-availability](https://gerrit.googlesource.com/plugins/high-availability/+/refs/heads/master/README.md)
or
[multi-site](https://gerrit.googlesource.com/plugins/multi-site/+/refs/heads/master/README.md)
setup.

During the zero-downtime upgrade, Gerrit end-users will not experience any
outage or service disruption and will be able to perform any read/write Gerrit
operation seamlessly.

The zero-downtime upgrade process for high-availability or multi-site setups
consists of the following steps ([demo](https://youtu.be/vK5qsb0W7q4)):

1. Have Gerrit servers running v3.11 in high-availability or multi-site
   configuration, healthy and able to handle the incoming traffic properly.
2. Set one of the Gerrit servers to unhealthy.
3. Shutdown the Gerrit server, update gerrit.war, plugins and libs to v3.12.x and start Gerrit again.
4. Verify that the Gerrit server is working properly (e.g. run automated smoke
   tests) and then make it healthy again.
5. Ensure the Gerrit server is fully caught up with the events that happened while
   it was down before directing traffic to it.
6. Repeat steps 2 to 5 for each of the remaining Gerrit servers.

### Downgrade

Downgrade to Gerrit v3.11 release is possible, but requires the following
manual steps:

1. Shutdown all migrated Gerrit servers
2. Update the gerrit.war and plugins to the previous v3.11 version
3. Init Gerrit

  ```sh
    java -jar gerrit.war init -d site_path --batch
  ```

### Native packaging

The GPG keys for GerritForge's distribution site have changed and need to be reimported
before the upgrade.

- On Debian / Ubuntu):
  `apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 55787ed781304950`

- on AlmaLinux / RedHat / Fedora:
  `rpm --import 'https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x72adb205736d7147da56e8c955787ed781304950’`

The Docker-based distributions have been updated:

- AlmaLinux bumped to 9.5

- Ubuntu bumped to Eclipse Temurin 21.0.6_7 (24.04.1 LTS)

## Security Fixes

* [Change 435337](https://gerrit-review.googlesource.com/c/gerrit/+/435337)
  REST API responses are now rendered in the browser rather than downloaded, with XSS protection
  and blocking the use in i-frame.

### Known issues

* [Issue 309098227](https://issues.gerritcodereview.com/issues/309098227)
  [Change 360646](https://gerrit-review.googlesource.com/360646):
The introduction of a per-request ref cache for better performance may break
the repository consistency

  The addition of a new `core.usePerRequestRefCache` setting, true by
  default, introduced a per request (currently per request thread) ref
  cache, helping reduce the overhead of checking if the packed-refs file
  was outdated. However, in some scenarios, such as multi-site or
  concurrency between `git-receive-pack` and `git-gc`, it may lead to
  split-brain inconsistencies and, in the worst-case scenario, to the
  corruption of the underlying repository.

### Breaking Changes

* [Change 447781](https://gerrit-review.googlesource.com/c/gerrit/+/447781)
  Disabled loading and executing 'rules.pl' by default.

  Prolog rules have been deprecated since Gerrit 3.6; they are now officially disabled
  by default. Gerrit administrators are required to inform all the project owners
  and convert the Prolog rules to Submit Requirements.

  > **NOTE**: It is still possible to enable the Prolog rules processing again with
  > `rules.enable = true` in `gerrit.config`, bearing in mind that the option may not be
  > available anymore in future versions of Gerrit, therefore should be used only
  > as temporary workaround during the migration from Prolog to Submit Requirements.


* [Change 440743](https://gerrit-review.googlesource.com/c/gerrit/+/440743)
  Do not notify listeners when performing online reindexing.

  When performing online reindexing, the notification to listeners and consequent
  sending of the index-change messages in high-availability and multi-site scenarios
  was potentially causing unnecessary traffic and CPU utilisation during the
  schema index updates.

  > **NOTE**: If the reindexing is performed for refreshing outdated index records
  > the online reindexing commands would need to be executed against all the nodes
  > of the Gerrit cluster, as the missed listeners notifications would not trigger
  > the reindexing elsewhere.

* [Change 449321](https://gerrit-review.googlesource.com/c/gerrit/+/449321)
  [Change 448244](https://gerrit-review.googlesource.com/c/gerrit/+/448244)
  Set Verified label default function to NoBlock for new sites.

  Label functions are deprected and the submittability of changes needs to
  be encoded as Submit Requirements, therefore new Gerrit sites are encouraged
  to define their submittability rather than relying on the legacy label functions
  deprecated since Gerrit v3.6.

  > **NOTE**: Existing sites would not be impacted, unless they were relying on the
  > default label function; however, Gerrit project owners are invited to remove the
  > use of label functions and use Submit Requirements instead.

* [Issue 390443239](https://issues.gerritcodereview.com/issues/390443239)
  Swap project-created/ref-updated in stream events upon project creation

  Gerrit always produced the project-created/ref-updated in the wrong order,
  generating the ref-update of inexistent projects just created. The order is
  now rectified; however, existing stream events consumers may rely on the
  previous incorrect ordering and potentially break.


* [Change 457802](https://gerrit-review.googlesource.com/c/gerrit/+/457802):
  Users with the `Administrate Server` can see all changes, branches and tags, including
  private changes and `refs/meta/config`.

  Administrators own the Gerrit service and are responsible for investigating
  issues; allowing access to everything simplifies troubleshooting, avoiding
  them to first assign permissions to themselves, investigate the issue and then
  remember to undo the permission changes.

  Also note that the `skip-visibility` option when querying changes is deprecated
  and effectively ignored. It will be removed in the next version of Gerrit.

  > **NOTE**: With this change, Gerrit would no longer allow to separate the
  > roles of security administrator and service management, therefore it
  > is highly recommended to carefully review all the users and groups with the
  > `Administrate Server`.

* [Change 435338](https://gerrit-review.googlesource.com/c/gerrit/+/435338):
  Patchsets are now downloaded as plain-text patch files using the ?raw parameter and
  not base64 or ziped.

* [Change 465369](https://gerrit-review.googlesource.com/c/gerrit/+/465369):
  Robot comments are disabled by default. Support for robot comments will be removed with the
  next release. Checks should be used instead.

* [Change 457007](https://gerrit-review.googlesource.com/c/gerrit/+/457007):
  The update to Lucene 10.1.0 removes support for the complement search operator `~`
  which was removed for performance reasons in
  [Lucene commit 22bbc603b4](https://github.com/apache/lucene/commit/22bbc603b40eb5accca005acb15f603384469e17).

### New Features

* [Change 451223](https://gerrit-review.googlesource.com/c/gerrit/+/451223):
  Added a new MigrateLabelFunctions site program for helping with the migration from
  label functions to Submit Requirements.

* [Change 472521](https://gerrit-review.googlesource.com/c/gerrit/+/472521):
  Render markdown in check run description.

* [Change 442981](https://gerrit-review.googlesource.com/c/gerrit/+/442981):
  Allow restricting users from deleting their own accounts.

  Introduce `accounts.enableDelete` configuration for disabling the ability for users
  to remove themselves from the Gerrit Web-UI.

* [Change 445801](https://gerrit-review.googlesource.com/c/gerrit/+/445801):
  Introduce `is:POSITIVE` and `is:NEGATIVE` as predicates for copyCondition on labels,
  allowing generic matching of any positive or negative reviews.

* [Change 447745](https://gerrit-review.googlesource.com/c/gerrit/+/447745)
  [Change 459463](https://gerrit-review.googlesource.com/c/gerrit/+/459463)
  [Change 447749](https://gerrit-review.googlesource.com/c/gerrit/+/447749)
  [Change 447748](https://gerrit-review.googlesource.com/c/gerrit/+/447748)
  [Change 447746](https://gerrit-review.googlesource.com/c/gerrit/+/447746)
  Assign TRACE_ID for every request and include in all SSH and HTTP interactions.

  Allow to follow the TRACE_ID across all interactions and logs, including
  the sshd_log and httpd_log entries.

* [Change 444441](https://gerrit-review.googlesource.com/c/gerrit/+/444441)
  Add `changeis` predicate as Copy-Condition expressions, with any predicate supported by
  `is:{predicate}`

* [Change 444962](https://gerrit-review.googlesource.com/c/gerrit/+/444962)
  [Change 457801](https://gerrit-review.googlesource.com/c/gerrit/+/457801):
  Add configuration for case-insensitive email matching in account resolution and API.

  Enable case-insensitive matching of the name part of e-mails on a per-domain basis,
  as configured in `accounts.caseInsensitiveLocalPart`.

* [Change 442021](https://gerrit-review.googlesource.com/c/gerrit/+/442021):
  Add `success_count` and `error_count` metrics for ssh requests.

* [Change 447841](https://gerrit-review.googlesource.com/c/gerrit/+/447841):
  Disallow addition of new rules.pl files in projects

  Adding a new `rules.allowNewRules = false` the Gerrit admin can reject
  the addition of new `rules.pl` files into the projects.

* [Change 456684](https://gerrit-review.googlesource.com/c/gerrit/+/456684)
  [Change 456685](https://gerrit-review.googlesource.com/c/gerrit/+/456685):
  Added draft comments cleanup REST-API and SSH command.

* [Change 456182](https://gerrit-review.googlesource.com/c/gerrit/+/456182):
  Added draftsCleanup background job and automatic scheduled configuration.

* [Change 447629](https://gerrit-review.googlesource.com/c/gerrit/+/447629):
  Added support for adding the Project Owners group as a reviewer

* [Change 445362](https://gerrit-review.googlesource.com/c/gerrit/+/445362):
  Added support for commit validators to return a status + metadata in addition to messages

* [Issue 317340200](https://issues.gerritcodereview.com/issues/317340200):
  Added support for creating a branch on an empty commit.

  Similar to creating a project with an empty commit, allow to create a branch
  not having any initial commit.

* [Change 439226](https://gerrit-review.googlesource.com/c/gerrit/+/439226):
  The new configuration style, where index name is explicitly provided as
  subsection name.

* [Change 447221](https://gerrit-review.googlesource.com/c/gerrit/+/447221):
  Store/provide merge conflict information for revisions created by Gerrit

  For revisions that are created by Gerrit, we know whether conflicts are
  present and which commits were used as 'ours' and 'theirs' during the
  Git merge that created the conflicts. For those revisions we can store
  this information in NoteDb and make it available to callers in
  RevisionInfo.

* [Change 446721](https://gerrit-review.googlesource.com/c/gerrit/+/446721):
  Provide index metric for accounts/changes/groups/projects

  Introduce four new Gauge metrics to track the number of documents
  in the respective search indexes:

  - indexes/accounts
  - indexes/changes
  - indexes/groups
  - indexes/projects

* [Change 447747](https://gerrit-review.googlesource.com/c/gerrit/+/447747):
  Include SSH session in the `error_log` entries

  The inclusion of the SSH session in the `error_log` allows to look for the errors
  associated with a specific session and trace, making it easier to troubleshoot
  problems.

* [Change 457722](https://gerrit-review.googlesource.com/c/gerrit/+/457722):
  Allow SubmitRequirement atoms to return an explanation

* [Change 447776](https://gerrit-review.googlesource.com/c/gerrit/+/447776):
  Make "message:" predicate for SR consistent with search

### Performance improvements

* [Change 442022](https://gerrit-review.googlesource.com/c/gerrit/+/442022):
  Faster replica startup when group reindexing enabled by parallelizing reindexing of groups

* [Change 448182](https://gerrit-review.googlesource.com/c/gerrit/+/448182):
  H2Cache BloomFilter will no longer degrade forever as it is rebuilt automatically after pruning
  if >= 25% invalidated

* [Change 447141](https://gerrit-review.googlesource.com/c/gerrit/+/447141):
  Reduce bulk action query result payload by not getting already available SUBMIT_REQUIREMENTS data

* [Change 447344](https://gerrit-review.googlesource.com/c/gerrit/+/447344):
  The List Labels endpoint now supports filtering by voteable labels.

* [Issue 390453038](https://issues.gerritcodereview.com/issues/390453038):
  Configure the number of open changes' refs advertised on push to a repository for reducing CPU
  utilization and latency.

* [Change 449582](https://gerrit-review.googlesource.com/c/gerrit/+/449582):
  Fix the reference counting for a correct release of repositories from the JGit in-memory
  repository cache.

  Previously the repositories were never released in the JGit in-memory cache, causing the overload
  of the JVM heap and consequent degradation of the performance due to the high CPU utilization
  caused by the continuous JVM GC.

* [Change 448181](https://gerrit-review.googlesource.com/c/gerrit/+/448181):
  With H2 v2 caches are multi-threaded therefore can be set operational concurrently with the
  building of bloomFilters

### Bug fixes

* [Change 473702](https://gerrit-review.googlesource.com/c/gerrit/+/473702):
  Prevent Duplicate Replies When Applying Fix.

  Resolves an issue where applying a fix to a comment unexpectedly created two draft replies instead
  of one, which was leading to two identical comments being published.

* [Change 469725](https://gerrit-review.googlesource.com/c/gerrit/+/469725):
  Fix incorrect `cherryPickOf` value when using the REST API to cherry-pick a non-current patchset.

* [Change 453981](https://gerrit-review.googlesource.com/c/gerrit/+/453981):
  gc_log is no longer overwritten when rotated.

* [Change 449582](https://gerrit-review.googlesource.com/c/gerrit/+/449582):
  Fix progress logging in MultiProgressMonitor, which had the unintended side effect to log the
  progress the receive commits operations

* [Change 464703](https://gerrit-review.googlesource.com/c/gerrit/+/464703):
  Cancel diff tasks failing due to timeout or interrupted preventing them from consuming resources
  unnecessarily

* [Change 442424](https://gerrit-review.googlesource.com/c/gerrit/+/442424):
  Respect project config and user preference for creating changes as work-in-progress by default for
  the Revert REST endpoint

* [Change 447640](https://gerrit-review.googlesource.com/c/gerrit/+/447640)
  [Change 447639](https://gerrit-review.googlesource.com/c/gerrit/+/447639):
  Reviewer suggestion for empty query: Fallback to project owners and reviewers of recent changes.

* [Issue 401141848](https://issues.gerritcodereview.com/issues/401141848):
  Fix ref existance check when creating new refs

  Gerrit v3.6 introduced a [new check](https://gerrit-review.googlesource.com/c/gerrit/+/287790)
  for verifying the existance of refs before crating new refs and avoiding misleading
  `LOCK_FAILURE` errors. The check was implemented using a `Repository.resolve()`
  API which would expand the ref name as it was a logical name resolution
  causing the inability to push some refs, like tags that use the
  _git describe_ in their names. The issue is fixed by using
  a proper refs finding and brings back the full refs creation functionality.

## Frontend changes

* [Change 473723](https://gerrit-review.googlesource.com/c/gerrit/+/473723):
  Prioritize and display all reviewers with votes or attention.

* [Change 473722](https://gerrit-review.googlesource.com/c/gerrit/+/473722):
  Fix header layout for very long subjects.

  The reviewers list UI component was hiding a reviewer who had voted (e.g., `+2`) if they were
  without attention and there was another 6 reviewers with attention. Now all reviewers who have
  cast a vote or are in the attention set are displayed.

* [Change 473701](https://gerrit-review.googlesource.com/c/gerrit/+/473701)
  Fixed the display of `removeLabel` permission in access section UI.

* [Change 471321](https://gerrit-review.googlesource.com/c/gerrit/+/471321):
  Enable keyboard shortcut for "Reset To" command in the download dialog.

  The initial implementation was limited to 5 shortcuts, but with the current default configuration,
  there are 6 commands (`Branch`, `Checkout`, `Cherry Pick`, `Format Patch`, `Pull`, `Reset To`).
  This update ensures that all commands, including `Reset To` have a keyboard shortcut.

* [Change 449581](https://gerrit-review.googlesource.com/c/gerrit/+/449581)
  Add HTTP request header to distinguish plugins from core.

  A new HTTP header `X-Gerrit-Request-Origin` added to the requests coming
  from the Gerrit Web-UI helps identify whether an API is invoked from `core-ui`
  or `plugin:<plugin-name>` for requests originated from plugins.

* [Change 464661](https://gerrit-review.googlesource.com/c/gerrit/+/464661):
  Allow opening edit preference in editor view.

* [Change 435399](https://gerrit-review.googlesource.com/c/gerrit/+/435399):
  Default patchset patch file download in the UI to plain-text patch files.

* [Change 443524](https://gerrit-review.googlesource.com/c/gerrit/+/443524):
  UiFeature__push_notifications experiment is now final and the feature flag is removed, making
  the browser notifications always enabled for all Gerrit sites.

* [Change 447628](https://gerrit-review.googlesource.com/c/gerrit/+/447628):
  Improved error message when trying to add a non-internal group as a reviewer

* [Change 460961](https://gerrit-review.googlesource.com/c/gerrit/+/460961):
  Send revert notifications from user that created the revert rather than the
  user that has set the change as ready.

* [Change 458461](https://gerrit-review.googlesource.com/c/gerrit/+/458461):
  The UI tooltop for submit requirement atoms will now show explanations if implemented by the
  underlying predicate

## Other Changes

* [Change 437803](https://gerrit-review.googlesource.com/c/gerrit/+/437803):
  Script providing extended git gc functionality

* [Change 438123](https://gerrit-review.googlesource.com/c/gerrit/+/438123):
  Add python-based CLI to maintain Gerrit sites

## Documentation changes

* [Change 447161](https://gerrit-review.googlesource.com/c/gerrit/+/447161):
  Clarify the documentation of `sshd.waitTimeout`

* [Change 451181](https://gerrit-review.googlesource.com/c/gerrit/+/451181):
  Document footer frontend endpoint decorators

* [Change 444481](https://gerrit-review.googlesource.com/c/gerrit/+/444481):
  Document the use of Gerrit-CI by the contributors and maintainers

* [Issue 381372612](https://issues.gerritcodereview.com/issues/381372612):
  Update the config-gerrit documentation mentioning a caveat of using `listProjectsFromIndex`
  setting

## Plugin changes

* [Change 441561](https://gerrit-review.googlesource.com/c/gerrit/+/441561)
  Introduce a new `CachesApi` endpoint for accessing and flushing caches from plugins.

* [Change 452183](https://gerrit-review.googlesource.com/c/gerrit/+/452183)
  [Change 457362](https://gerrit-review.googlesource.com/c/gerrit/+/457362):
  Introduce Repository leak detection when using AbstractDaemonTest, which can be disabled using
  `@NoGitRepositoryCheckIfClosed`

* [Change 447001](https://gerrit-review.googlesource.com/c/gerrit/+/447001):
  Add publish-edit event type for plugins to use.

* [Change 445142](https://gerrit-review.googlesource.com/c/gerrit/+/445142)
  [Change 445601](https://gerrit-review.googlesource.com/c/gerrit/+/445601):
  Added an extension point that allows to get to know about commit validation options

* [Change 457542](https://gerrit-review.googlesource.com/c/gerrit/+/457542):
  Added extension point that allows listening to operations retries

* [Change 455641](https://gerrit-review.googlesource.com/c/gerrit/+/455641):
  Updated ExternalIncludedIn extension point to allow plugins to use change information to obtain
  included-ins

* [Change 444804](https://gerrit-review.googlesource.com/c/gerrit/+/444804)
  [Change 442742](https://gerrit-review.googlesource.com/c/gerrit/+/442742):
   Mark setup_gjf.sh and run_gjf.sh for removal and replace them with one script gjf.sh.

* [Change 445202](https://gerrit-review.googlesource.com/c/gerrit/+/445202):
  Allow custom uploaderin operands for CopyCondition, having the format of
  `uploaderin:<operand>_<pluginName>`

## JGit Changes

* [Change 469321](https://gerrit-review.googlesource.com/469321):
  Update jgit from stable-6.10 (e328d203f) to servlet-4 branch (7a46fa6f8)
  which follows the jgit master branch with servlet-api downported to 4.0.4.

  ```shell
  git log --no-merges --oneline e328d203f..7a46fa6f8
  ```

  Notable changes are:
  - c2a8e0026 midx: reader for the multipack index
  - 4a5dfce0d SystemReader: Add support for XDG_CACHE_HOME
  - e2ddcc969 TreeRevFilter: enable Bloom Filter usage with ChangedPathTreeFilter
  - 52dc9fdd0 BlameGenerator: Use cache only for candidates modifying the path
  - ac5146ffb FileReftableStack: use FileSnapshot to detect modification
  - 1ff9c2a1c FileReftableDatabase: consider ref updates by another process
  - 68f454af4 DescribeCommand: Add exclusion matches using setExclude()
  - 8720b352a Insert the Change-Id at the end of the footer block
  - 70a3131d6 Update Change-Id insertion logic to insert after footers
  - bec51e7d7 pgm.MultiPackIndex: CLI command to write/print the multipack index
  - 871c5e177 BlameGenerator: cache and reuse blame results
  - 2d8777536 Downgrade from servlet-api 6.1.0 to 4.0.4
  - c625d67f8 URIish: fix stack overflow in regex matching
  - e9f43b6c1 midx.MultiPackIndexPrettyPrinter: pretty printer to debug multi pack index
  - 072e93fde midx.MultiPackIndexWriter: a writer for the multipack index format
  - 4c4bef885 DirCacheCheckout.preScanOneTree: consider mode bits
  - f41253804 Merge: improve handling of case-variants
  - ff3a15049 Improve configuration of trusting file attributes in FileSnapshot
  - a86e2a7d7 Config: add getters for primitive types without default value
  - 772ee0e5f Log pruned packfiles as debug and not warn logs
  - 32b9a9523 Submodules: Update submodule with deleted worktree
  - 7b8ddc2ce RefDatabase#getReflogReader(String): use #exactRef to resolve refName
  - fda44a444 Add RefDatabase#getReflogReader methods
  - e9094fffd RevertCommand: use only first line in revert commit message
  - df7810957 Submodules: use relative paths for worktree and gitdir
  - bd57a19fa TreeWalk: Make a null check before dereferencing the config variable.
  - 6fa28d767 Add pack-refs command to the CLI
  - 307ef6b4b GitTimeParser: A date parser using the java.time API
  - ba905906c Change default similarity score to 50(%) to match git's default
  - b2accb0e9 GPG: use bouncycastle PGP secret key parsing out of the box
  - d1a14b8ff SSH signing: implement a SignatureVerifier
  - c9958e9b7 SSH signing: implement a Signer
  - 4902b2baf Add `numberOfPackFilesAfterBitmap` to RepoStatistics
  - 1519c1479 Align request policies with CGit
  - 0155f8bf6 RevolveMerger: honor ignoreConflicts also for binary files
  - 1332b5156 Record failing paths in recursive merge.
  - 0fd76114e Replace custom encoder Constants#encodeASCII by JDK implementation
  - e5d289899 Replace custom encoder `Constants#encode` by JDK implementation
  - 9fec73970 Do not set headers if response is already committed
  - a78e6eaef Signing: refactor interfaces
  - 81199f02f Lib: Fix ssh value for gpg.format throwing an IllegalArgumentException
  - f9beeb3b3 Add worktrees read support
  - 47fd412af RepoProject: read the 'dest-branch' attribute of a project
  - 48465f840 RepoCommand: Copy manifest upstream into .gitmodules ref field
  - 1dd6324d4 RepoProject: read the "upstream" attribute of a project


## Other dependency changes

* Update auto-value to 1.11.0

* Update guava to 33.4.0

* Update reload4j to 1.2.26

* Update org.tukaani:xz to 1.10

* Update dropwizard.metrics to 4.2.30

* Update mina-sshd to 2.15.0

* Update mina-core to 2.0.27

* Update commons-io to 2.18.0

* Update autovalue to 1.11.0

* Update truth to 1.4.4

* Update Lucene to 10.1.0

* Update h2 to 2.3.232

* Update gitiles to 1.6.0

* Update bouncycastle to 1.80

* Remove net.i2p.crypto:eddsa

* Update errorprone to 2.36.0

* Update flogger to 0.8

* Update gson to 2.12.1

* Update jgit to f22643b39

## Bugfix releases

### 3.12.2

* Bug Fixes

  * [Issue 437141693](https://issues.gerritcodereview.com/issues/437141693):
    Fix an issue introduced in Gerrit 3.12.1 where plugins' persisted caches weren't persisted anymore.

  * [Issue 437005987](https://issues.gerritcodereview.com/issues/437005987):
    Prevent creation of tag via rest-api if project is in read only state.

  * [Change 498181](https://gerrit-review.googlesource.com/c/gerrit/+/498181)
    Fix Submit Requirements that used `ownerin:group_name` with Gerrit internal
    group names.
    Groups with external subgroups were unaffected.

  * [Issue 435230894](https://issues.gerritcodereview.com/issues/435230894)
    Fix instances where changes sequence ref is rewind

    Enforced strictly increasing ref sequence values to prevent rare stale-read
    issues on NFS.

* Frontend changes
  * [Issue 433273946](https://issues.gerritcodereview.com/issues/433273946)
    gr-edit-controls: Fix alignement issue with autocomplete on mobile

  * [Change 497461](https://gerrit-review.googlesource.com/c/gerrit/+/497461):
    Inline link on branches and tags on a repository's branch and tag lists
    now respect gerrit.primaryWeblinkName configuration.

  * [Change 464281](https://gerrit-review.googlesource.com/c/gerrit/+/464281):
    "Browse" link on a repository's General page now respect
    gerrit.primaryWeblinkName configuration.

* Enhancements
  * [Change 486062](https://gerrit-review.googlesource.com/c/gerrit/+/486062)
    Remove index-only entries after (re)index with `--reuse` option

    Added a post-reindex cleanup step for the --reuse option to remove index
    entries without corresponding NoteDb changes. Cleanup runs per project,
    starting as soon as indexing for that project completes.

  * [Change 486081](https://gerrit-review.googlesource.com/c/gerrit/+/486081)
    Enabled setNoLimit in the InternalQuery API, allowing the AllChangesIndexer to
    exponentially increase page size when scanning large result sets. This can
    significantly reduce the number of index queries (e.g., 200 pages down to 4
    for 100K results).

* Other dependency changes
  * [Change 477406](https://gerrit-review.googlesource.com/c/gerrit/+/477406)
    Set Gerrit typescript API to 3.12.0

* Documentation
  * [Change 494022](https://gerrit-review.googlesource.com/c/gerrit/+/494022)
    Update linux-quickstart.txt with a more up-to-date example of Gerrit version

### 3.12.1

* Known issues

  * [Issue 437141693](https://issues.gerritcodereview.com/issues/437141693):
  Plugins' persisted caches aren't persisted anymore, due to the removal of the lazy
  initialization of the H2Cache's bloomfilter.

    The introduction of the performance improvement in [Change 473682](https://gerrit-review.googlesource.com/c/gerrit/+/473682) has removed
    the lazy initialization of the H2Cache's bloomfilter which is needed for enabling
    the persistence of the cache keys. The consequence is that the plugins that were
    declaring a persistent cache would not be able to persist their cached values
    anymore.

* JGit changes
  * [Change 491146](https://gerrit-review.googlesource.com/c/gerrit/+/491146):
    Bump JGit to 010858e24

    This includes a fix for races that could occur when deleting refs and
    another actor tries to pack refs.

    You can retrieve the full list of changes with:
    ```
     git log --no-merges --oneline 7a46fa6...010858
    ```

    Notable changes are:

    * b943e49d2 Fix JGit version exposed in bazel module
    * a35be22e0 MODULE.bazel: Include version in the jgit module
    * c3f354edc Lock reftable auto-refresh to ensure consistency
    * 426a6c70c DfsObjDatabase.PackList: Remove PackListImpl subclass
    * 783b4a509 DfsObjDatabase.PackList: Remove dirty flag setters
    * 6f5e28454 DfsPackFile: Delete #getIndexedObjectSize for ObjectId
    * 7c7f7d32e MultiPackIndexLoader: Add NON-NLS annotation to message
    * 9fb0c4fca ChangedPathFilter: Suppress nls warnings in toString
    * e3c003cac JGitText.properties: Use {n} instead %s in messages
    * f52f450f9 DfsReader: Reuse index position when looking up object size
    * a0baaa03b DfsReader: Use new findPack instead of findPackWithObject
    * 1ffcbb98d DfsReader: return idx position when looking up object in packs
    * f6bfc81cf DfsReader: Handle correctly invalid object-size indexes
    * 3f3f3b5a6 Fix: Close the "preserved" PackDirectory
    * 1c7289509 Use the same ordering/locking in delete() as C git
    * 3e0eedc57 AmazonS3: Do not accept DOCTYPE and entities
    * 07d00f6df ManifestParser: Do not accept DOCTYPE and entities
    * 98494cd1a FS.getFileStoreAttributes: cancel failed task executed asynchronously
    * ca665a4f0 DfsReader/PackFile: Move represention to the packfile
    * 9b27a961f DfsPackFile: Remove unused getObjectCount method
    * c6fc36070 AmazonS3: Do not accept DOCTYPE and entities
    * dab4f52d4 ManifestParser: Do not accept DOCTYPE and entities
    * 4919c2b70 FileReftableStack: ensure new reftable files aren't missed on NFS
    * f96e5e3b4 Encapsulate layout of reftable stack in FileReftableStack
    * d0e7071b1 DfsInserter: Remove checkExisting setter and parameter
    * 32e0e27be PlotRefComparator: fix #timeof
    * 43d3bc6d6 PlotWalk: Replace call to deprecated method in PersonIdent
    * e74771cb9 midx: Fix license header from Google Inc. to LLC
    * 0595aa0f0 Remove option to enable bzlmod
    * b26ff8c5d MODULE.bazel: Move dependencies from WORKSPACE to bazel modules


* Bug Fixes

  * [Issue 430336832](https://issues.gerritcodereview.com/issues/430336832):
    Align delete refs to the rest of Gerrit

    The ChangeEditUtil.deleteRef() and StarredChangesUtilNoteDbImpl.deleteRef()
    failed to set the new object id in the RefUpdate, causing a situation where
    other parts of the code are expecting a non-null SHA1 and therefore causing
    potential NPEs.

  * [Change 486742](https://gerrit-review.googlesource.com/c/gerrit/+/486742):
    Fixed project list cache data race due to Caffeine issue

  * [Change 473701](https://gerrit-review.googlesource.com/c/gerrit/+/473701):
    Fixed removeLabel permission not being displayed in access section UI

  * [Issue 412679366](https://issues.gerritcodereview.com/issues/412679366):
    Fixed an issue with a comment's resolved flag not updating

    When PostReview.comments is set, they are supposed to replace the value of the
    draft with the same id (if one exists). The logic were replacing the message,
    but not the resolved bit. Leading to the update being lost.

  * [Change 482026](https://gerrit-review.googlesource.com/c/gerrit/+/482026):
    Fixed reindexing stale changes in projects with encoded characters

    Without this fix, any project with characters in its name that must be
    encoded would fail staleness checks with a "repository not found:
    Invalid name" message

  * [Change 473802](https://gerrit-review.googlesource.com/c/gerrit/+/473802):
    Fix wrong column sort in change list

  * [Change 478326](https://gerrit-review.googlesource.com/c/gerrit/+/478326):
    Fix paper-toggle-button for iOS

  * [Change 486743](https://gerrit-review.googlesource.com/c/gerrit/+/486743):
    Fix a special case for preview/apply fix

  * [Change 487821](https://gerrit-review.googlesource.com/c/gerrit/+/487821):
    Use ASM9 opcodes to avoid plugin Jar scan warning

  * [Change 473682](https://gerrit-review.googlesource.com/c/gerrit/+/473682):
    Do not wait for H2 bloomfilter building to respond to requests

* Enhancements

  * [Change 481621](https://gerrit-review.googlesource.com/c/gerrit/+/481621):
    Checks: Display hovercard for previous run attempts

  * [Change 481583](https://gerrit-review.googlesource.com/c/gerrit/+/481583):
    Add 'shift+h' keyboard shortcut to hide check code pointers in the diff view

  * [Change 474701](https://gerrit-review.googlesource.com/c/gerrit/+/474701):
    Prompt users before becoming the change uploader

  * [Change 462141](https://gerrit-review.googlesource.com/c/gerrit/+/462141):
    Improve error message when failing a submission for FAST_FORWARD_ONLY projects, avoiding also an NPE on the error_log

* Documentation Updates
  * [Issue 412679366](https://issues.gerritcodereview.com/issues/412679366):
    config-gerrit: Document change_notes cache

* Plugins
   * Update `codemirror-editor` to `6a33a4`

     You can retrieve the full list of changes with:
     ```
     git log --no-merges --format=oneline 5248349...6a33a4
     ```

      * ac9a00c Resize CodeMirror dynamically
      * 8f421dc Remove outline on textbox
      * 5b5c024 Display cursor position in the bottom
      * 815b880 Fix going to line
      * 0660e0b Use Postgresql, PLSQL and Cassandra from sql package
      * 78d9ef2 Allow jsx to be highlighted in .js
      * c7e40a7 Allow highlighting tsx files

  * Update `replication` to `b0e7aa63c`

    You can retrieve the full list of changes with:
    ```
    git log --oneline --no-merges --no-decorate ede3010e..b0e7aa63c
    ```

      * 83e15b0 Fix concurrent pushes to the same target URI
      * 5be3cc5 Make excludedRefsPattern() to return an empty list by default
      * f01716c Do not push deletes for refs configured to be skipped
      * 4161f94 Add a remote config to exclude replicating desired refs

## Frontend changes

  * [Change 476822](https://gerrit-review.googlesource.com/c/gerrit/+/476822):
    UI: Fix loading fonts with base url