From d639a965bce7acafb004906cd07a8f0b5f7af993 Mon Sep 17 00:00:00 2001
From: Pierre Guillot <pierre.guillot@sonarsource.com>
Date: Tue, 10 Dec 2024 15:29:09 +0100
Subject: SONAR-22998 fetch active rules with a dedicated endpoint

Co-authored-by: Julien HENRY <julien.henry@sonarsource.com>
---
 .../sonar/db/qualityprofile/ActiveRuleDaoIT.java   |  74 +++++++-
 .../org/sonar/db/qualityprofile/ActiveRuleDao.java |  15 +-
 .../org/sonar/db/qualityprofile/ActiveRuleDto.java |  51 ++++-
 .../sonar/db/qualityprofile/ActiveRuleMapper.java  |   4 +-
 .../sonar/db/qualityprofile/QualityProfileDao.java |   7 +-
 .../src/main/java/org/sonar/db/rule/RuleDto.java   |   6 +-
 .../sonar/db/qualityprofile/ActiveRuleMapper.xml   |  39 +++-
 .../org/sonar/server/rule/ActiveRuleServiceIT.java | 206 ++++++++++++++++++++
 .../sonar/server/rule/ActiveRuleRestReponse.java   | 123 ++++++++++++
 .../org/sonar/server/rule/ActiveRuleService.java   | 177 ++++++++++++++++++
 .../org/sonar/server/rule/CachingRuleFinder.java   |   1 -
 .../java/org/sonar/server/v2/WebApiEndpoints.java  |   1 +
 .../analysis/controller/ActiveRulesController.java |  47 +++++
 .../controller/DefaultActiveRulesController.java   |  38 ++++
 .../api/analysis/service/ActiveRulesHandler.java   |  27 +++
 .../analysis/service/ActiveRulesHandlerImpl.java   |  47 +++++
 .../server/v2/config/PlatformLevel4WebConfig.java  |  20 ++
 .../DefaultActiveRulesControllerTest.java          | 107 +++++++++++
 .../service/ActiveRulesHandlerImplTest.java        |  71 +++++++
 .../java/org/sonar/core/rule/ImpactFormatter.java  |   1 +
 .../api/batch/rule/internal/NewActiveRule.java     |  14 ++
 .../mediumtest/bootstrap/BootstrapMediumIT.java    |   9 +-
 .../scanner/mediumtest/issues/ChecksMediumIT.java  |   3 +-
 .../scanner/mediumtest/issues/IssuesMediumIT.java  |   6 +-
 .../language/DefaultLanguagesLoader.java           |   4 +-
 .../org/sonar/scanner/rule/ActiveRulesLoader.java  |   2 +-
 .../sonar/scanner/rule/ActiveRulesProvider.java    |  51 +----
 .../scanner/rule/DefaultActiveRulesLoader.java     | 173 ++++++++---------
 .../org/sonar/scanner/rule/LoadedActiveRule.java   |  12 +-
 .../scanner/rule/ActiveRulesProviderTest.java      |  69 +++----
 .../scanner/rule/DefaultActiveRulesLoaderTest.java | 208 +++++++++++++--------
 .../scanner/mediumtest/ScannerMediumTester.java    |   4 +
 32 files changed, 1319 insertions(+), 298 deletions(-)
 create mode 100644 server/sonar-server-common/src/it/java/org/sonar/server/rule/ActiveRuleServiceIT.java
 create mode 100644 server/sonar-server-common/src/main/java/org/sonar/server/rule/ActiveRuleRestReponse.java
 create mode 100644 server/sonar-server-common/src/main/java/org/sonar/server/rule/ActiveRuleService.java
 create mode 100644 server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/controller/ActiveRulesController.java
 create mode 100644 server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/controller/DefaultActiveRulesController.java
 create mode 100644 server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandler.java
 create mode 100644 server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandlerImpl.java
 create mode 100644 server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/analysis/controller/DefaultActiveRulesControllerTest.java
 create mode 100644 server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandlerImplTest.java

diff --git a/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/ActiveRuleDaoIT.java b/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/ActiveRuleDaoIT.java
index b229d7895b6..eeebb9d5b9e 100644
--- a/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/ActiveRuleDaoIT.java
+++ b/server/sonar-db-dao/src/it/java/org/sonar/db/qualityprofile/ActiveRuleDaoIT.java
@@ -62,6 +62,7 @@ import static org.sonar.api.rule.Severity.MAJOR;
 import static org.sonar.db.qualityprofile.ActiveRuleDto.INHERITED;
 import static org.sonar.db.qualityprofile.ActiveRuleDto.OVERRIDES;
 import static org.sonar.db.qualityprofile.ActiveRuleDto.createFor;
+import static org.sonar.db.rule.RuleDto.deserializeSecurityStandardsString;
 
 class ActiveRuleDaoIT {
 
@@ -112,6 +113,19 @@ class ActiveRuleDaoIT {
     rule2Param1 = db.rules().insertRuleParam(rule2);
   }
 
+  @Test
+  void selectAllParamsByProfileUuids() {
+    ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
+    underTest.insert(dbSession, activeRule);
+    ActiveRuleParamDto activeRuleParam1 = ActiveRuleParamDto.createFor(rule1Param1);
+    underTest.insertParam(dbSession, activeRule, activeRuleParam1);
+    ActiveRuleParamDto activeRuleParam2 = ActiveRuleParamDto.createFor(rule1Param2);
+    underTest.insertParam(dbSession, activeRule, activeRuleParam2);
+    dbSession.commit();
+
+    assertThat(underTest.selectAllParamsByProfileUuids(dbSession, List.of(profile1.getKee()))).hasSize(2);
+  }
+
   @Test
   void selectByKey() {
     ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
@@ -183,6 +197,50 @@ class ActiveRuleDaoIT {
     assertThat(underTest.selectByProfile(dbSession, profile1)).isEmpty();
   }
 
+  @Test
+  void selectByProfileUuids_ignores_removed_rules() {
+    ActiveRuleDto activeRule = createFor(profile1, removedRule).setSeverity(BLOCKER);
+    underTest.insert(dbSession, activeRule);
+
+    assertThat(underTest.selectByProfileUuids(dbSession, List.of(profile1.getKee()))).isEmpty();
+  }
+
+  @Test
+  void selectByProfileUuids_exclude_other_profiles() {
+    ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
+    underTest.insert(dbSession, activeRule);
+    ActiveRuleDto activeRule2 = createFor(profile2, rule2).setSeverity(BLOCKER);
+    underTest.insert(dbSession, activeRule2);
+
+    assertThat(underTest.selectByProfileUuids(dbSession, List.of(profile1.getKee()))).hasSize(1);
+  }
+
+  @Test
+  void selectByProfileUuids_returns_all_fields() {
+    ActiveRuleDto activeRule = createFor(profile1, rule1).setSeverity(BLOCKER);
+    underTest.insert(dbSession, activeRule);
+
+    List<OrgActiveRuleDto> actualActiveRule = underTest.selectByProfileUuids(dbSession, List.of(profile1.getKee()));
+    // verify data from the "rules" table
+    assertThat(actualActiveRule)
+      .extracting(OrgActiveRuleDto::getRuleKey, org -> deserializeSecurityStandardsString(org.getSecurityStandards()), OrgActiveRuleDto::isExternal, OrgActiveRuleDto::getName,
+        OrgActiveRuleDto::getConfigKey, OrgActiveRuleDto::getTemplateUuid, OrgActiveRuleDto::getLanguage)
+      .containsExactly(
+        tuple(rule1.getKey(), rule1.getSecurityStandards(), rule1.isExternal(), rule1.getName(), rule1.getConfigKey(), rule1.getTemplateUuid(), rule1.getLanguage()));
+
+    // verify data from "active_rules" table
+    assertThat(actualActiveRule)
+      .extracting(OrgActiveRuleDto::getUuid, OrgActiveRuleDto::getProfileUuid, OrgActiveRuleDto::getRuleUuid, OrgActiveRuleDto::getSeverity, OrgActiveRuleDto::getInheritance,
+        OrgActiveRuleDto::isPrioritizedRule, OrgActiveRuleDto::getCreatedAt, OrgActiveRuleDto::getUpdatedAt)
+      .containsExactly(tuple(activeRule.getUuid(), activeRule.getProfileUuid(), activeRule.getRuleUuid(), activeRule.getSeverity(), activeRule.getInheritance(),
+        activeRule.isPrioritizedRule(), activeRule.getCreatedAt(), activeRule.getUpdatedAt()));
+
+    // verify data from "rules_profiles" and "org_qprofiles"
+    assertThat(actualActiveRule)
+      .extracting(o -> o.getKey().getRuleProfileUuid(), OrgActiveRuleDto::getOrgProfileUuid)
+      .containsExactly(tuple(activeRule.getKey().getRuleProfileUuid(), profile1.getKee()));
+  }
+
   @Test
   void selectByTypeAndProfileUuids() {
     RuleDto rule1 = db.rules().insert(r -> r.setType(RuleType.VULNERABILITY.getDbConstant()));
@@ -192,8 +250,8 @@ class ActiveRuleDaoIT {
 
     assertThat(underTest.selectByTypeAndProfileUuids(dbSession, singletonList(RuleType.VULNERABILITY.getDbConstant()),
       singletonList(profile1.getKee())))
-        .extracting(OrgActiveRuleDto::getOrgProfileUuid, OrgActiveRuleDto::getRuleUuid)
-        .contains(tuple(profile1.getKee(), rule1.getUuid()));
+      .extracting(OrgActiveRuleDto::getOrgProfileUuid, OrgActiveRuleDto::getRuleUuid)
+      .contains(tuple(profile1.getKee(), rule1.getUuid()));
   }
 
   @Test
@@ -205,7 +263,7 @@ class ActiveRuleDaoIT {
 
     assertThat(underTest.selectByTypeAndProfileUuids(dbSession, singletonList(RuleType.VULNERABILITY.getDbConstant()),
       singletonList(profile1.getKee())))
-        .isEmpty();
+      .isEmpty();
   }
 
   @Test
@@ -219,14 +277,14 @@ class ActiveRuleDaoIT {
       underTest.selectByTypeAndProfileUuids(dbSession,
         singletonList(RuleType.VULNERABILITY.getDbConstant()),
         singletonList(profile1.getKee())))
-          .extracting(OrgActiveRuleDto::getOrgProfileUuid, OrgActiveRuleDto::getRuleUuid)
-          .contains(tuple(profile1.getKee(), rule1.getUuid()));
+      .extracting(OrgActiveRuleDto::getOrgProfileUuid, OrgActiveRuleDto::getRuleUuid)
+      .contains(tuple(profile1.getKee(), rule1.getUuid()));
 
     assertThat(
       underTest.selectByTypeAndProfileUuids(dbSession,
         asList(RuleType.CODE_SMELL.getDbConstant(), RuleType.SECURITY_HOTSPOT.getDbConstant(), RuleType.BUG.getDbConstant()),
         singletonList(profile1.getKee())))
-          .isEmpty();
+      .isEmpty();
   }
 
   @Test
@@ -684,10 +742,10 @@ class ActiveRuleDaoIT {
     ActiveRuleCountQuery.Builder builder = ActiveRuleCountQuery.builder();
     assertThat(underTest.countActiveRulesByQuery(dbSession,
       builder.setProfiles(asList(profile1, profile2)).setInheritance(OVERRIDES).build()))
-        .containsOnly(entry(profile1.getKee(), 1L), entry(profile2.getKee(), 1L));
+      .containsOnly(entry(profile1.getKee(), 1L), entry(profile2.getKee(), 1L));
     assertThat(underTest.countActiveRulesByQuery(dbSession,
       builder.setProfiles(asList(profile1, profile2)).setInheritance(INHERITED).build()))
-        .containsOnly(entry(profile2.getKee(), 1L));
+      .containsOnly(entry(profile2.getKee(), 1L));
   }
 
   @Test
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDao.java
index e085a3cc315..76c9ae977ef 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDao.java
@@ -84,8 +84,15 @@ public class ActiveRuleDao implements Dao {
   /**
    * Active rule on removed rule are NOT returned
    */
-  public List<OrgActiveRuleDto> selectByProfileUuid(DbSession dbSession, String uuid) {
-    return mapper(dbSession).selectByProfileUuid(uuid);
+  public List<OrgActiveRuleDto> selectByProfileUuid(DbSession dbSession, String profileUuid) {
+    return selectByProfileUuids(dbSession, List.of(profileUuid));
+  }
+
+  /**
+   * Active rule on removed rule are NOT returned
+   */
+  public List<OrgActiveRuleDto> selectByProfileUuids(DbSession dbSession, Collection<String> profileUuids) {
+    return mapper(dbSession).selectByProfileUuids(profileUuids);
   }
 
   public List<OrgActiveRuleDto> selectByTypeAndProfileUuids(DbSession dbSession, List<Integer> types, List<String> uuids) {
@@ -162,6 +169,10 @@ public class ActiveRuleDao implements Dao {
     return executeLargeInputs(activeRuleUuids, mapper(dbSession)::selectParamsByActiveRuleUuids);
   }
 
+  public List<ActiveRuleParamDto> selectAllParamsByProfileUuids(final DbSession dbSession, Collection<String> profileUuids) {
+    return mapper(dbSession).selectAllParamsByProfileUuids(profileUuids);
+  }
+
   public ActiveRuleParamDto insertParam(DbSession dbSession, ActiveRuleDto activeRule, ActiveRuleParamDto activeRuleParam) {
     checkArgument(activeRule.getUuid() != null, ACTIVE_RULE_IS_NOT_PERSISTED);
     checkArgument(activeRuleParam.getUuid() == null, ACTIVE_RULE_PARAM_IS_ALREADY_PERSISTED);
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDto.java
index 906cdb4a2c7..483ed6e34a9 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDto.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleDto.java
@@ -58,10 +58,14 @@ public class ActiveRuleDto {
   // These fields do not exist in db, it's only retrieve by joins
   private String repository;
   private String ruleField;
-  private String ruleProfileUuid;
   private String securityStandards;
   private boolean isExternal;
 
+  private String name;
+  private String configKey;
+  private String templateUuid;
+  private String language;
+
   public ActiveRuleDto() {
     // nothing to do here
   }
@@ -69,12 +73,12 @@ public class ActiveRuleDto {
   public ActiveRuleDto setKey(ActiveRuleKey key) {
     this.repository = key.getRuleKey().repository();
     this.ruleField = key.getRuleKey().rule();
-    this.ruleProfileUuid = key.getRuleProfileUuid();
+    this.profileUuid = key.getRuleProfileUuid();
     return this;
   }
 
   public ActiveRuleKey getKey() {
-    return new ActiveRuleKey(ruleProfileUuid, RuleKey.of(repository, ruleField));
+    return new ActiveRuleKey(profileUuid, RuleKey.of(repository, ruleField));
   }
 
   public RuleKey getRuleKey() {
@@ -207,6 +211,43 @@ public class ActiveRuleDto {
     return this;
   }
 
+  public String getName() {
+    return name;
+  }
+
+  public ActiveRuleDto setName(String name) {
+    this.name = name;
+    return this;
+  }
+
+  public String getConfigKey() {
+    return configKey;
+  }
+
+  public ActiveRuleDto setConfigKey(String configKey) {
+    this.configKey = configKey;
+    return this;
+  }
+
+  @CheckForNull
+  public String getTemplateUuid() {
+    return templateUuid;
+  }
+
+  public ActiveRuleDto setTemplateUuid(@Nullable String templateUuid) {
+    this.templateUuid = templateUuid;
+    return this;
+  }
+
+  public String getLanguage() {
+    return language;
+  }
+
+  public ActiveRuleDto setLanguage(String language) {
+    this.language = language;
+    return this;
+  }
+
   public static ActiveRuleDto createFor(QProfileDto profile, RuleDto ruleDto) {
     requireNonNull(profile.getRulesProfileUuid(), "Profile is not persisted");
     requireNonNull(ruleDto.getUuid(), "Rule is not persisted");
@@ -214,6 +255,10 @@ public class ActiveRuleDto {
     dto.setProfileUuid(profile.getRulesProfileUuid());
     dto.setRuleUuid(ruleDto.getUuid());
     dto.setKey(ActiveRuleKey.of(profile, ruleDto.getKey()));
+    dto.setName(ruleDto.getName());
+    dto.setConfigKey(ruleDto.getConfigKey());
+    dto.setTemplateUuid(ruleDto.getTemplateUuid());
+    dto.setLanguage(ruleDto.getLanguage());
     dto.setImpacts(ruleDto.getDefaultImpactsMap());
     return dto;
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleMapper.java
index d2b2dddfdbe..af2d2dcaa98 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/ActiveRuleMapper.java
@@ -52,7 +52,7 @@ public interface ActiveRuleMapper {
 
   List<OrgActiveRuleDto> selectByRuleUuids(@Param("ruleUuids") List<String> partitionOfRuleUuids);
 
-  List<OrgActiveRuleDto> selectByProfileUuid(String uuid);
+  List<OrgActiveRuleDto> selectByProfileUuids(@Param("profileUuids") Collection<String> profileUuids);
 
   List<OrgActiveRuleDto> selectByTypeAndProfileUuids(@Param("types") List<Integer> types, @Param("profileUuids") List<String> uuids);
 
@@ -90,4 +90,6 @@ public interface ActiveRuleMapper {
   void scrollByRuleProfileUuidForIndexing(@Param("ruleProfileUuid") String ruleProfileUuid, ResultHandler<IndexedActiveRuleDto> handler);
 
   int countMissingRules(@Param("rulesProfileUuid") String rulesProfileUuid, @Param("compareToRulesProfileUuid") String compareToRulesProfileUuid);
+
+  List<ActiveRuleParamDto> selectAllParamsByProfileUuids(@Param("profileUuids") Collection<String> profileUuids);
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QualityProfileDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QualityProfileDao.java
index f9d0982e4b4..34d9bd3ea71 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QualityProfileDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/qualityprofile/QualityProfileDao.java
@@ -168,7 +168,11 @@ public class QualityProfileDao implements Dao {
   }
 
   public List<QProfileDto> selectAssociatedToProjectAndLanguages(DbSession dbSession, ProjectDto project, Collection<String> languages) {
-    return executeLargeInputs(languages, partition -> mapper(dbSession).selectAssociatedToProjectUuidAndLanguages(project.getUuid(), partition));
+    return selectAssociatedToProjectAndLanguages(dbSession, project.getUuid(), languages);
+  }
+
+  public List<QProfileDto> selectAssociatedToProjectAndLanguages(DbSession dbSession, String projectUuid, Collection<String> languages) {
+    return executeLargeInputs(languages, partition -> mapper(dbSession).selectAssociatedToProjectUuidAndLanguages(projectUuid, partition));
   }
 
   public List<QProfileDto> selectQProfilesByProjectUuid(DbSession dbSession, String projectUuid) {
@@ -251,6 +255,7 @@ public class QualityProfileDao implements Dao {
   public List<ProjectQProfileLanguageAssociationDto> selectAllProjectAssociations(DbSession dbSession) {
     return mapper(dbSession).selectAllProjectAssociations();
   }
+
   public Collection<String> selectUuidsOfCustomRulesProfiles(DbSession dbSession, String language, String name) {
     return mapper(dbSession).selectUuidsOfCustomRuleProfiles(language, name);
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java
index 6d1f544e076..722f131695b 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/rule/RuleDto.java
@@ -72,7 +72,7 @@ public class RuleDto {
   private RuleDto.Format descriptionFormat = null;
   private RuleStatus status = null;
 
-  private Set<ImpactDto> defaultImpacts = new HashSet<>();
+  private final Set<ImpactDto> defaultImpacts = new HashSet<>();
 
   private String name = null;
   private String configKey = null;
@@ -375,7 +375,6 @@ public class RuleDto {
     return this;
   }
 
-  @CheckForNull
   public String getLanguage() {
     return language;
   }
@@ -650,13 +649,12 @@ public class RuleDto {
 
   @Override
   public boolean equals(Object obj) {
-    if (!(obj instanceof RuleDto)) {
+    if (!(obj instanceof RuleDto other)) {
       return false;
     }
     if (this == obj) {
       return true;
     }
-    RuleDto other = (RuleDto) obj;
     return Objects.equals(this.uuid, other.uuid);
   }
 
diff --git a/server/sonar-db-dao/src/main/resources/org/sonar/db/qualityprofile/ActiveRuleMapper.xml b/server/sonar-db-dao/src/main/resources/org/sonar/db/qualityprofile/ActiveRuleMapper.xml
index 10442858528..c6facb12ff6 100644
--- a/server/sonar-db-dao/src/main/resources/org/sonar/db/qualityprofile/ActiveRuleMapper.xml
+++ b/server/sonar-db-dao/src/main/resources/org/sonar/db/qualityprofile/ActiveRuleMapper.xml
@@ -26,14 +26,19 @@
     a.inheritance as "inheritance",
     a.impacts as "impactsString",
     a.prioritized_rule as "prioritizedRule",
+    a.created_at as "createdAt",
+    a.updated_at as "updatedAt",
+
     r.plugin_rule_key as "rulefield",
     r.plugin_name as "repository",
     r.security_standards as "securityStandards",
-    rp.uuid as "ruleProfileUuid",
-    a.created_at as "createdAt",
-    a.updated_at as "updatedAt",
-    oqp.uuid as "orgProfileUuid",
-    r.is_external as "isExternal"
+    r.is_external as "isExternal",
+    r.name as "name",
+    r.plugin_config_key as "configKey",
+    r.template_uuid as "templateUuid",
+    r.language as "language",
+
+    oqp.uuid as "orgProfileUuid"
   </sql>
 
   <sql id="activeRuleKeyJoin">
@@ -113,14 +118,18 @@
     and r.plugin_name = #{repository, jdbcType=VARCHAR}
   </select>
 
-  <select id="selectByProfileUuid" parameterType="string" resultType="org.sonar.db.qualityprofile.OrgActiveRuleDto">
+  <select id="selectByProfileUuids" parameterType="string" resultType="org.sonar.db.qualityprofile.OrgActiveRuleDto">
     select
     <include refid="orgActiveRuleColumns"/>
     from active_rules a
     inner join rules_profiles rp on rp.uuid = a.profile_uuid
     inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.uuid
     inner join rules r on r.uuid = a.rule_uuid and r.status != 'REMOVED'
-    where oqp.uuid = #{id, jdbcType=VARCHAR}
+    where
+    oqp.uuid in
+    <foreach collection="profileUuids" item="profileUuid" separator="," open="(" close=")">
+      #{profileUuid, jdbcType=VARCHAR}
+    </foreach>
   </select>
 
   <select id="selectByTypeAndProfileUuids" parameterType="Map" resultType="org.sonar.db.qualityprofile.OrgActiveRuleDto">
@@ -306,6 +315,22 @@
     </where>
   </select>
 
+  <select id="selectAllParamsByProfileUuids" parameterType="map" resultType="ActiveRuleParam">
+    select
+    <include refid="activeRuleParamColumns"/>
+    from active_rule_parameters p
+    inner join active_rules ar on ar.uuid = p.active_rule_uuid
+    inner join rules_profiles rp on rp.uuid = ar.profile_uuid
+    inner join org_qprofiles oqp on oqp.rules_profile_uuid = rp.uuid
+    inner join rules r on r.uuid = ar.rule_uuid
+    <where>
+      <foreach collection="profileUuids" item="profileUuid" open="(" separator=" or " close=")">
+        oqp.uuid = #{profileUuid, jdbcType=VARCHAR}
+      </foreach>
+      and r.status != 'REMOVED'
+    </where>
+  </select>
+
   <select id="countActiveRulesByQuery" resultType="KeyLongValue" parameterType="map">
     select oqp.uuid as "key", count(ar.uuid) as "value"
     from active_rules ar
diff --git a/server/sonar-server-common/src/it/java/org/sonar/server/rule/ActiveRuleServiceIT.java b/server/sonar-server-common/src/it/java/org/sonar/server/rule/ActiveRuleServiceIT.java
new file mode 100644
index 00000000000..2d36a185236
--- /dev/null
+++ b/server/sonar-server-common/src/it/java/org/sonar/server/rule/ActiveRuleServiceIT.java
@@ -0,0 +1,206 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.rule;
+
+import java.util.List;
+import org.assertj.core.groups.Tuple;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.sonar.api.resources.Language;
+import org.sonar.api.resources.Languages;
+import org.sonar.api.utils.System2;
+import org.sonar.db.DbTester;
+import org.sonar.db.component.ProjectData;
+import org.sonar.db.qualityprofile.ActiveRuleDto;
+import org.sonar.db.qualityprofile.ActiveRuleKey;
+import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleParamDto;
+import org.sonar.server.rule.ActiveRuleRestReponse.ActiveRule;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.sonar.api.utils.DateUtils.formatDateTime;
+
+class ActiveRuleServiceIT {
+
+  public static final Language XOO_LANGUAGE = mock(Language.class);
+  public static final Language XOO2_LANGUAGE = mock(Language.class);
+
+  public static final String XOO_LANGUAGE_KEY = "xoo";
+  public static final String XOO2_LANGUAGE_KEY = "xoo2";
+
+  static {
+    when(XOO_LANGUAGE.getKey()).thenReturn(XOO_LANGUAGE_KEY);
+    when(XOO2_LANGUAGE.getKey()).thenReturn(XOO2_LANGUAGE_KEY);
+  }
+
+  @RegisterExtension
+  DbTester db = DbTester.create(System2.INSTANCE);
+
+  private final ActiveRuleService activeRuleService = new ActiveRuleService(db.getDbClient(), new Languages(XOO_LANGUAGE, XOO2_LANGUAGE));
+
+  @Test
+  void buildDefaultActiveRules() {
+    QProfileDto qProfileDto1 = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO_LANGUAGE_KEY));
+    db.qualityProfiles().setAsDefault(qProfileDto1);
+    RuleDto rule1 = db.rules().insert(r -> r.setLanguage(XOO_LANGUAGE_KEY), r -> r.setName("rule1"));
+    ActiveRuleDto activatedRule1 = db.qualityProfiles().activateRule(qProfileDto1, rule1);
+    RuleDto rule2 = db.rules().insert(r -> r.setLanguage(XOO_LANGUAGE_KEY), r -> r.setName("rule2"));
+    ActiveRuleDto activatedRule2 = db.qualityProfiles().activateRule(qProfileDto1, rule2);
+
+    QProfileDto qProfileDto2 = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO2_LANGUAGE_KEY));
+    db.qualityProfiles().setAsDefault(qProfileDto2);
+    RuleDto rule3 = db.rules().insert(r -> r.setLanguage(XOO2_LANGUAGE_KEY), r -> r.setName("rule3"));
+    ActiveRuleDto activatedRule3 = db.qualityProfiles().activateRule(qProfileDto2, rule3);
+
+    List<ActiveRule> activeRules = activeRuleService.buildDefaultActiveRules();
+    assertThat(activeRules).isNotNull().hasSize(3)
+      .extracting(ActiveRule::ruleKey, ActiveRule::name, ActiveRule::severity,
+        ActiveRule::createdAt, ActiveRule::updatedAt, ActiveRule::internalKey,
+        ActiveRule::language, ActiveRule::templateRuleKey, ActiveRule::qProfileKey,
+        ActiveRule::deprecatedKeys, ActiveRule::params)
+      .containsExactlyInAnyOrder(
+        toTuple(activatedRule1, XOO_LANGUAGE_KEY, qProfileDto1, List.of()),
+        toTuple(activatedRule2, XOO_LANGUAGE_KEY, qProfileDto1, List.of()),
+        toTuple(activatedRule3, XOO2_LANGUAGE_KEY, qProfileDto2, List.of()));
+  }
+
+  @Test
+  void buildActiveRule_with_default_profile() {
+    QProfileDto qProfileDto1 = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO_LANGUAGE_KEY));
+    db.qualityProfiles().setAsDefault(qProfileDto1);
+    RuleDto rule1 = db.rules().insert(r -> r.setLanguage(XOO_LANGUAGE_KEY), r -> r.setName("rule1"));
+    ActiveRuleDto activatedRule1 = db.qualityProfiles().activateRule(qProfileDto1, rule1);
+    RuleDto rule2 = db.rules().insert(r -> r.setLanguage(XOO_LANGUAGE_KEY), r -> r.setName("rule2"));
+    ActiveRuleDto activatedRule2 = db.qualityProfiles().activateRule(qProfileDto1, rule2);
+
+    QProfileDto qProfileDto2 = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO2_LANGUAGE_KEY));
+    db.qualityProfiles().setAsDefault(qProfileDto2);
+    RuleDto rule3 = db.rules().insert(r -> r.setLanguage(XOO2_LANGUAGE_KEY), r -> r.setName("rule3"));
+    ActiveRuleDto activatedRule3 = db.qualityProfiles().activateRule(qProfileDto2, rule3);
+
+    var removedLanguageKey = "removed";
+    QProfileDto qProfileDtoRemovedLanguage = db.qualityProfiles().insert(qp -> qp.setLanguage(removedLanguageKey));
+    db.qualityProfiles().setAsDefault(qProfileDtoRemovedLanguage);
+    RuleDto ruleRemovedLanguage = db.rules().insert(r -> r.setLanguage(removedLanguageKey), r -> r.setName("ruleRemovedLanguage"));
+    db.qualityProfiles().activateRule(qProfileDtoRemovedLanguage, ruleRemovedLanguage);
+
+    List<ActiveRule> activeRules = activeRuleService.buildActiveRules("myProjectUuid");
+    assertThat(activeRules).isNotNull().hasSize(3)
+      .extracting(ActiveRule::ruleKey, ActiveRule::name, ActiveRule::severity,
+        ActiveRule::createdAt, ActiveRule::updatedAt, ActiveRule::internalKey,
+        ActiveRule::language, ActiveRule::templateRuleKey, ActiveRule::qProfileKey,
+        ActiveRule::deprecatedKeys, ActiveRule::params)
+      .containsExactlyInAnyOrder(
+        toTuple(activatedRule1, XOO_LANGUAGE_KEY, qProfileDto1, List.of()),
+        toTuple(activatedRule2, XOO_LANGUAGE_KEY, qProfileDto1, List.of()),
+        toTuple(activatedRule3, XOO2_LANGUAGE_KEY, qProfileDto2, List.of()));
+  }
+
+  @Test
+  void projectProfile_overrides_defaultProfile() {
+    QProfileDto qProfileDto1 = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO_LANGUAGE_KEY));
+    db.qualityProfiles().setAsDefault(qProfileDto1);
+    RuleDto rule1 = db.rules().insert(r -> r.setLanguage(XOO_LANGUAGE_KEY), r -> r.setName("rule1"));
+    db.qualityProfiles().activateRule(qProfileDto1, rule1);
+
+    QProfileDto qProfileDto2 = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO_LANGUAGE_KEY));
+    ProjectData project = db.components().insertPrivateProject();
+    db.qualityProfiles().associateWithProject(project.getProjectDto(), qProfileDto2);
+    ActiveRuleDto activatedRule2 = db.qualityProfiles().activateRule(qProfileDto2, rule1);
+
+    List<ActiveRule> activeRules = activeRuleService.buildActiveRules(project.projectUuid());
+    assertThat(activeRules).hasSize(1)
+      .extracting(ActiveRule::ruleKey, ActiveRule::name, ActiveRule::severity,
+        ActiveRule::createdAt, ActiveRule::updatedAt, ActiveRule::internalKey,
+        ActiveRule::language, ActiveRule::templateRuleKey, ActiveRule::qProfileKey,
+        ActiveRule::deprecatedKeys, ActiveRule::params)
+      .containsExactlyInAnyOrder(
+        toTuple(activatedRule2, XOO_LANGUAGE_KEY, qProfileDto2, List.of()));
+  }
+
+  @Test
+  void customRuleParam_overrides_defaultRuleParamValue() {
+    RuleDto rule = db.rules().insert(r -> r.setLanguage(XOO_LANGUAGE_KEY), r -> r.setName("rule"));
+    RuleParamDto ruleParam = db.rules().insertRuleParam(rule, p -> p.setDefaultValue("defaultValue"));
+    QProfileDto defaultQualityProfile = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO_LANGUAGE_KEY));
+    db.qualityProfiles().setAsDefault(defaultQualityProfile);
+    db.qualityProfiles().activateRule(defaultQualityProfile, rule);
+
+    QProfileDto qProfileDto2 = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO_LANGUAGE_KEY));
+    ProjectData project = db.components().insertPrivateProject();
+    db.qualityProfiles().associateWithProject(project.getProjectDto(), qProfileDto2);
+    ActiveRuleDto activatedRule2 = db.qualityProfiles().activateRule(qProfileDto2, rule);
+    db.getDbClient().activeRuleDao().insertParam(db.getSession(), activatedRule2, new ActiveRuleParamDto()
+      .setRulesParameterUuid(ruleParam.getUuid())
+      .setKey(ruleParam.getName())
+      .setValue("overriddenValue"));
+
+    db.commit();
+
+    List<ActiveRule> activeRules = activeRuleService.buildActiveRules(project.projectUuid());
+    assertThat(activeRules).hasSize(1)
+      .extracting(ActiveRule::ruleKey, ActiveRule::name, ActiveRule::severity,
+        ActiveRule::createdAt, ActiveRule::updatedAt, ActiveRule::internalKey,
+        ActiveRule::language, ActiveRule::templateRuleKey, ActiveRule::qProfileKey,
+        ActiveRule::deprecatedKeys, ActiveRule::params)
+      .containsExactlyInAnyOrder(
+        toTuple(activatedRule2, XOO_LANGUAGE_KEY, qProfileDto2, List.of(new ActiveRuleRestReponse.Param(ruleParam.getName(), "overriddenValue"))));
+  }
+
+  @Test
+  void returnsRuleTemplate() {
+    RuleDto templateRule = db.rules().insert(r -> r.setLanguage(XOO_LANGUAGE_KEY)
+      .setIsTemplate(true));
+    RuleDto rule = db.rules().insert(r -> r.setLanguage(XOO_LANGUAGE_KEY)
+      .setTemplateUuid(templateRule.getUuid()));
+    RuleParamDto ruleParam = db.rules().insertRuleParam(rule);
+    QProfileDto defaultQualityProfile = db.qualityProfiles().insert(qp -> qp.setLanguage(XOO_LANGUAGE_KEY));
+    db.qualityProfiles().setAsDefault(defaultQualityProfile);
+    ActiveRuleDto activeRule = db.qualityProfiles().activateRule(defaultQualityProfile, rule);
+    ProjectData project = db.components().insertPrivateProject();
+
+    List<ActiveRule> activeRules = activeRuleService.buildActiveRules(project.projectUuid());
+    assertThat(activeRules).hasSize(1)
+      .extracting(ActiveRule::ruleKey, ActiveRule::name, ActiveRule::severity,
+        ActiveRule::createdAt, ActiveRule::updatedAt, ActiveRule::internalKey,
+        ActiveRule::language, ActiveRule::templateRuleKey, ActiveRule::qProfileKey,
+        ActiveRule::deprecatedKeys, ActiveRule::params)
+      .containsExactlyInAnyOrder(
+        tuple(toRuleKey(activeRule.getKey()), activeRule.getName(), activeRule.getSeverityString(), formatDateTime(activeRule.getCreatedAt()),
+          formatDateTime(activeRule.getUpdatedAt()), activeRule.getConfigKey(), XOO_LANGUAGE_KEY, templateRule.getKey().toString(), defaultQualityProfile.getKee(), List.of(),
+          List.of(new ActiveRuleRestReponse.Param(ruleParam.getName(), ruleParam.getDefaultValue()))));
+
+  }
+
+  private Tuple toTuple(ActiveRuleDto activatedRule, String language, QProfileDto qProfileDto, List<ActiveRuleRestReponse.Param> expectedParams) {
+    return tuple(toRuleKey(activatedRule.getKey()), activatedRule.getName(), activatedRule.getSeverityString(), formatDateTime(activatedRule.getCreatedAt()),
+      formatDateTime(activatedRule.getUpdatedAt()), activatedRule.getConfigKey(), language, null, qProfileDto.getKee(), List.of(), expectedParams);
+  }
+
+  private ActiveRuleRestReponse.RuleKey toRuleKey(ActiveRuleKey key) {
+    return new ActiveRuleRestReponse.RuleKey(key.getRuleKey().repository(), key.getRuleKey().rule());
+  }
+
+}
diff --git a/server/sonar-server-common/src/main/java/org/sonar/server/rule/ActiveRuleRestReponse.java b/server/sonar-server-common/src/main/java/org/sonar/server/rule/ActiveRuleRestReponse.java
new file mode 100644
index 00000000000..f802e7f004d
--- /dev/null
+++ b/server/sonar-server-common/src/main/java/org/sonar/server/rule/ActiveRuleRestReponse.java
@@ -0,0 +1,123 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.rule;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
+import org.sonar.api.issue.impact.Severity;
+import org.sonar.api.issue.impact.SoftwareQuality;
+
+public class ActiveRuleRestReponse {
+
+  public record ActiveRule(
+    RuleKey ruleKey,
+    String name,
+    String severity,
+    String createdAt,
+    String updatedAt,
+    @JsonInclude(JsonInclude.Include.NON_NULL) @Nullable String internalKey,
+    String language,
+    @JsonInclude(JsonInclude.Include.NON_NULL) @Nullable String templateRuleKey,
+    String qProfileKey,
+    @JsonInclude(JsonInclude.Include.NON_EMPTY) List<RuleKey> deprecatedKeys,
+    @JsonInclude(JsonInclude.Include.NON_EMPTY) List<Param> params,
+    @JsonInclude(JsonInclude.Include.NON_EMPTY) Map<SoftwareQuality, Severity> impacts) {
+  }
+
+  public record RuleKey(String repository, String rule) {
+  }
+
+  public record Param(String key, String value) {
+  }
+
+  public static class Builder {
+    private RuleKey ruleKey;
+    private String name;
+    private String severity;
+    private String createdAt;
+    private String updatedAt;
+    private String internalKey;
+    private String language;
+    private String templateRuleKey;
+    private String qProfilKey;
+    private final List<RuleKey> deprecatedKeys = new ArrayList<>();
+    private final List<Param> params = new ArrayList<>();
+    private final Map<SoftwareQuality, Severity> impacts = new EnumMap<>(SoftwareQuality.class);
+
+    public void setRuleKey(RuleKey ruleKey) {
+      this.ruleKey = ruleKey;
+    }
+
+    public void setName(String name) {
+      this.name = name;
+    }
+
+    public void setSeverity(String severity) {
+      this.severity = severity;
+    }
+
+    public void setCreatedAt(String createdAt) {
+      this.createdAt = createdAt;
+    }
+
+    public void setUpdatedAt(String updatedAt) {
+      this.updatedAt = updatedAt;
+    }
+
+    public void setInternalKey(String internalKey) {
+      this.internalKey = internalKey;
+    }
+
+    public void setLanguage(String language) {
+      this.language = language;
+    }
+
+    public void setTemplateRuleKey(String templateRuleKey) {
+      this.templateRuleKey = templateRuleKey;
+    }
+
+    public void setQProfilKey(String qProfilKey) {
+      this.qProfilKey = qProfilKey;
+    }
+
+    public void setParams(List<Param> params) {
+      this.params.clear();
+      this.params.addAll(params);
+    }
+
+    public void addAllDeprecatedKeys(List<RuleKey> deprecatedKeys) {
+      this.deprecatedKeys.addAll(deprecatedKeys);
+    }
+
+    public void setImpacts(Map<SoftwareQuality, Severity> impacts) {
+      this.impacts.clear();
+      this.impacts.putAll(impacts);
+    }
+
+    public ActiveRule build() {
+      return new ActiveRule(ruleKey, name, severity, createdAt, updatedAt, internalKey, language, templateRuleKey, qProfilKey, deprecatedKeys, params, impacts);
+    }
+  }
+
+}
diff --git a/server/sonar-server-common/src/main/java/org/sonar/server/rule/ActiveRuleService.java b/server/sonar-server-common/src/main/java/org/sonar/server/rule/ActiveRuleService.java
new file mode 100644
index 00000000000..5a7960a6010
--- /dev/null
+++ b/server/sonar-server-common/src/main/java/org/sonar/server/rule/ActiveRuleService.java
@@ -0,0 +1,177 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.rule;
+
+import com.google.common.base.Strings;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+import org.sonar.api.resources.Language;
+import org.sonar.api.resources.Languages;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.api.utils.DateUtils;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.db.qualityprofile.ActiveRuleParamDto;
+import org.sonar.db.qualityprofile.OrgActiveRuleDto;
+import org.sonar.db.qualityprofile.QProfileDto;
+import org.sonar.db.rule.DeprecatedRuleKeyDto;
+import org.sonar.db.rule.RuleDto;
+import org.sonar.db.rule.RuleParamDto;
+
+import static java.util.Optional.ofNullable;
+
+public class ActiveRuleService {
+
+  private final DbClient dbClient;
+  private final Languages languages;
+
+  public ActiveRuleService(DbClient dbClient, Languages languages) {
+    this.dbClient = dbClient;
+    this.languages = languages;
+  }
+
+  public List<ActiveRuleRestReponse.ActiveRule> buildDefaultActiveRules() {
+    try (DbSession dbSession = dbClient.openSession(false)) {
+      List<QProfileDto> qualityProfiles = dbClient.qualityProfileDao().selectDefaultProfiles(dbSession, getLanguageKeys());
+      return loadActiveRules(qualityProfiles, dbSession);
+    }
+  }
+
+  public List<ActiveRuleRestReponse.ActiveRule> buildActiveRules(String projectUuid) {
+    try (DbSession dbSession = dbClient.openSession(false)) {
+      List<QProfileDto> qualityProfiles = getQualityProfiles(dbSession, projectUuid);
+      return loadActiveRules(qualityProfiles, dbSession);
+    }
+  }
+
+  private Set<String> getLanguageKeys() {
+    return Arrays.stream(languages.all()).map(Language::getKey).collect(Collectors.toSet());
+  }
+
+  private List<ActiveRuleRestReponse.ActiveRule> loadActiveRules(List<QProfileDto> qualityProfiles, DbSession dbSession) {
+
+    Map<String, QProfileDto> profilesByUuids = qualityProfiles.stream().collect(Collectors.toMap(QProfileDto::getKee, Function.identity()));
+
+    Map<String, List<RuleParamDto>> ruleParamsByRuleUuid = dbClient.ruleDao().selectAllRuleParams(dbSession).stream()
+      .collect(Collectors.groupingBy(RuleParamDto::getRuleUuid));
+
+    Map<String, List<ActiveRuleParamDto>> activeRuleParamsByActiveRuleUuid = dbClient.activeRuleDao().selectAllParamsByProfileUuids(dbSession, profilesByUuids.keySet()).stream()
+      .collect(Collectors.groupingBy(ActiveRuleParamDto::getActiveRuleUuid));
+
+    List<OrgActiveRuleDto> activeRuleDtos = dbClient.activeRuleDao().selectByProfileUuids(dbSession, profilesByUuids.keySet());
+    Map<String, RuleDto> templateRulesByUuid = getTemplateRulesByUuid(dbSession, activeRuleDtos);
+    Map<String, List<DeprecatedRuleKeyDto>> deprecatedRuleKeysByRuleUuid = getDeprecatedRuleKeysByRuleUuid(dbSession);
+
+    return activeRuleDtos.stream()
+      .map(
+        activeRuleDto -> buildActiveRule(activeRuleDto, profilesByUuids, templateRulesByUuid, deprecatedRuleKeysByRuleUuid, ruleParamsByRuleUuid, activeRuleParamsByActiveRuleUuid))
+      .toList();
+  }
+
+  private static ActiveRuleRestReponse.ActiveRule buildActiveRule(OrgActiveRuleDto activeRuleDto,
+    Map<String, QProfileDto> profilesByUuids,
+    Map<String, RuleDto> templateRulesByUuid,
+    Map<String, List<DeprecatedRuleKeyDto>> deprecatedRuleKeysByRuleUuid,
+    Map<String, List<RuleParamDto>> ruleParamsByRuleUuid,
+    Map<String, List<ActiveRuleParamDto>> activeRuleParamsByActiveRuleUuid) {
+    ActiveRuleRestReponse.Builder activeRuleBuilder = new ActiveRuleRestReponse.Builder();
+    activeRuleBuilder.setRuleKey(toRuleKey(activeRuleDto.getRuleKey()));
+    activeRuleBuilder.setName(activeRuleDto.getName());
+    activeRuleBuilder.setSeverity(activeRuleDto.getSeverityString());
+    activeRuleBuilder.setCreatedAt(DateUtils.formatDateTime(activeRuleDto.getCreatedAt()));
+    activeRuleBuilder.setUpdatedAt(DateUtils.formatDateTime(activeRuleDto.getUpdatedAt()));
+    // same as RuleForIndexingDto mapping
+    activeRuleBuilder.setInternalKey(activeRuleDto.getConfigKey());
+    activeRuleBuilder.setQProfilKey(profilesByUuids.get(activeRuleDto.getOrgProfileUuid()).getKee());
+    activeRuleBuilder.setLanguage(activeRuleDto.getLanguage());
+    Optional<RuleDto> templateRule = ofNullable(templateRulesByUuid.get(activeRuleDto.getTemplateUuid()));
+    templateRule.ifPresent(template -> activeRuleBuilder.setTemplateRuleKey(template.getKey().toString()));
+
+    List<ActiveRuleRestReponse.RuleKey> deprecatedKeys = buildDeprecatedKeys(activeRuleDto, deprecatedRuleKeysByRuleUuid);
+    activeRuleBuilder.addAllDeprecatedKeys(deprecatedKeys);
+
+    List<RuleParamDto> ruleParams = ruleParamsByRuleUuid.get(activeRuleDto.getRuleUuid());
+    List<ActiveRuleParamDto> activeRuleParams = ofNullable(activeRuleParamsByActiveRuleUuid.get(activeRuleDto.getUuid())).orElse(List.of());
+    List<ActiveRuleRestReponse.Param> params = buildParams(ruleParams, activeRuleParams);
+    activeRuleBuilder.setParams(params);
+
+    activeRuleBuilder.setImpacts(activeRuleDto.getImpacts());
+
+    return activeRuleBuilder.build();
+  }
+
+  private static List<ActiveRuleRestReponse.Param> buildParams(@Nullable List<RuleParamDto> ruleParams, List<ActiveRuleParamDto> activeRuleParams) {
+    if (ruleParams == null) {
+      return List.of();
+    }
+    return ruleParams.stream()
+      .map(parameter -> {
+        Optional<ActiveRuleParamDto> activeRuleParamDto = activeRuleParams.stream()
+          .filter(arp -> arp.getRulesParameterUuid().equals(parameter.getUuid()))
+          .findAny();
+        String paramValue = activeRuleParamDto.map(ActiveRuleParamDto::getValue).orElse(parameter.getDefaultValue());
+        return new ActiveRuleRestReponse.Param(parameter.getName(), Strings.nullToEmpty(paramValue));
+      })
+      .toList();
+  }
+
+  private static List<ActiveRuleRestReponse.RuleKey> buildDeprecatedKeys(OrgActiveRuleDto activeRuleDto, Map<String, List<DeprecatedRuleKeyDto>> deprecatedRuleKeysByRuleUuid) {
+    List<DeprecatedRuleKeyDto> deprecatedRuleKeyDtos = deprecatedRuleKeysByRuleUuid.getOrDefault(activeRuleDto.getUuid(), List.of());
+    return deprecatedRuleKeyDtos.stream()
+      .map(ActiveRuleService::toRuleKey)
+      .toList();
+  }
+
+  private List<QProfileDto> getQualityProfiles(DbSession dbSession, String projectUuid) {
+    List<QProfileDto> defaultProfiles = dbClient.qualityProfileDao().selectDefaultProfiles(dbSession, getLanguageKeys());
+    Map<String, QProfileDto> projectProfiles = dbClient.qualityProfileDao().selectAssociatedToProjectAndLanguages(dbSession, projectUuid, getLanguageKeys())
+      .stream().collect(Collectors.toMap(QProfileDto::getLanguage, Function.identity()));
+
+    return defaultProfiles.stream()
+      .map(defaultProfile -> projectProfiles.getOrDefault(defaultProfile.getLanguage(), defaultProfile))
+      .toList();
+  }
+
+  private Map<String, RuleDto> getTemplateRulesByUuid(DbSession dbSession, List<OrgActiveRuleDto> activeRuleDtos) {
+    Set<String> templateRuleUuids = activeRuleDtos.stream().map(OrgActiveRuleDto::getTemplateUuid).filter(Objects::nonNull).collect(Collectors.toSet());
+    return dbClient.ruleDao().selectByUuids(dbSession, templateRuleUuids).stream().collect(Collectors.toMap(RuleDto::getUuid, p -> p));
+  }
+
+  private static ActiveRuleRestReponse.RuleKey toRuleKey(RuleKey ruleKey) {
+    return new ActiveRuleRestReponse.RuleKey(ruleKey.repository(), ruleKey.rule());
+  }
+
+  private static ActiveRuleRestReponse.RuleKey toRuleKey(DeprecatedRuleKeyDto r) {
+    return new ActiveRuleRestReponse.RuleKey(r.getOldRepositoryKey(), r.getOldRuleKey());
+  }
+
+  private Map<String, List<DeprecatedRuleKeyDto>> getDeprecatedRuleKeysByRuleUuid(DbSession dbSession) {
+    return dbClient.ruleDao().selectAllDeprecatedRuleKeys(dbSession).stream()
+      .collect(Collectors.groupingBy(DeprecatedRuleKeyDto::getRuleUuid));
+  }
+
+}
diff --git a/server/sonar-webserver-api/src/main/java/org/sonar/server/rule/CachingRuleFinder.java b/server/sonar-webserver-api/src/main/java/org/sonar/server/rule/CachingRuleFinder.java
index 4809218d3e2..3b6c7007df7 100644
--- a/server/sonar-webserver-api/src/main/java/org/sonar/server/rule/CachingRuleFinder.java
+++ b/server/sonar-webserver-api/src/main/java/org/sonar/server/rule/CachingRuleFinder.java
@@ -20,7 +20,6 @@
 package org.sonar.server.rule;
 
 import com.google.common.collect.Ordering;
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/WebApiEndpoints.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/WebApiEndpoints.java
index d77f2fda48a..1d053c5049f 100644
--- a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/WebApiEndpoints.java
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/WebApiEndpoints.java
@@ -51,6 +51,7 @@ public class WebApiEndpoints {
   public static final String ANALYSIS_DOMAIN = "/analysis";
   public static final String VERSION_ENDPOINT = ANALYSIS_DOMAIN + "/version";
   public static final String JRE_ENDPOINT = ANALYSIS_DOMAIN + "/jres";
+  public static final String ACTIVE_RULES_ENDPOINT = ANALYSIS_DOMAIN + "/active_rules";
   public static final String SCANNER_ENGINE_ENDPOINT = ANALYSIS_DOMAIN + "/engine";
 
   private WebApiEndpoints() {
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/controller/ActiveRulesController.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/controller/ActiveRulesController.java
new file mode 100644
index 00000000000..905420589a3
--- /dev/null
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/controller/ActiveRulesController.java
@@ -0,0 +1,47 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.v2.api.analysis.controller;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import java.util.List;
+import org.sonar.server.rule.ActiveRuleRestReponse;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+
+import static org.sonar.server.v2.WebApiEndpoints.ACTIVE_RULES_ENDPOINT;
+import static org.springframework.http.HttpStatus.OK;
+import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
+
+@RequestMapping(value = ACTIVE_RULES_ENDPOINT, produces = APPLICATION_JSON_VALUE)
+@ResponseStatus(OK)
+@RestController
+public interface ActiveRulesController {
+
+  String PROJECT_KEY_PARAM_DESCRIPTION = "Project Key";
+
+  @GetMapping
+  @Operation(summary = "Get all active rules for a specific project", description = "Used by the scanner-engine to get all active rules for a given project.")
+  List<ActiveRuleRestReponse.ActiveRule> getActiveRules(@RequestParam(value = "projectKey") @Parameter(description = PROJECT_KEY_PARAM_DESCRIPTION) String projectKey);
+
+}
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/controller/DefaultActiveRulesController.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/controller/DefaultActiveRulesController.java
new file mode 100644
index 00000000000..9a51bd5972b
--- /dev/null
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/controller/DefaultActiveRulesController.java
@@ -0,0 +1,38 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.v2.api.analysis.controller;
+
+import java.util.List;
+import org.sonar.server.rule.ActiveRuleRestReponse;
+import org.sonar.server.v2.api.analysis.service.ActiveRulesHandler;
+
+public class DefaultActiveRulesController implements ActiveRulesController {
+
+  private final ActiveRulesHandler activeRulesHandler;
+
+  public DefaultActiveRulesController(ActiveRulesHandler activeRulesHandler) {
+    this.activeRulesHandler = activeRulesHandler;
+  }
+
+  @Override
+  public List<ActiveRuleRestReponse.ActiveRule> getActiveRules(String projectKey) {
+    return activeRulesHandler.getActiveRules(projectKey);
+  }
+}
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandler.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandler.java
new file mode 100644
index 00000000000..d14a66a6d7a
--- /dev/null
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandler.java
@@ -0,0 +1,27 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.v2.api.analysis.service;
+
+import java.util.List;
+import org.sonar.server.rule.ActiveRuleRestReponse;
+
+public interface ActiveRulesHandler {
+  List<ActiveRuleRestReponse.ActiveRule> getActiveRules(String projectKey);
+}
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandlerImpl.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandlerImpl.java
new file mode 100644
index 00000000000..8b4562bc4f9
--- /dev/null
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandlerImpl.java
@@ -0,0 +1,47 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.v2.api.analysis.service;
+
+import java.util.List;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.server.rule.ActiveRuleRestReponse;
+import org.sonar.server.rule.ActiveRuleService;
+
+public class ActiveRulesHandlerImpl implements ActiveRulesHandler {
+
+  private final DbClient dbClient;
+  private final ActiveRuleService activeRuleService;
+
+  public ActiveRulesHandlerImpl(DbClient dbClient, ActiveRuleService activeRuleService) {
+    this.dbClient = dbClient;
+    this.activeRuleService = activeRuleService;
+  }
+
+  @Override
+  public List<ActiveRuleRestReponse.ActiveRule> getActiveRules(String projectKey) {
+    try (DbSession dbSession = dbClient.openSession(false)) {
+      return dbClient.projectDao().selectProjectByKey(dbSession, projectKey)
+        .map(projectDto -> activeRuleService.buildActiveRules(projectDto.getUuid()))
+        .orElse(activeRuleService.buildDefaultActiveRules());
+    }
+  }
+
+}
diff --git a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/config/PlatformLevel4WebConfig.java b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/config/PlatformLevel4WebConfig.java
index 20880ad7420..2ae1170b7af 100644
--- a/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/config/PlatformLevel4WebConfig.java
+++ b/server/sonar-webserver-webapi-v2/src/main/java/org/sonar/server/v2/config/PlatformLevel4WebConfig.java
@@ -48,16 +48,21 @@ import org.sonar.server.platform.ServerFileSystem;
 import org.sonar.server.platform.db.migration.DatabaseMigrationState;
 import org.sonar.server.platform.db.migration.version.DatabaseVersion;
 import org.sonar.server.qualitygate.QualityGateConditionsValidator;
+import org.sonar.server.rule.ActiveRuleService;
 import org.sonar.server.rule.RuleDescriptionFormatter;
 import org.sonar.server.setting.SettingsChangeNotifier;
 import org.sonar.server.user.SystemPasscode;
 import org.sonar.server.user.UserSession;
+import org.sonar.server.v2.api.analysis.controller.ActiveRulesController;
+import org.sonar.server.v2.api.analysis.controller.DefaultActiveRulesController;
 import org.sonar.server.v2.api.analysis.controller.DefaultJresController;
 import org.sonar.server.v2.api.analysis.controller.DefaultScannerEngineController;
 import org.sonar.server.v2.api.analysis.controller.DefaultVersionController;
 import org.sonar.server.v2.api.analysis.controller.JresController;
 import org.sonar.server.v2.api.analysis.controller.ScannerEngineController;
 import org.sonar.server.v2.api.analysis.controller.VersionController;
+import org.sonar.server.v2.api.analysis.service.ActiveRulesHandler;
+import org.sonar.server.v2.api.analysis.service.ActiveRulesHandlerImpl;
 import org.sonar.server.v2.api.analysis.service.JresHandler;
 import org.sonar.server.v2.api.analysis.service.JresHandlerImpl;
 import org.sonar.server.v2.api.analysis.service.ScannerEngineHandler;
@@ -227,4 +232,19 @@ public class PlatformLevel4WebConfig {
     return new DefaultModeController(userSession, dbClient, configuration, settingsChangeNotifier, notificationManager, qualityGateConditionsValidator);
   }
 
+  @Bean
+  public ActiveRuleService activeRuleService(DbClient dbClient, Languages languages) {
+    return new ActiveRuleService(dbClient, languages);
+  }
+
+  @Bean
+  public ActiveRulesHandler activeRulesHandler(DbClient dbClient, ActiveRuleService activeRuleService) {
+    return new ActiveRulesHandlerImpl(dbClient, activeRuleService);
+  }
+
+  @Bean
+  public ActiveRulesController activeRulesController(ActiveRulesHandler activeRulesHandler) {
+    return new DefaultActiveRulesController(activeRulesHandler);
+  }
+
 }
diff --git a/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/analysis/controller/DefaultActiveRulesControllerTest.java b/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/analysis/controller/DefaultActiveRulesControllerTest.java
new file mode 100644
index 00000000000..c35ecfda28a
--- /dev/null
+++ b/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/analysis/controller/DefaultActiveRulesControllerTest.java
@@ -0,0 +1,107 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.v2.api.analysis.controller;
+
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import org.sonar.api.issue.impact.Severity;
+import org.sonar.api.issue.impact.SoftwareQuality;
+import org.sonar.server.rule.ActiveRuleRestReponse;
+import org.sonar.server.v2.api.analysis.service.ActiveRulesHandler;
+import org.springframework.test.web.servlet.MockMvc;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.sonar.server.v2.WebApiEndpoints.ACTIVE_RULES_ENDPOINT;
+import static org.sonar.server.v2.api.ControllerTester.getMockMvc;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+class DefaultActiveRulesControllerTest {
+
+  private final ActiveRulesHandler handler = mock(ActiveRulesHandler.class);
+
+  private final MockMvc mockMvc = getMockMvc(new DefaultActiveRulesController(handler));
+
+  @Test
+  void getActiveRules_shouldReturnActiveRulesAsJson() throws Exception {
+    var minimalAr = new ActiveRuleRestReponse.ActiveRule(
+      new ActiveRuleRestReponse.RuleKey("xoo", "rule1"),
+      "Rule 1",
+      "MAJOR",
+      "2024-12-09",
+      "2024-12-09",
+      null,
+      "java",
+      null,
+      "qProfileKey",
+      List.of(),
+      List.of(),
+      Map.of());
+    var maximalAr = new ActiveRuleRestReponse.ActiveRule(
+      new ActiveRuleRestReponse.RuleKey("xoo", "rule1"),
+      "Rule 1",
+      "MAJOR",
+      "2024-12-09",
+      "2024-12-09",
+      "someInternalKey",
+      "java",
+      "templateKey",
+      "qProfileKey",
+      List.of(new ActiveRuleRestReponse.RuleKey("old", "rule")),
+      List.of(new ActiveRuleRestReponse.Param("key", "value")),
+      Map.of(SoftwareQuality.MAINTAINABILITY, Severity.HIGH));
+    when(handler.getActiveRules("someKey")).thenReturn(List.of(minimalAr, maximalAr));
+
+    String expectedJson = """
+      [
+        {
+          "ruleKey":{"repository":"xoo","rule":"rule1"},
+          "name":"Rule 1",
+          "severity":"MAJOR",
+          "createdAt":"2024-12-09",
+          "updatedAt":"2024-12-09",
+          "language":"java",
+          "qProfileKey":"qProfileKey"
+        },
+        {
+          "ruleKey":{"repository":"xoo","rule":"rule1"},
+          "name":"Rule 1","severity":"MAJOR",
+          "createdAt":"2024-12-09",
+          "updatedAt":"2024-12-09",
+          "internalKey":"someInternalKey",
+          "language":"java",
+          "templateRuleKey":"templateKey",
+          "qProfileKey":"qProfileKey",
+          "deprecatedKeys":[{"repository":"old","rule":"rule"}],
+          "params":[{"key":"key","value":"value"}],
+          "impacts":{"MAINTAINABILITY":"HIGH"}}
+      ]
+      """;
+
+    mockMvc.perform(get(ACTIVE_RULES_ENDPOINT + "?projectKey=someKey"))
+      .andExpectAll(
+        status().isOk(),
+        content().json(expectedJson, true));
+  }
+
+}
diff --git a/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandlerImplTest.java b/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandlerImplTest.java
new file mode 100644
index 00000000000..26c8983195a
--- /dev/null
+++ b/server/sonar-webserver-webapi-v2/src/test/java/org/sonar/server/v2/api/analysis/service/ActiveRulesHandlerImplTest.java
@@ -0,0 +1,71 @@
+/*
+ * SonarQube
+ * Copyright (C) 2009-2024 SonarSource SA
+ * mailto:info AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+package org.sonar.server.v2.api.analysis.service;
+
+import java.util.List;
+import java.util.Optional;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.sonar.db.DbClient;
+import org.sonar.db.DbSession;
+import org.sonar.db.project.ProjectDto;
+import org.sonar.server.rule.ActiveRuleRestReponse;
+import org.sonar.server.rule.ActiveRuleService;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class ActiveRulesHandlerImplTest {
+
+  private final DbClient dbClient = mock(DbClient.class, RETURNS_DEEP_STUBS);
+  private final DbSession dbSession = mock();
+  private final ActiveRuleService activeRuleService = mock(ActiveRuleService.class);
+
+  @BeforeEach
+  void setup() {
+    when(dbClient.openSession(false)).thenReturn(dbSession);
+  }
+
+  ActiveRulesHandlerImpl underTest = new ActiveRulesHandlerImpl(dbClient, activeRuleService);
+
+  @Test
+  void getActiveRules_returns_default_quality_profile_for_unknown_project() {
+    var defaultActiveRule1 = mock(ActiveRuleRestReponse.ActiveRule.class);
+    when(activeRuleService.buildDefaultActiveRules()).thenReturn(List.of(defaultActiveRule1));
+
+    List<ActiveRuleRestReponse.ActiveRule> result = underTest.getActiveRules("unknown-project");
+
+    assertThat(result).containsExactly(defaultActiveRule1);
+  }
+
+  @Test
+  void getActiveRules_returns_associated_quality_profile_for_known_project() {
+    when(dbClient.projectDao().selectProjectByKey(dbSession, "my-project")).thenReturn(Optional.of(new ProjectDto().setUuid("someProjectUuid")));
+    var activeRule1 = mock(ActiveRuleRestReponse.ActiveRule.class);
+    when(activeRuleService.buildActiveRules("someProjectUuid")).thenReturn(List.of(activeRule1));
+
+    List<ActiveRuleRestReponse.ActiveRule> result = underTest.getActiveRules("my-project");
+
+    assertThat(result).containsExactly(activeRule1);
+  }
+
+}
diff --git a/sonar-core/src/main/java/org/sonar/core/rule/ImpactFormatter.java b/sonar-core/src/main/java/org/sonar/core/rule/ImpactFormatter.java
index 73120079f0f..62cb1726e18 100644
--- a/sonar-core/src/main/java/org/sonar/core/rule/ImpactFormatter.java
+++ b/sonar-core/src/main/java/org/sonar/core/rule/ImpactFormatter.java
@@ -52,4 +52,5 @@ public class ImpactFormatter {
       case UNKNOWN_IMPACT_SEVERITY -> throw new UnsupportedOperationException("Impact severity not supported");
     };
   }
+
 }
diff --git a/sonar-plugin-api-impl/src/main/java/org/sonar/api/batch/rule/internal/NewActiveRule.java b/sonar-plugin-api-impl/src/main/java/org/sonar/api/batch/rule/internal/NewActiveRule.java
index cf21a1b39cd..a1e874253f4 100644
--- a/sonar-plugin-api-impl/src/main/java/org/sonar/api/batch/rule/internal/NewActiveRule.java
+++ b/sonar-plugin-api-impl/src/main/java/org/sonar/api/batch/rule/internal/NewActiveRule.java
@@ -64,10 +64,23 @@ public class NewActiveRule {
     this.deprecatedKeys = builder.deprecatedKeys;
   }
 
+
   public RuleKey ruleKey() {
     return this.ruleKey;
   }
 
+  public Map<String, String> getParams() {
+    return params;
+  }
+
+  public String getSeverity() {
+    return severity;
+  }
+
+  public Map<SoftwareQuality, org.sonar.api.issue.impact.Severity> getImpacts() {
+    return impacts;
+  }
+
   public static class Builder {
     private RuleKey ruleKey;
     private String name;
@@ -150,5 +163,6 @@ public class NewActiveRule {
     public NewActiveRule build() {
       return new NewActiveRule(this);
     }
+
   }
 }
diff --git a/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/bootstrap/BootstrapMediumIT.java b/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/bootstrap/BootstrapMediumIT.java
index 4af42659e6e..5df0d03b111 100644
--- a/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/bootstrap/BootstrapMediumIT.java
+++ b/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/bootstrap/BootstrapMediumIT.java
@@ -35,7 +35,6 @@ import org.sonar.api.testfixtures.log.LogTesterJUnit5;
 import org.sonar.scanner.bootstrap.ScannerMain;
 import org.sonarqube.ws.Ce;
 import org.sonarqube.ws.Qualityprofiles;
-import org.sonarqube.ws.Rules;
 
 import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
 import static com.github.tomakehurst.wiremock.client.WireMock.get;
@@ -81,10 +80,10 @@ class BootstrapMediumIT {
             .build())
           .build()))));
 
-    sonarqube.stubFor(get("/api/rules/list.protobuf?qprofile=" + QPROFILE_KEY + "&ps=500&p=1")
-      .willReturn(aResponse()
-        .withResponseBody(protobufBody(Rules.ListResponse.newBuilder()
-          .build()))));
+    sonarqube.stubFor(get("/api/v2/analysis/active_rules?projectKey=" + PROJECT_KEY)
+      .willReturn(okJson("""
+        []
+        """)));
 
     sonarqube.stubFor(get("/api/languages/list")
       .willReturn(okJson("""
diff --git a/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/issues/ChecksMediumIT.java b/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/issues/ChecksMediumIT.java
index 7883b4c064f..035267f43fe 100644
--- a/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/issues/ChecksMediumIT.java
+++ b/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/issues/ChecksMediumIT.java
@@ -30,11 +30,11 @@ import org.apache.commons.io.FileUtils;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
-import org.sonar.scanner.rule.LoadedActiveRule;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.scanner.mediumtest.AnalysisResult;
 import org.sonar.scanner.mediumtest.ScannerMediumTester;
 import org.sonar.scanner.protocol.output.ScannerReport.Issue;
+import org.sonar.scanner.rule.LoadedActiveRule;
 import org.sonar.xoo.XooPlugin;
 import org.sonar.xoo.rule.XooRulesDefinition;
 
@@ -100,6 +100,7 @@ public class ChecksMediumIT {
     r.setLanguage(languag);
     r.setSeverity(severity);
     r.setDeprecatedKeys(emptySet());
+    r.setQProfileKey("whatever");
 
     Map<String, String> params = new HashMap<>();
     params.put(paramKey, paramValue);
diff --git a/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/issues/IssuesMediumIT.java b/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/issues/IssuesMediumIT.java
index 39c65da4861..541a690a63c 100644
--- a/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/issues/IssuesMediumIT.java
+++ b/sonar-scanner-engine/src/it/java/org/sonar/scanner/mediumtest/issues/IssuesMediumIT.java
@@ -30,13 +30,13 @@ import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.slf4j.event.Level;
-import org.sonar.scanner.rule.LoadedActiveRule;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.testfixtures.log.LogTester;
 import org.sonar.scanner.mediumtest.AnalysisResult;
 import org.sonar.scanner.mediumtest.ScannerMediumTester;
 import org.sonar.scanner.protocol.output.ScannerReport.ExternalIssue;
 import org.sonar.scanner.protocol.output.ScannerReport.Issue;
+import org.sonar.scanner.rule.LoadedActiveRule;
 import org.sonar.xoo.XooPlugin;
 import org.sonar.xoo.rule.HasTagSensor;
 import org.sonar.xoo.rule.OneExternalIssueOnProjectSensor;
@@ -414,9 +414,9 @@ public class IssuesMediumIT {
     r.setName("TODO");
     r.setLanguage("xoo");
     r.setSeverity("MAJOR");
-    r.setDeprecatedKeys(emptySet()
-    );
+    r.setDeprecatedKeys(emptySet());
     r.setParams(ImmutableMap.of("tag", "TODO"));
+    r.setQProfileKey("whatever");
     tester.activateRule(r);
   }
 
diff --git a/sonar-scanner-engine/src/main/java/org/sonar/scanner/repository/language/DefaultLanguagesLoader.java b/sonar-scanner-engine/src/main/java/org/sonar/scanner/repository/language/DefaultLanguagesLoader.java
index 58aeb9695f8..4a34d21d016 100644
--- a/sonar-scanner-engine/src/main/java/org/sonar/scanner/repository/language/DefaultLanguagesLoader.java
+++ b/sonar-scanner-engine/src/main/java/org/sonar/scanner/repository/language/DefaultLanguagesLoader.java
@@ -39,8 +39,7 @@ public class DefaultLanguagesLoader implements LanguagesLoader {
     "js", "javascript",
     "ts", "typescript",
     "py", "python",
-    "web", "html"
-  );
+    "web", "html");
 
   private final DefaultScannerWsClient wsClient;
 
@@ -76,7 +75,6 @@ public class DefaultLanguagesLoader implements LanguagesLoader {
     return new Language(lang);
   }
 
-
   private String[] getFileSuffixes(String languageKey) {
     return getPropertyForLanguage("sonar.%s.file.suffixes", languageKey);
   }
diff --git a/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/ActiveRulesLoader.java b/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/ActiveRulesLoader.java
index 1bd49f3ec27..06358376c69 100644
--- a/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/ActiveRulesLoader.java
+++ b/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/ActiveRulesLoader.java
@@ -22,5 +22,5 @@ package org.sonar.scanner.rule;
 import java.util.List;
 
 public interface ActiveRulesLoader {
-  List<LoadedActiveRule> load(String qualityProfileKey);
+  List<LoadedActiveRule> load(String projectKey);
 }
diff --git a/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/ActiveRulesProvider.java b/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/ActiveRulesProvider.java
index eb703522dc3..a6d7f7666aa 100644
--- a/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/ActiveRulesProvider.java
+++ b/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/ActiveRulesProvider.java
@@ -19,21 +19,16 @@
  */
 package org.sonar.scanner.rule;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import org.sonar.api.batch.rule.internal.ActiveRulesBuilder;
 import org.sonar.api.batch.rule.internal.DefaultActiveRules;
 import org.sonar.api.batch.rule.internal.NewActiveRule;
 import org.sonar.api.issue.impact.Severity;
 import org.sonar.api.issue.impact.SoftwareQuality;
-import org.sonar.api.rule.RuleKey;
 import org.sonar.api.utils.log.Logger;
 import org.sonar.api.utils.log.Loggers;
 import org.sonar.api.utils.log.Profiler;
+import org.sonar.scanner.bootstrap.ScannerProperties;
 import org.springframework.context.annotation.Bean;
 
 /**
@@ -45,34 +40,22 @@ public class ActiveRulesProvider {
   private static final String LOG_MSG = "Load active rules";
 
   @Bean("ActiveRules")
-  public DefaultActiveRules provide(ActiveRulesLoader loader, QualityProfiles qProfiles) {
+  public DefaultActiveRules provide(ActiveRulesLoader loader, ScannerProperties props) {
     Profiler profiler = Profiler.create(LOG).startInfo(LOG_MSG);
-    DefaultActiveRules activeRules = load(loader, qProfiles);
+    DefaultActiveRules activeRules = load(loader, props.getProjectKey());
     profiler.stopInfo();
     return activeRules;
   }
 
-  private static DefaultActiveRules load(ActiveRulesLoader loader, QualityProfiles qProfiles) {
-
-    Collection<String> qProfileKeys = getKeys(qProfiles);
-    Set<RuleKey> loadedRulesKey = new HashSet<>();
+  private static DefaultActiveRules load(ActiveRulesLoader loader, String projectKey) {
     ActiveRulesBuilder builder = new ActiveRulesBuilder();
-
-    for (String qProfileKey : qProfileKeys) {
-      Collection<LoadedActiveRule> qProfileRules = load(loader, qProfileKey);
-
-      for (LoadedActiveRule r : qProfileRules) {
-        if (!loadedRulesKey.contains(r.getRuleKey())) {
-          loadedRulesKey.add(r.getRuleKey());
-          builder.addRule(transform(r, qProfileKey, r.getDeprecatedKeys()));
-        }
-      }
-    }
-
+    loader.load(projectKey).stream()
+      .map(ActiveRulesProvider::transform)
+      .forEach(builder::addRule);
     return builder.build();
   }
 
-  private static NewActiveRule transform(LoadedActiveRule activeRule, String qProfileKey, Set<RuleKey> deprecatedKeys) {
+  private static NewActiveRule transform(LoadedActiveRule activeRule) {
     NewActiveRule.Builder builder = new NewActiveRule.Builder();
     builder
       .setRuleKey(activeRule.getRuleKey())
@@ -83,8 +66,8 @@ public class ActiveRulesProvider {
       .setLanguage(activeRule.getLanguage())
       .setInternalKey(activeRule.getInternalKey())
       .setTemplateRuleKey(activeRule.getTemplateRuleKey())
-      .setQProfileKey(qProfileKey)
-      .setDeprecatedKeys(deprecatedKeys);
+      .setQProfileKey(activeRule.getQProfileKey())
+      .setDeprecatedKeys(activeRule.getDeprecatedKeys());
     // load parameters
     if (activeRule.getParams() != null) {
       for (Map.Entry<String, String> params : activeRule.getParams().entrySet()) {
@@ -100,18 +83,4 @@ public class ActiveRulesProvider {
 
     return builder.build();
   }
-
-  private static List<LoadedActiveRule> load(ActiveRulesLoader loader, String qProfileKey) {
-    return loader.load(qProfileKey);
-  }
-
-  private static Collection<String> getKeys(QualityProfiles qProfiles) {
-    List<String> keys = new ArrayList<>(qProfiles.findAll().size());
-
-    for (QProfile qp : qProfiles.findAll()) {
-      keys.add(qp.getKey());
-    }
-
-    return keys;
-  }
 }
diff --git a/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/DefaultActiveRulesLoader.java b/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/DefaultActiveRulesLoader.java
index 78c047d5903..dad400fb11b 100644
--- a/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/DefaultActiveRulesLoader.java
+++ b/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/DefaultActiveRulesLoader.java
@@ -19,34 +19,27 @@
  */
 package org.sonar.scanner.rule;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.EnumMap;
-import java.util.HashMap;
-import java.util.LinkedList;
+import com.google.gson.Gson;
+import com.google.gson.annotations.SerializedName;
+import com.google.gson.reflect.TypeToken;
+import java.io.Reader;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.stream.Collectors;
-import org.apache.commons.io.IOUtils;
-import org.sonar.api.impl.utils.ScannerUtils;
+import javax.annotation.Nullable;
 import org.sonar.api.issue.impact.Severity;
 import org.sonar.api.issue.impact.SoftwareQuality;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.utils.DateUtils;
-import org.sonar.core.rule.ImpactFormatter;
 import org.sonar.scanner.http.ScannerWsClient;
-import org.sonarqube.ws.Common;
-import org.sonarqube.ws.Common.Paging;
-import org.sonarqube.ws.Rules;
-import org.sonarqube.ws.Rules.Active;
-import org.sonarqube.ws.Rules.Active.Param;
-import org.sonarqube.ws.Rules.ActiveList;
-import org.sonarqube.ws.Rules.ListResponse;
-import org.sonarqube.ws.Rules.Rule;
 import org.sonarqube.ws.client.GetRequest;
 
+import static java.util.Optional.ofNullable;
+
 public class DefaultActiveRulesLoader implements ActiveRulesLoader {
-  private static final String RULES_SEARCH_URL = "/api/rules/list.protobuf?";
+  private static final String RULES_ACTIVE_URL = "/api/v2/analysis/active_rules?";
 
   private final ScannerWsClient wsClient;
 
@@ -55,101 +48,83 @@ public class DefaultActiveRulesLoader implements ActiveRulesLoader {
   }
 
   @Override
-  public List<LoadedActiveRule> load(String qualityProfileKey) {
-    List<LoadedActiveRule> ruleList = new LinkedList<>();
-    int page = 1;
-    int pageSize = 500;
-    long loaded = 0;
-
-    while (true) {
-      GetRequest getRequest = new GetRequest(getUrl(qualityProfileKey, page, pageSize));
-      ListResponse response = loadFromStream(wsClient.call(getRequest).contentStream());
-      List<LoadedActiveRule> pageRules = readPage(response);
-      ruleList.addAll(pageRules);
-
-      Paging paging = response.getPaging();
-      loaded += paging.getPageSize();
-
-      if (paging.getTotal() <= loaded) {
-        break;
-      }
-      page++;
+  public List<LoadedActiveRule> load(String projectKey) {
+    GetRequest getRequest = new GetRequest(getUrl(projectKey));
+    List<ActiveRuleGson> jsonResponse;
+    try (Reader reader = wsClient.call(getRequest).contentReader()) {
+      jsonResponse = new Gson().fromJson(reader, new TypeToken<ArrayList<ActiveRuleGson>>() {
+      }.getType());
+    } catch (Exception e) {
+      throw new IllegalStateException("Unable to load active rules", e);
     }
-
-    return ruleList;
+    return convert(jsonResponse);
   }
 
-  private static String getUrl(String qualityProfileKey, int page, int pageSize) {
-    StringBuilder builder = new StringBuilder(1024);
-    builder.append(RULES_SEARCH_URL);
-    builder.append("qprofile=").append(ScannerUtils.encodeForUrl(qualityProfileKey));
-    builder.append("&ps=").append(pageSize);
-    builder.append("&p=").append(page);
-    return builder.toString();
+  private static String getUrl(String projectKey) {
+    return RULES_ACTIVE_URL + "projectKey=" + projectKey;
   }
 
-  private static ListResponse loadFromStream(InputStream is) {
-    try {
-      return ListResponse.parseFrom(is);
-    } catch (IOException e) {
-      throw new IllegalStateException("Failed to load quality profiles", e);
-    } finally {
-      IOUtils.closeQuietly(is);
-    }
+  private static List<LoadedActiveRule> convert(List<ActiveRuleGson> activeRuleGsonList) {
+    return activeRuleGsonList.stream()
+      .map(DefaultActiveRulesLoader::convertActiveRule)
+      .toList();
   }
 
-  private static List<LoadedActiveRule> readPage(ListResponse response) {
-    List<LoadedActiveRule> loadedRules = new LinkedList<>();
-
-    List<Rule> rulesList = response.getRulesList();
-    Map<String, ActiveList> actives = response.getActives().getActivesMap();
-
-    for (Rule r : rulesList) {
-      ActiveList activeList = actives.get(r.getKey());
-      Active active = activeList.getActiveList(0);
-
-      LoadedActiveRule loadedRule = new LoadedActiveRule();
-
-      loadedRule.setRuleKey(RuleKey.parse(r.getKey()));
-      loadedRule.setName(r.getName());
-      loadedRule.setSeverity(active.getSeverity());
-
-      loadedRule.setCreatedAt(DateUtils.dateToLong(DateUtils.parseDateTime(active.getCreatedAt())));
-      loadedRule.setUpdatedAt(DateUtils.dateToLong(DateUtils.parseDateTime(active.getUpdatedAt())));
-      loadedRule.setLanguage(r.getLang());
-      loadedRule.setInternalKey(r.getInternalKey());
-      if (r.hasTemplateKey()) {
-        RuleKey templateRuleKey = RuleKey.parse(r.getTemplateKey());
-        loadedRule.setTemplateRuleKey(templateRuleKey.rule());
-      }
-
-      Map<String, String> params = new HashMap<>();
+  private static LoadedActiveRule convertActiveRule(ActiveRuleGson activeRule) {
+    LoadedActiveRule loadedRule = new LoadedActiveRule();
+    loadedRule.setRuleKey(convertRuleKey(activeRule.ruleKey()));
+    loadedRule.setName(activeRule.name());
+    loadedRule.setSeverity(activeRule.severity());
+    loadedRule.setCreatedAt(DateUtils.dateToLong(DateUtils.parseDateTime(activeRule.createdAt())));
+    loadedRule.setUpdatedAt(DateUtils.dateToLong(DateUtils.parseDateTime(activeRule.updatedAt())));
+    loadedRule.setLanguage(activeRule.language());
+    loadedRule.setInternalKey(activeRule.internalKey());
+    loadedRule.setQProfileKey(activeRule.qProfileKey());
+    ofNullable(activeRule.templateRuleKey())
+      .map(RuleKey::parse)
+      .map(RuleKey::rule)
+      .ifPresent(loadedRule::setTemplateRuleKey);
+    loadedRule.setParams(activeRule.params() != null ? convertParams(activeRule.params()) : Map.of());
+    loadedRule.setImpacts(activeRule.impacts() != null ? activeRule.impacts() : Map.of());
+    loadedRule.setDeprecatedKeys(convertDeprecatedKeys(activeRule.deprecatedKeys()));
+    return loadedRule;
+  }
 
-      for (Rules.Rule.Param param : r.getParams().getParamsList()) {
-        params.put(param.getKey(), param.getDefaultValue());
-      }
+  private static Map<String, String> convertParams(List<ParamGson> params) {
+    return params.stream().collect(Collectors.toMap(ParamGson::key, ParamGson::value));
+  }
 
-      // overrides defaultValue if the key is the same
-      for (Param param : active.getParamsList()) {
-        params.put(param.getKey(), param.getValue());
-      }
+  private static Set<RuleKey> convertDeprecatedKeys(@Nullable List<RuleKeyGson> deprecatedKeysList) {
+    return ofNullable(deprecatedKeysList)
+      .orElse(List.of())
+      .stream()
+      .map(value -> RuleKey.of(value.repository(), value.rule()))
+      .collect(Collectors.toSet());
+  }
 
-      loadedRule.setParams(params);
+  private static RuleKey convertRuleKey(RuleKeyGson ruleKey) {
+    return RuleKey.of(ruleKey.repository(), ruleKey.rule());
+  }
 
-      Map<SoftwareQuality, Severity> impacts = new EnumMap<>(SoftwareQuality.class);
-      for (Common.Impact impact : active.getImpacts().getImpactsList()) {
-        impacts.put(SoftwareQuality.valueOf(impact.getSoftwareQuality().name()), ImpactFormatter.mapImpactSeverity(impact.getSeverity()));
-      }
-      loadedRule.setImpacts(impacts);
+  record ActiveRuleGson(
+    @SerializedName("ruleKey") RuleKeyGson ruleKey,
+    @SerializedName("name") String name,
+    @SerializedName("severity") String severity,
+    @SerializedName("createdAt") String createdAt,
+    @SerializedName("updatedAt") String updatedAt,
+    @SerializedName("internalKey") @Nullable String internalKey,
+    @SerializedName("language") String language,
+    @SerializedName("templateRuleKey") @Nullable String templateRuleKey,
+    @SerializedName("qProfileKey") String qProfileKey,
+    @SerializedName("deprecatedKeys") @Nullable List<RuleKeyGson> deprecatedKeys,
+    @SerializedName("params") @Nullable List<ParamGson> params,
+    @SerializedName("impacts") @Nullable Map<SoftwareQuality, Severity> impacts) {
+  }
 
-      loadedRule.setDeprecatedKeys(r.getDeprecatedKeys().getDeprecatedKeyList()
-        .stream()
-        .map(RuleKey::parse)
-        .collect(Collectors.toSet()));
-      loadedRules.add(loadedRule);
-    }
+  record RuleKeyGson(@SerializedName("repository") String repository, @SerializedName("rule") String rule) {
+  }
 
-    return loadedRules;
+  record ParamGson(@SerializedName("key") String key, @SerializedName("value") String value) {
   }
 
 }
diff --git a/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/LoadedActiveRule.java b/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/LoadedActiveRule.java
index 8f2c3643237..b0d1ee6d3b8 100644
--- a/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/LoadedActiveRule.java
+++ b/sonar-scanner-engine/src/main/java/org/sonar/scanner/rule/LoadedActiveRule.java
@@ -39,6 +39,7 @@ public class LoadedActiveRule {
   private String templateRuleKey;
   private String internalKey;
   private Set<RuleKey> deprecatedKeys;
+  private String qProfileKey;
 
   public LoadedActiveRule() {
     // nothing to do here
@@ -117,11 +118,12 @@ public class LoadedActiveRule {
     this.templateRuleKey = templateRuleKey;
   }
 
+  @CheckForNull
   public String getInternalKey() {
     return internalKey;
   }
 
-  public void setInternalKey(String internalKey) {
+  public void setInternalKey(@Nullable String internalKey) {
     this.internalKey = internalKey;
   }
 
@@ -132,4 +134,12 @@ public class LoadedActiveRule {
   public void setDeprecatedKeys(Set<RuleKey> deprecatedKeys) {
     this.deprecatedKeys = deprecatedKeys;
   }
+
+  public String getQProfileKey() {
+    return qProfileKey;
+  }
+
+  public void setQProfileKey(String qProfileKey) {
+    this.qProfileKey = qProfileKey;
+  }
 }
diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/rule/ActiveRulesProviderTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/rule/ActiveRulesProviderTest.java
index 4072d462f92..c5f3fceedbc 100644
--- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/rule/ActiveRulesProviderTest.java
+++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/rule/ActiveRulesProviderTest.java
@@ -19,13 +19,12 @@
  */
 package org.sonar.scanner.rule;
 
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
-import java.util.Date;
-import java.util.LinkedList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import org.assertj.core.groups.Tuple;
 import org.junit.Test;
@@ -36,16 +35,17 @@ import org.sonar.api.batch.rule.internal.DefaultActiveRules;
 import org.sonar.api.issue.impact.Severity;
 import org.sonar.api.issue.impact.SoftwareQuality;
 import org.sonar.api.rule.RuleKey;
-import org.sonar.api.utils.DateUtils;
-import org.sonarqube.ws.Qualityprofiles.SearchWsResponse.QualityProfile;
+import org.sonar.scanner.bootstrap.ScannerProperties;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
+import static org.sonar.api.CoreProperties.PROJECT_KEY_PROPERTY;
 
 public class ActiveRulesProviderTest {
+  public static final String PROJECT_KEY = "my-awesome-project";
   private final ActiveRulesProvider provider = new ActiveRulesProvider();
   private final DefaultActiveRulesLoader loader = mock(DefaultActiveRulesLoader.class);
 
@@ -57,21 +57,19 @@ public class ActiveRulesProviderTest {
 
     r1.setImpacts(Map.of(SoftwareQuality.MAINTAINABILITY, Severity.HIGH));
 
-    List<LoadedActiveRule> qp1Rules = ImmutableList.of(r1, r2);
-    List<LoadedActiveRule> qp2Rules = ImmutableList.of(r2, r3);
-    List<LoadedActiveRule> qp3Rules = ImmutableList.of(r1, r3);
+    when(loader.load(PROJECT_KEY)).thenReturn(List.of(r1, r2, r3));
 
-    when(loader.load("qp1")).thenReturn(qp1Rules);
-    when(loader.load("qp2")).thenReturn(qp2Rules);
-    when(loader.load("qp3")).thenReturn(qp3Rules);
-
-    QualityProfiles profiles = mockProfiles("qp1", "qp2", "qp3");
-    DefaultActiveRules activeRules = provider.provide(loader, profiles);
+    HashMap<String, String> propertiesMap = new HashMap<>();
+    propertiesMap.put(PROJECT_KEY_PROPERTY, PROJECT_KEY);
+    ScannerProperties scannerProperties = new ScannerProperties(propertiesMap);
+    DefaultActiveRules activeRules = provider.provide(loader, scannerProperties);
 
     assertThat(activeRules.findAll()).hasSize(3);
     assertThat(activeRules.findAll()).extracting("ruleKey").containsOnly(
       RuleKey.of("rule1", "rule1"), RuleKey.of("rule2", "rule2"), RuleKey.of("rule3", "rule3"));
 
+    verify(loader).load(PROJECT_KEY);
+
     Map<String, ActiveRule> activeRuleByKey = activeRules.findAll().stream().collect(Collectors.toMap(e -> e.ruleKey().rule(), e -> e));
     assertThat(((DefaultActiveRule) activeRuleByKey.get("rule1")).impacts())
       .containsExactlyInAnyOrderEntriesOf(Map.of(SoftwareQuality.MAINTAINABILITY, Severity.HIGH));
@@ -79,10 +77,6 @@ public class ActiveRulesProviderTest {
     assertThat(((DefaultActiveRule) activeRuleByKey.get("rule2")).impacts()).isEmpty();
     assertThat(((DefaultActiveRule) activeRuleByKey.get("rule3")).impacts()).isEmpty();
 
-    verify(loader).load("qp1");
-    verify(loader).load("qp2");
-    verify(loader).load("qp3");
-
     assertThat(activeRules.getDeprecatedRuleKeys(RuleKey.of("rule1", "rule1"))).containsOnly("rule1old:rule1old");
     verifyNoMoreInteractions(loader);
   }
@@ -90,40 +84,33 @@ public class ActiveRulesProviderTest {
   @Test
   public void testParamsAreTransformed() {
     LoadedActiveRule r1 = mockRule("rule1");
-    LoadedActiveRule r2 = mockRule("rule2");
-    r2.setParams(ImmutableMap.of("foo1", "bar1", "foo2", "bar2"));
+    LoadedActiveRule r2 = mockRule("rule2", b -> b.setParams(Map.of("foo1", "bar1", "foo2", "bar2")));
 
-    List<LoadedActiveRule> qpRules = ImmutableList.of(r1, r2);
-    when(loader.load("qp")).thenReturn(qpRules);
+    when(loader.load(PROJECT_KEY)).thenReturn(List.of(r1, r2));
 
-    QualityProfiles profiles = mockProfiles("qp");
-    ActiveRules activeRules = provider.provide(loader, profiles);
+    HashMap<String, String> propertiesMap = new HashMap<>();
+    propertiesMap.put(PROJECT_KEY_PROPERTY, PROJECT_KEY);
+    ScannerProperties scannerProperties = new ScannerProperties(propertiesMap);
+    ActiveRules activeRules = provider.provide(loader, scannerProperties);
 
     assertThat(activeRules.findAll()).hasSize(2);
     assertThat(activeRules.findAll()).extracting("ruleKey", "params").containsOnly(
       Tuple.tuple(RuleKey.of("rule1", "rule1"), ImmutableMap.of()),
       Tuple.tuple(RuleKey.of("rule2", "rule2"), ImmutableMap.of("foo1", "bar1", "foo2", "bar2")));
 
-    verify(loader).load("qp");
+    verify(loader).load(PROJECT_KEY);
     verifyNoMoreInteractions(loader);
   }
 
-  private static QualityProfiles mockProfiles(String... keys) {
-    List<QualityProfile> profiles = new LinkedList<>();
-
-    for (String k : keys) {
-      QualityProfile p = QualityProfile.newBuilder().setKey(k).setLanguage(k).setRulesUpdatedAt(DateUtils.formatDateTime(new Date())).build();
-      profiles.add(p);
+  @SafeVarargs
+  private static LoadedActiveRule mockRule(String name, Consumer<LoadedActiveRule>... consumers) {
+    LoadedActiveRule rule = new LoadedActiveRule();
+    rule.setName(name);
+    rule.setRuleKey(RuleKey.of(name, name));
+    rule.setDeprecatedKeys(ImmutableSet.of(RuleKey.of(name + "old", name + "old")));
+    for (Consumer<LoadedActiveRule> consumer : consumers) {
+      consumer.accept(rule);
     }
-
-    return new QualityProfiles(profiles);
-  }
-
-  private static LoadedActiveRule mockRule(String name) {
-    LoadedActiveRule r = new LoadedActiveRule();
-    r.setName(name);
-    r.setRuleKey(RuleKey.of(name, name));
-    r.setDeprecatedKeys(ImmutableSet.of(RuleKey.of(name + "old", name + "old")));
-    return r;
+    return rule;
   }
 }
diff --git a/sonar-scanner-engine/src/test/java/org/sonar/scanner/rule/DefaultActiveRulesLoaderTest.java b/sonar-scanner-engine/src/test/java/org/sonar/scanner/rule/DefaultActiveRulesLoaderTest.java
index 59a49084742..cf66faeb655 100644
--- a/sonar-scanner-engine/src/test/java/org/sonar/scanner/rule/DefaultActiveRulesLoaderTest.java
+++ b/sonar-scanner-engine/src/test/java/org/sonar/scanner/rule/DefaultActiveRulesLoaderTest.java
@@ -19,46 +19,49 @@
  */
 package org.sonar.scanner.rule;
 
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import java.util.Collection;
+import com.google.gson.Gson;
+import java.io.Reader;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 import java.util.stream.IntStream;
-import org.junit.Before;
-import org.junit.Test;
-import org.sonar.scanner.rule.LoadedActiveRule;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.sonar.api.issue.impact.SoftwareQuality;
 import org.sonar.api.rule.RuleKey;
 import org.sonar.api.rule.Severity;
 import org.sonar.scanner.WsTestUtil;
 import org.sonar.scanner.http.DefaultScannerWsClient;
 import org.sonar.scanner.scan.branch.BranchConfiguration;
-import org.sonarqube.ws.Common;
-import org.sonarqube.ws.Rules;
-import org.sonarqube.ws.Rules.Active;
-import org.sonarqube.ws.Rules.ActiveList;
-import org.sonarqube.ws.Rules.Actives;
-import org.sonarqube.ws.Rules.Rule;
 
+import static java.util.Map.entry;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
+import static org.sonar.api.issue.impact.Severity.HIGH;
+import static org.sonar.scanner.rule.DefaultActiveRulesLoader.ActiveRuleGson;
+import static org.sonar.scanner.rule.DefaultActiveRulesLoader.ParamGson;
+import static org.sonar.scanner.rule.DefaultActiveRulesLoader.RuleKeyGson;
 
-public class DefaultActiveRulesLoaderTest {
+class DefaultActiveRulesLoaderTest {
 
-  private static final int PAGE_SIZE_1 = 150;
-  private static final int PAGE_SIZE_2 = 76;
+  private static final int NUMBER_OF_RULES = 150;
   private static final RuleKey EXAMPLE_KEY = RuleKey.of("java", "S108");
+  private static final RuleKey CUSTOM_RULE_KEY = RuleKey.of("java", "my-custom-rule");
   private static final String FORMAT_KEY = "format";
   private static final String FORMAT_VALUE = "^[a-z][a-zA-Z0-9]*$";
+  private static final String PROJECT_KEY = "myProjectKey";
   private static final String SEVERITY_VALUE = Severity.MINOR;
 
   private DefaultActiveRulesLoader loader;
   private DefaultScannerWsClient wsClient;
 
-  @Before
-  public void setUp() {
+  @BeforeEach
+  void setUp() {
     wsClient = mock(DefaultScannerWsClient.class);
     BranchConfiguration branchConfig = mock(BranchConfiguration.class);
     when(branchConfig.isPullRequest()).thenReturn(false);
@@ -66,78 +69,131 @@ public class DefaultActiveRulesLoaderTest {
   }
 
   @Test
-  public void load_shouldRequestRulesAndParseResponse() {
-    int total = PAGE_SIZE_1 + PAGE_SIZE_2;
-
-    WsTestUtil.mockStream(wsClient, urlOfPage(1), responseOfSize(1, PAGE_SIZE_1, total));
-    WsTestUtil.mockStream(wsClient, urlOfPage(2), responseOfSize(2, PAGE_SIZE_2, total));
-
-    Collection<LoadedActiveRule> activeRules = loader.load("c+-test_c+-values-17445");
-    assertThat(activeRules).hasSize(total);
-    assertThat(activeRules)
-      .filteredOn(r -> r.getRuleKey().equals(EXAMPLE_KEY))
-      .extracting(LoadedActiveRule::getParams)
-      .extracting(p -> p.get(FORMAT_KEY))
-      .containsExactly(FORMAT_VALUE);
-    assertThat(activeRules)
-      .filteredOn(r -> r.getRuleKey().equals(EXAMPLE_KEY))
-      .extracting(LoadedActiveRule::getSeverity)
-      .containsExactly(SEVERITY_VALUE);
-    assertThat(activeRules)
-      .filteredOn(r -> r.getRuleKey().equals(EXAMPLE_KEY))
-      .extracting(LoadedActiveRule::getImpacts)
-      .containsExactlyInAnyOrder(Map.of(SoftwareQuality.MAINTAINABILITY, org.sonar.api.issue.impact.Severity.HIGH));
-
-    WsTestUtil.verifyCall(wsClient, urlOfPage(1));
-    WsTestUtil.verifyCall(wsClient, urlOfPage(2));
+  void load_shouldRequestRulesAndParseResponse() {
+    WsTestUtil.mockReader(wsClient, getUrl(), response());
+
+    Map<RuleKey, LoadedActiveRule> activeRulesByKey = loader.load(PROJECT_KEY).stream().collect(Collectors.toMap(LoadedActiveRule::getRuleKey, r -> r));
+    assertThat(activeRulesByKey).hasSize(NUMBER_OF_RULES);
+
+    var exampleRule = activeRulesByKey.get(EXAMPLE_KEY);
+    assertThat(exampleRule.getParams()).containsEntry(FORMAT_KEY, FORMAT_VALUE);
+    assertThat(exampleRule.getSeverity()).isEqualTo(SEVERITY_VALUE);
+    assertThat(exampleRule.getImpacts()).containsExactly(entry(SoftwareQuality.MAINTAINABILITY, HIGH));
+
+    var customRule = activeRulesByKey.get(CUSTOM_RULE_KEY);
+    assertThat(customRule.getTemplateRuleKey()).isEqualTo("ruleTemplate");
+
+    WsTestUtil.verifyCall(wsClient, getUrl());
 
     verifyNoMoreInteractions(wsClient);
   }
 
-  private String urlOfPage(int page) {
-    return "/api/rules/list.protobuf?qprofile=c%2B-test_c%2B-values-17445&ps=500&p=" + page + "";
+  private String getUrl() {
+    return "/api/v2/analysis/active_rules?projectKey=" + PROJECT_KEY;
   }
 
-  /**
-   * Generates an imaginary protobuf result.
-   *
-   * @param pageIndex page index, that the response should contain
-   * @param numberOfRules the number of rules, that the response should contain
-   * @param total the number of results on all pages
-   * @return the binary stream
-   */
-  private InputStream responseOfSize(int pageIndex, int numberOfRules, int total) {
-    Rules.ListResponse.Builder rules = Rules.ListResponse.newBuilder();
-    Actives.Builder actives = Actives.newBuilder();
-
-    IntStream.rangeClosed(1, numberOfRules)
+  private Reader response() {
+    List<ActiveRuleGson> activeRules = new ArrayList<>();
+
+    IntStream.rangeClosed(1, NUMBER_OF_RULES - 1)
       .mapToObj(i -> RuleKey.of("java", "S" + i))
       .forEach(key -> {
+        ActiveRuleGsonBuilder builder = new ActiveRuleGsonBuilder();
 
-        Rule.Builder ruleBuilder = Rule.newBuilder();
-        ruleBuilder.setKey(key.toString());
-        rules.addRules(ruleBuilder);
+        builder.setRuleKey(new RuleKeyGson(key.repository(), key.rule()));
 
-        Active.Builder activeBuilder = Active.newBuilder();
-        activeBuilder.setCreatedAt("2014-05-27T15:50:45+0100");
-        activeBuilder.setUpdatedAt("2014-05-27T15:50:45+0100");
+        builder.setCreatedAt("2014-05-27T15:50:45+0100");
+        builder.setUpdatedAt("2014-05-27T15:50:45+0100");
         if (EXAMPLE_KEY.equals(key)) {
-          activeBuilder.addParams(Rules.Active.Param.newBuilder().setKey(FORMAT_KEY).setValue(FORMAT_VALUE));
-          activeBuilder.setSeverity(SEVERITY_VALUE);
-          activeBuilder.setImpacts(Rules.Impacts.newBuilder().addImpacts(Common.Impact.newBuilder()
-            .setSoftwareQuality(Common.SoftwareQuality.MAINTAINABILITY)
-            .setSeverity(Common.ImpactSeverity.HIGH).build()).build());
+          builder.setParams(List.of(new ParamGson(FORMAT_KEY, FORMAT_VALUE)));
+          builder.setSeverity(SEVERITY_VALUE);
+          builder.setImpacts(Map.of(SoftwareQuality.MAINTAINABILITY, HIGH));
         }
-        ActiveList activeList = Rules.ActiveList.newBuilder().addActiveList(activeBuilder).build();
-        actives.putAllActives(Map.of(key.toString(), activeList));
+
+        activeRules.add(builder.build());
       });
 
-    rules.setActives(actives);
-    rules.setPaging(Common.Paging.newBuilder()
-      .setTotal(total)
-      .setPageIndex(pageIndex)
-      .setPageSize(numberOfRules)
-      .build());
-    return new ByteArrayInputStream(rules.build().toByteArray());
+    ActiveRuleGsonBuilder builder = new ActiveRuleGsonBuilder();
+    builder.setRuleKey(new RuleKeyGson(CUSTOM_RULE_KEY.repository(), CUSTOM_RULE_KEY.rule()));
+    builder.setCreatedAt("2014-05-27T15:50:45+0100");
+    builder.setUpdatedAt("2014-05-27T15:50:45+0100");
+    builder.setTemplateRuleKey("java:ruleTemplate");
+    activeRules.add(builder.build());
+
+    return toReader(activeRules);
+  }
+
+  private static Reader toReader(List<ActiveRuleGson> activeRules) {
+    String json = new Gson().toJson(activeRules);
+    return new StringReader(json);
+  }
+
+  private static class ActiveRuleGsonBuilder {
+    private RuleKeyGson ruleKey;
+    private String name;
+    private String severity;
+    private String createdAt;
+    private String updatedAt;
+    private String internalKey;
+    private String language;
+    private String templateRuleKey;
+    private String qProfilKey;
+    private final List<RuleKeyGson> deprecatedKeys = new ArrayList<>();
+    private final List<ParamGson> params = new ArrayList<>();
+    private final Map<SoftwareQuality, org.sonar.api.issue.impact.Severity> impacts = new EnumMap<>(SoftwareQuality.class);
+
+    public void setRuleKey(RuleKeyGson ruleKey) {
+      this.ruleKey = ruleKey;
+    }
+
+    public void setName(String name) {
+      this.name = name;
+    }
+
+    public void setSeverity(String severity) {
+      this.severity = severity;
+    }
+
+    public void setCreatedAt(String createdAt) {
+      this.createdAt = createdAt;
+    }
+
+    public void setUpdatedAt(String updatedAt) {
+      this.updatedAt = updatedAt;
+    }
+
+    public void setInternalKey(String internalKey) {
+      this.internalKey = internalKey;
+    }
+
+    public void setLanguage(String language) {
+      this.language = language;
+    }
+
+    public void setTemplateRuleKey(String templateRuleKey) {
+      this.templateRuleKey = templateRuleKey;
+    }
+
+    public void setQProfilKey(String qProfilKey) {
+      this.qProfilKey = qProfilKey;
+    }
+
+    public void setParams(List<ParamGson> params) {
+      this.params.clear();
+      this.params.addAll(params);
+    }
+
+    public void addAllDeprecatedKeys(List<RuleKeyGson> deprecatedKeys) {
+      this.deprecatedKeys.addAll(deprecatedKeys);
+    }
+
+    public void setImpacts(Map<SoftwareQuality, org.sonar.api.issue.impact.Severity> impacts) {
+      this.impacts.clear();
+      this.impacts.putAll(impacts);
+    }
+
+    public ActiveRuleGson build() {
+      return new ActiveRuleGson(ruleKey, name, severity, createdAt, updatedAt, internalKey, language, templateRuleKey, qProfilKey, deprecatedKeys, params, impacts);
+    }
   }
 }
diff --git a/sonar-scanner-engine/src/testFixtures/java/org/sonar/scanner/mediumtest/ScannerMediumTester.java b/sonar-scanner-engine/src/testFixtures/java/org/sonar/scanner/mediumtest/ScannerMediumTester.java
index 89f54283c45..0dc09835a06 100644
--- a/sonar-scanner-engine/src/testFixtures/java/org/sonar/scanner/mediumtest/ScannerMediumTester.java
+++ b/sonar-scanner-engine/src/testFixtures/java/org/sonar/scanner/mediumtest/ScannerMediumTester.java
@@ -30,6 +30,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -49,6 +50,7 @@ import org.sonar.api.SonarEdition;
 import org.sonar.api.SonarProduct;
 import org.sonar.api.SonarQubeSide;
 import org.sonar.api.SonarRuntime;
+import org.sonar.api.batch.rule.internal.NewActiveRule;
 import org.sonar.api.impl.server.RulesDefinitionContext;
 import org.sonar.api.measures.CoreMetrics;
 import org.sonar.api.measures.Metric;
@@ -223,6 +225,7 @@ public class ScannerMediumTester extends ExternalResource implements BeforeTestE
     r.setLanguage(language);
     r.setSeverity(severity);
     r.setDeprecatedKeys(emptySet());
+    r.setQProfileKey("whatever");
 
     activeRules.addActiveRule(r);
     return this;
@@ -280,6 +283,7 @@ public class ScannerMediumTester extends ExternalResource implements BeforeTestE
     }
   }
 
+
   public AnalysisBuilder newAnalysis() {
     return new AnalysisBuilder(this);
   }
-- 
cgit v1.2.3