diff --git a/.ci/bwcVersions b/.ci/bwcVersions
index 535dea1da3c28..7173155220a67 100644
--- a/.ci/bwcVersions
+++ b/.ci/bwcVersions
@@ -54,6 +54,9 @@ BWC_VERSION:
   - "1.3.15"
   - "1.3.16"
   - "1.3.17"
+  - "1.3.18"
+  - "1.3.19"
+  - "1.3.20"
   - "2.0.0"
   - "2.0.1"
   - "2.0.2"
@@ -88,3 +91,8 @@ BWC_VERSION:
   - "2.13.1"
   - "2.14.0"
   - "2.14.1"
+  - "2.15.0"
+  - "2.15.1"
+  - "2.16.0"
+  - "2.16.1"
+  - "2.17.0"
diff --git a/.ci/java-versions.properties b/.ci/java-versions.properties
index f73122ee21a6b..e290bda773f68 100644
--- a/.ci/java-versions.properties
+++ b/.ci/java-versions.properties
@@ -13,7 +13,8 @@
 # build and test OpenSearch for this branch. Valid Java versions
 # are 'java' or 'openjdk' followed by the major release number.
 
-OPENSEARCH_BUILD_JAVA=openjdk11
+# See please https://docs.gradle.org/8.10/userguide/upgrading_version_8.html#minimum_daemon_jvm_version
+OPENSEARCH_BUILD_JAVA=openjdk17
 OPENSEARCH_RUNTIME_JAVA=java11
 GRADLE_TASK=build
 GRADLE_EXTRA_ARGS=
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index b5b0a815b02b2..18a310862dfbb 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -11,17 +11,27 @@
 #   3. Use the command palette to run the CODEOWNERS: Show owners of current file command, which will display all code owners for the current file.
 
 # Default ownership for all repo files
-* @anasalkouz @andrross @Bukhtawar @CEHENKLE @dblock @dbwiddis @dreamer-89 @gbbafna @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @tlfeng @VachaShah
+* @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jainankitk @kotwanikunal @linuxpi @mch2 @msfroh @nknize @owaiskazi19  @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
 
+/modules/lang-painless/ @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
+/modules/parent-join/ @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
 /modules/transport-netty4/ @peternied
 
 /plugins/identity-shiro/ @peternied
 
+/server/src/internalClusterTest/java/org/opensearch/index/ @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
+/server/src/internalClusterTest/java/org/opensearch/search/ @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
+
 /server/src/main/java/org/opensearch/extensions/ @peternied
 /server/src/main/java/org/opensearch/identity/ @peternied
-/server/src/main/java/org/opensearch/threadpool/ @peternied
+/server/src/main/java/org/opensearch/index/ @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
+/server/src/main/java/org/opensearch/search/ @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
+/server/src/main/java/org/opensearch/threadpool/ @jed326 @peternied
 /server/src/main/java/org/opensearch/transport/ @peternied
 
-/.github/ @peternied
+/server/src/test/java/org/opensearch/index/ @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
+/server/src/test/java/org/opensearch/search/ @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
+
+/.github/ @jed326 @peternied
 
-/MAINTAINERS.md @anasalkouz @andrross @Bukhtawar @CEHENKLE @dblock @dbwiddis @dreamer-89 @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @peternied @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @tlfeng @VachaShah
+/MAINTAINERS.md @anasalkouz @andrross @ashking94 @Bukhtawar @CEHENKLE @dblock @dbwiddis @gaobinlong @gbbafna @jed326 @kotwanikunal @mch2 @msfroh @nknize @owaiskazi19 @peternied @reta @Rishikesh1159 @sachinpkale @saratvemulapalli @shwetathareja @sohami @VachaShah
diff --git a/.github/ISSUE_TEMPLATE/failed_check.md b/.github/ISSUE_TEMPLATE/failed_check.md
deleted file mode 100644
index 71508c9f5bd43..0000000000000
--- a/.github/ISSUE_TEMPLATE/failed_check.md
+++ /dev/null
@@ -1,8 +0,0 @@
----
-title: '[AUTOCUT] Gradle Check Failure on push to {{ env.branch_name }}'
-labels: '>test-failure, bug, autocut'
----
-
-Gradle check has failed on push of your commit {{ env.pr_from_sha }}.
-Please examine the workflow log {{ env.workflow_url }}.
-Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 7a4119a763b09..5476637b84e92 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,18 +1,21 @@
+<!--  Thanks for sending a pull request, here are some tips:
+
+1. If this is a fix for an undisclosed security vulnerability, please STOP. All security vulnerability reporting and fixes should be done as per our security policy https://github.com/opensearch-project/OpenSearch/security/policy
+2. If this is your first time, please read our contributor guidelines: https://github.com/opensearch-project/OpenSearch/blob/main/CONTRIBUTING.md and developer guide https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md
+3. Ensure you have added or ran the appropriate tests for your PR: https://github.com/opensearch-project/OpenSearch/blob/main/TESTING.md
+-->
+
 ### Description
 [Describe what this change achieves]
 
-### Issues Resolved
-[List any issues this PR will resolve]
+### Related Issues
+Resolves #[Issue number to be closed when this PR is merged]
+<!-- List any other related issues here -->
 
 ### Check List
-- [ ] New functionality includes testing.
-  - [ ] All tests pass
-- [ ] New functionality has been documented.
-  - [ ] New functionality has javadoc added
-- [ ] Failing checks are inspected and point to the corresponding known issue(s) (See: [Troubleshooting Failing Builds](../blob/main/CONTRIBUTING.md#troubleshooting-failing-builds))
-- [ ] Commits are signed per the DCO using --signoff
-- [ ] Commit changes are listed out in CHANGELOG.md file (See: [Changelog](../blob/main/CONTRIBUTING.md#changelog))
-- [ ] Public documentation issue/PR [created](https://github.com/opensearch-project/documentation-website/issues/new/choose)
+- [ ] Functionality includes testing.
+- [ ] API changes companion pull request [created](https://github.com/opensearch-project/opensearch-api-specification/blob/main/DEVELOPER_GUIDE.md), if applicable.
+- [ ] Public documentation issue/PR [created](https://github.com/opensearch-project/documentation-website/issues/new/choose), if applicable.
 
 By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.
 For more information on following Developer Certificate of Origin and signing off your commits, please check [here](https://github.com/opensearch-project/OpenSearch/blob/main/CONTRIBUTING.md#developer-certificate-of-origin).
diff --git a/.github/workflows/assemble.yml b/.github/workflows/assemble.yml
index d18170e9ea6b7..294627622a136 100644
--- a/.github/workflows/assemble.yml
+++ b/.github/workflows/assemble.yml
@@ -16,9 +16,33 @@ jobs:
         with:
           java-version: ${{ matrix.java }}
           distribution: temurin
+      - name: Set up JDK 17
+        # See please https://docs.gradle.org/8.10/userguide/upgrading_version_8.html#minimum_daemon_jvm_version
+        if: matrix.java == 11
+        uses: actions/setup-java@v4
+        with:
+          java-version: 17
+          distribution: temurin
+      - name: Set JAVA${{ matrix.java }}_HOME
+        shell: bash
+        run: |
+          echo "JAVA${{ matrix.java }}_HOME=$JAVA_HOME_${{ matrix.java }}_${{ runner.arch }}" >> $GITHUB_ENV
       - name: Setup docker (missing on MacOS)
+        id: setup_docker
         if: runner.os == 'macos'
-        uses: douglascamata/setup-docker-macos-action@main
+        run: |
+          exit 0;
+      - name: Run Gradle (assemble)
+        if: runner.os == 'macos' && steps.setup_docker.outcome != 'success'
+        run: |
+          # Report success even if previous step failed (Docker on MacOS runner is very unstable)
+          exit 0;
+      - name: Run Gradle (assemble)
+        shell: bash
+        if: runner.os != 'macos'
+        run: |
+          ./gradlew assemble --parallel --no-build-cache -PDISABLE_BUILD_CACHE -Druntime.java=${{ matrix.java }} 
       - name: Run Gradle (assemble)
+        if: runner.os == 'macos' && steps.setup_docker.outcome == 'success'
         run: |
-          ./gradlew assemble --parallel --no-build-cache -PDISABLE_BUILD_CACHE
+          exit 0;
diff --git a/.github/workflows/dco.yml b/.github/workflows/dco.yml
new file mode 100644
index 0000000000000..ef842bb405d60
--- /dev/null
+++ b/.github/workflows/dco.yml
@@ -0,0 +1,19 @@
+name: Developer Certificate of Origin Check
+
+on: [pull_request]
+
+jobs:
+  dco-check:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Get PR Commits
+      id: 'get-pr-commits'
+      uses: tim-actions/get-pr-commits@v1.3.1
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+    - name: DCO Check
+      uses: tim-actions/dco@v1.1.0
+      with:
+        commits: ${{ steps.get-pr-commits.outputs.commits }}
+
diff --git a/.github/workflows/dependabot_pr.yml b/.github/workflows/dependabot_pr.yml
index e265a5933b845..bf0c0127805b1 100644
--- a/.github/workflows/dependabot_pr.yml
+++ b/.github/workflows/dependabot_pr.yml
@@ -22,6 +22,13 @@ jobs:
         with:
           token: ${{ steps.github_app_token.outputs.token }}
 
+      # See please https://docs.gradle.org/8.10/userguide/upgrading_version_8.html#minimum_daemon_jvm_version
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: 17
+          distribution: temurin
+
       - name: Update Gradle SHAs
         run: |
           ./gradlew updateSHAs
diff --git a/.github/workflows/gradle-check.yml b/.github/workflows/gradle-check.yml
index f610ff5c31049..1b9b30625eb83 100644
--- a/.github/workflows/gradle-check.yml
+++ b/.github/workflows/gradle-check.yml
@@ -12,13 +12,28 @@ permissions:
   contents: read # to fetch code (actions/checkout)
 
 jobs:
+  check-files:
+    runs-on: ubuntu-latest
+    outputs:
+      RUN_GRADLE_CHECK: ${{ steps.changed-files-specific.outputs.any_changed }}
+    steps:
+    - uses: actions/checkout@v4
+    - name: Get changed files
+      id: changed-files-specific
+      uses: tj-actions/changed-files@v45
+      with:
+        files_ignore: |
+          release-notes/*.md
+          .github/**
+          *.md
+
   gradle-check:
-    if: github.repository == 'opensearch-project/OpenSearch'
+    needs: check-files
+    if: github.repository == 'opensearch-project/OpenSearch' && needs.check-files.outputs.RUN_GRADLE_CHECK == 'true'
     permissions:
       contents: read # to fetch code (actions/checkout)
       pull-requests: write # to create or update comment (peter-evans/create-or-update-comment)
       issues: write # To create an issue if check fails on push.
-
     runs-on: ubuntu-latest
     timeout-minutes: 130
     steps:
@@ -98,6 +113,7 @@ jobs:
         if: success()
         uses: codecov/codecov-action@v4
         with:
+          token: ${{ secrets.CODECOV_TOKEN }}
           files: ./codeCoverage.xml
 
       - name: Create Comment Success
@@ -143,11 +159,11 @@ jobs:
 
             Please examine the workflow log, locate, and copy-paste the failure(s) below, then iterate to green. Is the failure [a flaky test](https://github.com/opensearch-project/OpenSearch/blob/main/DEVELOPER_GUIDE.md#flaky-tests) unrelated to your change?
 
-      - name: Create Issue On Push Failure
-        if: ${{ github.event_name == 'push' && failure() }}
-        uses: dblock/create-a-github-issue@v3
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          assignees: ${{ github.event.head_commit.author.username }}, ${{ github.triggering_actor }}
-          filename: .github/ISSUE_TEMPLATE/failed_check.md
+  check-result:
+    needs: [check-files, gradle-check]
+    if: always()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fail if gradle-check fails
+        if: ${{ needs.check-files.outputs.RUN_GRADLE_CHECK && needs.gradle-check.result == 'failure' }}
+        run: exit 1
diff --git a/.github/workflows/precommit.yml b/.github/workflows/precommit.yml
index 95ca49ac9cb43..7c65df1f677a5 100644
--- a/.github/workflows/precommit.yml
+++ b/.github/workflows/precommit.yml
@@ -8,7 +8,7 @@ jobs:
     strategy:
       matrix:
         java: [ 11, 17, 21 ]
-        os: [ubuntu-latest, windows-latest, macos-13]
+        os: [ubuntu-latest, windows-latest, macos-latest, macos-13]
     steps:
       - uses: actions/checkout@v4
       - name: Set up JDK ${{ matrix.java }}
@@ -17,6 +17,18 @@ jobs:
           java-version: ${{ matrix.java }}
           distribution: temurin
           cache: gradle
+      - name: Set up JDK 17
+        # See please https://docs.gradle.org/8.10/userguide/upgrading_version_8.html#minimum_daemon_jvm_version
+        if: matrix.java == 11
+        uses: actions/setup-java@v4
+        with:
+          java-version: 17
+          distribution: temurin
+      - name: Set JAVA${{ matrix.java }}_HOME
+        shell: bash
+        run: |
+          echo "JAVA${{ matrix.java }}_HOME=$JAVA_HOME_${{ matrix.java }}_${{ runner.arch }}" >> $GITHUB_ENV
       - name: Run Gradle (precommit)
+        shell: bash
         run: |
-          ./gradlew javadoc precommit --parallel
+          ./gradlew javadoc precommit --parallel -Druntime.java=${{ matrix.java }}
diff --git a/.github/workflows/version.yml b/.github/workflows/version.yml
index fd91bef553d1c..eb80b5a1c6ff1 100644
--- a/.github/workflows/version.yml
+++ b/.github/workflows/version.yml
@@ -127,3 +127,32 @@ jobs:
           title: '[AUTO] [main] Add bwc version ${{ env.NEXT_VERSION }}.'
           body: |
             I've noticed that a new tag ${{ env.TAG }} was pushed, and added a bwc version ${{ env.NEXT_VERSION }}.
+
+      - name: Create tracking issue
+        id: create-issue
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const body = `
+             ### Description
+             A new version of OpenSearch was released, to prepare for the next release new version numbers need to be updated in all active branches of development.
+
+             ### Exit Criteria
+             Review and merged the following pull requests
+             - [ ] ${{ steps.base_pr.outputs.pull-request-url }}
+             - [ ] ${{ steps.base_x_pr.outputs.pull-request-url }}
+             - [ ] ${{ steps.main_pr.outputs.pull-request-url }}
+
+             ### Additional Context
+             See project wide guidance on branching and versions [[link]](https://github.com/opensearch-project/.github/blob/main/RELEASING.md).
+            `
+            const { data: issue }= await github.rest.issues.create({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              labels: ["Build"],
+              title: "Increment version for ${{ env.NEXT_VERSION }}",
+              body: body
+            });
+            console.error(JSON.stringify(issue));
+            return issue.number;
+          result-encoding: string
diff --git a/.whitesource b/.whitesource
new file mode 100644
index 0000000000000..bb071b4a2b1ce
--- /dev/null
+++ b/.whitesource
@@ -0,0 +1,45 @@
+{
+  "scanSettings": {
+    "configMode": "AUTO",
+    "configExternalURL": "",
+    "projectToken": "",
+    "baseBranches": []
+  },
+  "scanSettingsSAST": {
+    "enableScan": false,
+    "scanPullRequests": false,
+    "incrementalScan": true,
+    "baseBranches": [],
+    "snippetSize": 10
+  },
+  "checkRunSettings": {
+    "vulnerableCheckRunConclusionLevel": "failure",
+    "displayMode": "diff",
+    "useMendCheckNames": true
+  },
+  "checkRunSettingsSAST": {
+    "checkRunConclusionLevel": "failure",
+    "severityThreshold": "high"
+  },
+  "issueSettings": {
+    "minSeverityLevel": "LOW",
+    "issueType": "DEPENDENCY"
+  },
+  "issueSettingsSAST": {
+    "minSeverityLevel": "high",
+    "issueType": "repo"
+  },
+  "remediateSettings": {
+    "workflowRules": {
+      "enabled": true
+    }
+  },
+   "imageSettings":{
+       "imageTracing":{
+           "enableImageTracingPR": false,
+           "addRepositoryCoordinate": false,
+           "addDockerfilePath": false,
+           "addMendIdentifier": false
+       }
+   }
+}
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8c77bd846640..886c082053fd6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,42 +5,106 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ## [Unreleased 2.x]
 ### Added
-- Add support for Azure Managed Identity in repository-azure ([#12423](https://github.com/opensearch-project/OpenSearch/issues/12423))
-- Add useCompoundFile index setting ([#13478](https://github.com/opensearch-project/OpenSearch/pull/13478))
-- Make outbound side of transport protocol dependent ([#13293](https://github.com/opensearch-project/OpenSearch/pull/13293))
-- [Remote Store] Upload translog checkpoint as object metadata to translog.tlog([#13637](https://github.com/opensearch-project/OpenSearch/pull/13637))
-- [Remote Store] Add dynamic cluster settings to set timeout for segments upload to Remote Store ([#13679](https://github.com/opensearch-project/OpenSearch/pull/13679))
+- [Workload Management] Add Settings for Workload Management feature ([#15028](https://github.com/opensearch-project/OpenSearch/pull/15028))
+- Fix for hasInitiatedFetching to fix allocation explain and manual reroute APIs (([#14972](https://github.com/opensearch-project/OpenSearch/pull/14972))
+- [Workload Management] Add queryGroupId to Task ([14708](https://github.com/opensearch-project/OpenSearch/pull/14708))
+- Add setting to ignore throttling nodes for allocation of unassigned primaries in remote restore ([#14991](https://github.com/opensearch-project/OpenSearch/pull/14991))
+- [Workload Management] Add Delete QueryGroup API Logic ([#14735](https://github.com/opensearch-project/OpenSearch/pull/14735))
+- [Streaming Indexing] Enhance RestClient with a new streaming API support ([#14437](https://github.com/opensearch-project/OpenSearch/pull/14437))
+- Add basic aggregation support for derived fields ([#14618](https://github.com/opensearch-project/OpenSearch/pull/14618))
+- [Workload Management] Add Create QueryGroup API Logic ([#14680](https://github.com/opensearch-project/OpenSearch/pull/14680))- [Workload Management] Add Create QueryGroup API Logic ([#14680](https://github.com/opensearch-project/OpenSearch/pull/14680))
+- Add ThreadContextPermission for markAsSystemContext and allow core to perform the method ([#15016](https://github.com/opensearch-project/OpenSearch/pull/15016))
+- Add ThreadContextPermission for stashAndMergeHeaders and stashWithOrigin ([#15039](https://github.com/opensearch-project/OpenSearch/pull/15039))
+- [Concurrent Segment Search] Support composite aggregations with scripting ([#15072](https://github.com/opensearch-project/OpenSearch/pull/15072))
+- Add `rangeQuery` and `regexpQuery` for `constant_keyword` field type ([#14711](https://github.com/opensearch-project/OpenSearch/pull/14711))
+- Add took time to request nodes stats ([#15054](https://github.com/opensearch-project/OpenSearch/pull/15054))
+- [Workload Management] Add Get QueryGroup API Logic ([14709](https://github.com/opensearch-project/OpenSearch/pull/14709))
+- [Workload Management] Add Update QueryGroup API Logic ([#14775](https://github.com/opensearch-project/OpenSearch/pull/14775))
+- [Workload Management] QueryGroup resource tracking framework changes ([#13897](https://github.com/opensearch-project/OpenSearch/pull/13897))
+- Support filtering on a large list encoded by bitmap ([#14774](https://github.com/opensearch-project/OpenSearch/pull/14774))
+- Add slice execution listeners to SearchOperationListener interface ([#15153](https://github.com/opensearch-project/OpenSearch/pull/15153))
+- Make balanced shards allocator timebound ([#15239](https://github.com/opensearch-project/OpenSearch/pull/15239))
+- Add allowlist setting for ingest-geoip and ingest-useragent ([#15325](https://github.com/opensearch-project/OpenSearch/pull/15325))
+- Adding access to noSubMatches and noOverlappingMatches in Hyphenation ([#13895](https://github.com/opensearch-project/OpenSearch/pull/13895))
+- Star tree mapping changes ([#14605](https://github.com/opensearch-project/OpenSearch/pull/14605))
+- Add support for index level max slice count setting for concurrent segment search ([#15336](https://github.com/opensearch-project/OpenSearch/pull/15336))
+- Support cancellation for cat shards and node stats API.([#13966](https://github.com/opensearch-project/OpenSearch/pull/13966))
+- [Streaming Indexing] Introduce bulk HTTP API streaming flavor ([#15381](https://github.com/opensearch-project/OpenSearch/pull/15381))
+- Add support for centralize snapshot creation with pinned timestamp ([#15124](https://github.com/opensearch-project/OpenSearch/pull/15124))
+- Add concurrent search support for Derived Fields ([#15326](https://github.com/opensearch-project/OpenSearch/pull/15326))
+- [Workload Management] Add query group stats constructs ([#15343](https://github.com/opensearch-project/OpenSearch/pull/15343)))
+- Add limit on number of processors for Ingest pipeline([#15460](https://github.com/opensearch-project/OpenSearch/pull/15465)).
+- Add runAs to Subject interface and introduce IdentityAwarePlugin extension point ([#14630](https://github.com/opensearch-project/OpenSearch/pull/14630))
+- [Workload Management] Add rejection logic for co-ordinator and shard level requests ([#15428](https://github.com/opensearch-project/OpenSearch/pull/15428)))
+- Adding translog durability validation in index templates ([#15494](https://github.com/opensearch-project/OpenSearch/pull/15494))
+- [Range Queries] Add new approximateable query framework to short-circuit range queries ([#13788](https://github.com/opensearch-project/OpenSearch/pull/13788))
+- [Workload Management] Add query group level failure tracking ([#15227](https://github.com/opensearch-project/OpenSearch/pull/15527))
+- [Reader Writer Separation] Add experimental search replica shard type to achieve reader writer separation ([#15237](https://github.com/opensearch-project/OpenSearch/pull/15237))
+- Add index creation using the context field ([#15290](https://github.com/opensearch-project/OpenSearch/pull/15290))
+- [Remote Publication] Add remote download stats ([#15291](https://github.com/opensearch-project/OpenSearch/pull/15291)))
+- Add support to upload snapshot shard blobs with hashed prefix ([#15426](https://github.com/opensearch-project/OpenSearch/pull/15426))
+- Add prefix support to hashed prefix & infix path types on remote store ([#15557](https://github.com/opensearch-project/OpenSearch/pull/15557))
+- Add canRemain method to TargetPoolAllocationDecider to move shards from local to remote pool for hot to warm tiering ([#15010](https://github.com/opensearch-project/OpenSearch/pull/15010))
+- Add support for pluggable deciders for concurrent search ([#15363](https://github.com/opensearch-project/OpenSearch/pull/15363))
+- Add support for comma-separated list of index names to be used with Snapshot Status API ([#15409](https://github.com/opensearch-project/OpenSearch/pull/15409))[SnapshotV2] Snapshot Status API changes (#15409))
+- Optimise snapshot deletion to speed up snapshot deletion and creation ([#15568](https://github.com/opensearch-project/OpenSearch/pull/15568))
+- [Remote Publication] Added checksum validation for cluster state behind a cluster setting ([#15218](https://github.com/opensearch-project/OpenSearch/pull/15218))
+- Relax the join validation for Remote State publication ([#15471](https://github.com/opensearch-project/OpenSearch/pull/15471))
+- Optimize NodeIndicesStats output behind flag ([#14454](https://github.com/opensearch-project/OpenSearch/pull/14454))
 
 ### Dependencies
-- Bump `com.github.spullara.mustache.java:compiler` from 0.9.10 to 0.9.13 ([#13329](https://github.com/opensearch-project/OpenSearch/pull/13329), [#13559](https://github.com/opensearch-project/OpenSearch/pull/13559))
-- Bump `org.apache.commons:commons-text` from 1.11.0 to 1.12.0 ([#13557](https://github.com/opensearch-project/OpenSearch/pull/13557))
-- Bump `org.hdrhistogram:HdrHistogram` from 2.1.12 to 2.2.1 ([#13556](https://github.com/opensearch-project/OpenSearch/pull/13556))
-- Bump `com.gradle.enterprise` from 3.17.2 to 3.17.4 ([#13641](https://github.com/opensearch-project/OpenSearch/pull/13641), [#13753](https://github.com/opensearch-project/OpenSearch/pull/13753))
-- Bump `org.apache.hadoop:hadoop-minicluster` from 3.3.6 to 3.4.0 ([#13642](https://github.com/opensearch-project/OpenSearch/pull/13642))
-- Bump `mockito` from 5.11.0 to 5.12.0 ([#13665](https://github.com/opensearch-project/OpenSearch/pull/13665))
-- Bump `com.google.code.gson:gson` from 2.10.1 to 2.11.0 ([#13752](https://github.com/opensearch-project/OpenSearch/pull/13752))
-- Bump `ch.qos.logback:logback-core` from 1.5.3 to 1.5.6 ([#13756](https://github.com/opensearch-project/OpenSearch/pull/13756))
-- Bump `netty` from 4.1.109.Final to 4.1.110.Final ([#13802](https://github.com/opensearch-project/OpenSearch/pull/13802))
-- Bump `jackson` from 2.17.0 to 2.17.1 ([#13817](https://github.com/opensearch-project/OpenSearch/pull/13817))
-- Bump `reactor` from 3.5.15 to 3.5.17 ([#13825](https://github.com/opensearch-project/OpenSearch/pull/13825))
-- Bump `reactor-netty` from 1.1.17 to 1.1.19 ([#13825](https://github.com/opensearch-project/OpenSearch/pull/13825))
-- Bump `commons-cli:commons-cli` from 1.7.0 to 1.8.0 ([#13840](https://github.com/opensearch-project/OpenSearch/pull/13840))
+- Bump `netty` from 4.1.111.Final to 4.1.112.Final ([#15081](https://github.com/opensearch-project/OpenSearch/pull/15081))
+- Bump `org.apache.commons:commons-lang3` from 3.14.0 to 3.15.0 ([#14861](https://github.com/opensearch-project/OpenSearch/pull/14861))
+- OpenJDK Update (July 2024 Patch releases) ([#14998](https://github.com/opensearch-project/OpenSearch/pull/14998))
+- Bump `com.microsoft.azure:msal4j` from 1.16.1 to 1.17.0 ([#14995](https://github.com/opensearch-project/OpenSearch/pull/14995), [#15420](https://github.com/opensearch-project/OpenSearch/pull/15420))
+- Bump `actions/github-script` from 6 to 7 ([#14997](https://github.com/opensearch-project/OpenSearch/pull/14997))
+- Bump `org.tukaani:xz` from 1.9 to 1.10 ([#15110](https://github.com/opensearch-project/OpenSearch/pull/15110))
+- Bump `org.apache.avro:avro` from 1.11.3 to 1.12.0 in /plugins/repository-hdfs ([#15119](https://github.com/opensearch-project/OpenSearch/pull/15119))
+- Bump `org.bouncycastle:bcpg-fips` from 1.0.7.1 to 2.0.9 ([#15103](https://github.com/opensearch-project/OpenSearch/pull/15103), [#15299](https://github.com/opensearch-project/OpenSearch/pull/15299))
+- Bump `com.azure:azure-core` from 1.49.1 to 1.51.0 ([#15111](https://github.com/opensearch-project/OpenSearch/pull/15111))
+- Bump `org.xerial.snappy:snappy-java` from 1.1.10.5 to 1.1.10.6 ([#15207](https://github.com/opensearch-project/OpenSearch/pull/15207))
+- Bump `com.azure:azure-xml` from 1.0.0 to 1.1.0 ([#15206](https://github.com/opensearch-project/OpenSearch/pull/15206))
+- Bump `reactor` from 3.5.19 to 3.5.20 ([#15262](https://github.com/opensearch-project/OpenSearch/pull/15262))
+- Bump `reactor-netty` from 1.1.21 to 1.1.22 ([#15262](https://github.com/opensearch-project/OpenSearch/pull/15262))
+- Bump `org.apache.kerby:kerb-admin` from 2.0.3 to 2.1.0 ([#15301](https://github.com/opensearch-project/OpenSearch/pull/15301))
+- Bump `com.azure:azure-core-http-netty` from 1.15.1 to 1.15.3 ([#15300](https://github.com/opensearch-project/OpenSearch/pull/15300))
+- Bump `com.gradle.develocity` from 3.17.6 to 3.18 ([#15297](https://github.com/opensearch-project/OpenSearch/pull/15297))
+- Bump `commons-cli:commons-cli` from 1.8.0 to 1.9.0 ([#15298](https://github.com/opensearch-project/OpenSearch/pull/15298))
+- Bump `opentelemetry` from 1.40.0 to 1.41.0 ([#15361](https://github.com/opensearch-project/OpenSearch/pull/15361))
+- Bump `opentelemetry-semconv` from 1.26.0-alpha to 1.27.0-alpha ([#15361](https://github.com/opensearch-project/OpenSearch/pull/15361))
+- Bump `tj-actions/changed-files` from 44 to 45 ([#15422](https://github.com/opensearch-project/OpenSearch/pull/15422))
+- Bump `dnsjava:dnsjava` from 3.6.0 to 3.6.1 ([#15418](https://github.com/opensearch-project/OpenSearch/pull/15418))
+- Bump `com.netflix.nebula.ospackage-base` from 11.9.1 to 11.10.0 ([#15419](https://github.com/opensearch-project/OpenSearch/pull/15419))
+- Bump `org.roaringbitmap:RoaringBitmap` from 1.1.0 to 1.2.1 ([#15423](https://github.com/opensearch-project/OpenSearch/pull/15423))
+- Bump `icu4j` from 70.1 to 75.1 ([#15469](https://github.com/opensearch-project/OpenSearch/pull/15469))
 
 ### Changed
-- Add ability for Boolean and date field queries to run when only doc_values are enabled ([#11650](https://github.com/opensearch-project/OpenSearch/pull/11650))
-- Refactor implementations of query phase searcher, allow QueryCollectorContext to have zero collectors ([#13481](https://github.com/opensearch-project/OpenSearch/pull/13481))
-- Adds support to inject telemetry instances to plugins ([#13636](https://github.com/opensearch-project/OpenSearch/pull/13636))
+- Add lower limit for primary and replica batch allocators timeout ([#14979](https://github.com/opensearch-project/OpenSearch/pull/14979))
+- Optimize regexp-based include/exclude on aggregations when pattern matches prefixes ([#14371](https://github.com/opensearch-project/OpenSearch/pull/14371))
+- Replace and block usages of org.apache.logging.log4j.util.Strings ([#15238](https://github.com/opensearch-project/OpenSearch/pull/15238))
+- Remote publication using minimum node version for backward compatibility ([#15216](https://github.com/opensearch-project/OpenSearch/pull/15216))
+
 
 ### Deprecated
 
 ### Removed
-- Remove handling of index.mapper.dynamic in AutoCreateIndex([#13067](https://github.com/opensearch-project/OpenSearch/pull/13067))
+- Remove some unused code in the search backpressure package ([#15518](https://github.com/opensearch-project/OpenSearch/pull/15518))
 
 ### Fixed
-- Fix negative RequestStats metric issue ([#13553](https://github.com/opensearch-project/OpenSearch/pull/13553))
-- Fix get field mapping API returns 404 error in mixed cluster with multiple versions ([#13624](https://github.com/opensearch-project/OpenSearch/pull/13624))
-- Allow clearing `remote_store.compatibility_mode` setting ([#13646](https://github.com/opensearch-project/OpenSearch/pull/13646))
+- Fix constraint bug which allows more primary shards than average primary shards per index ([#14908](https://github.com/opensearch-project/OpenSearch/pull/14908))
+- Fix NPE when bulk ingest with empty pipeline ([#15033](https://github.com/opensearch-project/OpenSearch/pull/15033))
+- Fix missing value of FieldSort for unsigned_long ([#14963](https://github.com/opensearch-project/OpenSearch/pull/14963))
+- Fix delete index template failed when the index template matches a data stream but is unused ([#15080](https://github.com/opensearch-project/OpenSearch/pull/15080))
+- Fix array_index_out_of_bounds_exception when indexing documents with field name containing only dot ([#15126](https://github.com/opensearch-project/OpenSearch/pull/15126))
+- Fixed array field name omission in flat_object function for nested JSON ([#13620](https://github.com/opensearch-project/OpenSearch/pull/13620))
+- Fix incorrect parameter names in MinHash token filter configuration handling ([#15233](https://github.com/opensearch-project/OpenSearch/pull/15233))
+- Fix range aggregation optimization ignoring top level queries ([#15287](https://github.com/opensearch-project/OpenSearch/pull/15287))
+- Fix indexing error when flat_object field is explicitly null ([#15375](https://github.com/opensearch-project/OpenSearch/pull/15375))
+- Fix split response processor not included in allowlist ([#15393](https://github.com/opensearch-project/OpenSearch/pull/15393))
+- Fix unchecked cast in dynamic action map getter ([#15394](https://github.com/opensearch-project/OpenSearch/pull/15394))
+- Fix null values indexed as "null" strings in flat_object field ([#14069](https://github.com/opensearch-project/OpenSearch/pull/14069))
+- Fix terms query on wildcard field returns nothing ([#15607](https://github.com/opensearch-project/OpenSearch/pull/15607))
 
 ### Security
 
-[Unreleased 2.x]: https://github.com/opensearch-project/OpenSearch/compare/2.13...2.x
+[Unreleased 2.x]: https://github.com/opensearch-project/OpenSearch/compare/2.16...2.x
diff --git a/MAINTAINERS.md b/MAINTAINERS.md
index 6855281a488ca..4a8aa9305df74 100644
--- a/MAINTAINERS.md
+++ b/MAINTAINERS.md
@@ -5,20 +5,24 @@ This document contains a list of maintainers in this repo. See [opensearch-proje
 ## Current Maintainers
 
 | Maintainer               | GitHub ID                                               | Affiliation |
-| ------------------------ | ------------------------------------------------------- | ----------- |
+|--------------------------|---------------------------------------------------------|-------------|
 | Anas Alkouz              | [anasalkouz](https://github.com/anasalkouz)             | Amazon      |
 | Andrew Ross              | [andrross](https://github.com/andrross)                 | Amazon      |
 | Andriy Redko             | [reta](https://github.com/reta)                         | Aiven       |
+| Ankit Jain               | [jainankitk](https://github.com/jainankitk)             | Amazon      |
+| Ashish Singh             | [ashking94](https://github.com/ashking94)               | Amazon      |
 | Bukhtawar Khan           | [Bukhtawar](https://github.com/Bukhtawar)               | Amazon      |
 | Charlotte Henkle         | [CEHENKLE](https://github.com/CEHENKLE)                 | Amazon      |
 | Dan Widdis               | [dbwiddis](https://github.com/dbwiddis)                 | Amazon      |
 | Daniel "dB." Doubrovkine | [dblock](https://github.com/dblock)                     | Amazon      |
+| Gao Binlong              | [gaobinlong](https://github.com/gaobinlong)             | Amazon      |
 | Gaurav Bafna             | [gbbafna](https://github.com/gbbafna)                   | Amazon      |
 | Jay Deng                 | [jed326](https://github.com/jed326)                     | Amazon      |
 | Kunal Kotwani            | [kotwanikunal](https://github.com/kotwanikunal)         | Amazon      |
+| Varun Bansal             | [linuxpi](https://github.com/linuxpi)                   | Amazon      |
 | Marc Handalian           | [mch2](https://github.com/mch2)                         | Amazon      |
 | Michael Froh             | [msfroh](https://github.com/msfroh)                     | Amazon      |
-| Nick Knize               | [nknize](https://github.com/nknize)                     | Amazon      |
+| Nick Knize               | [nknize](https://github.com/nknize)                     | Lucenia     |
 | Owais Kazi               | [owaiskazi19](https://github.com/owaiskazi19)           | Amazon      |
 | Peter Nied               | [peternied](https://github.com/peternied)               | Amazon      |
 | Rishikesh Pasham         | [Rishikesh1159](https://github.com/Rishikesh1159)       | Amazon      |
@@ -26,18 +30,18 @@ This document contains a list of maintainers in this repo. See [opensearch-proje
 | Sarat Vemulapalli        | [saratvemulapalli](https://github.com/saratvemulapalli) | Amazon      |
 | Shweta Thareja           | [shwetathareja](https://github.com/shwetathareja)       | Amazon      |
 | Sorabh Hamirwasia        | [sohami](https://github.com/sohami)                     | Amazon      |
-| Suraj Singh              | [dreamer-89](https://github.com/dreamer-89)             | Amazon      |
-| Tianli Feng              | [tlfeng](https://github.com/tlfeng)                     | Amazon      |
 | Vacha Shah               | [VachaShah](https://github.com/VachaShah)               | Amazon      |
 
 ## Emeritus
 
-| Maintainer            | GitHub ID                                 | Affiliation |
-| --------------------- | ----------------------------------------- | ----------- |
-| Megha Sai Kavikondala | [meghasaik](https://github.com/meghasaik) | Amazon      |
-| Xue Zhou              | [xuezhou25](https://github.com/xuezhou25) | Amazon      |
-| Kartik Ganesh         | [kartg](https://github.com/kartg)         | Amazon      |
-| Abbas Hussain         | [abbashus](https://github.com/abbashus)   | Meta        |
-| Himanshu Setia        | [setiah](https://github.com/setiah)       | Amazon      |
-| Ryan Bogan            | [ryanbogan](https://github.com/ryanbogan) | Amazon      |
-| Rabi Panda            | [adnapibar](https://github.com/adnapibar) | Independent |
+| Maintainer             | GitHub ID                                   | Affiliation |
+| ---------------------- |-------------------------------------------- | ----------- |
+| Megha Sai Kavikondala  | [meghasaik](https://github.com/meghasaik)   | Amazon      |
+| Xue Zhou               | [xuezhou25](https://github.com/xuezhou25)   | Amazon      |
+| Kartik Ganesh          | [kartg](https://github.com/kartg)           | Amazon      |
+| Abbas Hussain          | [abbashus](https://github.com/abbashus)     | Meta        |
+| Himanshu Setia         | [setiah](https://github.com/setiah)         | Amazon      |
+| Ryan Bogan             | [ryanbogan](https://github.com/ryanbogan)   | Amazon      |
+| Rabi Panda             | [adnapibar](https://github.com/adnapibar)   | Independent |
+| Tianli Feng            | [tlfeng](https://github.com/tlfeng)         | Amazon      |
+| Suraj Singh            | [dreamer-89](https://github.com/dreamer-89) | Amazon      |
diff --git a/TESTING.md b/TESTING.md
index 85fc889270955..b6e7354225c7e 100644
--- a/TESTING.md
+++ b/TESTING.md
@@ -17,6 +17,8 @@ OpenSearch uses [jUnit](https://junit.org/junit5/) for testing, it also uses ran
   - [Miscellaneous](#miscellaneous)
 - [Running verification tasks](#running-verification-tasks)
 - [Testing the REST layer](#testing-the-rest-layer)
+  - [Running REST Tests Against An External Cluster](#running-rest-tests-against-an-external-cluster)
+  - [Debugging REST Tests](#debugging-rest-tests)
 - [Testing packaging](#testing-packaging)
   - [Testing packaging on Windows](#testing-packaging-on-windows)
   - [Testing VMs are disposable](#testing-vms-are-disposable)
@@ -32,6 +34,9 @@ OpenSearch uses [jUnit](https://junit.org/junit5/) for testing, it also uses ran
   - [Bad practices](#bad-practices)
     - [Use randomized-testing for coverage](#use-randomized-testing-for-coverage)
     - [Abuse randomization in multi-threaded tests](#abuse-randomization-in-multi-threaded-tests)
+    - [Use `Thread.sleep`](#use-threadsleep)
+    - [Expect a specific segment topology](#expect-a-specific-segment-topology)
+    - [Leave environment in an unstable state after test](#leave-environment-in-an-unstable-state-after-test)
 - [Test coverage analysis](#test-coverage-analysis)
 - [Building with extra plugins](#building-with-extra-plugins)
 - [Environment misc](#environment-misc)
@@ -87,21 +92,23 @@ This will instruct all JVMs (including any that run cli tools such as creating t
 
 ## Test case filtering
 
--   `tests.class` is a class-filtering shell-like glob pattern
--   `tests.method` is a method-filtering glob pattern.
+To be able to run a single test you need to specify the module where you're running the tests from.
+
+Example: `./gradlew server:test --tests "*.ReplicaShardBatchAllocatorTests.testNoAsyncFetchData"`
 
 Run a single test case (variants)
 
-    ./gradlew test -Dtests.class=org.opensearch.package.ClassName
-    ./gradlew test "-Dtests.class=*.ClassName"
+    ./gradlew module:test --tests org.opensearch.package.ClassName
+    ./gradlew module:test --tests org.opensearch.package.ClassName.testName
+    ./gradlew module:test --tests "*.ClassName"
 
 Run all tests in a package and its sub-packages
 
-    ./gradlew test "-Dtests.class=org.opensearch.package.*"
+    ./gradlew module:test --tests "org.opensearch.package.*"
 
 Run any test methods that contain *esi* (e.g.: .r*esi*ze.)
 
-    ./gradlew test "-Dtests.method=*esi*"
+    ./gradlew module:test --tests "*esi*"
 
 Run all tests that are waiting for a bugfix (disabled by default)
 
@@ -266,7 +273,18 @@ yamlRestTest’s and javaRestTest’s are easy to identify, since they are found
 
 If in doubt about which command to use, simply run &lt;gradle path&gt;:check
 
-Note that the REST tests, like all the integration tests, can be run against an external cluster by specifying the `tests.cluster` property, which if present needs to contain a comma separated list of nodes to connect to (e.g. localhost:9300).
+## Running REST Tests Against An External Cluster
+
+Note that the REST tests, like all the integration tests, can be run against an external cluster by specifying the following properties `tests.cluster`, `tests.rest.cluster`, `tests.clustername`. Use a comma separated list of node properties for the multi-node cluster.
+
+For example :
+
+    ./gradlew :rest-api-spec:yamlRestTest \
+      -Dtests.cluster=localhost:9200 -Dtests.rest.cluster=localhost:9200 -Dtests.clustername=opensearch
+
+## Debugging REST Tests
+
+You can launch a local OpenSearch cluster in debug mode following [Launching and debugging from an IDE](#launching-and-debugging-from-an-ide), and run your REST tests against that following [Running REST Tests Against An External Cluster](#running-rest-tests-against-an-external-cluster).
 
 # Testing packaging
 
@@ -431,7 +449,7 @@ Unit tests are the preferred way to test some functionality: most of the time th
 
 The reason why `OpenSearchSingleNodeTestCase` exists is that all our components used to be very hard to set up in isolation, which had led us to having a number of integration tests but close to no unit tests. `OpenSearchSingleNodeTestCase` is a workaround for this issue which provides an easy way to spin up a node and get access to components that are hard to instantiate like `IndicesService`. Whenever practical, you should prefer unit tests.
 
-Finally, if the the functionality under test needs to be run in a cluster, there are two test classes to consider:
+Finally, if the functionality under test needs to be run in a cluster, there are two test classes to consider:
   * `OpenSearchRestTestCase` will connect to an external cluster. This is a good option if the tests cases don't rely on a specific configuration of the test cluster. A test cluster is set up as part of the Gradle task running integration tests, and test cases using this class can connect to it. The configuration of the cluster is provided in the Gradle files.
   * `OpenSearchIntegTestCase` will create a local cluster as part of each test case. The configuration of the cluster is controlled by the test class. This is a good option if different tests cases depend on different cluster configurations, as it would be impractical (and limit parallelization) to keep re-configuring (and re-starting) the external cluster for each test case. A good example of when this class might come in handy is for testing security features, where different cluster configurations are needed to fully test each one.
 
@@ -453,6 +471,27 @@ However, it should not be used for coverage. For instance if you are testing a p
 
 Multi-threaded tests are often not reproducible due to the fact that there is no guarantee on the order in which operations occur across threads. Adding randomization to the mix usually makes things worse and should be done with care.
 
+### Use `Thread.sleep`
+
+`Thread.sleep()` is almost always a bad idea because it is very difficult to know that you've waited long enough. Using primitives like `waitUntil` or `assertBusy`, which use Thread.sleep internally, is okay to wait for a specific condition. However, it is almost always better to instrument your code with concurrency primitives like a `CountDownLatch` that will allow you to deterministically wait for a specific condition, without waiting longer than necessary that will happen with a polling approach used by `assertBusy`.
+
+Example:
+- [PrimaryShardAllocatorIT](https://github.com/opensearch-project/OpenSearch/blob/7ffcd6500e0bd5956cef5c289ee66d9f99d533fc/server/src/internalClusterTest/java/org/opensearch/gateway/ReplicaShardAllocatorIT.java#L208-L235): This test is using two latches: one to wait for a recovery to start and one to block that recovery so that it can deterministically test things that happen during a recovery.
+
+### Expect a specific segment topology
+
+By design, OpenSearch integration tests will vary how the merge policy works because in almost all scenarios you should not depend on a specific segment topology (in the real world your code will see a huge diversity of indexing workloads with OpenSearch merging things in the background all the time!). If you do in fact need to care about the segment topology (e.g. for testing statistics that might vary slightly depending on number of segments), then you must take care to ensure that segment topology is deterministic by doing things like disabling background refreshes, force merging after indexing data, etc.
+
+Example:
+- [SegmentReplicationResizeRequestIT](https://github.com/opensearch-project/OpenSearch/blob/f715ee1a485e550802accc1c2e3d8101208d4f0b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationResizeRequestIT.java#L102-L109): This test disables refreshes to prevent interfering with the segment replication behavior under test.
+
+### Leave environment in an unstable state after test
+
+The default test case will ensure that no open file handles or running threads are left after tear down. You must ensure that all resources are cleaned up at the end of each test case, or else the cleanup may end up racing with the tear down logic in the base test class in a way that is very difficult to reproduce.
+
+Example:
+- [AwarenessAttributeDecommissionIT](https://github.com/opensearch-project/OpenSearch/blob/main/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/AwarenessAttributeDecommissionIT.java#L951): Recommissions any decommissioned nodes at the end of the test to ensure the after-test checks succeed.
+
 # Test coverage analysis
 
 The code coverage report can be generated through Gradle with [JaCoCo plugin](https://docs.gradle.org/current/userguide/jacoco_plugin.html).
diff --git a/TRIAGING.md b/TRIAGING.md
new file mode 100644
index 0000000000000..90842cd8e9393
--- /dev/null
+++ b/TRIAGING.md
@@ -0,0 +1,87 @@
+<img src="https://opensearch.org/assets/img/opensearch-logo-themed.svg" height="64px">
+
+The maintainers of the OpenSearch Repo seek to promote an inclusive and engaged community of contributors. In order to facilitate this, weekly triage meetings are open-to-all and attendance is encouraged for anyone who hopes to contribute, discuss an issue, or learn more about the project. There are several weekly triage meetings scoped to the following component areas: Search, Storage, Cluster Manager, and finally "Core" as a catch-all for all other issues. To learn more about contributing to the OpenSearch Repo visit the [Contributing](./CONTRIBUTING.md) documentation.
+
+### Do I need to attend for my issue to be addressed/triaged?
+
+Attendance is not required for your issue to be triaged or addressed.  If not accepted the issue will be updated with a comment for next steps.  All new issues are triaged weekly.
+
+You can track if your issue was triaged by watching your GitHub notifications for updates.
+
+### What happens if my issue does not get covered this time?
+
+Each meeting we seek to address all new issues. However, should we run out of time before your issue is discussed, you are always welcome to attend the next meeting or to follow up on the issue post itself.
+
+### How do I join a Triage meeting?
+
+ Check the [OpenSearch Meetup Group](https://www.meetup.com/opensearch/) for the latest schedule and details for joining each meeting. Each component area has its own meetup series: [Search](https://www.meetup.com/opensearch/events/300929493/), [Storage](https://www.meetup.com/opensearch/events/299907409/), [Cluster Manager](https://www.meetup.com/opensearch/events/301082218/), and [Core](https://www.meetup.com/opensearch/events/301061009/).
+
+After joining the virtual meeting, you can enable your video / voice to join the discussion.  If you do not have a webcam or microphone available, you can still join in via the text chat.
+
+If you have an issue you'd like to bring forth please prepare a link to the issue so it can be presented and viewed by everyone in the meeting.
+
+### Is there an agenda for each week?
+
+Meeting structure may vary slightly, but the general structure is as follows:
+
+1. **Initial Gathering:** Feel free to turn on your video and engage in informal conversation. Shortly, a volunteer triage [facilitator](#what-is-the-role-of-the-facilitator) will begin the meeting and share their screen.
+2. **Record Attendees:** The facilitator will request attendees to share their GitHub profile links. These links will be collected and assembled into a [tag](#how-do-triage-facilitator-tag-comments-during-the-triage-meeting) to annotate comments during the meeting.
+3. **Announcements:** Any announcements will be made at the beginning of the meeting.
+4. **Review of New Issues:** We start by reviewing all untriaged issues. Each meeting has a label-based search to find relevant issues:
+   - [Search](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3Auntriaged+label%3A%22Search%22%2C%22Search%3ARemote+Search%22%2C%22Search%3AResiliency%22%2C%22Search%3APerformance%22%2C%22Search%3ARelevance%22%2C%22Search%3AAggregations%22%2C%22Search%3AQuery+Capabilities%22%2C%22Search%3AQuery+Insights%22%2C%22Search%3ASearchable+Snapshots%22%2C%22Search%3AUser+Behavior+Insights%22)
+   - [Storage](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3Auntriaged+label%3AStorage%2C%22Storage%3AResiliency%22%2C%22Storage%3APerformance%22%2C%22Storage%3ASnapshots%22%2C%22Storage%3ARemote%22%2C%22Storage%3ADurability%22)
+   - [Cluster Manager](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3Auntriaged+label%3A%22Cluster+Manager%22%2C%22ClusterManager%3ARemoteState%22)
+   - [Core](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3Auntriaged+-label%3A%22Search%22%2C%22Search%3ARemote+Search%22%2C%22Search%3AResiliency%22%2C%22Search%3APerformance%22%2C%22Search%3ARelevance%22%2C%22Search%3AAggregations%22%2C%22Search%3AQuery+Capabilities%22%2C%22Search%3AQuery+Insights%22%2C%22Search%3ASearchable+Snapshots%22%2C%22Search%3AUser+Behavior+Insights%22%2C%22Storage%22%2C%22Storage%3AResiliency%22%2C%22Storage%3APerformance%22%2C%22Storage%3ASnapshots%22%2C%22Storage%3ARemote%22%2C%22Storage%3ADurability%22%2C%22Cluster+Manager%22%2C%22ClusterManager%3ARemoteState%22)
+5. **Attendee Requests:** An opportunity for any meeting member to request consideration of an issue or pull request.
+6. **Open Discussion:** Attendees can bring up any topics not already covered by filed issues or pull requests.
+7. **Review of Old Untriaged Issues:** Time permitting, each meeting will look at all [untriaged issues older than 14 days](https://github.com/opensearch-project/OpenSearch/issues?q=is%3Aissue+is%3Aopen+label%3Auntriaged+created%3A%3C2024-05-20) to prevent issues from falling through the cracks (note the GitHub API does not allow for relative times, so the date in this search must be updated every meeting).
+
+### What is the role of the facilitator?
+
+The facilitator is crucial in driving the meeting, ensuring a smooth flow of issues into OpenSearch for future contributions. They maintain the meeting's agenda, solicit input from attendees, and record outcomes using the triage tag as items are discussed.
+
+### Do I need to have already contributed to the project to attend a triage meeting?
+
+No prior contributions are required. All interested individuals are welcome and encouraged to attend. Triage meetings offer a fantastic opportunity for new contributors to understand the project and explore various contribution avenues.
+
+### What if I have an issue that is almost a duplicate, should I open a new one to be triaged?
+
+You can always open an [issue](https://github.com/opensearch-project/OpenSearch/issues/new/choose) including one that you think may be a duplicate. If you believe your issue is similar but distinct from an existing one, you are encouraged to file it and explain the differences during the triage meeting.
+
+### What if I have follow-up questions on an issue?
+
+If you have an existing issue you would like to discuss, you can always comment on the issue itself. Alternatively, you are welcome to come to the triage meeting to discuss.
+
+### Is this meeting a good place to get help setting up features on my OpenSearch instance?
+
+While we are always happy to help the community, the best resource for implementation questions is [the OpenSearch forum](https://forum.opensearch.org/).
+
+There you can find answers to many common questions as well as speak with implementation experts.
+
+### What are the issue labels associated with triaging?
+
+Yes, there are several labels that are used to identify the 'state' of issues filed in OpenSearch .
+| Label         | When Applied         | Meaning                                                                                                                                 |
+|---------------|----------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
+| `Untriaged` | When issues are created or re-opened. | Issues labeled as 'Untriaged' require the attention of the repository maintainers and may need to be prioritized for quicker resolution. It's crucial to keep the count of 'Untriaged' labels low to ensure all potential security issues are addressed in a timely manner. See [SECURITY.md](https://github.com/opensearch-project/OpenSearch/blob/main/SECURITY.md) for more details on handling these issues. |
+| `Help Wanted` | Anytime. | Issues marked as 'Help Wanted' signal that they are actionable and not the current focus of the project maintainers. Community contributions are especially encouraged for these issues. |
+| `Good First Issue` | Anytime. | Issues labeled as 'Good First Issue' are small in scope and can be resolved with a single pull request. These are recommended starting points for newcomers looking to make their first contributions. |
+
+### What are the typical outcomes of a triaged issue?
+
+| Outcome      | Label            | Description                                                                                                                                                                                      | Canned Response                                                                                                                                                           |
+|--------------|------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Accepted     | `-untriaged`     | The issue has the details needed to be directed towards area owners.                                                                                                                            | "Thanks for filing this issue, please feel free to submit a pull request."                                                                                                 |
+| Rejected     | N/A              | The issue will be closed with a reason for why it was rejected. Reasons might include lack of details, or being outside the scope of the project.                                               | "Thanks for creating this issue; however, it isn't being accepted due to {REASON}. Please feel free to open a new issue after addressing the reason."                                |
+| Area Triage  | `+{AREALABEL}`  | OpenSearch has many different areas. If it's unclear whether an issue should be accepted, it will be labeled with the area and an owner will be @mentioned for follow-up.                        | "Thanks for creating this issue; the triage meeting was unsure if this issue should be accepted, @{PERSON} or someone from the area please review and then accept or reject this issue?" |
+| Transfer     | N/A              | If the issue applies to another repository within the OpenSearch Project, it will be transferred accordingly.                                                                                    | "@opensearch-project/triage, can you please transfer this issue to project {REPOSITORY}." Or, if someone at the meeting has permissions, they can start the transfer.        |
+
+### Is this where I should bring up potential security vulnerabilities?
+
+Due to the sensitive nature of security vulnerabilities, please report all potential vulnerabilities directly by following the steps outlined on the [SECURITY.md](https://github.com/opensearch-project/OpenSearch/blob/main/SECURITY.md) document.
+
+### How do triage facilitator tag comments during the triage meeting?
+
+During the triage meeting, facilitators should use the tag _[Triage - attendees [1](#Profile_link) [2](#Profile_link)]_ to indicate a collective decision. This ensures contributors know the decision came from the meeting rather than an individual and identifies participants for any follow-up queries.
+
+This tag should not be used outside triage meetings.
diff --git a/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/RerouteBenchmark.java b/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/RerouteBenchmark.java
new file mode 100644
index 0000000000000..e54bca579423b
--- /dev/null
+++ b/benchmarks/src/main/java/org/opensearch/benchmark/routing/allocation/RerouteBenchmark.java
@@ -0,0 +1,135 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.benchmark.routing.allocation;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.allocation.AllocationService;
+import org.opensearch.common.logging.LogConfigurator;
+import org.opensearch.common.settings.Settings;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.BenchmarkMode;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Mode;
+import org.openjdk.jmh.annotations.OutputTimeUnit;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static org.opensearch.cluster.routing.ShardRoutingState.INITIALIZING;
+
+@Fork(1)
+@Warmup(iterations = 3)
+@Measurement(iterations = 3)
+@BenchmarkMode(Mode.AverageTime)
+@OutputTimeUnit(TimeUnit.MILLISECONDS)
+@State(Scope.Benchmark)
+@SuppressWarnings("unused") // invoked by benchmarking framework
+public class RerouteBenchmark {
+    @Param({
+        // indices| nodes
+        "    10000|  500|", })
+    public String indicesNodes = "1|1";
+    public int numIndices;
+    public int numNodes;
+    public int numShards = 10;
+    public int numReplicas = 1;
+
+    private AllocationService allocationService;
+    private ClusterState initialClusterState;
+
+    @Setup
+    public void setUp() throws Exception {
+        LogConfigurator.setNodeName("test");
+        final String[] params = indicesNodes.split("\\|");
+        numIndices = toInt(params[0]);
+        numNodes = toInt(params[1]);
+
+        int totalShardCount = (numReplicas + 1) * numShards * numIndices;
+        Metadata.Builder mb = Metadata.builder();
+        for (int i = 1; i <= numIndices; i++) {
+            mb.put(
+                IndexMetadata.builder("test_" + i)
+                    .settings(Settings.builder().put("index.version.created", Version.CURRENT))
+                    .numberOfShards(numShards)
+                    .numberOfReplicas(numReplicas)
+            );
+        }
+
+        Metadata metadata = mb.build();
+        RoutingTable.Builder rb = RoutingTable.builder();
+        for (int i = 1; i <= numIndices; i++) {
+            rb.addAsNew(metadata.index("test_" + i));
+        }
+        RoutingTable routingTable = rb.build();
+        initialClusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(setUpClusterNodes(numNodes))
+            .build();
+    }
+
+    @Benchmark
+    public ClusterState measureShardAllocationEmptyCluster() throws Exception {
+        ClusterState clusterState = initialClusterState;
+        allocationService = Allocators.createAllocationService(
+            Settings.builder()
+                .put("cluster.routing.allocation.awareness.attributes", "zone")
+                .put("cluster.routing.allocation.load_awareness.provisioned_capacity", numNodes)
+                .put("cluster.routing.allocation.load_awareness.skew_factor", "50")
+                .put("cluster.routing.allocation.node_concurrent_recoveries", "2")
+                .build()
+        );
+        clusterState = allocationService.reroute(clusterState, "reroute");
+        while (clusterState.getRoutingNodes().hasUnassignedShards()) {
+            clusterState = startInitializingShardsAndReroute(allocationService, clusterState);
+        }
+        return clusterState;
+    }
+
+    private int toInt(String v) {
+        return Integer.valueOf(v.trim());
+    }
+
+    private DiscoveryNodes.Builder setUpClusterNodes(int nodes) {
+        DiscoveryNodes.Builder nb = DiscoveryNodes.builder();
+        for (int i = 1; i <= nodes; i++) {
+            Map<String, String> attributes = new HashMap<>();
+            attributes.put("zone", "zone_" + (i % 3));
+            nb.add(Allocators.newNode("node_0_" + i, attributes));
+        }
+        return nb;
+    }
+
+    private static ClusterState startInitializingShardsAndReroute(AllocationService allocationService, ClusterState clusterState) {
+        return startShardsAndReroute(allocationService, clusterState, clusterState.routingTable().shardsWithState(INITIALIZING));
+    }
+
+    private static ClusterState startShardsAndReroute(
+        AllocationService allocationService,
+        ClusterState clusterState,
+        List<ShardRouting> initializingShards
+    ) {
+        return allocationService.reroute(allocationService.applyStartedShards(clusterState, initializingShards), "reroute after starting");
+    }
+}
diff --git a/build.gradle b/build.gradle
index 80e0b0dc95d4d..a0a253fc00bd9 100644
--- a/build.gradle
+++ b/build.gradle
@@ -55,7 +55,6 @@ plugins {
   id 'opensearch.docker-support'
   id 'opensearch.global-build-info'
   id "com.diffplug.spotless" version "6.25.0" apply false
-  id "org.gradle.test-retry" version "1.5.8" apply false
   id "test-report-aggregation"
   id 'jacoco-report-aggregation'
 }
@@ -71,6 +70,13 @@ apply from: 'gradle/run.gradle'
 apply from: 'gradle/missing-javadoc.gradle'
 apply from: 'gradle/code-coverage.gradle'
 
+// Disable unconditional publishing of build scans
+develocity {
+  buildScan {
+    publishing.onlyIf { false }
+  }
+}
+
 // common maven publishing configuration
 allprojects {
   group = 'org.opensearch'
@@ -454,9 +460,8 @@ gradle.projectsEvaluated {
 
 // test retry configuration
 subprojects {
-  apply plugin: "org.gradle.test-retry"
   tasks.withType(Test).configureEach {
-    retry {
+    develocity.testRetry {
       if (BuildParams.isCi()) {
         maxRetries = 3
         maxFailures = 10
diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle
index b41997d7fc813..4ebcd5ea57911 100644
--- a/buildSrc/build.gradle
+++ b/buildSrc/build.gradle
@@ -127,7 +127,7 @@ dependencies {
   testFixturesApi "com.carrotsearch.randomizedtesting:randomizedtesting-runner:${props.getProperty('randomizedrunner')}"
   testFixturesApi gradleApi()
   testFixturesApi gradleTestKit()
-  testImplementation 'org.wiremock:wiremock-standalone:3.3.1'
+  testImplementation 'org.wiremock:wiremock-standalone:3.6.0'
   testImplementation "org.mockito:mockito-core:${props.getProperty('mockito')}"
   integTestImplementation('org.spockframework:spock-core:2.3-groovy-3.0') {
     exclude module: "groovy"
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/info/GlobalBuildInfoPlugin.java b/buildSrc/src/main/java/org/opensearch/gradle/info/GlobalBuildInfoPlugin.java
index 448ba8a96ef02..570ab4a9f70e1 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/info/GlobalBuildInfoPlugin.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/info/GlobalBuildInfoPlugin.java
@@ -199,7 +199,28 @@ private JavaVersion determineJavaVersion(String description, File javaHome, Java
     }
 
     private JvmInstallationMetadata getJavaInstallation(File javaHome) {
-        final InstallationLocation location = new InstallationLocation(javaHome, "Java home");
+        InstallationLocation location = null;
+
+        try {
+            try {
+                // The InstallationLocation(File, String) is used by Gradle pre-8.8
+                location = (InstallationLocation) MethodHandles.publicLookup()
+                    .findConstructor(InstallationLocation.class, MethodType.methodType(void.class, File.class, String.class))
+                    .invokeExact(javaHome, "Java home");
+            } catch (Throwable ex) {
+                // The InstallationLocation::userDefined is used by Gradle post-8.7
+                location = (InstallationLocation) MethodHandles.publicLookup()
+                    .findStatic(
+                        InstallationLocation.class,
+                        "userDefined",
+                        MethodType.methodType(InstallationLocation.class, File.class, String.class)
+                    )
+                    .invokeExact(javaHome, "Java home");
+
+            }
+        } catch (Throwable ex) {
+            throw new IllegalStateException("Unable to find suitable InstallationLocation constructor / factory method", ex);
+        }
 
         try {
             try {
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/internal/InternalDistributionArchiveSetupPlugin.java b/buildSrc/src/main/java/org/opensearch/gradle/internal/InternalDistributionArchiveSetupPlugin.java
index 7ab91448252f2..a7f720855951a 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/internal/InternalDistributionArchiveSetupPlugin.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/internal/InternalDistributionArchiveSetupPlugin.java
@@ -148,8 +148,8 @@ private void configureGeneralTaskDefaults(Project project) {
         project.getTasks().withType(AbstractCopyTask.class).configureEach(t -> {
             t.dependsOn(project.getTasks().withType(EmptyDirTask.class));
             t.setIncludeEmptyDirs(true);
-            t.setDirMode(0755);
-            t.setFileMode(0644);
+            t.dirPermissions(perms -> perms.unix(0755));
+            t.filePermissions(perms -> perms.unix(0644));
         });
 
         // common config across all archives
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/internal/InternalDistributionBwcSetupPlugin.java b/buildSrc/src/main/java/org/opensearch/gradle/internal/InternalDistributionBwcSetupPlugin.java
index 6892af1b17f97..0502280cb69ad 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/internal/InternalDistributionBwcSetupPlugin.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/internal/InternalDistributionBwcSetupPlugin.java
@@ -158,7 +158,17 @@ private static List<DistributionProject> resolveArchiveProjects(File checkoutDir
         projects.addAll(asList("deb", "rpm"));
 
         if (bwcVersion.onOrAfter("7.0.0")) { // starting with 7.0 we bundle a jdk which means we have platform-specific archives
-            projects.addAll(asList("darwin-tar", "linux-tar", "windows-zip"));
+            projects.addAll(
+                asList(
+                    "darwin-tar",
+                    "darwin-arm64-tar",
+                    "linux-tar",
+                    "linux-arm64-tar",
+                    "linux-ppc64le-tar",
+                    "linux-s390x-tar",
+                    "windows-zip"
+                )
+            );
         } else { // prior to 7.0 we published only a single zip and tar archives
             projects.addAll(asList("zip", "tar"));
         }
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/precommit/DependencyLicensesPrecommitPlugin.java b/buildSrc/src/main/java/org/opensearch/gradle/precommit/DependencyLicensesPrecommitPlugin.java
index d4dcde9d63087..28a344de31ddb 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/precommit/DependencyLicensesPrecommitPlugin.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/precommit/DependencyLicensesPrecommitPlugin.java
@@ -33,11 +33,14 @@
 package org.opensearch.gradle.precommit;
 
 import org.opensearch.gradle.dependencies.CompileOnlyResolvePlugin;
+import org.opensearch.gradle.util.GradleUtils;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.ProjectDependency;
+import org.gradle.api.file.FileCollection;
 import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.TaskProvider;
 
 public class DependencyLicensesPrecommitPlugin extends PrecommitPlugin {
@@ -48,15 +51,16 @@ public TaskProvider<? extends Task> createTask(Project project) {
         TaskProvider<DependencyLicensesTask> dependencyLicenses = project.getTasks()
             .register("dependencyLicenses", DependencyLicensesTask.class);
 
+        final Configuration runtimeClasspath = project.getConfigurations().getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME);
+        final Configuration compileOnly = project.getConfigurations()
+            .getByName(CompileOnlyResolvePlugin.RESOLVEABLE_COMPILE_ONLY_CONFIGURATION_NAME);
+        final Provider<FileCollection> provider = project.provider(
+            () -> GradleUtils.getFiles(project, runtimeClasspath, dependency -> dependency instanceof ProjectDependency == false)
+                .minus(compileOnly)
+        );
+
         // only require dependency licenses for non-opensearch deps
-        dependencyLicenses.configure(t -> {
-            Configuration runtimeClasspath = project.getConfigurations().getByName(JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME);
-            Configuration compileOnly = project.getConfigurations()
-                .getByName(CompileOnlyResolvePlugin.RESOLVEABLE_COMPILE_ONLY_CONFIGURATION_NAME);
-            t.setDependencies(
-                runtimeClasspath.fileCollection(dependency -> dependency instanceof ProjectDependency == false).minus(compileOnly)
-            );
-        });
+        dependencyLicenses.configure(t -> t.getDependencies().set(provider));
 
         // we also create the updateShas helper task that is associated with dependencyLicenses
         project.getTasks().register("updateShas", UpdateShasTask.class, t -> t.setParentTask(dependencyLicenses));
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/precommit/DependencyLicensesTask.java b/buildSrc/src/main/java/org/opensearch/gradle/precommit/DependencyLicensesTask.java
index e801681c5c386..7248e0bc14431 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/precommit/DependencyLicensesTask.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/precommit/DependencyLicensesTask.java
@@ -39,6 +39,7 @@
 import org.gradle.api.file.FileCollection;
 import org.gradle.api.logging.Logger;
 import org.gradle.api.logging.Logging;
+import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.Input;
 import org.gradle.api.tasks.InputDirectory;
 import org.gradle.api.tasks.InputFiles;
@@ -121,7 +122,7 @@ public class DependencyLicensesTask extends DefaultTask {
     /**
      * A collection of jar files that should be checked.
      */
-    private FileCollection dependencies;
+    private Property<FileCollection> dependenciesProvider;
 
     /**
      * The directory to find the license and sha files in.
@@ -158,12 +159,11 @@ public void mapping(Map<String, String> props) {
     }
 
     @InputFiles
-    public FileCollection getDependencies() {
-        return dependencies;
-    }
-
-    public void setDependencies(FileCollection dependencies) {
-        this.dependencies = dependencies;
+    public Property<FileCollection> getDependencies() {
+        if (dependenciesProvider == null) {
+            dependenciesProvider = getProject().getObjects().property(FileCollection.class);
+        }
+        return dependenciesProvider;
     }
 
     @Optional
@@ -190,6 +190,11 @@ public void ignoreSha(String dep) {
 
     @TaskAction
     public void checkDependencies() throws IOException, NoSuchAlgorithmException {
+        if (dependenciesProvider == null) {
+            throw new GradleException("No dependencies variable defined.");
+        }
+
+        final FileCollection dependencies = dependenciesProvider.get();
         if (dependencies == null) {
             throw new GradleException("No dependencies variable defined.");
         }
@@ -226,7 +231,7 @@ public void checkDependencies() throws IOException, NoSuchAlgorithmException {
             }
         }
 
-        checkDependencies(licenses, notices, sources, shaFiles);
+        checkDependencies(dependencies, licenses, notices, sources, shaFiles);
 
         licenses.forEach((item, exists) -> failIfAnyMissing(item, exists, "license"));
 
@@ -255,6 +260,7 @@ private void failIfAnyMissing(String item, Boolean exists, String type) {
     }
 
     private void checkDependencies(
+        FileCollection dependencies,
         Map<String, Boolean> licenses,
         Map<String, Boolean> notices,
         Map<String, Boolean> sources,
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/precommit/ThirdPartyAuditTask.java b/buildSrc/src/main/java/org/opensearch/gradle/precommit/ThirdPartyAuditTask.java
index 9e740b4e061cf..984308ff68a8c 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/precommit/ThirdPartyAuditTask.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/precommit/ThirdPartyAuditTask.java
@@ -37,6 +37,7 @@
 import org.opensearch.gradle.LoggedExec;
 import org.opensearch.gradle.OS;
 import org.opensearch.gradle.dependencies.CompileOnlyResolvePlugin;
+import org.opensearch.gradle.util.GradleUtils;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.JavaVersion;
 import org.gradle.api.artifacts.Configuration;
@@ -203,11 +204,13 @@ public Set<File> getJarsToScan() {
         // or dependencies added as `files(...)`, we can't be sure if those are third party or not.
         // err on the side of scanning these to make sure we don't miss anything
         Spec<Dependency> reallyThirdParty = dep -> dep.getGroup() != null && dep.getGroup().startsWith("org.opensearch") == false;
-        Set<File> jars = getRuntimeConfiguration().getResolvedConfiguration().getFiles(reallyThirdParty);
-        Set<File> compileOnlyConfiguration = getProject().getConfigurations()
-            .getByName(CompileOnlyResolvePlugin.RESOLVEABLE_COMPILE_ONLY_CONFIGURATION_NAME)
-            .getResolvedConfiguration()
-            .getFiles(reallyThirdParty);
+
+        Set<File> jars = GradleUtils.getFiles(getProject(), getRuntimeConfiguration(), reallyThirdParty).getFiles();
+        Set<File> compileOnlyConfiguration = GradleUtils.getFiles(
+            getProject(),
+            getProject().getConfigurations().getByName(CompileOnlyResolvePlugin.RESOLVEABLE_COMPILE_ONLY_CONFIGURATION_NAME),
+            reallyThirdParty
+        ).getFiles();
         // don't scan provided dependencies that we already scanned, e.x. don't scan cores dependencies for every plugin
         if (compileOnlyConfiguration != null) {
             jars.removeAll(compileOnlyConfiguration);
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/precommit/UpdateShasTask.java b/buildSrc/src/main/java/org/opensearch/gradle/precommit/UpdateShasTask.java
index 3fe08888afb09..de479f3b560b6 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/precommit/UpdateShasTask.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/precommit/UpdateShasTask.java
@@ -66,7 +66,7 @@ public UpdateShasTask() {
     public void updateShas() throws NoSuchAlgorithmException, IOException {
         Set<File> shaFiles = parentTask.get().getShaFiles();
 
-        for (File dependency : parentTask.get().getDependencies()) {
+        for (File dependency : parentTask.get().getDependencies().get()) {
             String jarName = dependency.getName();
             File shaFile = parentTask.get().getShaFile(jarName);
 
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/tar/SymbolicLinkPreservingTar.java b/buildSrc/src/main/java/org/opensearch/gradle/tar/SymbolicLinkPreservingTar.java
index e82d8ed73ced2..3352dda98ef66 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/tar/SymbolicLinkPreservingTar.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/tar/SymbolicLinkPreservingTar.java
@@ -184,7 +184,7 @@ private void visitSymbolicLink(final FileCopyDetailsInternal details) {
                 visitedSymbolicLinks.add(details.getFile());
                 final TarArchiveEntry entry = new TarArchiveEntry(details.getRelativePath().getPathString(), TarConstants.LF_SYMLINK);
                 entry.setModTime(getModTime(details));
-                entry.setMode(UnixStat.LINK_FLAG | details.getMode());
+                entry.setMode(UnixStat.LINK_FLAG | details.getPermissions().toUnixNumeric());
                 try {
                     entry.setLinkName(Files.readSymbolicLink(details.getFile().toPath()).toString());
                     tar.putArchiveEntry(entry);
@@ -197,7 +197,7 @@ private void visitSymbolicLink(final FileCopyDetailsInternal details) {
             private void visitDirectory(final FileCopyDetailsInternal details) {
                 final TarArchiveEntry entry = new TarArchiveEntry(details.getRelativePath().getPathString() + "/");
                 entry.setModTime(getModTime(details));
-                entry.setMode(UnixStat.DIR_FLAG | details.getMode());
+                entry.setMode(UnixStat.DIR_FLAG | details.getPermissions().toUnixNumeric());
                 try {
                     tar.putArchiveEntry(entry);
                     tar.closeArchiveEntry();
@@ -209,7 +209,7 @@ private void visitDirectory(final FileCopyDetailsInternal details) {
             private void visitFile(final FileCopyDetailsInternal details) {
                 final TarArchiveEntry entry = new TarArchiveEntry(details.getRelativePath().getPathString());
                 entry.setModTime(getModTime(details));
-                entry.setMode(UnixStat.FILE_FLAG | details.getMode());
+                entry.setMode(UnixStat.FILE_FLAG | details.getPermissions().toUnixNumeric());
                 entry.setSize(details.getSize());
                 try {
                     tar.putArchiveEntry(entry);
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/test/DistroTestPlugin.java b/buildSrc/src/main/java/org/opensearch/gradle/test/DistroTestPlugin.java
index b2b3e3003e572..8d5ce9143cbac 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/test/DistroTestPlugin.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/test/DistroTestPlugin.java
@@ -77,9 +77,9 @@
 import java.util.stream.Stream;
 
 public class DistroTestPlugin implements Plugin<Project> {
-    private static final String SYSTEM_JDK_VERSION = "21.0.3+9";
+    private static final String SYSTEM_JDK_VERSION = "21.0.4+7";
     private static final String SYSTEM_JDK_VENDOR = "adoptium";
-    private static final String GRADLE_JDK_VERSION = "21.0.3+9";
+    private static final String GRADLE_JDK_VERSION = "21.0.4+7";
     private static final String GRADLE_JDK_VENDOR = "adoptium";
 
     // all distributions used by distro tests. this is temporary until tests are per distribution
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/test/rest/RestResourcesPlugin.java b/buildSrc/src/main/java/org/opensearch/gradle/test/rest/RestResourcesPlugin.java
index fcadf35593ce6..9396797536052 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/test/rest/RestResourcesPlugin.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/test/rest/RestResourcesPlugin.java
@@ -81,50 +81,52 @@ public void apply(Project project) {
         // tests
         Configuration testConfig = project.getConfigurations().create("restTestConfig");
         project.getConfigurations().create("restTests");
+
+        if (BuildParams.isInternal()) {
+            // core
+            Dependency restTestdependency = project.getDependencies().project(new HashMap<String, String>() {
+                {
+                    put("path", ":rest-api-spec");
+                    put("configuration", "restTests");
+                }
+            });
+            testConfig.withDependencies(s -> s.add(restTestdependency));
+        } else {
+            Dependency dependency = project.getDependencies().create("org.opensearch:rest-api-spec:" + VersionProperties.getOpenSearch());
+            testConfig.withDependencies(s -> s.add(dependency));
+        }
+
         Provider<CopyRestTestsTask> copyRestYamlTestTask = project.getTasks()
             .register("copyYamlTestsTask", CopyRestTestsTask.class, task -> {
                 task.includeCore.set(extension.restTests.getIncludeCore());
                 task.coreConfig = testConfig;
                 task.sourceSetName = SourceSet.TEST_SOURCE_SET_NAME;
-                if (BuildParams.isInternal()) {
-                    // core
-                    Dependency restTestdependency = project.getDependencies().project(new HashMap<String, String>() {
-                        {
-                            put("path", ":rest-api-spec");
-                            put("configuration", "restTests");
-                        }
-                    });
-                    project.getDependencies().add(task.coreConfig.getName(), restTestdependency);
-                } else {
-                    Dependency dependency = project.getDependencies()
-                        .create("org.opensearch:rest-api-spec:" + VersionProperties.getOpenSearch());
-                    project.getDependencies().add(task.coreConfig.getName(), dependency);
-                }
                 task.dependsOn(task.coreConfig);
             });
 
         // api
         Configuration specConfig = project.getConfigurations().create("restSpec"); // name chosen for passivity
         project.getConfigurations().create("restSpecs");
+
+        if (BuildParams.isInternal()) {
+            Dependency restSpecDependency = project.getDependencies().project(new HashMap<String, String>() {
+                {
+                    put("path", ":rest-api-spec");
+                    put("configuration", "restSpecs");
+                }
+            });
+            specConfig.withDependencies(s -> s.add(restSpecDependency));
+        } else {
+            Dependency dependency = project.getDependencies().create("org.opensearch:rest-api-spec:" + VersionProperties.getOpenSearch());
+            specConfig.withDependencies(s -> s.add(dependency));
+        }
+
         Provider<CopyRestApiTask> copyRestYamlSpecTask = project.getTasks()
             .register("copyRestApiSpecsTask", CopyRestApiTask.class, task -> {
                 task.includeCore.set(extension.restApi.getIncludeCore());
                 task.dependsOn(copyRestYamlTestTask);
                 task.coreConfig = specConfig;
                 task.sourceSetName = SourceSet.TEST_SOURCE_SET_NAME;
-                if (BuildParams.isInternal()) {
-                    Dependency restSpecDependency = project.getDependencies().project(new HashMap<String, String>() {
-                        {
-                            put("path", ":rest-api-spec");
-                            put("configuration", "restSpecs");
-                        }
-                    });
-                    project.getDependencies().add(task.coreConfig.getName(), restSpecDependency);
-                } else {
-                    Dependency dependency = project.getDependencies()
-                        .create("org.opensearch:rest-api-spec:" + VersionProperties.getOpenSearch());
-                    project.getDependencies().add(task.coreConfig.getName(), dependency);
-                }
                 task.dependsOn(task.coreConfig);
             });
 
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/testfixtures/TestFixturesPlugin.java b/buildSrc/src/main/java/org/opensearch/gradle/testfixtures/TestFixturesPlugin.java
index c9e18426966f9..e8772522b19a4 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/testfixtures/TestFixturesPlugin.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/testfixtures/TestFixturesPlugin.java
@@ -34,6 +34,7 @@
 import com.avast.gradle.dockercompose.ComposeExtension;
 import com.avast.gradle.dockercompose.DockerComposePlugin;
 import com.avast.gradle.dockercompose.ServiceInfo;
+import com.avast.gradle.dockercompose.tasks.ComposeBuild;
 import com.avast.gradle.dockercompose.tasks.ComposeDown;
 import com.avast.gradle.dockercompose.tasks.ComposePull;
 import com.avast.gradle.dockercompose.tasks.ComposeUp;
@@ -200,6 +201,7 @@ public void execute(Task task) {
         maybeSkipTasks(tasks, dockerSupport, getTaskClass("org.opensearch.gradle.test.RestIntegTestTask"));
         maybeSkipTasks(tasks, dockerSupport, TestingConventionsTasks.class);
         maybeSkipTasks(tasks, dockerSupport, getTaskClass("org.opensearch.gradle.test.AntFixture"));
+        maybeSkipTasks(tasks, dockerSupport, ComposeBuild.class);
         maybeSkipTasks(tasks, dockerSupport, ComposeUp.class);
         maybeSkipTasks(tasks, dockerSupport, ComposePull.class);
         maybeSkipTasks(tasks, dockerSupport, ComposeDown.class);
diff --git a/buildSrc/src/main/java/org/opensearch/gradle/util/GradleUtils.java b/buildSrc/src/main/java/org/opensearch/gradle/util/GradleUtils.java
index 031fee2d1127f..428b4a16748e1 100644
--- a/buildSrc/src/main/java/org/opensearch/gradle/util/GradleUtils.java
+++ b/buildSrc/src/main/java/org/opensearch/gradle/util/GradleUtils.java
@@ -39,12 +39,17 @@
 import org.gradle.api.UnknownTaskException;
 import org.gradle.api.artifacts.Configuration;
 import org.gradle.api.artifacts.Dependency;
+import org.gradle.api.artifacts.LenientConfiguration;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.internal.artifacts.ivyservice.ResolvedFilesCollectingVisitor;
+import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.SelectedArtifactSet;
 import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.provider.Provider;
 import org.gradle.api.services.BuildService;
 import org.gradle.api.services.BuildServiceRegistration;
 import org.gradle.api.services.BuildServiceRegistry;
+import org.gradle.api.specs.Spec;
 import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.SourceSetContainer;
 import org.gradle.api.tasks.TaskContainer;
@@ -53,6 +58,9 @@
 import org.gradle.plugins.ide.eclipse.model.EclipseModel;
 import org.gradle.plugins.ide.idea.model.IdeaModel;
 
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -245,4 +253,22 @@ public static String getProjectPathFromTask(String taskPath) {
         int lastDelimiterIndex = taskPath.lastIndexOf(":");
         return lastDelimiterIndex == 0 ? ":" : taskPath.substring(0, lastDelimiterIndex);
     }
+
+    public static FileCollection getFiles(Project project, Configuration cfg, Spec<Dependency> spec) {
+        final LenientConfiguration configuration = cfg.getResolvedConfiguration().getLenientConfiguration();
+        try {
+            // Using reflection here to cover the pre 8.7 releases (since those have no such APIs), the
+            // ResolverResults.LegacyResolverResults.LegacyVisitedArtifactSet::select(...) is not available
+            // on older versions.
+            final MethodHandle mh = MethodHandles.lookup()
+                .findVirtual(configuration.getClass(), "select", MethodType.methodType(SelectedArtifactSet.class, Spec.class))
+                .bindTo(configuration);
+
+            final ResolvedFilesCollectingVisitor visitor = new ResolvedFilesCollectingVisitor();
+            ((SelectedArtifactSet) mh.invoke(spec)).visitArtifacts(visitor, false);
+            return project.files(visitor.getFiles());
+        } catch (Throwable ex) {
+            return project.files(configuration.getFiles(spec));
+        }
+    }
 }
diff --git a/buildSrc/src/main/resources/forbidden/opensearch-all-signatures.txt b/buildSrc/src/main/resources/forbidden/opensearch-all-signatures.txt
index f9f24fd1e2367..199e206450178 100644
--- a/buildSrc/src/main/resources/forbidden/opensearch-all-signatures.txt
+++ b/buildSrc/src/main/resources/forbidden/opensearch-all-signatures.txt
@@ -17,6 +17,9 @@
 java.nio.file.Paths @ Use org.opensearch.common.io.PathUtils.get() instead.
 java.nio.file.FileSystems#getDefault() @ use org.opensearch.common.io.PathUtils.getDefaultFileSystem() instead.
 
+joptsimple.internal.Strings @ use org.opensearch.core.common.Strings instead.
+org.apache.logging.log4j.util.Strings @ use org.opensearch.core.common.Strings instead.
+
 java.nio.file.Files#getFileStore(java.nio.file.Path) @ Use org.opensearch.env.Environment.getFileStore() instead, impacted by JDK-8034057
 java.nio.file.Files#isWritable(java.nio.file.Path) @ Use org.opensearch.env.Environment.isWritable() instead, impacted by JDK-8034057
 
diff --git a/buildSrc/src/main/resources/minimumCompilerVersion b/buildSrc/src/main/resources/minimumCompilerVersion
index 8351c19397f4f..98d9bcb75a685 100644
--- a/buildSrc/src/main/resources/minimumCompilerVersion
+++ b/buildSrc/src/main/resources/minimumCompilerVersion
@@ -1 +1 @@
-14
+17
diff --git a/buildSrc/src/test/java/org/opensearch/gradle/precommit/DependencyLicensesTaskTests.java b/buildSrc/src/test/java/org/opensearch/gradle/precommit/DependencyLicensesTaskTests.java
index bb216b27128e1..28513710470af 100644
--- a/buildSrc/src/test/java/org/opensearch/gradle/precommit/DependencyLicensesTaskTests.java
+++ b/buildSrc/src/test/java/org/opensearch/gradle/precommit/DependencyLicensesTaskTests.java
@@ -344,7 +344,7 @@ private TaskProvider<DependencyLicensesTask> createDependencyLicensesTask(Projec
             .register("dependencyLicenses", DependencyLicensesTask.class, new Action<DependencyLicensesTask>() {
                 @Override
                 public void execute(DependencyLicensesTask dependencyLicensesTask) {
-                    dependencyLicensesTask.setDependencies(getDependencies(project));
+                    dependencyLicensesTask.getDependencies().set(getDependencies(project));
 
                     final Map<String, String> mappings = new HashMap<>();
                     mappings.put("from", "groovy-.*");
diff --git a/buildSrc/src/test/java/org/opensearch/gradle/precommit/UpdateShasTaskTests.java b/buildSrc/src/test/java/org/opensearch/gradle/precommit/UpdateShasTaskTests.java
index 2deabb752017a..15d6d6cd4c31c 100644
--- a/buildSrc/src/test/java/org/opensearch/gradle/precommit/UpdateShasTaskTests.java
+++ b/buildSrc/src/test/java/org/opensearch/gradle/precommit/UpdateShasTaskTests.java
@@ -102,7 +102,7 @@ public void whenDependencyExistsButShaNotThenShouldCreateNewShaFile() throws IOE
     public void whenDependencyAndWrongShaExistsThenShouldNotOverwriteShaFile() throws IOException, NoSuchAlgorithmException {
         project.getDependencies().add("someCompileConfiguration", dependency);
 
-        File groovyJar = task.getParentTask().getDependencies().getFiles().iterator().next();
+        File groovyJar = task.getParentTask().getDependencies().get().getFiles().iterator().next();
         String groovyShaName = groovyJar.getName() + ".sha1";
 
         File groovySha = createFileIn(getLicensesDir(project), groovyShaName, "content");
@@ -162,7 +162,7 @@ private TaskProvider<DependencyLicensesTask> createDependencyLicensesTask(Projec
             .register("dependencyLicenses", DependencyLicensesTask.class, new Action<DependencyLicensesTask>() {
                 @Override
                 public void execute(DependencyLicensesTask dependencyLicensesTask) {
-                    dependencyLicensesTask.setDependencies(getDependencies(project));
+                    dependencyLicensesTask.getDependencies().set(getDependencies(project));
                 }
             });
 
diff --git a/buildSrc/version.properties b/buildSrc/version.properties
index 96d4f2a39f66b..fce5e4a194837 100644
--- a/buildSrc/version.properties
+++ b/buildSrc/version.properties
@@ -1,16 +1,16 @@
-opensearch        = 2.15.0
-lucene            = 9.10.0
+opensearch        = 2.18.0
+lucene            = 9.11.1
 
 bundled_jdk_vendor = adoptium
-bundled_jdk = 21.0.3+9
+bundled_jdk = 21.0.4+7
 
 # optional dependencies
 spatial4j         = 0.7
 jts               = 1.15.0
-jackson           = 2.17.1
-jackson_databind  = 2.17.1
+jackson           = 2.17.2
+jackson_databind  = 2.17.2
 snakeyaml         = 2.1
-icu4j             = 70.1
+icu4j             = 75.1
 supercsv          = 2.4.0
 log4j             = 2.21.0
 slf4j             = 1.7.36
@@ -23,16 +23,18 @@ guava             = 32.1.1-jre
 protobuf          = 3.22.3
 jakarta_annotation = 1.3.5
 google_http_client = 1.44.1
+tdigest           = 3.2
+hdrhistogram      = 2.2.2
 
 # when updating the JNA version, also update the version in buildSrc/build.gradle
 jna               = 5.13.0
 
-netty             = 4.1.110.Final
+netty             = 4.1.112.Final
 joda              = 2.12.7
 
 # project reactor
-reactor_netty     = 1.1.19
-reactor           = 3.5.17
+reactor_netty     = 1.1.22
+reactor           = 3.5.20
 
 # client dependencies
 httpclient        = 4.5.14
@@ -70,5 +72,5 @@ jzlib             = 1.1.3
 resteasy          = 6.2.4.Final
 
 # opentelemetry dependencies
-opentelemetry         = 1.36.0
-opentelemetrysemconv  = 1.23.1-alpha
+opentelemetry         = 1.41.0
+opentelemetrysemconv  = 1.27.0-alpha
diff --git a/client/rest-high-level/src/main/java/org/opensearch/client/RequestConverters.java b/client/rest-high-level/src/main/java/org/opensearch/client/RequestConverters.java
index 80f878d25c859..20f0563a2d032 100644
--- a/client/rest-high-level/src/main/java/org/opensearch/client/RequestConverters.java
+++ b/client/rest-high-level/src/main/java/org/opensearch/client/RequestConverters.java
@@ -154,6 +154,9 @@ static Request bulk(BulkRequest bulkRequest) throws IOException {
         parameters.withRefreshPolicy(bulkRequest.getRefreshPolicy());
         parameters.withPipeline(bulkRequest.pipeline());
         parameters.withRouting(bulkRequest.routing());
+        if (bulkRequest.requireAlias() != null) {
+            parameters.withRequireAlias(bulkRequest.requireAlias());
+        }
         // Bulk API only supports newline delimited JSON or Smile. Before executing
         // the bulk, we need to check that all requests have the same content-type
         // and this content-type is supported by the Bulk API.
@@ -232,6 +235,10 @@ static Request bulk(BulkRequest bulkRequest) throws IOException {
                             metadata.field("_source", updateRequest.fetchSource());
                         }
                     }
+
+                    if (action.isRequireAlias()) {
+                        metadata.field("require_alias", action.isRequireAlias());
+                    }
                     metadata.endObject();
                 }
                 metadata.endObject();
@@ -533,7 +540,7 @@ static Request searchTemplate(SearchTemplateRequest searchTemplateRequest) throw
         Request request;
 
         if (searchTemplateRequest.isSimulate()) {
-            request = new Request(HttpGet.METHOD_NAME, "_render/template");
+            request = new Request(HttpGet.METHOD_NAME, "/_render/template");
         } else {
             SearchRequest searchRequest = searchTemplateRequest.getRequest();
             String endpoint = endpoint(searchRequest.indices(), "_search/template");
@@ -796,8 +803,7 @@ static Request termVectors(TermVectorsRequest tvrequest) throws IOException {
     }
 
     static Request mtermVectors(MultiTermVectorsRequest mtvrequest) throws IOException {
-        String endpoint = "_mtermvectors";
-        Request request = new Request(HttpGet.METHOD_NAME, endpoint);
+        Request request = new Request(HttpGet.METHOD_NAME, "/_mtermvectors");
         request.setEntity(createEntity(mtvrequest, REQUEST_BODY_CONTENT_TYPE));
         return request;
     }
diff --git a/client/rest-high-level/src/main/java/org/opensearch/client/RestHighLevelClient.java b/client/rest-high-level/src/main/java/org/opensearch/client/RestHighLevelClient.java
index 94303097c772d..d587f76e61b49 100644
--- a/client/rest-high-level/src/main/java/org/opensearch/client/RestHighLevelClient.java
+++ b/client/rest-high-level/src/main/java/org/opensearch/client/RestHighLevelClient.java
@@ -2227,11 +2227,11 @@ protected final <Resp> Resp parseEntity(final HttpEntity entity, final CheckedFu
         if (entity.getContentType() == null) {
             throw new IllegalStateException("OpenSearch didn't return the [Content-Type] header, unable to parse response body");
         }
-        MediaType medaiType = MediaType.fromMediaType(entity.getContentType().getValue());
-        if (medaiType == null) {
+        MediaType mediaType = MediaType.fromMediaType(entity.getContentType().getValue());
+        if (mediaType == null) {
             throw new IllegalStateException("Unsupported Content-Type: " + entity.getContentType().getValue());
         }
-        try (XContentParser parser = medaiType.xContent().createParser(registry, DEPRECATION_HANDLER, entity.getContent())) {
+        try (XContentParser parser = mediaType.xContent().createParser(registry, DEPRECATION_HANDLER, entity.getContent())) {
             return entityParser.apply(parser);
         }
     }
diff --git a/client/rest-high-level/src/main/java/org/opensearch/client/indices/GetIndexResponse.java b/client/rest-high-level/src/main/java/org/opensearch/client/indices/GetIndexResponse.java
index 6ec1c312c9ba9..1ceaeab6c0064 100644
--- a/client/rest-high-level/src/main/java/org/opensearch/client/indices/GetIndexResponse.java
+++ b/client/rest-high-level/src/main/java/org/opensearch/client/indices/GetIndexResponse.java
@@ -34,6 +34,7 @@
 
 import org.apache.lucene.util.CollectionUtil;
 import org.opensearch.cluster.metadata.AliasMetadata;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.MappingMetadata;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.xcontent.XContentParser;
@@ -61,6 +62,7 @@ public class GetIndexResponse {
     private Map<String, Settings> settings;
     private Map<String, Settings> defaultSettings;
     private Map<String, String> dataStreams;
+    private Map<String, Context> contexts;
     private String[] indices;
 
     GetIndexResponse(
@@ -69,7 +71,8 @@ public class GetIndexResponse {
         Map<String, List<AliasMetadata>> aliases,
         Map<String, Settings> settings,
         Map<String, Settings> defaultSettings,
-        Map<String, String> dataStreams
+        Map<String, String> dataStreams,
+        Map<String, Context> contexts
     ) {
         this.indices = indices;
         // to have deterministic order
@@ -89,6 +92,9 @@ public class GetIndexResponse {
         if (dataStreams != null) {
             this.dataStreams = dataStreams;
         }
+        if (contexts != null) {
+            this.contexts = contexts;
+        }
     }
 
     public String[] getIndices() {
@@ -123,6 +129,10 @@ public Map<String, String> getDataStreams() {
         return dataStreams;
     }
 
+    public Map<String, Context> contexts() {
+        return contexts;
+    }
+
     /**
      * Returns the string value for the specified index and setting. If the includeDefaults flag was not set or set to
      * false on the {@link GetIndexRequest}, this method will only return a value where the setting was explicitly set
@@ -167,6 +177,7 @@ private static IndexEntry parseIndexEntry(XContentParser parser) throws IOExcept
         Settings indexSettings = null;
         Settings indexDefaultSettings = null;
         String dataStream = null;
+        Context context = null;
         // We start at START_OBJECT since fromXContent ensures that
         while (parser.nextToken() != Token.END_OBJECT) {
             ensureExpectedToken(Token.FIELD_NAME, parser.currentToken(), parser);
@@ -185,6 +196,9 @@ private static IndexEntry parseIndexEntry(XContentParser parser) throws IOExcept
                     case "defaults":
                         indexDefaultSettings = Settings.fromXContent(parser);
                         break;
+                    case "context":
+                        context = Context.fromXContent(parser);
+                        break;
                     default:
                         parser.skipChildren();
                 }
@@ -197,7 +211,7 @@ private static IndexEntry parseIndexEntry(XContentParser parser) throws IOExcept
                 parser.skipChildren();
             }
         }
-        return new IndexEntry(indexAliases, indexMappings, indexSettings, indexDefaultSettings, dataStream);
+        return new IndexEntry(indexAliases, indexMappings, indexSettings, indexDefaultSettings, dataStream, context);
     }
 
     // This is just an internal container to make stuff easier for returning
@@ -207,19 +221,22 @@ private static class IndexEntry {
         Settings indexSettings = Settings.EMPTY;
         Settings indexDefaultSettings = Settings.EMPTY;
         String dataStream;
+        Context context;
 
         IndexEntry(
             List<AliasMetadata> indexAliases,
             MappingMetadata indexMappings,
             Settings indexSettings,
             Settings indexDefaultSettings,
-            String dataStream
+            String dataStream,
+            Context context
         ) {
             if (indexAliases != null) this.indexAliases = indexAliases;
             if (indexMappings != null) this.indexMappings = indexMappings;
             if (indexSettings != null) this.indexSettings = indexSettings;
             if (indexDefaultSettings != null) this.indexDefaultSettings = indexDefaultSettings;
             if (dataStream != null) this.dataStream = dataStream;
+            if (context != null) this.context = context;
         }
     }
 
@@ -229,6 +246,7 @@ public static GetIndexResponse fromXContent(XContentParser parser) throws IOExce
         Map<String, Settings> settings = new HashMap<>();
         Map<String, Settings> defaultSettings = new HashMap<>();
         Map<String, String> dataStreams = new HashMap<>();
+        Map<String, Context> contexts = new HashMap<>();
         List<String> indices = new ArrayList<>();
 
         if (parser.currentToken() == null) {
@@ -254,12 +272,15 @@ public static GetIndexResponse fromXContent(XContentParser parser) throws IOExce
                 if (indexEntry.dataStream != null) {
                     dataStreams.put(indexName, indexEntry.dataStream);
                 }
+                if (indexEntry.context != null) {
+                    contexts.put(indexName, indexEntry.context);
+                }
             } else if (parser.currentToken() == Token.START_ARRAY) {
                 parser.skipChildren();
             } else {
                 parser.nextToken();
             }
         }
-        return new GetIndexResponse(indices.toArray(new String[0]), mappings, aliases, settings, defaultSettings, dataStreams);
+        return new GetIndexResponse(indices.toArray(new String[0]), mappings, aliases, settings, defaultSettings, dataStreams, contexts);
     }
 }
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/CrudIT.java b/client/rest-high-level/src/test/java/org/opensearch/client/CrudIT.java
index da9f790215669..f5b1b0768ff4a 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/CrudIT.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/CrudIT.java
@@ -1299,4 +1299,61 @@ public void testMultiTermvectors() throws IOException {
             }
         }
     }
+
+    public void testBulkWithRequireAlias() throws IOException {
+        {
+            String indexAliasName = "testindex-1";
+
+            BulkRequest bulkRequest = new BulkRequest(indexAliasName);
+            bulkRequest.requireAlias(true);
+            bulkRequest.add(new IndexRequest().id("1").source("{ \"name\": \"Biden\" }", XContentType.JSON));
+            bulkRequest.add(new IndexRequest().id("2").source("{ \"name\": \"Trump\" }", XContentType.JSON));
+
+            BulkResponse bulkResponse = execute(bulkRequest, highLevelClient()::bulk, highLevelClient()::bulkAsync, RequestOptions.DEFAULT);
+
+            assertFalse("Should not auto-create the '" + indexAliasName + "' index.", indexExists(indexAliasName));
+            assertTrue("Bulk response must have failures.", bulkResponse.hasFailures());
+        }
+        {
+            String indexAliasName = "testindex-2";
+
+            BulkRequest bulkRequest = new BulkRequest();
+            bulkRequest.requireAlias(true);
+            bulkRequest.add(new IndexRequest().index(indexAliasName).id("1").source("{ \"name\": \"Biden\" }", XContentType.JSON));
+            bulkRequest.add(new IndexRequest().index(indexAliasName).id("2").source("{ \"name\": \"Trump\" }", XContentType.JSON));
+
+            BulkResponse bulkResponse = execute(bulkRequest, highLevelClient()::bulk, highLevelClient()::bulkAsync, RequestOptions.DEFAULT);
+
+            assertFalse("Should not auto-create the '" + indexAliasName + "' index.", indexExists(indexAliasName));
+            assertTrue("Bulk response must have failures.", bulkResponse.hasFailures());
+        }
+        {
+            String indexAliasName = "testindex-3";
+
+            BulkRequest bulkRequest = new BulkRequest(indexAliasName);
+            bulkRequest.add(new IndexRequest().id("1").setRequireAlias(true).source("{ \"name\": \"Biden\" }", XContentType.JSON));
+            bulkRequest.add(new IndexRequest().id("2").setRequireAlias(true).source("{ \"name\": \"Trump\" }", XContentType.JSON));
+
+            BulkResponse bulkResponse = execute(bulkRequest, highLevelClient()::bulk, highLevelClient()::bulkAsync, RequestOptions.DEFAULT);
+
+            assertFalse("Should not auto-create the '" + indexAliasName + "' index.", indexExists(indexAliasName));
+            assertTrue("Bulk response must have failures.", bulkResponse.hasFailures());
+        }
+        {
+            String indexAliasName = "testindex-4";
+
+            BulkRequest bulkRequest = new BulkRequest();
+            bulkRequest.add(
+                new IndexRequest().index(indexAliasName).id("1").setRequireAlias(true).source("{ \"name\": \"Biden\" }", XContentType.JSON)
+            );
+            bulkRequest.add(
+                new IndexRequest().index(indexAliasName).id("2").setRequireAlias(true).source("{ \"name\": \"Trump\" }", XContentType.JSON)
+            );
+
+            BulkResponse bulkResponse = execute(bulkRequest, highLevelClient()::bulk, highLevelClient()::bulkAsync, RequestOptions.DEFAULT);
+
+            assertFalse("Should not auto-create the '" + indexAliasName + "' index.", indexExists(indexAliasName));
+            assertTrue("Bulk response must have failures.", bulkResponse.hasFailures());
+        }
+    }
 }
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/IndicesClientIT.java b/client/rest-high-level/src/test/java/org/opensearch/client/IndicesClientIT.java
index 649e921b54cbe..d2dde8d3c2684 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/IndicesClientIT.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/IndicesClientIT.java
@@ -701,7 +701,7 @@ public void testOpenExistingIndex() throws IOException {
         closeIndex(index);
         ResponseException exception = expectThrows(
             ResponseException.class,
-            () -> client().performRequest(new Request(HttpGet.METHOD_NAME, index + "/_search"))
+            () -> client().performRequest(new Request(HttpGet.METHOD_NAME, "/" + index + "/_search"))
         );
         assertThat(exception.getResponse().getStatusLine().getStatusCode(), equalTo(RestStatus.BAD_REQUEST.getStatus()));
         assertThat(exception.getMessage().contains(index), equalTo(true));
@@ -714,7 +714,7 @@ public void testOpenExistingIndex() throws IOException {
         );
         assertTrue(openIndexResponse.isAcknowledged());
 
-        Response response = client().performRequest(new Request(HttpGet.METHOD_NAME, index + "/_search"));
+        Response response = client().performRequest(new Request(HttpGet.METHOD_NAME, "/" + index + "/_search"));
         assertThat(response.getStatusLine().getStatusCode(), equalTo(RestStatus.OK.getStatus()));
     }
 
@@ -771,7 +771,7 @@ public void testCloseExistingIndex() throws IOException {
 
             ResponseException exception = expectThrows(
                 ResponseException.class,
-                () -> client().performRequest(new Request(HttpGet.METHOD_NAME, indexResult.getIndex() + "/_search"))
+                () -> client().performRequest(new Request(HttpGet.METHOD_NAME, "/" + indexResult.getIndex() + "/_search"))
             );
             assertThat(exception.getResponse().getStatusLine().getStatusCode(), equalTo(RestStatus.BAD_REQUEST.getStatus()));
             assertThat(exception.getMessage().contains(indexResult.getIndex()), equalTo(true));
@@ -1270,7 +1270,7 @@ public void testGetAliasesNonExistentIndexOrAlias() throws IOException {
             assertThat(getAliasesResponse.getException(), nullValue());
         }
         createIndex(index, Settings.EMPTY);
-        client().performRequest(new Request(HttpPut.METHOD_NAME, index + "/_alias/" + alias));
+        client().performRequest(new Request(HttpPut.METHOD_NAME, "/" + index + "/_alias/" + alias));
         {
             GetAliasesRequest getAliasesRequest = new GetAliasesRequest().indices(index, "non_existent_index");
             GetAliasesResponse getAliasesResponse = execute(
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/RankEvalIT.java b/client/rest-high-level/src/test/java/org/opensearch/client/RankEvalIT.java
index 47add92ecaccd..01fdd489aa7d8 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/RankEvalIT.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/RankEvalIT.java
@@ -121,7 +121,7 @@ public void testRankEvalRequest() throws IOException {
         }
 
         // now try this when test2 is closed
-        client().performRequest(new Request("POST", "index2/_close"));
+        client().performRequest(new Request("POST", "/index2/_close"));
         rankEvalRequest.indicesOptions(IndicesOptions.fromParameters(null, "true", null, "false", SearchRequest.DEFAULT_INDICES_OPTIONS));
         response = execute(rankEvalRequest, highLevelClient()::rankEval, highLevelClient()::rankEvalAsync);
     }
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/RequestConvertersTests.java b/client/rest-high-level/src/test/java/org/opensearch/client/RequestConvertersTests.java
index 2be3c27c6b5ce..2a1fc179d13bc 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/RequestConvertersTests.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/RequestConvertersTests.java
@@ -1399,7 +1399,7 @@ public void testRenderSearchTemplate() throws Exception {
 
         // Verify that the resulting REST request looks as expected.
         Request request = RequestConverters.searchTemplate(searchTemplateRequest);
-        String endpoint = "_render/template";
+        String endpoint = "/_render/template";
 
         assertEquals(HttpGet.METHOD_NAME, request.getMethod());
         assertEquals(endpoint, request.getEndpoint());
@@ -1565,7 +1565,7 @@ public void testMultiTermVectors() throws IOException {
 
         Request request = RequestConverters.mtermVectors(mtvRequest);
         assertEquals(HttpGet.METHOD_NAME, request.getMethod());
-        assertEquals("_mtermvectors", request.getEndpoint());
+        assertEquals("/_mtermvectors", request.getEndpoint());
         assertToXContentBody(mtvRequest, request.getEntity());
     }
 
@@ -1585,7 +1585,7 @@ public void testMultiTermVectorsWithType() throws IOException {
 
         Request request = RequestConverters.mtermVectors(mtvRequest);
         assertEquals(HttpGet.METHOD_NAME, request.getMethod());
-        assertEquals("_mtermvectors", request.getEndpoint());
+        assertEquals("/_mtermvectors", request.getEndpoint());
         assertToXContentBody(mtvRequest, request.getEntity());
     }
 
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/SearchIT.java b/client/rest-high-level/src/test/java/org/opensearch/client/SearchIT.java
index b962fa8ff415e..aeb052fdce138 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/SearchIT.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/SearchIT.java
@@ -727,7 +727,7 @@ public void testSearchWithSuggest() throws IOException {
     }
 
     public void testSearchWithWeirdScriptFields() throws Exception {
-        Request doc = new Request("PUT", "test/_doc/1");
+        Request doc = new Request("PUT", "/test/_doc/1");
         doc.setJsonEntity("{\"field\":\"value\"}");
         client().performRequest(doc);
         client().performRequest(new Request("POST", "/test/_refresh"));
@@ -774,7 +774,7 @@ public void testSearchWithWeirdScriptFields() throws Exception {
     public void testSearchWithDerivedFields() throws Exception {
         // Just testing DerivedField definition from SearchSourceBuilder derivedField()
         // We are not testing the full functionality here
-        Request doc = new Request("PUT", "test/_doc/1");
+        Request doc = new Request("PUT", "/test/_doc/1");
         doc.setJsonEntity("{\"field\":\"value\"}");
         client().performRequest(doc);
         client().performRequest(new Request("POST", "/test/_refresh"));
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/SnapshotRequestConvertersTests.java b/client/rest-high-level/src/test/java/org/opensearch/client/SnapshotRequestConvertersTests.java
index 93ffd7cade7c3..fef8f4ab3991e 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/SnapshotRequestConvertersTests.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/SnapshotRequestConvertersTests.java
@@ -230,6 +230,7 @@ public void testSnapshotsStatus() {
         Map<String, String> expectedParams = new HashMap<>();
         String repository = RequestConvertersTests.randomIndicesNames(1, 1)[0];
         String[] snapshots = RequestConvertersTests.randomIndicesNames(1, 5);
+        String[] indices = RequestConvertersTests.randomIndicesNames(1, 5);
         StringBuilder snapshotNames = new StringBuilder(snapshots[0]);
         for (int idx = 1; idx < snapshots.length; idx++) {
             snapshotNames.append(",").append(snapshots[idx]);
@@ -237,8 +238,9 @@ public void testSnapshotsStatus() {
         boolean ignoreUnavailable = randomBoolean();
         String endpoint = "/_snapshot/" + repository + "/" + snapshotNames.toString() + "/_status";
 
-        SnapshotsStatusRequest snapshotsStatusRequest = new SnapshotsStatusRequest(repository, snapshots);
+        SnapshotsStatusRequest snapshotsStatusRequest = (new SnapshotsStatusRequest(repository, snapshots)).indices(indices);
         RequestConvertersTests.setRandomMasterTimeout(snapshotsStatusRequest, expectedParams);
+
         snapshotsStatusRequest.ignoreUnavailable(ignoreUnavailable);
         expectedParams.put("ignore_unavailable", Boolean.toString(ignoreUnavailable));
 
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/documentation/SearchDocumentationIT.java b/client/rest-high-level/src/test/java/org/opensearch/client/documentation/SearchDocumentationIT.java
index bf0f70304168e..326dde54cfb61 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/documentation/SearchDocumentationIT.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/documentation/SearchDocumentationIT.java
@@ -998,7 +998,7 @@ public void onFailure(Exception e) {
 
     protected void registerQueryScript(RestClient restClient) throws IOException {
         // tag::register-script
-        Request scriptRequest = new Request("POST", "_scripts/title_search");
+        Request scriptRequest = new Request("POST", "/_scripts/title_search");
         scriptRequest.setJsonEntity(
             "{" +
             "  \"script\": {" +
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/documentation/SnapshotClientDocumentationIT.java b/client/rest-high-level/src/test/java/org/opensearch/client/documentation/SnapshotClientDocumentationIT.java
index d0015db044843..6949bc382bfe8 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/documentation/SnapshotClientDocumentationIT.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/documentation/SnapshotClientDocumentationIT.java
@@ -827,7 +827,7 @@ private void createTestIndex() throws IOException {
     }
 
     private void createTestSnapshots() throws IOException {
-        Request createSnapshot = new Request("put", String.format(Locale.ROOT, "_snapshot/%s/%s", repositoryName, snapshotName));
+        Request createSnapshot = new Request("put", String.format(Locale.ROOT, "/_snapshot/%s/%s", repositoryName, snapshotName));
         createSnapshot.addParameter("wait_for_completion", "true");
         createSnapshot.setJsonEntity("{\"indices\":\"" + indexName + "\"}");
         Response response = highLevelClient().getLowLevelClient().performRequest(createSnapshot);
diff --git a/client/rest-high-level/src/test/java/org/opensearch/client/indices/GetIndexResponseTests.java b/client/rest-high-level/src/test/java/org/opensearch/client/indices/GetIndexResponseTests.java
index a00f0487116dc..fa313e68f8a35 100644
--- a/client/rest-high-level/src/test/java/org/opensearch/client/indices/GetIndexResponseTests.java
+++ b/client/rest-high-level/src/test/java/org/opensearch/client/indices/GetIndexResponseTests.java
@@ -36,6 +36,7 @@
 import org.opensearch.client.AbstractResponseTestCase;
 import org.opensearch.client.GetAliasesResponseTests;
 import org.opensearch.cluster.metadata.AliasMetadata;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.MappingMetadata;
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Settings;
@@ -66,6 +67,7 @@ protected org.opensearch.action.admin.indices.get.GetIndexResponse createServerT
         final Map<String, Settings> settings = new HashMap<>();
         final Map<String, Settings> defaultSettings = new HashMap<>();
         final Map<String, String> dataStreams = new HashMap<>();
+        final Map<String, Context> contexts = new HashMap<>();
         IndexScopedSettings indexScopedSettings = IndexScopedSettings.DEFAULT_SCOPED_SETTINGS;
         boolean includeDefaults = randomBoolean();
         for (String index : indices) {
@@ -90,6 +92,10 @@ protected org.opensearch.action.admin.indices.get.GetIndexResponse createServerT
             if (randomBoolean()) {
                 dataStreams.put(index, randomAlphaOfLength(5).toLowerCase(Locale.ROOT));
             }
+
+            if (randomBoolean()) {
+                contexts.put(index, new Context(randomAlphaOfLength(5).toLowerCase(Locale.ROOT)));
+            }
         }
         return new org.opensearch.action.admin.indices.get.GetIndexResponse(
             indices,
@@ -97,7 +103,8 @@ protected org.opensearch.action.admin.indices.get.GetIndexResponse createServerT
             aliases,
             settings,
             defaultSettings,
-            dataStreams
+            dataStreams,
+            null
         );
     }
 
@@ -116,6 +123,7 @@ protected void assertInstances(
         assertEquals(serverTestInstance.getSettings(), clientInstance.getSettings());
         assertEquals(serverTestInstance.defaultSettings(), clientInstance.getDefaultSettings());
         assertEquals(serverTestInstance.getAliases(), clientInstance.getAliases());
+        assertEquals(serverTestInstance.contexts(), clientInstance.contexts());
     }
 
     private static MappingMetadata createMappingsForIndex() {
diff --git a/client/rest/build.gradle b/client/rest/build.gradle
index 42012ab935e72..a448e3d34dc22 100644
--- a/client/rest/build.gradle
+++ b/client/rest/build.gradle
@@ -51,6 +51,10 @@ dependencies {
   api "commons-codec:commons-codec:${versions.commonscodec}"
   api "commons-logging:commons-logging:${versions.commonslogging}"
 
+  // reactor
+  api "io.projectreactor:reactor-core:${versions.reactor}"
+  api "org.reactivestreams:reactive-streams:${versions.reactivestreams}"
+
   testImplementation project(":client:test")
   testImplementation "com.carrotsearch.randomizedtesting:randomizedtesting-runner:${versions.randomizedrunner}"
   testImplementation "junit:junit:${versions.junit}"
@@ -92,18 +96,50 @@ testingConventions {
   }
 }
 
-thirdPartyAudit.ignoreMissingClasses(
-  //commons-logging optional dependencies
-  'org.apache.avalon.framework.logger.Logger',
-  'org.apache.log.Hierarchy',
-  'org.apache.log.Logger',
-  'org.apache.log4j.Level',
-  'org.apache.log4j.Logger',
-  'org.apache.log4j.Priority',
-  //commons-logging provided dependencies
-  'javax.servlet.ServletContextEvent',
-  'javax.servlet.ServletContextListener'
-)
+thirdPartyAudit {
+  ignoreMissingClasses(
+      'org.slf4j.Logger',
+      'org.slf4j.LoggerFactory',
+      //commons-logging optional dependencies
+      'org.apache.avalon.framework.logger.Logger',
+      'org.apache.log.Hierarchy',
+      'org.apache.log.Logger',
+      'org.apache.log4j.Level',
+      'org.apache.log4j.Logger',
+      'org.apache.log4j.Priority',
+      //commons-logging provided dependencies
+      'javax.servlet.ServletContextEvent',
+      'javax.servlet.ServletContextListener',
+      'io.micrometer.context.ContextAccessor',
+      'io.micrometer.context.ContextRegistry',
+      'io.micrometer.context.ContextSnapshot',
+      'io.micrometer.context.ContextSnapshot$Scope',
+      'io.micrometer.context.ContextSnapshotFactory',
+      'io.micrometer.context.ContextSnapshotFactory$Builder',
+      'io.micrometer.context.ThreadLocalAccessor',
+      'io.micrometer.core.instrument.Clock',
+      'io.micrometer.core.instrument.Counter',
+      'io.micrometer.core.instrument.Counter$Builder',
+      'io.micrometer.core.instrument.DistributionSummary',
+      'io.micrometer.core.instrument.DistributionSummary$Builder',
+      'io.micrometer.core.instrument.Meter',
+      'io.micrometer.core.instrument.MeterRegistry',
+      'io.micrometer.core.instrument.Metrics',
+      'io.micrometer.core.instrument.Tag',
+      'io.micrometer.core.instrument.Tags',
+      'io.micrometer.core.instrument.Timer',
+      'io.micrometer.core.instrument.Timer$Builder',
+      'io.micrometer.core.instrument.Timer$Sample',
+      'io.micrometer.core.instrument.binder.jvm.ExecutorServiceMetrics',
+      'io.micrometer.core.instrument.composite.CompositeMeterRegistry',
+      'io.micrometer.core.instrument.search.Search',
+      'reactor.blockhound.BlockHound$Builder',
+      'reactor.blockhound.integration.BlockHoundIntegration'
+   )
+   ignoreViolations(
+      'reactor.core.publisher.Traces$SharedSecretsCallSiteSupplierFactory$TracingException'
+   )
+}
 
 tasks.withType(JavaCompile) {
   // Suppressing '[options] target value 8 is obsolete and will be removed in a future release'
diff --git a/client/rest/licenses/reactive-streams-1.0.4.jar.sha1 b/client/rest/licenses/reactive-streams-1.0.4.jar.sha1
new file mode 100644
index 0000000000000..45a80e3f7e361
--- /dev/null
+++ b/client/rest/licenses/reactive-streams-1.0.4.jar.sha1
@@ -0,0 +1 @@
+3864a1320d97d7b045f729a326e1e077661f31b7
\ No newline at end of file
diff --git a/client/rest/licenses/reactive-streams-LICENSE.txt b/client/rest/licenses/reactive-streams-LICENSE.txt
new file mode 100644
index 0000000000000..1e3c7e7c77495
--- /dev/null
+++ b/client/rest/licenses/reactive-streams-LICENSE.txt
@@ -0,0 +1,21 @@
+MIT No Attribution
+
+Copyright 2014 Reactive Streams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-extension-incubator-NOTICE.txt b/client/rest/licenses/reactive-streams-NOTICE.txt
similarity index 100%
rename from plugins/telemetry-otel/licenses/opentelemetry-extension-incubator-NOTICE.txt
rename to client/rest/licenses/reactive-streams-NOTICE.txt
diff --git a/client/rest/licenses/reactor-core-3.5.20.jar.sha1 b/client/rest/licenses/reactor-core-3.5.20.jar.sha1
new file mode 100644
index 0000000000000..0c80be89f66c8
--- /dev/null
+++ b/client/rest/licenses/reactor-core-3.5.20.jar.sha1
@@ -0,0 +1 @@
+1fc0f91e2b93778a974339d2c24363d7f34f90b4
\ No newline at end of file
diff --git a/client/rest/licenses/reactor-core-LICENSE.txt b/client/rest/licenses/reactor-core-LICENSE.txt
new file mode 100644
index 0000000000000..e5583c184e67a
--- /dev/null
+++ b/client/rest/licenses/reactor-core-LICENSE.txt
@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/client/rest/licenses/reactor-core-NOTICE.txt b/client/rest/licenses/reactor-core-NOTICE.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/client/rest/src/main/java/org/opensearch/client/Cancellable.java b/client/rest/src/main/java/org/opensearch/client/Cancellable.java
index 4bfc0704227aa..6b698ad351d86 100644
--- a/client/rest/src/main/java/org/opensearch/client/Cancellable.java
+++ b/client/rest/src/main/java/org/opensearch/client/Cancellable.java
@@ -34,6 +34,8 @@
 import org.apache.http.client.methods.AbstractExecutionAwareRequest;
 import org.apache.http.client.methods.HttpRequestBase;
 
+import java.io.IOException;
+import java.util.concurrent.Callable;
 import java.util.concurrent.CancellationException;
 
 /**
@@ -75,7 +77,7 @@ public synchronized void cancel() {
     }
 
     /**
-     * Executes some arbitrary code iff the on-going request has not been cancelled, otherwise throws {@link CancellationException}.
+     * Executes some arbitrary code if the on-going request has not been cancelled, otherwise throws {@link CancellationException}.
      * This is needed to guarantee that cancelling a request works correctly even in case {@link #cancel()} is called between different
      * attempts of the same request. The low-level client reuses the same instance of the {@link AbstractExecutionAwareRequest} by calling
      * {@link AbstractExecutionAwareRequest#reset()} between subsequent retries. The {@link #cancel()} method can be called at anytime,
@@ -93,6 +95,31 @@ synchronized void runIfNotCancelled(Runnable runnable) {
         runnable.run();
     }
 
+    /**
+     * Executes some arbitrary code if the on-going request has not been cancelled, otherwise throws {@link CancellationException}.
+     * This is needed to guarantee that cancelling a request works correctly even in case {@link #cancel()} is called between different
+     * attempts of the same request. The low-level client reuses the same instance of the {@link AbstractExecutionAwareRequest} by calling
+     * {@link AbstractExecutionAwareRequest#reset()} between subsequent retries. The {@link #cancel()} method can be called at anytime,
+     * and we need to handle the case where it gets called while there is no request being executed as one attempt may have failed and
+     * the subsequent attempt has not been started yet.
+     * If the request has already been cancelled we don't go ahead with the next attempt, and artificially raise the
+     * {@link CancellationException}, otherwise we run the provided {@link Runnable} which will reset the request and send the next attempt.
+     * Note that this method must be synchronized as well as the {@link #cancel()} method, to prevent a request from being cancelled
+     * when there is no future to cancel, which would make cancelling the request a no-op.
+     */
+    synchronized <T> T callIfNotCancelled(Callable<T> callable) throws IOException {
+        if (this.httpRequest.isAborted()) {
+            throw newCancellationException();
+        }
+        try {
+            return callable.call();
+        } catch (final IOException ex) {
+            throw ex;
+        } catch (final Exception ex) {
+            throw new IOException(ex);
+        }
+    }
+
     static CancellationException newCancellationException() {
         return new CancellationException("request was cancelled");
     }
diff --git a/client/rest/src/main/java/org/opensearch/client/Message.java b/client/rest/src/main/java/org/opensearch/client/Message.java
new file mode 100644
index 0000000000000..562b95f38d4ea
--- /dev/null
+++ b/client/rest/src/main/java/org/opensearch/client/Message.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.client;
+
+import org.apache.http.HttpMessage;
+
+import java.util.Objects;
+
+final class Message<H extends HttpMessage, B> {
+    private final H head;
+    private final B body;
+
+    public Message(final H head, final B body) {
+        this.head = Objects.requireNonNull(head, "Message head");
+        this.body = body;
+    }
+
+    public H getHead() {
+        return head;
+    }
+
+    public B getBody() {
+        return body;
+    }
+
+    @Override
+    public String toString() {
+        return "[" + "head=" + head + ", body=" + body + ']';
+    }
+}
diff --git a/client/rest/src/main/java/org/opensearch/client/ReactiveDataConsumer.java b/client/rest/src/main/java/org/opensearch/client/ReactiveDataConsumer.java
new file mode 100644
index 0000000000000..e79832067bd27
--- /dev/null
+++ b/client/rest/src/main/java/org/opensearch/client/ReactiveDataConsumer.java
@@ -0,0 +1,122 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.client;
+
+import org.apache.http.util.Args;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/**
+ * Adapted from https://github.com/apache/httpcomponents-core/blob/master/httpcore5-reactive/src/main/java/org/apache/hc/core5/reactive/ReactiveDataConsumer.java
+ */
+class ReactiveDataConsumer implements Publisher<ByteBuffer> {
+
+    private final AtomicLong requests = new AtomicLong(0);
+
+    private final BlockingQueue<ByteBuffer> buffers = new LinkedBlockingQueue<>();
+    private final AtomicBoolean flushInProgress = new AtomicBoolean(false);
+    private final AtomicInteger windowScalingIncrement = new AtomicInteger(0);
+    private volatile boolean completed;
+    private volatile Exception exception;
+    private volatile Subscriber<? super ByteBuffer> subscriber;
+
+    private final ReentrantLock lock = new ReentrantLock();
+
+    public void failed(final Exception cause) {
+        if (!completed) {
+            exception = cause;
+            flushToSubscriber();
+        }
+    }
+
+    public void consume(final ByteBuffer byteBuffer) throws IOException {
+        if (completed) {
+            throw new IllegalStateException("Received data past end of stream");
+        }
+
+        final byte[] copy = new byte[byteBuffer.remaining()];
+        byteBuffer.get(copy);
+        buffers.add(ByteBuffer.wrap(copy));
+
+        flushToSubscriber();
+    }
+
+    public void complete() {
+        completed = true;
+        flushToSubscriber();
+    }
+
+    private void flushToSubscriber() {
+        lock.lock();
+        try {
+            final Subscriber<? super ByteBuffer> s = subscriber;
+            if (flushInProgress.getAndSet(true)) {
+                return;
+            }
+            try {
+                if (s == null) {
+                    return;
+                }
+                if (exception != null) {
+                    subscriber = null;
+                    s.onError(exception);
+                    return;
+                }
+                ByteBuffer next;
+                while (requests.get() > 0 && ((next = buffers.poll()) != null)) {
+                    final int bytesFreed = next.remaining();
+                    s.onNext(next);
+                    requests.decrementAndGet();
+                    windowScalingIncrement.addAndGet(bytesFreed);
+                }
+                if (completed && buffers.isEmpty()) {
+                    subscriber = null;
+                    s.onComplete();
+                }
+            } finally {
+                flushInProgress.set(false);
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public void subscribe(final Subscriber<? super ByteBuffer> subscriber) {
+        this.subscriber = Args.notNull(subscriber, "subscriber");
+        subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(final long increment) {
+                if (increment <= 0) {
+                    failed(new IllegalArgumentException("The number of elements requested must be strictly positive"));
+                    return;
+                }
+                requests.addAndGet(increment);
+                flushToSubscriber();
+            }
+
+            @Override
+            public void cancel() {
+                ReactiveDataConsumer.this.subscriber = null;
+            }
+        });
+    }
+
+}
diff --git a/client/rest/src/main/java/org/opensearch/client/ReactiveDataProducer.java b/client/rest/src/main/java/org/opensearch/client/ReactiveDataProducer.java
new file mode 100644
index 0000000000000..0f80af81ab60b
--- /dev/null
+++ b/client/rest/src/main/java/org/opensearch/client/ReactiveDataProducer.java
@@ -0,0 +1,147 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.client;
+
+import org.apache.http.nio.ContentEncoder;
+import org.apache.http.nio.IOControl;
+import org.apache.http.nio.entity.HttpAsyncContentProducer;
+import org.apache.http.util.Args;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayDeque;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.ReentrantLock;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+/**
+ * Adapted from https://github.com/apache/httpcomponents-core/blob/master/httpcore5-reactive/src/main/java/org/apache/hc/core5/reactive/ReactiveDataProducer.java
+ */
+class ReactiveDataProducer implements HttpAsyncContentProducer, Subscriber<ByteBuffer> {
+    private static final int BUFFER_WINDOW_SIZE = 5;
+    private final AtomicReference<IOControl> controlChannel = new AtomicReference<>();
+    private final AtomicReference<Throwable> exception = new AtomicReference<>();
+    private final AtomicBoolean complete = new AtomicBoolean(false);
+    private final Publisher<ByteBuffer> publisher;
+    private final AtomicReference<Subscription> subscription = new AtomicReference<>();
+    private final ArrayDeque<ByteBuffer> buffers = new ArrayDeque<>(); // This field requires synchronization
+    private final ReentrantLock lock;
+
+    public ReactiveDataProducer(final Publisher<ByteBuffer> publisher) {
+        this.publisher = Args.notNull(publisher, "publisher");
+        this.lock = new ReentrantLock();
+    }
+
+    @Override
+    public void onSubscribe(final Subscription subscription) {
+        if (this.subscription.getAndSet(subscription) != null) {
+            throw new IllegalStateException("Already subscribed");
+        }
+
+        subscription.request(BUFFER_WINDOW_SIZE);
+    }
+
+    @Override
+    public void onNext(final ByteBuffer byteBuffer) {
+        final byte[] copy = new byte[byteBuffer.remaining()];
+        byteBuffer.get(copy);
+
+        lock.lock();
+        try {
+            buffers.add(ByteBuffer.wrap(copy));
+        } finally {
+            lock.unlock();
+        }
+
+        if (controlChannel.get() != null) {
+            controlChannel.get().requestOutput();
+        }
+    }
+
+    @Override
+    public void onError(final Throwable throwable) {
+        subscription.set(null);
+        exception.set(throwable);
+        if (controlChannel.get() != null) {
+            controlChannel.get().requestOutput();
+        }
+    }
+
+    @Override
+    public void onComplete() {
+        subscription.set(null);
+        complete.set(true);
+        if (controlChannel.get() != null) {
+            controlChannel.get().requestOutput();
+        }
+    }
+
+    @Override
+    public void produceContent(ContentEncoder encoder, IOControl ioControl) throws IOException {
+        if (controlChannel.get() == null) {
+            controlChannel.set(ioControl);
+            publisher.subscribe(this);
+        }
+
+        final Throwable t = exception.get();
+        final Subscription s = subscription.get();
+        int buffersToReplenish = 0;
+        try {
+            lock.lock();
+            try {
+                if (t != null) {
+                    throw new IOException(t.getMessage(), t);
+                } else if (this.complete.get() && buffers.isEmpty()) {
+                    encoder.complete();
+                } else {
+                    while (!buffers.isEmpty()) {
+                        final ByteBuffer nextBuffer = buffers.remove();
+                        encoder.write(nextBuffer);
+                        if (nextBuffer.remaining() > 0) {
+                            buffers.push(nextBuffer);
+                            break;
+                        } else if (s != null) {
+                            // We defer the #request call until after we release the buffer lock.
+                            buffersToReplenish++;
+                        }
+                    }
+                }
+            } finally {
+                lock.unlock();
+            }
+        } finally {
+            if (s != null && buffersToReplenish > 0) {
+                s.request(buffersToReplenish);
+            }
+
+            if (!this.complete.get()) {
+                ioControl.suspendOutput();
+            }
+        }
+    }
+
+    @Override
+    public boolean isRepeatable() {
+        return false;
+    }
+
+    @Override
+    public void close() throws IOException {
+        controlChannel.set(null);
+
+        final Subscription s = subscription.getAndSet(null);
+        if (s != null) {
+            s.cancel();
+        }
+    }
+}
diff --git a/client/rest/src/main/java/org/opensearch/client/ReactiveRequestProducer.java b/client/rest/src/main/java/org/opensearch/client/ReactiveRequestProducer.java
new file mode 100644
index 0000000000000..3f306a96f24c4
--- /dev/null
+++ b/client/rest/src/main/java/org/opensearch/client/ReactiveRequestProducer.java
@@ -0,0 +1,166 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.client;
+
+import org.apache.http.Header;
+import org.apache.http.HttpEntity;
+import org.apache.http.HttpEntityEnclosingRequest;
+import org.apache.http.HttpHost;
+import org.apache.http.HttpRequest;
+import org.apache.http.entity.ContentType;
+import org.apache.http.message.BasicHeader;
+import org.apache.http.nio.ContentEncoder;
+import org.apache.http.nio.IOControl;
+import org.apache.http.nio.protocol.HttpAsyncRequestProducer;
+import org.apache.http.protocol.HttpContext;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+
+import org.reactivestreams.Publisher;
+
+class ReactiveRequestProducer implements HttpAsyncRequestProducer {
+    private final HttpHost target;
+    private final HttpRequest request;
+    private final ReactiveDataProducer producer;
+
+    private static final class ReactiveHttpEntity implements HttpEntity {
+        private final Header contentType;
+        private final Header contentEncoding;
+
+        private ReactiveHttpEntity(final Header contentType, final Header contentEncoding) {
+            this.contentType = contentType;
+            this.contentEncoding = contentEncoding;
+        }
+
+        @Override
+        public void writeTo(OutputStream outStream) throws IOException {
+            throw new UnsupportedOperationException("This operation is not supported");
+        }
+
+        @Override
+        public boolean isStreaming() {
+            return true;
+        }
+
+        @Override
+        public boolean isRepeatable() {
+            return false;
+        }
+
+        @Override
+        public boolean isChunked() {
+            return true;
+        }
+
+        @Override
+        public Header getContentType() {
+            return contentType;
+        }
+
+        @Override
+        public long getContentLength() {
+            return -1;
+        }
+
+        @Override
+        public Header getContentEncoding() {
+            return contentEncoding;
+        }
+
+        @Override
+        public InputStream getContent() throws IOException, UnsupportedOperationException {
+            throw new UnsupportedOperationException("This operation is not supported");
+        }
+
+        @Override
+        public void consumeContent() throws IOException {
+            throw new UnsupportedOperationException("This operation is not supported");
+        }
+    };
+
+    ReactiveRequestProducer(HttpRequest request, HttpHost target, Publisher<ByteBuffer> publisher) {
+        this.target = target;
+        this.request = request;
+        this.producer = new ReactiveDataProducer(publisher);
+    }
+
+    @Override
+    public HttpRequest generateRequest() {
+        final Header contentTypeHeader = request.getFirstHeader("Content-Type");
+        if (contentTypeHeader == null) {
+            request.setHeader(new BasicHeader("Content-Type", ContentType.APPLICATION_JSON.getMimeType()));
+        }
+
+        if (request instanceof HttpEntityEnclosingRequest) {
+            final HttpEntityEnclosingRequest enclosingRequest = (HttpEntityEnclosingRequest) request;
+            enclosingRequest.setEntity(
+                new ReactiveHttpEntity(request.getFirstHeader("Content-Type"), request.getFirstHeader("Content-Encoding"))
+            );
+        }
+
+        return this.request;
+    }
+
+    @Override
+    public HttpHost getTarget() {
+        return this.target;
+    }
+
+    @Override
+    public void produceContent(final ContentEncoder encoder, final IOControl ioControl) throws IOException {
+        if (this.producer != null) {
+            this.producer.produceContent(encoder, ioControl);
+            if (encoder.isCompleted()) {
+                this.producer.close();
+            }
+        }
+    }
+
+    @Override
+    public void requestCompleted(final HttpContext context) {
+        this.producer.onComplete();
+    }
+
+    @Override
+    public void failed(final Exception ex) {
+        this.producer.onError(ex);
+    }
+
+    @Override
+    public boolean isRepeatable() {
+        return this.producer.isRepeatable();
+    }
+
+    @Override
+    public void resetRequest() throws IOException {
+        this.producer.close();
+    }
+
+    @Override
+    public void close() throws IOException {
+        this.producer.close();
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder();
+        sb.append(this.target);
+        sb.append(' ');
+        sb.append(this.request);
+        if (this.producer != null) {
+            sb.append(' ');
+            sb.append(this.producer);
+        }
+        return sb.toString();
+    }
+
+}
diff --git a/client/rest/src/main/java/org/opensearch/client/ReactiveResponseConsumer.java b/client/rest/src/main/java/org/opensearch/client/ReactiveResponseConsumer.java
new file mode 100644
index 0000000000000..9ccd64d4aa942
--- /dev/null
+++ b/client/rest/src/main/java/org/opensearch/client/ReactiveResponseConsumer.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.client;
+
+import org.apache.http.HttpException;
+import org.apache.http.HttpResponse;
+import org.apache.http.concurrent.BasicFuture;
+import org.apache.http.concurrent.FutureCallback;
+import org.apache.http.nio.IOControl;
+import org.apache.http.nio.client.methods.AsyncByteConsumer;
+import org.apache.http.protocol.HttpContext;
+import org.apache.http.util.Args;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import org.reactivestreams.Publisher;
+
+class ReactiveResponseConsumer extends AsyncByteConsumer<HttpResponse> {
+    private final BasicFuture<Message<HttpResponse, Publisher<ByteBuffer>>> responseFuture;
+    private final ReactiveDataConsumer reactiveDataConsumer = new ReactiveDataConsumer();
+
+    ReactiveResponseConsumer(final FutureCallback<Message<HttpResponse, Publisher<ByteBuffer>>> responseCallback) {
+        this.responseFuture = new BasicFuture<>(Args.notNull(responseCallback, "responseCallback"));
+    }
+
+    @Override
+    protected void onByteReceived(ByteBuffer buf, IOControl ioctrl) throws IOException {
+        reactiveDataConsumer.consume(buf);
+        ioctrl.requestInput();
+    }
+
+    @Override
+    public void onResponseReceived(HttpResponse response) throws HttpException, IOException {
+        responseFuture.completed(new Message<>(response, reactiveDataConsumer));
+    }
+
+    @Override
+    public HttpResponse buildResult(HttpContext context) throws Exception {
+        reactiveDataConsumer.complete();
+        return null;
+    }
+
+    @Override
+    protected void releaseResources() {
+        if (getException() != null) {
+            reactiveDataConsumer.failed(getException());
+            responseFuture.failed(getException());
+        }
+    }
+}
diff --git a/client/rest/src/main/java/org/opensearch/client/Request.java b/client/rest/src/main/java/org/opensearch/client/Request.java
index df81ca7f717ae..9bf8cce3e70e7 100644
--- a/client/rest/src/main/java/org/opensearch/client/Request.java
+++ b/client/rest/src/main/java/org/opensearch/client/Request.java
@@ -110,7 +110,13 @@ public void addParameters(Map<String, String> paramSource) {
      * will change it.
      */
     public Map<String, String> getParameters() {
-        return unmodifiableMap(parameters);
+        if (options.getParameters().isEmpty()) {
+            return unmodifiableMap(parameters);
+        } else {
+            Map<String, String> combinedParameters = new HashMap<>(parameters);
+            combinedParameters.putAll(options.getParameters());
+            return unmodifiableMap(combinedParameters);
+        }
     }
 
     /**
diff --git a/client/rest/src/main/java/org/opensearch/client/RequestOptions.java b/client/rest/src/main/java/org/opensearch/client/RequestOptions.java
index 5390e303ff499..13a14b9e4da12 100644
--- a/client/rest/src/main/java/org/opensearch/client/RequestOptions.java
+++ b/client/rest/src/main/java/org/opensearch/client/RequestOptions.java
@@ -40,8 +40,11 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.stream.Collectors;
 
 /**
  * The portion of an HTTP request to OpenSearch that can be
@@ -53,18 +56,21 @@ public final class RequestOptions {
      */
     public static final RequestOptions DEFAULT = new Builder(
         Collections.emptyList(),
+        Collections.emptyMap(),
         HeapBufferedResponseConsumerFactory.DEFAULT,
         null,
         null
     ).build();
 
     private final List<Header> headers;
+    private final Map<String, String> parameters;
     private final HttpAsyncResponseConsumerFactory httpAsyncResponseConsumerFactory;
     private final WarningsHandler warningsHandler;
     private final RequestConfig requestConfig;
 
     private RequestOptions(Builder builder) {
         this.headers = Collections.unmodifiableList(new ArrayList<>(builder.headers));
+        this.parameters = Collections.unmodifiableMap(new HashMap<>(builder.parameters));
         this.httpAsyncResponseConsumerFactory = builder.httpAsyncResponseConsumerFactory;
         this.warningsHandler = builder.warningsHandler;
         this.requestConfig = builder.requestConfig;
@@ -74,7 +80,7 @@ private RequestOptions(Builder builder) {
      * Create a builder that contains these options but can be modified.
      */
     public Builder toBuilder() {
-        return new Builder(headers, httpAsyncResponseConsumerFactory, warningsHandler, requestConfig);
+        return new Builder(headers, parameters, httpAsyncResponseConsumerFactory, warningsHandler, requestConfig);
     }
 
     /**
@@ -84,6 +90,14 @@ public List<Header> getHeaders() {
         return headers;
     }
 
+    /**
+     * Query parameters to attach to the request. Any parameters present here
+     * will override matching parameters in the {@link Request}, if they exist.
+     */
+    public Map<String, String> getParameters() {
+        return parameters;
+    }
+
     /**
      * The {@link HttpAsyncResponseConsumerFactory} used to create one
      * {@link HttpAsyncResponseConsumer} callback per retry. Controls how the
@@ -139,6 +153,12 @@ public String toString() {
                 b.append(headers.get(h).toString());
             }
         }
+        if (parameters.size() > 0) {
+            if (comma) b.append(", ");
+            comma = true;
+            b.append("parameters=");
+            b.append(parameters.entrySet().stream().map(e -> e.getKey() + "=" + e.getValue()).collect(Collectors.joining(",")));
+        }
         if (httpAsyncResponseConsumerFactory != HttpAsyncResponseConsumerFactory.DEFAULT) {
             if (comma) b.append(", ");
             comma = true;
@@ -163,13 +183,14 @@ public boolean equals(Object obj) {
 
         RequestOptions other = (RequestOptions) obj;
         return headers.equals(other.headers)
+            && parameters.equals(other.parameters)
             && httpAsyncResponseConsumerFactory.equals(other.httpAsyncResponseConsumerFactory)
             && Objects.equals(warningsHandler, other.warningsHandler);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(headers, httpAsyncResponseConsumerFactory, warningsHandler);
+        return Objects.hash(headers, parameters, httpAsyncResponseConsumerFactory, warningsHandler);
     }
 
     /**
@@ -179,17 +200,20 @@ public int hashCode() {
      */
     public static class Builder {
         private final List<Header> headers;
+        private final Map<String, String> parameters;
         private HttpAsyncResponseConsumerFactory httpAsyncResponseConsumerFactory;
         private WarningsHandler warningsHandler;
         private RequestConfig requestConfig;
 
         private Builder(
             List<Header> headers,
+            Map<String, String> parameters,
             HttpAsyncResponseConsumerFactory httpAsyncResponseConsumerFactory,
             WarningsHandler warningsHandler,
             RequestConfig requestConfig
         ) {
             this.headers = new ArrayList<>(headers);
+            this.parameters = new HashMap<>(parameters);
             this.httpAsyncResponseConsumerFactory = httpAsyncResponseConsumerFactory;
             this.warningsHandler = warningsHandler;
             this.requestConfig = requestConfig;
@@ -216,6 +240,21 @@ public Builder addHeader(String name, String value) {
             return this;
         }
 
+        /**
+         * Add the provided query parameter to the request. Any parameters added here
+         * will override matching parameters in the {@link Request}, if they exist.
+         *
+         * @param name  the query parameter name
+         * @param value the query parameter value
+         * @throws NullPointerException if {@code name} or {@code value} is null.
+         */
+        public Builder addParameter(String name, String value) {
+            Objects.requireNonNull(name, "query parameter name cannot be null");
+            Objects.requireNonNull(value, "query parameter value cannot be null");
+            this.parameters.put(name, value);
+            return this;
+        }
+
         /**
          * Set the {@link HttpAsyncResponseConsumerFactory} used to create one
          * {@link HttpAsyncResponseConsumer} callback per retry. Controls how the
diff --git a/client/rest/src/main/java/org/opensearch/client/Response.java b/client/rest/src/main/java/org/opensearch/client/Response.java
index d380607b7df9e..ad492b18f0e5c 100644
--- a/client/rest/src/main/java/org/opensearch/client/Response.java
+++ b/client/rest/src/main/java/org/opensearch/client/Response.java
@@ -39,11 +39,8 @@
 import org.apache.http.RequestLine;
 import org.apache.http.StatusLine;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 /**
  * Holds an opensearch response. It wraps the {@link HttpResponse} returned and associates it with
@@ -115,79 +112,11 @@ public HttpEntity getEntity() {
         return response.getEntity();
     }
 
-    /**
-     * Optimized regular expression to test if a string matches the RFC 1123 date
-     * format (with quotes and leading space). Start/end of line characters and
-     * atomic groups are used to prevent backtracking.
-     */
-    private static final Pattern WARNING_HEADER_DATE_PATTERN = Pattern.compile("^ " + // start of line, leading space
-    // quoted RFC 1123 date format
-        "\"" + // opening quote
-        "(?>Mon|Tue|Wed|Thu|Fri|Sat|Sun), " + // day of week, atomic group to prevent backtracking
-        "\\d{2} " + // 2-digit day
-        "(?>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) " + // month, atomic group to prevent backtracking
-        "\\d{4} " + // 4-digit year
-        "\\d{2}:\\d{2}:\\d{2} " + // (two-digit hour):(two-digit minute):(two-digit second)
-        "GMT" + // GMT
-        "\"$"); // closing quote (optional, since an older version can still send a warn-date), end of line
-
-    /**
-     * Length of RFC 1123 format (with quotes and leading space), used in
-     * matchWarningHeaderPatternByPrefix(String).
-     */
-    private static final int WARNING_HEADER_DATE_LENGTH = 0 + 1 + 1 + 3 + 1 + 1 + 2 + 1 + 3 + 1 + 4 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 3 + 1;
-
-    /**
-     * Tests if a string matches the RFC 7234 specification for warning headers.
-     * This assumes that the warn code is always 299 and the warn agent is always
-     * OpenSearch.
-     *
-     * @param s the value of a warning header formatted according to RFC 7234
-     * @return {@code true} if the input string matches the specification
-     */
-    private static boolean matchWarningHeaderPatternByPrefix(final String s) {
-        return s.startsWith("299 OpenSearch-") || s.startsWith("299 Elasticsearch-");
-    }
-
-    /**
-     * Refer to org.opensearch.common.logging.DeprecationLogger
-     */
-    private static String extractWarningValueFromWarningHeader(final String s) {
-        String warningHeader = s;
-
-        /*
-         * The following block tests for the existence of a RFC 1123 date in the warning header. If the date exists, it is removed for
-         * extractWarningValueFromWarningHeader(String) to work properly (as it does not handle dates).
-         */
-        if (s.length() > WARNING_HEADER_DATE_LENGTH) {
-            final String possibleDateString = s.substring(s.length() - WARNING_HEADER_DATE_LENGTH);
-            final Matcher matcher = WARNING_HEADER_DATE_PATTERN.matcher(possibleDateString);
-
-            if (matcher.matches()) {
-                warningHeader = warningHeader.substring(0, s.length() - WARNING_HEADER_DATE_LENGTH);
-            }
-        }
-
-        final int firstQuote = warningHeader.indexOf('\"');
-        final int lastQuote = warningHeader.length() - 1;
-        final String warningValue = warningHeader.substring(firstQuote + 1, lastQuote);
-        return warningValue;
-    }
-
     /**
      * Returns a list of all warning headers returned in the response.
      */
     public List<String> getWarnings() {
-        List<String> warnings = new ArrayList<>();
-        for (Header header : response.getHeaders("Warning")) {
-            String warning = header.getValue();
-            if (matchWarningHeaderPatternByPrefix(warning)) {
-                warnings.add(extractWarningValueFromWarningHeader(warning));
-            } else {
-                warnings.add(warning);
-            }
-        }
-        return warnings;
+        return ResponseWarningsExtractor.getWarnings(response);
     }
 
     /**
diff --git a/client/rest/src/main/java/org/opensearch/client/ResponseWarningsExtractor.java b/client/rest/src/main/java/org/opensearch/client/ResponseWarningsExtractor.java
new file mode 100644
index 0000000000000..46b63097d76b4
--- /dev/null
+++ b/client/rest/src/main/java/org/opensearch/client/ResponseWarningsExtractor.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.client;
+
+import org.apache.http.Header;
+import org.apache.http.HttpResponse;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+final class ResponseWarningsExtractor {
+
+    /**
+     * Optimized regular expression to test if a string matches the RFC 1123 date
+     * format (with quotes and leading space). Start/end of line characters and
+     * atomic groups are used to prevent backtracking.
+     */
+    private static final Pattern WARNING_HEADER_DATE_PATTERN = Pattern.compile("^ " + // start of line, leading space
+    // quoted RFC 1123 date format
+        "\"" + // opening quote
+        "(?>Mon|Tue|Wed|Thu|Fri|Sat|Sun), " + // day of week, atomic group to prevent backtracking
+        "\\d{2} " + // 2-digit day
+        "(?>Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) " + // month, atomic group to prevent backtracking
+        "\\d{4} " + // 4-digit year
+        "\\d{2}:\\d{2}:\\d{2} " + // (two-digit hour):(two-digit minute):(two-digit second)
+        "GMT" + // GMT
+        "\"$"); // closing quote (optional, since an older version can still send a warn-date), end of line
+
+    /**
+     * Length of RFC 1123 format (with quotes and leading space), used in
+     * matchWarningHeaderPatternByPrefix(String).
+     */
+    private static final int WARNING_HEADER_DATE_LENGTH = 0 + 1 + 1 + 3 + 1 + 1 + 2 + 1 + 3 + 1 + 4 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 3 + 1;
+
+    private ResponseWarningsExtractor() {}
+
+    /**
+     * Returns a list of all warning headers returned in the response.
+     * @param response HTTP response
+     */
+    static List<String> getWarnings(final HttpResponse response) {
+        List<String> warnings = new ArrayList<>();
+        for (Header header : response.getHeaders("Warning")) {
+            String warning = header.getValue();
+            if (matchWarningHeaderPatternByPrefix(warning)) {
+                warnings.add(extractWarningValueFromWarningHeader(warning));
+            } else {
+                warnings.add(warning);
+            }
+        }
+        return warnings;
+    }
+
+    /**
+     * Tests if a string matches the RFC 7234 specification for warning headers.
+     * This assumes that the warn code is always 299 and the warn agent is always
+     * OpenSearch.
+     *
+     * @param s the value of a warning header formatted according to RFC 7234
+     * @return {@code true} if the input string matches the specification
+     */
+    private static boolean matchWarningHeaderPatternByPrefix(final String s) {
+        return s.startsWith("299 OpenSearch-");
+    }
+
+    /**
+     * Refer to org.opensearch.common.logging.DeprecationLogger
+     */
+    private static String extractWarningValueFromWarningHeader(final String s) {
+        String warningHeader = s;
+
+        /*
+         * The following block tests for the existence of a RFC 1123 date in the warning header. If the date exists, it is removed for
+         * extractWarningValueFromWarningHeader(String) to work properly (as it does not handle dates).
+         */
+        if (s.length() > WARNING_HEADER_DATE_LENGTH) {
+            final String possibleDateString = s.substring(s.length() - WARNING_HEADER_DATE_LENGTH);
+            final Matcher matcher = WARNING_HEADER_DATE_PATTERN.matcher(possibleDateString);
+
+            if (matcher.matches()) {
+                warningHeader = warningHeader.substring(0, s.length() - WARNING_HEADER_DATE_LENGTH);
+            }
+        }
+
+        final int firstQuote = warningHeader.indexOf('\"');
+        final int lastQuote = warningHeader.length() - 1;
+        final String warningValue = warningHeader.substring(firstQuote + 1, lastQuote);
+        return warningValue;
+    }
+
+}
diff --git a/client/rest/src/main/java/org/opensearch/client/RestClient.java b/client/rest/src/main/java/org/opensearch/client/RestClient.java
index 3e07365f4f80e..ac86460adba97 100644
--- a/client/rest/src/main/java/org/opensearch/client/RestClient.java
+++ b/client/rest/src/main/java/org/opensearch/client/RestClient.java
@@ -60,6 +60,7 @@
 import org.apache.http.impl.auth.BasicScheme;
 import org.apache.http.impl.client.BasicAuthCache;
 import org.apache.http.impl.nio.client.CloseableHttpAsyncClient;
+import org.apache.http.message.BasicHttpResponse;
 import org.apache.http.nio.client.methods.HttpAsyncMethods;
 import org.apache.http.nio.protocol.HttpAsyncRequestProducer;
 import org.apache.http.nio.protocol.HttpAsyncResponseConsumer;
@@ -75,6 +76,7 @@
 import java.net.SocketTimeoutException;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Base64;
@@ -90,6 +92,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.CancellationException;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ExecutionException;
@@ -97,6 +100,11 @@
 import java.util.stream.Collectors;
 import java.util.zip.GZIPOutputStream;
 
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.core.publisher.MonoSink;
+
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Collections.singletonList;
 
@@ -291,6 +299,23 @@ public boolean isRunning() {
         return client.isRunning();
     }
 
+    /**
+     * Sends a streaming request to the OpenSearch cluster that the client points to and returns streaming response. <strong>This is an experimental API</strong>.
+     * @param request streaming request
+     * @return streaming response
+     * @throws IOException IOException
+     */
+    public StreamingResponse<ByteBuffer> streamRequest(StreamingRequest<ByteBuffer> request) throws IOException {
+        final InternalStreamingRequest internalRequest = new InternalStreamingRequest(request);
+
+        final StreamingResponse<ByteBuffer> response = new StreamingResponse<>(
+            internalRequest.httpRequest.getRequestLine(),
+            streamRequest(nextNodes(), internalRequest)
+        );
+
+        return response;
+    }
+
     /**
      * Sends a request to the OpenSearch cluster that the client points to.
      * Blocks until the request is completed and returns its response or fails
@@ -323,13 +348,13 @@ public Response performRequest(Request request) throws IOException {
 
     private Response performRequest(final NodeTuple<Iterator<Node>> nodeTuple, final InternalRequest request, Exception previousException)
         throws IOException {
-        RequestContext context = request.createContextForNextAttempt(nodeTuple.nodes.next(), nodeTuple.authCache);
+        RequestContext<HttpResponse> context = request.createContextForNextAttempt(nodeTuple.nodes.next(), nodeTuple.authCache);
         HttpResponse httpResponse;
         try {
-            httpResponse = client.execute(context.requestProducer, context.asyncResponseConsumer, context.context, null).get();
+            httpResponse = client.execute(context.requestProducer(), context.asyncResponseConsumer(), context.context(), null).get();
         } catch (Exception e) {
-            RequestLogger.logFailedRequest(logger, request.httpRequest, context.node, e);
-            onFailure(context.node);
+            RequestLogger.logFailedRequest(logger, request.httpRequest, context.node(), e);
+            onFailure(context.node());
             Exception cause = extractAndWrapCause(e);
             addSuppressedException(previousException, cause);
             if (nodeTuple.nodes.hasNext()) {
@@ -343,7 +368,7 @@ private Response performRequest(final NodeTuple<Iterator<Node>> nodeTuple, final
             }
             throw new IllegalStateException("unexpected exception type: must be either RuntimeException or IOException", cause);
         }
-        ResponseOrResponseException responseOrResponseException = convertResponse(request, context.node, httpResponse);
+        ResponseOrResponseException responseOrResponseException = convertResponse(request, context.node(), httpResponse);
         if (responseOrResponseException.responseException == null) {
             return responseOrResponseException.response;
         }
@@ -354,6 +379,84 @@ private Response performRequest(final NodeTuple<Iterator<Node>> nodeTuple, final
         throw responseOrResponseException.responseException;
     }
 
+    private Publisher<Message<HttpResponse, Publisher<ByteBuffer>>> streamRequest(
+        final NodeTuple<Iterator<Node>> nodeTuple,
+        final InternalStreamingRequest request
+    ) throws IOException {
+        return request.cancellable.callIfNotCancelled(() -> {
+            final Node node = nodeTuple.nodes.next();
+
+            final Mono<Message<HttpResponse, Publisher<ByteBuffer>>> publisher = Mono.create(emitter -> {
+                final RequestContext<HttpResponse> context = request.createContextForNextAttempt(node, nodeTuple.authCache, emitter);
+                client.execute(context.requestProducer(), context.asyncResponseConsumer(), context.context(), null);
+            });
+
+            return publisher.flatMap(message -> {
+                try {
+                    final ResponseOrResponseException responseOrResponseException = convertResponse(request, node, message);
+                    if (responseOrResponseException.responseException == null) {
+                        return Mono.just(
+                            new Message<>(
+                                message.getHead(),
+                                Flux.from(message.getBody()).flatMapSequential(b -> Flux.fromIterable(frame(b)))
+                            )
+                        );
+                    } else {
+                        if (nodeTuple.nodes.hasNext()) {
+                            return Mono.from(streamRequest(nodeTuple, request));
+                        } else {
+                            return Mono.error(responseOrResponseException.responseException);
+                        }
+                    }
+                } catch (final Exception ex) {
+                    return Mono.error(ex);
+                }
+            });
+        });
+    }
+
+    /**
+     * Frame the {@link ByteBuffer} into individual chunks that are separated by '\r\n' sequence.
+     * @param b {@link ByteBuffer} to split
+     * @return individual chunks
+     */
+    private static Collection<ByteBuffer> frame(ByteBuffer b) {
+        final Collection<ByteBuffer> buffers = new ArrayList<>();
+
+        int position = b.position();
+        while (b.hasRemaining()) {
+            // Skip the chunk separator when it comes right at the beginning
+            if (b.get() == '\r' && b.hasRemaining() && b.position() > 1) {
+                if (b.get() == '\n') {
+                    final byte[] chunk = new byte[b.position() - position];
+
+                    b.position(position);
+                    b.get(chunk);
+
+                    // Do not copy the '\r\n' sequence
+                    buffers.add(ByteBuffer.wrap(chunk, 0, chunk.length - 2));
+                    position = b.position();
+                }
+            }
+        }
+
+        if (buffers.isEmpty()) {
+            return Collections.singleton(b);
+        }
+
+        // Copy last chunk
+        if (position != b.position()) {
+            final byte[] chunk = new byte[b.position() - position];
+
+            b.position(position);
+            b.get(chunk);
+
+            buffers.add(ByteBuffer.wrap(chunk, 0, chunk.length));
+        }
+
+        return buffers;
+    }
+
     private ResponseOrResponseException convertResponse(InternalRequest request, Node node, HttpResponse httpResponse) throws IOException {
         RequestLogger.logResponse(logger, request.httpRequest, node.getHost(), httpResponse);
         int statusCode = httpResponse.getStatusLine().getStatusCode();
@@ -384,6 +487,37 @@ private ResponseOrResponseException convertResponse(InternalRequest request, Nod
         throw responseException;
     }
 
+    private ResponseOrResponseException convertResponse(
+        InternalStreamingRequest request,
+        Node node,
+        Message<HttpResponse, Publisher<ByteBuffer>> message
+    ) throws IOException {
+
+        // Streaming Response could accumulate a lot of data so we may not be able to fully consume it.
+        final HttpResponse httpResponse = new BasicHttpResponse(message.getHead().getStatusLine());
+        final Response response = new Response(request.httpRequest.getRequestLine(), node.getHost(), httpResponse);
+
+        RequestLogger.logResponse(logger, request.httpRequest, node.getHost(), httpResponse);
+        int statusCode = httpResponse.getStatusLine().getStatusCode();
+
+        if (isSuccessfulResponse(statusCode) || request.ignoreErrorCodes.contains(response.getStatusLine().getStatusCode())) {
+            onResponse(node);
+            if (request.warningsHandler.warningsShouldFailRequest(response.getWarnings())) {
+                throw new WarningFailureException(response);
+            }
+            return new ResponseOrResponseException(response);
+        }
+        ResponseException responseException = new ResponseException(response);
+        if (isRetryStatus(statusCode)) {
+            // mark host dead and retry against next one
+            onFailure(node);
+            return new ResponseOrResponseException(responseException);
+        }
+        // mark host alive and don't retry, as the error should be a request problem
+        onResponse(node);
+        throw responseException;
+    }
+
     /**
      * Sends a request to the OpenSearch cluster that the client points to.
      * The request is executed asynchronously and the provided
@@ -418,48 +552,57 @@ private void performRequestAsync(
         final FailureTrackingResponseListener listener
     ) {
         request.cancellable.runIfNotCancelled(() -> {
-            final RequestContext context = request.createContextForNextAttempt(nodeTuple.nodes.next(), nodeTuple.authCache);
-            client.execute(context.requestProducer, context.asyncResponseConsumer, context.context, new FutureCallback<HttpResponse>() {
-                @Override
-                public void completed(HttpResponse httpResponse) {
-                    try {
-                        ResponseOrResponseException responseOrResponseException = convertResponse(request, context.node, httpResponse);
-                        if (responseOrResponseException.responseException == null) {
-                            listener.onSuccess(responseOrResponseException.response);
-                        } else {
-                            if (nodeTuple.nodes.hasNext()) {
-                                listener.trackFailure(responseOrResponseException.responseException);
-                                performRequestAsync(nodeTuple, request, listener);
+            final RequestContext<HttpResponse> context = request.createContextForNextAttempt(nodeTuple.nodes.next(), nodeTuple.authCache);
+            client.execute(
+                context.requestProducer(),
+                context.asyncResponseConsumer(),
+                context.context(),
+                new FutureCallback<HttpResponse>() {
+                    @Override
+                    public void completed(HttpResponse httpResponse) {
+                        try {
+                            ResponseOrResponseException responseOrResponseException = convertResponse(
+                                request,
+                                context.node(),
+                                httpResponse
+                            );
+                            if (responseOrResponseException.responseException == null) {
+                                listener.onSuccess(responseOrResponseException.response);
                             } else {
-                                listener.onDefinitiveFailure(responseOrResponseException.responseException);
+                                if (nodeTuple.nodes.hasNext()) {
+                                    listener.trackFailure(responseOrResponseException.responseException);
+                                    performRequestAsync(nodeTuple, request, listener);
+                                } else {
+                                    listener.onDefinitiveFailure(responseOrResponseException.responseException);
+                                }
                             }
+                        } catch (Exception e) {
+                            listener.onDefinitiveFailure(e);
                         }
-                    } catch (Exception e) {
-                        listener.onDefinitiveFailure(e);
                     }
-                }
 
-                @Override
-                public void failed(Exception failure) {
-                    try {
-                        RequestLogger.logFailedRequest(logger, request.httpRequest, context.node, failure);
-                        onFailure(context.node);
-                        if (nodeTuple.nodes.hasNext()) {
-                            listener.trackFailure(failure);
-                            performRequestAsync(nodeTuple, request, listener);
-                        } else {
-                            listener.onDefinitiveFailure(failure);
+                    @Override
+                    public void failed(Exception failure) {
+                        try {
+                            RequestLogger.logFailedRequest(logger, request.httpRequest, context.node(), failure);
+                            onFailure(context.node());
+                            if (nodeTuple.nodes.hasNext()) {
+                                listener.trackFailure(failure);
+                                performRequestAsync(nodeTuple, request, listener);
+                            } else {
+                                listener.onDefinitiveFailure(failure);
+                            }
+                        } catch (Exception e) {
+                            listener.onDefinitiveFailure(e);
                         }
-                    } catch (Exception e) {
-                        listener.onDefinitiveFailure(e);
                     }
-                }
 
-                @Override
-                public void cancelled() {
-                    listener.onDefinitiveFailure(Cancellable.newCancellationException());
+                    @Override
+                    public void cancelled() {
+                        listener.onDefinitiveFailure(Cancellable.newCancellationException());
+                    }
                 }
-            });
+            );
         });
     }
 
@@ -800,6 +943,66 @@ public void remove() {
         }
     }
 
+    private class InternalStreamingRequest {
+        private final StreamingRequest<ByteBuffer> request;
+        private final Set<Integer> ignoreErrorCodes;
+        private final HttpRequestBase httpRequest;
+        private final Cancellable cancellable;
+        private final WarningsHandler warningsHandler;
+
+        InternalStreamingRequest(StreamingRequest<ByteBuffer> request) {
+            this.request = request;
+            Map<String, String> params = new HashMap<>(request.getParameters());
+            // ignore is a special parameter supported by the clients, shouldn't be sent to es
+            String ignoreString = params.remove("ignore");
+            this.ignoreErrorCodes = getIgnoreErrorCodes(ignoreString, request.getMethod());
+            URI uri = buildUri(pathPrefix, request.getEndpoint(), params);
+            this.httpRequest = createHttpRequest(request.getMethod(), uri, null);
+            this.cancellable = Cancellable.fromRequest(httpRequest);
+            setHeaders(httpRequest, request.getOptions().getHeaders());
+            setRequestConfig(httpRequest, request.getOptions().getRequestConfig());
+            this.warningsHandler = request.getOptions().getWarningsHandler() == null
+                ? RestClient.this.warningsHandler
+                : request.getOptions().getWarningsHandler();
+        }
+
+        private void setHeaders(HttpRequest httpRequest, Collection<Header> requestHeaders) {
+            // request headers override default headers, so we don't add default headers if they exist as request headers
+            final Set<String> requestNames = new HashSet<>(requestHeaders.size());
+            for (Header requestHeader : requestHeaders) {
+                httpRequest.addHeader(requestHeader);
+                requestNames.add(requestHeader.getName());
+            }
+            for (Header defaultHeader : defaultHeaders) {
+                if (requestNames.contains(defaultHeader.getName()) == false) {
+                    httpRequest.addHeader(defaultHeader);
+                }
+            }
+            if (compressionEnabled) {
+                httpRequest.addHeader("Accept-Encoding", "gzip");
+            }
+        }
+
+        private void setRequestConfig(HttpRequestBase httpRequest, RequestConfig requestConfig) {
+            if (requestConfig != null) {
+                httpRequest.setConfig(requestConfig);
+            }
+        }
+
+        public Publisher<ByteBuffer> getPublisher() {
+            return request.getBody();
+        }
+
+        RequestContext<HttpResponse> createContextForNextAttempt(
+            Node node,
+            AuthCache authCache,
+            MonoSink<Message<HttpResponse, Publisher<ByteBuffer>>> emitter
+        ) {
+            this.httpRequest.reset();
+            return new ReactiveRequestContext(this, node, authCache, emitter);
+        }
+    }
+
     private class InternalRequest {
         private final Request request;
         private final Set<Integer> ignoreErrorCodes;
@@ -846,19 +1049,89 @@ private void setRequestConfig(HttpRequestBase httpRequest, RequestConfig request
             }
         }
 
-        RequestContext createContextForNextAttempt(Node node, AuthCache authCache) {
+        RequestContext<HttpResponse> createContextForNextAttempt(Node node, AuthCache authCache) {
             this.httpRequest.reset();
-            return new RequestContext(this, node, authCache);
+            return new AsyncRequestContext(this, node, authCache);
+        }
+    }
+
+    private interface RequestContext<T> {
+        Node node();
+
+        HttpAsyncRequestProducer requestProducer();
+
+        HttpAsyncResponseConsumer<T> asyncResponseConsumer();
+
+        HttpClientContext context();
+    }
+
+    private static class ReactiveRequestContext implements RequestContext<HttpResponse> {
+        private final Node node;
+        private final HttpAsyncRequestProducer requestProducer;
+        private final HttpAsyncResponseConsumer<HttpResponse> asyncResponseConsumer;
+        private final HttpClientContext context;
+
+        ReactiveRequestContext(
+            InternalStreamingRequest request,
+            Node node,
+            AuthCache authCache,
+            MonoSink<Message<HttpResponse, Publisher<ByteBuffer>>> emitter
+        ) {
+            this.node = node;
+            // we stream the request body if the entity allows for it
+            this.requestProducer = new ReactiveRequestProducer(request.httpRequest, node.getHost(), request.getPublisher());
+            this.asyncResponseConsumer = new ReactiveResponseConsumer(new FutureCallback<Message<HttpResponse, Publisher<ByteBuffer>>>() {
+                @Override
+                public void failed(Exception ex) {
+                    emitter.error(ex);
+                }
+
+                @Override
+                public void completed(Message<HttpResponse, Publisher<ByteBuffer>> result) {
+                    if (result == null) {
+                        emitter.success();
+                    } else {
+                        emitter.success(result);
+                    }
+                }
+
+                @Override
+                public void cancelled() {
+                    failed(new CancellationException("Future cancelled"));
+                }
+            });
+            this.context = HttpClientContext.create();
+            context.setAuthCache(authCache);
+        }
+
+        @Override
+        public HttpAsyncResponseConsumer<HttpResponse> asyncResponseConsumer() {
+            return asyncResponseConsumer;
+        }
+
+        @Override
+        public HttpClientContext context() {
+            return context;
+        }
+
+        @Override
+        public Node node() {
+            return node;
+        }
+
+        @Override
+        public HttpAsyncRequestProducer requestProducer() {
+            return requestProducer;
         }
     }
 
-    private static class RequestContext {
+    private static class AsyncRequestContext implements RequestContext<HttpResponse> {
         private final Node node;
         private final HttpAsyncRequestProducer requestProducer;
         private final HttpAsyncResponseConsumer<HttpResponse> asyncResponseConsumer;
         private final HttpClientContext context;
 
-        RequestContext(InternalRequest request, Node node, AuthCache authCache) {
+        AsyncRequestContext(InternalRequest request, Node node, AuthCache authCache) {
             this.node = node;
             // we stream the request body if the entity allows for it
             this.requestProducer = HttpAsyncMethods.create(node.getHost(), request.httpRequest);
@@ -868,6 +1141,26 @@ private static class RequestContext {
             this.context = HttpClientContext.create();
             context.setAuthCache(authCache);
         }
+
+        @Override
+        public HttpAsyncResponseConsumer<HttpResponse> asyncResponseConsumer() {
+            return asyncResponseConsumer;
+        }
+
+        @Override
+        public HttpClientContext context() {
+            return context;
+        }
+
+        @Override
+        public Node node() {
+            return node;
+        }
+
+        @Override
+        public HttpAsyncRequestProducer requestProducer() {
+            return requestProducer;
+        }
     }
 
     private static Set<Integer> getIgnoreErrorCodes(String ignoreString, String requestMethod) {
diff --git a/client/rest/src/main/java/org/opensearch/client/StreamingRequest.java b/client/rest/src/main/java/org/opensearch/client/StreamingRequest.java
new file mode 100644
index 0000000000000..e1767407b1353
--- /dev/null
+++ b/client/rest/src/main/java/org/opensearch/client/StreamingRequest.java
@@ -0,0 +1,114 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.client;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import org.reactivestreams.Publisher;
+
+import static java.util.Collections.unmodifiableMap;
+
+/**
+ * HTTP Streaming Request to OpenSearch. <strong>This is an experimental API.</strong>
+ */
+public class StreamingRequest<T> {
+    private final String method;
+    private final String endpoint;
+    private final Map<String, String> parameters = new HashMap<>();
+
+    private RequestOptions options = RequestOptions.DEFAULT;
+    private final Publisher<T> publisher;
+
+    /**
+     * Constructor
+     * @param method method
+     * @param endpoint endpoint
+     * @param publisher publisher
+     */
+    public StreamingRequest(String method, String endpoint, Publisher<T> publisher) {
+        this.method = method;
+        this.endpoint = endpoint;
+        this.publisher = publisher;
+    }
+
+    /**
+     * Get endpoint
+     * @return endpoint
+     */
+    public String getEndpoint() {
+        return endpoint;
+    }
+
+    /**
+     * Get method
+     * @return method
+     */
+    public String getMethod() {
+        return method;
+    }
+
+    /**
+     * Get options
+     * @return options
+     */
+    public RequestOptions getOptions() {
+        return options;
+    }
+
+    /**
+     * Get parameters
+     * @return parameters
+     */
+    public Map<String, String> getParameters() {
+        if (options.getParameters().isEmpty()) {
+            return unmodifiableMap(parameters);
+        } else {
+            Map<String, String> combinedParameters = new HashMap<>(parameters);
+            combinedParameters.putAll(options.getParameters());
+            return unmodifiableMap(combinedParameters);
+        }
+    }
+
+    /**
+     * Add a query string parameter.
+     * @param name the name of the url parameter. Must not be null.
+     * @param value the value of the url url parameter. If {@code null} then
+     *      the parameter is sent as {@code name} rather than {@code name=value}
+     * @throws IllegalArgumentException if a parameter with that name has
+     *      already been set
+     */
+    public void addParameter(String name, String value) {
+        Objects.requireNonNull(name, "url parameter name cannot be null");
+        if (parameters.containsKey(name)) {
+            throw new IllegalArgumentException("url parameter [" + name + "] has already been set to [" + parameters.get(name) + "]");
+        } else {
+            parameters.put(name, value);
+        }
+    }
+
+    /**
+     * Add query parameters using the provided map of key value pairs.
+     *
+     * @param paramSource a map of key value pairs where the key is the url parameter.
+     * @throws IllegalArgumentException if a parameter with that name has already been set.
+     */
+    public void addParameters(Map<String, String> paramSource) {
+        paramSource.forEach(this::addParameter);
+    }
+
+    /**
+     * Body publisher
+     * @return body publisher
+     */
+    public Publisher<T> getBody() {
+        return publisher;
+    }
+}
diff --git a/client/rest/src/main/java/org/opensearch/client/StreamingResponse.java b/client/rest/src/main/java/org/opensearch/client/StreamingResponse.java
new file mode 100644
index 0000000000000..4869187ab9261
--- /dev/null
+++ b/client/rest/src/main/java/org/opensearch/client/StreamingResponse.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.client;
+
+import org.apache.http.HttpHost;
+import org.apache.http.HttpResponse;
+import org.apache.http.RequestLine;
+import org.apache.http.StatusLine;
+
+import java.util.List;
+
+import org.reactivestreams.Publisher;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * HTTP Streaming Response from OpenSearch. <strong>This is an experimental API.</strong>
+ */
+public class StreamingResponse<T> {
+    private final RequestLine requestLine;
+    private final Mono<Message<HttpResponse, Publisher<T>>> publisher;
+    private volatile HttpHost host;
+
+    /**
+     * Constructor
+     * @param requestLine request line
+     * @param publisher message publisher(response with a body)
+     */
+    public StreamingResponse(RequestLine requestLine, Publisher<Message<HttpResponse, Publisher<T>>> publisher) {
+        this.requestLine = requestLine;
+        // We cache the publisher here so the body or / and HttpResponse could
+        // be consumed independently or/and more than once.
+        this.publisher = Mono.from(publisher).cache();
+    }
+
+    /**
+     * Set host
+     * @param host host
+     */
+    public void setHost(HttpHost host) {
+        this.host = host;
+    }
+
+    /**
+     * Get request line
+     * @return request line
+     */
+    public RequestLine getRequestLine() {
+        return requestLine;
+    }
+
+    /**
+     * Get host
+     * @return host
+     */
+    public HttpHost getHost() {
+        return host;
+    }
+
+    /**
+     * Get response boby {@link Publisher}
+     * @return response boby {@link Publisher}
+     */
+    public Publisher<T> getBody() {
+        return publisher.flatMapMany(m -> Flux.from(m.getBody()));
+    }
+
+    /**
+     * Returns the status line of the current response
+     */
+    public StatusLine getStatusLine() {
+        return publisher.map(Message::getHead)
+            .onErrorResume(ResponseException.class, e -> Mono.just(e.getResponse().getHttpResponse()))
+            .map(HttpResponse::getStatusLine)
+            .block();
+    }
+
+    /**
+     * Returns a list of all warning headers returned in the response.
+     */
+    public List<String> getWarnings() {
+        return ResponseWarningsExtractor.getWarnings(
+            publisher.map(Message::getHead)
+                .onErrorResume(ResponseException.class, e -> Mono.just(e.getResponse().getHttpResponse()))
+                .block()
+        );
+    }
+}
diff --git a/client/rest/src/test/java/org/opensearch/client/RequestOptionsTests.java b/client/rest/src/test/java/org/opensearch/client/RequestOptionsTests.java
index aaa40db1442ee..f1782a6a29795 100644
--- a/client/rest/src/test/java/org/opensearch/client/RequestOptionsTests.java
+++ b/client/rest/src/test/java/org/opensearch/client/RequestOptionsTests.java
@@ -38,12 +38,15 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 
@@ -89,6 +92,39 @@ public void testAddHeader() {
         }
     }
 
+    public void testAddParameter() {
+        assertThrows(
+            "query parameter name cannot be null",
+            NullPointerException.class,
+            () -> randomBuilder().addParameter(null, randomAsciiLettersOfLengthBetween(3, 10))
+        );
+
+        assertThrows(
+            "query parameter value cannot be null",
+            NullPointerException.class,
+            () -> randomBuilder().addParameter(randomAsciiLettersOfLengthBetween(3, 10), null)
+        );
+
+        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
+        int numParameters = between(0, 5);
+        Map<String, String> parameters = new HashMap<>();
+        for (int i = 0; i < numParameters; i++) {
+            String name = randomAsciiAlphanumOfLengthBetween(5, 10);
+            String value = randomAsciiAlphanumOfLength(3);
+            parameters.put(name, value);
+            builder.addParameter(name, value);
+        }
+        RequestOptions options = builder.build();
+        assertEquals(parameters, options.getParameters());
+
+        try {
+            options.getParameters().put(randomAsciiAlphanumOfLengthBetween(5, 10), randomAsciiAlphanumOfLength(3));
+            fail("expected failure");
+        } catch (UnsupportedOperationException e) {
+            assertNull(e.getMessage());
+        }
+    }
+
     public void testSetHttpAsyncResponseConsumerFactory() {
         try {
             RequestOptions.DEFAULT.toBuilder().setHttpAsyncResponseConsumerFactory(null);
@@ -144,6 +180,13 @@ static RequestOptions.Builder randomBuilder() {
             }
         }
 
+        if (randomBoolean()) {
+            int queryParamCount = between(1, 5);
+            for (int i = 0; i < queryParamCount; i++) {
+                builder.addParameter(randomAsciiAlphanumOfLength(3), randomAsciiAlphanumOfLength(3));
+            }
+        }
+
         if (randomBoolean()) {
             builder.setHttpAsyncResponseConsumerFactory(new HeapBufferedResponseConsumerFactory(1));
         }
diff --git a/client/rest/src/test/java/org/opensearch/client/RestClientTests.java b/client/rest/src/test/java/org/opensearch/client/RestClientTests.java
index ca761dcb6b9b6..cb5e856362fb7 100644
--- a/client/rest/src/test/java/org/opensearch/client/RestClientTests.java
+++ b/client/rest/src/test/java/org/opensearch/client/RestClientTests.java
@@ -55,12 +55,15 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Supplier;
 
+import reactor.core.publisher.Mono;
+
 import static java.util.Collections.singletonList;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
@@ -417,6 +420,16 @@ public void testIsRunning() {
         assertFalse(restClient.isRunning());
     }
 
+    public void testStreamWithUnsupportedMethod() throws Exception {
+        try (RestClient restClient = createRestClient()) {
+            final UnsupportedOperationException ex = assertThrows(
+                UnsupportedOperationException.class,
+                () -> restClient.streamRequest(new StreamingRequest<>("unsupported", randomAsciiLettersOfLength(5), Mono.empty()))
+            );
+            assertEquals("http method not supported: unsupported", ex.getMessage());
+        }
+    }
+
     private static void assertNodes(NodeTuple<List<Node>> nodeTuple, AtomicInteger lastNodeIndex, int runs) throws IOException {
         int distance = lastNodeIndex.get() % nodeTuple.nodes.size();
         /*
diff --git a/client/sniffer/licenses/jackson-core-2.17.1.jar.sha1 b/client/sniffer/licenses/jackson-core-2.17.1.jar.sha1
deleted file mode 100644
index 82dab5981e652..0000000000000
--- a/client/sniffer/licenses/jackson-core-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-5e52a11644cd59a28ef79f02bddc2cc3bab45edb
\ No newline at end of file
diff --git a/client/sniffer/licenses/jackson-core-2.17.2.jar.sha1 b/client/sniffer/licenses/jackson-core-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..e15f2340980bc
--- /dev/null
+++ b/client/sniffer/licenses/jackson-core-2.17.2.jar.sha1
@@ -0,0 +1 @@
+969a35cb35c86512acbadcdbbbfb044c877db814
\ No newline at end of file
diff --git a/distribution/archives/build.gradle b/distribution/archives/build.gradle
index 161b8008525b4..792b1ab57ddbc 100644
--- a/distribution/archives/build.gradle
+++ b/distribution/archives/build.gradle
@@ -39,11 +39,17 @@ CopySpec archiveFiles(CopySpec modulesFiles, String distributionType, String pla
         with libFiles()
       }
       into('config') {
-        dirMode 0750
-        fileMode 0660
+        dirPermissions {
+          unix 0750
+        }
+        filePermissions {
+          unix 0660
+        }
         with configFiles(distributionType, java)
         from {
-          dirMode 0750
+          dirPermissions {
+            unix 0750
+          }
           jvmOptionsDir.getParent()
         }
       }
@@ -61,13 +67,17 @@ CopySpec archiveFiles(CopySpec modulesFiles, String distributionType, String pla
       }
       into('') {
         from {
-          dirMode 0755
+          dirPermissions {
+            unix 0755
+          }
           logsDir.getParent()
         }
       }
       into('') {
         from {
-          dirMode 0755
+          dirPermissions {
+            unix 0755
+          }
           pluginsDir.getParent()
         }
       }
diff --git a/distribution/build.gradle b/distribution/build.gradle
index bbbef40f51c57..a323dd15ed9cf 100644
--- a/distribution/build.gradle
+++ b/distribution/build.gradle
@@ -363,9 +363,9 @@ configure(subprojects.findAll { ['archives', 'packages'].contains(it.name) }) {
           if (it.relativePath.segments[-2] == 'bin' || (platform == 'darwin-x64' && it.relativePath.segments[-2] == 'MacOS')) {
             // bin files, wherever they are within modules (eg platform specific) should be executable
             // and MacOS is an alternative to bin on macOS
-            it.mode = 0755
+            it.permissions(perm -> perm.unix(0755))
           } else {
-            it.mode = 0644
+            it.permissions(perm -> perm.unix(0644))
           }
         }
         def buildModules = buildModulesTaskProvider
@@ -413,7 +413,7 @@ configure(subprojects.findAll { ['archives', 'packages'].contains(it.name) }) {
           from '../src/bin'
           exclude '*.exe'
           exclude '*.bat'
-          eachFile { it.setMode(0755) }
+          eachFile { it.permissions(perm -> perm.unix(0755)) }
           MavenFilteringHack.filter(it, expansionsForDistribution(distributionType, java))
         }
         // windows files, only for zip
@@ -431,7 +431,7 @@ configure(subprojects.findAll { ['archives', 'packages'].contains(it.name) }) {
         }
         // module provided bin files
         with copySpec {
-          eachFile { it.setMode(0755) }
+          eachFile { it.permissions(perm -> perm.unix(0755)) }
           from project(':distribution').buildBin
           if (distributionType != 'zip') {
             exclude '*.bat'
@@ -473,7 +473,7 @@ configure(subprojects.findAll { ['archives', 'packages'].contains(it.name) }) {
         }
         eachFile { FileCopyDetails details ->
           if (details.relativePath.segments[-2] == 'bin' || details.relativePath.segments[-1] == 'jspawnhelper') {
-            details.mode = 0755
+            details.permissions(perm -> perm.unix(0755))
           }
           if (details.name == 'src.zip') {
             details.exclude()
@@ -501,7 +501,7 @@ configure(subprojects.findAll { ['archives', 'packages'].contains(it.name) }) {
         }
         eachFile { FileCopyDetails details ->
           if (details.relativePath.segments[-2] == 'bin' || details.relativePath.segments[-1] == 'jspawnhelper') {
-            details.mode = 0755
+            details.permissions(perm -> perm.unix(0755))
           }
         }
       }
diff --git a/distribution/packages/build.gradle b/distribution/packages/build.gradle
index 49319789e04e9..659b25129b23c 100644
--- a/distribution/packages/build.gradle
+++ b/distribution/packages/build.gradle
@@ -63,7 +63,7 @@ import java.util.regex.Pattern
  */
 
 plugins {
-  id "com.netflix.nebula.ospackage-base" version "11.9.0"
+  id "com.netflix.nebula.ospackage-base" version "11.10.0"
 }
 
 void addProcessFilesTask(String type, boolean jdk) {
@@ -160,7 +160,9 @@ Closure commonPackageConfig(String type, boolean jdk, String architecture) {
       }
       from(rootProject.projectDir) {
         include 'README.md'
-        fileMode 0644
+        filePermissions {
+          unix 0644
+        }
       }
       into('lib') {
         with libFiles()
@@ -183,9 +185,9 @@ Closure commonPackageConfig(String type, boolean jdk, String architecture) {
             directory('/' + segments[0..i].join('/'), 0755)
           }
           if (segments[-2] == 'bin' || segments[-1] == 'jspawnhelper') {
-            fcp.mode = 0755
+            fcp.permissions(perm -> perm.unix(0755))
           } else {
-            fcp.mode = 0644
+            fcp.permissions(perm -> perm.unix(0644))
           }
         }
       }
@@ -195,7 +197,9 @@ Closure commonPackageConfig(String type, boolean jdk, String architecture) {
     if (type == 'deb') {
       into("/usr/share/doc/${packageName}") {
         from "${packagingFiles}/copyright"
-        fileMode 0644
+        filePermissions {
+          unix 0644
+        }
       }
     } else {
       assert type == 'rpm'
@@ -204,7 +208,9 @@ Closure commonPackageConfig(String type, boolean jdk, String architecture) {
           include 'APACHE-LICENSE-2.0.txt'
           rename { 'LICENSE.txt' }
         }
-        fileMode 0644
+        filePermissions {
+          unix 0644
+        }
       }
     }
 
@@ -213,7 +219,9 @@ Closure commonPackageConfig(String type, boolean jdk, String architecture) {
     configurationFile '/etc/opensearch/jvm.options'
     configurationFile '/etc/opensearch/log4j2.properties'
     from("${packagingFiles}") {
-      dirMode 0750
+      dirPermissions {
+        unix 0750
+      }
       into('/etc')
       permissionGroup 'opensearch'
       includeEmptyDirs true
@@ -223,8 +231,12 @@ Closure commonPackageConfig(String type, boolean jdk, String architecture) {
     }
     from("${packagingFiles}/etc/opensearch") {
       into('/etc/opensearch')
-      dirMode 0750
-      fileMode 0660
+      dirPermissions {
+        unix 0750
+      }
+      filePermissions{
+        unix 0660
+      }
       permissionGroup 'opensearch'
       includeEmptyDirs true
       createDirectoryEntry true
@@ -235,34 +247,46 @@ Closure commonPackageConfig(String type, boolean jdk, String architecture) {
     into(new File(envFile).getParent()) {
       fileType CONFIG | NOREPLACE
       permissionGroup 'opensearch'
-      fileMode 0660
+      filePermissions {
+        unix 0660
+      }
       from "${packagingFiles}/env/opensearch"
     }
 
     // ========= systemd =========
     into('/usr/lib/tmpfiles.d') {
       from "${packagingFiles}/systemd/opensearch.conf"
-      fileMode 0644
+      filePermissions {
+        unix 0644
+      }
     }
     into('/usr/lib/systemd/system') {
       fileType CONFIG | NOREPLACE
       from "${packagingFiles}/systemd/opensearch.service"
-      fileMode 0644
+      filePermissions {
+        unix 0644
+      }
     }
     into('/usr/lib/sysctl.d') {
       fileType CONFIG | NOREPLACE
       from "${packagingFiles}/systemd/sysctl/opensearch.conf"
-      fileMode 0644
+      filePermissions {
+        unix 0644
+      }
     }
     into('/usr/share/opensearch/bin') {
       from "${packagingFiles}/systemd/systemd-entrypoint"
-      fileMode 0755
+      filePermissions {
+        unix 0755
+      }
     }
 
     // ========= sysV init =========
     configurationFile '/etc/init.d/opensearch'
     into('/etc/init.d') {
-      fileMode 0750
+      filePermissions {
+        unix 0750
+      }
       fileType CONFIG | NOREPLACE
       from "${packagingFiles}/init.d/opensearch"
     }
@@ -278,7 +302,9 @@ Closure commonPackageConfig(String type, boolean jdk, String architecture) {
         createDirectoryEntry true
         user u
         permissionGroup g
-        dirMode mode
+        dirPermissions {
+          unix mode
+        }
       }
     }
     copyEmptyDir('/var/log/opensearch', 'opensearch', 'opensearch', 0750)
@@ -341,7 +367,9 @@ Closure commonDebConfig(boolean jdk, String architecture) {
 
     into('/usr/share/lintian/overrides') {
       from('src/deb/lintian/opensearch')
-      fileMode 0644
+      filePermissions {
+        unix 0644
+      }
     }
   }
 }
diff --git a/distribution/src/config/opensearch.yml b/distribution/src/config/opensearch.yml
index 10bab9b3fce92..ce8d9079049e5 100644
--- a/distribution/src/config/opensearch.yml
+++ b/distribution/src/config/opensearch.yml
@@ -125,3 +125,7 @@ ${path.logs}
 # Gates the functionality of enabling Opensearch to use pluggable caches with respective store names via setting.
 #
 #opensearch.experimental.feature.pluggable.caching.enabled: false
+#
+# Gates the functionality of star tree index, which improves the performance of search aggregations.
+#
+#opensearch.experimental.feature.composite_index.star_tree.enabled: false
diff --git a/distribution/tools/plugin-cli/build.gradle b/distribution/tools/plugin-cli/build.gradle
index 3083ad4375460..784cdc457a1a9 100644
--- a/distribution/tools/plugin-cli/build.gradle
+++ b/distribution/tools/plugin-cli/build.gradle
@@ -37,8 +37,8 @@ base {
 dependencies {
   compileOnly project(":server")
   compileOnly project(":libs:opensearch-cli")
-  api "org.bouncycastle:bcpg-fips:1.0.7.1"
-  api "org.bouncycastle:bc-fips:1.0.2.5"
+  api "org.bouncycastle:bcpg-fips:2.0.9"
+  api "org.bouncycastle:bc-fips:2.0.0"
   testImplementation project(":test:framework")
   testImplementation 'com.google.jimfs:jimfs:1.3.0'
   testRuntimeOnly("com.google.guava:guava:${versions.guava}") {
@@ -58,33 +58,6 @@ test {
   jvmArgs += [ "-Djava.security.egd=file:/dev/urandom" ]
 }
 
-/*
- * these two classes intentionally use the following JDK internal APIs in order to offer the necessary
- * functionality
- *
- * sun.security.internal.spec.TlsKeyMaterialParameterSpec
- * sun.security.internal.spec.TlsKeyMaterialSpec
- * sun.security.internal.spec.TlsMasterSecretParameterSpec
- * sun.security.internal.spec.TlsPrfParameterSpec
- * sun.security.internal.spec.TlsRsaPremasterSecretParameterSpec
- * sun.security.provider.SecureRandom
- *
- */
-thirdPartyAudit.ignoreViolations(
-  'org.bouncycastle.jcajce.provider.BouncyCastleFipsProvider$CoreSecureRandom',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$BaseTLSKeyGeneratorSpi',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSKeyMaterialGenerator',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSKeyMaterialGenerator$2',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSMasterSecretGenerator',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSMasterSecretGenerator$2',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSPRFKeyGenerator',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSRsaPreMasterSecretGenerator',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSRsaPreMasterSecretGenerator$2',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSExtendedMasterSecretGenerator',
-  'org.bouncycastle.jcajce.provider.ProvSunTLSKDF$TLSExtendedMasterSecretGenerator$2'
-)
-
 thirdPartyAudit.ignoreMissingClasses(
   'org.brotli.dec.BrotliInputStream',
   'org.objectweb.asm.AnnotationVisitor',
diff --git a/distribution/tools/plugin-cli/licenses/bc-fips-1.0.2.5.jar.sha1 b/distribution/tools/plugin-cli/licenses/bc-fips-1.0.2.5.jar.sha1
deleted file mode 100644
index 1b44c77dd4ee1..0000000000000
--- a/distribution/tools/plugin-cli/licenses/bc-fips-1.0.2.5.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-704e65f7e4fe679e5ab2aa8a840f27f8ced4c522
\ No newline at end of file
diff --git a/distribution/tools/plugin-cli/licenses/bc-fips-2.0.0.jar.sha1 b/distribution/tools/plugin-cli/licenses/bc-fips-2.0.0.jar.sha1
new file mode 100644
index 0000000000000..79f0e3e9930bb
--- /dev/null
+++ b/distribution/tools/plugin-cli/licenses/bc-fips-2.0.0.jar.sha1
@@ -0,0 +1 @@
+ee9ac432cf08f9a9ebee35d7cf8a45f94959a7ab
\ No newline at end of file
diff --git a/distribution/tools/plugin-cli/licenses/bcpg-fips-1.0.7.1.jar.sha1 b/distribution/tools/plugin-cli/licenses/bcpg-fips-1.0.7.1.jar.sha1
deleted file mode 100644
index 44cebc7c92d87..0000000000000
--- a/distribution/tools/plugin-cli/licenses/bcpg-fips-1.0.7.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-5e1952428655ea822066f86df2e3ecda8fa0ba2b
\ No newline at end of file
diff --git a/distribution/tools/plugin-cli/licenses/bcpg-fips-2.0.9.jar.sha1 b/distribution/tools/plugin-cli/licenses/bcpg-fips-2.0.9.jar.sha1
new file mode 100644
index 0000000000000..20cdbf6dc8aa8
--- /dev/null
+++ b/distribution/tools/plugin-cli/licenses/bcpg-fips-2.0.9.jar.sha1
@@ -0,0 +1 @@
+f69719ef8dbf34d5f906ce480496446b2fd2ae27
\ No newline at end of file
diff --git a/distribution/tools/upgrade-cli/licenses/jackson-annotations-2.17.1.jar.sha1 b/distribution/tools/upgrade-cli/licenses/jackson-annotations-2.17.1.jar.sha1
deleted file mode 100644
index 4ceead1b7ae4f..0000000000000
--- a/distribution/tools/upgrade-cli/licenses/jackson-annotations-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fca7ef6192c9ad05d07bc50da991bf937a84af3a
\ No newline at end of file
diff --git a/distribution/tools/upgrade-cli/licenses/jackson-annotations-2.17.2.jar.sha1 b/distribution/tools/upgrade-cli/licenses/jackson-annotations-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..411e1d62459fd
--- /dev/null
+++ b/distribution/tools/upgrade-cli/licenses/jackson-annotations-2.17.2.jar.sha1
@@ -0,0 +1 @@
+147b7b9412ffff24339f8aba080b292448e08698
\ No newline at end of file
diff --git a/distribution/tools/upgrade-cli/licenses/jackson-databind-2.17.1.jar.sha1 b/distribution/tools/upgrade-cli/licenses/jackson-databind-2.17.1.jar.sha1
deleted file mode 100644
index 7cf1ac1b60301..0000000000000
--- a/distribution/tools/upgrade-cli/licenses/jackson-databind-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-0524dcbcccdde7d45a679dfc333e4763feb09079
\ No newline at end of file
diff --git a/distribution/tools/upgrade-cli/licenses/jackson-databind-2.17.2.jar.sha1 b/distribution/tools/upgrade-cli/licenses/jackson-databind-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f2b4dbdc5decb
--- /dev/null
+++ b/distribution/tools/upgrade-cli/licenses/jackson-databind-2.17.2.jar.sha1
@@ -0,0 +1 @@
+e6deb029e5901e027c129341fac39e515066b68c
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
index 7c359ed2b652c..4e8c5b98116c1 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -22,7 +22,7 @@ org.gradle.jvmargs=-Xmx3g -XX:+HeapDumpOnOutOfMemoryError -Xss2m \
 options.forkOptions.memoryMaximumSize=3g
 
 # Disable Gradle Enterprise Gradle plugin's test retry
-systemProp.gradle.enterprise.testretry.enabled=false
+systemProp.develocity.testretry.enabled.enabled=false
 
 # Disable duplicate project id detection
 # See https://docs.gradle.org/current/userguide/upgrading_version_6.html#duplicate_project_names_may_cause_publication_to_fail
diff --git a/gradle/ide.gradle b/gradle/ide.gradle
index 14d6b2982ccd0..ea353f8d92bdd 100644
--- a/gradle/ide.gradle
+++ b/gradle/ide.gradle
@@ -28,7 +28,7 @@ allprojects {
   apply plugin: 'idea'
 
   tasks.named('idea').configure {
-    doFirst { throw new GradleException("Use of the 'idea' task has been deprecated. For details on importing into IntelliJ see CONTRIBUTING.md.") }
+    doFirst { throw new GradleException("Use of the 'idea' task has been deprecated. For details on importing into IntelliJ see DEVELOPER_GUIDE.md.") }
   }
 }
 
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index d64cd4917707c..a4b76b9530d66 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 9b0d73222260e..39a291b258efb 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -11,7 +11,7 @@
 
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionSha256Sum=194717442575a6f96e1c1befa2c30e9a4fc90f701d7aee33eb879b79e7ff05c0
+distributionSha256Sum=682b4df7fe5accdca84a4d1ef6a3a6ab096b3efd5edf7de2bd8c758d95a93703
diff --git a/gradlew b/gradlew
index 1aa94a4269074..f5feea6d6b116 100755
--- a/gradlew
+++ b/gradlew
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -84,7 +86,8 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
diff --git a/gradlew.bat b/gradlew.bat
index 6689b85beecde..9b42019c7915b 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +59,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
diff --git a/libs/common/src/main/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessor.java b/libs/common/src/main/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessor.java
index 569f48a8465f3..94ec0db3a9712 100644
--- a/libs/common/src/main/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessor.java
+++ b/libs/common/src/main/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessor.java
@@ -59,6 +59,7 @@ public class ApiAnnotationProcessor extends AbstractProcessor {
     private static final String OPENSEARCH_PACKAGE = "org.opensearch";
 
     private final Set<Element> reported = new HashSet<>();
+    private final Set<Element> validated = new HashSet<>();
     private final Set<AnnotatedConstruct> processed = new HashSet<>();
     private Kind reportFailureAs = Kind.ERROR;
 
@@ -85,6 +86,8 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
         );
 
         for (var element : elements) {
+            validate(element);
+
             if (!checkPackage(element)) {
                 continue;
             }
@@ -100,6 +103,64 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
         return false;
     }
 
+    private void validate(Element element) {
+        // The element was validated already
+        if (validated.contains(element)) {
+            return;
+        }
+
+        validated.add(element);
+
+        final PublicApi publicApi = element.getAnnotation(PublicApi.class);
+        if (publicApi != null) {
+            if (!validateVersion(publicApi.since())) {
+                processingEnv.getMessager()
+                    .printMessage(
+                        reportFailureAs,
+                        "The type " + element + " has @PublicApi annotation with unparseable OpenSearch version: " + publicApi.since()
+                    );
+            }
+        }
+
+        final DeprecatedApi deprecatedApi = element.getAnnotation(DeprecatedApi.class);
+        if (deprecatedApi != null) {
+            if (!validateVersion(deprecatedApi.since())) {
+                processingEnv.getMessager()
+                    .printMessage(
+                        reportFailureAs,
+                        "The type "
+                            + element
+                            + " has @DeprecatedApi annotation with unparseable OpenSearch version: "
+                            + deprecatedApi.since()
+                    );
+            }
+        }
+    }
+
+    private boolean validateVersion(String version) {
+        String[] parts = version.split("[.-]");
+        if (parts.length < 3 || parts.length > 4) {
+            return false;
+        }
+
+        int major = Integer.parseInt(parts[0]);
+        if (major > 3 || major < 0) {
+            return false;
+        }
+
+        int minor = Integer.parseInt(parts[1]);
+        if (minor < 0) {
+            return false;
+        }
+
+        int patch = Integer.parseInt(parts[2]);
+        if (patch < 0) {
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * Check top level executable element
      * @param executable top level executable element
diff --git a/libs/common/src/test/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessorTests.java b/libs/common/src/test/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessorTests.java
index 8d8a4c7895339..716dcc3b9015f 100644
--- a/libs/common/src/test/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessorTests.java
+++ b/libs/common/src/test/java/org/opensearch/common/annotation/processor/ApiAnnotationProcessorTests.java
@@ -473,4 +473,48 @@ public void testPublicApiWithProtectedInterface() {
 
         assertThat(failure.diagnotics(), not(hasItem(matching(Diagnostic.Kind.ERROR))));
     }
+
+    /**
+     * The constructor arguments have relaxed semantics at the moment: those could be not annotated or be annotated as {@link InternalApi}
+     */
+    public void testPublicApiConstructorAnnotatedInternalApi() {
+        final CompilerResult result = compile("PublicApiConstructorAnnotatedInternalApi.java", "NotAnnotated.java");
+        assertThat(result, instanceOf(Failure.class));
+
+        final Failure failure = (Failure) result;
+        assertThat(failure.diagnotics(), hasSize(2));
+
+        assertThat(failure.diagnotics(), not(hasItem(matching(Diagnostic.Kind.ERROR))));
+    }
+
+    public void testPublicApiUnparseableVersion() {
+        final CompilerResult result = compile("PublicApiAnnotatedUnparseable.java");
+        assertThat(result, instanceOf(Failure.class));
+
+        final Failure failure = (Failure) result;
+        assertThat(failure.diagnotics(), hasSize(3));
+
+        assertThat(
+            failure.diagnotics(),
+            hasItem(
+                matching(
+                    Diagnostic.Kind.ERROR,
+                    containsString(
+                        "The type org.opensearch.common.annotation.processor.PublicApiAnnotatedUnparseable has @PublicApi annotation with unparseable OpenSearch version: 2.x"
+                    )
+                )
+            )
+        );
+    }
+
+    public void testPublicApiWithDeprecatedApiMethod() {
+        final CompilerResult result = compile("PublicApiWithDeprecatedApiMethod.java");
+        assertThat(result, instanceOf(Failure.class));
+
+        final Failure failure = (Failure) result;
+        assertThat(failure.diagnotics(), hasSize(2));
+
+        assertThat(failure.diagnotics(), not(hasItem(matching(Diagnostic.Kind.ERROR))));
+    }
+
 }
diff --git a/libs/common/src/test/resources/org/opensearch/common/annotation/processor/InternalApiAnnotated.java b/libs/common/src/test/resources/org/opensearch/common/annotation/processor/InternalApiAnnotated.java
index 9996ba8b736aa..b0b542e127285 100644
--- a/libs/common/src/test/resources/org/opensearch/common/annotation/processor/InternalApiAnnotated.java
+++ b/libs/common/src/test/resources/org/opensearch/common/annotation/processor/InternalApiAnnotated.java
@@ -8,9 +8,9 @@
 
 package org.opensearch.common.annotation.processor;
 
-import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.annotation.InternalApi;
 
-@PublicApi(since = "1.0.0")
+@InternalApi
 public class InternalApiAnnotated {
 
 }
diff --git a/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiAnnotatedUnparseable.java b/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiAnnotatedUnparseable.java
new file mode 100644
index 0000000000000..44779450c9fd1
--- /dev/null
+++ b/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiAnnotatedUnparseable.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.annotation.processor;
+
+import org.opensearch.common.annotation.PublicApi;
+
+@PublicApi(since = "2.x")
+public class PublicApiAnnotatedUnparseable {
+
+}
diff --git a/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiConstructorAnnotatedInternalApi.java b/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiConstructorAnnotatedInternalApi.java
new file mode 100644
index 0000000000000..d355a6b770391
--- /dev/null
+++ b/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiConstructorAnnotatedInternalApi.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.annotation.processor;
+
+import org.opensearch.common.annotation.InternalApi;
+import org.opensearch.common.annotation.PublicApi;
+
+@PublicApi(since = "1.0.0")
+public class PublicApiConstructorAnnotatedInternalApi {
+    /**
+     * The constructors have relaxed semantics at the moment: those could be not annotated or be annotated as {@link InternalApi}
+     */
+    @InternalApi
+    public PublicApiConstructorAnnotatedInternalApi(NotAnnotated arg) {}
+}
diff --git a/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiWithDeprecatedApiMethod.java b/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiWithDeprecatedApiMethod.java
new file mode 100644
index 0000000000000..3cb28d3360830
--- /dev/null
+++ b/libs/common/src/test/resources/org/opensearch/common/annotation/processor/PublicApiWithDeprecatedApiMethod.java
@@ -0,0 +1,20 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.annotation.processor;
+
+import org.opensearch.common.annotation.DeprecatedApi;
+import org.opensearch.common.annotation.PublicApi;
+
+@PublicApi(since = "1.0.0")
+public class PublicApiWithDeprecatedApiMethod {
+    @DeprecatedApi(since = "0.1.0")
+    public void method() {
+
+    }
+}
diff --git a/libs/core/licenses/jackson-core-2.17.1.jar.sha1 b/libs/core/licenses/jackson-core-2.17.1.jar.sha1
deleted file mode 100644
index 82dab5981e652..0000000000000
--- a/libs/core/licenses/jackson-core-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-5e52a11644cd59a28ef79f02bddc2cc3bab45edb
\ No newline at end of file
diff --git a/libs/core/licenses/jackson-core-2.17.2.jar.sha1 b/libs/core/licenses/jackson-core-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..e15f2340980bc
--- /dev/null
+++ b/libs/core/licenses/jackson-core-2.17.2.jar.sha1
@@ -0,0 +1 @@
+969a35cb35c86512acbadcdbbbfb044c877db814
\ No newline at end of file
diff --git a/libs/core/licenses/lucene-core-9.10.0.jar.sha1 b/libs/core/licenses/lucene-core-9.10.0.jar.sha1
deleted file mode 100644
index 31b6bcd29f418..0000000000000
--- a/libs/core/licenses/lucene-core-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-64e5624754d59386be5d9159c68f81ff96298704
\ No newline at end of file
diff --git a/libs/core/licenses/lucene-core-9.11.1.jar.sha1 b/libs/core/licenses/lucene-core-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..82de964a2b755
--- /dev/null
+++ b/libs/core/licenses/lucene-core-9.11.1.jar.sha1
@@ -0,0 +1 @@
+8f52ba14b21774f41ce33cf5ca111cbdefeed7f9
\ No newline at end of file
diff --git a/libs/core/src/main/java/org/opensearch/Version.java b/libs/core/src/main/java/org/opensearch/Version.java
index be34553aa214c..4ab6542654f05 100644
--- a/libs/core/src/main/java/org/opensearch/Version.java
+++ b/libs/core/src/main/java/org/opensearch/Version.java
@@ -97,6 +97,9 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final Version V_1_3_15 = new Version(1031599, org.apache.lucene.util.Version.LUCENE_8_10_1);
     public static final Version V_1_3_16 = new Version(1031699, org.apache.lucene.util.Version.LUCENE_8_10_1);
     public static final Version V_1_3_17 = new Version(1031799, org.apache.lucene.util.Version.LUCENE_8_10_1);
+    public static final Version V_1_3_18 = new Version(1031899, org.apache.lucene.util.Version.LUCENE_8_10_1);
+    public static final Version V_1_3_19 = new Version(1031999, org.apache.lucene.util.Version.LUCENE_8_10_1);
+    public static final Version V_1_3_20 = new Version(1032099, org.apache.lucene.util.Version.LUCENE_8_10_1);
     public static final Version V_2_0_0 = new Version(2000099, org.apache.lucene.util.Version.LUCENE_9_1_0);
     public static final Version V_2_0_1 = new Version(2000199, org.apache.lucene.util.Version.LUCENE_9_1_0);
     public static final Version V_2_0_2 = new Version(2000299, org.apache.lucene.util.Version.LUCENE_9_1_0);
@@ -132,7 +135,12 @@ public class Version implements Comparable<Version>, ToXContentFragment {
     public static final Version V_2_14_0 = new Version(2140099, org.apache.lucene.util.Version.LUCENE_9_10_0);
     public static final Version V_2_14_1 = new Version(2140199, org.apache.lucene.util.Version.LUCENE_9_10_0);
     public static final Version V_2_15_0 = new Version(2150099, org.apache.lucene.util.Version.LUCENE_9_10_0);
-    public static final Version CURRENT = V_2_15_0;
+    public static final Version V_2_15_1 = new Version(2150199, org.apache.lucene.util.Version.LUCENE_9_10_0);
+    public static final Version V_2_16_0 = new Version(2160099, org.apache.lucene.util.Version.LUCENE_9_11_1);
+    public static final Version V_2_16_1 = new Version(2160199, org.apache.lucene.util.Version.LUCENE_9_11_1);
+    public static final Version V_2_17_0 = new Version(2170099, org.apache.lucene.util.Version.LUCENE_9_11_1);
+    public static final Version V_2_18_0 = new Version(2180099, org.apache.lucene.util.Version.LUCENE_9_11_1);
+    public static final Version CURRENT = V_2_18_0;
 
     public static Version fromId(int id) {
         final Version known = LegacyESVersion.idToVersion.get(id);
diff --git a/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamOutput.java b/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamOutput.java
index b7599265aece3..cac8ddc8f94e3 100644
--- a/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamOutput.java
+++ b/libs/core/src/main/java/org/opensearch/core/common/io/stream/StreamOutput.java
@@ -633,7 +633,7 @@ public final <K, V> void writeMapOfLists(final Map<K, List<V>> map, final Writer
      * @param keyWriter The key writer
      * @param valueWriter The value writer
      */
-    public final <K, V> void writeMap(final Map<K, V> map, final Writer<K> keyWriter, final Writer<V> valueWriter) throws IOException {
+    public <K, V> void writeMap(final Map<K, V> map, final Writer<K> keyWriter, final Writer<V> valueWriter) throws IOException {
         writeVInt(map.size());
         for (final Map.Entry<K, V> entry : map.entrySet()) {
             keyWriter.write(this, entry.getKey());
@@ -969,9 +969,13 @@ public <T extends Writeable> void writeOptionalArray(@Nullable T[] array) throws
     }
 
     public void writeOptionalWriteable(@Nullable Writeable writeable) throws IOException {
+        writeOptionalWriteable((out, writable) -> writable.writeTo(out), writeable);
+    }
+
+    public <T extends Writeable> void writeOptionalWriteable(final Writer<T> writer, @Nullable T writeable) throws IOException {
         if (writeable != null) {
             writeBoolean(true);
-            writeable.writeTo(this);
+            writer.write(this, writeable);
         } else {
             writeBoolean(false);
         }
diff --git a/libs/core/src/main/java/org/opensearch/core/compress/CompressorRegistry.java b/libs/core/src/main/java/org/opensearch/core/compress/CompressorRegistry.java
index af09a7aebba79..711f56c9f3e3b 100644
--- a/libs/core/src/main/java/org/opensearch/core/compress/CompressorRegistry.java
+++ b/libs/core/src/main/java/org/opensearch/core/compress/CompressorRegistry.java
@@ -78,6 +78,19 @@ public static Compressor compressor(final BytesReference bytes) {
         return null;
     }
 
+    /**
+     * @param bytes The bytes to check the compression for
+     * @return The detected compressor. If no compressor detected then return NoneCompressor.
+     */
+    public static Compressor compressorForWritable(final BytesReference bytes) {
+        for (Compressor compressor : registeredCompressors.values()) {
+            if (compressor.isCompressed(bytes) == true) {
+                return compressor;
+            }
+        }
+        return CompressorRegistry.none();
+    }
+
     /** Decompress the provided {@link BytesReference}. */
     public static BytesReference uncompress(BytesReference bytes) throws IOException {
         Compressor compressor = compressor(bytes);
diff --git a/libs/core/src/main/java/org/opensearch/core/tasks/resourcetracker/ResourceUsageInfo.java b/libs/core/src/main/java/org/opensearch/core/tasks/resourcetracker/ResourceUsageInfo.java
index a278b61894a65..e7b51c3389b52 100644
--- a/libs/core/src/main/java/org/opensearch/core/tasks/resourcetracker/ResourceUsageInfo.java
+++ b/libs/core/src/main/java/org/opensearch/core/tasks/resourcetracker/ResourceUsageInfo.java
@@ -104,6 +104,10 @@ public long getTotalValue() {
             return endValue.get() - startValue;
         }
 
+        public long getStartValue() {
+            return startValue;
+        }
+
         @Override
         public String toString() {
             return String.valueOf(getTotalValue());
diff --git a/libs/core/src/main/java/org/opensearch/core/tasks/resourcetracker/TaskResourceInfo.java b/libs/core/src/main/java/org/opensearch/core/tasks/resourcetracker/TaskResourceInfo.java
new file mode 100644
index 0000000000000..373cdbfa7e9a1
--- /dev/null
+++ b/libs/core/src/main/java/org/opensearch/core/tasks/resourcetracker/TaskResourceInfo.java
@@ -0,0 +1,225 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.core.tasks.resourcetracker;
+
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.core.ParseField;
+import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ConstructingObjectParser;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Objects;
+
+import static org.opensearch.core.xcontent.ConstructingObjectParser.constructorArg;
+
+/**
+ * Task resource usage information with minimal information about the task
+ * <p>
+ * Writeable TaskResourceInfo objects are used to represent resource usage
+ * information of running tasks, which can be propagated to coordinator node
+ * to infer query-level resource usage
+ *
+ *  @opensearch.api
+ */
+@PublicApi(since = "2.15.0")
+public class TaskResourceInfo implements Writeable, ToXContentObject {
+    private final String action;
+    private final long taskId;
+    private final long parentTaskId;
+    private final String nodeId;
+    private final TaskResourceUsage taskResourceUsage;
+
+    private static final ParseField ACTION = new ParseField("action");
+    private static final ParseField TASK_ID = new ParseField("taskId");
+    private static final ParseField PARENT_TASK_ID = new ParseField("parentTaskId");
+    private static final ParseField NODE_ID = new ParseField("nodeId");
+    private static final ParseField TASK_RESOURCE_USAGE = new ParseField("taskResourceUsage");
+
+    public TaskResourceInfo(
+        final String action,
+        final long taskId,
+        final long parentTaskId,
+        final String nodeId,
+        final TaskResourceUsage taskResourceUsage
+    ) {
+        this.action = action;
+        this.taskId = taskId;
+        this.parentTaskId = parentTaskId;
+        this.nodeId = nodeId;
+        this.taskResourceUsage = taskResourceUsage;
+    }
+
+    public static final ConstructingObjectParser<TaskResourceInfo, Void> PARSER = new ConstructingObjectParser<>(
+        "task_resource_info",
+        a -> new Builder().setAction((String) a[0])
+            .setTaskId((Long) a[1])
+            .setParentTaskId((Long) a[2])
+            .setNodeId((String) a[3])
+            .setTaskResourceUsage((TaskResourceUsage) a[4])
+            .build()
+    );
+
+    static {
+        PARSER.declareString(constructorArg(), ACTION);
+        PARSER.declareLong(constructorArg(), TASK_ID);
+        PARSER.declareLong(constructorArg(), PARENT_TASK_ID);
+        PARSER.declareString(constructorArg(), NODE_ID);
+        PARSER.declareObject(constructorArg(), TaskResourceUsage.PARSER, TASK_RESOURCE_USAGE);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(ACTION.getPreferredName(), this.action);
+        builder.field(TASK_ID.getPreferredName(), this.taskId);
+        builder.field(PARENT_TASK_ID.getPreferredName(), this.parentTaskId);
+        builder.field(NODE_ID.getPreferredName(), this.nodeId);
+        builder.startObject(TASK_RESOURCE_USAGE.getPreferredName());
+        this.taskResourceUsage.toXContent(builder, params);
+        builder.endObject();
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * Builder for {@link TaskResourceInfo}
+     */
+    public static class Builder {
+        private TaskResourceUsage taskResourceUsage;
+        private String action;
+        private long taskId;
+        private long parentTaskId;
+        private String nodeId;
+
+        public Builder setTaskResourceUsage(final TaskResourceUsage taskResourceUsage) {
+            this.taskResourceUsage = taskResourceUsage;
+            return this;
+        }
+
+        public Builder setAction(final String action) {
+            this.action = action;
+            return this;
+        }
+
+        public Builder setTaskId(final long taskId) {
+            this.taskId = taskId;
+            return this;
+        }
+
+        public Builder setParentTaskId(final long parentTaskId) {
+            this.parentTaskId = parentTaskId;
+            return this;
+        }
+
+        public Builder setNodeId(final String nodeId) {
+            this.nodeId = nodeId;
+            return this;
+        }
+
+        public TaskResourceInfo build() {
+            return new TaskResourceInfo(action, taskId, parentTaskId, nodeId, taskResourceUsage);
+        }
+    }
+
+    /**
+     * Read task info from a stream.
+     *
+     * @param in StreamInput to read
+     * @return {@link TaskResourceInfo}
+     * @throws IOException IOException
+     */
+    public static TaskResourceInfo readFromStream(StreamInput in) throws IOException {
+        return new TaskResourceInfo.Builder().setAction(in.readString())
+            .setTaskId(in.readLong())
+            .setParentTaskId(in.readLong())
+            .setNodeId(in.readString())
+            .setTaskResourceUsage(TaskResourceUsage.readFromStream(in))
+            .build();
+    }
+
+    /**
+     * Get TaskResourceUsage
+     *
+     * @return taskResourceUsage
+     */
+    public TaskResourceUsage getTaskResourceUsage() {
+        return taskResourceUsage;
+    }
+
+    /**
+     * Get parent task id
+     *
+     * @return parent task id
+     */
+    public long getParentTaskId() {
+        return parentTaskId;
+    }
+
+    /**
+     * Get task id
+     * @return task id
+     */
+    public long getTaskId() {
+        return taskId;
+    }
+
+    /**
+     * Get node id
+     * @return node id
+     */
+    public String getNodeId() {
+        return nodeId;
+    }
+
+    /**
+     * Get task action
+     * @return task action
+     */
+    public String getAction() {
+        return action;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(action);
+        out.writeLong(taskId);
+        out.writeLong(parentTaskId);
+        out.writeString(nodeId);
+        taskResourceUsage.writeTo(out);
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(MediaTypeRegistry.JSON, this);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null || obj.getClass() != TaskResourceInfo.class) {
+            return false;
+        }
+        TaskResourceInfo other = (TaskResourceInfo) obj;
+        return action.equals(other.action)
+            && taskId == other.taskId
+            && parentTaskId == other.parentTaskId
+            && Objects.equals(nodeId, other.nodeId)
+            && taskResourceUsage.equals(other.taskResourceUsage);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(action, taskId, parentTaskId, nodeId, taskResourceUsage);
+    }
+}
diff --git a/libs/core/src/main/java/org/opensearch/core/xcontent/AbstractXContentParser.java b/libs/core/src/main/java/org/opensearch/core/xcontent/AbstractXContentParser.java
index 4efaacecd0e67..4605aa684db1c 100644
--- a/libs/core/src/main/java/org/opensearch/core/xcontent/AbstractXContentParser.java
+++ b/libs/core/src/main/java/org/opensearch/core/xcontent/AbstractXContentParser.java
@@ -375,7 +375,7 @@ private static void skipToListStart(XContentParser parser) throws IOException {
         }
     }
 
-    // read a list without bounds checks, assuming the the current parser is always on an array start
+    // read a list without bounds checks, assuming the current parser is always on an array start
     private static List<Object> readListUnsafe(XContentParser parser, Supplier<Map<String, Object>> mapFactory) throws IOException {
         assert parser.currentToken() == Token.START_ARRAY;
         ArrayList<Object> list = new ArrayList<>();
diff --git a/libs/core/src/main/java/org/opensearch/core/xcontent/XContentBuilder.java b/libs/core/src/main/java/org/opensearch/core/xcontent/XContentBuilder.java
index 976f353100c55..552945d085884 100644
--- a/libs/core/src/main/java/org/opensearch/core/xcontent/XContentBuilder.java
+++ b/libs/core/src/main/java/org/opensearch/core/xcontent/XContentBuilder.java
@@ -157,6 +157,9 @@ public static XContentBuilder builder(XContent xContent, Set<String> includes, S
 
     /**
      * Returns a string representation of the builder (only applicable for text based xcontent).
+     * Note: explicitly or implicitly (from debugger) calling toString() could cause XContentBuilder
+     * to close which is a side effect done by @see BytesReference#bytes().
+     * Trying to write more contents after toString() will cause NPE. Use it with caution.
      */
     @Override
     public String toString() {
diff --git a/libs/core/src/main/java/org/opensearch/core/xcontent/filtering/FilterPath.java b/libs/core/src/main/java/org/opensearch/core/xcontent/filtering/FilterPath.java
index 2fa49233a4480..5ca5e4de04145 100644
--- a/libs/core/src/main/java/org/opensearch/core/xcontent/filtering/FilterPath.java
+++ b/libs/core/src/main/java/org/opensearch/core/xcontent/filtering/FilterPath.java
@@ -46,7 +46,6 @@
 public class FilterPath {
 
     static final FilterPath EMPTY = new FilterPath();
-
     private final String filter;
     private final String segment;
     private final FilterPath next;
@@ -99,32 +98,29 @@ public static FilterPath[] compile(Set<String> filters) {
 
         List<FilterPath> paths = new ArrayList<>();
         for (String filter : filters) {
-            if (filter != null) {
+            if (filter != null && !filter.isEmpty()) {
                 filter = filter.trim();
                 if (filter.length() > 0) {
-                    paths.add(parse(filter, filter));
+                    paths.add(parse(filter));
                 }
             }
         }
         return paths.toArray(new FilterPath[paths.size()]);
     }
 
-    private static FilterPath parse(final String filter, final String segment) {
-        int end = segment.length();
-
-        for (int i = 0; i < end;) {
-            char c = segment.charAt(i);
+    private static FilterPath parse(final String filter) {
+        // Split the filter into segments using a regex
+        // that avoids splitting escaped dots.
+        String[] segments = filter.split("(?<!\\\\)\\.");
+        FilterPath next = EMPTY;
 
-            if (c == '.') {
-                String current = segment.substring(0, i).replaceAll("\\\\.", ".");
-                return new FilterPath(filter, current, parse(filter, segment.substring(i + 1)));
-            }
-            ++i;
-            if ((c == '\\') && (i < end) && (segment.charAt(i) == '.')) {
-                ++i;
-            }
+        for (int i = segments.length - 1; i >= 0; i--) {
+            // Replace escaped dots with actual dots in the current segment.
+            String segment = segments[i].replaceAll("\\\\.", ".");
+            next = new FilterPath(filter, segment, next);
         }
-        return new FilterPath(filter, segment.replaceAll("\\\\.", "."), EMPTY);
+
+        return next;
     }
 
     @Override
diff --git a/libs/core/src/test/java/org/opensearch/core/xcontent/filtering/FilterPathTests.java b/libs/core/src/test/java/org/opensearch/core/xcontent/filtering/FilterPathTests.java
index 0c5a17b70a956..d3191609f6119 100644
--- a/libs/core/src/test/java/org/opensearch/core/xcontent/filtering/FilterPathTests.java
+++ b/libs/core/src/test/java/org/opensearch/core/xcontent/filtering/FilterPathTests.java
@@ -35,6 +35,7 @@
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.test.OpenSearchTestCase;
 
+import java.util.HashSet;
 import java.util.Set;
 
 import static java.util.Collections.singleton;
@@ -369,4 +370,20 @@ public void testMultipleFilterPaths() {
         assertThat(filterPath.getSegment(), is(emptyString()));
         assertSame(filterPath, FilterPath.EMPTY);
     }
+
+    public void testCompileWithEmptyString() {
+        Set<String> filters = new HashSet<>();
+        filters.add("");
+        FilterPath[] filterPaths = FilterPath.compile(filters);
+        assertNotNull(filterPaths);
+        assertEquals(0, filterPaths.length);
+    }
+
+    public void testCompileWithNull() {
+        Set<String> filters = new HashSet<>();
+        filters.add(null);
+        FilterPath[] filterPaths = FilterPath.compile(filters);
+        assertNotNull(filterPaths);
+        assertEquals(0, filterPaths.length);
+    }
 }
diff --git a/libs/geo/src/main/java/org/opensearch/geometry/utils/WellKnownText.java b/libs/geo/src/main/java/org/opensearch/geometry/utils/WellKnownText.java
index ed1d63e6d4fef..8ad135b8bc1ca 100644
--- a/libs/geo/src/main/java/org/opensearch/geometry/utils/WellKnownText.java
+++ b/libs/geo/src/main/java/org/opensearch/geometry/utils/WellKnownText.java
@@ -49,8 +49,10 @@
 import java.io.StreamTokenizer;
 import java.io.StringReader;
 import java.text.ParseException;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Deque;
 import java.util.List;
 import java.util.Locale;
 
@@ -67,6 +69,7 @@ public class WellKnownText {
     public static final String RPAREN = ")";
     public static final String COMMA = ",";
     public static final String NAN = "NaN";
+    public static final int MAX_DEPTH_OF_GEO_COLLECTION = 1000;
 
     private final String NUMBER = "<NUMBER>";
     private final String EOF = "END-OF-STREAM";
@@ -278,6 +281,16 @@ public Geometry fromWKT(String wkt) throws IOException, ParseException {
      */
     private Geometry parseGeometry(StreamTokenizer stream) throws IOException, ParseException {
         final String type = nextWord(stream).toLowerCase(Locale.ROOT);
+        switch (type) {
+            case "geometrycollection":
+                return parseGeometryCollection(stream);
+            default:
+                return parseSimpleGeometry(stream, type);
+        }
+    }
+
+    private Geometry parseSimpleGeometry(StreamTokenizer stream, String type) throws IOException, ParseException {
+        assert "geometrycollection".equals(type) == false;
         switch (type) {
             case "point":
                 return parsePoint(stream);
@@ -294,7 +307,7 @@ private Geometry parseGeometry(StreamTokenizer stream) throws IOException, Parse
             case "bbox":
                 return parseBBox(stream);
             case "geometrycollection":
-                return parseGeometryCollection(stream);
+                throw new IllegalStateException("Unexpected type: geometrycollection");
             case "circle": // Not part of the standard, but we need it for internal serialization
                 return parseCircle(stream);
         }
@@ -305,12 +318,56 @@ private GeometryCollection<Geometry> parseGeometryCollection(StreamTokenizer str
         if (nextEmptyOrOpen(stream).equals(EMPTY)) {
             return GeometryCollection.EMPTY;
         }
-        List<Geometry> shapes = new ArrayList<>();
-        shapes.add(parseGeometry(stream));
-        while (nextCloserOrComma(stream).equals(COMMA)) {
-            shapes.add(parseGeometry(stream));
+
+        List<Geometry> topLevelShapes = new ArrayList<>();
+        Deque<List<Geometry>> deque = new ArrayDeque<>();
+        deque.push(topLevelShapes);
+        boolean isFirstIteration = true;
+        List<Geometry> currentLevelShapes = null;
+        while (!deque.isEmpty()) {
+            List<Geometry> previousShapes = deque.pop();
+            if (currentLevelShapes != null) {
+                previousShapes.add(new GeometryCollection<>(currentLevelShapes));
+            }
+            currentLevelShapes = previousShapes;
+
+            if (isFirstIteration == true) {
+                isFirstIteration = false;
+            } else {
+                if (nextCloserOrComma(stream).equals(COMMA) == false) {
+                    // Done with current level, continue with parent level
+                    continue;
+                }
+            }
+            while (true) {
+                final String type = nextWord(stream).toLowerCase(Locale.ROOT);
+                if (type.equals("geometrycollection")) {
+                    if (nextEmptyOrOpen(stream).equals(EMPTY) == false) {
+                        // GEOMETRYCOLLECTION() -> 1 depth, GEOMETRYCOLLECTION(GEOMETRYCOLLECTION()) -> 2 depth
+                        // When parsing the top level geometry collection, the queue size is zero.
+                        // When max depth is 1, we don't want to push any sub geometry collection in the queue.
+                        // Therefore, we subtract 2 from max depth.
+                        if (deque.size() >= MAX_DEPTH_OF_GEO_COLLECTION - 2) {
+                            throw new IllegalArgumentException(
+                                "a geometry collection with a depth greater than " + MAX_DEPTH_OF_GEO_COLLECTION + " is not supported"
+                            );
+                        }
+                        deque.push(currentLevelShapes);
+                        currentLevelShapes = new ArrayList<>();
+                        continue;
+                    }
+                    currentLevelShapes.add(GeometryCollection.EMPTY);
+                } else {
+                    currentLevelShapes.add(parseSimpleGeometry(stream, type));
+                }
+
+                if (nextCloserOrComma(stream).equals(COMMA) == false) {
+                    break;
+                }
+            }
         }
-        return new GeometryCollection<>(shapes);
+
+        return new GeometryCollection<>(topLevelShapes);
     }
 
     private Point parsePoint(StreamTokenizer stream) throws IOException, ParseException {
diff --git a/libs/geo/src/test/java/org/opensearch/geometry/GeometryCollectionTests.java b/libs/geo/src/test/java/org/opensearch/geometry/GeometryCollectionTests.java
index 631b6456a77da..cd8bb8f585966 100644
--- a/libs/geo/src/test/java/org/opensearch/geometry/GeometryCollectionTests.java
+++ b/libs/geo/src/test/java/org/opensearch/geometry/GeometryCollectionTests.java
@@ -62,6 +62,11 @@ public void testBasicSerialization() throws IOException, ParseException {
 
         assertEquals("GEOMETRYCOLLECTION EMPTY", wkt.toWKT(GeometryCollection.EMPTY));
         assertEquals(GeometryCollection.EMPTY, wkt.fromWKT("GEOMETRYCOLLECTION EMPTY)"));
+
+        assertEquals(
+            new GeometryCollection<Geometry>(Arrays.asList(GeometryCollection.EMPTY)),
+            wkt.fromWKT("GEOMETRYCOLLECTION (GEOMETRYCOLLECTION EMPTY)")
+        );
     }
 
     @SuppressWarnings("ConstantConditions")
@@ -86,4 +91,29 @@ public void testInitValidation() {
 
         new StandardValidator(true).validate(new GeometryCollection<Geometry>(Collections.singletonList(new Point(20, 10, 30))));
     }
+
+    public void testDeeplyNestedGeometryCollection() throws IOException, ParseException {
+        WellKnownText wkt = new WellKnownText(true, new GeographyValidator(true));
+        StringBuilder validGeometryCollectionHead = new StringBuilder("GEOMETRYCOLLECTION");
+        StringBuilder validGeometryCollectionTail = new StringBuilder(" EMPTY");
+        for (int i = 0; i < WellKnownText.MAX_DEPTH_OF_GEO_COLLECTION - 1; i++) {
+            validGeometryCollectionHead.append(" (GEOMETRYCOLLECTION");
+            validGeometryCollectionTail.append(")");
+        }
+        // Expect no exception
+        wkt.fromWKT(validGeometryCollectionHead.append(validGeometryCollectionTail).toString());
+
+        StringBuilder invalidGeometryCollectionHead = new StringBuilder("GEOMETRYCOLLECTION");
+        StringBuilder invalidGeometryCollectionTail = new StringBuilder(" EMPTY");
+        for (int i = 0; i < WellKnownText.MAX_DEPTH_OF_GEO_COLLECTION; i++) {
+            invalidGeometryCollectionHead.append(" (GEOMETRYCOLLECTION");
+            invalidGeometryCollectionTail.append(")");
+        }
+
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> wkt.fromWKT(invalidGeometryCollectionHead.append(invalidGeometryCollectionTail).toString())
+        );
+        assertEquals("a geometry collection with a depth greater than 1000 is not supported", ex.getMessage());
+    }
 }
diff --git a/libs/grok/src/main/java/org/opensearch/grok/Grok.java b/libs/grok/src/main/java/org/opensearch/grok/Grok.java
index 7aa3347ba4f4b..aa5b1a936b99d 100644
--- a/libs/grok/src/main/java/org/opensearch/grok/Grok.java
+++ b/libs/grok/src/main/java/org/opensearch/grok/Grok.java
@@ -37,14 +37,18 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Stack;
+import java.util.Set;
 import java.util.function.Consumer;
 
 import org.jcodings.specific.UTF8Encoding;
@@ -86,6 +90,7 @@ public final class Grok {
         UTF8Encoding.INSTANCE,
         Syntax.DEFAULT
     );
+    private static final int MAX_PATTERN_DEPTH_SIZE = 500;
 
     private static final int MAX_TO_REGEX_ITERATIONS = 100_000; // sanity limit
 
@@ -128,7 +133,7 @@ private Grok(
             expressionBytes.length,
             Option.DEFAULT,
             UTF8Encoding.INSTANCE,
-            message -> logCallBack.accept(message)
+            logCallBack::accept
         );
 
         List<GrokCaptureConfig> captureConfig = new ArrayList<>();
@@ -144,7 +149,7 @@ private Grok(
      */
     private void validatePatternBank() {
         for (String patternName : patternBank.keySet()) {
-            validatePatternBank(patternName, new Stack<>());
+            validatePatternBank(patternName);
         }
     }
 
@@ -156,33 +161,84 @@ private void validatePatternBank() {
      * a reference to another named pattern. This method will navigate to all these named patterns and
      * check for a circular reference.
      */
-    private void validatePatternBank(String patternName, Stack<String> path) {
-        String pattern = patternBank.get(patternName);
-        boolean isSelfReference = pattern.contains("%{" + patternName + "}") || pattern.contains("%{" + patternName + ":");
-        if (isSelfReference) {
-            throwExceptionForCircularReference(patternName, pattern);
-        } else if (path.contains(patternName)) {
-            // current pattern name is already in the path, fetch its predecessor
-            String prevPatternName = path.pop();
-            String prevPattern = patternBank.get(prevPatternName);
-            throwExceptionForCircularReference(prevPatternName, prevPattern, patternName, path);
-        }
-        path.push(patternName);
-        for (int i = pattern.indexOf("%{"); i != -1; i = pattern.indexOf("%{", i + 1)) {
-            int begin = i + 2;
-            int syntaxEndIndex = pattern.indexOf('}', begin);
-            if (syntaxEndIndex == -1) {
-                throw new IllegalArgumentException("Malformed pattern [" + patternName + "][" + pattern + "]");
+    private void validatePatternBank(String initialPatternName) {
+        Deque<Frame> stack = new ArrayDeque<>();
+        Set<String> visitedPatterns = new HashSet<>();
+        Map<String, List<String>> pathMap = new HashMap<>();
+
+        List<String> initialPath = new ArrayList<>();
+        initialPath.add(initialPatternName);
+        pathMap.put(initialPatternName, initialPath);
+        stack.push(new Frame(initialPatternName, initialPath, 0));
+
+        while (!stack.isEmpty()) {
+            Frame frame = stack.peek();
+            String patternName = frame.patternName;
+            List<String> path = frame.path;
+            int startIndex = frame.startIndex;
+            String pattern = patternBank.get(patternName);
+
+            if (visitedPatterns.contains(patternName)) {
+                stack.pop();
+                continue;
+            }
+
+            visitedPatterns.add(patternName);
+            boolean foundDependency = false;
+
+            for (int i = startIndex; i < pattern.length(); i++) {
+                if (pattern.startsWith("%{", i)) {
+                    int begin = i + 2;
+                    int syntaxEndIndex = pattern.indexOf('}', begin);
+                    if (syntaxEndIndex == -1) {
+                        throw new IllegalArgumentException("Malformed pattern [" + patternName + "][" + pattern + "]");
+                    }
+
+                    int semanticNameIndex = pattern.indexOf(':', begin);
+                    int end = semanticNameIndex == -1 ? syntaxEndIndex : Math.min(syntaxEndIndex, semanticNameIndex);
+
+                    String dependsOnPattern = pattern.substring(begin, end);
+
+                    if (dependsOnPattern.equals(patternName)) {
+                        throwExceptionForCircularReference(patternName, pattern);
+                    }
+
+                    if (pathMap.containsKey(dependsOnPattern)) {
+                        throwExceptionForCircularReference(patternName, pattern, dependsOnPattern, path.subList(0, path.size() - 1));
+                    }
+
+                    List<String> newPath = new ArrayList<>(path);
+                    newPath.add(dependsOnPattern);
+                    pathMap.put(dependsOnPattern, newPath);
+
+                    stack.push(new Frame(dependsOnPattern, newPath, 0));
+                    frame.startIndex = i + 1;
+                    foundDependency = true;
+                    break;
+                }
             }
-            int semanticNameIndex = pattern.indexOf(':', begin);
-            int end = syntaxEndIndex;
-            if (semanticNameIndex != -1) {
-                end = Math.min(syntaxEndIndex, semanticNameIndex);
+
+            if (!foundDependency) {
+                pathMap.remove(patternName);
+                stack.pop();
+            }
+
+            if (stack.size() > MAX_PATTERN_DEPTH_SIZE) {
+                throw new IllegalArgumentException("Pattern references exceeded maximum depth of " + MAX_PATTERN_DEPTH_SIZE);
             }
-            String dependsOnPattern = pattern.substring(begin, end);
-            validatePatternBank(dependsOnPattern, path);
         }
-        path.pop();
+    }
+
+    private static class Frame {
+        String patternName;
+        List<String> path;
+        int startIndex;
+
+        Frame(String patternName, List<String> path, int startIndex) {
+            this.patternName = patternName;
+            this.path = path;
+            this.startIndex = startIndex;
+        }
     }
 
     private static void throwExceptionForCircularReference(String patternName, String pattern) {
@@ -192,13 +248,13 @@ private static void throwExceptionForCircularReference(String patternName, Strin
     private static void throwExceptionForCircularReference(
         String patternName,
         String pattern,
-        String originPatterName,
-        Stack<String> path
+        String originPatternName,
+        List<String> path
     ) {
         StringBuilder message = new StringBuilder("circular reference in pattern [");
         message.append(patternName).append("][").append(pattern).append("]");
-        if (originPatterName != null) {
-            message.append(" back to pattern [").append(originPatterName).append("]");
+        if (originPatternName != null) {
+            message.append(" back to pattern [").append(originPatternName).append("]");
         }
         if (path != null && path.size() > 1) {
             message.append(" via patterns [").append(String.join("=>", path)).append("]");
@@ -217,9 +273,7 @@ private String groupMatch(String name, Region region, String pattern) {
             int begin = region.getBeg(number);
             int end = region.getEnd(number);
             return new String(pattern.getBytes(StandardCharsets.UTF_8), begin, end - begin, StandardCharsets.UTF_8);
-        } catch (StringIndexOutOfBoundsException e) {
-            return null;
-        } catch (ValueException e) {
+        } catch (StringIndexOutOfBoundsException | ValueException e) {
             return null;
         }
     }
diff --git a/libs/grok/src/test/java/org/opensearch/grok/GrokTests.java b/libs/grok/src/test/java/org/opensearch/grok/GrokTests.java
index a37689e051c67..8476d541aa46e 100644
--- a/libs/grok/src/test/java/org/opensearch/grok/GrokTests.java
+++ b/libs/grok/src/test/java/org/opensearch/grok/GrokTests.java
@@ -377,6 +377,16 @@ public void testCircularReference() {
             "circular reference in pattern [NAME5][!!!%{NAME1}!!!] back to pattern [NAME1] " + "via patterns [NAME1=>NAME2=>NAME3=>NAME4]",
             e.getMessage()
         );
+
+        e = expectThrows(IllegalArgumentException.class, () -> {
+            Map<String, String> bank = new TreeMap<>();
+            for (int i = 1; i <= 501; i++) {
+                bank.put("NAME" + i, "!!!%{NAME" + (i + 1) + "}!!!");
+            }
+            String pattern = "%{NAME1}";
+            new Grok(bank, pattern, false, logger::warn);
+        });
+        assertEquals("Pattern references exceeded maximum depth of 500", e.getMessage());
     }
 
     public void testMalformedPattern() {
diff --git a/libs/secure-sm/src/main/java/org/opensearch/secure_sm/ThreadContextPermission.java b/libs/secure-sm/src/main/java/org/opensearch/secure_sm/ThreadContextPermission.java
new file mode 100644
index 0000000000000..2f33eb513c165
--- /dev/null
+++ b/libs/secure-sm/src/main/java/org/opensearch/secure_sm/ThreadContextPermission.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.secure_sm;
+
+import java.security.BasicPermission;
+
+/**
+ * Permission to utilize methods in the ThreadContext class that are normally not accessible
+ *
+ * @see ThreadGroup
+ * @see SecureSM
+ */
+public final class ThreadContextPermission extends BasicPermission {
+
+    /**
+     * Creates a new ThreadContextPermission object.
+     *
+     * @param name target name
+     */
+    public ThreadContextPermission(String name) {
+        super(name);
+    }
+
+    /**
+     * Creates a new ThreadContextPermission object.
+     * This constructor exists for use by the {@code Policy} object to instantiate new Permission objects.
+     *
+     * @param name target name
+     * @param actions ignored
+     */
+    public ThreadContextPermission(String name, String actions) {
+        super(name, actions);
+    }
+}
diff --git a/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/DefaultMetricsRegistry.java b/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/DefaultMetricsRegistry.java
index c861c21f89fc5..bcf5c163cb91f 100644
--- a/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/DefaultMetricsRegistry.java
+++ b/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/DefaultMetricsRegistry.java
@@ -48,6 +48,11 @@ public Closeable createGauge(String name, String description, String unit, Suppl
         return metricsTelemetry.createGauge(name, description, unit, valueProvider, tags);
     }
 
+    @Override
+    public Closeable createGauge(String name, String description, String unit, Supplier<TaggedMeasurement> value) {
+        return metricsTelemetry.createGauge(name, description, unit, value);
+    }
+
     @Override
     public void close() throws IOException {
         metricsTelemetry.close();
diff --git a/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/MetricsRegistry.java b/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/MetricsRegistry.java
index 3ab3dcf82c7a7..3dc212b1341cc 100644
--- a/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/MetricsRegistry.java
+++ b/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/MetricsRegistry.java
@@ -63,4 +63,16 @@ public interface MetricsRegistry extends Closeable {
      */
     Closeable createGauge(String name, String description, String unit, Supplier<Double> valueProvider, Tags tags);
 
+    /**
+     * Creates the Observable Gauge type of Metric. Where the value provider will be called at a certain frequency
+     * to capture the value.
+     *
+     * @param name        name of the observable gauge.
+     * @param description any description about the metric.
+     * @param unit        unit of the metric.
+     * @param value       value provider.
+     * @return closeable to dispose/close the Gauge metric.
+     */
+    Closeable createGauge(String name, String description, String unit, Supplier<TaggedMeasurement> value);
+
 }
diff --git a/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/TaggedMeasurement.java b/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/TaggedMeasurement.java
new file mode 100644
index 0000000000000..707f2c79c62f2
--- /dev/null
+++ b/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/TaggedMeasurement.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.telemetry.metrics;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.telemetry.metrics.tags.Tags;
+
+/**
+ * Observable Measurement for the Asynchronous instruments.
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public final class TaggedMeasurement {
+    private final Double value;
+    private final Tags tags;
+
+    /**
+     * Factory method to create the {@link TaggedMeasurement} object.
+     * @param value value.
+     * @param tags tags to be added per value.
+     * @return tagged measurement TaggedMeasurement
+     */
+    public static TaggedMeasurement create(double value, Tags tags) {
+        return new TaggedMeasurement(value, tags);
+    }
+
+    private TaggedMeasurement(double value, Tags tags) {
+        this.value = value;
+        this.tags = tags;
+    }
+
+    /**
+     * Returns the value.
+     * @return value
+     */
+    public Double getValue() {
+        return value;
+    }
+
+    /**
+     * Returns the tags.
+     * @return tags
+     */
+    public Tags getTags() {
+        return tags;
+    }
+}
diff --git a/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/noop/NoopMetricsRegistry.java b/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/noop/NoopMetricsRegistry.java
index 9a913d25e872d..7bec136c42ba7 100644
--- a/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/noop/NoopMetricsRegistry.java
+++ b/libs/telemetry/src/main/java/org/opensearch/telemetry/metrics/noop/NoopMetricsRegistry.java
@@ -12,6 +12,7 @@
 import org.opensearch.telemetry.metrics.Counter;
 import org.opensearch.telemetry.metrics.Histogram;
 import org.opensearch.telemetry.metrics.MetricsRegistry;
+import org.opensearch.telemetry.metrics.TaggedMeasurement;
 import org.opensearch.telemetry.metrics.tags.Tags;
 
 import java.io.Closeable;
@@ -52,6 +53,11 @@ public Closeable createGauge(String name, String description, String unit, Suppl
         return () -> {};
     }
 
+    @Override
+    public Closeable createGauge(String name, String description, String unit, Supplier<TaggedMeasurement> value) {
+        return () -> {};
+    }
+
     @Override
     public void close() throws IOException {
 
diff --git a/libs/telemetry/src/test/java/org/opensearch/telemetry/metrics/DefaultMetricsRegistryTests.java b/libs/telemetry/src/test/java/org/opensearch/telemetry/metrics/DefaultMetricsRegistryTests.java
index 872f697ade09e..e1506eecff6e9 100644
--- a/libs/telemetry/src/test/java/org/opensearch/telemetry/metrics/DefaultMetricsRegistryTests.java
+++ b/libs/telemetry/src/test/java/org/opensearch/telemetry/metrics/DefaultMetricsRegistryTests.java
@@ -79,4 +79,19 @@ public void testGauge() {
         assertSame(mockCloseable, closeable);
     }
 
+    @SuppressWarnings("unchecked")
+    public void testGaugeWithValueAndTagSupplier() {
+        Closeable mockCloseable = mock(Closeable.class);
+        when(defaultMeterRegistry.createGauge(any(String.class), any(String.class), any(String.class), any(Supplier.class))).thenReturn(
+            mockCloseable
+        );
+        Closeable closeable = defaultMeterRegistry.createGauge(
+            "org.opensearch.telemetry.metrics.DefaultMeterRegistryTests.testObservableGauge",
+            "test observable gauge",
+            "ms",
+            () -> TaggedMeasurement.create(1.0, Tags.EMPTY)
+        );
+        assertSame(mockCloseable, closeable);
+    }
+
 }
diff --git a/libs/x-content/licenses/jackson-core-2.17.1.jar.sha1 b/libs/x-content/licenses/jackson-core-2.17.1.jar.sha1
deleted file mode 100644
index 82dab5981e652..0000000000000
--- a/libs/x-content/licenses/jackson-core-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-5e52a11644cd59a28ef79f02bddc2cc3bab45edb
\ No newline at end of file
diff --git a/libs/x-content/licenses/jackson-core-2.17.2.jar.sha1 b/libs/x-content/licenses/jackson-core-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..e15f2340980bc
--- /dev/null
+++ b/libs/x-content/licenses/jackson-core-2.17.2.jar.sha1
@@ -0,0 +1 @@
+969a35cb35c86512acbadcdbbbfb044c877db814
\ No newline at end of file
diff --git a/libs/x-content/licenses/jackson-dataformat-cbor-2.17.1.jar.sha1 b/libs/x-content/licenses/jackson-dataformat-cbor-2.17.1.jar.sha1
deleted file mode 100644
index ff42ed1f92cfe..0000000000000
--- a/libs/x-content/licenses/jackson-dataformat-cbor-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ba5d8e6ecc62aa0e49c0ce935b8696352dbebc71
\ No newline at end of file
diff --git a/libs/x-content/licenses/jackson-dataformat-cbor-2.17.2.jar.sha1 b/libs/x-content/licenses/jackson-dataformat-cbor-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..069e088413ef1
--- /dev/null
+++ b/libs/x-content/licenses/jackson-dataformat-cbor-2.17.2.jar.sha1
@@ -0,0 +1 @@
+57fa7c1b5104bbc4599278d13933a937ee058e68
\ No newline at end of file
diff --git a/libs/x-content/licenses/jackson-dataformat-smile-2.17.1.jar.sha1 b/libs/x-content/licenses/jackson-dataformat-smile-2.17.1.jar.sha1
deleted file mode 100644
index 47d19067cf2a6..0000000000000
--- a/libs/x-content/licenses/jackson-dataformat-smile-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-89683ac4f0a0c2c4f69ea56b90480ed40266dac8
\ No newline at end of file
diff --git a/libs/x-content/licenses/jackson-dataformat-smile-2.17.2.jar.sha1 b/libs/x-content/licenses/jackson-dataformat-smile-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..28d8c8382aed3
--- /dev/null
+++ b/libs/x-content/licenses/jackson-dataformat-smile-2.17.2.jar.sha1
@@ -0,0 +1 @@
+20e956b9b6f67138edd39fab7a506ded19638bcb
\ No newline at end of file
diff --git a/libs/x-content/licenses/jackson-dataformat-yaml-2.17.1.jar.sha1 b/libs/x-content/licenses/jackson-dataformat-yaml-2.17.1.jar.sha1
deleted file mode 100644
index 7946e994c7104..0000000000000
--- a/libs/x-content/licenses/jackson-dataformat-yaml-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b4c7b8a9ea3f398116a75c146b982b22afebc4ee
\ No newline at end of file
diff --git a/libs/x-content/licenses/jackson-dataformat-yaml-2.17.2.jar.sha1 b/libs/x-content/licenses/jackson-dataformat-yaml-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f3e25b7eb253c
--- /dev/null
+++ b/libs/x-content/licenses/jackson-dataformat-yaml-2.17.2.jar.sha1
@@ -0,0 +1 @@
+78d2c73dbec62044d7cf3b544b2e0d24a1a093b0
\ No newline at end of file
diff --git a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/CommonAnalysisPlugin.java b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/CommonAnalysisPlugin.java
index 8a6f0b045b275..e2b778a71ebf5 100644
--- a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/CommonAnalysisPlugin.java
+++ b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/CommonAnalysisPlugin.java
@@ -75,6 +75,7 @@
 import org.apache.lucene.analysis.eu.BasqueAnalyzer;
 import org.apache.lucene.analysis.fa.PersianAnalyzer;
 import org.apache.lucene.analysis.fa.PersianNormalizationFilter;
+import org.apache.lucene.analysis.fa.PersianStemFilter;
 import org.apache.lucene.analysis.fi.FinnishAnalyzer;
 import org.apache.lucene.analysis.fr.FrenchAnalyzer;
 import org.apache.lucene.analysis.ga.IrishAnalyzer;
@@ -308,6 +309,7 @@ public Map<String, AnalysisProvider<TokenFilterFactory>> getTokenFilters() {
         filters.put("pattern_capture", requiresAnalysisSettings(PatternCaptureGroupTokenFilterFactory::new));
         filters.put("pattern_replace", requiresAnalysisSettings(PatternReplaceTokenFilterFactory::new));
         filters.put("persian_normalization", PersianNormalizationFilterFactory::new);
+        filters.put("persian_stem", PersianStemTokenFilterFactory::new);
         filters.put("porter_stem", PorterStemTokenFilterFactory::new);
         filters.put(
             "predicate_token_filter",
@@ -549,6 +551,7 @@ public List<PreConfiguredTokenFilter> getPreConfiguredTokenFilters() {
             return new NGramTokenFilter(reader, 1, 2, false);
         }));
         filters.add(PreConfiguredTokenFilter.singleton("persian_normalization", true, PersianNormalizationFilter::new));
+        filters.add(PreConfiguredTokenFilter.singleton("persian_stem", true, PersianStemFilter::new));
         filters.add(PreConfiguredTokenFilter.singleton("porter_stem", false, PorterStemFilter::new));
         filters.add(PreConfiguredTokenFilter.singleton("reverse", false, ReverseStringFilter::new));
         filters.add(PreConfiguredTokenFilter.singleton("russian_stem", false, input -> new SnowballFilter(input, "Russian")));
diff --git a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/HyphenationCompoundWordTokenFilterFactory.java b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/HyphenationCompoundWordTokenFilterFactory.java
index 8d29a347caeb8..181ebe5500ee5 100644
--- a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/HyphenationCompoundWordTokenFilterFactory.java
+++ b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/HyphenationCompoundWordTokenFilterFactory.java
@@ -54,11 +54,16 @@
  */
 public class HyphenationCompoundWordTokenFilterFactory extends AbstractCompoundWordTokenFilterFactory {
 
+    private final boolean noSubMatches;
+    private final boolean noOverlappingMatches;
     private final HyphenationTree hyphenationTree;
 
     HyphenationCompoundWordTokenFilterFactory(IndexSettings indexSettings, Environment env, String name, Settings settings) {
         super(indexSettings, env, name, settings);
 
+        noSubMatches = settings.getAsBoolean("no_sub_matches", false);
+        noOverlappingMatches = settings.getAsBoolean("no_overlapping_matches", false);
+
         String hyphenationPatternsPath = settings.get("hyphenation_patterns_path", null);
         if (hyphenationPatternsPath == null) {
             throw new IllegalArgumentException("hyphenation_patterns_path is a required setting.");
@@ -85,7 +90,9 @@ public TokenStream create(TokenStream tokenStream) {
             minWordSize,
             minSubwordSize,
             maxSubwordSize,
-            onlyLongestMatch
+            onlyLongestMatch,
+            noSubMatches,
+            noOverlappingMatches
         );
     }
 }
diff --git a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/MinHashTokenFilterFactory.java b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/MinHashTokenFilterFactory.java
index e76354ae3a765..40655b84794d5 100644
--- a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/MinHashTokenFilterFactory.java
+++ b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/MinHashTokenFilterFactory.java
@@ -65,10 +65,10 @@ private Map<String, String> convertSettings(Settings settings) {
         if (settings.hasValue("hash_count")) {
             settingMap.put("hashCount", settings.get("hash_count"));
         }
-        if (settings.hasValue("bucketCount")) {
+        if (settings.hasValue("bucket_count")) {
             settingMap.put("bucketCount", settings.get("bucket_count"));
         }
-        if (settings.hasValue("hashSetSize")) {
+        if (settings.hasValue("hash_set_size")) {
             settingMap.put("hashSetSize", settings.get("hash_set_size"));
         }
         if (settings.hasValue("with_rotation")) {
diff --git a/test/framework/src/main/java/org/opensearch/node/RecoverySettingsChunkSizePlugin.java b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/PersianStemTokenFilterFactory.java
similarity index 54%
rename from test/framework/src/main/java/org/opensearch/node/RecoverySettingsChunkSizePlugin.java
rename to modules/analysis-common/src/main/java/org/opensearch/analysis/common/PersianStemTokenFilterFactory.java
index dabf23ce08263..afe8058343e17 100644
--- a/test/framework/src/main/java/org/opensearch/node/RecoverySettingsChunkSizePlugin.java
+++ b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/PersianStemTokenFilterFactory.java
@@ -30,34 +30,23 @@
  * GitHub history for details.
  */
 
-package org.opensearch.node;
+package org.opensearch.analysis.common;
 
-import org.opensearch.common.settings.Setting;
-import org.opensearch.common.settings.Setting.Property;
-import org.opensearch.core.common.unit.ByteSizeValue;
-import org.opensearch.indices.recovery.RecoverySettings;
-import org.opensearch.plugins.Plugin;
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.fa.PersianStemFilter;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.env.Environment;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.analysis.AbstractTokenFilterFactory;
 
-import java.util.List;
+public class PersianStemTokenFilterFactory extends AbstractTokenFilterFactory {
 
-import static java.util.Collections.singletonList;
-
-/**
- * Marker plugin that will trigger {@link MockNode} making {@link #CHUNK_SIZE_SETTING} dynamic.
- */
-public class RecoverySettingsChunkSizePlugin extends Plugin {
-    /**
-     * The chunk size. Only exposed by tests.
-     */
-    public static final Setting<ByteSizeValue> CHUNK_SIZE_SETTING = Setting.byteSizeSetting(
-        "indices.recovery.chunk_size",
-        RecoverySettings.DEFAULT_CHUNK_SIZE,
-        Property.Dynamic,
-        Property.NodeScope
-    );
+    PersianStemTokenFilterFactory(IndexSettings indexSettings, Environment environment, String name, Settings settings) {
+        super(indexSettings, name, settings);
+    }
 
     @Override
-    public List<Setting<?>> getSettings() {
-        return singletonList(CHUNK_SIZE_SETTING);
+    public TokenStream create(TokenStream tokenStream) {
+        return new PersianStemFilter(tokenStream);
     }
 }
diff --git a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/StemmerTokenFilterFactory.java b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/StemmerTokenFilterFactory.java
index 5506626e40da0..e81f3c6cc09cc 100644
--- a/modules/analysis-common/src/main/java/org/opensearch/analysis/common/StemmerTokenFilterFactory.java
+++ b/modules/analysis-common/src/main/java/org/opensearch/analysis/common/StemmerTokenFilterFactory.java
@@ -47,6 +47,7 @@
 import org.apache.lucene.analysis.en.KStemFilter;
 import org.apache.lucene.analysis.en.PorterStemFilter;
 import org.apache.lucene.analysis.es.SpanishLightStemFilter;
+import org.apache.lucene.analysis.fa.PersianStemFilter;
 import org.apache.lucene.analysis.fi.FinnishLightStemFilter;
 import org.apache.lucene.analysis.fr.FrenchLightStemFilter;
 import org.apache.lucene.analysis.fr.FrenchMinimalStemFilter;
@@ -239,6 +240,8 @@ public TokenStream create(TokenStream tokenStream) {
                 return new NorwegianLightStemFilter(tokenStream, NorwegianLightStemmer.NYNORSK);
             } else if ("minimal_nynorsk".equalsIgnoreCase(language) || "minimalNynorsk".equalsIgnoreCase(language)) {
                 return new NorwegianMinimalStemFilter(tokenStream, NorwegianLightStemmer.NYNORSK);
+            } else if ("persian".equalsIgnoreCase(language)) {
+                return new PersianStemFilter(tokenStream);
 
                 // Portuguese stemmers
             } else if ("portuguese".equalsIgnoreCase(language)) {
diff --git a/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CommonAnalysisFactoryTests.java b/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CommonAnalysisFactoryTests.java
index e0e99cdc31672..e6aeea96995a9 100644
--- a/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CommonAnalysisFactoryTests.java
+++ b/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CommonAnalysisFactoryTests.java
@@ -158,6 +158,7 @@ protected Map<String, Class<?>> getTokenFilters() {
         filters.put("brazilianstem", BrazilianStemTokenFilterFactory.class);
         filters.put("czechstem", CzechStemTokenFilterFactory.class);
         filters.put("germanstem", GermanStemTokenFilterFactory.class);
+        filters.put("persianstem", PersianStemTokenFilterFactory.class);
         filters.put("telugunormalization", TeluguNormalizationFilterFactory.class);
         filters.put("telugustem", TeluguStemFilterFactory.class);
         // this filter is not exposed and should only be used internally
@@ -220,6 +221,7 @@ protected Map<String, Class<?>> getPreConfiguredTokenFilters() {
         filters.put("ngram", null);
         filters.put("nGram", null);
         filters.put("persian_normalization", null);
+        filters.put("persian_stem", null);
         filters.put("porter_stem", null);
         filters.put("reverse", ReverseStringFilterFactory.class);
         filters.put("russian_stem", SnowballPorterFilterFactory.class);
diff --git a/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CompoundAnalysisTests.java b/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CompoundAnalysisTests.java
index 1955b7eaa0e45..4f262d97813f2 100644
--- a/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CompoundAnalysisTests.java
+++ b/modules/analysis-common/src/test/java/org/opensearch/analysis/common/CompoundAnalysisTests.java
@@ -50,8 +50,12 @@
 import org.opensearch.test.IndexSettingsModule;
 import org.opensearch.test.OpenSearchTestCase;
 import org.hamcrest.MatcherAssert;
+import org.junit.Before;
 
 import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -63,17 +67,27 @@
 import static org.hamcrest.Matchers.instanceOf;
 
 public class CompoundAnalysisTests extends OpenSearchTestCase {
+
+    Settings[] settingsArr;
+
+    @Before
+    public void initialize() throws IOException {
+        final Path home = createTempDir();
+        copyHyphenationPatternsFile(home);
+        this.settingsArr = new Settings[] { getJsonSettings(home), getYamlSettings(home) };
+    }
+
     public void testDefaultsCompoundAnalysis() throws Exception {
-        Settings settings = getJsonSettings();
-        IndexSettings idxSettings = IndexSettingsModule.newIndexSettings("test", settings);
-        AnalysisModule analysisModule = createAnalysisModule(settings);
-        TokenFilterFactory filterFactory = analysisModule.getAnalysisRegistry().buildTokenFilterFactories(idxSettings).get("dict_dec");
-        MatcherAssert.assertThat(filterFactory, instanceOf(DictionaryCompoundWordTokenFilterFactory.class));
+        for (Settings settings : this.settingsArr) {
+            IndexSettings idxSettings = IndexSettingsModule.newIndexSettings("test", settings);
+            AnalysisModule analysisModule = createAnalysisModule(settings);
+            TokenFilterFactory filterFactory = analysisModule.getAnalysisRegistry().buildTokenFilterFactories(idxSettings).get("dict_dec");
+            MatcherAssert.assertThat(filterFactory, instanceOf(DictionaryCompoundWordTokenFilterFactory.class));
+        }
     }
 
     public void testDictionaryDecompounder() throws Exception {
-        Settings[] settingsArr = new Settings[] { getJsonSettings(), getYamlSettings() };
-        for (Settings settings : settingsArr) {
+        for (Settings settings : this.settingsArr) {
             List<String> terms = analyze(settings, "decompoundingAnalyzer", "donaudampfschiff spargelcremesuppe");
             MatcherAssert.assertThat(terms.size(), equalTo(8));
             MatcherAssert.assertThat(
@@ -83,6 +97,26 @@ public void testDictionaryDecompounder() throws Exception {
         }
     }
 
+    // Hyphenation Decompounder tests mimic the behavior of lucene tests
+    // lucene/analysis/common/src/test/org/apache/lucene/analysis/compound/TestHyphenationCompoundWordTokenFilterFactory.java
+    public void testHyphenationDecompounder() throws Exception {
+        for (Settings settings : this.settingsArr) {
+            List<String> terms = analyze(settings, "hyphenationAnalyzer", "min veninde som er lidt af en læsehest");
+            MatcherAssert.assertThat(terms.size(), equalTo(10));
+            MatcherAssert.assertThat(terms, hasItems("min", "veninde", "som", "er", "lidt", "af", "en", "læsehest", "læse", "hest"));
+        }
+    }
+
+    // Hyphenation Decompounder tests mimic the behavior of lucene tests
+    // lucene/analysis/common/src/test/org/apache/lucene/analysis/compound/TestHyphenationCompoundWordTokenFilterFactory.java
+    public void testHyphenationDecompounderNoSubMatches() throws Exception {
+        for (Settings settings : this.settingsArr) {
+            List<String> terms = analyze(settings, "hyphenationAnalyzerNoSubMatches", "basketballkurv");
+            MatcherAssert.assertThat(terms.size(), equalTo(3));
+            MatcherAssert.assertThat(terms, hasItems("basketballkurv", "basketball", "kurv"));
+        }
+    }
+
     private List<String> analyze(Settings settings, String analyzerName, String text) throws IOException {
         IndexSettings idxSettings = IndexSettingsModule.newIndexSettings("test", settings);
         AnalysisModule analysisModule = createAnalysisModule(settings);
@@ -111,21 +145,28 @@ public Map<String, AnalysisProvider<TokenFilterFactory>> getTokenFilters() {
         }));
     }
 
-    private Settings getJsonSettings() throws IOException {
+    private void copyHyphenationPatternsFile(Path home) throws IOException {
+        InputStream hyphenation_patterns_path = getClass().getResourceAsStream("da_UTF8.xml");
+        Path config = home.resolve("config");
+        Files.createDirectory(config);
+        Files.copy(hyphenation_patterns_path, config.resolve("da_UTF8.xml"));
+    }
+
+    private Settings getJsonSettings(Path home) throws IOException {
         String json = "/org/opensearch/analysis/common/test1.json";
         return Settings.builder()
             .loadFromStream(json, getClass().getResourceAsStream(json), false)
             .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
-            .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir().toString())
+            .put(Environment.PATH_HOME_SETTING.getKey(), home.toString())
             .build();
     }
 
-    private Settings getYamlSettings() throws IOException {
+    private Settings getYamlSettings(Path home) throws IOException {
         String yaml = "/org/opensearch/analysis/common/test1.yml";
         return Settings.builder()
             .loadFromStream(yaml, getClass().getResourceAsStream(yaml), false)
             .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
-            .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir().toString())
+            .put(Environment.PATH_HOME_SETTING.getKey(), home.toString())
             .build();
     }
 }
diff --git a/modules/analysis-common/src/test/java/org/opensearch/analysis/common/MinHashFilterFactoryTests.java b/modules/analysis-common/src/test/java/org/opensearch/analysis/common/MinHashFilterFactoryTests.java
index 514c53f17456c..7d21dcab4e951 100644
--- a/modules/analysis-common/src/test/java/org/opensearch/analysis/common/MinHashFilterFactoryTests.java
+++ b/modules/analysis-common/src/test/java/org/opensearch/analysis/common/MinHashFilterFactoryTests.java
@@ -53,8 +53,7 @@ public void testDefault() throws IOException {
         OpenSearchTestCase.TestAnalysis analysis = AnalysisTestsHelper.createTestAnalysisFromSettings(settings, new CommonAnalysisPlugin());
         TokenFilterFactory tokenFilter = analysis.tokenFilter.get("min_hash");
         String source = "the quick brown fox";
-        Tokenizer tokenizer = new WhitespaceTokenizer();
-        tokenizer.setReader(new StringReader(source));
+        Tokenizer tokenizer = getTokenizer(source);
 
         // with_rotation is true by default, and hash_set_size is 1, so even though the source doesn't
         // have enough tokens to fill all the buckets, we still expect 512 tokens.
@@ -73,11 +72,60 @@ public void testSettings() throws IOException {
         OpenSearchTestCase.TestAnalysis analysis = AnalysisTestsHelper.createTestAnalysisFromSettings(settings, new CommonAnalysisPlugin());
         TokenFilterFactory tokenFilter = analysis.tokenFilter.get("test_min_hash");
         String source = "sushi";
-        Tokenizer tokenizer = new WhitespaceTokenizer();
-        tokenizer.setReader(new StringReader(source));
+        Tokenizer tokenizer = getTokenizer(source);
 
         // despite the fact that bucket_count is 2 and hash_set_size is 1,
         // because with_rotation is false, we only expect 1 token here.
         assertStreamHasNumberOfTokens(tokenFilter.create(tokenizer), 1);
     }
+
+    public void testBucketCountSetting() throws IOException {
+        // Correct case with "bucket_count"
+        Settings settingsWithBucketCount = Settings.builder()
+            .put("index.analysis.filter.test_min_hash.type", "min_hash")
+            .put("index.analysis.filter.test_min_hash.hash_count", "1")
+            .put("index.analysis.filter.test_min_hash.bucket_count", "3")
+            .put("index.analysis.filter.test_min_hash.hash_set_size", "1")
+            .put("index.analysis.filter.test_min_hash.with_rotation", false)
+            .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir().toString())
+            .build();
+
+        OpenSearchTestCase.TestAnalysis analysisWithBucketCount = getTestAnalysisFromSettings(settingsWithBucketCount);
+
+        TokenFilterFactory tokenFilterWithBucketCount = analysisWithBucketCount.tokenFilter.get("test_min_hash");
+        String sourceWithBucketCount = "salmon avocado roll uramaki";
+        Tokenizer tokenizerWithBucketCount = getTokenizer(sourceWithBucketCount);
+        // Expect 3 tokens due to bucket_count being set to 3
+        assertStreamHasNumberOfTokens(tokenFilterWithBucketCount.create(tokenizerWithBucketCount), 3);
+    }
+
+    public void testHashSetSizeSetting() throws IOException {
+        // Correct case with "hash_set_size"
+        Settings settingsWithHashSetSize = Settings.builder()
+            .put("index.analysis.filter.test_min_hash.type", "min_hash")
+            .put("index.analysis.filter.test_min_hash.hash_count", "1")
+            .put("index.analysis.filter.test_min_hash.bucket_count", "1")
+            .put("index.analysis.filter.test_min_hash.hash_set_size", "2")
+            .put("index.analysis.filter.test_min_hash.with_rotation", false)
+            .put(Environment.PATH_HOME_SETTING.getKey(), createTempDir().toString())
+            .build();
+
+        OpenSearchTestCase.TestAnalysis analysisWithHashSetSize = getTestAnalysisFromSettings(settingsWithHashSetSize);
+
+        TokenFilterFactory tokenFilterWithHashSetSize = analysisWithHashSetSize.tokenFilter.get("test_min_hash");
+        String sourceWithHashSetSize = "salmon avocado roll uramaki";
+        Tokenizer tokenizerWithHashSetSize = getTokenizer(sourceWithHashSetSize);
+        // Expect 2 tokens due to hash_set_size being set to 2 and bucket_count being 1
+        assertStreamHasNumberOfTokens(tokenFilterWithHashSetSize.create(tokenizerWithHashSetSize), 2);
+    }
+
+    private static OpenSearchTestCase.TestAnalysis getTestAnalysisFromSettings(Settings settingsWithBucketCount) throws IOException {
+        return AnalysisTestsHelper.createTestAnalysisFromSettings(settingsWithBucketCount, new CommonAnalysisPlugin());
+    }
+
+    private static Tokenizer getTokenizer(String sourceWithBucketCount) {
+        Tokenizer tokenizerWithBucketCount = new WhitespaceTokenizer();
+        tokenizerWithBucketCount.setReader(new StringReader(sourceWithBucketCount));
+        return tokenizerWithBucketCount;
+    }
 }
diff --git a/modules/analysis-common/src/test/resources/org/opensearch/analysis/common/da_UTF8.xml b/modules/analysis-common/src/test/resources/org/opensearch/analysis/common/da_UTF8.xml
new file mode 100644
index 0000000000000..2c8d203be6881
--- /dev/null
+++ b/modules/analysis-common/src/test/resources/org/opensearch/analysis/common/da_UTF8.xml
@@ -0,0 +1,1208 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hyphenation-info SYSTEM "hyphenation.dtd">
+<!--
+  Copyright 1999-2004 The Apache Software Foundation
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+<!--
+This file contains the hyphenation patterns for danish.
+Adapted from dkhyph.tex, dkcommon.tex and dkspecial.tex
+originally created by Frank Jensen (fj@iesd.auc.dk).
+FOP adaptation by Carlos Villegas (cav@uniscope.co.jp)
+-->
+<hyphenation-info>
+
+<hyphen-char value="-"/>
+<hyphen-min before="2" after="2"/>
+
+<classes>
+aA
+bB
+cC
+dD
+eE
+fF
+gG
+hH
+iI
+jJ
+kK
+lL
+mM
+nN
+oO
+pP
+qQ
+rR
+sS
+tT
+uU
+vV
+wW
+xX
+yY
+zZ
+æÆ
+øØ
+åÅ
+</classes>
+<patterns>
+<!-- dkcommon -->
+.ae3
+.an3k
+.an1s
+.be5la
+.be1t
+.bi4tr
+.der3i
+.diagno5
+.her3
+.hoved3
+.ne4t5
+.om1
+.ove4
+.po1
+.til3
+.yd5r
+ab5le
+3abst
+a3c
+ade5la
+5adg
+a1e
+5afg
+5a4f1l
+af3r
+af4ri
+5afs
+a4gef
+a4gi
+ag5in
+ag5si
+3agti
+a4gy
+a3h
+ais5t
+a3j
+a5ka
+a3ke
+a5kr
+aku5
+a3la
+a1le
+a1li
+al3k
+4alkv
+a1lo
+al5si
+a3lu
+a1ly
+am4pa
+3analy
+an4k5r
+a3nu
+3anv
+a5o
+a5pe
+a3pi
+a5po
+a1ra
+ar5af
+1arb
+a1re
+5arg
+a1ri
+a3ro
+a3sa
+a3sc
+a1si
+a3sk
+a3so
+3a3sp
+a3ste
+a3sti
+a1ta1
+a1te
+a1ti
+a4t5in
+a1to
+ato5v
+a5tr
+a1tu
+a5va
+a1ve
+a5z
+1ba
+ba4ti
+4bd
+1be
+be1k
+be3ro
+be5ru
+be1s4
+be1tr
+1bi
+bi5sk
+b1j
+4b1n
+1bo
+bo4gr
+bo3ra
+bo5re
+1br4
+4bs
+bs5k
+b3so
+b1st
+b5t
+3bu
+bu4s5tr
+b5w
+1by
+by5s
+4c1c
+1ce
+ce5ro
+3ch
+4ch.
+ci4o
+ck3
+5cy
+3da
+4d3af
+d5anta
+da4s
+d1b
+d1d4
+1de
+de5d
+4de4lem
+der5eri
+de4rig
+de5sk
+d1f
+d1g
+d3h
+1di
+di1e
+di5l
+d3j
+d1k
+d1l
+d1m
+4d1n
+3do
+4dop
+d5ov
+d1p
+4drett
+5d4reve
+3drif
+3driv
+d5ros
+d5ru
+ds5an
+ds5in
+d1ski
+d4sm
+d4su
+dsu5l
+ds5vi
+d3ta
+d1te
+dt5o
+d5tr
+dt5u
+1du
+dub5
+d1v
+3dy
+e5ad
+e3af
+e5ag
+e3ak
+e1al
+ea4la
+e3an
+e5ap
+e3at
+e3bl
+ebs3
+e1ci
+ed5ar
+edde4
+eddel5
+e4do
+ed5ra
+ed3re
+ed3rin
+ed4str
+e3e
+3eff
+e3fr
+3eft
+e3gu
+e1h
+e3in
+ei5s
+e3je
+e4j5el
+e1ka
+e3ke
+e3kl
+4e1ko
+e5kr
+ek5sa
+3eksem
+3eksp
+e3ku
+e1kv
+e5ky
+e3lad
+el3ak
+el3ar
+e1las
+e3le
+e4lek
+3elem
+e1li
+5elim
+e3lo
+el5sa
+e5lu
+e3ly
+e4mad
+em4p5le
+em1s
+en5ak
+e4nan
+4enn
+e4no
+en3so
+e5nu
+e5ol
+e3op
+e1or
+e3ov
+epi3
+e1pr
+e3ra
+er3af
+e4rag
+e4rak
+e1re
+e4ref
+er5ege
+5erhv
+e1ri
+e4rib
+er1k
+ero5d
+er5ov
+er3s
+er5tr
+e3rum
+er5un
+e5ry
+e1ta
+e1te
+etek4s
+e1ti
+e3tj
+e1to
+e3tr
+e3tu
+e1ty
+e3um
+e3un
+3eur
+e1va
+e3ve
+e4v3erf
+e1vi
+e5x
+1fa
+fa4ce
+fags3
+f1b
+f1d
+1fe
+fej4
+fejl1
+f1f
+f1g
+f1h
+1fi
+f1k
+3fl
+1fo
+for1en
+fo4ri
+f1p
+f1s4
+4ft
+f3ta
+f1te
+f1ti
+f5to
+f5tvi
+1fu
+f1v
+3fy
+1ga
+g3art
+g1b
+g1d
+1ge
+4g5enden
+ger3in
+ge3s
+g3f
+g1g
+g1h
+1gi
+gi4b
+gi3st
+5gj
+g3k
+g1l
+g1m
+3go
+4g5om
+g5ov
+g3p
+1gr
+gs1a
+gsde4len
+g4se
+gsha4
+g5sla
+gs3or
+gs1p
+g5s4tide
+g4str
+gs1v
+g3ta
+g1te
+g1ti
+g5to
+g3tr
+gt4s
+g3ud
+gun5
+g3v
+1gy
+g5yd
+4ha.
+heds3
+he5s
+4het
+hi4e
+hi4n5
+hi3s
+ho5ko
+ho5ve
+4h3t
+hun4
+hund3
+hvo4
+i1a
+i3b
+i4ble
+i1c
+i3dr
+ids5k
+i1el
+i1en
+i3er
+i3et.
+if3r
+i3gu
+i3h
+i5i
+i5j
+i1ka
+i1ke
+ik1l
+i5ko
+ik3re
+ik5ri
+iks5t
+ik4tu
+i3ku
+ik3v
+i3lag
+il3eg
+il5ej
+il5el
+i3li
+i4l5id
+il3k
+i1lo
+il5u
+i3mu
+ind3t
+5inf
+ings1
+in3s
+in4sv
+inter1
+i3nu
+i3od
+i3og
+i5ok
+i3ol
+ion4
+ions1
+i5o5r
+i3ot
+i5pi
+i3pli
+i5pr
+i3re
+i3ri
+ir5t
+i3sc
+i3si
+i4sm
+is3p
+i1ster
+i3sti
+i5sua
+i1ta
+i1te
+i1ti
+i3to
+i3tr
+it5re.
+i1tu
+i3ty
+i1u
+i1va
+i1ve
+i1vi
+j3ag
+jde4rer
+jds1
+jek4to
+4j5en.
+j5k
+j3le
+j3li
+jlmeld5
+jlmel4di
+j3r
+jre5
+ju3s
+5kap
+k5au
+5kav
+k5b
+kel5s
+ke3sk
+ke5st
+ke4t5a
+k3h
+ki3e
+ki3st
+k1k
+k5lak
+k1le
+3klu
+k4ny
+5kod
+1kon
+ko3ra
+3kort
+ko3v
+1kra
+5kry
+ks3an
+k1si
+ks3k
+ks1p
+k3ste
+k5stu
+ks5v
+k1t
+k4tar
+k4terh
+kti4e
+kt5re
+kt5s
+3kur
+1kus
+3kut
+k4vo
+k4vu
+5lab
+lad3r
+5lagd
+la4g3r
+5lam
+1lat
+l1b
+ldiagnos5
+l3dr
+ld3st
+1le.
+5led
+4lele
+le4mo
+3len
+1ler
+1les
+4leu
+l1f
+lfin4
+lfind5
+l1go1
+l3h
+li4ga
+4l5ins
+4l3int
+li5o
+l3j
+l1ke
+l1ko
+l3ky
+l1l
+l5mu
+lo4du
+l3op
+4l5or
+3lov
+4l3p
+l4ps
+l3r
+4ls
+lses1
+ls5in
+l5sj
+l1ta
+l4taf
+l1te
+l4t5erf
+l3ti
+lt3o
+l3tr
+l3tu
+lu5l
+l3ve
+l3vi
+1ma
+m1b
+m3d
+1me
+4m5ej
+m3f
+m1g
+m3h
+1mi
+mi3k
+m5ing
+mi4o
+mi5sty
+m3k
+m1l
+m1m
+mmen5
+m1n
+3mo
+mo4da
+4mop
+4m5ov
+m1pe
+m3pi
+m3pl
+m1po
+m3pr
+m1r
+mse5s
+ms5in
+m5sk
+ms3p
+m3ste
+ms5v
+m3ta
+m3te
+m3ti
+m3tr
+m1ud
+1mul
+mu1li
+3my
+3na
+4nak
+1nal
+n1b
+n1c
+4nd
+n3dr
+nd5si
+nd5sk
+nd5sp
+1ne
+ne5a
+ne4da
+nemen4
+nement5e
+neo4
+n3erk
+n5erl
+ne5sl
+ne5st
+n1f
+n4go
+4n1h
+1ni
+4nim
+ni5o
+ni3st
+n1ke
+n1ko
+n3kr
+n3ku
+n5kv
+4n1l
+n1m
+n1n
+1no
+n3ord
+n5p
+n3r
+4ns
+n3si
+n1sku
+ns3po
+n1sta
+n5sti
+n1ta
+nta4le
+n1te
+n1ti
+ntiali4
+n3to
+n1tr
+nt4s5t
+nt4su
+n3tu
+n3ty
+4n1v
+3ny
+n3z
+o3a
+o4as
+ob3li
+o1c
+o4din
+od5ri
+od5s
+od5un
+o1e
+of5r
+o4gek
+o4gel
+o4g5o
+og5re
+og5sk
+o5h
+o5in
+oi6s5e
+o1j
+o3ka
+o1ke
+o3ku
+o3la
+o3le
+o1li
+o1lo
+o3lu
+o5ly
+1omr
+on3k
+ook5
+o3or
+o5ov
+o3pi
+op3l
+op3r
+op3s
+3opta
+4or.
+or1an
+3ordn
+ord5s
+o3re.
+o3reg
+o3rek
+o3rer
+o3re3s
+o3ret
+o3ri
+3orient
+or5im
+o4r5in
+or3k
+or5o
+or3sl
+or3st
+o3si
+o3so
+o3t
+o1te
+o5un
+ov4s
+3pa
+pa5gh
+p5anl
+p3d
+4pec
+3pen
+1per
+pe1ra
+pe5s
+pe3u
+p3f
+4p5h
+1pla
+p4lan
+4ple.
+4pler
+4ples
+p3m
+p3n
+5pok
+4po3re
+3pot
+4p5p4
+p4ro
+1proc
+p3sk
+p5so
+ps4p
+p3st
+p1t
+1pu
+pu5b
+p5ule
+p5v
+5py3
+qu4
+4raf
+ra5is
+4rarb
+r1b
+r4d5ar
+r3dr
+rd4s3
+4reks
+1rel
+re5la
+r5enss
+5rese
+re5spo
+4ress
+re3st
+re5s4u
+5rett
+r1f
+r1gu
+r1h
+ri1e
+ri5la
+4rimo
+r4ing
+ringse4
+ringso4r
+4rinp
+4rint
+r3ka
+r1ke
+r1ki
+rk3so
+r3ku
+r1l
+rmo4
+r5mu
+r1n
+ro1b
+ro3p
+r3or
+r3p
+r1r
+rre5s
+rro4n5
+r1sa
+r1si
+r5skr
+r4sk5v
+rs4n
+r3sp
+r5stu
+r5su
+r3sv
+r5tal
+r1te
+r4teli
+r1ti
+r3to
+r4t5or
+rt5rat
+rt3re
+r5tri
+r5tro
+rt3s
+r5ty
+r3ud
+run4da
+5rut
+r3va
+r1ve
+r3vi
+ry4s
+s3af
+1sam
+sa4ma
+s3ap
+s1ar
+1sat
+4s1b
+s1d
+sdy4
+1se
+s4ed
+5s4er
+se4se
+s1f
+4s1g4
+4s3h
+si4bl
+1sig
+s5int
+5sis
+5sit
+5siu
+s5ju
+4sk.
+1skab
+1ske
+s3kl
+sk5s4
+5sky
+s1le
+s1li
+slo3
+5slu
+s5ly
+s1m
+s4my
+4snin
+s4nit
+so5k
+5sol
+5som.
+3somm
+s5oms
+5somt
+3son
+4s1op
+sp4
+3spec
+4sper
+3s4pi
+s1pl
+3sprog.
+s5r4
+s1s4
+4st.
+5s4tam
+1stan
+st5as
+3stat
+1stav
+1ste.
+1sted
+3stel
+5stemo
+1sten
+5step
+3ster.
+3stes
+5stet
+5stj
+3sto
+st5om
+1str
+s1ud
+3sul
+s3un
+3sur
+s3ve
+3s4y
+1sy1s
+5ta.
+1tag
+tands3
+4tanv
+4tb
+tede4l
+teds5
+3teg
+5tekn
+teo1
+5term
+te5ro
+4t1f
+6t3g
+t1h
+tialis5t
+3tid
+ti4en
+ti3st
+4t3k
+4t1l
+tli4s5
+t1m
+t1n
+to5ra
+to1re
+to1ri
+tor4m
+4t3p
+t4ra
+4tres
+tro5v
+1try
+4ts
+t3si
+ts4pa
+ts5pr
+t3st
+ts5ul
+4t1t
+t5uds
+5tur
+t5ve
+1typ
+u1a
+5udl
+ud5r
+ud3s
+3udv
+u1e
+ue4t5
+uge4ri
+ugs3
+u5gu
+u3i
+u5kl
+uk4ta
+uk4tr
+u1la
+u1le
+u5ly
+u5pe
+up5l
+u5q
+u3ra
+u3re
+u4r3eg
+u1rer
+u3ro
+us5a
+u3si
+u5ska
+u5so
+us5v
+u1te
+u1ti
+u1to
+ut5r
+ut5s4
+5u5v
+va5d
+3varm
+1ved
+ve4l5e
+ve4reg
+ve3s
+5vet
+v5h
+vi4l3in
+1vis
+v5j
+v5k
+vl4
+v3le
+v5li
+vls1
+1vo
+4v5om
+v5p
+v5re
+v3st
+v5su
+v5t
+3vu
+y3a
+y5dr
+y3e
+y3ke
+y5ki
+yk3li
+y3ko
+yk4s5
+y3kv
+y5li
+y5lo
+y5mu
+yns5
+y5o
+y1pe
+y3pi
+y3re
+yr3ek
+y3ri
+y3si
+y3ti
+y5t3r
+y5ve
+zi5o
+<!-- dkspecial -->
+.så3
+.ær5i
+.øv3r
+a3tø
+a5væ
+brød3
+5bæ
+5drøv
+dstå4
+3dæ
+3dø
+e3læ
+e3lø
+e3rø
+er5øn
+e5tæ
+e5tø
+e1væ
+e3æ
+e5å
+3fæ
+3fø
+fø4r5en
+giø4
+g4sø
+g5så
+3gæ
+3gø1
+3gå
+i5tæ
+i3ø
+3kø
+3kå
+lingeniø4
+l3væ
+5løs
+m5tå
+1mæ
+3mø
+3må
+n3kæ
+n5tæ
+3næ
+4n5æb
+5nø
+o5læ
+or3ø
+o5å
+5præ
+5pæd
+på3
+r5kæ
+r5tæ
+r5tø
+r3væ
+r5æl
+4røn
+5rør
+3råd
+r5år
+s4kå
+3slå
+s4næ
+5stø
+1stå
+1sæ
+4s5æn
+1sø
+s5øk
+så4r5
+ti4ø
+3træk.
+t4sø
+t5så
+t3væ
+u3læ
+3værd
+1værk
+5vå
+y5væ
+æb3l
+æ3c
+æ3e
+æg5a
+æ4gek
+æ4g5r
+ægs5
+æ5i
+æ5kv
+ælle4
+æn1dr
+æ5o
+æ1re
+ær4g5r
+æ3ri
+ær4ma
+ær4mo
+ær5s
+æ5si
+æ3so
+æ3ste
+æ3ve
+øde5
+ø3e
+ø1je
+ø3ke
+ø3le
+øms5
+øn3st
+øn4t3
+ø1re
+ø3ri
+ørne3
+ør5o
+ø1ve
+å1d
+å1e
+å5h
+å3l
+å3re
+års5t
+å5sk
+å3t
+</patterns>
+</hyphenation-info>
diff --git a/modules/analysis-common/src/yamlRestTest/resources/rest-api-spec/test/analysis-common/40_token_filters.yml b/modules/analysis-common/src/yamlRestTest/resources/rest-api-spec/test/analysis-common/40_token_filters.yml
index 802c79c780689..c6b075571f221 100644
--- a/modules/analysis-common/src/yamlRestTest/resources/rest-api-spec/test/analysis-common/40_token_filters.yml
+++ b/modules/analysis-common/src/yamlRestTest/resources/rest-api-spec/test/analysis-common/40_token_filters.yml
@@ -1781,6 +1781,37 @@
     - length: { tokens: 1 }
     - match:  { tokens.0.token: abschliess }
 
+---
+"persian_stem":
+  - do:
+      indices.create:
+        index: test
+        body:
+          settings:
+            analysis:
+              filter:
+                my_persian_stem:
+                  type: persian_stem
+  - do:
+      indices.analyze:
+        index: test
+        body:
+          text: جامدات
+          tokenizer: keyword
+          filter:    [my_persian_stem]
+  - length: { tokens: 1 }
+  - match:  { tokens.0.token: جامد }
+
+  # Test pre-configured token filter too:
+  - do:
+      indices.analyze:
+        body:
+          text: جامدات
+          tokenizer: keyword
+          filter:    [persian_stem]
+  - length: { tokens: 1 }
+  - match:  { tokens.0.token: جامد }
+
 ---
 "russian_stem":
     - do:
diff --git a/modules/cache-common/src/internalClusterTest/java/org.opensearch.cache.common.tier/TieredSpilloverCacheIT.java b/modules/cache-common/src/internalClusterTest/java/org/opensearch/cache/common/tier/TieredSpilloverCacheIT.java
similarity index 99%
rename from modules/cache-common/src/internalClusterTest/java/org.opensearch.cache.common.tier/TieredSpilloverCacheIT.java
rename to modules/cache-common/src/internalClusterTest/java/org/opensearch/cache/common/tier/TieredSpilloverCacheIT.java
index bfc184cff0566..02be0990eb136 100644
--- a/modules/cache-common/src/internalClusterTest/java/org.opensearch.cache.common.tier/TieredSpilloverCacheIT.java
+++ b/modules/cache-common/src/internalClusterTest/java/org/opensearch/cache/common/tier/TieredSpilloverCacheIT.java
@@ -65,7 +65,7 @@ protected Collection<Class<? extends Plugin>> nodePlugins() {
         return Arrays.asList(TieredSpilloverCachePlugin.class, MockDiskCachePlugin.class);
     }
 
-    private Settings defaultSettings(String onHeapCacheSizeInBytesOrPecentage) {
+    static Settings defaultSettings(String onHeapCacheSizeInBytesOrPercentage) {
         return Settings.builder()
             .put(FeatureFlags.PLUGGABLE_CACHE, "true")
             .put(
@@ -88,7 +88,7 @@ private Settings defaultSettings(String onHeapCacheSizeInBytesOrPecentage) {
                 OpenSearchOnHeapCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
                     .get(MAXIMUM_SIZE_IN_BYTES_KEY)
                     .getKey(),
-                onHeapCacheSizeInBytesOrPecentage
+                onHeapCacheSizeInBytesOrPercentage
             )
             .build();
     }
diff --git a/modules/cache-common/src/internalClusterTest/java/org/opensearch/cache/common/tier/TieredSpilloverCacheStatsIT.java b/modules/cache-common/src/internalClusterTest/java/org/opensearch/cache/common/tier/TieredSpilloverCacheStatsIT.java
new file mode 100644
index 0000000000000..783b6083e9226
--- /dev/null
+++ b/modules/cache-common/src/internalClusterTest/java/org/opensearch/cache/common/tier/TieredSpilloverCacheStatsIT.java
@@ -0,0 +1,507 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cache.common.tier;
+
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.action.admin.indices.forcemerge.ForceMergeResponse;
+import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.client.Client;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.cache.CacheType;
+import org.opensearch.common.cache.service.NodeCacheStats;
+import org.opensearch.common.cache.stats.ImmutableCacheStats;
+import org.opensearch.common.cache.stats.ImmutableCacheStatsHolder;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.cache.request.RequestCacheStats;
+import org.opensearch.index.query.QueryBuilders;
+import org.opensearch.indices.IndicesRequestCache;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.opensearch.test.hamcrest.OpenSearchAssertions;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import static org.opensearch.cache.common.tier.TieredSpilloverCacheStatsHolder.TIER_DIMENSION_NAME;
+import static org.opensearch.cache.common.tier.TieredSpilloverCacheStatsHolder.TIER_DIMENSION_VALUE_DISK;
+import static org.opensearch.cache.common.tier.TieredSpilloverCacheStatsHolder.TIER_DIMENSION_VALUE_ON_HEAP;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertSearchResponse;
+
+// Use a single data node to simplify accessing cache stats across different shards.
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class TieredSpilloverCacheStatsIT extends OpenSearchIntegTestCase {
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return Arrays.asList(TieredSpilloverCachePlugin.class, TieredSpilloverCacheIT.MockDiskCachePlugin.class);
+    }
+
+    private final String HEAP_CACHE_SIZE_STRING = "10000B";
+    private final int HEAP_CACHE_SIZE = 10_000;
+    private final String index1Name = "index1";
+    private final String index2Name = "index2";
+
+    /**
+     * Test aggregating by indices
+     */
+    public void testIndicesLevelAggregation() throws Exception {
+        internalCluster().startNodes(
+            1,
+            Settings.builder()
+                .put(TieredSpilloverCacheIT.defaultSettings(HEAP_CACHE_SIZE_STRING))
+                .put(
+                    TieredSpilloverCacheSettings.TOOK_TIME_POLICY_CONCRETE_SETTINGS_MAP.get(CacheType.INDICES_REQUEST_CACHE).getKey(),
+                    new TimeValue(0, TimeUnit.SECONDS)
+                )
+                .build()
+        );
+        Client client = client();
+        Map<String, Integer> values = setupCacheForAggregationTests(client);
+
+        ImmutableCacheStatsHolder allLevelsStatsHolder = getNodeCacheStatsResult(
+            client,
+            List.of(IndicesRequestCache.INDEX_DIMENSION_NAME, TIER_DIMENSION_NAME)
+        );
+        ImmutableCacheStatsHolder indicesOnlyStatsHolder = getNodeCacheStatsResult(
+            client,
+            List.of(IndicesRequestCache.INDEX_DIMENSION_NAME)
+        );
+
+        // Get values for indices alone, assert these match for statsHolders that have additional dimensions vs. a statsHolder that only has
+        // the indices dimension
+        ImmutableCacheStats index1ExpectedStats = returnNullIfAllZero(
+            new ImmutableCacheStats(
+                values.get("hitsOnHeapIndex1") + values.get("hitsOnDiskIndex1"),
+                values.get("itemsOnDiskIndex1AfterTest") + values.get("itemsOnHeapIndex1AfterTest"),
+                0,
+                (values.get("itemsOnDiskIndex1AfterTest") + values.get("itemsOnHeapIndex1AfterTest")) * values.get("singleSearchSize"),
+                values.get("itemsOnDiskIndex1AfterTest") + values.get("itemsOnHeapIndex1AfterTest")
+            )
+        );
+        ImmutableCacheStats index2ExpectedStats = returnNullIfAllZero(
+            new ImmutableCacheStats(
+                values.get("hitsOnHeapIndex2") + values.get("hitsOnDiskIndex2"),
+                values.get("itemsOnDiskIndex2AfterTest") + values.get("itemsOnHeapIndex2AfterTest"),
+                0,
+                (values.get("itemsOnDiskIndex2AfterTest") + values.get("itemsOnHeapIndex2AfterTest")) * values.get("singleSearchSize"),
+                values.get("itemsOnDiskIndex2AfterTest") + values.get("itemsOnHeapIndex2AfterTest")
+            )
+        );
+
+        for (ImmutableCacheStatsHolder statsHolder : List.of(allLevelsStatsHolder, indicesOnlyStatsHolder)) {
+            assertEquals(index1ExpectedStats, statsHolder.getStatsForDimensionValues(List.of(index1Name)));
+            assertEquals(index2ExpectedStats, statsHolder.getStatsForDimensionValues(List.of(index2Name)));
+        }
+    }
+
+    /**
+     * Test aggregating by indices and tier
+     */
+    public void testIndicesAndTierLevelAggregation() throws Exception {
+        internalCluster().startNodes(
+            1,
+            Settings.builder()
+                .put(TieredSpilloverCacheIT.defaultSettings(HEAP_CACHE_SIZE_STRING))
+                .put(
+                    TieredSpilloverCacheSettings.TOOK_TIME_POLICY_CONCRETE_SETTINGS_MAP.get(CacheType.INDICES_REQUEST_CACHE).getKey(),
+                    new TimeValue(0, TimeUnit.SECONDS)
+                )
+                .build()
+        );
+        Client client = client();
+        Map<String, Integer> values = setupCacheForAggregationTests(client);
+
+        ImmutableCacheStatsHolder allLevelsStatsHolder = getNodeCacheStatsResult(
+            client,
+            List.of(IndicesRequestCache.INDEX_DIMENSION_NAME, TIER_DIMENSION_NAME)
+        );
+
+        // Get values broken down by indices+tiers
+        ImmutableCacheStats index1HeapExpectedStats = returnNullIfAllZero(
+            new ImmutableCacheStats(
+                values.get("hitsOnHeapIndex1"),
+                values.get("itemsOnHeapIndex1AfterTest") + values.get("itemsOnDiskIndex1AfterTest") + values.get("hitsOnDiskIndex1"),
+                values.get("itemsOnDiskIndex1AfterTest"),
+                values.get("itemsOnHeapIndex1AfterTest") * values.get("singleSearchSize"),
+                values.get("itemsOnHeapIndex1AfterTest")
+            )
+        );
+        assertEquals(
+            index1HeapExpectedStats,
+            allLevelsStatsHolder.getStatsForDimensionValues(List.of(index1Name, TIER_DIMENSION_VALUE_ON_HEAP))
+        );
+
+        ImmutableCacheStats index2HeapExpectedStats = returnNullIfAllZero(
+            new ImmutableCacheStats(
+                values.get("hitsOnHeapIndex2"),
+                values.get("itemsOnHeapIndex2AfterTest") + values.get("itemsOnDiskIndex2AfterTest") + values.get("hitsOnDiskIndex2"),
+                values.get("itemsOnDiskIndex2AfterTest"),
+                values.get("itemsOnHeapIndex2AfterTest") * values.get("singleSearchSize"),
+                values.get("itemsOnHeapIndex2AfterTest")
+            )
+        );
+        assertEquals(
+            index2HeapExpectedStats,
+            allLevelsStatsHolder.getStatsForDimensionValues(List.of(index2Name, TIER_DIMENSION_VALUE_ON_HEAP))
+        );
+
+        ImmutableCacheStats index1DiskExpectedStats = returnNullIfAllZero(
+            new ImmutableCacheStats(
+                values.get("hitsOnDiskIndex1"),
+                values.get("itemsOnHeapIndex1AfterTest") + values.get("itemsOnDiskIndex1AfterTest"),
+                0,
+                values.get("itemsOnDiskIndex1AfterTest") * values.get("singleSearchSize"),
+                values.get("itemsOnDiskIndex1AfterTest")
+            )
+        );
+        assertEquals(
+            index1DiskExpectedStats,
+            allLevelsStatsHolder.getStatsForDimensionValues(List.of(index1Name, TIER_DIMENSION_VALUE_DISK))
+        );
+
+        ImmutableCacheStats index2DiskExpectedStats = returnNullIfAllZero(
+            new ImmutableCacheStats(
+                values.get("hitsOnDiskIndex2"),
+                values.get("itemsOnHeapIndex2AfterTest") + values.get("itemsOnDiskIndex2AfterTest"),
+                0,
+                values.get("itemsOnDiskIndex2AfterTest") * values.get("singleSearchSize"),
+                values.get("itemsOnDiskIndex2AfterTest")
+            )
+        );
+        assertEquals(
+            index2DiskExpectedStats,
+            allLevelsStatsHolder.getStatsForDimensionValues(List.of(index2Name, TIER_DIMENSION_VALUE_DISK))
+        );
+    }
+
+    /**
+     * Test aggregating by tier only
+     */
+    public void testTierLevelAggregation() throws Exception {
+        internalCluster().startNodes(
+            1,
+            Settings.builder()
+                .put(TieredSpilloverCacheIT.defaultSettings(HEAP_CACHE_SIZE_STRING))
+                .put(
+                    TieredSpilloverCacheSettings.TOOK_TIME_POLICY_CONCRETE_SETTINGS_MAP.get(CacheType.INDICES_REQUEST_CACHE).getKey(),
+                    new TimeValue(0, TimeUnit.SECONDS)
+                )
+                .build()
+        );
+        Client client = client();
+        Map<String, Integer> values = setupCacheForAggregationTests(client);
+
+        // Get values for tiers alone and check they add correctly across indices
+        ImmutableCacheStatsHolder tiersOnlyStatsHolder = getNodeCacheStatsResult(client, List.of(TIER_DIMENSION_NAME));
+        ImmutableCacheStats totalHeapExpectedStats = returnNullIfAllZero(
+            new ImmutableCacheStats(
+                values.get("hitsOnHeapIndex1") + values.get("hitsOnHeapIndex2"),
+                values.get("itemsOnHeapAfterTest") + values.get("itemsOnDiskAfterTest") + values.get("hitsOnDiskIndex1") + values.get(
+                    "hitsOnDiskIndex2"
+                ),
+                values.get("itemsOnDiskAfterTest"),
+                values.get("itemsOnHeapAfterTest") * values.get("singleSearchSize"),
+                values.get("itemsOnHeapAfterTest")
+            )
+        );
+        ImmutableCacheStats heapStats = tiersOnlyStatsHolder.getStatsForDimensionValues(List.of(TIER_DIMENSION_VALUE_ON_HEAP));
+        assertEquals(totalHeapExpectedStats, heapStats);
+        ImmutableCacheStats totalDiskExpectedStats = returnNullIfAllZero(
+            new ImmutableCacheStats(
+                values.get("hitsOnDiskIndex1") + values.get("hitsOnDiskIndex2"),
+                values.get("itemsOnHeapAfterTest") + values.get("itemsOnDiskAfterTest"),
+                0,
+                values.get("itemsOnDiskAfterTest") * values.get("singleSearchSize"),
+                values.get("itemsOnDiskAfterTest")
+            )
+        );
+        ImmutableCacheStats diskStats = tiersOnlyStatsHolder.getStatsForDimensionValues(List.of(TIER_DIMENSION_VALUE_DISK));
+        assertEquals(totalDiskExpectedStats, diskStats);
+    }
+
+    public void testInvalidLevelsAreIgnored() throws Exception {
+        internalCluster().startNodes(
+            1,
+            Settings.builder()
+                .put(TieredSpilloverCacheIT.defaultSettings(HEAP_CACHE_SIZE_STRING))
+                .put(
+                    TieredSpilloverCacheSettings.TOOK_TIME_POLICY_CONCRETE_SETTINGS_MAP.get(CacheType.INDICES_REQUEST_CACHE).getKey(),
+                    new TimeValue(0, TimeUnit.SECONDS)
+                )
+                .build()
+        );
+        Client client = client();
+        Map<String, Integer> values = setupCacheForAggregationTests(client);
+
+        ImmutableCacheStatsHolder allLevelsStatsHolder = getNodeCacheStatsResult(
+            client,
+            List.of(IndicesRequestCache.INDEX_DIMENSION_NAME, TIER_DIMENSION_NAME)
+        );
+        ImmutableCacheStatsHolder indicesOnlyStatsHolder = getNodeCacheStatsResult(
+            client,
+            List.of(IndicesRequestCache.INDEX_DIMENSION_NAME)
+        );
+
+        // Test invalid levels are ignored and permuting the order of levels in the request doesn't matter
+
+        // This should be equivalent to just "indices"
+        ImmutableCacheStatsHolder indicesEquivalentStatsHolder = getNodeCacheStatsResult(
+            client,
+            List.of(IndicesRequestCache.INDEX_DIMENSION_NAME, "unrecognized_dimension")
+        );
+        assertEquals(indicesOnlyStatsHolder, indicesEquivalentStatsHolder);
+
+        // This should be equivalent to "indices", "tier"
+        ImmutableCacheStatsHolder indicesAndTierEquivalentStatsHolder = getNodeCacheStatsResult(
+            client,
+            List.of(TIER_DIMENSION_NAME, "unrecognized_dimension_1", IndicesRequestCache.INDEX_DIMENSION_NAME, "unrecognized_dimension_2")
+        );
+        assertEquals(allLevelsStatsHolder, indicesAndTierEquivalentStatsHolder);
+
+        // This should be equivalent to no levels passed in
+        ImmutableCacheStatsHolder noLevelsEquivalentStatsHolder = getNodeCacheStatsResult(
+            client,
+            List.of("unrecognized_dimension_1", "unrecognized_dimension_2")
+        );
+        ImmutableCacheStatsHolder noLevelsStatsHolder = getNodeCacheStatsResult(client, List.of());
+        assertEquals(noLevelsStatsHolder, noLevelsEquivalentStatsHolder);
+    }
+
+    /**
+     * Check the new stats API returns the same values as the old stats API.
+     */
+    public void testStatsMatchOldApi() throws Exception {
+        internalCluster().startNodes(
+            1,
+            Settings.builder()
+                .put(TieredSpilloverCacheIT.defaultSettings(HEAP_CACHE_SIZE_STRING))
+                .put(
+                    TieredSpilloverCacheSettings.TOOK_TIME_POLICY_CONCRETE_SETTINGS_MAP.get(CacheType.INDICES_REQUEST_CACHE).getKey(),
+                    new TimeValue(0, TimeUnit.SECONDS)
+                )
+                .build()
+        );
+        String index = "index";
+        Client client = client();
+        startIndex(client, index);
+
+        // First search one time to see how big a single value will be
+        searchIndex(client, index, 0);
+        // get total stats
+        long singleSearchSize = getTotalStats(client).getSizeInBytes();
+        // Select numbers so we get some values on both heap and disk
+        int itemsOnHeap = HEAP_CACHE_SIZE / (int) singleSearchSize;
+        int itemsOnDisk = 1 + randomInt(30); // The first one we search (to get the size) always goes to disk
+        int expectedEntries = itemsOnHeap + itemsOnDisk;
+
+        for (int i = 1; i < expectedEntries; i++) {
+            // Cause misses
+            searchIndex(client, index, i);
+        }
+        int expectedMisses = itemsOnHeap + itemsOnDisk;
+
+        // Cause some hits
+        int expectedHits = randomIntBetween(itemsOnHeap, expectedEntries); // Select it so some hits come from both tiers
+        for (int i = 0; i < expectedHits; i++) {
+            searchIndex(client, index, i);
+        }
+
+        ImmutableCacheStats totalStats = getNodeCacheStatsResult(client, List.of()).getTotalStats();
+
+        // Check the new stats API values are as expected
+        assertEquals(
+            new ImmutableCacheStats(expectedHits, expectedMisses, 0, expectedEntries * singleSearchSize, expectedEntries),
+            totalStats
+        );
+        // Now check the new stats API values for the cache as a whole match the old stats API values
+        RequestCacheStats oldAPIStats = client.admin()
+            .indices()
+            .prepareStats(index)
+            .setRequestCache(true)
+            .get()
+            .getTotal()
+            .getRequestCache();
+        assertEquals(oldAPIStats.getHitCount(), totalStats.getHits());
+        assertEquals(oldAPIStats.getMissCount(), totalStats.getMisses());
+        assertEquals(oldAPIStats.getEvictions(), totalStats.getEvictions());
+        assertEquals(oldAPIStats.getMemorySizeInBytes(), totalStats.getSizeInBytes());
+    }
+
+    private void startIndex(Client client, String indexName) throws InterruptedException {
+        assertAcked(
+            client.admin()
+                .indices()
+                .prepareCreate(indexName)
+                .setMapping("k", "type=keyword")
+                .setSettings(
+                    Settings.builder()
+                        .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
+                        .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+                        .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
+                        .build()
+                )
+                .get()
+        );
+        indexRandom(true, client.prepareIndex(indexName).setSource("k", "hello"));
+        // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
+        ForceMergeResponse forceMergeResponse = client.admin().indices().prepareForceMerge(indexName).setFlush(true).get();
+        ensureSearchable(indexName);
+    }
+
+    private Map<String, Integer> setupCacheForAggregationTests(Client client) throws Exception {
+        startIndex(client, index1Name);
+        startIndex(client, index2Name);
+
+        // First search one time to see how big a single value will be
+        searchIndex(client, index1Name, 0);
+        // get total stats
+        long singleSearchSize = getTotalStats(client).getSizeInBytes();
+        int itemsOnHeapAfterTest = HEAP_CACHE_SIZE / (int) singleSearchSize; // As the heap tier evicts, the items on it after the test will
+        // be the same as its max capacity
+        int itemsOnDiskAfterTest = 1 + randomInt(30); // The first one we search (to get the size) always goes to disk
+
+        // Put some values on heap and disk for each index
+        int itemsOnHeapIndex1AfterTest = randomInt(itemsOnHeapAfterTest);
+        int itemsOnHeapIndex2AfterTest = itemsOnHeapAfterTest - itemsOnHeapIndex1AfterTest;
+        int itemsOnDiskIndex1AfterTest = 1 + randomInt(itemsOnDiskAfterTest - 1);
+        // The first one we search (to get the size) always goes to disk
+        int itemsOnDiskIndex2AfterTest = itemsOnDiskAfterTest - itemsOnDiskIndex1AfterTest;
+        int hitsOnHeapIndex1 = randomInt(itemsOnHeapIndex1AfterTest);
+        int hitsOnDiskIndex1 = randomInt(itemsOnDiskIndex1AfterTest);
+        int hitsOnHeapIndex2 = randomInt(itemsOnHeapIndex2AfterTest);
+        int hitsOnDiskIndex2 = randomInt(itemsOnDiskIndex2AfterTest);
+
+        // Put these values into a map so tests can know what to expect in stats responses
+        Map<String, Integer> expectedValues = new HashMap<>();
+        expectedValues.put("itemsOnHeapIndex1AfterTest", itemsOnHeapIndex1AfterTest);
+        expectedValues.put("itemsOnHeapIndex2AfterTest", itemsOnHeapIndex2AfterTest);
+        expectedValues.put("itemsOnDiskIndex1AfterTest", itemsOnDiskIndex1AfterTest);
+        expectedValues.put("itemsOnDiskIndex2AfterTest", itemsOnDiskIndex2AfterTest);
+        expectedValues.put("hitsOnHeapIndex1", hitsOnHeapIndex1);
+        expectedValues.put("hitsOnDiskIndex1", hitsOnDiskIndex1);
+        expectedValues.put("hitsOnHeapIndex2", hitsOnHeapIndex2);
+        expectedValues.put("hitsOnDiskIndex2", hitsOnDiskIndex2);
+        expectedValues.put("singleSearchSize", (int) singleSearchSize);
+        expectedValues.put("itemsOnDiskAfterTest", itemsOnDiskAfterTest);
+        expectedValues.put("itemsOnHeapAfterTest", itemsOnHeapAfterTest); // Can only pass 10 keys in Map.of() constructor
+
+        // The earliest items (0 - itemsOnDiskAfterTest) are the ones which get evicted to disk
+        for (int i = 1; i < itemsOnDiskIndex1AfterTest; i++) { // Start at 1 as 0 has already been searched
+            searchIndex(client, index1Name, i);
+        }
+        for (int i = itemsOnDiskIndex1AfterTest; i < itemsOnDiskIndex1AfterTest + itemsOnDiskIndex2AfterTest; i++) {
+            searchIndex(client, index2Name, i);
+        }
+        // The remaining items stay on heap
+        for (int i = itemsOnDiskAfterTest; i < itemsOnDiskAfterTest + itemsOnHeapIndex1AfterTest; i++) {
+            searchIndex(client, index1Name, i);
+        }
+        for (int i = itemsOnDiskAfterTest + itemsOnHeapIndex1AfterTest; i < itemsOnDiskAfterTest + itemsOnHeapAfterTest; i++) {
+            searchIndex(client, index2Name, i);
+        }
+
+        // Get some hits on all combinations of indices and tiers
+        for (int i = itemsOnDiskAfterTest; i < itemsOnDiskAfterTest + hitsOnHeapIndex1; i++) {
+            // heap hits for index 1
+            searchIndex(client, index1Name, i);
+        }
+        for (int i = itemsOnDiskAfterTest + itemsOnHeapIndex1AfterTest; i < itemsOnDiskAfterTest + itemsOnHeapIndex1AfterTest
+            + hitsOnHeapIndex2; i++) {
+            // heap hits for index 2
+            searchIndex(client, index2Name, i);
+        }
+        for (int i = 0; i < hitsOnDiskIndex1; i++) {
+            // disk hits for index 1
+            searchIndex(client, index1Name, i);
+        }
+        for (int i = itemsOnDiskIndex1AfterTest; i < itemsOnDiskIndex1AfterTest + hitsOnDiskIndex2; i++) {
+            // disk hits for index 2
+            searchIndex(client, index2Name, i);
+        }
+        return expectedValues;
+    }
+
+    private ImmutableCacheStats returnNullIfAllZero(ImmutableCacheStats expectedStats) {
+        // If the randomly chosen numbers are such that the expected stats would be 0, we actually have not interacted with the cache for
+        // this index.
+        // In this case, we expect the stats holder to have no stats for this node, and therefore we should get null from
+        // statsHolder.getStatsForDimensionValues().
+        // We will not see it in the XContent response.
+        if (expectedStats.equals(new ImmutableCacheStats(0, 0, 0, 0, 0))) {
+            return null;
+        }
+        return expectedStats;
+    }
+
+    // Duplicated from CacheStatsAPIIndicesRequestCacheIT.java, as we can't add a dependency on server.internalClusterTest
+
+    private SearchResponse searchIndex(Client client, String index, int searchSuffix) {
+        SearchResponse resp = client.prepareSearch(index)
+            .setRequestCache(true)
+            .setQuery(QueryBuilders.termQuery("k", "hello" + padWithZeros(4, searchSuffix)))
+            // pad with zeros so request 0 and request 10 have the same size ("0000" and "0010" instead of "0" and "10")
+            .get();
+        assertSearchResponse(resp);
+        OpenSearchAssertions.assertAllSuccessful(resp);
+        return resp;
+    }
+
+    private String padWithZeros(int finalLength, int inputValue) {
+        // Avoid forbidden API String.format()
+        String input = String.valueOf(inputValue);
+        if (input.length() >= finalLength) {
+            return input;
+        }
+        StringBuilder sb = new StringBuilder();
+        while (sb.length() < finalLength - input.length()) {
+            sb.append('0');
+        }
+        sb.append(input);
+        return sb.toString();
+    }
+
+    private ImmutableCacheStats getTotalStats(Client client) throws IOException {
+        ImmutableCacheStatsHolder statsHolder = getNodeCacheStatsResult(client, List.of());
+        return statsHolder.getStatsForDimensionValues(List.of());
+    }
+
+    private static ImmutableCacheStatsHolder getNodeCacheStatsResult(Client client, List<String> aggregationLevels) throws IOException {
+        CommonStatsFlags statsFlags = new CommonStatsFlags();
+        statsFlags.includeAllCacheTypes();
+        String[] flagsLevels;
+        if (aggregationLevels == null) {
+            flagsLevels = null;
+        } else {
+            flagsLevels = aggregationLevels.toArray(new String[0]);
+        }
+        statsFlags.setLevels(flagsLevels);
+
+        NodesStatsResponse nodeStatsResponse = client.admin()
+            .cluster()
+            .prepareNodesStats("data:true")
+            .addMetric(NodesStatsRequest.Metric.CACHE_STATS.metricName())
+            .setIndices(statsFlags)
+            .get();
+        // Can always get the first data node as there's only one in this test suite
+        assertEquals(1, nodeStatsResponse.getNodes().size());
+        NodeCacheStats ncs = nodeStatsResponse.getNodes().get(0).getNodeCacheStats();
+        return ncs.getStatsByCache(CacheType.INDICES_REQUEST_CACHE);
+    }
+}
diff --git a/modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCache.java b/modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCache.java
index 9942651ccdd67..f69c56808b2a1 100644
--- a/modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCache.java
+++ b/modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCache.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.cache.common.tier;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.opensearch.cache.common.policy.TookTimePolicy;
 import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.cache.CacheType;
@@ -35,9 +37,13 @@
 import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.ToLongBiFunction;
@@ -61,6 +67,7 @@ public class TieredSpilloverCache<K, V> implements ICache<K, V> {
 
     // Used to avoid caching stale entries in lower tiers.
     private static final List<RemovalReason> SPILLOVER_REMOVAL_REASONS = List.of(RemovalReason.EVICTED, RemovalReason.CAPACITY);
+    private static final Logger logger = LogManager.getLogger(TieredSpilloverCache.class);
 
     private final ICache<K, V> diskCache;
     private final ICache<K, V> onHeapCache;
@@ -86,6 +93,12 @@ public class TieredSpilloverCache<K, V> implements ICache<K, V> {
     private final Map<ICache<K, V>, TierInfo> caches;
     private final List<Predicate<V>> policies;
 
+    /**
+     * This map is used to handle concurrent requests for same key in computeIfAbsent() to ensure we load the value
+     * only once.
+     */
+    Map<ICacheKey<K>, CompletableFuture<Tuple<ICacheKey<K>, V>>> completableFutureMap = new ConcurrentHashMap<>();
+
     TieredSpilloverCache(Builder<K, V> builder) {
         Objects.requireNonNull(builder.onHeapCacheFactory, "onHeap cache builder can't be null");
         Objects.requireNonNull(builder.diskCacheFactory, "disk cache builder can't be null");
@@ -119,6 +132,8 @@ public class TieredSpilloverCache<K, V> implements ICache<K, V> {
                 .setValueType(builder.cacheConfig.getValueType())
                 .setSettings(builder.cacheConfig.getSettings())
                 .setWeigher(builder.cacheConfig.getWeigher())
+                .setKeySerializer(builder.cacheConfig.getKeySerializer())
+                .setValueSerializer(builder.cacheConfig.getValueSerializer())
                 .setDimensionNames(builder.cacheConfig.getDimensionNames())
                 .setStatsTrackingEnabled(false)
                 .build(),
@@ -180,7 +195,16 @@ public V computeIfAbsent(ICacheKey<K> key, LoadAwareCacheLoader<ICacheKey<K>, V>
         // and it only has to be loaded one time, we should report one miss and the rest hits. But, if we do stats in
         // getValueFromTieredCache(),
         // we will see all misses. Instead, handle stats in computeIfAbsent().
-        Tuple<V, String> cacheValueTuple = getValueFromTieredCache(false).apply(key);
+        Tuple<V, String> cacheValueTuple;
+        CompletableFuture<Tuple<ICacheKey<K>, V>> future = null;
+        try (ReleasableLock ignore = readLock.acquire()) {
+            cacheValueTuple = getValueFromTieredCache(false).apply(key);
+            if (cacheValueTuple == null) {
+                // Only one of the threads will succeed putting a future into map for the same key.
+                // Rest will fetch existing future and wait on that to complete.
+                future = completableFutureMap.putIfAbsent(key, new CompletableFuture<>());
+            }
+        }
         List<String> heapDimensionValues = statsHolder.getDimensionsWithTierValue(key.dimensions, TIER_DIMENSION_VALUE_ON_HEAP);
         List<String> diskDimensionValues = statsHolder.getDimensionsWithTierValue(key.dimensions, TIER_DIMENSION_VALUE_DISK);
 
@@ -188,10 +212,7 @@ public V computeIfAbsent(ICacheKey<K> key, LoadAwareCacheLoader<ICacheKey<K>, V>
             // Add the value to the onHeap cache. We are calling computeIfAbsent which does another get inside.
             // This is needed as there can be many requests for the same key at the same time and we only want to load
             // the value once.
-            V value = null;
-            try (ReleasableLock ignore = writeLock.acquire()) {
-                value = onHeapCache.computeIfAbsent(key, loader);
-            }
+            V value = compute(key, loader, future);
             // Handle stats
             if (loader.isLoaded()) {
                 // The value was just computed and added to the cache by this thread. Register a miss for the heap cache, and the disk cache
@@ -220,6 +241,55 @@ public V computeIfAbsent(ICacheKey<K> key, LoadAwareCacheLoader<ICacheKey<K>, V>
         return cacheValueTuple.v1();
     }
 
+    private V compute(ICacheKey<K> key, LoadAwareCacheLoader<ICacheKey<K>, V> loader, CompletableFuture<Tuple<ICacheKey<K>, V>> future)
+        throws Exception {
+        // Handler to handle results post processing. Takes a tuple<key, value> or exception as an input and returns
+        // the value. Also before returning value, puts the value in cache.
+        BiFunction<Tuple<ICacheKey<K>, V>, Throwable, Void> handler = (pair, ex) -> {
+            if (pair != null) {
+                try (ReleasableLock ignore = writeLock.acquire()) {
+                    onHeapCache.put(pair.v1(), pair.v2());
+                } catch (Exception e) {
+                    // TODO: Catch specific exceptions to know whether this resulted from cache or underlying removal
+                    // listeners/stats. Needs better exception handling at underlying layers.For now swallowing
+                    // exception.
+                    logger.warn("Exception occurred while putting item onto heap cache", e);
+                }
+            } else {
+                if (ex != null) {
+                    logger.warn("Exception occurred while trying to compute the value", ex);
+                }
+            }
+            completableFutureMap.remove(key);// Remove key from map as not needed anymore.
+            return null;
+        };
+        V value = null;
+        if (future == null) {
+            future = completableFutureMap.get(key);
+            future.handle(handler);
+            try {
+                value = loader.load(key);
+            } catch (Exception ex) {
+                future.completeExceptionally(ex);
+                throw new ExecutionException(ex);
+            }
+            if (value == null) {
+                NullPointerException npe = new NullPointerException("Loader returned a null value");
+                future.completeExceptionally(npe);
+                throw new ExecutionException(npe);
+            } else {
+                future.complete(new Tuple<>(key, value));
+            }
+        } else {
+            try {
+                value = future.get().v2();
+            } catch (InterruptedException ex) {
+                throw new IllegalStateException(ex);
+            }
+        }
+        return value;
+    }
+
     @Override
     public void invalidate(ICacheKey<K> key) {
         // We are trying to invalidate the key from all caches though it would be present in only of them.
@@ -325,30 +395,48 @@ private Function<ICacheKey<K>, Tuple<V, String>> getValueFromTieredCache(boolean
     void handleRemovalFromHeapTier(RemovalNotification<ICacheKey<K>, V> notification) {
         ICacheKey<K> key = notification.getKey();
         boolean wasEvicted = SPILLOVER_REMOVAL_REASONS.contains(notification.getRemovalReason());
-        if (caches.get(diskCache).isEnabled() && wasEvicted && evaluatePolicies(notification.getValue())) {
+        boolean countEvictionTowardsTotal = false; // Don't count this eviction towards the cache's total if it ends up in the disk tier
+        boolean exceptionOccurredOnDiskCachePut = false;
+        boolean canCacheOnDisk = caches.get(diskCache).isEnabled() && wasEvicted && evaluatePolicies(notification.getValue());
+        if (canCacheOnDisk) {
             try (ReleasableLock ignore = writeLock.acquire()) {
                 diskCache.put(key, notification.getValue()); // spill over to the disk tier and increment its stats
+            } catch (Exception ex) {
+                // TODO: Catch specific exceptions. Needs better exception handling. We are just swallowing exception
+                // in this case as it shouldn't cause upstream request to fail.
+                logger.warn("Exception occurred while putting item to disk cache", ex);
+                exceptionOccurredOnDiskCachePut = true;
             }
-            updateStatsOnPut(TIER_DIMENSION_VALUE_DISK, key, notification.getValue());
-        } else {
+            if (!exceptionOccurredOnDiskCachePut) {
+                updateStatsOnPut(TIER_DIMENSION_VALUE_DISK, key, notification.getValue());
+            }
+        }
+        if (!canCacheOnDisk || exceptionOccurredOnDiskCachePut) {
             // If the value is not going to the disk cache, send this notification to the TSC's removal listener
             // as the value is leaving the TSC entirely
             removalListener.onRemoval(notification);
+            countEvictionTowardsTotal = true;
         }
-        updateStatsOnRemoval(TIER_DIMENSION_VALUE_ON_HEAP, wasEvicted, key, notification.getValue());
+        updateStatsOnRemoval(TIER_DIMENSION_VALUE_ON_HEAP, wasEvicted, key, notification.getValue(), countEvictionTowardsTotal);
     }
 
     void handleRemovalFromDiskTier(RemovalNotification<ICacheKey<K>, V> notification) {
         // Values removed from the disk tier leave the TSC entirely
         removalListener.onRemoval(notification);
         boolean wasEvicted = SPILLOVER_REMOVAL_REASONS.contains(notification.getRemovalReason());
-        updateStatsOnRemoval(TIER_DIMENSION_VALUE_DISK, wasEvicted, notification.getKey(), notification.getValue());
+        updateStatsOnRemoval(TIER_DIMENSION_VALUE_DISK, wasEvicted, notification.getKey(), notification.getValue(), true);
     }
 
-    void updateStatsOnRemoval(String removedFromTierValue, boolean wasEvicted, ICacheKey<K> key, V value) {
+    void updateStatsOnRemoval(
+        String removedFromTierValue,
+        boolean wasEvicted,
+        ICacheKey<K> key,
+        V value,
+        boolean countEvictionTowardsTotal
+    ) {
         List<String> dimensionValues = statsHolder.getDimensionsWithTierValue(key.dimensions, removedFromTierValue);
         if (wasEvicted) {
-            statsHolder.incrementEvictions(dimensionValues);
+            statsHolder.incrementEvictions(dimensionValues, countEvictionTowardsTotal);
         }
         statsHolder.decrementItems(dimensionValues);
         statsHolder.decrementSizeInBytes(dimensionValues, weigher.applyAsLong(key, value));
diff --git a/modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCacheStatsHolder.java b/modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCacheStatsHolder.java
index d17059e8dee94..b40724430454b 100644
--- a/modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCacheStatsHolder.java
+++ b/modules/cache-common/src/main/java/org/opensearch/cache/common/tier/TieredSpilloverCacheStatsHolder.java
@@ -105,20 +105,29 @@ public void incrementMisses(List<String> dimensionValues) {
         internalIncrement(dimensionValues, missIncrementer, true);
     }
 
+    /**
+     * This method shouldn't be used in this class. Instead, use incrementEvictions(dimensionValues, includeInTotal)
+     * which specifies whether the eviction should be included in the cache's total evictions, or if it should
+     * just count towards that tier's evictions.
+     * @param dimensionValues The dimension values
+     */
     @Override
     public void incrementEvictions(List<String> dimensionValues) {
-        final String tierValue = validateTierDimensionValue(dimensionValues);
+        throw new UnsupportedOperationException(
+            "TieredSpilloverCacheHolder must specify whether to include an eviction in the total cache stats. Use incrementEvictions(List<String> dimensionValues, boolean includeInTotal)"
+        );
+    }
 
-        // If the disk tier is present, only evictions from the disk tier should be included in total values.
+    /**
+     * Increment evictions for this set of dimension values.
+     * @param dimensionValues The dimension values
+     * @param includeInTotal Whether to include this eviction in the total for the whole cache's evictions
+     */
+    public void incrementEvictions(List<String> dimensionValues, boolean includeInTotal) {
+        validateTierDimensionValue(dimensionValues);
+        // If we count this eviction towards the total, we should increment all ancestor nodes. If not, only increment the leaf node.
         Consumer<DefaultCacheStatsHolder.Node> evictionsIncrementer = (node) -> {
-            if (tierValue.equals(TIER_DIMENSION_VALUE_ON_HEAP) && diskCacheEnabled) {
-                // If on-heap tier, increment only the leaf node corresponding to the on heap values; not the total values in its parent
-                // nodes
-                if (node.isAtLowestLevel()) {
-                    node.incrementEvictions();
-                }
-            } else {
-                // If disk tier, or on-heap tier with a disabled disk tier, increment the leaf node and its parents
+            if (includeInTotal || node.isAtLowestLevel()) {
                 node.incrementEvictions();
             }
         };
diff --git a/modules/cache-common/src/test/java/org/opensearch/cache/common/tier/MockDiskCache.java b/modules/cache-common/src/test/java/org/opensearch/cache/common/tier/MockDiskCache.java
index 2058faa5181b1..69e2060f7ea2f 100644
--- a/modules/cache-common/src/test/java/org/opensearch/cache/common/tier/MockDiskCache.java
+++ b/modules/cache-common/src/test/java/org/opensearch/cache/common/tier/MockDiskCache.java
@@ -141,6 +141,10 @@ public MockDiskCacheFactory(long delay, int maxSize, boolean statsTrackingEnable
         @Override
         @SuppressWarnings({ "unchecked" })
         public <K, V> ICache<K, V> create(CacheConfig<K, V> config, CacheType cacheType, Map<String, Factory> cacheFactories) {
+            // As we can't directly IT with the tiered cache and ehcache, check that we receive non-null serializers, as an ehcache disk
+            // cache would require.
+            assert config.getKeySerializer() != null;
+            assert config.getValueSerializer() != null;
             return new Builder<K, V>().setKeySerializer((Serializer<K, byte[]>) config.getKeySerializer())
                 .setValueSerializer((Serializer<V, byte[]>) config.getValueSerializer())
                 .setMaxSize(maxSize)
diff --git a/modules/cache-common/src/test/java/org/opensearch/cache/common/tier/TieredSpilloverCacheTests.java b/modules/cache-common/src/test/java/org/opensearch/cache/common/tier/TieredSpilloverCacheTests.java
index 6d5ee91326338..c6440a1e1797f 100644
--- a/modules/cache-common/src/test/java/org/opensearch/cache/common/tier/TieredSpilloverCacheTests.java
+++ b/modules/cache-common/src/test/java/org/opensearch/cache/common/tier/TieredSpilloverCacheTests.java
@@ -16,6 +16,7 @@
 import org.opensearch.common.cache.RemovalListener;
 import org.opensearch.common.cache.RemovalNotification;
 import org.opensearch.common.cache.policy.CachedQueryResult;
+import org.opensearch.common.cache.serializer.Serializer;
 import org.opensearch.common.cache.settings.CacheSettings;
 import org.opensearch.common.cache.stats.ImmutableCacheStats;
 import org.opensearch.common.cache.stats.ImmutableCacheStatsHolder;
@@ -32,6 +33,8 @@
 import org.junit.Before;
 
 import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -41,8 +44,12 @@
 import java.util.UUID;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.Phaser;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 import java.util.function.Predicate;
@@ -53,6 +60,10 @@
 import static org.opensearch.cache.common.tier.TieredSpilloverCacheStatsHolder.TIER_DIMENSION_VALUE_DISK;
 import static org.opensearch.cache.common.tier.TieredSpilloverCacheStatsHolder.TIER_DIMENSION_VALUE_ON_HEAP;
 import static org.opensearch.common.cache.store.settings.OpenSearchOnHeapCacheSettings.MAXIMUM_SIZE_IN_BYTES_KEY;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class TieredSpilloverCacheTests extends OpenSearchTestCase {
     static final List<String> dimensionNames = List.of("dim1", "dim2", "dim3");
@@ -166,6 +177,8 @@ public void testComputeIfAbsentWithFactoryBasedCacheCreation() throws Exception
                 .setKeyType(String.class)
                 .setWeigher((k, v) -> keyValueSize)
                 .setRemovalListener(removalListener)
+                .setKeySerializer(new StringSerializer())
+                .setValueSerializer(new StringSerializer())
                 .setSettings(settings)
                 .setDimensionNames(dimensionNames)
                 .setCachedResultParser(s -> new CachedQueryResult.PolicyValues(20_000_000L)) // Values will always appear to have taken
@@ -318,6 +331,8 @@ public void testComputeIfAbsentWithEvictionsFromOnHeapCache() throws Exception {
             .setKeyType(String.class)
             .setWeigher((k, v) -> keyValueSize)
             .setRemovalListener(removalListener)
+            .setKeySerializer(new StringSerializer())
+            .setValueSerializer(new StringSerializer())
             .setDimensionNames(dimensionNames)
             .setSettings(
                 Settings.builder()
@@ -401,6 +416,7 @@ public void testComputeIfAbsentWithEvictionsFromOnHeapCache() throws Exception {
         assertEquals(onHeapCacheHit, getHitsForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_ON_HEAP));
         assertEquals(cacheMiss + numOfItems1, getMissesForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_DISK));
         assertEquals(diskCacheHit, getHitsForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_DISK));
+        assertEquals(0, tieredSpilloverCache.completableFutureMap.size());
     }
 
     public void testComputeIfAbsentWithEvictionsFromTieredCache() throws Exception {
@@ -744,7 +760,7 @@ public void testInvalidateAll() throws Exception {
     }
 
     public void testComputeIfAbsentConcurrently() throws Exception {
-        int onHeapCacheSize = randomIntBetween(100, 300);
+        int onHeapCacheSize = randomIntBetween(500, 700);
         int diskCacheSize = randomIntBetween(200, 400);
         int keyValueSize = 50;
 
@@ -766,7 +782,7 @@ public void testComputeIfAbsentConcurrently() throws Exception {
             0
         );
 
-        int numberOfSameKeys = randomIntBetween(10, onHeapCacheSize - 1);
+        int numberOfSameKeys = randomIntBetween(400, onHeapCacheSize - 1);
         ICacheKey<String> key = getICacheKey(UUID.randomUUID().toString());
         String value = UUID.randomUUID().toString();
 
@@ -795,7 +811,7 @@ public String load(ICacheKey<String> key) {
                     };
                     loadAwareCacheLoaderList.add(loadAwareCacheLoader);
                     phaser.arriveAndAwaitAdvance();
-                    tieredSpilloverCache.computeIfAbsent(key, loadAwareCacheLoader);
+                    assertEquals(value, tieredSpilloverCache.computeIfAbsent(key, loadAwareCacheLoader));
                 } catch (Exception e) {
                     throw new RuntimeException(e);
                 }
@@ -804,7 +820,7 @@ public String load(ICacheKey<String> key) {
             threads[i].start();
         }
         phaser.arriveAndAwaitAdvance();
-        countDownLatch.await(); // Wait for rest of tasks to be cancelled.
+        countDownLatch.await();
         int numberOfTimesKeyLoaded = 0;
         assertEquals(numberOfSameKeys, loadAwareCacheLoaderList.size());
         for (int i = 0; i < loadAwareCacheLoaderList.size(); i++) {
@@ -817,6 +833,215 @@ public String load(ICacheKey<String> key) {
         // We should see only one heap miss, and the rest hits
         assertEquals(1, getMissesForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_ON_HEAP));
         assertEquals(numberOfSameKeys - 1, getHitsForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_ON_HEAP));
+        assertEquals(0, tieredSpilloverCache.completableFutureMap.size());
+    }
+
+    public void testComputIfAbsentConcurrentlyWithMultipleKeys() throws Exception {
+        int onHeapCacheSize = randomIntBetween(300, 500);
+        int diskCacheSize = randomIntBetween(600, 700);
+        int keyValueSize = 50;
+
+        MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
+        Settings settings = Settings.builder()
+            .put(
+                OpenSearchOnHeapCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .get(MAXIMUM_SIZE_IN_BYTES_KEY)
+                    .getKey(),
+                onHeapCacheSize * keyValueSize + "b"
+            )
+            .build();
+
+        TieredSpilloverCache<String, String> tieredSpilloverCache = initializeTieredSpilloverCache(
+            keyValueSize,
+            diskCacheSize,
+            removalListener,
+            settings,
+            0
+        );
+
+        int iterations = 10;
+        int numberOfKeys = 20;
+        List<ICacheKey<String>> iCacheKeyList = new ArrayList<>();
+        for (int i = 0; i < numberOfKeys; i++) {
+            ICacheKey<String> key = getICacheKey(UUID.randomUUID().toString());
+            iCacheKeyList.add(key);
+        }
+        ExecutorService executorService = Executors.newFixedThreadPool(8);
+        CountDownLatch countDownLatch = new CountDownLatch(iterations * numberOfKeys); // To wait for all threads to finish.
+
+        List<LoadAwareCacheLoader<ICacheKey<String>, String>> loadAwareCacheLoaderList = new CopyOnWriteArrayList<>();
+        for (int j = 0; j < numberOfKeys; j++) {
+            int finalJ = j;
+            for (int i = 0; i < iterations; i++) {
+                executorService.submit(() -> {
+                    try {
+                        LoadAwareCacheLoader<ICacheKey<String>, String> loadAwareCacheLoader = new LoadAwareCacheLoader<>() {
+                            boolean isLoaded = false;
+
+                            @Override
+                            public boolean isLoaded() {
+                                return isLoaded;
+                            }
+
+                            @Override
+                            public String load(ICacheKey<String> key) {
+                                isLoaded = true;
+                                return iCacheKeyList.get(finalJ).key;
+                            }
+                        };
+                        loadAwareCacheLoaderList.add(loadAwareCacheLoader);
+                        tieredSpilloverCache.computeIfAbsent(iCacheKeyList.get(finalJ), loadAwareCacheLoader);
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    } finally {
+                        countDownLatch.countDown();
+                    }
+                });
+            }
+        }
+        countDownLatch.await();
+        int numberOfTimesKeyLoaded = 0;
+        assertEquals(iterations * numberOfKeys, loadAwareCacheLoaderList.size());
+        for (int i = 0; i < loadAwareCacheLoaderList.size(); i++) {
+            LoadAwareCacheLoader<ICacheKey<String>, String> loader = loadAwareCacheLoaderList.get(i);
+            if (loader.isLoaded()) {
+                numberOfTimesKeyLoaded++;
+            }
+        }
+        assertEquals(numberOfKeys, numberOfTimesKeyLoaded); // It should be loaded only once.
+        // We should see only one heap miss, and the rest hits
+        assertEquals(numberOfKeys, getMissesForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_ON_HEAP));
+        assertEquals((iterations * numberOfKeys) - numberOfKeys, getHitsForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_ON_HEAP));
+        assertEquals(0, tieredSpilloverCache.completableFutureMap.size());
+        executorService.shutdownNow();
+    }
+
+    public void testComputeIfAbsentConcurrentlyAndThrowsException() throws Exception {
+        LoadAwareCacheLoader<ICacheKey<String>, String> loadAwareCacheLoader = new LoadAwareCacheLoader<>() {
+            boolean isLoaded = false;
+
+            @Override
+            public boolean isLoaded() {
+                return isLoaded;
+            }
+
+            @Override
+            public String load(ICacheKey<String> key) {
+                throw new RuntimeException("Testing");
+            }
+        };
+        verifyComputeIfAbsentThrowsException(RuntimeException.class, loadAwareCacheLoader, "Testing");
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public void testComputeIfAbsentWithOnHeapCacheThrowingExceptionOnPut() throws Exception {
+        int onHeapCacheSize = randomIntBetween(100, 300);
+        int diskCacheSize = randomIntBetween(200, 400);
+        int keyValueSize = 50;
+
+        MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
+        Settings settings = Settings.builder()
+            .put(
+                OpenSearchOnHeapCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .get(MAXIMUM_SIZE_IN_BYTES_KEY)
+                    .getKey(),
+                onHeapCacheSize * keyValueSize + "b"
+            )
+            .build();
+        ICache.Factory onHeapCacheFactory = mock(OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory.class);
+        ICache mockOnHeapCache = mock(ICache.class);
+        when(onHeapCacheFactory.create(any(), any(), any())).thenReturn(mockOnHeapCache);
+        doThrow(new RuntimeException("Testing")).when(mockOnHeapCache).put(any(), any());
+        CacheConfig<String, String> cacheConfig = getCacheConfig(keyValueSize, settings, removalListener);
+        ICache.Factory mockDiskCacheFactory = new MockDiskCache.MockDiskCacheFactory(0, diskCacheSize, false);
+
+        TieredSpilloverCache<String, String> tieredSpilloverCache = getTieredSpilloverCache(
+            onHeapCacheFactory,
+            mockDiskCacheFactory,
+            cacheConfig,
+            null,
+            removalListener
+        );
+        String value = "";
+        value = tieredSpilloverCache.computeIfAbsent(getICacheKey("test"), new LoadAwareCacheLoader<>() {
+            @Override
+            public boolean isLoaded() {
+                return false;
+            }
+
+            @Override
+            public String load(ICacheKey<String> key) {
+                return "test";
+            }
+        });
+        assertEquals("test", value);
+        assertEquals(0, tieredSpilloverCache.completableFutureMap.size());
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public void testComputeIfAbsentWithDiskCacheThrowingExceptionOnPut() throws Exception {
+        int onHeapCacheSize = 0;
+        int keyValueSize = 50;
+
+        MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
+        Settings settings = Settings.builder()
+            .put(
+                OpenSearchOnHeapCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .get(MAXIMUM_SIZE_IN_BYTES_KEY)
+                    .getKey(),
+                onHeapCacheSize * keyValueSize + "b"
+            )
+            .build();
+        ICache.Factory onHeapCacheFactory = new OpenSearchOnHeapCache.OpenSearchOnHeapCacheFactory();
+        CacheConfig<String, String> cacheConfig = getCacheConfig(keyValueSize, settings, removalListener);
+        ICache.Factory mockDiskCacheFactory = mock(MockDiskCache.MockDiskCacheFactory.class);
+        ICache mockDiskCache = mock(ICache.class);
+        when(mockDiskCacheFactory.create(any(), any(), any())).thenReturn(mockDiskCache);
+        doThrow(new RuntimeException("Test")).when(mockDiskCache).put(any(), any());
+
+        TieredSpilloverCache<String, String> tieredSpilloverCache = getTieredSpilloverCache(
+            onHeapCacheFactory,
+            mockDiskCacheFactory,
+            cacheConfig,
+            null,
+            removalListener
+        );
+
+        String response = "";
+        response = tieredSpilloverCache.computeIfAbsent(getICacheKey("test"), new LoadAwareCacheLoader<>() {
+            @Override
+            public boolean isLoaded() {
+                return false;
+            }
+
+            @Override
+            public String load(ICacheKey<String> key) {
+                return "test";
+            }
+        });
+        ImmutableCacheStats diskStats = getStatsSnapshotForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_DISK);
+
+        assertEquals(0, diskStats.getSizeInBytes());
+        assertEquals(1, removalListener.evictionsMetric.count());
+        assertEquals("test", response);
+        assertEquals(0, tieredSpilloverCache.completableFutureMap.size());
+    }
+
+    public void testComputeIfAbsentConcurrentlyWithLoaderReturningNull() throws Exception {
+        LoadAwareCacheLoader<ICacheKey<String>, String> loadAwareCacheLoader = new LoadAwareCacheLoader<>() {
+            boolean isLoaded = false;
+
+            @Override
+            public boolean isLoaded() {
+                return isLoaded;
+            }
+
+            @Override
+            public String load(ICacheKey<String> key) {
+                return null;
+            }
+        };
+        verifyComputeIfAbsentThrowsException(NullPointerException.class, loadAwareCacheLoader, "Loader returned a null value");
     }
 
     public void testConcurrencyForEvictionFlowFromOnHeapToDiskTier() throws Exception {
@@ -830,6 +1055,8 @@ public void testConcurrencyForEvictionFlowFromOnHeapToDiskTier() throws Exceptio
             .setKeyType(String.class)
             .setWeigher((k, v) -> 150)
             .setRemovalListener(removalListener)
+            .setKeySerializer(new StringSerializer())
+            .setValueSerializer(new StringSerializer())
             .setSettings(
                 Settings.builder()
                     .put(
@@ -917,14 +1144,14 @@ public void testDiskTierPolicies() throws Exception {
         MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
         TieredSpilloverCache<String, String> tieredSpilloverCache = intializeTieredSpilloverCache(
             keyValueSize,
-            100,
+            keyValueSize * 100,
             removalListener,
             Settings.builder()
                 .put(
                     OpenSearchOnHeapCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
                         .get(MAXIMUM_SIZE_IN_BYTES_KEY)
                         .getKey(),
-                    onHeapCacheSize * 50 + "b"
+                    onHeapCacheSize * keyValueSize + "b"
                 )
                 .build(),
             0,
@@ -946,6 +1173,7 @@ public void testDiskTierPolicies() throws Exception {
 
         LoadAwareCacheLoader<ICacheKey<String>, String> loader = getLoadAwareCacheLoader(keyValuePairs);
 
+        int expectedEvictions = 0;
         for (String key : keyValuePairs.keySet()) {
             ICacheKey<String> iCacheKey = getICacheKey(key);
             Boolean expectedOutput = expectedOutputs.get(key);
@@ -958,8 +1186,15 @@ public void testDiskTierPolicies() throws Exception {
             } else {
                 // Should miss as heap tier size = 0 and the policy rejected it
                 assertNull(result);
+                expectedEvictions++;
             }
         }
+
+        // We expect values that were evicted from the heap tier and not allowed into the disk tier by the policy
+        // to count towards total evictions
+        assertEquals(keyValuePairs.size(), getEvictionsForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_ON_HEAP));
+        assertEquals(0, getEvictionsForTier(tieredSpilloverCache, TIER_DIMENSION_VALUE_DISK)); // Disk tier is large enough for no evictions
+        assertEquals(expectedEvictions, getTotalStatsSnapshot(tieredSpilloverCache).getEvictions());
     }
 
     public void testTookTimePolicyFromFactory() throws Exception {
@@ -1014,6 +1249,8 @@ public void testTookTimePolicyFromFactory() throws Exception {
                 .setKeyType(String.class)
                 .setWeigher((k, v) -> keyValueSize)
                 .setRemovalListener(removalListener)
+                .setKeySerializer(new StringSerializer())
+                .setValueSerializer(new StringSerializer())
                 .setSettings(settings)
                 .setMaxSizeInBytes(onHeapCacheSize * keyValueSize)
                 .setDimensionNames(dimensionNames)
@@ -1389,6 +1626,26 @@ public boolean isLoaded() {
         };
     }
 
+    private TieredSpilloverCache<String, String> getTieredSpilloverCache(
+        ICache.Factory onHeapCacheFactory,
+        ICache.Factory mockDiskCacheFactory,
+        CacheConfig<String, String> cacheConfig,
+        List<Predicate<String>> policies,
+        RemovalListener<ICacheKey<String>, String> removalListener
+    ) {
+        TieredSpilloverCache.Builder<String, String> builder = new TieredSpilloverCache.Builder<String, String>().setCacheType(
+            CacheType.INDICES_REQUEST_CACHE
+        )
+            .setRemovalListener(removalListener)
+            .setOnHeapCacheFactory(onHeapCacheFactory)
+            .setDiskCacheFactory(mockDiskCacheFactory)
+            .setCacheConfig(cacheConfig);
+        if (policies != null) {
+            builder.addPolicies(policies);
+        }
+        return builder.build();
+    }
+
     private TieredSpilloverCache<String, String> initializeTieredSpilloverCache(
         int keyValueSize,
         int diskCacheSize,
@@ -1415,6 +1672,8 @@ private TieredSpilloverCache<String, String> intializeTieredSpilloverCache(
             .setSettings(settings)
             .setDimensionNames(dimensionNames)
             .setRemovalListener(removalListener)
+            .setKeySerializer(new StringSerializer())
+            .setValueSerializer(new StringSerializer())
             .setSettings(
                 Settings.builder()
                     .put(
@@ -1429,17 +1688,34 @@ private TieredSpilloverCache<String, String> intializeTieredSpilloverCache(
             .build();
         ICache.Factory mockDiskCacheFactory = new MockDiskCache.MockDiskCacheFactory(diskDeliberateDelay, diskCacheSize, false);
 
-        TieredSpilloverCache.Builder<String, String> builder = new TieredSpilloverCache.Builder<String, String>().setCacheType(
-            CacheType.INDICES_REQUEST_CACHE
-        )
+        return getTieredSpilloverCache(onHeapCacheFactory, mockDiskCacheFactory, cacheConfig, policies, removalListener);
+    }
+
+    private CacheConfig<String, String> getCacheConfig(
+        int keyValueSize,
+        Settings settings,
+        RemovalListener<ICacheKey<String>, String> removalListener
+    ) {
+        return new CacheConfig.Builder<String, String>().setKeyType(String.class)
+            .setKeyType(String.class)
+            .setWeigher((k, v) -> keyValueSize)
+            .setSettings(settings)
+            .setDimensionNames(dimensionNames)
             .setRemovalListener(removalListener)
-            .setOnHeapCacheFactory(onHeapCacheFactory)
-            .setDiskCacheFactory(mockDiskCacheFactory)
-            .setCacheConfig(cacheConfig);
-        if (policies != null) {
-            builder.addPolicies(policies);
-        }
-        return builder.build();
+            .setKeySerializer(new StringSerializer())
+            .setValueSerializer(new StringSerializer())
+            .setSettings(
+                Settings.builder()
+                    .put(
+                        CacheSettings.getConcreteStoreNameSettingForCacheType(CacheType.INDICES_REQUEST_CACHE).getKey(),
+                        TieredSpilloverCache.TieredSpilloverCacheFactory.TIERED_SPILLOVER_CACHE_NAME
+                    )
+                    .put(FeatureFlags.PLUGGABLE_CACHE, "true")
+                    .put(settings)
+                    .build()
+            )
+            .setClusterSettings(clusterSettings)
+            .build();
     }
 
     // Helper functions for extracting tier aggregated stats.
@@ -1479,4 +1755,91 @@ private ImmutableCacheStats getStatsSnapshotForTier(TieredSpilloverCache<?, ?> t
         }
         return snapshot;
     }
+
+    private void verifyComputeIfAbsentThrowsException(
+        Class<? extends Exception> expectedException,
+        LoadAwareCacheLoader<ICacheKey<String>, String> loader,
+        String expectedExceptionMessage
+    ) throws InterruptedException {
+        int onHeapCacheSize = randomIntBetween(100, 300);
+        int diskCacheSize = randomIntBetween(200, 400);
+        int keyValueSize = 50;
+
+        MockCacheRemovalListener<String, String> removalListener = new MockCacheRemovalListener<>();
+        Settings settings = Settings.builder()
+            .put(
+                OpenSearchOnHeapCacheSettings.getSettingListForCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .get(MAXIMUM_SIZE_IN_BYTES_KEY)
+                    .getKey(),
+                onHeapCacheSize * keyValueSize + "b"
+            )
+            .build();
+
+        TieredSpilloverCache<String, String> tieredSpilloverCache = initializeTieredSpilloverCache(
+            keyValueSize,
+            diskCacheSize,
+            removalListener,
+            settings,
+            0
+        );
+
+        int numberOfSameKeys = randomIntBetween(10, onHeapCacheSize - 1);
+        ICacheKey<String> key = getICacheKey(UUID.randomUUID().toString());
+        String value = UUID.randomUUID().toString();
+        AtomicInteger exceptionCount = new AtomicInteger();
+
+        Thread[] threads = new Thread[numberOfSameKeys];
+        Phaser phaser = new Phaser(numberOfSameKeys + 1);
+        CountDownLatch countDownLatch = new CountDownLatch(numberOfSameKeys); // To wait for all threads to finish.
+
+        for (int i = 0; i < numberOfSameKeys; i++) {
+            threads[i] = new Thread(() -> {
+                try {
+                    phaser.arriveAndAwaitAdvance();
+                    tieredSpilloverCache.computeIfAbsent(key, loader);
+                } catch (Exception e) {
+                    exceptionCount.incrementAndGet();
+                    assertEquals(ExecutionException.class, e.getClass());
+                    assertEquals(expectedException, e.getCause().getClass());
+                    assertEquals(expectedExceptionMessage, e.getCause().getMessage());
+                } finally {
+                    countDownLatch.countDown();
+                }
+            });
+            threads[i].start();
+        }
+        phaser.arriveAndAwaitAdvance();
+        countDownLatch.await(); // Wait for rest of tasks to be cancelled.
+
+        // Verify exception count was equal to number of requests
+        assertEquals(numberOfSameKeys, exceptionCount.get());
+        assertEquals(0, tieredSpilloverCache.completableFutureMap.size());
+    }
+
+    private ImmutableCacheStats getTotalStatsSnapshot(TieredSpilloverCache<?, ?> tsc) throws IOException {
+        ImmutableCacheStatsHolder cacheStats = tsc.stats(new String[0]);
+        return cacheStats.getStatsForDimensionValues(List.of());
+    }
+
+    // Duplicated here from EhcacheDiskCacheTests.java, we can't add a dependency on that plugin
+    static class StringSerializer implements Serializer<String, byte[]> {
+        private final Charset charset = StandardCharsets.UTF_8;
+
+        @Override
+        public byte[] serialize(String object) {
+            return object.getBytes(charset);
+        }
+
+        @Override
+        public String deserialize(byte[] bytes) {
+            if (bytes == null) {
+                return null;
+            }
+            return new String(bytes, charset);
+        }
+
+        public boolean equals(String object, byte[] bytes) {
+            return object.equals(deserialize(bytes));
+        }
+    }
 }
diff --git a/modules/ingest-common/src/main/java/org/opensearch/ingest/common/CommunityIdProcessor.java b/modules/ingest-common/src/main/java/org/opensearch/ingest/common/CommunityIdProcessor.java
index c968fb2f6c2da..c84892971c87e 100644
--- a/modules/ingest-common/src/main/java/org/opensearch/ingest/common/CommunityIdProcessor.java
+++ b/modules/ingest-common/src/main/java/org/opensearch/ingest/common/CommunityIdProcessor.java
@@ -29,7 +29,7 @@
  * Processor that generating community id flow hash for the network flow tuples, the algorithm is defined in
  * <a href="https://github.com/corelight/community-id-spec">Community ID Flow Hashing</a>.
  */
-public class CommunityIdProcessor extends AbstractProcessor {
+public final class CommunityIdProcessor extends AbstractProcessor {
     public static final String TYPE = "community_id";
     // the version of the community id flow hashing algorithm
     private static final String COMMUNITY_ID_HASH_VERSION = "1";
diff --git a/modules/ingest-common/src/main/java/org/opensearch/ingest/common/FingerprintProcessor.java b/modules/ingest-common/src/main/java/org/opensearch/ingest/common/FingerprintProcessor.java
new file mode 100644
index 0000000000000..c2f59bf586c81
--- /dev/null
+++ b/modules/ingest-common/src/main/java/org/opensearch/ingest/common/FingerprintProcessor.java
@@ -0,0 +1,279 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.ingest.common;
+
+import org.opensearch.common.Nullable;
+import org.opensearch.common.hash.MessageDigests;
+import org.opensearch.core.common.Strings;
+import org.opensearch.ingest.AbstractProcessor;
+import org.opensearch.ingest.ConfigurationUtils;
+import org.opensearch.ingest.IngestDocument;
+import org.opensearch.ingest.Processor;
+
+import java.nio.charset.StandardCharsets;
+import java.security.MessageDigest;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.opensearch.ingest.ConfigurationUtils.newConfigurationException;
+
+/**
+ * Processor that generating hash value for the specified fields or fields not in the specified excluded list
+ */
+public final class FingerprintProcessor extends AbstractProcessor {
+    public static final String TYPE = "fingerprint";
+    // this processor is introduced in 2.16.0, we append the OpenSearch version to the hash method name to ensure
+    // that this processor always generates same hash value based on a specific hash method, if the processing logic
+    // of this processor changes in future version, the version number in the hash method should be increased correspondingly.
+    private static final Set<String> HASH_METHODS = Set.of("MD5@2.16.0", "SHA-1@2.16.0", "SHA-256@2.16.0", "SHA3-256@2.16.0");
+
+    // fields used to generate hash value
+    private final List<String> fields;
+    // all fields other than the excluded fields are used to generate hash value
+    private final List<String> excludeFields;
+    // the target field to store the hash value, defaults to fingerprint
+    private final String targetField;
+    // hash method used to generate the hash value, defaults to SHA-1
+    private final String hashMethod;
+    private final boolean ignoreMissing;
+
+    FingerprintProcessor(
+        String tag,
+        String description,
+        @Nullable List<String> fields,
+        @Nullable List<String> excludeFields,
+        String targetField,
+        String hashMethod,
+        boolean ignoreMissing
+    ) {
+        super(tag, description);
+        if (fields != null && !fields.isEmpty()) {
+            if (fields.stream().anyMatch(Strings::isNullOrEmpty)) {
+                throw new IllegalArgumentException("field name in [fields] cannot be null nor empty");
+            }
+            if (excludeFields != null && !excludeFields.isEmpty()) {
+                throw new IllegalArgumentException("either fields or exclude_fields can be set");
+            }
+        }
+        if (excludeFields != null && !excludeFields.isEmpty() && excludeFields.stream().anyMatch(Strings::isNullOrEmpty)) {
+            throw new IllegalArgumentException("field name in [exclude_fields] cannot be null nor empty");
+        }
+
+        if (!HASH_METHODS.contains(hashMethod.toUpperCase(Locale.ROOT))) {
+            throw new IllegalArgumentException("hash method must be MD5@2.16.0, SHA-1@2.16.0 or SHA-256@2.16.0 or SHA3-256@2.16.0");
+        }
+        this.fields = fields;
+        this.excludeFields = excludeFields;
+        this.targetField = targetField;
+        this.hashMethod = hashMethod;
+        this.ignoreMissing = ignoreMissing;
+    }
+
+    public List<String> getFields() {
+        return fields;
+    }
+
+    public List<String> getExcludeFields() {
+        return excludeFields;
+    }
+
+    public String getTargetField() {
+        return targetField;
+    }
+
+    public String getHashMethod() {
+        return hashMethod;
+    }
+
+    public boolean isIgnoreMissing() {
+        return ignoreMissing;
+    }
+
+    @Override
+    public IngestDocument execute(IngestDocument document) {
+        // we should deduplicate and sort the field names to make sure we can get consistent hash value
+        final List<String> sortedFields;
+        Set<String> existingFields = new HashSet<>(document.getSourceAndMetadata().keySet());
+        Set<String> metadataFields = document.getMetadata()
+            .keySet()
+            .stream()
+            .map(IngestDocument.Metadata::getFieldName)
+            .collect(Collectors.toSet());
+        // metadata fields such as _index, _id and _routing are ignored
+        if (fields != null && !fields.isEmpty()) {
+            sortedFields = fields.stream()
+                .distinct()
+                .filter(field -> !metadataFields.contains(field))
+                .sorted()
+                .collect(Collectors.toList());
+        } else if (excludeFields != null && !excludeFields.isEmpty()) {
+            sortedFields = existingFields.stream()
+                .filter(field -> !metadataFields.contains(field) && !excludeFields.contains(field))
+                .sorted()
+                .collect(Collectors.toList());
+        } else {
+            sortedFields = existingFields.stream().filter(field -> !metadataFields.contains(field)).sorted().collect(Collectors.toList());
+        }
+        assert (!sortedFields.isEmpty());
+
+        final StringBuilder concatenatedFields = new StringBuilder();
+        sortedFields.forEach(field -> {
+            if (!document.hasField(field)) {
+                if (ignoreMissing) {
+                    return;
+                } else {
+                    throw new IllegalArgumentException("field [" + field + "] doesn't exist");
+                }
+            }
+
+            final Object value = document.getFieldValue(field, Object.class);
+            if (value instanceof Map) {
+                @SuppressWarnings("unchecked")
+                Map<String, Object> flattenedMap = toFlattenedMap((Map<String, Object>) value);
+                flattenedMap.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEach(entry -> {
+                    String fieldValue = String.valueOf(entry.getValue());
+                    concatenatedFields.append("|")
+                        .append(field)
+                        .append(".")
+                        .append(entry.getKey())
+                        .append("|")
+                        .append(fieldValue.length())
+                        .append(":")
+                        .append(fieldValue);
+                });
+            } else {
+                String fieldValue = String.valueOf(value);
+                concatenatedFields.append("|").append(field).append("|").append(fieldValue.length()).append(":").append(fieldValue);
+            }
+        });
+        // if all specified fields don't exist and ignore_missing is true, then do nothing
+        if (concatenatedFields.length() == 0) {
+            return document;
+        }
+        concatenatedFields.append("|");
+
+        MessageDigest messageDigest = HashMethod.fromMethodName(hashMethod);
+        assert (messageDigest != null);
+        messageDigest.update(concatenatedFields.toString().getBytes(StandardCharsets.UTF_8));
+        document.setFieldValue(targetField, hashMethod + ":" + Base64.getEncoder().encodeToString(messageDigest.digest()));
+
+        return document;
+    }
+
+    @Override
+    public String getType() {
+        return TYPE;
+    }
+
+    /**
+     * Convert a map containing nested fields to a flattened map,
+     * for example, if the original map is
+     * {
+     *     "a": {
+     *         "b": 1,
+     *         "c": 2
+     *     }
+     * }, then the converted map is
+     * {
+     *     "a.b": 1,
+     *     "a.c": 2
+     * }
+     * @param map the original map which may contain nested fields
+     * @return a flattened map which has only one level fields
+     */
+    @SuppressWarnings("unchecked")
+    private Map<String, Object> toFlattenedMap(Map<String, Object> map) {
+        Map<String, Object> flattenedMap = new HashMap<>();
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            if (entry.getValue() instanceof Map) {
+                toFlattenedMap((Map<String, Object>) entry.getValue()).forEach(
+                    (key, value) -> flattenedMap.put(entry.getKey() + "." + key, value)
+                );
+            } else {
+                flattenedMap.put(entry.getKey(), entry.getValue());
+            }
+        }
+        return flattenedMap;
+    }
+
+    /**
+     * The supported hash methods used to generate hash value
+     */
+    enum HashMethod {
+        MD5(MessageDigests.md5()),
+        SHA1(MessageDigests.sha1()),
+        SHA256(MessageDigests.sha256()),
+        SHA3256(MessageDigests.sha3256());
+
+        private final MessageDigest messageDigest;
+
+        HashMethod(MessageDigest messageDigest) {
+            this.messageDigest = messageDigest;
+        }
+
+        public static MessageDigest fromMethodName(String methodName) {
+            String name = methodName.toUpperCase(Locale.ROOT);
+            switch (name) {
+                case "MD5@2.16.0":
+                    return MD5.messageDigest;
+                case "SHA-1@2.16.0":
+                    return SHA1.messageDigest;
+                case "SHA-256@2.16.0":
+                    return SHA256.messageDigest;
+                case "SHA3-256@2.16.0":
+                    return SHA3256.messageDigest;
+                default:
+                    return null;
+            }
+        }
+    }
+
+    public static final class Factory implements Processor.Factory {
+        @Override
+        public FingerprintProcessor create(
+            Map<String, Processor.Factory> registry,
+            String processorTag,
+            String description,
+            Map<String, Object> config
+        ) throws Exception {
+            List<String> fields = ConfigurationUtils.readOptionalList(TYPE, processorTag, config, "fields");
+            List<String> excludeFields = ConfigurationUtils.readOptionalList(TYPE, processorTag, config, "exclude_fields");
+            if (fields != null && !fields.isEmpty()) {
+                if (fields.stream().anyMatch(Strings::isNullOrEmpty)) {
+                    throw newConfigurationException(TYPE, processorTag, "fields", "field name cannot be null nor empty");
+                }
+                if (excludeFields != null && !excludeFields.isEmpty()) {
+                    throw newConfigurationException(TYPE, processorTag, "fields", "either fields or exclude_fields can be set");
+                }
+            }
+            if (excludeFields != null && !excludeFields.isEmpty() && excludeFields.stream().anyMatch(Strings::isNullOrEmpty)) {
+                throw newConfigurationException(TYPE, processorTag, "exclude_fields", "field name cannot be null nor empty");
+            }
+
+            String targetField = ConfigurationUtils.readStringProperty(TYPE, processorTag, config, "target_field", "fingerprint");
+            String hashMethod = ConfigurationUtils.readStringProperty(TYPE, processorTag, config, "hash_method", "SHA-1@2.16.0");
+            if (!HASH_METHODS.contains(hashMethod.toUpperCase(Locale.ROOT))) {
+                throw newConfigurationException(
+                    TYPE,
+                    processorTag,
+                    "hash_method",
+                    "hash method must be MD5@2.16.0, SHA-1@2.16.0, SHA-256@2.16.0 or SHA3-256@2.16.0"
+                );
+            }
+            boolean ignoreMissing = ConfigurationUtils.readBooleanProperty(TYPE, processorTag, config, "ignore_missing", false);
+            return new FingerprintProcessor(processorTag, description, fields, excludeFields, targetField, hashMethod, ignoreMissing);
+        }
+    }
+}
diff --git a/modules/ingest-common/src/main/java/org/opensearch/ingest/common/IngestCommonPlugin.java b/modules/ingest-common/src/main/java/org/opensearch/ingest/common/IngestCommonPlugin.java
index a4fd2b9686f4a..2611545f0b9fe 100644
--- a/modules/ingest-common/src/main/java/org/opensearch/ingest/common/IngestCommonPlugin.java
+++ b/modules/ingest-common/src/main/java/org/opensearch/ingest/common/IngestCommonPlugin.java
@@ -58,10 +58,20 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 public class IngestCommonPlugin extends Plugin implements ActionPlugin, IngestPlugin {
 
+    static final Setting<List<String>> PROCESSORS_ALLOWLIST_SETTING = Setting.listSetting(
+        "ingest.common.processors.allowed",
+        List.of(),
+        Function.identity(),
+        Setting.Property.NodeScope
+    );
+
     static final Setting<TimeValue> WATCHDOG_INTERVAL = Setting.timeSetting(
         "ingest.grok.watchdog.interval",
         TimeValue.timeValueSeconds(1),
@@ -77,7 +87,7 @@ public IngestCommonPlugin() {}
 
     @Override
     public Map<String, Processor.Factory> getProcessors(Processor.Parameters parameters) {
-        Map<String, Processor.Factory> processors = new HashMap<>();
+        final Map<String, Processor.Factory> processors = new HashMap<>();
         processors.put(DateProcessor.TYPE, new DateProcessor.Factory(parameters.scriptService));
         processors.put(SetProcessor.TYPE, new SetProcessor.Factory(parameters.scriptService));
         processors.put(AppendProcessor.TYPE, new AppendProcessor.Factory(parameters.scriptService));
@@ -109,7 +119,8 @@ public Map<String, Processor.Factory> getProcessors(Processor.Parameters paramet
         processors.put(CopyProcessor.TYPE, new CopyProcessor.Factory(parameters.scriptService));
         processors.put(RemoveByPatternProcessor.TYPE, new RemoveByPatternProcessor.Factory());
         processors.put(CommunityIdProcessor.TYPE, new CommunityIdProcessor.Factory());
-        return Collections.unmodifiableMap(processors);
+        processors.put(FingerprintProcessor.TYPE, new FingerprintProcessor.Factory());
+        return filterForAllowlistSetting(parameters.env.settings(), processors);
     }
 
     @Override
@@ -132,7 +143,7 @@ public List<RestHandler> getRestHandlers(
 
     @Override
     public List<Setting<?>> getSettings() {
-        return Arrays.asList(WATCHDOG_INTERVAL, WATCHDOG_MAX_EXECUTION_TIME);
+        return Arrays.asList(WATCHDOG_INTERVAL, WATCHDOG_MAX_EXECUTION_TIME, PROCESSORS_ALLOWLIST_SETTING);
     }
 
     private static MatcherWatchdog createGrokThreadWatchdog(Processor.Parameters parameters) {
@@ -146,4 +157,27 @@ private static MatcherWatchdog createGrokThreadWatchdog(Processor.Parameters par
         );
     }
 
+    private Map<String, Processor.Factory> filterForAllowlistSetting(Settings settings, Map<String, Processor.Factory> map) {
+        if (PROCESSORS_ALLOWLIST_SETTING.exists(settings) == false) {
+            return Map.copyOf(map);
+        }
+        final Set<String> allowlist = Set.copyOf(PROCESSORS_ALLOWLIST_SETTING.get(settings));
+        // Assert that no unknown processors are defined in the allowlist
+        final Set<String> unknownAllowlistProcessors = allowlist.stream()
+            .filter(p -> map.containsKey(p) == false)
+            .collect(Collectors.toUnmodifiableSet());
+        if (unknownAllowlistProcessors.isEmpty() == false) {
+            throw new IllegalArgumentException(
+                "Processor(s) "
+                    + unknownAllowlistProcessors
+                    + " were defined in ["
+                    + PROCESSORS_ALLOWLIST_SETTING.getKey()
+                    + "] but do not exist"
+            );
+        }
+        return map.entrySet()
+            .stream()
+            .filter(e -> allowlist.contains(e.getKey()))
+            .collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
 }
diff --git a/modules/ingest-common/src/test/java/org/opensearch/ingest/common/FingerprintProcessorFactoryTests.java b/modules/ingest-common/src/test/java/org/opensearch/ingest/common/FingerprintProcessorFactoryTests.java
new file mode 100644
index 0000000000000..74ad4cade7b37
--- /dev/null
+++ b/modules/ingest-common/src/test/java/org/opensearch/ingest/common/FingerprintProcessorFactoryTests.java
@@ -0,0 +1,119 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.ingest.common;
+
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+
+public class FingerprintProcessorFactoryTests extends OpenSearchTestCase {
+
+    private FingerprintProcessor.Factory factory;
+
+    @Before
+    public void init() {
+        factory = new FingerprintProcessor.Factory();
+    }
+
+    public void testCreate() throws Exception {
+        Map<String, Object> config = new HashMap<>();
+
+        List<String> fields = null;
+        List<String> excludeFields = null;
+        if (randomBoolean()) {
+            fields = List.of(randomAlphaOfLength(10));
+            config.put("fields", fields);
+        } else {
+            excludeFields = List.of(randomAlphaOfLength(10));
+            config.put("exclude_fields", excludeFields);
+        }
+
+        String targetField = null;
+        if (randomBoolean()) {
+            targetField = randomAlphaOfLength(10);
+        }
+        config.put("target_field", targetField);
+
+        boolean ignoreMissing = randomBoolean();
+        config.put("ignore_missing", ignoreMissing);
+        String processorTag = randomAlphaOfLength(10);
+        FingerprintProcessor fingerprintProcessor = factory.create(null, processorTag, null, config);
+        assertThat(fingerprintProcessor.getTag(), equalTo(processorTag));
+        assertThat(fingerprintProcessor.getFields(), equalTo(fields));
+        assertThat(fingerprintProcessor.getExcludeFields(), equalTo(excludeFields));
+        assertThat(fingerprintProcessor.getTargetField(), equalTo(Objects.requireNonNullElse(targetField, "fingerprint")));
+        assertThat(fingerprintProcessor.isIgnoreMissing(), equalTo(ignoreMissing));
+    }
+
+    public void testCreateWithFields() throws Exception {
+        Map<String, Object> config = new HashMap<>();
+        config.put("fields", List.of(randomAlphaOfLength(10)));
+        config.put("exclude_fields", List.of(randomAlphaOfLength(10)));
+        try {
+            factory.create(null, null, null, config);
+            fail("factory create should have failed");
+        } catch (OpenSearchParseException e) {
+            assertThat(e.getMessage(), equalTo("[fields] either fields or exclude_fields can be set"));
+        }
+
+        config = new HashMap<>();
+        List<String> fields = new ArrayList<>();
+        if (randomBoolean()) {
+            fields.add(null);
+        } else {
+            fields.add("");
+        }
+        config.put("fields", fields);
+        try {
+            factory.create(null, null, null, config);
+            fail("factory create should have failed");
+        } catch (OpenSearchParseException e) {
+            assertThat(e.getMessage(), equalTo("[fields] field name cannot be null nor empty"));
+        }
+
+        config = new HashMap<>();
+        List<String> excludeFields = new ArrayList<>();
+        if (randomBoolean()) {
+            excludeFields.add(null);
+        } else {
+            excludeFields.add("");
+        }
+        config.put("exclude_fields", excludeFields);
+        try {
+            factory.create(null, null, null, config);
+            fail("factory create should have failed");
+        } catch (OpenSearchParseException e) {
+            assertThat(e.getMessage(), equalTo("[exclude_fields] field name cannot be null nor empty"));
+        }
+    }
+
+    public void testCreateWithHashMethod() throws Exception {
+        Map<String, Object> config = new HashMap<>();
+        List<String> fields = List.of(randomAlphaOfLength(10));
+        config.put("fields", fields);
+        config.put("hash_method", randomAlphaOfLength(10));
+        try {
+            factory.create(null, null, null, config);
+            fail("factory create should have failed");
+        } catch (OpenSearchParseException e) {
+            assertThat(
+                e.getMessage(),
+                equalTo("[hash_method] hash method must be MD5@2.16.0, SHA-1@2.16.0, SHA-256@2.16.0 or SHA3-256@2.16.0")
+            );
+        }
+    }
+}
diff --git a/modules/ingest-common/src/test/java/org/opensearch/ingest/common/FingerprintProcessorTests.java b/modules/ingest-common/src/test/java/org/opensearch/ingest/common/FingerprintProcessorTests.java
new file mode 100644
index 0000000000000..67a82f28fb763
--- /dev/null
+++ b/modules/ingest-common/src/test/java/org/opensearch/ingest/common/FingerprintProcessorTests.java
@@ -0,0 +1,176 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.ingest.common;
+
+import org.opensearch.ingest.IngestDocument;
+import org.opensearch.ingest.Processor;
+import org.opensearch.ingest.RandomDocumentPicks;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.Matchers.equalTo;
+
+public class FingerprintProcessorTests extends OpenSearchTestCase {
+    private final List<String> hashMethods = List.of("MD5@2.16.0", "SHA-1@2.16.0", "SHA-256@2.16.0", "SHA3-256@2.16.0");
+
+    public void testGenerateFingerprint() throws Exception {
+        IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
+        List<String> fields = null;
+        List<String> excludeFields = null;
+        if (randomBoolean()) {
+            fields = new ArrayList<>();
+            for (int i = 0; i < randomIntBetween(1, 10); i++) {
+                fields.add(RandomDocumentPicks.addRandomField(random(), ingestDocument, randomAlphaOfLength(10)));
+            }
+        } else {
+            excludeFields = new ArrayList<>();
+            for (int i = 0; i < randomIntBetween(1, 10); i++) {
+                excludeFields.add(RandomDocumentPicks.addRandomField(random(), ingestDocument, randomAlphaOfLength(10)));
+            }
+        }
+
+        String targetField = "fingerprint";
+        if (randomBoolean()) {
+            targetField = randomAlphaOfLength(10);
+        }
+
+        String hashMethod = randomFrom(hashMethods);
+        Processor processor = createFingerprintProcessor(fields, excludeFields, targetField, hashMethod, false);
+        processor.execute(ingestDocument);
+        assertThat(ingestDocument.hasField(targetField), equalTo(true));
+    }
+
+    public void testCreateFingerprintProcessorFailed() {
+        List<String> fields = new ArrayList<>();
+        if (randomBoolean()) {
+            fields.add(null);
+        } else {
+            fields.add("");
+        }
+        fields.add(randomAlphaOfLength(10));
+
+        assertThrows(
+            "field name in [fields] cannot be null nor empty",
+            IllegalArgumentException.class,
+            () -> createFingerprintProcessor(fields, null, null, randomFrom(hashMethods), false)
+        );
+
+        List<String> excludeFields = new ArrayList<>();
+        if (randomBoolean()) {
+            excludeFields.add(null);
+        } else {
+            excludeFields.add("");
+        }
+        excludeFields.add(randomAlphaOfLength(10));
+
+        assertThrows(
+            "field name in [exclude_fields] cannot be null nor empty",
+            IllegalArgumentException.class,
+            () -> createFingerprintProcessor(null, excludeFields, null, randomFrom(hashMethods), false)
+        );
+
+        assertThrows(
+            "either fields or exclude_fields can be set",
+            IllegalArgumentException.class,
+            () -> createFingerprintProcessor(
+                List.of(randomAlphaOfLength(10)),
+                List.of(randomAlphaOfLength(10)),
+                null,
+                randomFrom(hashMethods),
+                false
+            )
+        );
+
+        assertThrows(
+            "hash method must be MD5@2.16.0, SHA-1@2.16.0, SHA-256@2.16.0 or SHA3-256@2.16.0",
+            IllegalArgumentException.class,
+            () -> createFingerprintProcessor(Collections.emptyList(), null, "fingerprint", randomAlphaOfLength(10), false)
+        );
+    }
+
+    public void testEmptyFieldAndExcludeFields() throws Exception {
+        IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
+        List<String> fields = null;
+        List<String> excludeFields = null;
+        if (randomBoolean()) {
+            fields = new ArrayList<>();
+        } else {
+            excludeFields = new ArrayList<>();
+        }
+        String targetField = "fingerprint";
+        if (randomBoolean()) {
+            targetField = randomAlphaOfLength(10);
+        }
+
+        String hashMethod = randomFrom(hashMethods);
+        Processor processor = createFingerprintProcessor(fields, excludeFields, targetField, hashMethod, false);
+        processor.execute(ingestDocument);
+        assertThat(ingestDocument.hasField(targetField), equalTo(true));
+    }
+
+    public void testIgnoreMissing() throws Exception {
+        IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
+        String nonExistingFieldName = RandomDocumentPicks.randomNonExistingFieldName(random(), ingestDocument);
+        List<String> nonExistingFields = List.of(nonExistingFieldName);
+        Processor processor = createFingerprintProcessor(nonExistingFields, null, "fingerprint", randomFrom(hashMethods), false);
+        assertThrows(
+            "field [" + nonExistingFieldName + "] doesn't exist",
+            IllegalArgumentException.class,
+            () -> processor.execute(ingestDocument)
+        );
+
+        String targetField = "fingerprint";
+        Processor processorWithIgnoreMissing = createFingerprintProcessor(
+            nonExistingFields,
+            null,
+            "fingerprint",
+            randomFrom(hashMethods),
+            true
+        );
+        processorWithIgnoreMissing.execute(ingestDocument);
+        assertThat(ingestDocument.hasField(targetField), equalTo(false));
+    }
+
+    public void testIgnoreMetadataFields() throws Exception {
+        IngestDocument ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
+        List<String> metadataFields = ingestDocument.getMetadata()
+            .keySet()
+            .stream()
+            .map(IngestDocument.Metadata::getFieldName)
+            .collect(Collectors.toList());
+
+        String existingFieldName = RandomDocumentPicks.addRandomField(random(), ingestDocument, randomAlphaOfLength(10));
+        List<String> fields = List.of(existingFieldName, metadataFields.get(randomIntBetween(0, metadataFields.size() - 1)));
+
+        String targetField = "fingerprint";
+        String algorithm = randomFrom(hashMethods);
+        Processor processor = createFingerprintProcessor(fields, null, targetField, algorithm, false);
+
+        processor.execute(ingestDocument);
+        String fingerprint = ingestDocument.getFieldValue(targetField, String.class);
+
+        processor = createFingerprintProcessor(List.of(existingFieldName), null, targetField, algorithm, false);
+        processor.execute(ingestDocument);
+        assertThat(ingestDocument.getFieldValue(targetField, String.class), equalTo(fingerprint));
+    }
+
+    private FingerprintProcessor createFingerprintProcessor(
+        List<String> fields,
+        List<String> excludeFields,
+        String targetField,
+        String hashMethod,
+        boolean ignoreMissing
+    ) {
+        return new FingerprintProcessor(randomAlphaOfLength(10), null, fields, excludeFields, targetField, hashMethod, ignoreMissing);
+    }
+}
diff --git a/modules/ingest-common/src/test/java/org/opensearch/ingest/common/IngestCommonPluginTests.java b/modules/ingest-common/src/test/java/org/opensearch/ingest/common/IngestCommonPluginTests.java
new file mode 100644
index 0000000000000..06c611009df64
--- /dev/null
+++ b/modules/ingest-common/src/test/java/org/opensearch/ingest/common/IngestCommonPluginTests.java
@@ -0,0 +1,107 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.ingest.common;
+
+import org.opensearch.common.settings.Settings;
+import org.opensearch.env.TestEnvironment;
+import org.opensearch.ingest.Processor;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+
+public class IngestCommonPluginTests extends OpenSearchTestCase {
+
+    public void testAllowlist() throws IOException {
+        runAllowlistTest(List.of());
+        runAllowlistTest(List.of("date"));
+        runAllowlistTest(List.of("set"));
+        runAllowlistTest(List.of("copy", "date"));
+        runAllowlistTest(List.of("date", "set", "copy"));
+    }
+
+    private void runAllowlistTest(List<String> allowlist) throws IOException {
+        final Settings settings = Settings.builder().putList(IngestCommonPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey(), allowlist).build();
+        try (IngestCommonPlugin plugin = new IngestCommonPlugin()) {
+            assertEquals(Set.copyOf(allowlist), plugin.getProcessors(createParameters(settings)).keySet());
+        }
+    }
+
+    public void testAllowlistNotSpecified() throws IOException {
+        final Settings.Builder builder = Settings.builder();
+        builder.remove(IngestCommonPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey());
+        final Settings settings = builder.build();
+        try (IngestCommonPlugin plugin = new IngestCommonPlugin()) {
+            final Set<String> expected = Set.of(
+                "append",
+                "urldecode",
+                "sort",
+                "fail",
+                "trim",
+                "set",
+                "fingerprint",
+                "pipeline",
+                "json",
+                "join",
+                "kv",
+                "bytes",
+                "date",
+                "drop",
+                "community_id",
+                "lowercase",
+                "convert",
+                "copy",
+                "gsub",
+                "dot_expander",
+                "rename",
+                "remove_by_pattern",
+                "html_strip",
+                "remove",
+                "csv",
+                "grok",
+                "date_index_name",
+                "foreach",
+                "script",
+                "dissect",
+                "uppercase",
+                "split"
+            );
+            assertEquals(expected, plugin.getProcessors(createParameters(settings)).keySet());
+        }
+    }
+
+    public void testAllowlistHasNonexistentProcessors() throws IOException {
+        final Settings settings = Settings.builder()
+            .putList(IngestCommonPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey(), List.of("threeve"))
+            .build();
+        try (IngestCommonPlugin plugin = new IngestCommonPlugin()) {
+            IllegalArgumentException e = expectThrows(
+                IllegalArgumentException.class,
+                () -> plugin.getProcessors(createParameters(settings))
+            );
+            assertTrue(e.getMessage(), e.getMessage().contains("threeve"));
+        }
+    }
+
+    private static Processor.Parameters createParameters(Settings settings) {
+        return new Processor.Parameters(
+            TestEnvironment.newEnvironment(Settings.builder().put(settings).put("path.home", "").build()),
+            null,
+            null,
+            null,
+            () -> 0L,
+            (a, b) -> null,
+            null,
+            null,
+            $ -> {},
+            null
+        );
+    }
+}
diff --git a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/10_basic.yml b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/10_basic.yml
index 2a816f0386667..9bf4faf53a999 100644
--- a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/10_basic.yml
+++ b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/10_basic.yml
@@ -86,3 +86,19 @@
     - do:
           nodes.info: {}
     - contains:  { nodes.$cluster_manager.ingest.processors: { type: community_id } }
+
+---
+"Fingerprint processor exists":
+  - skip:
+      version: " - 2.15.99"
+      features: contains
+      reason: "fingerprint processor was introduced in 2.16.0 and contains is a newly added assertion"
+  - do:
+      cluster.state: {}
+
+  # Get cluster-manager node id
+  - set: { cluster_manager_node: cluster_manager }
+
+  - do:
+      nodes.info: {}
+  - contains:  { nodes.$cluster_manager.ingest.processors: { type: fingerprint } }
diff --git a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/190_script_processor.yml b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/190_script_processor.yml
index a66f02d6b6a6d..984c67d39757d 100644
--- a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/190_script_processor.yml
+++ b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/190_script_processor.yml
@@ -278,3 +278,78 @@ teardown:
         body: {source_field: "fooBar", foo: {foo: "bar"}}
   - match: { error.root_cause.0.type: "illegal_argument_exception" }
   - match: { error.root_cause.0.reason: "Iterable object is self-referencing itself (ingest script)" }
+
+---
+"Test painless data types":
+  - do:
+      ingest.put_pipeline:
+        id: "my_pipeline"
+        body:  >
+          {
+            "description": "_description",
+            "processors": [
+              {
+                "script" : {
+                  "source" : "ctx.byte = (byte)127;ctx.short = (short)32767;ctx.int = (int)2147483647;ctx.long = (long)9223372036854775807L;ctx.float = (float)0.1;ctx.double = (double)0.1;ctx.boolean = (boolean)true"
+                }
+              },
+              {
+                "script" : {
+                  "source" : "ctx.other_field = 'other_field'"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 1
+        pipeline: "my_pipeline"
+        body: {source_field: "FooBar"}
+
+  - do:
+      get:
+        index: test
+        id: 1
+  - match: { _source.byte: 127 }
+  - match: { _source.int: 2147483647 }
+  - match: { _source.long: 9223372036854775807 }
+  - gt: { _source.float: 0.0 }
+  - lt: { _source.float: 0.2 }
+  - gt: { _source.double: 0.0 }
+  - lt: { _source.double: 0.2 }
+  - match: { _source.boolean: true }
+
+---
+"Test char type fails":
+  - do:
+      ingest.put_pipeline:
+        id: "my_pipeline"
+        body:  >
+          {
+            "description": "_description",
+            "processors": [
+              {
+                "script" : {
+                  "source" : "ctx.char = (char)'a'"
+                }
+              },
+              {
+                "script" : {
+                  "source" : "ctx.other_field = 'other_field'"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      catch: bad_request
+      index:
+        index: test
+        id: 1
+        pipeline: "my_pipeline"
+        body: {source_field: "FooBar"}
+  - match: { error.root_cause.0.type: "illegal_argument_exception" }
diff --git a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/340_fingerprint_processor.yml b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/340_fingerprint_processor.yml
new file mode 100644
index 0000000000000..04568916239f4
--- /dev/null
+++ b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/340_fingerprint_processor.yml
@@ -0,0 +1,786 @@
+---
+teardown:
+  - do:
+      ingest.delete_pipeline:
+        id: "1"
+        ignore: 404
+
+---
+"Test creat fingerprint processor":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+  - do:
+      catch: /field name cannot be null nor empty/
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields": [null]
+                }
+              }
+            ]
+          }
+  - do:
+      catch: /field name cannot be null nor empty/
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "exclude_fields": [""]
+                }
+              }
+            ]
+          }
+  - do:
+      catch: /either fields or exclude\_fields can be set/
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields": ["foo"],
+                  "exclude_fields": ["bar"]
+                }
+              }
+            ]
+          }
+
+  - do:
+      catch: /hash method must be MD5@2.16.0\, SHA\-1@2.16.0, SHA\-256@2.16.0 or SHA3\-256@2.16.0/
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields": ["foo"],
+                  "hash_method": "non-existing"
+                }
+              }
+            ]
+          }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields" : ["foo"],
+                  "target_field" : "fingerprint_field",
+                  "hash_method": "SHA-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+---
+"Test fingerprint processor with ignore_missing":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields" : ["foo"]
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      catch: /field \[foo\] doesn't exist/
+      index:
+        index: test
+        id: 1
+        pipeline: "1"
+        body: {
+          bar: "bar"
+        }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields" : ["foo", "bar"],
+                  "ignore_missing" : true
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 1
+        pipeline: "1"
+        body: {
+          foo: "foo"
+        }
+  - do:
+      get:
+        index: test
+        id: 1
+  - match: { _source.fingerprint: "SHA-1@2.16.0:YqpBTuHXCPV04j/7lGfWeUl8Tyo=" }
+
+---
+"Test fingerprint processor with custom target field":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields" : ["foo"],
+                  "target_field" : "target"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 1
+        pipeline: "1"
+        body: {
+          foo: "foo"
+        }
+  - do:
+      get:
+        index: test
+        id: 1
+  - match: { _source.target: "SHA-1@2.16.0:YqpBTuHXCPV04j/7lGfWeUl8Tyo=" }
+
+---
+"Test fingerprint processor with non-primitive fields and SHA-1":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields" : ["foo", "bar", "zoo"]
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 1
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 1
+  - match: { _source.fingerprint: "SHA-1@2.16.0:KYJ4pc4ouFmAbgZGp7CfNoykZeo=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 2
+  - match: { _source.fingerprint: "SHA-1@2.16.0:KYJ4pc4ouFmAbgZGp7CfNoykZeo=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields":[]
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 3
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 3
+  - match: { _source.fingerprint: "SHA-1@2.16.0:KYJ4pc4ouFmAbgZGp7CfNoykZeo=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "exclude_fields":[]
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 4
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 4
+  - match: { _source.fingerprint: "SHA-1@2.16.0:KYJ4pc4ouFmAbgZGp7CfNoykZeo=" }
+
+---
+"Test fingerprint processor with non-primitive fields and MD5":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields" : ["foo", "bar", "zoo"],
+                  "hash_method" : "MD5@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 1
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 1
+  - match: { _source.fingerprint: "MD5@2.16.0:NovpcJ+MYHzEZtCewcDPTQ==" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "hash_method" : "MD5@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 2
+  - match: { _source.fingerprint: "MD5@2.16.0:NovpcJ+MYHzEZtCewcDPTQ==" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields":[],
+                  "hash_method" : "MD5@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 3
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 3
+  - match: { _source.fingerprint: "MD5@2.16.0:NovpcJ+MYHzEZtCewcDPTQ==" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "exclude_fields":[],
+                  "hash_method" : "MD5@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 4
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 4
+  - match: { _source.fingerprint: "MD5@2.16.0:NovpcJ+MYHzEZtCewcDPTQ==" }
+
+
+---
+"Test fingerprint processor with non-primitive fields and SHA-256":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields" : ["foo", "bar", "zoo"],
+                  "hash_method" : "SHA-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 1
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 1
+  - match: { _source.fingerprint: "SHA-256@2.16.0:Sdlg0BodM3n1my4BvaTfJCPrvHxfrxno0kCLfMaC+XY=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "hash_method" : "SHA-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 2
+  - match: { _source.fingerprint: "SHA-256@2.16.0:Sdlg0BodM3n1my4BvaTfJCPrvHxfrxno0kCLfMaC+XY=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields":[],
+                  "hash_method" : "SHA-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 3
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 3
+  - match: { _source.fingerprint: "SHA-256@2.16.0:Sdlg0BodM3n1my4BvaTfJCPrvHxfrxno0kCLfMaC+XY=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "exclude_fields":[],
+                  "hash_method" : "SHA-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 4
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 4
+  - match: { _source.fingerprint: "SHA-256@2.16.0:Sdlg0BodM3n1my4BvaTfJCPrvHxfrxno0kCLfMaC+XY=" }
+
+---
+"Test fingerprint processor with non-primitive fields and SHA3-256":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields" : ["foo", "bar", "zoo"],
+                  "hash_method" : "SHA3-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 1
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 1
+  - match: { _source.fingerprint: "SHA3-256@2.16.0:+GZCkMLEMkUA/4IrEZEZZYsVMbZdpJ92ppN3wUsFYOI=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "hash_method" : "SHA3-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 2
+  - match: { _source.fingerprint: "SHA3-256@2.16.0:+GZCkMLEMkUA/4IrEZEZZYsVMbZdpJ92ppN3wUsFYOI=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "fields":[],
+                  "hash_method" : "SHA3-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 3
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 3
+  - match: { _source.fingerprint: "SHA3-256@2.16.0:+GZCkMLEMkUA/4IrEZEZZYsVMbZdpJ92ppN3wUsFYOI=" }
+
+  - do:
+      ingest.put_pipeline:
+        id: "1"
+        body:  >
+          {
+            "processors": [
+              {
+                "fingerprint" : {
+                  "exclude_fields":[],
+                  "hash_method" : "SHA3-256@2.16.0"
+                }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      index:
+        index: test
+        id: 4
+        pipeline: "1"
+        body: {
+          foo: [1, 2, 3],
+          bar: {
+            field: {
+              innerField: "inner"
+            }
+          },
+          zoo: null
+        }
+  - do:
+      get:
+        index: test
+        id: 4
+  - match: { _source.fingerprint: "SHA3-256@2.16.0:+GZCkMLEMkUA/4IrEZEZZYsVMbZdpJ92ppN3wUsFYOI=" }
diff --git a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
index edb7b77eb8d28..ecd56ea7f277e 100644
--- a/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
+++ b/modules/ingest-common/src/yamlRestTest/resources/rest-api-spec/test/ingest/70_bulk.yml
@@ -41,6 +41,10 @@ teardown:
       ingest.delete_pipeline:
         id: "pipeline2"
         ignore: 404
+  - do:
+      indices.delete_index_template:
+        name: test_index_template_for_bulk
+        ignore: 404
 
 ---
 "Test bulk request without default pipeline":
@@ -168,47 +172,45 @@ teardown:
         id: test_id3
   - match: { _source: {"f1": "v2", "f2": 47, "field1": "value1"}}
 
+# related issue: https://github.com/opensearch-project/OpenSearch/issues/12888
 ---
-"Test bulk API with batch enabled happy case":
+"Test bulk upsert honors default_pipeline and final_pipeline when the auto-created index matches with the index template":
   - skip:
-      version: " - 2.13.99"
-      reason: "Added in 2.14.0"
+      version: " - 2.15.99"
+      reason: "fixed in 2.16.0"
+      features: allowed_warnings
+  - do:
+      allowed_warnings:
+        - "index template [test_for_bulk_upsert_index_template] has index patterns [test_bulk_upsert_*] matching patterns from existing older templates [global] with patterns (global => [*]); this template [test_for_bulk_upsert_index_template] will take precedence during new index creation"
+      indices.put_index_template:
+        name: test_for_bulk_upsert_index_template
+        body:
+          index_patterns: test_bulk_upsert_*
+          template:
+            settings:
+              number_of_shards:   1
+              number_of_replicas: 0
+              default_pipeline: pipeline1
+              final_pipeline: pipeline2
 
   - do:
       bulk:
         refresh: true
-        batch_size: 2
-        pipeline: "pipeline1"
         body:
-          - '{"index": {"_index": "test_index", "_id": "test_id1"}}'
-          - '{"text": "text1"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id2"}}'
-          - '{"text": "text2"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id3"}}'
-          - '{"text": "text3"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id4"}}'
-          - '{"text": "text4"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id5", "pipeline": "pipeline2"}}'
-          - '{"text": "text5"}'
-          - '{"index": {"_index": "test_index", "_id": "test_id6", "pipeline": "pipeline2"}}'
-          - '{"text": "text6"}'
+          - '{"update": {"_index": "test_bulk_upsert_index", "_id": "test_id3"}}'
+          - '{"upsert": {"f1": "v2", "f2": 47}, "doc": {"x": 1}}'
 
   - match: { errors: false }
+  - match: { items.0.update.result: created }
 
   - do:
       get:
-        index: test_index
-        id: test_id5
-  - match: { _source: {"text": "text5", "field2": "value2"}}
-
-  - do:
-      get:
-        index: test_index
+        index: test_bulk_upsert_index
         id: test_id3
-  - match: { _source: { "text": "text3", "field1": "value1" } }
+  - match: { _source: {"f1": "v2", "f2": 47, "field1": "value1", "field2": "value2"}}
 
 ---
-"Test bulk API with batch_size missing":
+"Test bulk API with default batch size":
   - skip:
       version: " - 2.13.99"
       reason: "Added in 2.14.0"
@@ -222,20 +224,28 @@ teardown:
           - '{"text": "text1"}'
           - '{"index": {"_index": "test_index", "_id": "test_id2"}}'
           - '{"text": "text2"}'
+          - '{"index": {"_index": "test_index", "_id": "test_id3"}}'
+          - '{"text": "text3"}'
+          - '{"index": {"_index": "test_index", "_id": "test_id4"}}'
+          - '{"text": "text4"}'
+          - '{"index": {"_index": "test_index", "_id": "test_id5", "pipeline": "pipeline2"}}'
+          - '{"text": "text5"}'
+          - '{"index": {"_index": "test_index", "_id": "test_id6", "pipeline": "pipeline2"}}'
+          - '{"text": "text6"}'
 
   - match: { errors: false }
 
   - do:
       get:
         index: test_index
-        id: test_id1
-  - match: { _source: { "text": "text1", "field1": "value1" } }
+        id: test_id5
+  - match: { _source: {"text": "text5", "field2": "value2"}}
 
   - do:
       get:
         index: test_index
-        id: test_id2
-  - match: { _source: { "text": "text2", "field1": "value1" } }
+        id: test_id3
+  - match: { _source: { "text": "text3", "field1": "value1" } }
 
 ---
 "Test bulk API with invalid batch_size":
diff --git a/modules/ingest-geoip/licenses/jackson-annotations-2.17.1.jar.sha1 b/modules/ingest-geoip/licenses/jackson-annotations-2.17.1.jar.sha1
deleted file mode 100644
index 4ceead1b7ae4f..0000000000000
--- a/modules/ingest-geoip/licenses/jackson-annotations-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fca7ef6192c9ad05d07bc50da991bf937a84af3a
\ No newline at end of file
diff --git a/modules/ingest-geoip/licenses/jackson-annotations-2.17.2.jar.sha1 b/modules/ingest-geoip/licenses/jackson-annotations-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..411e1d62459fd
--- /dev/null
+++ b/modules/ingest-geoip/licenses/jackson-annotations-2.17.2.jar.sha1
@@ -0,0 +1 @@
+147b7b9412ffff24339f8aba080b292448e08698
\ No newline at end of file
diff --git a/modules/ingest-geoip/licenses/jackson-databind-2.17.1.jar.sha1 b/modules/ingest-geoip/licenses/jackson-databind-2.17.1.jar.sha1
deleted file mode 100644
index 7cf1ac1b60301..0000000000000
--- a/modules/ingest-geoip/licenses/jackson-databind-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-0524dcbcccdde7d45a679dfc333e4763feb09079
\ No newline at end of file
diff --git a/modules/ingest-geoip/licenses/jackson-databind-2.17.2.jar.sha1 b/modules/ingest-geoip/licenses/jackson-databind-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f2b4dbdc5decb
--- /dev/null
+++ b/modules/ingest-geoip/licenses/jackson-databind-2.17.2.jar.sha1
@@ -0,0 +1 @@
+e6deb029e5901e027c129341fac39e515066b68c
\ No newline at end of file
diff --git a/modules/ingest-geoip/src/main/java/org/opensearch/ingest/geoip/IngestGeoIpPlugin.java b/modules/ingest-geoip/src/main/java/org/opensearch/ingest/geoip/IngestGeoIpPlugin.java
index 8e51255b6123d..e810f13878497 100644
--- a/modules/ingest-geoip/src/main/java/org/opensearch/ingest/geoip/IngestGeoIpPlugin.java
+++ b/modules/ingest-geoip/src/main/java/org/opensearch/ingest/geoip/IngestGeoIpPlugin.java
@@ -44,6 +44,7 @@
 import org.opensearch.common.cache.CacheBuilder;
 import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.ingest.Processor;
 import org.opensearch.plugins.IngestPlugin;
@@ -62,10 +63,18 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class IngestGeoIpPlugin extends Plugin implements IngestPlugin, Closeable {
+    static final Setting<List<String>> PROCESSORS_ALLOWLIST_SETTING = Setting.listSetting(
+        "ingest.geoip.processors.allowed",
+        List.of(),
+        Function.identity(),
+        Setting.Property.NodeScope
+    );
     public static final Setting<Long> CACHE_SIZE = Setting.longSetting("ingest.geoip.cache_size", 1000, 0, Setting.Property.NodeScope);
 
     static String[] DEFAULT_DATABASE_FILENAMES = new String[] { "GeoLite2-ASN.mmdb", "GeoLite2-City.mmdb", "GeoLite2-Country.mmdb" };
@@ -74,7 +83,7 @@ public class IngestGeoIpPlugin extends Plugin implements IngestPlugin, Closeable
 
     @Override
     public List<Setting<?>> getSettings() {
-        return Arrays.asList(CACHE_SIZE);
+        return Arrays.asList(CACHE_SIZE, PROCESSORS_ALLOWLIST_SETTING);
     }
 
     @Override
@@ -90,7 +99,10 @@ public Map<String, Processor.Factory> getProcessors(Processor.Parameters paramet
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
-        return Collections.singletonMap(GeoIpProcessor.TYPE, new GeoIpProcessor.Factory(databaseReaders, new GeoIpCache(cacheSize)));
+        return filterForAllowlistSetting(
+            parameters.env.settings(),
+            Map.of(GeoIpProcessor.TYPE, new GeoIpProcessor.Factory(databaseReaders, new GeoIpCache(cacheSize)))
+        );
     }
 
     /*
@@ -175,6 +187,30 @@ public void close() throws IOException {
         }
     }
 
+    private Map<String, Processor.Factory> filterForAllowlistSetting(Settings settings, Map<String, Processor.Factory> map) {
+        if (PROCESSORS_ALLOWLIST_SETTING.exists(settings) == false) {
+            return Map.copyOf(map);
+        }
+        final Set<String> allowlist = Set.copyOf(PROCESSORS_ALLOWLIST_SETTING.get(settings));
+        // Assert that no unknown processors are defined in the allowlist
+        final Set<String> unknownAllowlistProcessors = allowlist.stream()
+            .filter(p -> map.containsKey(p) == false)
+            .collect(Collectors.toUnmodifiableSet());
+        if (unknownAllowlistProcessors.isEmpty() == false) {
+            throw new IllegalArgumentException(
+                "Processor(s) "
+                    + unknownAllowlistProcessors
+                    + " were defined in ["
+                    + PROCESSORS_ALLOWLIST_SETTING.getKey()
+                    + "] but do not exist"
+            );
+        }
+        return map.entrySet()
+            .stream()
+            .filter(e -> allowlist.contains(e.getKey()))
+            .collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
+
     /**
      * The in-memory cache for the geoip data. There should only be 1 instance of this class..
      * This cache differs from the maxmind's {@link NodeCache} such that this cache stores the deserialized Json objects to avoid the
diff --git a/modules/ingest-geoip/src/test/java/org/opensearch/ingest/geoip/IngestGeoIpPluginTests.java b/modules/ingest-geoip/src/test/java/org/opensearch/ingest/geoip/IngestGeoIpPluginTests.java
index a1120675872bb..0421b85206268 100644
--- a/modules/ingest-geoip/src/test/java/org/opensearch/ingest/geoip/IngestGeoIpPluginTests.java
+++ b/modules/ingest-geoip/src/test/java/org/opensearch/ingest/geoip/IngestGeoIpPluginTests.java
@@ -35,8 +35,20 @@
 import com.maxmind.geoip2.model.AbstractResponse;
 
 import org.opensearch.common.network.InetAddresses;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.env.TestEnvironment;
+import org.opensearch.ingest.Processor;
 import org.opensearch.ingest.geoip.IngestGeoIpPlugin.GeoIpCache;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.StreamsUtils;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
 
 import static org.mockito.Mockito.mock;
 
@@ -77,4 +89,87 @@ public void testInvalidInit() {
         IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, () -> new GeoIpCache(-1));
         assertEquals("geoip max cache size must be 0 or greater", ex.getMessage());
     }
+
+    public void testAllowList() throws IOException {
+        runAllowListTest(List.of());
+        runAllowListTest(List.of("geoip"));
+    }
+
+    public void testInvalidAllowList() throws IOException {
+        List<String> invalidAllowList = List.of("set");
+        Settings.Builder settingsBuilder = Settings.builder()
+            .putList(IngestGeoIpPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey(), invalidAllowList);
+        createDb(settingsBuilder);
+        try (IngestGeoIpPlugin plugin = new IngestGeoIpPlugin()) {
+            IllegalArgumentException e = expectThrows(
+                IllegalArgumentException.class,
+                () -> plugin.getProcessors(createParameters(settingsBuilder.build()))
+            );
+            assertEquals(
+                "Processor(s) "
+                    + invalidAllowList
+                    + " were defined in ["
+                    + IngestGeoIpPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey()
+                    + "] but do not exist",
+                e.getMessage()
+            );
+        }
+    }
+
+    public void testAllowListNotSpecified() throws IOException {
+        Settings.Builder settingsBuilder = Settings.builder();
+        settingsBuilder.remove(IngestGeoIpPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey());
+        createDb(settingsBuilder);
+        try (IngestGeoIpPlugin plugin = new IngestGeoIpPlugin()) {
+            final Set<String> expected = Set.of("geoip");
+            assertEquals(expected, plugin.getProcessors(createParameters(settingsBuilder.build())).keySet());
+        }
+    }
+
+    private void runAllowListTest(List<String> allowList) throws IOException {
+        Settings.Builder settingsBuilder = Settings.builder();
+        createDb(settingsBuilder);
+        final Settings settings = settingsBuilder.putList(IngestGeoIpPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey(), allowList).build();
+        try (IngestGeoIpPlugin plugin = new IngestGeoIpPlugin()) {
+            assertEquals(Set.copyOf(allowList), plugin.getProcessors(createParameters(settings)).keySet());
+        }
+    }
+
+    private void createDb(Settings.Builder settingsBuilder) throws IOException {
+        Path configDir = createTempDir();
+        Path userAgentConfigDir = configDir.resolve("ingest-geoip");
+        Files.createDirectories(userAgentConfigDir);
+        settingsBuilder.put("ingest.geoip.database_path", configDir).put("path.home", configDir);
+        try {
+            Files.copy(
+                new ByteArrayInputStream(StreamsUtils.copyToBytesFromClasspath("/GeoLite2-City.mmdb")),
+                configDir.resolve("GeoLite2-City.mmdb")
+            );
+            Files.copy(
+                new ByteArrayInputStream(StreamsUtils.copyToBytesFromClasspath("/GeoLite2-Country.mmdb")),
+                configDir.resolve("GeoLite2-Country.mmdb")
+            );
+            Files.copy(
+                new ByteArrayInputStream(StreamsUtils.copyToBytesFromClasspath("/GeoLite2-ASN.mmdb")),
+                configDir.resolve("GeoLite2-ASN.mmdb")
+            );
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+    private static Processor.Parameters createParameters(Settings settings) {
+        return new Processor.Parameters(
+            TestEnvironment.newEnvironment(settings),
+            null,
+            null,
+            null,
+            () -> 0L,
+            (a, b) -> null,
+            null,
+            null,
+            $ -> {},
+            null
+        );
+    }
 }
diff --git a/modules/ingest-user-agent/src/main/java/org/opensearch/ingest/useragent/IngestUserAgentPlugin.java b/modules/ingest-user-agent/src/main/java/org/opensearch/ingest/useragent/IngestUserAgentPlugin.java
index ee424ad1322fb..4ce03c66c71ed 100644
--- a/modules/ingest-user-agent/src/main/java/org/opensearch/ingest/useragent/IngestUserAgentPlugin.java
+++ b/modules/ingest-user-agent/src/main/java/org/opensearch/ingest/useragent/IngestUserAgentPlugin.java
@@ -33,6 +33,7 @@
 package org.opensearch.ingest.useragent;
 
 import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.ingest.Processor;
 import org.opensearch.plugins.IngestPlugin;
 import org.opensearch.plugins.Plugin;
@@ -47,10 +48,19 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 public class IngestUserAgentPlugin extends Plugin implements IngestPlugin {
 
+    static final Setting<List<String>> PROCESSORS_ALLOWLIST_SETTING = Setting.listSetting(
+        "ingest.useragent.processors.allowed",
+        List.of(),
+        Function.identity(),
+        Setting.Property.NodeScope
+    );
     private final Setting<Long> CACHE_SIZE_SETTING = Setting.longSetting(
         "ingest.user_agent.cache_size",
         1000,
@@ -77,7 +87,34 @@ public Map<String, Processor.Factory> getProcessors(Processor.Parameters paramet
         } catch (IOException e) {
             throw new RuntimeException(e);
         }
-        return Collections.singletonMap(UserAgentProcessor.TYPE, new UserAgentProcessor.Factory(userAgentParsers));
+        return filterForAllowlistSetting(
+            parameters.env.settings(),
+            Collections.singletonMap(UserAgentProcessor.TYPE, new UserAgentProcessor.Factory(userAgentParsers))
+        );
+    }
+
+    private Map<String, Processor.Factory> filterForAllowlistSetting(Settings settings, Map<String, Processor.Factory> map) {
+        if (PROCESSORS_ALLOWLIST_SETTING.exists(settings) == false) {
+            return Map.copyOf(map);
+        }
+        final Set<String> allowlist = Set.copyOf(PROCESSORS_ALLOWLIST_SETTING.get(settings));
+        // Assert that no unknown processors are defined in the allowlist
+        final Set<String> unknownAllowlistProcessors = allowlist.stream()
+            .filter(p -> map.containsKey(p) == false)
+            .collect(Collectors.toUnmodifiableSet());
+        if (unknownAllowlistProcessors.isEmpty() == false) {
+            throw new IllegalArgumentException(
+                "Processor(s) "
+                    + unknownAllowlistProcessors
+                    + " were defined in ["
+                    + PROCESSORS_ALLOWLIST_SETTING.getKey()
+                    + "] but do not exist"
+            );
+        }
+        return map.entrySet()
+            .stream()
+            .filter(e -> allowlist.contains(e.getKey()))
+            .collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, Map.Entry::getValue));
     }
 
     static Map<String, UserAgentParser> createUserAgentParsers(Path userAgentConfigDirectory, UserAgentCache cache) throws IOException {
diff --git a/modules/ingest-user-agent/src/test/java/org/opensearch/ingest/useragent/IngestUserAgentPluginTests.java b/modules/ingest-user-agent/src/test/java/org/opensearch/ingest/useragent/IngestUserAgentPluginTests.java
new file mode 100644
index 0000000000000..b353039c6398a
--- /dev/null
+++ b/modules/ingest-user-agent/src/test/java/org/opensearch/ingest/useragent/IngestUserAgentPluginTests.java
@@ -0,0 +1,111 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.ingest.useragent;
+
+import org.opensearch.common.settings.Settings;
+import org.opensearch.env.TestEnvironment;
+import org.opensearch.ingest.Processor;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Set;
+
+public class IngestUserAgentPluginTests extends OpenSearchTestCase {
+    private Settings.Builder settingsBuilder;
+
+    @Before
+    public void setup() throws IOException {
+        Path configDir = createTempDir();
+        Path userAgentConfigDir = configDir.resolve("ingest-user-agent");
+        Files.createDirectories(userAgentConfigDir);
+        settingsBuilder = Settings.builder().put("ingest-user-agent", configDir).put("path.home", configDir);
+
+        // Copy file, leaving out the device parsers at the end
+        String regexWithoutDevicesFilename = "regexes_without_devices.yml";
+        try (
+            BufferedReader reader = new BufferedReader(
+                new InputStreamReader(UserAgentProcessor.class.getResourceAsStream("/regexes.yml"), StandardCharsets.UTF_8)
+            );
+            BufferedWriter writer = Files.newBufferedWriter(userAgentConfigDir.resolve(regexWithoutDevicesFilename));
+        ) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                if (line.startsWith("device_parsers:")) {
+                    break;
+                }
+
+                writer.write(line);
+                writer.newLine();
+            }
+        }
+    }
+
+    public void testAllowList() throws IOException {
+        runAllowListTest(List.of());
+        runAllowListTest(List.of("user_agent"));
+    }
+
+    public void testInvalidAllowList() throws IOException {
+        List<String> invalidAllowList = List.of("set");
+        final Settings settings = settingsBuilder.putList(IngestUserAgentPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey(), invalidAllowList)
+            .build();
+        try (IngestUserAgentPlugin plugin = new IngestUserAgentPlugin()) {
+            IllegalArgumentException e = expectThrows(
+                IllegalArgumentException.class,
+                () -> plugin.getProcessors(createParameters(settings))
+            );
+            assertEquals(
+                "Processor(s) "
+                    + invalidAllowList
+                    + " were defined in ["
+                    + IngestUserAgentPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey()
+                    + "] but do not exist",
+                e.getMessage()
+            );
+        }
+    }
+
+    public void testAllowListNotSpecified() throws IOException {
+        settingsBuilder.remove(IngestUserAgentPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey());
+        try (IngestUserAgentPlugin plugin = new IngestUserAgentPlugin()) {
+            final Set<String> expected = Set.of("user_agent");
+            assertEquals(expected, plugin.getProcessors(createParameters(settingsBuilder.build())).keySet());
+        }
+    }
+
+    private void runAllowListTest(List<String> allowList) throws IOException {
+        final Settings settings = settingsBuilder.putList(IngestUserAgentPlugin.PROCESSORS_ALLOWLIST_SETTING.getKey(), allowList).build();
+        try (IngestUserAgentPlugin plugin = new IngestUserAgentPlugin()) {
+            assertEquals(Set.copyOf(allowList), plugin.getProcessors(createParameters(settings)).keySet());
+        }
+    }
+
+    private static Processor.Parameters createParameters(Settings settings) {
+        return new Processor.Parameters(
+            TestEnvironment.newEnvironment(settings),
+            null,
+            null,
+            null,
+            () -> 0L,
+            (a, b) -> null,
+            null,
+            null,
+            $ -> {},
+            null
+        );
+    }
+}
diff --git a/modules/lang-expression/licenses/lucene-expressions-9.10.0.jar.sha1 b/modules/lang-expression/licenses/lucene-expressions-9.10.0.jar.sha1
deleted file mode 100644
index 4c85d77f41cd6..0000000000000
--- a/modules/lang-expression/licenses/lucene-expressions-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e2daf2e568fe120e84567505f7c85643bb0b9dd2
\ No newline at end of file
diff --git a/modules/lang-expression/licenses/lucene-expressions-9.11.1.jar.sha1 b/modules/lang-expression/licenses/lucene-expressions-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..6b9e49f2e745f
--- /dev/null
+++ b/modules/lang-expression/licenses/lucene-expressions-9.11.1.jar.sha1
@@ -0,0 +1 @@
+e46fbc4fd325ca00ed5a7cacde7ffafa01d7973e
\ No newline at end of file
diff --git a/modules/lang-mustache/build.gradle b/modules/lang-mustache/build.gradle
index 6a3e5fd0e43ae..cb4f496201087 100644
--- a/modules/lang-mustache/build.gradle
+++ b/modules/lang-mustache/build.gradle
@@ -38,7 +38,7 @@ opensearchplugin {
 }
 
 dependencies {
-  api "com.github.spullara.mustache.java:compiler:0.9.13"
+  api "com.github.spullara.mustache.java:compiler:0.9.14"
 }
 
 restResources {
diff --git a/modules/lang-mustache/licenses/compiler-0.9.13.jar.sha1 b/modules/lang-mustache/licenses/compiler-0.9.13.jar.sha1
deleted file mode 100644
index 70d53aac260eb..0000000000000
--- a/modules/lang-mustache/licenses/compiler-0.9.13.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-60666500a7dce7a5d3e17c09b46ea6f037192bd5
\ No newline at end of file
diff --git a/modules/lang-mustache/licenses/compiler-0.9.14.jar.sha1 b/modules/lang-mustache/licenses/compiler-0.9.14.jar.sha1
new file mode 100644
index 0000000000000..29069ac90817a
--- /dev/null
+++ b/modules/lang-mustache/licenses/compiler-0.9.14.jar.sha1
@@ -0,0 +1 @@
+e6df8b5aabb80d6eb6d8fef312a56d66b7659ba6
\ No newline at end of file
diff --git a/modules/lang-painless/build.gradle b/modules/lang-painless/build.gradle
index a8e95911bbd7b..7cc4cec24a975 100644
--- a/modules/lang-painless/build.gradle
+++ b/modules/lang-painless/build.gradle
@@ -33,6 +33,7 @@ import com.github.jengelman.gradle.plugins.shadow.ShadowBasePlugin
 
 apply plugin: 'opensearch.validate-rest-spec'
 apply plugin: 'opensearch.yaml-rest-test'
+apply plugin: 'opensearch.internal-cluster-test'
 
 opensearchplugin {
   description 'An easy, safe and fast scripting language for OpenSearch'
@@ -46,6 +47,7 @@ ext {
 
 testClusters.all {
   module ':modules:mapper-extras'
+  module ':modules:aggs-matrix-stats'
   systemProperty 'opensearch.scripting.update.ctx_in_params', 'false'
   // TODO: remove this once cname is prepended to transport.publish_address by default in 8.0
   systemProperty 'opensearch.transport.cname_in_publish_address', 'true'
diff --git a/modules/lang-painless/src/internalClusterTest/java/org/opensearch/painless/SimplePainlessIT.java b/modules/lang-painless/src/internalClusterTest/java/org/opensearch/painless/SimplePainlessIT.java
new file mode 100644
index 0000000000000..d22a602b9b818
--- /dev/null
+++ b/modules/lang-painless/src/internalClusterTest/java/org/opensearch/painless/SimplePainlessIT.java
@@ -0,0 +1,223 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.painless;
+
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
+
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.support.WriteRequest;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.query.TermsQueryBuilder;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.script.Script;
+import org.opensearch.script.ScriptType;
+import org.opensearch.search.aggregations.AggregationBuilder;
+import org.opensearch.search.aggregations.AggregationBuilders;
+import org.opensearch.search.aggregations.bucket.composite.InternalComposite;
+import org.opensearch.search.aggregations.bucket.composite.TermsValuesSourceBuilder;
+import org.opensearch.search.aggregations.bucket.terms.Terms;
+import org.opensearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
+import org.opensearch.search.builder.SearchSourceBuilder;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.opensearch.test.ParameterizedStaticSettingsOpenSearchIntegTestCase;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import static org.opensearch.index.query.QueryBuilders.matchAllQuery;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertSearchResponse;
+
+@OpenSearchIntegTestCase.SuiteScopeTestCase
+public class SimplePainlessIT extends ParameterizedStaticSettingsOpenSearchIntegTestCase {
+
+    public SimplePainlessIT(Settings nodeSettings) {
+        super(nodeSettings);
+    }
+
+    @ParametersFactory
+    public static Collection<Object[]> parameters() {
+        return Arrays.asList(
+            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() },
+            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() }
+        );
+    }
+
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return List.of(PainlessPlugin.class);
+    }
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING.getKey(), "4")
+            .build();
+    }
+
+    @Override
+    public void setupSuiteScopeCluster() throws Exception {
+        XContentBuilder xContentBuilder = XContentFactory.jsonBuilder()
+            .startObject()
+            .field("dynamic", "false")
+            .startObject("_meta")
+            .field("schema_version", 5)
+            .endObject()
+            .startObject("properties")
+            .startObject("entity")
+            .field("type", "nested")
+            .endObject()
+            .endObject()
+            .endObject();
+
+        assertAcked(
+            prepareCreate("test").setMapping(xContentBuilder)
+                .setSettings(
+                    Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                )
+        );
+
+        assertAcked(
+            prepareCreate("test-df").setSettings(
+                Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            )
+        );
+
+        client().prepareIndex("test")
+            .setId("a")
+            .setSource(
+                "{\"entity\":[{\"name\":\"ip-field\",\"value\":\"1.2.3.4\"},{\"name\":\"keyword-field\",\"value\":\"field-1\"}]}",
+                MediaTypeRegistry.JSON
+            )
+            .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+            .get();
+        client().prepareIndex("test")
+            .setId("b")
+            .setSource(
+                "{\"entity\":[{\"name\":\"ip-field\",\"value\":\"5.6.7.8\"},{\"name\":\"keyword-field\",\"value\":\"field-2\"}]}",
+                MediaTypeRegistry.JSON
+            )
+            .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+            .get();
+        client().prepareIndex("test")
+            .setId("c")
+            .setSource(
+                "{\"entity\":[{\"name\":\"ip-field\",\"value\":\"1.6.3.8\"},{\"name\":\"keyword-field\",\"value\":\"field-2\"}]}",
+                MediaTypeRegistry.JSON
+            )
+            .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+            .get();
+        client().prepareIndex("test")
+            .setId("d")
+            .setSource(
+                "{\"entity\":[{\"name\":\"ip-field\",\"value\":\"2.6.4.8\"},{\"name\":\"keyword-field\",\"value\":\"field-2\"}]}",
+                MediaTypeRegistry.JSON
+            )
+            .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+            .get();
+        ensureSearchable("test");
+
+        client().prepareIndex("test-df")
+            .setId("a")
+            .setSource("{\"field\":\"value1\"}", MediaTypeRegistry.JSON)
+            .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+            .get();
+        client().prepareIndex("test-df")
+            .setId("b")
+            .setSource("{\"field\":\"value2\"}", MediaTypeRegistry.JSON)
+            .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+            .get();
+        client().prepareIndex("test-df")
+            .setId("c")
+            .setSource("{\"field\":\"value3\"}", MediaTypeRegistry.JSON)
+            .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+            .get();
+        client().prepareIndex("test-df")
+            .setId("d")
+            .setSource("{\"field\":\"value1\"}", MediaTypeRegistry.JSON)
+            .setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE)
+            .get();
+        ensureSearchable("test");
+    }
+
+    public void testTermsValuesSource() throws Exception {
+        AggregationBuilder agg = AggregationBuilders.composite(
+            "multi_buckets",
+            Collections.singletonList(
+                new TermsValuesSourceBuilder("keyword-field").script(
+                    new Script(
+                        ScriptType.INLINE,
+                        "painless",
+                        "String value = null; if (params == null || params._source == null || params._source.entity == null) { return \"\"; } for (item in params._source.entity) { if (item[\"name\"] == \"keyword-field\") { value = item['value']; break; } } return value;",
+                        Collections.emptyMap()
+                    )
+                )
+            )
+        );
+        SearchResponse response = client().prepareSearch("test").setQuery(matchAllQuery()).addAggregation(agg).get();
+
+        assertSearchResponse(response);
+        assertEquals(2, ((InternalComposite) response.getAggregations().get("multi_buckets")).getBuckets().size());
+        assertEquals(
+            "field-1",
+            ((InternalComposite) response.getAggregations().get("multi_buckets")).getBuckets().get(0).getKey().get("keyword-field")
+        );
+        assertEquals(1, ((InternalComposite) response.getAggregations().get("multi_buckets")).getBuckets().get(0).getDocCount());
+        assertEquals(
+            "field-2",
+            ((InternalComposite) response.getAggregations().get("multi_buckets")).getBuckets().get(1).getKey().get("keyword-field")
+        );
+        assertEquals(3, ((InternalComposite) response.getAggregations().get("multi_buckets")).getBuckets().get(1).getDocCount());
+    }
+
+    public void testSimpleDerivedFieldsQuery() {
+        SearchRequest searchRequest = new SearchRequest("test-df").source(
+            SearchSourceBuilder.searchSource()
+                .derivedField("result", "keyword", new Script("emit(params._source[\"field\"])"))
+                .fetchField("result")
+                .query(new TermsQueryBuilder("result", "value1"))
+        );
+        SearchResponse response = client().search(searchRequest).actionGet();
+        assertSearchResponse(response);
+        assertEquals(2, Objects.requireNonNull(response.getHits().getTotalHits()).value);
+    }
+
+    public void testSimpleDerivedFieldsAgg() {
+        SearchRequest searchRequest = new SearchRequest("test-df").source(
+            SearchSourceBuilder.searchSource()
+                .derivedField("result", "keyword", new Script("emit(params._source[\"field\"])"))
+                .fetchField("result")
+                .aggregation(new TermsAggregationBuilder("derived-agg").field("result"))
+        );
+        SearchResponse response = client().search(searchRequest).actionGet();
+        assertSearchResponse(response);
+        Terms aggResponse = response.getAggregations().get("derived-agg");
+        assertEquals(3, aggResponse.getBuckets().size());
+        Terms.Bucket bucket = aggResponse.getBuckets().get(0);
+        assertEquals("value1", bucket.getKey());
+        assertEquals(2, bucket.getDocCount());
+        bucket = aggResponse.getBuckets().get(1);
+        assertEquals("value2", bucket.getKey());
+        assertEquals(1, bucket.getDocCount());
+        bucket = aggResponse.getBuckets().get(2);
+        assertEquals("value3", bucket.getKey());
+        assertEquals(1, bucket.getDocCount());
+    }
+}
diff --git a/modules/lang-painless/src/test/java/org/opensearch/painless/WhenThingsGoWrongTests.java b/modules/lang-painless/src/test/java/org/opensearch/painless/WhenThingsGoWrongTests.java
index 0d498e16154c8..3d48e96117a1c 100644
--- a/modules/lang-painless/src/test/java/org/opensearch/painless/WhenThingsGoWrongTests.java
+++ b/modules/lang-painless/src/test/java/org/opensearch/painless/WhenThingsGoWrongTests.java
@@ -354,6 +354,9 @@ public void testInvalidAssignment() {
         assertEquals(iae.getMessage(), "invalid assignment: cannot assign a value to addition operation [+]");
         iae = expectScriptThrows(IllegalArgumentException.class, () -> exec("Double.x() = 1;"));
         assertEquals(iae.getMessage(), "invalid assignment: cannot assign a value to method call [x/0]");
+
+        expectScriptThrows(UnsupportedOperationException.class, () -> exec("params['modifyingParamsMap'] = 2;"));
+        expectScriptThrows(UnsupportedOperationException.class, () -> exec("params.modifyingParamsMap = 2;"));
     }
 
     public void testCannotResolveSymbol() {
diff --git a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/17_update_error.yml b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/17_update_error.yml
index 3d6db1b781caf..fdbc6de37e3ea 100644
--- a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/17_update_error.yml
+++ b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/17_update_error.yml
@@ -13,3 +13,50 @@
   - match: { error.root_cause.0.position.offset: 13 }
   - match: { error.root_cause.0.position.start: 0 }
   - match: { error.root_cause.0.position.end: 38 }
+
+---
+"Test modifying params map from script leads to exception":
+  - skip:
+      features: "node_selector"
+
+  - do:
+      put_script:
+        id: "except"
+        body: {"script": {"lang": "painless", "source": "params.that = 3"}}
+
+  - do:
+      indices.create:
+        index: "test"
+        body:
+          settings:
+            index:
+              number_of_shards: 1
+              number_of_replicas: 0
+          mappings:
+            properties:
+              this:
+                type: "integer"
+              that:
+                type: "integer"
+
+  - do:
+      index:
+        index: "test"
+        id: 1
+        body: {"this": 1, "that": 2}
+
+  - do:
+      catch: /unsupported_operation_exception/
+      node_selector:
+        version: "2.15.0 - "
+      update:
+        index: "test"
+        id: 1
+        body:
+          script:
+            id: "except"
+            params: {"this": 2}
+
+  - match: { error.caused_by.position.offset: 6 }
+  - match: { error.caused_by.position.start: 0 }
+  - match: { error.caused_by.position.end: 15 }
diff --git a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/10_derived_field_index_mapping_definition.yml b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/10_derived_field_index_mapping_definition.yml
new file mode 100644
index 0000000000000..4f700c3b83e8f
--- /dev/null
+++ b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/10_derived_field_index_mapping_definition.yml
@@ -0,0 +1,421 @@
+"Test derived_field supported type using index mapping definition":
+  - skip:
+      version: " - 2.14.99"
+      reason: "derived_field feature was added in 2.15"
+
+  - do:
+      indices.create:
+        index: test
+        body:
+          mappings:
+            properties:
+              text:
+                type: text
+              keyword:
+                type: keyword
+              long:
+                type: long
+              float:
+                type: float
+              double:
+                type: double
+              date:
+                type: date
+              geo:
+                type: geo_point
+              ip:
+                type: ip
+              boolean:
+                type: boolean
+              array_of_long:
+                type: long
+              json_field:
+                type: text
+            derived:
+              derived_text:
+                type: text
+                script: "emit(params._source[\"text\"])"
+              derived_text_prefilter_field:
+                type: text
+                script: "emit(params._source[\"text\"])"
+                prefilter_field: "text"
+              derived_keyword:
+                type: keyword
+                script: "emit(params._source[\"keyword\"])"
+              derived_long:
+                type: long
+                script: "emit(params._source[\"long\"])"
+              derived_float:
+                type: float
+                script: "emit(params._source[\"float\"])"
+              derived_double:
+                type: double
+                script: "emit(params._source[\"double\"])"
+              derived_date:
+                type: date
+                script: "emit(ZonedDateTime.parse(params._source[\"date\"]).toInstant().toEpochMilli())"
+              derived_geo:
+                type: geo_point
+                script: "emit(params._source[\"geo\"][0], params._source[\"geo\"][1])"
+              derived_ip:
+                type: ip
+                script: "emit(params._source[\"ip\"])"
+              derived_boolean:
+                type: boolean
+                script: "emit(params._source[\"boolean\"])"
+              derived_array_of_long:
+                type: long
+                script: "emit(params._source[\"array_of_long\"][0]);emit(params._source[\"array_of_long\"][1]);"
+              derived_object:
+                type: object
+                properties:
+                  keyword: keyword
+                script: "emit(params._source[\"json_field\"])"
+                prefilter_field: "json_field"
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          text: "peter piper",
+          keyword: "foo",
+          long: 1,
+          float: 1.0,
+          double: 1.0,
+          date: "2017-01-01T00:00:00Z",
+          geo: [0.0, 20.0],
+          ip: "192.168.0.1",
+          boolean: true,
+          array_of_long: [1, 2],
+          json_field: "{\"keyword\":\"json_keyword1\",\"long\":10,\"float\":10.0,\"double\":10.0,\"date\":\"2021-01-01T00:00:00Z\",\"ip\":\"10.0.0.1\",\"boolean\":true, \"array_of_long\": [1, 2]}}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        body: {
+          text: "piper picked a peck",
+          keyword: "bar",
+          long: 2,
+          float: 2.0,
+          double: 2.0,
+          date: "2017-01-02T00:00:00Z",
+          geo: [10.0, 30.0],
+          ip: "192.168.0.2",
+          boolean: false,
+          array_of_long: [2, 3],
+          json_field: "{\"keyword\":\"json_keyword2\",\"long\":20,\"float\":20.0,\"double\":20.0,\"date\":\"2021-02-01T00:00:00Z\",\"ip\":\"10.0.0.2\",\"boolean\":false, \"array_of_long\": [2, 3]}}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 3
+        body: {
+          text: "peck of pickled peppers",
+          keyword: "baz",
+          long: -3,
+          float: -3.0,
+          double: -3.0,
+          date: "2017-01-03T00:00:00Z",
+          geo: [20.0, 40.0],
+          ip: "192.168.0.3",
+          boolean: true,
+          array_of_long: [3, 4],
+          json_field: "{\"keyword\":\"json_keyword3\",\"long\":30,\"float\":30.0,\"double\":30.0,\"date\":\"2021-03-01T00:00:00Z\",\"ip\":\"10.0.0.3\",\"boolean\":true, \"array_of_long\": [3, 4]}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 4
+        body: {
+          text: "pickled peppers",
+          keyword: "qux",
+          long: 4,
+          float: 4.0,
+          double: 4.0,
+          date: "2017-01-04T00:00:00Z",
+          geo: [30.0, 50.0],
+          ip: "192.168.0.4",
+          boolean: false,
+          array_of_long: [4, 5],
+          json_field: "{\"keyword\":\"json_keyword4\",\"long\":40,\"float\":40.0,\"double\":40.0,\"date\":\"2021-04-01T00:00:00Z\",\"ip\":\"10.0.0.4\",\"boolean\":false, \"array_of_long\": [4, 5]}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 5
+        body: {
+          text: "peppers",
+          keyword: "quux",
+          long: 5,
+          float: 5.0,
+          double: 5.0,
+          date: "2017-01-05T00:00:00Z",
+          geo: [40.0, 60.0],
+          ip: "192.168.0.5",
+          boolean: true,
+          array_of_long: [5, 6],
+          json_field: "{\"keyword\":\"json_keyword5\",\"long\":50,\"float\":50.0,\"double\":50.0,\"date\":\"2021-05-01T00:00:00Z\",\"ip\":\"10.0.0.5\",\"boolean\":true, \"array_of_long\": [5, 6]}"
+        }
+
+  - do:
+      indices.refresh:
+        index: [test]
+
+  # Tests for derived_text
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            match_phrase:
+              derived_text:
+                query: "peter piper"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_keyword
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            term:
+              derived_keyword:
+                value: "foo"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_long
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_long:
+                gte: 1
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_float
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_float:
+                gte: 1.0
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_double
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_double:
+                gte: 1.0
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_date
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_date:
+                gte: "2017-01-02"
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_geo
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            geo_distance:
+              distance: "20km"
+              derived_geo:
+                lat: 0.0
+                lon: 20.0
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_ip
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            term:
+              derived_ip:
+                value: "192.168.0.1"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_boolean
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            term:
+              derived_boolean:
+                value: true
+
+  - match: { hits.total: 3 }
+
+  # Tests for derived_array_of_long
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_array_of_long:
+                gte: 3
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_object.keyword
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            term:
+              derived_object.keyword:
+                value: "json_keyword1"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_object.long
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_object.long:
+                gte: 11
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_object.float
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_object.float:
+                gte: 10.1
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_object.double
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_object.double:
+                gte: 10.1
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_object.date
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_object.date:
+                gte: "2021-03-01"
+
+  - match: { hits.total: 3 }
+
+  # Tests for derived_object.ip
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            term:
+              derived_object.ip:
+                value: "10.0.0.1"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_object.boolean
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            term:
+              derived_object.boolean:
+                value: true
+
+  - match: { hits.total: 3 }
+
+  # Tests for derived_object.array_of_long
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range:
+              derived_object.array_of_long:
+                gte: 3
+
+  - match: { hits.total: 4 }
+
+  # Tests for query string
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        q: "derived_keyword:foo"
+
+  - match: { hits.total: 1 }
+
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        q: derived_object.keyword:json_keyword1
+
+  - match: { hits.total: 1 }
diff --git a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/20_derived_field_put_mapping.yml b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/20_derived_field_put_mapping.yml
new file mode 100644
index 0000000000000..0370fd94e8548
--- /dev/null
+++ b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/20_derived_field_put_mapping.yml
@@ -0,0 +1,123 @@
+---
+"Test create and update mapping for derived fields":
+  - skip:
+      version: " - 2.14.99"
+      reason: "derived_field feature was added in 2.15"
+  - do:
+      indices.create:
+        index: test_index
+
+  - do:
+      indices.put_mapping:
+        index: test_index
+        body:
+          properties:
+            text:
+              type: text
+            json_field:
+              type: text
+          derived:
+            derived_text:
+              type: text
+              script: "emit(params._source[\"text\"])"
+            derived_text_prefilter_field:
+              type: keyword
+              script: "emit(params._source[\"text\"])"
+              prefilter_field: "text"
+            derived_date:
+              type: date
+              script: "emit(params._source[\"keyword\"])"
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+
+  - do:
+      indices.get_mapping:
+        index: test_index
+
+  - match: {test_index.mappings.derived.derived_text.type: text}
+  - match: {test_index.mappings.derived.derived_text_prefilter_field.type: keyword}
+  - match: {test_index.mappings.derived.derived_text_prefilter_field.prefilter_field: text}
+  - match: {test_index.mappings.derived.derived_date.type: date}
+  - match: {test_index.mappings.derived.derived_object.type: object}
+  - match: {test_index.mappings.derived.derived_object.properties.keyword: keyword}
+  - match: {test_index.mappings.derived.derived_object.prefilter_field: json_field}
+
+
+  - do:
+      indices.put_mapping:
+        index: test_index
+        body:
+          properties:
+            text:
+              type: text
+            json_field:
+              type: text
+          derived:
+            derived_text:
+              type: keyword
+              script: "emit(params._source[\"text\"])"
+            derived_text_prefilter_field:
+              type: text
+              script: "emit(params._source[\"text\"])"
+              prefilter_field: "text"
+            derived_date:
+              type: keyword
+              script: "emit(params._source[\"keyword\"])"
+            derived_object:
+              type: object
+              properties:
+                keyword: text
+              script: "emit(params._source[\"text\"])"
+              prefilter_field: "text"
+              format: "dd-MM-yyyy"
+              ignore_malformed: true
+
+  - do:
+      indices.get_mapping:
+        index: test_index
+
+  - match: {test_index.mappings.derived.derived_text.type: keyword}
+  - match: {test_index.mappings.derived.derived_text_prefilter_field.type: text}
+  - match: {test_index.mappings.derived.derived_text_prefilter_field.prefilter_field: text}
+  - match: {test_index.mappings.derived.derived_date.type: keyword}
+  - match: {test_index.mappings.derived.derived_object.type: object}
+  - match: {test_index.mappings.derived.derived_object.properties.keyword: text}
+  - match: {test_index.mappings.derived.derived_object.prefilter_field: text}
+  - match: {test_index.mappings.derived.derived_object.format: "dd-MM-yyyy"}
+  - match: {test_index.mappings.derived.derived_object.ignore_malformed: true}
+
+
+  - do:
+      indices.put_mapping:
+        index: test_index
+        body:
+          properties:
+            text:
+              type: text
+            json_field:
+              type: text
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+              ignore_malformed: false
+
+  - do:
+      indices.get_mapping:
+        index: test_index
+
+  - match: {test_index.mappings.derived.derived_text.type: keyword}
+  - match: {test_index.mappings.derived.derived_text_prefilter_field.type: text}
+  - match: {test_index.mappings.derived.derived_text_prefilter_field.prefilter_field: text}
+  - match: {test_index.mappings.derived.derived_date.type: keyword}
+  - match: {test_index.mappings.derived.derived_object.type: object}
+  - match: {test_index.mappings.derived.derived_object.properties.keyword: keyword}
+  - match: {test_index.mappings.derived.derived_object.prefilter_field: json_field}
+  - is_false: test_index.mappings.derived.derived_object.ignore_malformed
diff --git a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/30_derived_field_search_definition.yml b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/30_derived_field_search_definition.yml
new file mode 100644
index 0000000000000..bb619dce63010
--- /dev/null
+++ b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/30_derived_field_search_definition.yml
@@ -0,0 +1,489 @@
+"Test derived_field supported type using search definition":
+  - skip:
+      version: " - 2.14.99"
+      reason: "derived_field feature was added in 2.15"
+
+  - do:
+      indices.create:
+        index: test
+        body:
+          mappings:
+            properties:
+              text:
+                type: text
+              keyword:
+                type: keyword
+              long:
+                type: long
+              float:
+                type: float
+              double:
+                type: double
+              date:
+                type: date
+              geo:
+                type: geo_point
+              ip:
+                type: ip
+              boolean:
+                type: boolean
+              array_of_long:
+                type: long
+              json_field:
+                type: text
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          text: "peter piper",
+          keyword: "foo",
+          long: 1,
+          float: 1.0,
+          double: 1.0,
+          date: "2017-01-01T00:00:00Z",
+          geo: [0.0, 20.0],
+          ip: "192.168.0.1",
+          boolean: true,
+          array_of_long: [1, 2],
+          json_field: "{\"keyword\":\"json_keyword1\",\"long\":10,\"float\":10.0,\"double\":10.0,\"date\":\"2021-01-01T00:00:00Z\",\"ip\":\"10.0.0.1\",\"boolean\":true, \"array_of_long\": [1, 2]}}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        body: {
+          text: "piper picked a peck",
+          keyword: "bar",
+          long: 2,
+          float: 2.0,
+          double: 2.0,
+          date: "2017-01-02T00:00:00Z",
+          geo: [10.0, 30.0],
+          ip: "192.168.0.2",
+          boolean: false,
+          array_of_long: [2, 3],
+          json_field: "{\"keyword\":\"json_keyword2\",\"long\":20,\"float\":20.0,\"double\":20.0,\"date\":\"2021-02-01T00:00:00Z\",\"ip\":\"10.0.0.2\",\"boolean\":false, \"array_of_long\": [2, 3]}}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 3
+        body: {
+          text: "peck of pickled peppers",
+          keyword: "baz",
+          long: -3,
+          float: -3.0,
+          double: -3.0,
+          date: "2017-01-03T00:00:00Z",
+          geo: [20.0, 40.0],
+          ip: "192.168.0.3",
+          boolean: true,
+          array_of_long: [3, 4],
+          json_field: "{\"keyword\":\"json_keyword3\",\"long\":30,\"float\":30.0,\"double\":30.0,\"date\":\"2021-03-01T00:00:00Z\",\"ip\":\"10.0.0.3\",\"boolean\":true, \"array_of_long\": [3, 4]}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 4
+        body: {
+          text: "pickled peppers",
+          keyword: "qux",
+          long: 4,
+          float: 4.0,
+          double: 4.0,
+          date: "2017-01-04T00:00:00Z",
+          geo: [30.0, 50.0],
+          ip: "192.168.0.4",
+          boolean: false,
+          array_of_long: [4, 5],
+          json_field: "{\"keyword\":\"json_keyword4\",\"long\":40,\"float\":40.0,\"double\":40.0,\"date\":\"2021-04-01T00:00:00Z\",\"ip\":\"10.0.0.4\",\"boolean\":false, \"array_of_long\": [4, 5]}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 5
+        body: {
+          text: "peppers",
+          keyword: "quux",
+          long: 5,
+          float: 5.0,
+          double: 5.0,
+          date: "2017-01-05T00:00:00Z",
+          geo: [40.0, 60.0],
+          ip: "192.168.0.5",
+          boolean: true,
+          array_of_long: [5, 6],
+          json_field: "{\"keyword\":\"json_keyword5\",\"long\":50,\"float\":50.0,\"double\":50.0,\"date\":\"2021-05-01T00:00:00Z\",\"ip\":\"10.0.0.5\",\"boolean\":true, \"array_of_long\": [5, 6]}"
+        }
+
+  - do:
+      indices.refresh:
+        index: [test]
+
+  # Tests for derived_text
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_text:
+              type: text
+              script: "emit(params._source[\"text\"])"
+          query:
+            match_phrase:
+              derived_text:
+                query: "peter piper"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_keyword
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_keyword:
+              type: keyword
+              script: "emit(params._source[\"keyword\"])"
+          query:
+            term:
+              derived_keyword:
+                value: "foo"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_long
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_long:
+              type: long
+              script: "emit(params._source[\"long\"])"
+          query:
+            range:
+              derived_long:
+                gte: 1
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_float
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_float:
+              type: float
+              script: "emit(params._source[\"float\"])"
+          query:
+            range:
+              derived_float:
+                gte: 1.0
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_double
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_double:
+              type: double
+              script: "emit(params._source[\"double\"])"
+          query:
+            range:
+              derived_double:
+                gte: 1.0
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_date
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_date:
+              type: date
+              script: "emit(ZonedDateTime.parse(params._source[\"date\"]).toInstant().toEpochMilli())"
+          query:
+            range:
+              derived_date:
+                gte: "2017-01-02"
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_geo
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_geo:
+              type: geo_point
+              script: "emit(params._source[\"geo\"][0], params._source[\"geo\"][1])"
+          query:
+            geo_distance:
+              distance: "20km"
+              derived_geo:
+                lat: 0.0
+                lon: 20.0
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_ip
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_ip:
+              type: ip
+              script: "emit(params._source[\"ip\"])"
+          query:
+            term:
+              derived_ip:
+                value: "192.168.0.1"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_boolean
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_boolean:
+              type: boolean
+              script: "emit(params._source[\"boolean\"])"
+          query:
+            term:
+              derived_boolean:
+                value: true
+
+  - match: { hits.total: 3 }
+
+  # Tests for derived_array_of_long
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_array_of_long:
+              type: long
+              script: "emit(params._source[\"array_of_long\"][0]);emit(params._source[\"array_of_long\"][1]);"
+          query:
+            range:
+              derived_array_of_long:
+                gte: 3
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_object.keyword
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+          query:
+            term:
+              derived_object.keyword:
+                value: "json_keyword1"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_object.long
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+          query:
+            range:
+              derived_object.long:
+                gte: 11
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_object.float
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+          query:
+            range:
+              derived_object.float:
+                gte: 10.1
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_object.double
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+          query:
+            range:
+              derived_object.double:
+                gte: 10.1
+
+  - match: { hits.total: 4 }
+
+  # Tests for derived_object.date
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+          query:
+            range:
+              derived_object.date:
+                gte: "2021-03-01"
+
+  - match: { hits.total: 3 }
+
+  # Tests for derived_object.ip
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+          query:
+            term:
+              derived_object.ip:
+                value: "10.0.0.1"
+
+  - match: { hits.total: 1 }
+
+  # Tests for derived_object.boolean
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+          query:
+            term:
+              derived_object.boolean:
+                value: true
+
+  - match: { hits.total: 3 }
+
+  # Tests for derived_object.array_of_long
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+          query:
+            range:
+              derived_object.array_of_long:
+                gte: 3
+
+  - match: { hits.total: 4 }
+
+  # Tests for query string
+  - do:
+      search:
+        body:
+          derived:
+            derived_keyword:
+              type: keyword
+              script: "emit(params._source[\"keyword\"])"
+        rest_total_hits_as_int: true
+        index: test
+        q: "derived_keyword:foo"
+
+  - match: { hits.total: 1 }
+
+  - do:
+      search:
+        body:
+          derived:
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+        rest_total_hits_as_int: true
+        index: test
+        q: derived_object.keyword:json_keyword1
+
+  - match: { hits.total: 1 }
diff --git a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/40_derived_field_fetch_and_highlight.yml b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/40_derived_field_fetch_and_highlight.yml
new file mode 100644
index 0000000000000..52a897c341419
--- /dev/null
+++ b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/40_derived_field_fetch_and_highlight.yml
@@ -0,0 +1,279 @@
+setup:
+  - skip:
+      version: " - 2.14.99"
+      reason: "derived_field feature was added in 2.15"
+
+---
+"Test basic field retrieval":
+  - do:
+      indices.create:
+        index: test
+        body:
+          mappings:
+            properties:
+              text:
+                type: text
+              keyword:
+                type: keyword
+              long:
+                type: long
+              float:
+                type: float
+              double:
+                type: double
+              date:
+                type: date
+              geo:
+                type: geo_point
+              ip:
+                type: ip
+              boolean:
+                type: boolean
+              array_of_long:
+                type: long
+              json_field:
+                type: text
+            derived:
+              derived_text:
+                type: text
+                script: "emit(params._source[\"text\"])"
+              derived_text_prefilter_field:
+                type: text
+                script: "emit(params._source[\"text\"])"
+                prefilter_field: "text"
+              derived_keyword:
+                type: keyword
+                script: "emit(params._source[\"keyword\"])"
+              derived_long:
+                type: long
+                script: "emit(params._source[\"long\"])"
+              derived_float:
+                type: float
+                script: "emit(params._source[\"float\"])"
+              derived_double:
+                type: double
+                script: "emit(params._source[\"double\"])"
+              derived_date:
+                type: date
+                script: "emit(ZonedDateTime.parse(params._source[\"date\"]).toInstant().toEpochMilli())"
+              derived_geo:
+                type: geo_point
+                script: "emit(params._source[\"geo\"][0], params._source[\"geo\"][1])"
+              derived_ip:
+                type: ip
+                script: "emit(params._source[\"ip\"])"
+              derived_boolean:
+                type: boolean
+                script: "emit(params._source[\"boolean\"])"
+              derived_array_of_long:
+                type: long
+                script: "emit(params._source[\"array_of_long\"][0]);emit(params._source[\"array_of_long\"][1]);"
+              derived_object:
+                type: object
+                properties:
+                  keyword: keyword
+                script: "emit(params._source[\"json_field\"])"
+                prefilter_field: "json_field"
+                format: "yyyy-MM-dd"
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          text: "peter piper",
+          keyword: "foo",
+          long: 1,
+          float: 1.0,
+          double: 1.0,
+          date: "2017-01-01T00:00:00Z",
+          geo: [0.0, 20.0],
+          ip: "192.168.0.1",
+          boolean: true,
+          array_of_long: [1, 2],
+          json_field: "{\"keyword\":\"json_keyword1\",\"long\":10,\"float\":10.0,\"double\":10.0,\"date\":\"2021-01-01T00:00:00Z\",\"ip\":\"10.0.0.1\",\"boolean\":true, \"array_of_long\": [1, 2]}}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        body: {
+          text: "piper picked a peck",
+          keyword: "bar",
+          long: 2,
+          float: 2.0,
+          double: 2.0,
+          date: "2017-01-02T00:00:00Z",
+          geo: [10.0, 30.0],
+          ip: "192.168.0.2",
+          boolean: false,
+          array_of_long: [2, 3],
+          json_field: "{\"keyword\":\"json_keyword2\",\"long\":20,\"float\":20.0,\"double\":20.0,\"date\":\"2021-02-01T00:00:00Z\",\"ip\":\"10.0.0.2\",\"boolean\":false, \"array_of_long\": [2, 3]}}"
+        }
+
+  - do:
+      indices.refresh:
+        index: [test]
+
+  - do:
+      search:
+        index: test
+        body:
+          fields: [derived_text, derived_keyword, derived_long, derived_float, derived_double, derived_date, derived_geo, derived_ip, derived_boolean, derived_array_of_long,
+                   derived_object, derived_object.keyword, derived_object.long, derived_object.float, derived_object.double, derived_object.date, derived_object.ip, derived_object.boolean, derived_object.array_of_long]
+
+  - is_true: hits.hits.0._id
+  - is_true: hits.hits.0._source
+
+  - match: { hits.hits.0.fields.derived_text.0: "peter piper" }
+  - match: { hits.hits.0.fields.derived_keyword.0: foo }
+  - match: { hits.hits.0.fields.derived_long.0: 1 }
+  - match: { hits.hits.0.fields.derived_float.0: 1.0 }
+  - match: { hits.hits.0.fields.derived_double.0: 1 }
+  - match: { hits.hits.0.fields.derived_date.0: 2017-01-01T00:00:00.000Z }
+  - match: { hits.hits.0.fields.derived_geo.0.lat: 0.0 }
+  - match: { hits.hits.0.fields.derived_geo.0.lon: 20.0 }
+  - match: { hits.hits.0.fields.derived_ip.0: 192.168.0.1 }
+  - match: { hits.hits.0.fields.derived_array_of_long.0: 1 }
+  - match: { hits.hits.0.fields.derived_array_of_long.1: 2 }
+  - match: { hits.hits.0.fields.derived_object.0: "{\"keyword\":\"json_keyword1\",\"long\":10,\"float\":10.0,\"double\":10.0,\"date\":\"2021-01-01T00:00:00Z\",\"ip\":\"10.0.0.1\",\"boolean\":true, \"array_of_long\": [1, 2]}}" }
+  - match: { hits.hits.0.fields.derived_object\.keyword.0: json_keyword1 }
+  - match: { hits.hits.0.fields.derived_object\.long.0: 10 }
+  - match: { hits.hits.0.fields.derived_object\.float.0: 10.0 }
+  - match: { hits.hits.0.fields.derived_object\.double.0: 10.0 }
+  - match: { hits.hits.0.fields.derived_object\.date.0: 2021-01-01 }
+  - match: { hits.hits.0.fields.derived_object\.ip.0: 10.0.0.1 }
+  - match: { hits.hits.0.fields.derived_object\.boolean.0: true }
+  - match: { hits.hits.0.fields.derived_object\.array_of_long.0: 1 }
+  - match: { hits.hits.0.fields.derived_object\.array_of_long.1: 2 }
+
+  - match: { hits.hits.1.fields.derived_text.0: "piper picked a peck" }
+  - match: { hits.hits.1.fields.derived_keyword.0: bar }
+  - match: { hits.hits.1.fields.derived_long.0: 2 }
+  - match: { hits.hits.1.fields.derived_float.0: 2.0 }
+  - match: { hits.hits.1.fields.derived_double.0: 2 }
+  - match: { hits.hits.1.fields.derived_date.0: 2017-01-02T00:00:00.000Z }
+  - match: { hits.hits.1.fields.derived_geo.0.lat: 10.0 }
+  - match: { hits.hits.1.fields.derived_geo.0.lon: 30.0 }
+  - match: { hits.hits.1.fields.derived_ip.0: 192.168.0.2 }
+  - match: { hits.hits.1.fields.derived_array_of_long.0: 2 }
+  - match: { hits.hits.1.fields.derived_array_of_long.1: 3 }
+  - match: { hits.hits.1.fields.derived_object.0: "{\"keyword\":\"json_keyword2\",\"long\":20,\"float\":20.0,\"double\":20.0,\"date\":\"2021-02-01T00:00:00Z\",\"ip\":\"10.0.0.2\",\"boolean\":false, \"array_of_long\": [2, 3]}}" }
+  - match: { hits.hits.1.fields.derived_object\.keyword.0: json_keyword2 }
+  - match: { hits.hits.1.fields.derived_object\.long.0: 20 }
+  - match: { hits.hits.1.fields.derived_object\.float.0: 20.0 }
+  - match: { hits.hits.1.fields.derived_object\.double.0: 20.0 }
+  - match: { hits.hits.1.fields.derived_object\.date.0: 2021-02-01 }
+  - match: { hits.hits.1.fields.derived_object\.ip.0: 10.0.0.2 }
+  - match: { hits.hits.1.fields.derived_object\.boolean.0: false }
+  - match: { hits.hits.1.fields.derived_object\.array_of_long.0: 2 }
+  - match: { hits.hits.1.fields.derived_object\.array_of_long.1: 3 }
+
+
+---
+"Test highlight":
+  - do:
+      indices.create:
+        index: test
+        body:
+          mappings:
+            properties:
+              text:
+                type: text
+              array_of_text:
+                type: text
+              json_field:
+                type: text
+            derived:
+              derived_text:
+                type: text
+                script: "emit(params._source[\"text\"])"
+              derived_keyword:
+                type: keyword
+                script: "emit(params._source[\"keyword\"])"
+              derived_array_of_text:
+                type: text
+                script: "emit(params._source[\"array_of_text\"][0]);emit(params._source[\"array_of_text\"][1]);"
+              derived_object:
+                type: object
+                properties:
+                  array_of_text: text
+                script: "emit(params._source[\"json_field\"])"
+                prefilter_field: "json_field"
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          text: "peter piper",
+          keyword: "foo",
+          long: 1,
+          float: 1.0,
+          double: 1.0,
+          date: "2017-01-01T00:00:00Z",
+          geo: [0.0, 20.0],
+          ip: "192.168.0.1",
+          boolean: true,
+          array_of_text: ["The quick brown fox is brown", "The quick brown fox is black"],
+          json_field: "{\"keyword\":\"json_keyword1\",\"long\":10,\"float\":10.0,\"double\":10.0,\"date\":\"2021-01-01T00:00:00Z\",\"ip\":\"10.0.0.1\",\"boolean\":true, \"array_of_text\": [\"The quick brown fox is brown\", \"The quick brown fox is black\"]}}"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        body: {
+          text: "piper picked a peck",
+          keyword: "bar",
+          long: 2,
+          float: 2.0,
+          double: 2.0,
+          date: "2017-01-02T00:00:00Z",
+          geo: [10.0, 30.0],
+          ip: "192.168.0.2",
+          boolean: false,
+          array_of_text: ["The quick brown fox is brown", "The quick brown fox is black"],
+          json_field: "{\"keyword\":\"json_keyword2\",\"long\":20,\"float\":20.0,\"double\":20.0,\"date\":\"2021-02-01T00:00:00Z\",\"ip\":\"10.0.0.2\",\"boolean\":false, \"array_of_text\": [\"The quick brown fox is brown\", \"The quick brown fox is black\"]}}"
+        }
+
+  - do:
+      indices.refresh:
+        index: [test]
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        body: { "query" : {"multi_match" : { "query" : "piper", "fields" : [ "derived_text"] } },
+                "fields": [derived_text],
+                "highlight" : { "type" : "unified", "fields" : { "derived_text" : {} } }
+        }
+
+  - match: {hits.hits.0.highlight.derived_text.0: "peter <em>piper</em>"}
+
+
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        body: { "query" : {"multi_match" : { "query" : "quick brown", "fields" : [ "derived_array_of_text"] } },
+                "fields": [derived_array_of_text],
+                "highlight" : { "type" : "unified", "fields" : { "derived_array_of_text" : {} } }
+        }
+
+  - match: {hits.hits.0.highlight.derived_array_of_text.0: "The <em>quick</em> <em>brown</em> fox is <em>brown</em>"}
+
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            match_phrase:
+              derived_object.array_of_text:
+                query: "quick brown"
+          highlight:
+            type: unified
+            fields:
+              derived_object.array_of_text: {}
+
+  - match: {hits.hits.0.highlight.derived_object\.array_of_text.0: "The <em>quick</em> <em>brown</em> fox is <em>brown</em>"}
diff --git a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/50_derived_field_default_analyzer.yml b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/50_derived_field_default_analyzer.yml
new file mode 100644
index 0000000000000..e10c9cb3c133f
--- /dev/null
+++ b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/50_derived_field_default_analyzer.yml
@@ -0,0 +1,105 @@
+---
+"Test default index analyzer simple is applied on derived fields":
+  - do:
+      indices.create:
+        index: test
+        body:
+          settings:
+            index.analysis.analyzer.default.type: simple
+          mappings:
+            properties:
+              text:
+                type: text
+              json_field:
+                type: text
+            derived:
+              derived_text:
+                type: text
+                script: "emit(params._source[\"text\"])"
+              derived_object:
+                type: object
+                properties:
+                  array_of_text: text
+                script: "emit(params._source[\"json_field\"])"
+                prefilter_field: "json_field"
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          text: "Email: example@example.com, Visit https://example.com for more info.",
+          json_field: "{\"array_of_text\": [\"Email: example@example.com, Visit https://example.com for more info.\", \"Email: example@example.com, Visit https://example.com for more info.\"]}}"
+        }
+
+  - do:
+      indices.refresh:
+        index: [test]
+  - do:
+      search:
+        index: test
+        q: "derived_text:example.com"
+        analyzer: standard
+
+  - match: { hits.total.value: 0 }
+
+  - do:
+      search:
+        index: test
+        q: "derived_text:example.com"
+        analyzer: simple
+
+  - match: { hits.total.value: 1 }
+
+---
+"Test default index analyzer standard is applied on derived fields":
+  - do:
+      indices.create:
+        index: test
+        body:
+          settings:
+            index.analysis.analyzer.default.type: standard
+          mappings:
+            properties:
+              text:
+                type: text
+              json_field:
+                type: text
+            derived:
+              derived_text:
+                type: text
+                script: "emit(params._source[\"text\"])"
+              derived_object:
+                type: object
+                properties:
+                  array_of_text: text
+                script: "emit(params._source[\"json_field\"])"
+                prefilter_field: "json_field"
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          text: "Email: example@example.com, Visit https://example.com for more info.",
+          json_field: "{\"array_of_text\": [\"Email: example@example.com, Visit https://example.com for more info.\", \"Email: example@example.com, Visit https://example.com for more info.\"]}}"
+        }
+
+  - do:
+      indices.refresh:
+        index: [test]
+  - do:
+      search:
+        index: test
+        q: "derived_object.array_of_text:example.com"
+        analyzer: standard
+
+  - match: { hits.total.value: 1 }
+
+  - do:
+      search:
+        index: test
+        q: "derived_object.array_of_text:example.com"
+        analyzer: simple
+
+  - match: { hits.total.value: 1 }
diff --git a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/60_derived_field_aggs.yml b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/60_derived_field_aggs.yml
new file mode 100644
index 0000000000000..87c260ce5f308
--- /dev/null
+++ b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/derived_fields/60_derived_field_aggs.yml
@@ -0,0 +1,1515 @@
+---
+setup:
+- skip:
+    version: " - 2.14.99"
+    reason: "derived_field feature was added in 2.15"
+
+# -- NOT SUPPORTED: --
+# geobounds
+# scripted metric
+# -- NOT SUPPORTED: --
+# Any geo agg
+# sig terms/text
+
+- do:
+    indices.create:
+      index: test
+      body:
+        mappings:
+          properties:
+            text:
+              type: text
+            keyword:
+              type: keyword
+            os:
+              type: keyword
+            long:
+              type: long
+            float:
+              type: float
+            double:
+              type: double
+            date:
+              type: date
+            geo:
+              type: geo_point
+            ip:
+              type: ip
+            boolean:
+              type: boolean
+            array_of_long:
+              type: long
+            json_field:
+              type: text
+          derived:
+            derived_text:
+              type: text
+              script: "emit(params._source[\"text\"])"
+            derived_text_prefilter_field:
+              type: text
+              script: "emit(params._source[\"text\"])"
+              prefilter_field: "text"
+            derived_keyword:
+              type: keyword
+              script: "emit(params._source[\"keyword\"])"
+            derived_os:
+              type: keyword
+              script: "emit(params._source[\"os\"])"
+            derived_long:
+              type: long
+              script: "emit(params._source[\"long\"])"
+            derived_float:
+              type: float
+              script: "emit(params._source[\"float\"])"
+            derived_double:
+              type: double
+              script: "emit(params._source[\"double\"])"
+            derived_date:
+              type: date
+              script: "emit(ZonedDateTime.parse(params._source[\"date\"]).toInstant().toEpochMilli())"
+            derived_geo:
+              type: geo_point
+              script: "emit(params._source[\"geo\"][0], params._source[\"geo\"][1])"
+            derived_ip:
+              type: ip
+              script: "emit(params._source[\"ip\"])"
+            derived_boolean:
+              type: boolean
+              script: "emit(params._source[\"boolean\"])"
+            derived_array_of_long:
+              type: long
+              script: "emit(params._source[\"array_of_long\"][0]);emit(params._source[\"array_of_long\"][1]);"
+            derived_object:
+              type: object
+              properties:
+                keyword: keyword
+                ip: ip
+                os: keyword
+              script: "emit(params._source[\"json_field\"])"
+              prefilter_field: "json_field"
+
+- do:
+    bulk:
+      refresh: true
+      body:
+      - index:
+          _index: test
+          _id: 1
+      - text: "peter piper"
+        keyword: "foo"
+        os: "mac"
+        long: 1
+        float: 1.0
+        double: 1.0
+        date: "2017-01-01T00:00:00Z"
+        geo: [ -74.0060, 40.7128 ]
+        ip: "192.168.0.1"
+        boolean: true
+        array_of_long: [ 1, 2 ]
+        json_field: "{\"text\":\"peter piper\",\"keyword\":\"foo\",\"os\":\"mac\",\"long\":1,\"float\":1.0,\"double\":1.0,\"date\":\"2017-01-01T00:00:00Z\",\"ip\":\"192.168.0.1\",\"boolean\":true, \"array_of_long\": [1, 2]}"
+      - index:
+          _index: test
+          _id: 2
+      - text: "piper picked a peck"
+        keyword: "bar"
+        os: "windows"
+        long: 2
+        float: 2.0
+        double: 2.0
+        date: "2017-01-02T00:00:00Z"
+        geo: [ -118.2437, 34.0522 ]
+        ip: "10.0.0.1"
+        boolean: false
+        array_of_long: [ 2, 3 ]
+        json_field: "{\"keyword\":\"bar\",\"long\":2,\"float\":2.0,\"os\":\"windows\",\"double\":2.0,\"date\":\"2017-01-02T00:00:00Z\",\"ip\":\"10.0.0.1\",\"boolean\":false, \"array_of_long\": [2, 3]}"
+      - index:
+          _index: test
+          _id: 3
+      - text: "peck of pickled peppers"
+        keyword: "baz"
+        os: "mac"
+        long: -3
+        float: -3.0
+        double: -3.0
+        date: "2017-01-03T00:00:00Z"
+        geo: [ -87.6298, 41.87 ]
+        ip: "172.16.0.1"
+        boolean: true
+        array_of_long: [ 3, 4 ]
+        json_field: "{\"keyword\":\"baz\",\"long\":-3,\"float\":-3.0,\"os\":\"mac\",\"double\":-3.0,\"date\":\"2017-01-03T00:00:00Z\",\"ip\":\"172.16.0.1\",\"boolean\":true, \"array_of_long\": [3, 4]}"
+      - index:
+          _index: test
+          _id: 4
+      - text: "pickled peppers"
+        keyword: "qux"
+        os: "windows"
+        long: 4
+        float: 4.0
+        double: 4.0
+        date: "2017-01-04T00:00:00Z"
+        geo: [ -74.0060, 40.7128 ]
+        ip: "192.168.0.2"
+        boolean: false
+        array_of_long: [ 4, 5 ]
+        json_field: "{\"keyword\":\"qux\",\"long\":4,\"float\":4.0,\"os\":\"windows\",\"double\":4.0,\"date\":\"2017-01-04T00:00:00Z\",\"ip\":\"192.168.0.2\",\"boolean\":false, \"array_of_long\": [4, 5]}"
+      - index:
+          _index: test
+          _id: 5
+      - text: "peppers"
+        keyword: "quux"
+        os: "mac"
+        long: 5
+        float: 5.0
+        double: 5.0
+        date: "2017-01-05T00:00:00Z"
+        geo: [ -87.6298, 41.87 ]
+        ip: "10.0.0.2"
+        boolean: true
+        array_of_long: [ 5, 6 ]
+        json_field: "{\"keyword\":\"quux\",\"long\":5,\"float\":5.0,\"os\":\"mac\",\"double\":5.0,\"date\":\"2017-01-05T00:00:00Z\",\"ip\":\"10.0.0.2\",\"boolean\":true, \"array_of_long\": [5, 6]}"
+
+- do:
+      indices.refresh:
+        index: [test]
+
+### BUCKET AGGS
+---
+"Test terms aggregation on derived_keyword from search definition":
+- do:
+    search:
+      index: test
+      body:
+        derived:
+          derived_keyword_search_definition:
+            type: keyword
+            script: "emit(params._source[\"keyword\"])"
+        size: 0
+        aggs:
+          keywords:
+            terms:
+              field: derived_keyword_search_definition
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.keywords.buckets: 5 }
+- match: { aggregations.keywords.buckets.0.key: "bar" }
+- match: { aggregations.keywords.buckets.0.doc_count: 1 }
+- match: { aggregations.keywords.buckets.1.key: "baz" }
+- match: { aggregations.keywords.buckets.1.doc_count: 1 }
+- match: { aggregations.keywords.buckets.2.key: "foo" }
+- match: { aggregations.keywords.buckets.2.doc_count: 1 }
+- match: { aggregations.keywords.buckets.3.key: "quux" }
+- match: { aggregations.keywords.buckets.3.doc_count: 1 }
+- match: { aggregations.keywords.buckets.4.key: "qux" }
+- match: { aggregations.keywords.buckets.4.doc_count: 1 }
+
+---
+"Test terms aggregation on derived_keyword":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          keywords:
+            terms:
+              field: derived_keyword
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.keywords.buckets: 5 }
+- match: { aggregations.keywords.buckets.0.key: "bar" }
+- match: { aggregations.keywords.buckets.0.doc_count: 1 }
+- match: { aggregations.keywords.buckets.1.key: "baz" }
+- match: { aggregations.keywords.buckets.1.doc_count: 1 }
+- match: { aggregations.keywords.buckets.2.key: "foo" }
+- match: { aggregations.keywords.buckets.2.doc_count: 1 }
+- match: { aggregations.keywords.buckets.3.key: "quux" }
+- match: { aggregations.keywords.buckets.3.doc_count: 1 }
+- match: { aggregations.keywords.buckets.4.key: "qux" }
+- match: { aggregations.keywords.buckets.4.doc_count: 1 }
+
+---
+"Test range aggregation on derived_long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          long_ranges:
+            range:
+              field: derived_long
+              ranges:
+              - to: 0
+              - from: 0
+                to: 3
+              - from: 3
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.long_ranges.buckets: 3 }
+- match: { aggregations.long_ranges.buckets.0.doc_count: 1 }
+- match: { aggregations.long_ranges.buckets.1.doc_count: 2 }
+- match: { aggregations.long_ranges.buckets.2.doc_count: 2 }
+
+---
+"Test histogram aggregation on derived_float":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          float_histogram:
+            histogram:
+              field: derived_float
+              interval: 2
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.float_histogram.buckets: 5 }
+- match: { aggregations.float_histogram.buckets.0.key: -4.0 }
+- match: { aggregations.float_histogram.buckets.0.doc_count: 1 }
+
+---
+"Test date_histogram aggregation on derived_date":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          date_histogram:
+            date_histogram:
+              field: derived_date
+              calendar_interval: day
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.date_histogram.buckets: 5 }
+- match: { aggregations.date_histogram.buckets.0.key_as_string: "2017-01-01T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.0.doc_count: 1 }
+- match: { aggregations.date_histogram.buckets.1.key_as_string: "2017-01-02T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.1.doc_count: 1 }
+- match: { aggregations.date_histogram.buckets.2.key_as_string: "2017-01-03T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.2.doc_count: 1 }
+- match: { aggregations.date_histogram.buckets.3.key_as_string: "2017-01-04T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.3.doc_count: 1 }
+- match: { aggregations.date_histogram.buckets.4.key_as_string: "2017-01-05T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.4.doc_count: 1 }
+
+---
+"Test date_range aggregation on derived_date":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          date_range:
+            date_range:
+              field: derived_date
+              ranges:
+              - to: "2017-01-03T00:00:00Z"
+              - from: "2017-01-03T00:00:00Z"
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.date_range.buckets.0.key: "*-2017-01-03T00:00:00.000Z" }
+- match: { aggregations.date_range.buckets.0.doc_count: 2 }
+- match: { aggregations.date_range.buckets.1.key: "2017-01-03T00:00:00.000Z-*" }
+- match: { aggregations.date_range.buckets.1.doc_count: 3 }
+
+---
+"Test filters aggregation on derived_boolean":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          boolean_filters:
+            filters:
+              filters:
+                true_values:
+                  term:
+                    derived_boolean: true
+                false_values:
+                  term:
+                    derived_boolean: false
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.boolean_filters.buckets.true_values.doc_count: 3 }
+- match: { aggregations.boolean_filters.buckets.false_values.doc_count: 2 }
+
+---
+"Test adjacency matrix aggregation on derived_long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          adj_matrix:
+            adjacency_matrix:
+              filters:
+                high_num:
+                  range:
+                    derived_long:
+                      gte: 3
+                low_num:
+                  range:
+                    derived_long:
+                      lt: 3
+- match: { hits.total.value: 5 }
+- length: { aggregations.adj_matrix.buckets: 2 }
+- match: { aggregations.adj_matrix.buckets.0.key: "high_num" }
+- match: { aggregations.adj_matrix.buckets.0.doc_count: 2 }
+- match: { aggregations.adj_matrix.buckets.1.key: "low_num" }
+- match: { aggregations.adj_matrix.buckets.1.doc_count: 3 }
+
+### METRIC AGGS
+
+---
+"Test stats aggregation on derived_array_of_long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          long_array_stats:
+            stats:
+              field: derived_array_of_long
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.long_array_stats.count: 10 }
+- match: { aggregations.long_array_stats.min: 1 }
+- match: { aggregations.long_array_stats.max: 6 }
+- match: { aggregations.long_array_stats.avg: 3.5 }
+- match: { aggregations.long_array_stats.sum: 35 }
+
+---
+"Test cardinality aggregation on derived_keyword":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          unique_keywords:
+            cardinality:
+              field: derived_keyword
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.unique_keywords.value: 5 }
+
+---
+"Test percentiles aggregation on derived_double":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          double_percentiles:
+            percentiles:
+              field: derived_double
+              percents: [ 25, 50, 75 ]
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.double_percentiles.values: 3}
+
+---
+"Test percentile ranks aggregation on derived_long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          long_percentile_ranks:
+            percentile_ranks:
+              field: derived_long
+              values: [ 2, 4 ]
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.long_percentile_ranks.values: 2}
+
+---
+"Test top hits aggregation on derived_keyword":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          top_keywords:
+            terms:
+              field: derived_keyword
+            aggs:
+              top_hits:
+                top_hits:
+                  size: 1
+- match: { hits.total.value: 5 }
+- length: { aggregations.top_keywords.buckets: 5 }
+- match: { aggregations.top_keywords.buckets.0.key: "bar" }
+- match: { aggregations.top_keywords.buckets.0.doc_count: 1 }
+- length: { aggregations.top_keywords.buckets.0.top_hits.hits.hits: 1 }
+
+---
+"Test matrix stats aggregation on derived_long and float":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          matrix_stats:
+            matrix_stats:
+              fields: [ derived_long, derived_float ]
+- match: { hits.total.value: 5 }
+- length: { aggregations.matrix_stats.fields: 2 }
+- match: { aggregations.matrix_stats.fields.0.name: "derived_float" }
+- match: { aggregations.matrix_stats.fields.0.count: 5 }
+- match: { aggregations.matrix_stats.fields.1.name: "derived_long" }
+- match: { aggregations.matrix_stats.fields.1.count: 5 }
+
+---
+"Test median absolute deviation aggregation on derived_long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          mad_long:
+            median_absolute_deviation:
+              field: derived_long
+- match: { hits.total.value: 5 }
+- match: { aggregations.mad_long.value: 2.0 }
+
+## Pipeline agg
+---
+"Test simple pipeline agg with derived_keyword and long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          keywords:
+            terms:
+              field: derived_keyword
+            aggs:
+              sum_derived_longs:
+                sum:
+                  field: derived_long
+          sum_total:
+            sum_bucket:
+              buckets_path: "keywords>sum_derived_longs"
+- match: { hits.total.value: 5 }
+- match: { aggregations.keywords.buckets.0.key: "bar" }
+- match: { aggregations.keywords.buckets.0.sum_derived_longs.value: 2 }
+- match: { aggregations.keywords.buckets.1.key: "baz" }
+- match: { aggregations.keywords.buckets.1.sum_derived_longs.value: -3 }
+- match: { aggregations.keywords.buckets.2.key: "foo" }
+- match: { aggregations.keywords.buckets.2.sum_derived_longs.value: 1 }
+- match: { aggregations.keywords.buckets.3.key: "quux" }
+- match: { aggregations.keywords.buckets.3.sum_derived_longs.value: 5 }
+- match: { aggregations.keywords.buckets.4.key: "qux" }
+- match: { aggregations.keywords.buckets.4.sum_derived_longs.value: 4 }
+- match: { aggregations.sum_total.value: 9 }
+
+
+---
+"Test terms aggregation on derived_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          ip_terms:
+            terms:
+              field: derived_ip
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.ip_terms.buckets: 5 }
+- match: { aggregations.ip_terms.buckets.0.key: "10.0.0.1" }
+- match: { aggregations.ip_terms.buckets.0.doc_count: 1 }
+
+---
+"Test range aggregation on derived_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          ip_ranges:
+            ip_range:
+              field: derived_ip
+              ranges:
+              - to: "10.0.0.0"
+              - from: "10.0.0.0"
+                to: "172.16.0.0"
+              - from: "172.16.0.0"
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.ip_ranges.buckets: 3 }
+- match: { aggregations.ip_ranges.buckets.0.doc_count: 0 }
+- match: { aggregations.ip_ranges.buckets.1.doc_count: 2 }
+- match: { aggregations.ip_ranges.buckets.2.doc_count: 3 }
+
+---
+"Test cardinality aggregation on derived_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          unique_ips:
+            cardinality:
+              field: derived_ip
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.unique_ips.value: 5 }
+
+---
+"Test missing aggregation on derived_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          missing_ips:
+            missing:
+              field: derived_ip
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.missing_ips.doc_count: 0 }
+
+---
+"Test value count aggregation on derived_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          ip_count:
+            value_count:
+              field: derived_ip
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.ip_count.value: 5 }
+
+---
+"Test composite agg":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          test_composite_agg:
+            composite:
+              size: 10
+              sources:
+              - os:
+                  terms:
+                    field: derived_os
+              - keyword:
+                  terms:
+                    field: derived_keyword
+              - is_true:
+                  terms:
+                    field: derived_boolean
+            aggs:
+              avg_long:
+                avg:
+                  field: derived_long
+- match: { aggregations.test_composite_agg.buckets.0.key.os: "mac" }
+- match: { aggregations.test_composite_agg.buckets.0.key.keyword: "baz" }
+- match: { aggregations.test_composite_agg.buckets.0.key.is_true: true }
+- match: { aggregations.test_composite_agg.buckets.0.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.0.avg_long.value: -3.0 }
+- match: { aggregations.test_composite_agg.buckets.1.key.os: "mac" }
+- match: { aggregations.test_composite_agg.buckets.1.key.keyword: "foo" }
+- match: { aggregations.test_composite_agg.buckets.1.key.is_true: true }
+- match: { aggregations.test_composite_agg.buckets.1.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.1.avg_long.value: 1.0 }
+- match: { aggregations.test_composite_agg.buckets.2.key.os: "mac" }
+- match: { aggregations.test_composite_agg.buckets.2.key.keyword: "quux" }
+- match: { aggregations.test_composite_agg.buckets.2.key.is_true: true }
+- match: { aggregations.test_composite_agg.buckets.2.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.2.avg_long.value: 5.0 }
+- match: { aggregations.test_composite_agg.buckets.3.key.os: "windows" }
+- match: { aggregations.test_composite_agg.buckets.3.key.keyword: "bar" }
+- match: { aggregations.test_composite_agg.buckets.3.key.is_true: false }
+- match: { aggregations.test_composite_agg.buckets.3.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.3.avg_long.value: 2.0 }
+- match: { aggregations.test_composite_agg.buckets.4.key.os: "windows" }
+- match: { aggregations.test_composite_agg.buckets.4.key.keyword: "qux" }
+- match: { aggregations.test_composite_agg.buckets.4.key.is_true: false }
+- match: { aggregations.test_composite_agg.buckets.4.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.4.avg_long.value: 4.0 }
+
+---
+"Test auto date histogram":
+- do:
+    search:
+      rest_total_hits_as_int: true
+      index: test
+      body:
+        size: 0
+        aggs:
+          test_auto_date_histogram:
+            auto_date_histogram:
+              field: "derived_date"
+              buckets: 10
+              format: "yyyy-MM-dd"
+            aggs:
+              avg_long:
+                avg:
+                  field: derived_long
+- match: { hits.total: 5 }
+- length: { aggregations.test_auto_date_histogram.buckets: 9 }
+- match: { aggregations.test_auto_date_histogram.buckets.0.key_as_string: "2017-01-01"}
+- match: { aggregations.test_auto_date_histogram.buckets.0.avg_long.value: 1.0}
+
+---
+"Test variable_width_histogram aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          var_width_hist:
+            variable_width_histogram:
+              field: derived_long
+              buckets: 3
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.var_width_hist.buckets: 3 }
+
+---
+"Test extended_stats aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          extended_stats_agg:
+            extended_stats:
+              field: derived_long
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.extended_stats_agg.count: 5 }
+- match: { aggregations.extended_stats_agg.min: -3 }
+- match: { aggregations.extended_stats_agg.max: 5 }
+- is_true: aggregations.extended_stats_agg.avg
+- is_true: aggregations.extended_stats_agg.sum
+- is_true: aggregations.extended_stats_agg.sum_of_squares
+- is_true: aggregations.extended_stats_agg.variance
+- is_true: aggregations.extended_stats_agg.std_deviation
+
+---
+"Test rare_terms aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          rare_terms_agg:
+            rare_terms:
+              field: derived_keyword
+              max_doc_count: 1
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.rare_terms_agg.buckets: 5 }
+
+---
+"Test global aggregation":
+- do:
+    search:
+      index: test
+      body:
+        query:
+          term:
+            derived_keyword: "foo"
+        aggs:
+          all_docs:
+            global: {}
+            aggs:
+              avg_long:
+                avg:
+                  field: derived_long
+
+- match: { hits.total.value: 1 }
+- match: { aggregations.all_docs.doc_count: 5 }
+- match: { aggregations.all_docs.avg_long.value: 1.8 }
+
+---
+"Test missing aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          missing_agg:
+            missing:
+              field: derived_keyword
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.missing_agg.doc_count: 0 }
+
+---
+"Test value_count aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          value_count_agg:
+            value_count:
+              field: derived_long
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.value_count_agg.value: 5 }
+
+---
+"Test weighted_avg aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          weighted_avg_agg:
+            weighted_avg:
+              value:
+                field: derived_long
+              weight:
+                field: derived_float
+
+- match: { hits.total.value: 5 }
+- is_true: aggregations.weighted_avg_agg.value
+
+---
+"Test diversified_sampler aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          diversified_sampler_agg:
+            diversified_sampler:
+              field: derived_keyword
+              max_docs_per_value: 1
+            aggs:
+              avg_long:
+                avg:
+                  field: derived_long
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.diversified_sampler_agg.doc_count: 5 }
+- match: { aggregations.diversified_sampler_agg.avg_long.value: 1.8 }
+
+---
+"Test sampler aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          sampler_agg:
+            sampler:
+              shard_size: 2
+            aggs:
+              avg_long:
+                avg:
+                  field: derived_long
+
+- match: { hits.total.value: 5 }
+- is_true: aggregations.sampler_agg.doc_count
+- is_true: aggregations.sampler_agg.avg_long.value
+
+---
+"Test multi_terms aggregation":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          multi_terms_agg:
+            multi_terms:
+              terms:
+              - field: derived_keyword
+              - field: derived_os
+              size: 10
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.multi_terms_agg.buckets: 5 }
+
+#### SAME TESTS WITH DERIVED_OBJECT
+---
+"Test terms aggregation on derived_object.keyword":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          keywords:
+            terms:
+              field: derived_object.keyword
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.keywords.buckets: 5 }
+- match: { aggregations.keywords.buckets.0.key: "bar" }
+- match: { aggregations.keywords.buckets.0.doc_count: 1 }
+- match: { aggregations.keywords.buckets.1.key: "baz" }
+- match: { aggregations.keywords.buckets.1.doc_count: 1 }
+- match: { aggregations.keywords.buckets.2.key: "foo" }
+- match: { aggregations.keywords.buckets.2.doc_count: 1 }
+- match: { aggregations.keywords.buckets.3.key: "quux" }
+- match: { aggregations.keywords.buckets.3.doc_count: 1 }
+- match: { aggregations.keywords.buckets.4.key: "qux" }
+- match: { aggregations.keywords.buckets.4.doc_count: 1 }
+
+---
+"Test range aggregation on derived_object.long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          long_ranges:
+            range:
+              field: derived_object.long
+              ranges:
+              - to: 0
+              - from: 0
+                to: 3
+              - from: 3
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.long_ranges.buckets: 3 }
+- match: { aggregations.long_ranges.buckets.0.doc_count: 1 }
+- match: { aggregations.long_ranges.buckets.1.doc_count: 2 }
+- match: { aggregations.long_ranges.buckets.2.doc_count: 2 }
+
+---
+"Test histogram aggregation on derived_object.float":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          float_histogram:
+            histogram:
+              field: derived_object.float
+              interval: 2
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.float_histogram.buckets: 5 }
+- match: { aggregations.float_histogram.buckets.0.key: -4.0 }
+- match: { aggregations.float_histogram.buckets.0.doc_count: 1 }
+
+---
+"Test date_histogram aggregation on derived_object.date":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          date_histogram:
+            date_histogram:
+              field: derived_object.date
+              calendar_interval: day
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.date_histogram.buckets: 5 }
+- match: { aggregations.date_histogram.buckets.0.key_as_string: "2017-01-01T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.0.doc_count: 1 }
+- match: { aggregations.date_histogram.buckets.1.key_as_string: "2017-01-02T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.1.doc_count: 1 }
+- match: { aggregations.date_histogram.buckets.2.key_as_string: "2017-01-03T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.2.doc_count: 1 }
+- match: { aggregations.date_histogram.buckets.3.key_as_string: "2017-01-04T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.3.doc_count: 1 }
+- match: { aggregations.date_histogram.buckets.4.key_as_string: "2017-01-05T00:00:00.000Z" }
+- match: { aggregations.date_histogram.buckets.4.doc_count: 1 }
+
+---
+"Test date_range aggregation on derived_object.date":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          date_range:
+            date_range:
+              field: derived_object.date
+              ranges:
+              - to: "2017-01-03T00:00:00Z"
+              - from: "2017-01-03T00:00:00Z"
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.date_range.buckets.0.key: "*-2017-01-03T00:00:00.000Z" }
+- match: { aggregations.date_range.buckets.0.doc_count: 2 }
+- match: { aggregations.date_range.buckets.1.key: "2017-01-03T00:00:00.000Z-*" }
+- match: { aggregations.date_range.buckets.1.doc_count: 3 }
+
+---
+"Test filters aggregation on derived_object.boolean":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          boolean_filters:
+            filters:
+              filters:
+                true_values:
+                  term:
+                    derived_object.boolean: true
+                false_values:
+                  term:
+                    derived_object.boolean: false
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.boolean_filters.buckets.true_values.doc_count: 3 }
+- match: { aggregations.boolean_filters.buckets.false_values.doc_count: 2 }
+
+---
+"Test adjacency matrix aggregation on derived_object.long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          adj_matrix:
+            adjacency_matrix:
+              filters:
+                high_num:
+                  range:
+                    derived_object.long:
+                      gte: 3
+                low_num:
+                  range:
+                    derived_object.long:
+                      lt: 3
+- match: { hits.total.value: 5 }
+- length: { aggregations.adj_matrix.buckets: 2 }
+- match: { aggregations.adj_matrix.buckets.0.key: "high_num" }
+- match: { aggregations.adj_matrix.buckets.0.doc_count: 2 }
+- match: { aggregations.adj_matrix.buckets.1.key: "low_num" }
+- match: { aggregations.adj_matrix.buckets.1.doc_count: 3 }
+
+---
+"Test stats aggregation on derived_object.array_of_long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          long_array_stats:
+            stats:
+              field: derived_object.array_of_long
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.long_array_stats.count: 10 }
+- match: { aggregations.long_array_stats.min: 1 }
+- match: { aggregations.long_array_stats.max: 6 }
+- match: { aggregations.long_array_stats.avg: 3.5 }
+- match: { aggregations.long_array_stats.sum: 35 }
+
+---
+"Test cardinality aggregation on derived_object_keyword":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          unique_keywords:
+            cardinality:
+              field: derived_object.keyword
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.unique_keywords.value: 5 }
+
+---
+"Test percentiles aggregation on derived_object.double":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          double_percentiles:
+            percentiles:
+              field: derived_object.double
+              percents: [ 25, 50, 75 ]
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.double_percentiles.values: 3}
+
+---
+"Test percentile ranks aggregation on derived_object.long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          long_percentile_ranks:
+            percentile_ranks:
+              field: derived_object.long
+              values: [ 2, 4 ]
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.long_percentile_ranks.values: 2}
+
+---
+"Test top hits aggregation on derived_object.keyword":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          top_keywords:
+            terms:
+              field: derived_object.keyword
+            aggs:
+              top_hits:
+                top_hits:
+                  size: 1
+- match: { hits.total.value: 5 }
+- length: { aggregations.top_keywords.buckets: 5 }
+- match: { aggregations.top_keywords.buckets.0.key: "bar" }
+- match: { aggregations.top_keywords.buckets.0.doc_count: 1 }
+- length: { aggregations.top_keywords.buckets.0.top_hits.hits.hits: 1 }
+
+---
+"Test matrix stats aggregation on derived_object.long and float":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          matrix_stats:
+            matrix_stats:
+              fields: [ derived_object.long, derived_object.float ]
+- match: { hits.total.value: 5 }
+- length: { aggregations.matrix_stats.fields: 2 }
+- match: { aggregations.matrix_stats.fields.0.name: "derived_object.long" }
+- match: { aggregations.matrix_stats.fields.0.count: 5 }
+- match: { aggregations.matrix_stats.fields.1.name: "derived_object.float" }
+- match: { aggregations.matrix_stats.fields.1.count: 5 }
+
+---
+"Test median absolute deviation aggregation on derived_object.long":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          mad_long:
+            median_absolute_deviation:
+              field: derived_object.long
+- match: { hits.total.value: 5 }
+- match: { aggregations.mad_long.value: 2.0 }
+
+---
+"Test simple pipeline agg derived_object":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          keywords:
+            terms:
+              field: derived_object.keyword
+            aggs:
+              sum_derived_longs:
+                sum:
+                  field: derived_object.long
+          sum_total:
+            sum_bucket:
+              buckets_path: "keywords>sum_derived_longs"
+- match: { hits.total.value: 5 }
+- match: { aggregations.keywords.buckets.0.key: "bar" }
+- match: { aggregations.keywords.buckets.0.sum_derived_longs.value: 2 }
+- match: { aggregations.keywords.buckets.1.key: "baz" }
+- match: { aggregations.keywords.buckets.1.sum_derived_longs.value: -3 }
+- match: { aggregations.keywords.buckets.2.key: "foo" }
+- match: { aggregations.keywords.buckets.2.sum_derived_longs.value: 1 }
+- match: { aggregations.keywords.buckets.3.key: "quux" }
+- match: { aggregations.keywords.buckets.3.sum_derived_longs.value: 5 }
+- match: { aggregations.keywords.buckets.4.key: "qux" }
+- match: { aggregations.keywords.buckets.4.sum_derived_longs.value: 4 }
+- match: { aggregations.sum_total.value: 9 }
+
+
+---
+"Test composite agg on derived_object":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          test_composite_agg:
+            composite:
+              size: 10
+              sources:
+              - os:
+                  terms:
+                    field: derived_object.os
+              - keyword:
+                  terms:
+                    field: derived_object.keyword
+              - is_true:
+                  terms:
+                    field: derived_object.boolean
+            aggs:
+              avg_long:
+                avg:
+                  field: derived_object.long
+- length: { aggregations.test_composite_agg.buckets: 5 }
+- match: { aggregations.test_composite_agg.buckets.0.key.os: "mac" }
+- match: { aggregations.test_composite_agg.buckets.0.key.keyword: "baz" }
+- match: { aggregations.test_composite_agg.buckets.0.key.is_true: true }
+- match: { aggregations.test_composite_agg.buckets.0.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.0.avg_long.value: -3.0 }
+- match: { aggregations.test_composite_agg.buckets.1.key.os: "mac" }
+- match: { aggregations.test_composite_agg.buckets.1.key.keyword: "foo" }
+- match: { aggregations.test_composite_agg.buckets.1.key.is_true: true }
+- match: { aggregations.test_composite_agg.buckets.1.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.1.avg_long.value: 1.0 }
+- match: { aggregations.test_composite_agg.buckets.2.key.os: "mac" }
+- match: { aggregations.test_composite_agg.buckets.2.key.keyword: "quux" }
+- match: { aggregations.test_composite_agg.buckets.2.key.is_true: true }
+- match: { aggregations.test_composite_agg.buckets.2.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.2.avg_long.value: 5.0 }
+- match: { aggregations.test_composite_agg.buckets.3.key.os: "windows" }
+- match: { aggregations.test_composite_agg.buckets.3.key.keyword: "bar" }
+- match: { aggregations.test_composite_agg.buckets.3.key.is_true: false }
+- match: { aggregations.test_composite_agg.buckets.3.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.3.avg_long.value: 2.0 }
+- match: { aggregations.test_composite_agg.buckets.4.key.os: "windows" }
+- match: { aggregations.test_composite_agg.buckets.4.key.keyword: "qux" }
+- match: { aggregations.test_composite_agg.buckets.4.key.is_true: false }
+- match: { aggregations.test_composite_agg.buckets.4.doc_count: 1 }
+- match: { aggregations.test_composite_agg.buckets.4.avg_long.value: 4.0 }
+
+---
+"Test auto date histogram on derived_object":
+- do:
+    search:
+      rest_total_hits_as_int: true
+      index: test
+      body:
+        size: 0
+        aggs:
+          test_auto_date_histogram:
+            auto_date_histogram:
+              field: "derived_object.date"
+              buckets: 10
+              format: "yyyy-MM-dd"
+            aggs:
+              avg_long:
+                avg:
+                  field: derived_object.long
+- match: { hits.total: 5 }
+- length: { aggregations.test_auto_date_histogram.buckets: 9 }
+- match: { aggregations.test_auto_date_histogram.buckets.0.key_as_string: "2017-01-01"}
+- match: { aggregations.test_auto_date_histogram.buckets.0.avg_long.value: 1.0}
+
+---
+"Test variable_width_histogram aggregation on derived_object":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          var_width_hist:
+            variable_width_histogram:
+              field: derived_object.long
+              buckets: 3
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.var_width_hist.buckets: 3 }
+
+---
+"Test extended_stats aggregation on derived_object":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          extended_stats_agg:
+            extended_stats:
+              field: derived_object.long
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.extended_stats_agg.count: 5 }
+- match: { aggregations.extended_stats_agg.min: -3 }
+- match: { aggregations.extended_stats_agg.max: 5 }
+- is_true: aggregations.extended_stats_agg.avg
+- is_true: aggregations.extended_stats_agg.sum
+- is_true: aggregations.extended_stats_agg.sum_of_squares
+- is_true: aggregations.extended_stats_agg.variance
+- is_true: aggregations.extended_stats_agg.std_deviation
+
+---
+"Test rare_terms aggregation on derived_object":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          rare_terms_agg:
+            rare_terms:
+              field: derived_object.keyword
+              max_doc_count: 1
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.rare_terms_agg.buckets: 5 }
+
+---
+"Test global aggregation on derived_object":
+- do:
+    search:
+      index: test
+      body:
+        query:
+          term:
+            derived_object.keyword: "foo"
+        aggs:
+          all_docs:
+            global: {}
+            aggs:
+              avg_long:
+                avg:
+                  field: derived_object.long
+
+- match: { hits.total.value: 1 }
+- match: { aggregations.all_docs.doc_count: 5 }
+- match: { aggregations.all_docs.avg_long.value: 1.8 }
+
+---
+"Test value_count aggregation on derived_object":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          value_count_agg:
+            value_count:
+              field: derived_object.long
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.value_count_agg.value: 5 }
+
+---
+"Test multi_terms aggregation on derived_object":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          multi_terms_agg:
+            multi_terms:
+              terms:
+              - field: derived_object.keyword
+              - field: derived_object.os
+              size: 10
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.multi_terms_agg.buckets: 5 }
+
+
+### IP specific tests
+---
+"Test terms aggregation on derived_object_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          ip_terms:
+            terms:
+              field: derived_object.ip
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.ip_terms.buckets: 5 }
+- match: { aggregations.ip_terms.buckets.0.key: "10.0.0.1" }
+- match: { aggregations.ip_terms.buckets.0.doc_count: 1 }
+
+---
+"Test range aggregation on derived_object_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          ip_ranges:
+            ip_range:
+              field: derived_object.ip
+              ranges:
+              - to: "10.0.0.0"
+              - from: "10.0.0.0"
+                to: "172.16.0.0"
+              - from: "172.16.0.0"
+
+- match: { hits.total.value: 5 }
+- length: { aggregations.ip_ranges.buckets: 3 }
+- match: { aggregations.ip_ranges.buckets.0.doc_count: 0 }
+- match: { aggregations.ip_ranges.buckets.1.doc_count: 2 }
+- match: { aggregations.ip_ranges.buckets.2.doc_count: 3 }
+
+---
+"Test cardinality aggregation on derived_object_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          unique_ips:
+            cardinality:
+              field: derived_object.ip
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.unique_ips.value: 5 }
+
+---
+"Test missing aggregation on derived_object_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          missing_ips:
+            missing:
+              field: derived_object.ip
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.missing_ips.doc_count: 0 }
+
+---
+"Test value count aggregation on derived_object_ip":
+- do:
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          ip_count:
+            value_count:
+              field: derived_object.ip
+
+- match: { hits.total.value: 5 }
+- match: { aggregations.ip_count.value: 5 }
+
+### TEST UNSUPPORTED AGG TYPES
+---
+"Test sig terms not supported":
+- do:
+    catch: /illegal_argument_exception/
+    search:
+      rest_total_hits_as_int: true
+      index: test
+      body:
+        query:
+          terms:
+            derived_keyword: ["foo"]
+        aggs:
+          significant_os:
+            significant_terms:
+              field: "derived_os"
+              min_doc_count: 1
+              size: 10
+
+---
+"Test significant text":
+- do:
+    catch: /illegal_argument_exception/
+    search:
+      rest_total_hits_as_int: true
+      index: test
+      body:
+        query:
+          terms:
+            derived_keyword: ["foo"]
+        aggs:
+          significant_words:
+            significant_text:
+              field: "derived_text"
+              size: 10
+              min_doc_count: 1
+
+---
+"Test scripted_metric aggregation":
+- do:
+    catch: /A document doesn't have a value for a field/
+    search:
+      index: test
+      body:
+        size: 0
+        aggs:
+          scripted_metric_agg:
+            scripted_metric:
+              init_script: "state.arr = []"
+              map_script: "state.arr.add(doc.derived_long.value)"
+              combine_script: "return 0"
+              reduce_script: "return 0"
+
+---
+"Test geo_distance aggregation on derived_geo":
+- do:
+    catch: /aggregation_execution_exception/
+    search:
+      index: test
+      rest_total_hits_as_int: true
+      body:
+        size: 0
+        aggs:
+          distance:
+            geo_distance:
+              field: derived_geo
+              origin: "35.7796, -78.6382"
+              ranges:
+                - to: 1000000
+                - from: 1000000
+                  to: 5000000
+                - from: 5000000
diff --git a/modules/mapper-extras/src/main/java/org/opensearch/index/mapper/ScaledFloatFieldMapper.java b/modules/mapper-extras/src/main/java/org/opensearch/index/mapper/ScaledFloatFieldMapper.java
index 400d867296e5f..b46b58f415cfd 100644
--- a/modules/mapper-extras/src/main/java/org/opensearch/index/mapper/ScaledFloatFieldMapper.java
+++ b/modules/mapper-extras/src/main/java/org/opensearch/index/mapper/ScaledFloatFieldMapper.java
@@ -35,6 +35,7 @@
 import com.fasterxml.jackson.core.JsonParseException;
 
 import org.apache.lucene.document.Field;
+import org.apache.lucene.document.LongPoint;
 import org.apache.lucene.index.DocValues;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.NumericDocValues;
@@ -48,6 +49,7 @@
 import org.opensearch.common.xcontent.support.XContentMapValues;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.core.xcontent.XContentParser.Token;
+import org.opensearch.index.compositeindex.datacube.DimensionType;
 import org.opensearch.index.fielddata.FieldData;
 import org.opensearch.index.fielddata.IndexFieldData;
 import org.opensearch.index.fielddata.IndexNumericFieldData;
@@ -70,10 +72,12 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Supplier;
 
 /** A {@link FieldMapper} for scaled floats. Values are internally multiplied
- *  by a scaling factor and rounded to the closest long. */
+ * by a scaling factor and rounded to the closest long.
+ */
 public class ScaledFloatFieldMapper extends ParametrizedFieldMapper {
 
     public static final String CONTENT_TYPE = "scaled_float";
@@ -161,11 +165,21 @@ public ScaledFloatFieldMapper build(BuilderContext context) {
             );
             return new ScaledFloatFieldMapper(name, type, multiFieldsBuilder.build(this, context), copyTo.build(), this);
         }
+
+        @Override
+        public Optional<DimensionType> getSupportedDataCubeDimensionType() {
+            return Optional.of(DimensionType.NUMERIC);
+        }
+
+        @Override
+        public boolean isDataCubeMetricSupported() {
+            return true;
+        }
     }
 
     public static final TypeParser PARSER = new TypeParser((n, c) -> new Builder(n, c.getSettings()));
 
-    public static final class ScaledFloatFieldType extends SimpleMappedFieldType {
+    public static final class ScaledFloatFieldType extends SimpleMappedFieldType implements NumericPointEncoder, FieldValueConverter {
 
         private final double scalingFactor;
         private final Double nullValue;
@@ -188,6 +202,21 @@ public ScaledFloatFieldType(String name, double scalingFactor) {
             this(name, true, false, true, Collections.emptyMap(), scalingFactor, null);
         }
 
+        @Override
+        public byte[] encodePoint(Number value) {
+            assert value instanceof Double;
+            double doubleValue = (Double) value;
+            byte[] point = new byte[Long.BYTES];
+            if (doubleValue == Double.POSITIVE_INFINITY) {
+                LongPoint.encodeDimension(Long.MAX_VALUE, point, 0);
+            } else if (doubleValue == Double.NEGATIVE_INFINITY) {
+                LongPoint.encodeDimension(Long.MIN_VALUE, point, 0);
+            } else {
+                LongPoint.encodeDimension(Math.round(scale(value)), point, 0);
+            }
+            return point;
+        }
+
         public double getScalingFactor() {
             return scalingFactor;
         }
@@ -324,6 +353,12 @@ public DocValueFormat docValueFormat(String format, ZoneId timeZone) {
         private double scale(Object input) {
             return new BigDecimal(Double.toString(parse(input))).multiply(BigDecimal.valueOf(scalingFactor)).doubleValue();
         }
+
+        @Override
+        public double toDoubleValue(long value) {
+            double inverseScalingFactor = 1d / scalingFactor;
+            return value * inverseScalingFactor;
+        }
     }
 
     private final Explicit<Boolean> ignoreMalformed;
diff --git a/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/ScaledFloatFieldMapperTests.java b/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/ScaledFloatFieldMapperTests.java
index 7cb951ae73844..0c92523974f23 100644
--- a/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/ScaledFloatFieldMapperTests.java
+++ b/modules/mapper-extras/src/test/java/org/opensearch/index/mapper/ScaledFloatFieldMapperTests.java
@@ -34,11 +34,16 @@
 
 import org.apache.lucene.index.DocValuesType;
 import org.apache.lucene.index.IndexableField;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
 import org.opensearch.plugins.Plugin;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
 
 import java.io.IOException;
 import java.util.Arrays;
@@ -46,6 +51,7 @@
 import java.util.List;
 
 import static java.util.Collections.singletonList;
+import static org.opensearch.common.util.FeatureFlags.STAR_TREE_INDEX;
 import static org.hamcrest.Matchers.containsString;
 
 public class ScaledFloatFieldMapperTests extends MapperTestCase {
@@ -91,24 +97,112 @@ public void testExistsQueryDocValuesDisabled() throws IOException {
         assertParseMinimalWarnings();
     }
 
-    public void testDefaults() throws Exception {
-        XContentBuilder mapping = fieldMapping(b -> b.field("type", "scaled_float").field("scaling_factor", 10.0));
+    @BeforeClass
+    public static void createMapper() {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(STAR_TREE_INDEX, "true").build());
+    }
+
+    @AfterClass
+    public static void clearMapper() {
+        FeatureFlags.initializeFeatureFlags(Settings.EMPTY);
+    }
+
+    public void testScaledFloatWithStarTree() throws Exception {
+
+        double scalingFactorField1 = randomDouble() * 100;
+        double scalingFactorField2 = randomDouble() * 100;
+        double scalingFactorField3 = randomDouble() * 100;
+
+        XContentBuilder mapping = getStarTreeMappingWithScaledFloat(scalingFactorField1, scalingFactorField2, scalingFactorField3);
         DocumentMapper mapper = createDocumentMapper(mapping);
-        assertEquals(mapping.toString(), mapper.mappingSource().toString());
+        assertTrue(mapping.toString().contains("startree"));
 
-        ParsedDocument doc = mapper.parse(source(b -> b.field("field", 123)));
-        IndexableField[] fields = doc.rootDoc().getFields("field");
+        long randomLongField1 = randomLong();
+        long randomLongField2 = randomLong();
+        long randomLongField3 = randomLong();
+        ParsedDocument doc = mapper.parse(
+            source(b -> b.field("field1", randomLongField1).field("field2", randomLongField2).field("field3", randomLongField3))
+        );
+        validateScaledFloatFields(doc, "field1", randomLongField1, scalingFactorField1);
+        validateScaledFloatFields(doc, "field2", randomLongField2, scalingFactorField2);
+        validateScaledFloatFields(doc, "field3", randomLongField3, scalingFactorField3);
+    }
+
+    @Override
+    protected Settings getIndexSettings() {
+        return Settings.builder()
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .put(super.getIndexSettings())
+            .build();
+    }
+
+    private static void validateScaledFloatFields(ParsedDocument doc, String field, long value, double scalingFactor) {
+        IndexableField[] fields = doc.rootDoc().getFields(field);
         assertEquals(2, fields.length);
         IndexableField pointField = fields[0];
         assertEquals(1, pointField.fieldType().pointDimensionCount());
         assertFalse(pointField.fieldType().stored());
-        assertEquals(1230, pointField.numericValue().longValue());
+        assertEquals((long) (value * scalingFactor), pointField.numericValue().longValue());
         IndexableField dvField = fields[1];
         assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());
-        assertEquals(1230, dvField.numericValue().longValue());
+        assertEquals((long) (value * scalingFactor), dvField.numericValue().longValue());
         assertFalse(dvField.fieldType().stored());
     }
 
+    private XContentBuilder getStarTreeMappingWithScaledFloat(
+        double scalingFactorField1,
+        double scalingFactorField2,
+        double scalingFactorField3
+    ) throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+            b.field("max_leaf_docs", 100);
+            b.startArray("ordered_dimensions");
+            b.startObject();
+            b.field("name", "field1");
+            b.endObject();
+            b.startObject();
+            b.field("name", "field2");
+            b.endObject();
+            b.endArray();
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", "field3");
+            b.startArray("stats");
+            b.value("sum");
+            b.value("value_count");
+            b.endArray();
+            b.endObject();
+            b.endArray();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("field1");
+            b.field("type", "scaled_float").field("scaling_factor", scalingFactorField1);
+            b.endObject();
+            b.startObject("field2");
+            b.field("type", "scaled_float").field("scaling_factor", scalingFactorField2);
+            b.endObject();
+            b.startObject("field3");
+            b.field("type", "scaled_float").field("scaling_factor", scalingFactorField3);
+            b.endObject();
+            b.endObject();
+        });
+    }
+
+    public void testDefaults() throws Exception {
+        XContentBuilder mapping = fieldMapping(b -> b.field("type", "scaled_float").field("scaling_factor", 10.0));
+        DocumentMapper mapper = createDocumentMapper(mapping);
+        assertEquals(mapping.toString(), mapper.mappingSource().toString());
+
+        ParsedDocument doc = mapper.parse(source(b -> b.field("field", 123)));
+        validateScaledFloatFields(doc, "field", 123, 10.0);
+    }
+
     public void testMissingScalingFactor() {
         Exception e = expectThrows(
             MapperParsingException.class,
diff --git a/modules/opensearch-dashboards/src/main/java/org/opensearch/dashboards/OpenSearchDashboardsPlugin.java b/modules/opensearch-dashboards/src/main/java/org/opensearch/dashboards/OpenSearchDashboardsPlugin.java
index 534218ef438e7..5eab33f206ff4 100644
--- a/modules/opensearch-dashboards/src/main/java/org/opensearch/dashboards/OpenSearchDashboardsPlugin.java
+++ b/modules/opensearch-dashboards/src/main/java/org/opensearch/dashboards/OpenSearchDashboardsPlugin.java
@@ -54,6 +54,7 @@
 import org.opensearch.rest.action.admin.indices.RestRefreshAction;
 import org.opensearch.rest.action.admin.indices.RestUpdateSettingsAction;
 import org.opensearch.rest.action.document.RestBulkAction;
+import org.opensearch.rest.action.document.RestBulkStreamingAction;
 import org.opensearch.rest.action.document.RestDeleteAction;
 import org.opensearch.rest.action.document.RestGetAction;
 import org.opensearch.rest.action.document.RestIndexAction;
@@ -127,6 +128,7 @@ public List<RestHandler> getRestHandlers(
                 new OpenSearchDashboardsWrappedRestHandler(new RestMultiGetAction(settings)),
                 new OpenSearchDashboardsWrappedRestHandler(new RestSearchAction()),
                 new OpenSearchDashboardsWrappedRestHandler(new RestBulkAction(settings)),
+                new OpenSearchDashboardsWrappedRestHandler(new RestBulkStreamingAction(settings)),
                 new OpenSearchDashboardsWrappedRestHandler(new RestDeleteAction()),
                 new OpenSearchDashboardsWrappedRestHandler(new RestDeleteByQueryAction()),
 
diff --git a/modules/percolator/src/yamlRestTest/resources/rest-api-spec/test/10_basic.yml b/modules/percolator/src/yamlRestTest/resources/rest-api-spec/test/10_basic.yml
index 35ebb2b099139..61f79326dab06 100644
--- a/modules/percolator/src/yamlRestTest/resources/rest-api-spec/test/10_basic.yml
+++ b/modules/percolator/src/yamlRestTest/resources/rest-api-spec/test/10_basic.yml
@@ -83,3 +83,48 @@
                 index: documents_index
                 id: some_id
   - match:  { responses.0.hits.total:     1  }
+
+  - do:
+      catch: bad_request
+      index:
+        index: queries_index
+        body:
+          query:
+            query_string:
+              query: "unmapped: *"
+
+  - do:
+      catch: bad_request
+      index:
+        index: queries_index
+        body:
+          query:
+            query_string:
+              query: "_exists_: unmappedField"
+
+  - do:
+        catch: bad_request
+        index:
+          index: queries_index
+          body:
+            query:
+              query_string:
+                query: "unmappedField: <100"
+
+  - do:
+      catch: bad_request
+      index:
+        index: queries_index
+        body:
+          query:
+            query_string:
+              query: "unmappedField: test~"
+
+  - do:
+      catch: bad_request
+      index:
+        index: queries_index
+        body:
+          query:
+            query_string:
+              query: "unmappedField: test*"
diff --git a/modules/repository-url/src/internalClusterTest/java/org/opensearch/repositories/url/URLSnapshotRestoreIT.java b/modules/repository-url/src/internalClusterTest/java/org/opensearch/repositories/url/URLSnapshotRestoreIT.java
index e073db7276119..1b85a1e227252 100644
--- a/modules/repository-url/src/internalClusterTest/java/org/opensearch/repositories/url/URLSnapshotRestoreIT.java
+++ b/modules/repository-url/src/internalClusterTest/java/org/opensearch/repositories/url/URLSnapshotRestoreIT.java
@@ -67,19 +67,11 @@ public void testUrlRepository() throws Exception {
 
         logger.info("-->  creating repository");
         Path repositoryLocation = randomRepoPath();
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType(FsRepository.TYPE)
-                .setSettings(
-                    Settings.builder()
-                        .put(FsRepository.LOCATION_SETTING.getKey(), repositoryLocation)
-                        .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
-                        .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
-                )
-        );
-
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), repositoryLocation)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES);
+        createRepository("test-repo", FsRepository.TYPE, settings);
         createIndex("test-idx");
         ensureGreen();
 
@@ -115,17 +107,10 @@ public void testUrlRepository() throws Exception {
         cluster().wipeIndices("test-idx");
 
         logger.info("--> create read-only URL repository");
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository("url-repo")
-                .setType(URLRepository.TYPE)
-                .setSettings(
-                    Settings.builder()
-                        .put(URLRepository.URL_SETTING.getKey(), repositoryLocation.toUri().toURL().toString())
-                        .put("list_directories", randomBoolean())
-                )
-        );
+        Settings.Builder settingsBuilder = Settings.builder()
+            .put(URLRepository.URL_SETTING.getKey(), repositoryLocation.toUri().toURL().toString())
+            .put("list_directories", randomBoolean());
+        createRepository("url-repo", URLRepository.TYPE, settingsBuilder);
         logger.info("--> restore index after deletion");
         RestoreSnapshotResponse restoreSnapshotResponse = client.admin()
             .cluster()
diff --git a/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePlugin.java b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePlugin.java
index 5378a6721efb2..488b9e632aa2a 100644
--- a/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePlugin.java
+++ b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePlugin.java
@@ -8,24 +8,61 @@
 
 package org.opensearch.search.pipeline.common;
 
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.plugins.SearchPipelinePlugin;
 import org.opensearch.search.pipeline.Processor;
+import org.opensearch.search.pipeline.SearchPhaseResultsProcessor;
 import org.opensearch.search.pipeline.SearchRequestProcessor;
 import org.opensearch.search.pipeline.SearchResponseProcessor;
 
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 /**
  * Plugin providing common search request/response processors for use in search pipelines.
  */
 public class SearchPipelineCommonModulePlugin extends Plugin implements SearchPipelinePlugin {
 
+    static final Setting<List<String>> REQUEST_PROCESSORS_ALLOWLIST_SETTING = Setting.listSetting(
+        "search.pipeline.common.request.processors.allowed",
+        List.of(),
+        Function.identity(),
+        Setting.Property.NodeScope
+    );
+
+    static final Setting<List<String>> RESPONSE_PROCESSORS_ALLOWLIST_SETTING = Setting.listSetting(
+        "search.pipeline.common.response.processors.allowed",
+        List.of(),
+        Function.identity(),
+        Setting.Property.NodeScope
+    );
+
+    static final Setting<List<String>> SEARCH_PHASE_RESULTS_PROCESSORS_ALLOWLIST_SETTING = Setting.listSetting(
+        "search.pipeline.common.search.phase.results.processors.allowed",
+        List.of(),
+        Function.identity(),
+        Setting.Property.NodeScope
+    );
+
     /**
      * No constructor needed, but build complains if we don't have a constructor with JavaDoc.
      */
     public SearchPipelineCommonModulePlugin() {}
 
+    @Override
+    public List<Setting<?>> getSettings() {
+        return List.of(
+            REQUEST_PROCESSORS_ALLOWLIST_SETTING,
+            RESPONSE_PROCESSORS_ALLOWLIST_SETTING,
+            SEARCH_PHASE_RESULTS_PROCESSORS_ALLOWLIST_SETTING
+        );
+    }
+
     /**
      * Returns a map of processor factories.
      *
@@ -34,25 +71,66 @@ public SearchPipelineCommonModulePlugin() {}
      */
     @Override
     public Map<String, Processor.Factory<SearchRequestProcessor>> getRequestProcessors(Parameters parameters) {
-        return Map.of(
-            FilterQueryRequestProcessor.TYPE,
-            new FilterQueryRequestProcessor.Factory(parameters.namedXContentRegistry),
-            ScriptRequestProcessor.TYPE,
-            new ScriptRequestProcessor.Factory(parameters.scriptService),
-            OversampleRequestProcessor.TYPE,
-            new OversampleRequestProcessor.Factory()
+        return filterForAllowlistSetting(
+            REQUEST_PROCESSORS_ALLOWLIST_SETTING,
+            parameters.env.settings(),
+            Map.of(
+                FilterQueryRequestProcessor.TYPE,
+                new FilterQueryRequestProcessor.Factory(parameters.namedXContentRegistry),
+                ScriptRequestProcessor.TYPE,
+                new ScriptRequestProcessor.Factory(parameters.scriptService),
+                OversampleRequestProcessor.TYPE,
+                new OversampleRequestProcessor.Factory()
+            )
         );
     }
 
     @Override
     public Map<String, Processor.Factory<SearchResponseProcessor>> getResponseProcessors(Parameters parameters) {
-        return Map.of(
-            RenameFieldResponseProcessor.TYPE,
-            new RenameFieldResponseProcessor.Factory(),
-            TruncateHitsResponseProcessor.TYPE,
-            new TruncateHitsResponseProcessor.Factory(),
-            CollapseResponseProcessor.TYPE,
-            new CollapseResponseProcessor.Factory()
+        return filterForAllowlistSetting(
+            RESPONSE_PROCESSORS_ALLOWLIST_SETTING,
+            parameters.env.settings(),
+            Map.of(
+                RenameFieldResponseProcessor.TYPE,
+                new RenameFieldResponseProcessor.Factory(),
+                TruncateHitsResponseProcessor.TYPE,
+                new TruncateHitsResponseProcessor.Factory(),
+                CollapseResponseProcessor.TYPE,
+                new CollapseResponseProcessor.Factory(),
+                SplitResponseProcessor.TYPE,
+                new SplitResponseProcessor.Factory(),
+                SortResponseProcessor.TYPE,
+                new SortResponseProcessor.Factory()
+            )
         );
     }
+
+    @Override
+    public Map<String, Processor.Factory<SearchPhaseResultsProcessor>> getSearchPhaseResultsProcessors(Parameters parameters) {
+        return filterForAllowlistSetting(SEARCH_PHASE_RESULTS_PROCESSORS_ALLOWLIST_SETTING, parameters.env.settings(), Map.of());
+    }
+
+    private <T extends Processor> Map<String, Processor.Factory<T>> filterForAllowlistSetting(
+        Setting<List<String>> allowlistSetting,
+        Settings settings,
+        Map<String, Processor.Factory<T>> map
+    ) {
+        if (allowlistSetting.exists(settings) == false) {
+            return Map.copyOf(map);
+        }
+        final Set<String> allowlist = Set.copyOf(allowlistSetting.get(settings));
+        // Assert that no unknown processors are defined in the allowlist
+        final Set<String> unknownAllowlistProcessors = allowlist.stream()
+            .filter(p -> map.containsKey(p) == false)
+            .collect(Collectors.toUnmodifiableSet());
+        if (unknownAllowlistProcessors.isEmpty() == false) {
+            throw new IllegalArgumentException(
+                "Processor(s) " + unknownAllowlistProcessors + " were defined in [" + allowlistSetting.getKey() + "] but do not exist"
+            );
+        }
+        return map.entrySet()
+            .stream()
+            .filter(e -> allowlist.contains(e.getKey()))
+            .collect(Collectors.toUnmodifiableMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
 }
diff --git a/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SortResponseProcessor.java b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SortResponseProcessor.java
new file mode 100644
index 0000000000000..e0bfd38b26376
--- /dev/null
+++ b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SortResponseProcessor.java
@@ -0,0 +1,209 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.document.DocumentField;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.xcontent.MediaType;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.ingest.ConfigurationUtils;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.pipeline.AbstractProcessor;
+import org.opensearch.search.pipeline.Processor;
+import org.opensearch.search.pipeline.SearchResponseProcessor;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Processor that sorts an array of items.
+ * Throws exception is the specified field is not an array.
+ */
+public class SortResponseProcessor extends AbstractProcessor implements SearchResponseProcessor {
+    /** Key to reference this processor type from a search pipeline. */
+    public static final String TYPE = "sort";
+    /** Key defining the array field to be sorted. */
+    public static final String SORT_FIELD = "field";
+    /** Optional key defining the sort order. */
+    public static final String SORT_ORDER = "order";
+    /** Optional key to put the sorted values in a different field. */
+    public static final String TARGET_FIELD = "target_field";
+    /** Default sort order if not specified */
+    public static final String DEFAULT_ORDER = "asc";
+
+    /** Enum defining how elements will be sorted */
+    public enum SortOrder {
+        /** Sort in ascending (natural) order */
+        ASCENDING("asc"),
+        /** Sort in descending (reverse) order */
+        DESCENDING("desc");
+
+        private final String direction;
+
+        SortOrder(String direction) {
+            this.direction = direction;
+        }
+
+        @Override
+        public String toString() {
+            return this.direction;
+        }
+
+        /**
+         * Converts the string representation of the enum value to the enum.
+         * @param value A string ("asc" or "desc")
+         * @return the corresponding enum value
+         */
+        public static SortOrder fromString(String value) {
+            if (value == null) {
+                throw new IllegalArgumentException("Sort direction cannot be null");
+            }
+
+            if (value.equals(ASCENDING.toString())) {
+                return ASCENDING;
+            } else if (value.equals(DESCENDING.toString())) {
+                return DESCENDING;
+            }
+            throw new IllegalArgumentException("Sort direction [" + value + "] not recognized." + " Valid values are: [asc, desc]");
+        }
+    }
+
+    private final String sortField;
+    private final SortOrder sortOrder;
+    private final String targetField;
+
+    SortResponseProcessor(
+        String tag,
+        String description,
+        boolean ignoreFailure,
+        String sortField,
+        SortOrder sortOrder,
+        String targetField
+    ) {
+        super(tag, description, ignoreFailure);
+        this.sortField = Objects.requireNonNull(sortField);
+        this.sortOrder = Objects.requireNonNull(sortOrder);
+        this.targetField = targetField == null ? sortField : targetField;
+    }
+
+    /**
+     * Getter function for sortField
+     * @return sortField
+     */
+    public String getSortField() {
+        return sortField;
+    }
+
+    /**
+     * Getter function for targetField
+     * @return targetField
+     */
+    public String getTargetField() {
+        return targetField;
+    }
+
+    /**
+     * Getter function for sortOrder
+     * @return sortOrder
+     */
+    public SortOrder getSortOrder() {
+        return sortOrder;
+    }
+
+    @Override
+    public String getType() {
+        return TYPE;
+    }
+
+    @Override
+    public SearchResponse processResponse(SearchRequest request, SearchResponse response) throws Exception {
+        SearchHit[] hits = response.getHits().getHits();
+        for (SearchHit hit : hits) {
+            Map<String, DocumentField> fields = hit.getFields();
+            if (fields.containsKey(sortField)) {
+                DocumentField docField = hit.getFields().get(sortField);
+                if (docField == null) {
+                    throw new IllegalArgumentException("field [" + sortField + "] is null, cannot sort.");
+                }
+                hit.setDocumentField(targetField, new DocumentField(targetField, getSortedValues(docField.getValues())));
+            }
+            if (hit.hasSource()) {
+                BytesReference sourceRef = hit.getSourceRef();
+                Tuple<? extends MediaType, Map<String, Object>> typeAndSourceMap = XContentHelper.convertToMap(
+                    sourceRef,
+                    false,
+                    (MediaType) null
+                );
+
+                Map<String, Object> sourceAsMap = typeAndSourceMap.v2();
+                if (sourceAsMap.containsKey(sortField)) {
+                    Object val = sourceAsMap.get(sortField);
+                    if (val instanceof List) {
+                        @SuppressWarnings("unchecked")
+                        List<Object> listVal = (List<Object>) val;
+                        sourceAsMap.put(targetField, getSortedValues(listVal));
+                    }
+                    XContentBuilder builder = XContentBuilder.builder(typeAndSourceMap.v1().xContent());
+                    builder.map(sourceAsMap);
+                    hit.sourceRef(BytesReference.bytes(builder));
+                }
+            }
+        }
+        return response;
+    }
+
+    private List<Object> getSortedValues(List<Object> values) {
+        return values.stream()
+            .map(this::downcastToComparable)
+            .sorted(sortOrder.equals(SortOrder.ASCENDING) ? Comparator.naturalOrder() : Comparator.reverseOrder())
+            .collect(Collectors.toList());
+    }
+
+    @SuppressWarnings("unchecked")
+    private Comparable<Object> downcastToComparable(Object obj) {
+        if (obj instanceof Comparable) {
+            return (Comparable<Object>) obj;
+        } else if (obj == null) {
+            throw new IllegalArgumentException("field [" + sortField + "] contains a null value.]");
+        } else {
+            throw new IllegalArgumentException("field [" + sortField + "] of type [" + obj.getClass().getName() + "] is not comparable.]");
+        }
+    }
+
+    static class Factory implements Processor.Factory<SearchResponseProcessor> {
+
+        @Override
+        public SortResponseProcessor create(
+            Map<String, Processor.Factory<SearchResponseProcessor>> processorFactories,
+            String tag,
+            String description,
+            boolean ignoreFailure,
+            Map<String, Object> config,
+            PipelineContext pipelineContext
+        ) {
+            String sortField = ConfigurationUtils.readStringProperty(TYPE, tag, config, SORT_FIELD);
+            String targetField = ConfigurationUtils.readStringProperty(TYPE, tag, config, TARGET_FIELD, sortField);
+            try {
+                SortOrder sortOrder = SortOrder.fromString(
+                    ConfigurationUtils.readStringProperty(TYPE, tag, config, SORT_ORDER, DEFAULT_ORDER)
+                );
+                return new SortResponseProcessor(tag, description, ignoreFailure, sortField, sortOrder, targetField);
+            } catch (IllegalArgumentException e) {
+                throw ConfigurationUtils.newConfigurationException(TYPE, tag, SORT_ORDER, e.getMessage());
+            }
+        }
+    }
+}
diff --git a/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SplitResponseProcessor.java b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SplitResponseProcessor.java
new file mode 100644
index 0000000000000..bb3db4d9bc2c1
--- /dev/null
+++ b/modules/search-pipeline-common/src/main/java/org/opensearch/search/pipeline/common/SplitResponseProcessor.java
@@ -0,0 +1,162 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.document.DocumentField;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.xcontent.MediaType;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.ingest.ConfigurationUtils;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.pipeline.AbstractProcessor;
+import org.opensearch.search.pipeline.Processor;
+import org.opensearch.search.pipeline.SearchResponseProcessor;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Processor that sorts an array of items.
+ * Throws exception is the specified field is not an array.
+ */
+public class SplitResponseProcessor extends AbstractProcessor implements SearchResponseProcessor {
+    /** Key to reference this processor type from a search pipeline. */
+    public static final String TYPE = "split";
+    /** Key defining the string field to be split. */
+    public static final String SPLIT_FIELD = "field";
+    /** Key defining the delimiter used to split the string. This can be a regular expression pattern. */
+    public static final String SEPARATOR = "separator";
+    /** Optional key for handling empty trailing fields. */
+    public static final String PRESERVE_TRAILING = "preserve_trailing";
+    /** Optional key to put the split values in a different field. */
+    public static final String TARGET_FIELD = "target_field";
+
+    private final String splitField;
+    private final String separator;
+    private final boolean preserveTrailing;
+    private final String targetField;
+
+    SplitResponseProcessor(
+        String tag,
+        String description,
+        boolean ignoreFailure,
+        String splitField,
+        String separator,
+        boolean preserveTrailing,
+        String targetField
+    ) {
+        super(tag, description, ignoreFailure);
+        this.splitField = Objects.requireNonNull(splitField);
+        this.separator = Objects.requireNonNull(separator);
+        this.preserveTrailing = preserveTrailing;
+        this.targetField = targetField == null ? splitField : targetField;
+    }
+
+    /**
+     * Getter function for splitField
+     * @return sortField
+     */
+    public String getSplitField() {
+        return splitField;
+    }
+
+    /**
+     * Getter function for separator
+     * @return separator
+     */
+    public String getSeparator() {
+        return separator;
+    }
+
+    /**
+     * Getter function for preserveTrailing
+     * @return preserveTrailing;
+     */
+    public boolean isPreserveTrailing() {
+        return preserveTrailing;
+    }
+
+    /**
+     * Getter function for targetField
+     * @return targetField
+     */
+    public String getTargetField() {
+        return targetField;
+    }
+
+    @Override
+    public String getType() {
+        return TYPE;
+    }
+
+    @Override
+    public SearchResponse processResponse(SearchRequest request, SearchResponse response) throws Exception {
+        SearchHit[] hits = response.getHits().getHits();
+        for (SearchHit hit : hits) {
+            Map<String, DocumentField> fields = hit.getFields();
+            if (fields.containsKey(splitField)) {
+                DocumentField docField = hit.getFields().get(splitField);
+                if (docField == null) {
+                    throw new IllegalArgumentException("field [" + splitField + "] is null, cannot split.");
+                }
+                Object val = docField.getValue();
+                if (!(val instanceof String)) {
+                    throw new IllegalArgumentException("field [" + splitField + "] is not a string, cannot split");
+                }
+                Object[] strings = ((String) val).split(separator, preserveTrailing ? -1 : 0);
+                hit.setDocumentField(targetField, new DocumentField(targetField, Arrays.asList(strings)));
+            }
+            if (hit.hasSource()) {
+                BytesReference sourceRef = hit.getSourceRef();
+                Tuple<? extends MediaType, Map<String, Object>> typeAndSourceMap = XContentHelper.convertToMap(
+                    sourceRef,
+                    false,
+                    (MediaType) null
+                );
+
+                Map<String, Object> sourceAsMap = typeAndSourceMap.v2();
+                if (sourceAsMap.containsKey(splitField)) {
+                    Object val = sourceAsMap.get(splitField);
+                    if (val instanceof String) {
+                        Object[] strings = ((String) val).split(separator, preserveTrailing ? -1 : 0);
+                        sourceAsMap.put(targetField, Arrays.asList(strings));
+                    }
+                    XContentBuilder builder = XContentBuilder.builder(typeAndSourceMap.v1().xContent());
+                    builder.map(sourceAsMap);
+                    hit.sourceRef(BytesReference.bytes(builder));
+                }
+            }
+        }
+        return response;
+    }
+
+    static class Factory implements Processor.Factory<SearchResponseProcessor> {
+
+        @Override
+        public SplitResponseProcessor create(
+            Map<String, Processor.Factory<SearchResponseProcessor>> processorFactories,
+            String tag,
+            String description,
+            boolean ignoreFailure,
+            Map<String, Object> config,
+            PipelineContext pipelineContext
+        ) {
+            String splitField = ConfigurationUtils.readStringProperty(TYPE, tag, config, SPLIT_FIELD);
+            String separator = ConfigurationUtils.readStringProperty(TYPE, tag, config, SEPARATOR);
+            boolean preserveTrailing = ConfigurationUtils.readBooleanProperty(TYPE, tag, config, PRESERVE_TRAILING, false);
+            String targetField = ConfigurationUtils.readStringProperty(TYPE, tag, config, TARGET_FIELD, splitField);
+            return new SplitResponseProcessor(tag, description, ignoreFailure, splitField, separator, preserveTrailing, targetField);
+        }
+    }
+}
diff --git a/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePluginTests.java b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePluginTests.java
new file mode 100644
index 0000000000000..e10f06da29ba0
--- /dev/null
+++ b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SearchPipelineCommonModulePluginTests.java
@@ -0,0 +1,107 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.opensearch.common.settings.Settings;
+import org.opensearch.env.TestEnvironment;
+import org.opensearch.plugins.SearchPipelinePlugin;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiFunction;
+
+public class SearchPipelineCommonModulePluginTests extends OpenSearchTestCase {
+
+    public void testRequestProcessorAllowlist() throws IOException {
+        final String key = SearchPipelineCommonModulePlugin.REQUEST_PROCESSORS_ALLOWLIST_SETTING.getKey();
+        runAllowlistTest(key, List.of(), SearchPipelineCommonModulePlugin::getRequestProcessors);
+        runAllowlistTest(key, List.of("filter_query"), SearchPipelineCommonModulePlugin::getRequestProcessors);
+        runAllowlistTest(key, List.of("script"), SearchPipelineCommonModulePlugin::getRequestProcessors);
+        runAllowlistTest(key, List.of("oversample", "script"), SearchPipelineCommonModulePlugin::getRequestProcessors);
+        runAllowlistTest(key, List.of("filter_query", "script", "oversample"), SearchPipelineCommonModulePlugin::getRequestProcessors);
+
+        final IllegalArgumentException e = expectThrows(
+            IllegalArgumentException.class,
+            () -> runAllowlistTest(key, List.of("foo"), SearchPipelineCommonModulePlugin::getRequestProcessors)
+        );
+        assertTrue(e.getMessage(), e.getMessage().contains("foo"));
+    }
+
+    public void testResponseProcessorAllowlist() throws IOException {
+        final String key = SearchPipelineCommonModulePlugin.RESPONSE_PROCESSORS_ALLOWLIST_SETTING.getKey();
+        runAllowlistTest(key, List.of(), SearchPipelineCommonModulePlugin::getResponseProcessors);
+        runAllowlistTest(key, List.of("rename_field"), SearchPipelineCommonModulePlugin::getResponseProcessors);
+        runAllowlistTest(key, List.of("truncate_hits"), SearchPipelineCommonModulePlugin::getResponseProcessors);
+        runAllowlistTest(key, List.of("collapse", "truncate_hits"), SearchPipelineCommonModulePlugin::getResponseProcessors);
+        runAllowlistTest(
+            key,
+            List.of("rename_field", "truncate_hits", "collapse"),
+            SearchPipelineCommonModulePlugin::getResponseProcessors
+        );
+        runAllowlistTest(key, List.of("split", "sort"), SearchPipelineCommonModulePlugin::getResponseProcessors);
+
+        final IllegalArgumentException e = expectThrows(
+            IllegalArgumentException.class,
+            () -> runAllowlistTest(key, List.of("foo"), SearchPipelineCommonModulePlugin::getResponseProcessors)
+        );
+        assertTrue(e.getMessage(), e.getMessage().contains("foo"));
+    }
+
+    public void testSearchPhaseResultsProcessorAllowlist() throws IOException {
+        final String key = SearchPipelineCommonModulePlugin.SEARCH_PHASE_RESULTS_PROCESSORS_ALLOWLIST_SETTING.getKey();
+        runAllowlistTest(key, List.of(), SearchPipelineCommonModulePlugin::getSearchPhaseResultsProcessors);
+
+        final IllegalArgumentException e = expectThrows(
+            IllegalArgumentException.class,
+            () -> runAllowlistTest(key, List.of("foo"), SearchPipelineCommonModulePlugin::getSearchPhaseResultsProcessors)
+        );
+        assertTrue(e.getMessage(), e.getMessage().contains("foo"));
+    }
+
+    private void runAllowlistTest(
+        String settingKey,
+        List<String> allowlist,
+        BiFunction<SearchPipelineCommonModulePlugin, SearchPipelinePlugin.Parameters, Map<String, ?>> function
+    ) throws IOException {
+        final Settings settings = Settings.builder().putList(settingKey, allowlist).build();
+        try (SearchPipelineCommonModulePlugin plugin = new SearchPipelineCommonModulePlugin()) {
+            assertEquals(Set.copyOf(allowlist), function.apply(plugin, createParameters(settings)).keySet());
+        }
+    }
+
+    public void testAllowlistNotSpecified() throws IOException {
+        final Settings settings = Settings.EMPTY;
+        try (SearchPipelineCommonModulePlugin plugin = new SearchPipelineCommonModulePlugin()) {
+            assertEquals(Set.of("oversample", "filter_query", "script"), plugin.getRequestProcessors(createParameters(settings)).keySet());
+            assertEquals(
+                Set.of("rename_field", "truncate_hits", "collapse", "split", "sort"),
+                plugin.getResponseProcessors(createParameters(settings)).keySet()
+            );
+            assertEquals(Set.of(), plugin.getSearchPhaseResultsProcessors(createParameters(settings)).keySet());
+        }
+    }
+
+    private static SearchPipelinePlugin.Parameters createParameters(Settings settings) {
+        return new SearchPipelinePlugin.Parameters(
+            TestEnvironment.newEnvironment(Settings.builder().put(settings).put("path.home", "").build()),
+            null,
+            null,
+            null,
+            () -> 0L,
+            (a, b) -> null,
+            null,
+            null,
+            $ -> {},
+            null
+        );
+    }
+}
diff --git a/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SortResponseProcessorTests.java b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SortResponseProcessorTests.java
new file mode 100644
index 0000000000000..c18c6b34b05d1
--- /dev/null
+++ b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SortResponseProcessorTests.java
@@ -0,0 +1,230 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a.java
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.apache.lucene.search.TotalHits;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.search.SearchResponseSections;
+import org.opensearch.common.document.DocumentField;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.index.query.QueryBuilder;
+import org.opensearch.index.query.TermQueryBuilder;
+import org.opensearch.ingest.RandomDocumentPicks;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.SearchHits;
+import org.opensearch.search.builder.SearchSourceBuilder;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class SortResponseProcessorTests extends OpenSearchTestCase {
+
+    private static final List<Object> PI = List.of(3, 1, 4, 1, 5, 9, 2, 6);
+    private static final List<Object> E = List.of(2, 7, 1, 8, 2, 8, 1, 8);
+    private static final List<Object> X;
+    static {
+        List<Object> x = new ArrayList<>();
+        x.add(1);
+        x.add(null);
+        x.add(3);
+        X = x;
+    }
+
+    private SearchRequest createDummyRequest() {
+        QueryBuilder query = new TermQueryBuilder("field", "value");
+        SearchSourceBuilder source = new SearchSourceBuilder().query(query);
+        return new SearchRequest().source(source);
+    }
+
+    private SearchResponse createTestResponse() {
+        SearchHit[] hits = new SearchHit[2];
+
+        // one response with source
+        Map<String, DocumentField> piMap = new HashMap<>();
+        piMap.put("digits", new DocumentField("digits", PI));
+        hits[0] = new SearchHit(0, "doc 1", piMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"digits\" : " + PI + " }"));
+        hits[0].score((float) Math.PI);
+
+        // one without source
+        Map<String, DocumentField> eMap = new HashMap<>();
+        eMap.put("digits", new DocumentField("digits", E));
+        hits[1] = new SearchHit(1, "doc 2", eMap, Collections.emptyMap());
+        hits[1].score((float) Math.E);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(2, TotalHits.Relation.EQUAL_TO), 2);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNullField() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> map = new HashMap<>();
+        map.put("digits", null);
+        hits[0] = new SearchHit(0, "doc 1", map, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"digits\" : null }"));
+        hits[0].score((float) Math.PI);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNullListEntry() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> xMap = new HashMap<>();
+        xMap.put("digits", new DocumentField("digits", X));
+        hits[0] = new SearchHit(0, "doc 1", xMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"digits\" : " + X + " }"));
+        hits[0].score((float) Math.PI);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNotComparable() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> piMap = new HashMap<>();
+        piMap.put("maps", new DocumentField("maps", List.of(Map.of("foo", "I'm incomparable!"))));
+        hits[0] = new SearchHit(0, "doc 1", piMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"maps\" : [{ \"foo\" : \"I'm incomparable!\"}]] }"));
+        hits[0].score((float) Math.PI);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    public void testSortResponse() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "digits",
+            SortResponseProcessor.SortOrder.ASCENDING,
+            "sorted"
+        );
+        SearchResponse response = createTestResponse();
+        SearchResponse sortResponse = sortResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), sortResponse.getHits());
+
+        assertEquals(PI, sortResponse.getHits().getHits()[0].field("digits").getValues());
+        assertEquals(List.of(1, 1, 2, 3, 4, 5, 6, 9), sortResponse.getHits().getHits()[0].field("sorted").getValues());
+        Map<String, Object> map = sortResponse.getHits().getHits()[0].getSourceAsMap();
+        assertNotNull(map);
+        assertEquals(List.of(1, 1, 2, 3, 4, 5, 6, 9), map.get("sorted"));
+
+        assertEquals(E, sortResponse.getHits().getHits()[1].field("digits").getValues());
+        assertEquals(List.of(1, 1, 2, 2, 7, 8, 8, 8), sortResponse.getHits().getHits()[1].field("sorted").getValues());
+        assertNull(sortResponse.getHits().getHits()[1].getSourceAsMap());
+    }
+
+    public void testSortResponseSameField() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "digits",
+            SortResponseProcessor.SortOrder.DESCENDING,
+            null
+        );
+        SearchResponse response = createTestResponse();
+        SearchResponse sortResponse = sortResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), sortResponse.getHits());
+        assertEquals(List.of(9, 6, 5, 4, 3, 2, 1, 1), sortResponse.getHits().getHits()[0].field("digits").getValues());
+        assertEquals(List.of(8, 8, 8, 7, 2, 2, 1, 1), sortResponse.getHits().getHits()[1].field("digits").getValues());
+    }
+
+    public void testSortResponseNullListEntry() {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "digits",
+            SortResponseProcessor.SortOrder.ASCENDING,
+            null
+        );
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> sortResponseProcessor.processResponse(request, createTestResponseNullListEntry())
+        );
+    }
+
+    public void testNullField() {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "digits",
+            SortResponseProcessor.SortOrder.DESCENDING,
+            null
+        );
+
+        assertThrows(IllegalArgumentException.class, () -> sortResponseProcessor.processResponse(request, createTestResponseNullField()));
+    }
+
+    public void testNotComparableField() {
+        SearchRequest request = createDummyRequest();
+
+        SortResponseProcessor sortResponseProcessor = new SortResponseProcessor(
+            null,
+            null,
+            false,
+            "maps",
+            SortResponseProcessor.SortOrder.ASCENDING,
+            null
+        );
+
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> sortResponseProcessor.processResponse(request, createTestResponseNotComparable())
+        );
+    }
+
+    public void testFactory() {
+        String sortField = RandomDocumentPicks.randomFieldName(random());
+        String targetField = RandomDocumentPicks.randomFieldName(random());
+        Map<String, Object> config = new HashMap<>();
+        config.put("field", sortField);
+        config.put("order", "desc");
+        config.put("target_field", targetField);
+
+        SortResponseProcessor.Factory factory = new SortResponseProcessor.Factory();
+        SortResponseProcessor processor = factory.create(Collections.emptyMap(), null, null, false, config, null);
+        assertEquals("sort", processor.getType());
+        assertEquals(sortField, processor.getSortField());
+        assertEquals(targetField, processor.getTargetField());
+        assertEquals(SortResponseProcessor.SortOrder.DESCENDING, processor.getSortOrder());
+
+        expectThrows(
+            OpenSearchParseException.class,
+            () -> factory.create(Collections.emptyMap(), null, null, false, Collections.emptyMap(), null)
+        );
+    }
+}
diff --git a/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SplitResponseProcessorTests.java b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SplitResponseProcessorTests.java
new file mode 100644
index 0000000000000..fcbc8ccf43cff
--- /dev/null
+++ b/modules/search-pipeline-common/src/test/java/org/opensearch/search/pipeline/common/SplitResponseProcessorTests.java
@@ -0,0 +1,213 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a.java
+ * compatible open source license.
+ */
+
+package org.opensearch.search.pipeline.common;
+
+import org.apache.lucene.search.TotalHits;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.action.search.SearchRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.search.SearchResponseSections;
+import org.opensearch.common.document.DocumentField;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.index.query.QueryBuilder;
+import org.opensearch.index.query.TermQueryBuilder;
+import org.opensearch.ingest.RandomDocumentPicks;
+import org.opensearch.search.SearchHit;
+import org.opensearch.search.SearchHits;
+import org.opensearch.search.builder.SearchSourceBuilder;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class SplitResponseProcessorTests extends OpenSearchTestCase {
+
+    private static final String NO_TRAILING = "one,two,three";
+    private static final String TRAILING = "alpha,beta,gamma,";
+    private static final String REGEX_DELIM = "one1two2three";
+
+    private SearchRequest createDummyRequest() {
+        QueryBuilder query = new TermQueryBuilder("field", "value");
+        SearchSourceBuilder source = new SearchSourceBuilder().query(query);
+        return new SearchRequest().source(source);
+    }
+
+    private SearchResponse createTestResponse() {
+        SearchHit[] hits = new SearchHit[2];
+
+        // one response with source
+        Map<String, DocumentField> csvMap = new HashMap<>();
+        csvMap.put("csv", new DocumentField("csv", List.of(NO_TRAILING)));
+        hits[0] = new SearchHit(0, "doc 1", csvMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"csv\" : \"" + NO_TRAILING + "\" }"));
+        hits[0].score(1f);
+
+        // one without source
+        csvMap = new HashMap<>();
+        csvMap.put("csv", new DocumentField("csv", List.of(TRAILING)));
+        hits[1] = new SearchHit(1, "doc 2", csvMap, Collections.emptyMap());
+        hits[1].score(2f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(2, TotalHits.Relation.EQUAL_TO), 2);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseRegex() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> dsvMap = new HashMap<>();
+        dsvMap.put("dsv", new DocumentField("dsv", List.of(REGEX_DELIM)));
+        hits[0] = new SearchHit(0, "doc 1", dsvMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"dsv\" : \"" + REGEX_DELIM + "\" }"));
+        hits[0].score(1f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNullField() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> map = new HashMap<>();
+        map.put("csv", null);
+        hits[0] = new SearchHit(0, "doc 1", map, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"csv\" : null }"));
+        hits[0].score(1f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseEmptyList() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> map = new HashMap<>();
+        map.put("empty", new DocumentField("empty", List.of()));
+        hits[0] = new SearchHit(0, "doc 1", map, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"empty\" : [] }"));
+        hits[0].score(1f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    private SearchResponse createTestResponseNotString() {
+        SearchHit[] hits = new SearchHit[1];
+
+        Map<String, DocumentField> piMap = new HashMap<>();
+        piMap.put("maps", new DocumentField("maps", List.of(Map.of("foo", "I'm the Map!"))));
+        hits[0] = new SearchHit(0, "doc 1", piMap, Collections.emptyMap());
+        hits[0].sourceRef(new BytesArray("{ \"maps\" : [{ \"foo\" : \"I'm the Map!\"}]] }"));
+        hits[0].score(1f);
+
+        SearchHits searchHits = new SearchHits(hits, new TotalHits(1, TotalHits.Relation.EQUAL_TO), 1);
+        SearchResponseSections searchResponseSections = new SearchResponseSections(searchHits, null, null, false, false, null, 0);
+        return new SearchResponse(searchResponseSections, null, 1, 1, 0, 10, null, null);
+    }
+
+    public void testSplitResponse() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "csv", ",", false, "split");
+        SearchResponse response = createTestResponse();
+        SearchResponse splitResponse = splitResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), splitResponse.getHits());
+
+        assertEquals(NO_TRAILING, splitResponse.getHits().getHits()[0].field("csv").getValue());
+        assertEquals(List.of("one", "two", "three"), splitResponse.getHits().getHits()[0].field("split").getValues());
+        Map<String, Object> map = splitResponse.getHits().getHits()[0].getSourceAsMap();
+        assertNotNull(map);
+        assertEquals(List.of("one", "two", "three"), map.get("split"));
+
+        assertEquals(TRAILING, splitResponse.getHits().getHits()[1].field("csv").getValue());
+        assertEquals(List.of("alpha", "beta", "gamma"), splitResponse.getHits().getHits()[1].field("split").getValues());
+        assertNull(splitResponse.getHits().getHits()[1].getSourceAsMap());
+    }
+
+    public void testSplitResponseRegex() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "dsv", "\\d", false, "split");
+        SearchResponse response = createTestResponseRegex();
+        SearchResponse splitResponse = splitResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), splitResponse.getHits());
+
+        assertEquals(REGEX_DELIM, splitResponse.getHits().getHits()[0].field("dsv").getValue());
+        assertEquals(List.of("one", "two", "three"), splitResponse.getHits().getHits()[0].field("split").getValues());
+        Map<String, Object> map = splitResponse.getHits().getHits()[0].getSourceAsMap();
+        assertNotNull(map);
+        assertEquals(List.of("one", "two", "three"), map.get("split"));
+    }
+
+    public void testSplitResponseSameField() throws Exception {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "csv", ",", true, null);
+        SearchResponse response = createTestResponse();
+        SearchResponse splitResponse = splitResponseProcessor.processResponse(request, response);
+
+        assertEquals(response.getHits(), splitResponse.getHits());
+        assertEquals(List.of("one", "two", "three"), splitResponse.getHits().getHits()[0].field("csv").getValues());
+        assertEquals(List.of("alpha", "beta", "gamma", ""), splitResponse.getHits().getHits()[1].field("csv").getValues());
+    }
+
+    public void testSplitResponseEmptyList() {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "empty", ",", false, null);
+        assertThrows(IllegalArgumentException.class, () -> splitResponseProcessor.processResponse(request, createTestResponseEmptyList()));
+    }
+
+    public void testNullField() {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "csv", ",", false, null);
+
+        assertThrows(IllegalArgumentException.class, () -> splitResponseProcessor.processResponse(request, createTestResponseNullField()));
+    }
+
+    public void testNotStringField() {
+        SearchRequest request = createDummyRequest();
+
+        SplitResponseProcessor splitResponseProcessor = new SplitResponseProcessor(null, null, false, "maps", ",", false, null);
+
+        assertThrows(IllegalArgumentException.class, () -> splitResponseProcessor.processResponse(request, createTestResponseNotString()));
+    }
+
+    public void testFactory() {
+        String splitField = RandomDocumentPicks.randomFieldName(random());
+        String targetField = RandomDocumentPicks.randomFieldName(random());
+        Map<String, Object> config = new HashMap<>();
+        config.put("field", splitField);
+        config.put("separator", ",");
+        config.put("preserve_trailing", true);
+        config.put("target_field", targetField);
+
+        SplitResponseProcessor.Factory factory = new SplitResponseProcessor.Factory();
+        SplitResponseProcessor processor = factory.create(Collections.emptyMap(), null, null, false, config, null);
+        assertEquals("split", processor.getType());
+        assertEquals(splitField, processor.getSplitField());
+        assertEquals(",", processor.getSeparator());
+        assertTrue(processor.isPreserveTrailing());
+        assertEquals(targetField, processor.getTargetField());
+
+        expectThrows(
+            OpenSearchParseException.class,
+            () -> factory.create(Collections.emptyMap(), null, null, false, Collections.emptyMap(), null)
+        );
+    }
+}
diff --git a/modules/search-pipeline-common/src/yamlRestTest/resources/rest-api-spec/test/search_pipeline/80_sort_response.yml b/modules/search-pipeline-common/src/yamlRestTest/resources/rest-api-spec/test/search_pipeline/80_sort_response.yml
new file mode 100644
index 0000000000000..c160b550b2a6e
--- /dev/null
+++ b/modules/search-pipeline-common/src/yamlRestTest/resources/rest-api-spec/test/search_pipeline/80_sort_response.yml
@@ -0,0 +1,152 @@
+---
+teardown:
+  - do:
+      search_pipeline.delete:
+        id: "my_pipeline"
+        ignore: 404
+
+---
+"Test sort processor":
+  - do:
+      search_pipeline.put:
+        id: "my_pipeline"
+        body: >
+          {
+            "description": "test pipeline",
+            "response_processors": [
+              {
+                "sort":
+                  {
+                    "field": "a",
+                    "target_field": "b"
+                  }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      search_pipeline.put:
+        id: "my_pipeline_2"
+        body: >
+          {
+            "description": "test pipeline with ignore failure true",
+            "response_processors": [
+              {
+                "sort":
+                  {
+                    "field": "aa",
+                    "ignore_failure": true
+                  }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      search_pipeline.put:
+        id: "my_pipeline_3"
+        body: >
+          {
+            "description": "test pipeline",
+            "response_processors": [
+              {
+                "sort":
+                  {
+                    "field": "a",
+                    "order": "desc",
+                    "target_field": "b"
+                  }
+              }
+            ]
+          }
+  - match: { acknowledged: true }
+
+  - do:
+      indices.create:
+        index: test
+
+  - do:
+      indices.put_mapping:
+        index: test
+        body:
+          properties:
+            a:
+              type: integer
+              store: true
+              doc_values: true
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          "a": [ 3, 1, 4 ]
+        }
+
+  - do:
+      indices.refresh:
+        index: test
+
+  - do:
+      search:
+        body: { }
+  - match: { hits.total.value: 1 }
+
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline"
+        body: { }
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._source: { "a": [3, 1, 4], "b": [1, 3, 4] } }
+
+  # Should also work with no search body specified
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._source: { "a": [3, 1, 4], "b": [1, 3, 4] } }
+
+  # Pipeline with ignore_failure set to true
+  # Should return while catching error
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline_2"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._source: { "a": [3, 1, 4] } }
+
+  # Pipeline with desc sort order
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline_3"
+        body: { }
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._source: { "a": [3, 1, 4], "b": [4, 3, 1] } }
+
+  # No source, using stored_fields
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline"
+        body: {
+          "_source": false,
+          "stored_fields": [ "a" ]
+        }
+  - match: { hits.hits.0.fields: { "a": [3, 1, 4], "b": [1, 3, 4] } }
+
+  # No source, using docvalue_fields
+  - do:
+      search:
+        index: test
+        search_pipeline: "my_pipeline_3"
+        body: {
+          "_source": false,
+          "docvalue_fields": [ "a" ]
+        }
+  # a is stored sorted because docvalue_fields is pre-sorted to optimize aggregations
+  # this is poorly documented which makes it really hard to write "expected" values on tests
+  - match: { hits.hits.0.fields: { "a": [1, 3, 4], "b": [4, 3, 1] } }
diff --git a/modules/transport-netty4/licenses/netty-buffer-4.1.110.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-buffer-4.1.110.Final.jar.sha1
deleted file mode 100644
index faaf70c858a6e..0000000000000
--- a/modules/transport-netty4/licenses/netty-buffer-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3d918a9ee057d995c362902b54634fc307132aac
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5c26883046fed
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+bdc12df04bb6858890b8aa108060b5b365a26102
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-4.1.110.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-4.1.110.Final.jar.sha1
deleted file mode 100644
index 7affbc14fa93a..0000000000000
--- a/modules/transport-netty4/licenses/netty-codec-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f1fa43b03e93ab88e805b6a4e3e83780c80b47d2
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..1fd224fdd0b44
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+c87f2ec3d9a97bd2b793d16817abb2bab93a7fc3
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-http-4.1.110.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-http-4.1.110.Final.jar.sha1
deleted file mode 100644
index 07730a5606ce2..0000000000000
--- a/modules/transport-netty4/licenses/netty-codec-http-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-9d05cd927209ea25bbf342962c00b8e5a828c2a4
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..22d35128c3ad5
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+81af1040bfa977f98dd0e1bd9639513ea862ca04
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-common-4.1.110.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-common-4.1.110.Final.jar.sha1
deleted file mode 100644
index 568c0aa2a2c03..0000000000000
--- a/modules/transport-netty4/licenses/netty-common-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ec361e7e025c029be50c55c8480080cabcbc01e7
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-common-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-common-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..47af3100f0f2d
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-common-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b2798069092a981a832b7510d0462ee9efb7a80e
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-handler-4.1.110.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-handler-4.1.110.Final.jar.sha1
deleted file mode 100644
index 2d6050dd1e3a5..0000000000000
--- a/modules/transport-netty4/licenses/netty-handler-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-168db749c22652ee7fed1ebf7ec46ce856d75e51
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..8b30272861770
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+3d5e2d5bcc6baeeb8c13a230980c6132a778e036
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-resolver-4.1.110.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-resolver-4.1.110.Final.jar.sha1
deleted file mode 100644
index c3ee8087a8b5d..0000000000000
--- a/modules/transport-netty4/licenses/netty-resolver-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-66c15921104cda0159b34e316541bc765dfaf3c0
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..1a094fa19a623
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+58a631d9d44c4ed7cc0dcc9cffa6641da9374d72
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-transport-4.1.110.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-transport-4.1.110.Final.jar.sha1
deleted file mode 100644
index 32c8fa2b876a2..0000000000000
--- a/modules/transport-netty4/licenses/netty-transport-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b91f04c39ac14d6a29d07184ef305953ee6e0348
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5fbfde0836e0c
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+77cd136dd3843f5e7cbcf68c824975d745c49ddb
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1
deleted file mode 100644
index 2c468962b1b64..0000000000000
--- a/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a7096e7c0a25a983647909d7513f5d4943d589c0
\ No newline at end of file
diff --git a/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1 b/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..8dad0e3104dc8
--- /dev/null
+++ b/modules/transport-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b50ff619cdcdc48e748cba3405c9988529f28f60
\ No newline at end of file
diff --git a/plugins/analysis-icu/licenses/icu4j-70.1.jar.sha1 b/plugins/analysis-icu/licenses/icu4j-70.1.jar.sha1
deleted file mode 100644
index 6fad735235417..0000000000000
--- a/plugins/analysis-icu/licenses/icu4j-70.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-dfa3a1fbc55bf5db8c6e79fc0935ac7ab1202950
\ No newline at end of file
diff --git a/plugins/analysis-icu/licenses/icu4j-75.1.jar.sha1 b/plugins/analysis-icu/licenses/icu4j-75.1.jar.sha1
new file mode 100644
index 0000000000000..4ee1fbe23b117
--- /dev/null
+++ b/plugins/analysis-icu/licenses/icu4j-75.1.jar.sha1
@@ -0,0 +1 @@
+e8f8dcc2967f5ec2cfae185172293adfa5599b78
\ No newline at end of file
diff --git a/plugins/analysis-icu/licenses/lucene-analysis-icu-9.10.0.jar.sha1 b/plugins/analysis-icu/licenses/lucene-analysis-icu-9.10.0.jar.sha1
deleted file mode 100644
index a6f523b96685c..0000000000000
--- a/plugins/analysis-icu/licenses/lucene-analysis-icu-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ed54097d13dbaae6e758c31f55a473ba6566ae8d
\ No newline at end of file
diff --git a/plugins/analysis-icu/licenses/lucene-analysis-icu-9.11.1.jar.sha1 b/plugins/analysis-icu/licenses/lucene-analysis-icu-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..46c87a1611806
--- /dev/null
+++ b/plugins/analysis-icu/licenses/lucene-analysis-icu-9.11.1.jar.sha1
@@ -0,0 +1 @@
+028beadfa152c159d21d880461c06f895052bd33
\ No newline at end of file
diff --git a/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.10.0.jar.sha1 b/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.10.0.jar.sha1
deleted file mode 100644
index 0572d78c75516..0000000000000
--- a/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a158d8a7d386c782a10ec15827ff3f0aa6fd8291
\ No newline at end of file
diff --git a/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.11.1.jar.sha1 b/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..ba490a04c090c
--- /dev/null
+++ b/plugins/analysis-kuromoji/licenses/lucene-analysis-kuromoji-9.11.1.jar.sha1
@@ -0,0 +1 @@
+701c1366189c4410d3cb1f8607df2e50621bfd22
\ No newline at end of file
diff --git a/plugins/analysis-nori/licenses/lucene-analysis-nori-9.10.0.jar.sha1 b/plugins/analysis-nori/licenses/lucene-analysis-nori-9.10.0.jar.sha1
deleted file mode 100644
index b81b33d7b28f7..0000000000000
--- a/plugins/analysis-nori/licenses/lucene-analysis-nori-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-79eb4c5e1c92b613341d05173dfcdce182fa5f80
\ No newline at end of file
diff --git a/plugins/analysis-nori/licenses/lucene-analysis-nori-9.11.1.jar.sha1 b/plugins/analysis-nori/licenses/lucene-analysis-nori-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..4317b04bc4d8e
--- /dev/null
+++ b/plugins/analysis-nori/licenses/lucene-analysis-nori-9.11.1.jar.sha1
@@ -0,0 +1 @@
+46e8f4f3f2f540307fe7d9f500ddc56c1e74d400
\ No newline at end of file
diff --git a/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.10.0.jar.sha1 b/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.10.0.jar.sha1
deleted file mode 100644
index 66245cc1d36d9..0000000000000
--- a/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b6ba8f0ecee48b94911c08ee12c20f059ec38ec5
\ No newline at end of file
diff --git a/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.11.1.jar.sha1 b/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..07a0f261da92f
--- /dev/null
+++ b/plugins/analysis-phonetic/licenses/lucene-analysis-phonetic-9.11.1.jar.sha1
@@ -0,0 +1 @@
+5d8eca81f0d1e5671bf1f1692225f7d8cc7977e8
\ No newline at end of file
diff --git a/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.10.0.jar.sha1 b/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.10.0.jar.sha1
deleted file mode 100644
index 5f17e786f91d5..0000000000000
--- a/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ccf4512816ba9cd5c2cca9182db78a2e48e7e16f
\ No newline at end of file
diff --git a/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.11.1.jar.sha1 b/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..d1be3c76d6252
--- /dev/null
+++ b/plugins/analysis-smartcn/licenses/lucene-analysis-smartcn-9.11.1.jar.sha1
@@ -0,0 +1 @@
+e900ea081428c3fdc7ec7a48f9c392871304476e
\ No newline at end of file
diff --git a/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.10.0.jar.sha1 b/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.10.0.jar.sha1
deleted file mode 100644
index f7b19bc3b38cd..0000000000000
--- a/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b596817e70f00bc54d66e82c118f47ca91b9e401
\ No newline at end of file
diff --git a/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.11.1.jar.sha1 b/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..c5719a3a210ae
--- /dev/null
+++ b/plugins/analysis-stempel/licenses/lucene-analysis-stempel-9.11.1.jar.sha1
@@ -0,0 +1 @@
+50f4d2400fa6264bf682028d8c7b6bbdd588b496
\ No newline at end of file
diff --git a/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.10.0.jar.sha1 b/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.10.0.jar.sha1
deleted file mode 100644
index 7fb543858c1a7..0000000000000
--- a/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-7acc74d35684269ffa74909395044e0e02581285
\ No newline at end of file
diff --git a/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.11.1.jar.sha1 b/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..ab69cec5884a4
--- /dev/null
+++ b/plugins/analysis-ukrainian/licenses/lucene-analysis-morfologik-9.11.1.jar.sha1
@@ -0,0 +1 @@
+20fe70fa74097c35c9aaaa5c0e19ca5f7ac93141
\ No newline at end of file
diff --git a/plugins/cache-ehcache/build.gradle b/plugins/cache-ehcache/build.gradle
index 07113849c6511..5747624e2fb69 100644
--- a/plugins/cache-ehcache/build.gradle
+++ b/plugins/cache-ehcache/build.gradle
@@ -90,13 +90,3 @@ tasks.named("bundlePlugin").configure {
     into 'config'
   }
 }
-
-test {
-  // TODO: Adding permission in plugin-security.policy doesn't seem to work.
-  systemProperty 'tests.security.manager', 'false'
-}
-
-internalClusterTest {
-  // TODO: Remove this later once we have a way.
-  systemProperty 'tests.security.manager', 'false'
-}
diff --git a/plugins/cache-ehcache/licenses/slf4j-api-LICENSE.txt b/plugins/cache-ehcache/licenses/slf4j-api-LICENSE.txt
index 2be7689435062..54512cc08d16b 100644
--- a/plugins/cache-ehcache/licenses/slf4j-api-LICENSE.txt
+++ b/plugins/cache-ehcache/licenses/slf4j-api-LICENSE.txt
@@ -18,4 +18,4 @@ MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java b/plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java
index 9a4dce1067b61..4a95b04de3952 100644
--- a/plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java
+++ b/plugins/cache-ehcache/src/main/java/org/opensearch/cache/store/disk/EhcacheDiskCache.java
@@ -42,6 +42,8 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
 import java.time.Duration;
 import java.util.Arrays;
 import java.util.Iterator;
@@ -58,7 +60,6 @@
 import java.util.function.ToLongBiFunction;
 
 import org.ehcache.Cache;
-import org.ehcache.CachePersistenceException;
 import org.ehcache.PersistentCacheManager;
 import org.ehcache.config.builders.CacheConfigurationBuilder;
 import org.ehcache.config.builders.CacheEventListenerConfigurationBuilder;
@@ -102,8 +103,6 @@ public class EhcacheDiskCache<K, V> implements ICache<K, V> {
     // Unique id associated with this cache.
     private final static String UNIQUE_ID = UUID.randomUUID().toString();
     private final static String THREAD_POOL_ALIAS_PREFIX = "ehcachePool";
-    private final static int MINIMUM_MAX_SIZE_IN_BYTES = 1024 * 100; // 100KB
-
     // A Cache manager can create many caches.
     private final PersistentCacheManager cacheManager;
 
@@ -125,13 +124,18 @@ public class EhcacheDiskCache<K, V> implements ICache<K, V> {
     private final Serializer<K, byte[]> keySerializer;
     private final Serializer<V, byte[]> valueSerializer;
 
+    final static int MINIMUM_MAX_SIZE_IN_BYTES = 1024 * 100; // 100KB
+    final static String CACHE_DATA_CLEANUP_DURING_INITIALIZATION_EXCEPTION = "Failed to delete ehcache disk cache under "
+        + "path: %s during initialization. Please clean this up manually and restart the process";
+
     /**
      * Used in computeIfAbsent to synchronize loading of a given key. This is needed as ehcache doesn't provide a
      * computeIfAbsent method.
      */
     Map<ICacheKey<K>, CompletableFuture<Tuple<ICacheKey<K>, V>>> completableFutureMap = new ConcurrentHashMap<>();
 
-    private EhcacheDiskCache(Builder<K, V> builder) {
+    @SuppressForbidden(reason = "Ehcache uses File.io")
+    EhcacheDiskCache(Builder<K, V> builder) {
         this.keyType = Objects.requireNonNull(builder.keyType, "Key type shouldn't be null");
         this.valueType = Objects.requireNonNull(builder.valueType, "Value type shouldn't be null");
         this.expireAfterAccess = Objects.requireNonNull(builder.getExpireAfterAcess(), "ExpireAfterAccess value shouldn't " + "be null");
@@ -149,6 +153,18 @@ private EhcacheDiskCache(Builder<K, V> builder) {
         if (this.storagePath == null || this.storagePath.isBlank()) {
             throw new IllegalArgumentException("Storage path shouldn't be null or empty");
         }
+        // Delete all the previous disk cache related files/data. We don't persist data between process restart for
+        // now which is why need to do this. Clean up in case there was a non graceful restart and we had older disk
+        // cache data still lying around.
+        Path ehcacheDirectory = Paths.get(this.storagePath);
+        if (Files.exists(ehcacheDirectory)) {
+            try {
+                logger.info("Found older disk cache data lying around during initialization under path: {}", this.storagePath);
+                IOUtils.rm(ehcacheDirectory);
+            } catch (IOException e) {
+                throw new OpenSearchException(String.format(CACHE_DATA_CLEANUP_DURING_INITIALIZATION_EXCEPTION, this.storagePath), e);
+            }
+        }
         if (builder.threadPoolAlias == null || builder.threadPoolAlias.isBlank()) {
             this.threadPoolAlias = THREAD_POOL_ALIAS_PREFIX + "DiskWrite#" + UNIQUE_ID;
         } else {
@@ -173,59 +189,67 @@ private EhcacheDiskCache(Builder<K, V> builder) {
         }
     }
 
+    // Package private for testing
+    PersistentCacheManager getCacheManager() {
+        return this.cacheManager;
+    }
+
     @SuppressWarnings({ "rawtypes" })
     private Cache<ICacheKey, ByteArrayWrapper> buildCache(Duration expireAfterAccess, Builder<K, V> builder) {
-        try {
-            return this.cacheManager.createCache(
-                this.diskCacheAlias,
-                CacheConfigurationBuilder.newCacheConfigurationBuilder(
-                    ICacheKey.class,
-                    ByteArrayWrapper.class,
-                    ResourcePoolsBuilder.newResourcePoolsBuilder().disk(maxWeightInBytes, MemoryUnit.B)
-                ).withExpiry(new ExpiryPolicy<>() {
-                    @Override
-                    public Duration getExpiryForCreation(ICacheKey key, ByteArrayWrapper value) {
-                        return INFINITE;
-                    }
-
-                    @Override
-                    public Duration getExpiryForAccess(ICacheKey key, Supplier<? extends ByteArrayWrapper> value) {
-                        return expireAfterAccess;
-                    }
-
-                    @Override
-                    public Duration getExpiryForUpdate(
-                        ICacheKey key,
-                        Supplier<? extends ByteArrayWrapper> oldValue,
-                        ByteArrayWrapper newValue
-                    ) {
-                        return INFINITE;
-                    }
-                })
-                    .withService(getListenerConfiguration(builder))
-                    .withService(
-                        new OffHeapDiskStoreConfiguration(
-                            this.threadPoolAlias,
-                            (Integer) EhcacheDiskCacheSettings.getSettingListForCacheType(cacheType)
-                                .get(DISK_WRITE_CONCURRENCY_KEY)
-                                .get(settings),
-                            (Integer) EhcacheDiskCacheSettings.getSettingListForCacheType(cacheType).get(DISK_SEGMENT_KEY).get(settings)
+        // Creating the cache requires permissions specified in plugin-security.policy
+        return AccessController.doPrivileged((PrivilegedAction<Cache<ICacheKey, ByteArrayWrapper>>) () -> {
+            try {
+                return this.cacheManager.createCache(
+                    this.diskCacheAlias,
+                    CacheConfigurationBuilder.newCacheConfigurationBuilder(
+                        ICacheKey.class,
+                        ByteArrayWrapper.class,
+                        ResourcePoolsBuilder.newResourcePoolsBuilder().disk(maxWeightInBytes, MemoryUnit.B)
+                    ).withExpiry(new ExpiryPolicy<>() {
+                        @Override
+                        public Duration getExpiryForCreation(ICacheKey key, ByteArrayWrapper value) {
+                            return INFINITE;
+                        }
+
+                        @Override
+                        public Duration getExpiryForAccess(ICacheKey key, Supplier<? extends ByteArrayWrapper> value) {
+                            return expireAfterAccess;
+                        }
+
+                        @Override
+                        public Duration getExpiryForUpdate(
+                            ICacheKey key,
+                            Supplier<? extends ByteArrayWrapper> oldValue,
+                            ByteArrayWrapper newValue
+                        ) {
+                            return INFINITE;
+                        }
+                    })
+                        .withService(getListenerConfiguration(builder))
+                        .withService(
+                            new OffHeapDiskStoreConfiguration(
+                                this.threadPoolAlias,
+                                (Integer) EhcacheDiskCacheSettings.getSettingListForCacheType(cacheType)
+                                    .get(DISK_WRITE_CONCURRENCY_KEY)
+                                    .get(settings),
+                                (Integer) EhcacheDiskCacheSettings.getSettingListForCacheType(cacheType).get(DISK_SEGMENT_KEY).get(settings)
+                            )
                         )
-                    )
-                    .withKeySerializer(new KeySerializerWrapper(keySerializer))
-                    .withValueSerializer(new ByteArrayWrapperSerializer())
+                        .withKeySerializer(new KeySerializerWrapper(keySerializer))
+                        .withValueSerializer(new ByteArrayWrapperSerializer())
                 // We pass ByteArrayWrapperSerializer as ehcache's value serializer. If V is an interface, and we pass its
                 // serializer directly to ehcache, ehcache requires the classes match exactly before/after serialization.
                 // This is not always feasible or necessary, like for BytesReference. So, we handle the value serialization
                 // before V hits ehcache.
-            );
-        } catch (IllegalArgumentException ex) {
-            logger.error("Ehcache disk cache initialization failed due to illegal argument: {}", ex.getMessage());
-            throw ex;
-        } catch (IllegalStateException ex) {
-            logger.error("Ehcache disk cache initialization failed: {}", ex.getMessage());
-            throw ex;
-        }
+                );
+            } catch (IllegalArgumentException ex) {
+                logger.error("Ehcache disk cache initialization failed due to illegal argument: {}", ex.getMessage());
+                throw ex;
+            } catch (IllegalStateException ex) {
+                logger.error("Ehcache disk cache initialization failed: {}", ex.getMessage());
+                throw ex;
+            }
+        });
     }
 
     private CacheEventListenerConfigurationBuilder getListenerConfiguration(Builder<K, V> builder) {
@@ -250,27 +274,30 @@ Map<ICacheKey<K>, CompletableFuture<Tuple<ICacheKey<K>, V>>> getCompletableFutur
     }
 
     @SuppressForbidden(reason = "Ehcache uses File.io")
-    private PersistentCacheManager buildCacheManager() {
+    PersistentCacheManager buildCacheManager() {
         // In case we use multiple ehCaches, we can define this cache manager at a global level.
-        return CacheManagerBuilder.newCacheManagerBuilder()
-            .with(CacheManagerBuilder.persistence(new File(storagePath)))
-
-            .using(
-                PooledExecutionServiceConfigurationBuilder.newPooledExecutionServiceConfigurationBuilder()
-                    .defaultPool(THREAD_POOL_ALIAS_PREFIX + "Default#" + UNIQUE_ID, 1, 3) // Default pool used for other tasks
-                    // like event listeners
-                    .pool(
-                        this.threadPoolAlias,
-                        (Integer) EhcacheDiskCacheSettings.getSettingListForCacheType(cacheType)
-                            .get(DISK_WRITE_MIN_THREADS_KEY)
-                            .get(settings),
-                        (Integer) EhcacheDiskCacheSettings.getSettingListForCacheType(cacheType)
-                            .get(DISK_WRITE_MAXIMUM_THREADS_KEY)
-                            .get(settings)
-                    )
-                    .build()
-            )
-            .build(true);
+        // Creating the cache manager also requires permissions specified in plugin-security.policy
+        return AccessController.doPrivileged((PrivilegedAction<PersistentCacheManager>) () -> {
+            return CacheManagerBuilder.newCacheManagerBuilder()
+                .with(CacheManagerBuilder.persistence(new File(storagePath)))
+
+                .using(
+                    PooledExecutionServiceConfigurationBuilder.newPooledExecutionServiceConfigurationBuilder()
+                        .defaultPool(THREAD_POOL_ALIAS_PREFIX + "Default#" + UNIQUE_ID, 1, 3) // Default pool used for other tasks
+                        // like event listeners
+                        .pool(
+                            this.threadPoolAlias,
+                            (Integer) EhcacheDiskCacheSettings.getSettingListForCacheType(cacheType)
+                                .get(DISK_WRITE_MIN_THREADS_KEY)
+                                .get(settings),
+                            (Integer) EhcacheDiskCacheSettings.getSettingListForCacheType(cacheType)
+                                .get(DISK_WRITE_MAXIMUM_THREADS_KEY)
+                                .get(settings)
+                        )
+                        .build()
+                )
+                .build(true);
+        });
     }
 
     @Override
@@ -436,20 +463,21 @@ public void refresh() {
     @Override
     @SuppressForbidden(reason = "Ehcache uses File.io")
     public void close() {
-        cacheManager.removeCache(this.diskCacheAlias);
-        cacheManager.close();
         try {
-            cacheManager.destroyCache(this.diskCacheAlias);
-            // Delete all the disk cache related files/data
-            Path ehcacheDirectory = Paths.get(this.storagePath);
-            if (Files.exists(ehcacheDirectory)) {
+            cacheManager.close();
+        } catch (Exception e) {
+            logger.error(() -> new ParameterizedMessage("Exception occurred while trying to close ehcache manager"), e);
+        }
+        // Delete all the disk cache related files/data in case it is present
+        Path ehcacheDirectory = Paths.get(this.storagePath);
+        if (Files.exists(ehcacheDirectory)) {
+            try {
                 IOUtils.rm(ehcacheDirectory);
+            } catch (IOException e) {
+                logger.error(() -> new ParameterizedMessage("Failed to delete ehcache disk cache data under path: {}", this.storagePath));
             }
-        } catch (CachePersistenceException e) {
-            throw new OpenSearchException("Exception occurred while destroying ehcache and associated data", e);
-        } catch (IOException e) {
-            logger.error(() -> new ParameterizedMessage("Failed to delete ehcache disk cache data under path: {}", this.storagePath));
         }
+
     }
 
     /**
diff --git a/plugins/cache-ehcache/src/main/plugin-metadata/plugin-security.policy b/plugins/cache-ehcache/src/main/plugin-metadata/plugin-security.policy
index 40007eea62dba..85c82824d5d65 100644
--- a/plugins/cache-ehcache/src/main/plugin-metadata/plugin-security.policy
+++ b/plugins/cache-ehcache/src/main/plugin-metadata/plugin-security.policy
@@ -9,5 +9,8 @@
 grant {
   permission java.lang.RuntimePermission "accessClassInPackage.sun.misc";
   permission java.lang.RuntimePermission "createClassLoader";
+  permission java.lang.RuntimePermission "accessDeclaredMembers";
+  permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
+  permission java.lang.RuntimePermission "getClassLoader";
 };
 
diff --git a/plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java b/plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java
index 29551befd3e9f..2bc24227bb513 100644
--- a/plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java
+++ b/plugins/cache-ehcache/src/test/java/org/opensearch/cache/store/disk/EhCacheDiskCacheTests.java
@@ -25,6 +25,7 @@
 import org.opensearch.common.metrics.CounterMetric;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.bytes.CompositeBytesReference;
@@ -34,6 +35,8 @@
 import java.io.IOException;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -47,10 +50,17 @@
 import java.util.concurrent.Phaser;
 import java.util.function.ToLongBiFunction;
 
+import org.ehcache.PersistentCacheManager;
+
 import static org.opensearch.cache.EhcacheDiskCacheSettings.DISK_LISTENER_MODE_SYNC_KEY;
 import static org.opensearch.cache.EhcacheDiskCacheSettings.DISK_MAX_SIZE_IN_BYTES_KEY;
 import static org.opensearch.cache.EhcacheDiskCacheSettings.DISK_STORAGE_PATH_KEY;
+import static org.opensearch.cache.store.disk.EhcacheDiskCache.MINIMUM_MAX_SIZE_IN_BYTES;
 import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
 
 @ThreadLeakFilters(filters = { EhcacheThreadLeakFilter.class })
 public class EhCacheDiskCacheTests extends OpenSearchSingleNodeTestCase {
@@ -882,6 +892,289 @@ public void testStatsTrackingDisabled() throws Exception {
         }
     }
 
+    public void testDiskCacheFilesAreClearedUpDuringCloseAndInitialization() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            String path = env.nodePaths()[0].path.toString() + "/request_cache";
+            // Create a dummy file to simulate a scenario where the data is already in the disk cache storage path
+            // beforehand.
+            Files.createDirectory(Path.of(path));
+            Path dummyFilePath = Files.createFile(Path.of(path + "/testing.txt"));
+            assertTrue(Files.exists(dummyFilePath));
+            ICache<String, String> ehcacheTest = new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                .setStoragePath(path)
+                .setIsEventListenerModeSync(true)
+                .setKeyType(String.class)
+                .setValueType(String.class)
+                .setKeySerializer(new StringSerializer())
+                .setDiskCacheAlias("test1")
+                .setValueSerializer(new StringSerializer())
+                .setDimensionNames(List.of(dimensionName))
+                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                .setThreadPoolAlias("")
+                .setSettings(settings)
+                .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                .setRemovalListener(removalListener)
+                .setWeigher(weigher)
+                .setStatsTrackingEnabled(false)
+                .build();
+            int randomKeys = randomIntBetween(10, 100);
+            for (int i = 0; i < randomKeys; i++) {
+                ICacheKey<String> iCacheKey = getICacheKey(UUID.randomUUID().toString());
+                ehcacheTest.put(iCacheKey, UUID.randomUUID().toString());
+                assertEquals(0, ehcacheTest.count()); // Expect count of 0 if NoopCacheStatsHolder is used
+                assertEquals(new ImmutableCacheStats(0, 0, 0, 0, 0), ehcacheTest.stats().getTotalStats());
+            }
+            // Verify that older data was wiped out after initialization
+            assertFalse(Files.exists(dummyFilePath));
+
+            // Verify that there is data present under desired path by explicitly verifying the folder name by prefix
+            // (used from disk cache alias)
+            assertTrue(Files.exists(Path.of(path)));
+            boolean folderExists = Files.walk(Path.of(path))
+                .filter(Files::isDirectory)
+                .anyMatch(path1 -> path1.getFileName().toString().startsWith("test1"));
+            assertTrue(folderExists);
+            ehcacheTest.close();
+            assertFalse(Files.exists(Path.of(path))); // Verify everything is cleared up now after close()
+        }
+    }
+
+    public void testDiskCacheCloseCalledTwiceAndVerifyDiskDataIsCleanedUp() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            String path = env.nodePaths()[0].path.toString() + "/request_cache";
+            ICache<String, String> ehcacheTest = new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias(null)
+                .setStoragePath(path)
+                .setIsEventListenerModeSync(true)
+                .setKeyType(String.class)
+                .setValueType(String.class)
+                .setKeySerializer(new StringSerializer())
+                .setDiskCacheAlias("test1")
+                .setValueSerializer(new StringSerializer())
+                .setDimensionNames(List.of(dimensionName))
+                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                .setSettings(settings)
+                .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                .setRemovalListener(removalListener)
+                .setWeigher(weigher)
+                .setStatsTrackingEnabled(false)
+                .build();
+            int randomKeys = randomIntBetween(10, 100);
+            for (int i = 0; i < randomKeys; i++) {
+                ICacheKey<String> iCacheKey = getICacheKey(UUID.randomUUID().toString());
+                ehcacheTest.put(iCacheKey, UUID.randomUUID().toString());
+                assertEquals(0, ehcacheTest.count()); // Expect count storagePath 0 if NoopCacheStatsHolder is used
+                assertEquals(new ImmutableCacheStats(0, 0, 0, 0, 0), ehcacheTest.stats().getTotalStats());
+            }
+            ehcacheTest.close();
+            assertFalse(Files.exists(Path.of(path))); // Verify everything is cleared up now after close()
+            // Call it again. This will throw an exception.
+            ehcacheTest.close();
+        }
+    }
+
+    public void testDiskCacheCloseAfterCleaningUpFilesManually() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            String path = env.nodePaths()[0].path.toString() + "/request_cache";
+            ICache<String, String> ehcacheTest = new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias(null)
+                .setStoragePath(path)
+                .setIsEventListenerModeSync(true)
+                .setKeyType(String.class)
+                .setValueType(String.class)
+                .setKeySerializer(new StringSerializer())
+                .setDiskCacheAlias("test1")
+                .setValueSerializer(new StringSerializer())
+                .setDimensionNames(List.of(dimensionName))
+                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                .setSettings(settings)
+                .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                .setRemovalListener(removalListener)
+                .setWeigher(weigher)
+                .setStatsTrackingEnabled(false)
+                .build();
+            int randomKeys = randomIntBetween(10, 100);
+            for (int i = 0; i < randomKeys; i++) {
+                ICacheKey<String> iCacheKey = getICacheKey(UUID.randomUUID().toString());
+                ehcacheTest.put(iCacheKey, UUID.randomUUID().toString());
+                assertEquals(0, ehcacheTest.count()); // Expect count storagePath 0 if NoopCacheStatsHolder is used
+                assertEquals(new ImmutableCacheStats(0, 0, 0, 0, 0), ehcacheTest.stats().getTotalStats());
+            }
+            IOUtils.rm(Path.of(path));
+            ehcacheTest.close();
+        }
+    }
+
+    public void testEhcacheDiskCacheWithoutStoragePathDefined() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                    .setIsEventListenerModeSync(true)
+                    .setKeyType(String.class)
+                    .setValueType(String.class)
+                    .setKeySerializer(new StringSerializer())
+                    .setDiskCacheAlias("test1")
+                    .setValueSerializer(new StringSerializer())
+                    .setDimensionNames(List.of(dimensionName))
+                    .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .setSettings(settings)
+                    .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                    .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                    .setRemovalListener(removalListener)
+                    .setWeigher(weigher)
+                    .setStatsTrackingEnabled(false)
+                    .build()
+            );
+        }
+    }
+
+    public void testEhcacheDiskCacheWithoutStoragePathNull() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                    .setStoragePath(null)
+                    .setIsEventListenerModeSync(true)
+                    .setKeyType(String.class)
+                    .setValueType(String.class)
+                    .setKeySerializer(new StringSerializer())
+                    .setDiskCacheAlias("test1")
+                    .setValueSerializer(new StringSerializer())
+                    .setDimensionNames(List.of(dimensionName))
+                    .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .setSettings(settings)
+                    .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                    .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                    .setRemovalListener(removalListener)
+                    .setWeigher(weigher)
+                    .setStatsTrackingEnabled(false)
+                    .build()
+            );
+        }
+    }
+
+    public void testEhcacheWithStorageSizeLowerThanMinimumExpected() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                    .setIsEventListenerModeSync(true)
+                    .setKeyType(String.class)
+                    .setValueType(String.class)
+                    .setKeySerializer(new StringSerializer())
+                    .setDiskCacheAlias("test1")
+                    .setValueSerializer(new StringSerializer())
+                    .setDimensionNames(List.of(dimensionName))
+                    .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .setSettings(settings)
+                    .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                    .setMaximumWeightInBytes(MINIMUM_MAX_SIZE_IN_BYTES)
+                    .setRemovalListener(removalListener)
+                    .setWeigher(weigher)
+                    .setStatsTrackingEnabled(false)
+                    .build()
+            );
+        }
+    }
+
+    public void testEhcacheWithStorageSizeZero() throws Exception {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            assertThrows(
+                IllegalArgumentException.class,
+                () -> new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias("ehcacheTest")
+                    .setIsEventListenerModeSync(true)
+                    .setKeyType(String.class)
+                    .setValueType(String.class)
+                    .setKeySerializer(new StringSerializer())
+                    .setDiskCacheAlias("test1")
+                    .setValueSerializer(new StringSerializer())
+                    .setDimensionNames(List.of(dimensionName))
+                    .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                    .setSettings(settings)
+                    .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                    .setMaximumWeightInBytes(0)
+                    .setRemovalListener(removalListener)
+                    .setWeigher(weigher)
+                    .setStatsTrackingEnabled(false)
+                    .build()
+            );
+        }
+    }
+
+    public void testEhcacheCloseWithDestroyCacheMethodThrowingException() throws Exception {
+        EhcacheDiskCache<String, String> ehcacheDiskCache = new MockEhcahceDiskCache(createDummyBuilder(null));
+        PersistentCacheManager cacheManager = ehcacheDiskCache.getCacheManager();
+        doNothing().when(cacheManager).removeCache(anyString());
+        doNothing().when(cacheManager).close();
+        doThrow(new RuntimeException("test")).when(cacheManager).destroyCache(anyString());
+        ehcacheDiskCache.close();
+    }
+
+    static class MockEhcahceDiskCache extends EhcacheDiskCache<String, String> {
+
+        public MockEhcahceDiskCache(Builder<String, String> builder) {
+            super(builder);
+        }
+
+        @Override
+        PersistentCacheManager buildCacheManager() {
+            PersistentCacheManager cacheManager = mock(PersistentCacheManager.class);
+            return cacheManager;
+        }
+    }
+
+    private EhcacheDiskCache.Builder<String, String> createDummyBuilder(String storagePath) throws IOException {
+        Settings settings = Settings.builder().build();
+        MockRemovalListener<String, String> removalListener = new MockRemovalListener<>();
+        ToLongBiFunction<ICacheKey<String>, String> weigher = getWeigher();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            if (storagePath == null || storagePath.isBlank()) {
+                storagePath = env.nodePaths()[0].path.toString() + "/request_cache";
+            }
+            return (EhcacheDiskCache.Builder<String, String>) new EhcacheDiskCache.Builder<String, String>().setThreadPoolAlias(
+                "ehcacheTest"
+            )
+                .setIsEventListenerModeSync(true)
+                .setStoragePath(storagePath)
+                .setKeyType(String.class)
+                .setValueType(String.class)
+                .setKeySerializer(new StringSerializer())
+                .setDiskCacheAlias("test1")
+                .setValueSerializer(new StringSerializer())
+                .setDimensionNames(List.of(dimensionName))
+                .setCacheType(CacheType.INDICES_REQUEST_CACHE)
+                .setSettings(settings)
+                .setExpireAfterAccess(TimeValue.MAX_VALUE)
+                .setMaximumWeightInBytes(CACHE_SIZE_IN_BYTES)
+                .setRemovalListener(removalListener)
+                .setWeigher(weigher)
+                .setStatsTrackingEnabled(false);
+        }
+    }
+
     private List<String> getRandomDimensions(List<String> dimensionNames) {
         Random rand = Randomness.get();
         int bound = 3;
diff --git a/plugins/crypto-kms/licenses/jackson-annotations-2.17.1.jar.sha1 b/plugins/crypto-kms/licenses/jackson-annotations-2.17.1.jar.sha1
deleted file mode 100644
index 4ceead1b7ae4f..0000000000000
--- a/plugins/crypto-kms/licenses/jackson-annotations-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fca7ef6192c9ad05d07bc50da991bf937a84af3a
\ No newline at end of file
diff --git a/plugins/crypto-kms/licenses/jackson-annotations-2.17.2.jar.sha1 b/plugins/crypto-kms/licenses/jackson-annotations-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..411e1d62459fd
--- /dev/null
+++ b/plugins/crypto-kms/licenses/jackson-annotations-2.17.2.jar.sha1
@@ -0,0 +1 @@
+147b7b9412ffff24339f8aba080b292448e08698
\ No newline at end of file
diff --git a/plugins/crypto-kms/licenses/jackson-databind-2.17.1.jar.sha1 b/plugins/crypto-kms/licenses/jackson-databind-2.17.1.jar.sha1
deleted file mode 100644
index 7cf1ac1b60301..0000000000000
--- a/plugins/crypto-kms/licenses/jackson-databind-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-0524dcbcccdde7d45a679dfc333e4763feb09079
\ No newline at end of file
diff --git a/plugins/crypto-kms/licenses/jackson-databind-2.17.2.jar.sha1 b/plugins/crypto-kms/licenses/jackson-databind-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f2b4dbdc5decb
--- /dev/null
+++ b/plugins/crypto-kms/licenses/jackson-databind-2.17.2.jar.sha1
@@ -0,0 +1 @@
+e6deb029e5901e027c129341fac39e515066b68c
\ No newline at end of file
diff --git a/plugins/discovery-ec2/licenses/jackson-annotations-2.17.1.jar.sha1 b/plugins/discovery-ec2/licenses/jackson-annotations-2.17.1.jar.sha1
deleted file mode 100644
index 4ceead1b7ae4f..0000000000000
--- a/plugins/discovery-ec2/licenses/jackson-annotations-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fca7ef6192c9ad05d07bc50da991bf937a84af3a
\ No newline at end of file
diff --git a/plugins/discovery-ec2/licenses/jackson-annotations-2.17.2.jar.sha1 b/plugins/discovery-ec2/licenses/jackson-annotations-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..411e1d62459fd
--- /dev/null
+++ b/plugins/discovery-ec2/licenses/jackson-annotations-2.17.2.jar.sha1
@@ -0,0 +1 @@
+147b7b9412ffff24339f8aba080b292448e08698
\ No newline at end of file
diff --git a/plugins/discovery-ec2/licenses/jackson-databind-2.17.1.jar.sha1 b/plugins/discovery-ec2/licenses/jackson-databind-2.17.1.jar.sha1
deleted file mode 100644
index 7cf1ac1b60301..0000000000000
--- a/plugins/discovery-ec2/licenses/jackson-databind-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-0524dcbcccdde7d45a679dfc333e4763feb09079
\ No newline at end of file
diff --git a/plugins/discovery-ec2/licenses/jackson-databind-2.17.2.jar.sha1 b/plugins/discovery-ec2/licenses/jackson-databind-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f2b4dbdc5decb
--- /dev/null
+++ b/plugins/discovery-ec2/licenses/jackson-databind-2.17.2.jar.sha1
@@ -0,0 +1 @@
+e6deb029e5901e027c129341fac39e515066b68c
\ No newline at end of file
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroIdentityPlugin.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroIdentityPlugin.java
index 77cab13880c27..af802596ebaa7 100644
--- a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroIdentityPlugin.java
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroIdentityPlugin.java
@@ -12,23 +12,43 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.shiro.SecurityUtils;
 import org.apache.shiro.mgt.SecurityManager;
+import org.opensearch.client.Client;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.env.Environment;
+import org.opensearch.env.NodeEnvironment;
+import org.opensearch.identity.PluginSubject;
 import org.opensearch.identity.Subject;
 import org.opensearch.identity.tokens.TokenManager;
 import org.opensearch.plugins.IdentityPlugin;
 import org.opensearch.plugins.Plugin;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.script.ScriptService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.watcher.ResourceWatcherService;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.function.Supplier;
 
 /**
  * Identity implementation with Shiro
  *
  * @opensearch.experimental
  */
+@ExperimentalApi
 public final class ShiroIdentityPlugin extends Plugin implements IdentityPlugin {
     private Logger log = LogManager.getLogger(this.getClass());
 
     private final Settings settings;
     private final ShiroTokenManager authTokenHandler;
 
+    private ThreadPool threadPool;
+
     /**
      * Create a new instance of the Shiro Identity Plugin
      *
@@ -42,13 +62,31 @@ public ShiroIdentityPlugin(final Settings settings) {
         SecurityUtils.setSecurityManager(securityManager);
     }
 
+    @Override
+    public Collection<Object> createComponents(
+        Client client,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ResourceWatcherService resourceWatcherService,
+        ScriptService scriptService,
+        NamedXContentRegistry xContentRegistry,
+        Environment environment,
+        NodeEnvironment nodeEnvironment,
+        NamedWriteableRegistry namedWriteableRegistry,
+        IndexNameExpressionResolver expressionResolver,
+        Supplier<RepositoriesService> repositoriesServiceSupplier
+    ) {
+        this.threadPool = threadPool;
+        return Collections.emptyList();
+    }
+
     /**
      * Return a Shiro Subject based on the provided authTokenHandler and current subject
      *
      * @return The current subject
      */
     @Override
-    public Subject getSubject() {
+    public Subject getCurrentSubject() {
         return new ShiroSubject(authTokenHandler, SecurityUtils.getSubject());
     }
 
@@ -61,4 +99,9 @@ public Subject getSubject() {
     public TokenManager getTokenManager() {
         return this.authTokenHandler;
     }
+
+    @Override
+    public PluginSubject getPluginSubject(Plugin plugin) {
+        return new ShiroPluginSubject(threadPool);
+    }
 }
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroPluginSubject.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroPluginSubject.java
new file mode 100644
index 0000000000000..31dde34f447d4
--- /dev/null
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroPluginSubject.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.identity.shiro;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.identity.NamedPrincipal;
+import org.opensearch.identity.PluginSubject;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.security.Principal;
+import java.util.concurrent.Callable;
+
+/**
+ * Implementation of subject that is always authenticated
+ * <p>
+ * This class and related classes in this package will not return nulls or fail permissions checks
+ *
+ * This class is used by the ShiroIdentityPlugin to initialize IdentityAwarePlugins
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class ShiroPluginSubject implements PluginSubject {
+    private final ThreadPool threadPool;
+
+    ShiroPluginSubject(ThreadPool threadPool) {
+        super();
+        this.threadPool = threadPool;
+    }
+
+    @Override
+    public Principal getPrincipal() {
+        return NamedPrincipal.UNAUTHENTICATED;
+    }
+
+    @Override
+    public <T> T runAs(Callable<T> callable) throws Exception {
+        try (ThreadContext.StoredContext ctx = threadPool.getThreadContext().stashContext()) {
+            return callable.call();
+        }
+    }
+}
diff --git a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroSubject.java b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroSubject.java
index e55204593621c..72a168f23c5cd 100644
--- a/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroSubject.java
+++ b/plugins/identity-shiro/src/main/java/org/opensearch/identity/shiro/ShiroSubject.java
@@ -9,6 +9,7 @@
 package org.opensearch.identity.shiro;
 
 import org.opensearch.identity.Subject;
+import org.opensearch.identity.UserSubject;
 import org.opensearch.identity.tokens.AuthToken;
 
 import java.security.Principal;
@@ -19,7 +20,7 @@
  *
  * @opensearch.experimental
  */
-public class ShiroSubject implements Subject {
+public class ShiroSubject implements UserSubject {
     private final ShiroTokenManager authTokenHandler;
     private final org.apache.shiro.subject.Subject shiroSubject;
 
diff --git a/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/ShiroIdentityPluginTests.java b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/ShiroIdentityPluginTests.java
index 626cd44d13ec8..bc14410d81de0 100644
--- a/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/ShiroIdentityPluginTests.java
+++ b/plugins/identity-shiro/src/test/java/org/opensearch/identity/shiro/ShiroIdentityPluginTests.java
@@ -13,6 +13,7 @@
 import org.opensearch.identity.IdentityService;
 import org.opensearch.plugins.IdentityPlugin;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
 
 import java.util.List;
 
@@ -24,19 +25,23 @@
 public class ShiroIdentityPluginTests extends OpenSearchTestCase {
 
     public void testSingleIdentityPluginSucceeds() {
+        TestThreadPool threadPool = new TestThreadPool(getTestName());
         IdentityPlugin identityPlugin1 = new ShiroIdentityPlugin(Settings.EMPTY);
         List<IdentityPlugin> pluginList1 = List.of(identityPlugin1);
-        IdentityService identityService1 = new IdentityService(Settings.EMPTY, pluginList1);
+        IdentityService identityService1 = new IdentityService(Settings.EMPTY, threadPool, pluginList1);
         assertThat(identityService1.getTokenManager(), is(instanceOf(ShiroTokenManager.class)));
+        terminate(threadPool);
     }
 
     public void testMultipleIdentityPluginsFail() {
+        TestThreadPool threadPool = new TestThreadPool(getTestName());
         IdentityPlugin identityPlugin1 = new ShiroIdentityPlugin(Settings.EMPTY);
         IdentityPlugin identityPlugin2 = new ShiroIdentityPlugin(Settings.EMPTY);
         IdentityPlugin identityPlugin3 = new ShiroIdentityPlugin(Settings.EMPTY);
         List<IdentityPlugin> pluginList = List.of(identityPlugin1, identityPlugin2, identityPlugin3);
-        Exception ex = assertThrows(OpenSearchException.class, () -> new IdentityService(Settings.EMPTY, pluginList));
+        Exception ex = assertThrows(OpenSearchException.class, () -> new IdentityService(Settings.EMPTY, threadPool, pluginList));
         assert (ex.getMessage().contains("Multiple identity plugins are not supported,"));
+        terminate(threadPool);
     }
 
 }
diff --git a/plugins/ingest-attachment/build.gradle b/plugins/ingest-attachment/build.gradle
index 4749aa911886d..81ac52b97cefa 100644
--- a/plugins/ingest-attachment/build.gradle
+++ b/plugins/ingest-attachment/build.gradle
@@ -66,7 +66,7 @@ dependencies {
   runtimeOnly "com.optimaize.languagedetector:language-detector:0.6"
   runtimeOnly "com.google.guava:guava:${versions.guava}"
   // Other dependencies
-  api 'org.tukaani:xz:1.9'
+  api 'org.tukaani:xz:1.10'
   api "commons-io:commons-io:${versions.commonsio}"
   api "org.slf4j:slf4j-api:${versions.slf4j}"
 
@@ -89,7 +89,7 @@ dependencies {
   api "org.apache.poi:poi:${versions.poi}"
   api "org.apache.poi:poi-ooxml-lite:${versions.poi}"
   api "commons-codec:commons-codec:${versions.commonscodec}"
-  api 'org.apache.xmlbeans:xmlbeans:5.2.0'
+  api 'org.apache.xmlbeans:xmlbeans:5.2.1'
   api 'org.apache.commons:commons-collections4:4.4'
   // MS Office
   api "org.apache.poi:poi-scratchpad:${versions.poi}"
diff --git a/plugins/ingest-attachment/licenses/xmlbeans-5.2.0.jar.sha1 b/plugins/ingest-attachment/licenses/xmlbeans-5.2.0.jar.sha1
deleted file mode 100644
index f34274d593697..0000000000000
--- a/plugins/ingest-attachment/licenses/xmlbeans-5.2.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-6198ac997b3f234f2b5393fa415f78fac2e06510
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/xmlbeans-5.2.1.jar.sha1 b/plugins/ingest-attachment/licenses/xmlbeans-5.2.1.jar.sha1
new file mode 100644
index 0000000000000..eaab556163e5c
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/xmlbeans-5.2.1.jar.sha1
@@ -0,0 +1 @@
+e16ddf17fe181c202b097e0dcc0ee2fed91cb7da
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/xz-1.10.jar.sha1 b/plugins/ingest-attachment/licenses/xz-1.10.jar.sha1
new file mode 100644
index 0000000000000..e3757c19ce5ab
--- /dev/null
+++ b/plugins/ingest-attachment/licenses/xz-1.10.jar.sha1
@@ -0,0 +1 @@
+1be8166f89e035a56c6bfc67dbc423996fe577e2
\ No newline at end of file
diff --git a/plugins/ingest-attachment/licenses/xz-1.9.jar.sha1 b/plugins/ingest-attachment/licenses/xz-1.9.jar.sha1
deleted file mode 100644
index c3e22d167212f..0000000000000
--- a/plugins/ingest-attachment/licenses/xz-1.9.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-1ea4bec1a921180164852c65006d928617bd2caf
\ No newline at end of file
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/QueryInsightsPlugin.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/QueryInsightsPlugin.java
index 4d7e0d486068a..bba676436c39a 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/QueryInsightsPlugin.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/QueryInsightsPlugin.java
@@ -70,7 +70,7 @@ public Collection<Object> createComponents(
         final Supplier<RepositoriesService> repositoriesServiceSupplier
     ) {
         // create top n queries service
-        final QueryInsightsService queryInsightsService = new QueryInsightsService(threadPool);
+        final QueryInsightsService queryInsightsService = new QueryInsightsService(clusterService.getClusterSettings(), threadPool, client);
         return List.of(queryInsightsService, new QueryInsightsListener(clusterService, queryInsightsService));
     }
 
@@ -110,7 +110,16 @@ public List<Setting<?>> getSettings() {
             // Settings for top N queries
             QueryInsightsSettings.TOP_N_LATENCY_QUERIES_ENABLED,
             QueryInsightsSettings.TOP_N_LATENCY_QUERIES_SIZE,
-            QueryInsightsSettings.TOP_N_LATENCY_QUERIES_WINDOW_SIZE
+            QueryInsightsSettings.TOP_N_LATENCY_QUERIES_WINDOW_SIZE,
+            QueryInsightsSettings.TOP_N_LATENCY_EXPORTER_SETTINGS,
+            QueryInsightsSettings.TOP_N_CPU_QUERIES_ENABLED,
+            QueryInsightsSettings.TOP_N_CPU_QUERIES_SIZE,
+            QueryInsightsSettings.TOP_N_CPU_QUERIES_WINDOW_SIZE,
+            QueryInsightsSettings.TOP_N_CPU_EXPORTER_SETTINGS,
+            QueryInsightsSettings.TOP_N_MEMORY_QUERIES_ENABLED,
+            QueryInsightsSettings.TOP_N_MEMORY_QUERIES_SIZE,
+            QueryInsightsSettings.TOP_N_MEMORY_QUERIES_WINDOW_SIZE,
+            QueryInsightsSettings.TOP_N_MEMORY_EXPORTER_SETTINGS
         );
     }
 }
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/DebugExporter.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/DebugExporter.java
new file mode 100644
index 0000000000000..116bd26e1f9bc
--- /dev/null
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/DebugExporter.java
@@ -0,0 +1,61 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.insights.core.exporter;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
+
+import java.util.List;
+
+/**
+ * Debug exporter for development purpose
+ */
+public final class DebugExporter implements QueryInsightsExporter {
+    /**
+     * Logger of the debug exporter
+     */
+    private final Logger logger = LogManager.getLogger();
+
+    /**
+     * Constructor of DebugExporter
+     */
+    private DebugExporter() {}
+
+    private static class InstanceHolder {
+        private static final DebugExporter INSTANCE = new DebugExporter();
+    }
+
+    /**
+     Get the singleton instance of DebugExporter
+     *
+     @return DebugExporter instance
+     */
+    public static DebugExporter getInstance() {
+        return InstanceHolder.INSTANCE;
+    }
+
+    /**
+     * Write the list of SearchQueryRecord to debug log
+     *
+     * @param records list of {@link SearchQueryRecord}
+     */
+    @Override
+    public void export(final List<SearchQueryRecord> records) {
+        logger.debug("QUERY_INSIGHTS_RECORDS: " + records.toString());
+    }
+
+    /**
+     * Close the debugger exporter sink
+     */
+    @Override
+    public void close() {
+        logger.debug("Closing the DebugExporter..");
+    }
+}
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/LocalIndexExporter.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/LocalIndexExporter.java
new file mode 100644
index 0000000000000..c19fe3655098b
--- /dev/null
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/LocalIndexExporter.java
@@ -0,0 +1,113 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.insights.core.exporter;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.bulk.BulkRequestBuilder;
+import org.opensearch.action.bulk.BulkResponse;
+import org.opensearch.action.index.IndexRequest;
+import org.opensearch.client.Client;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.joda.time.format.DateTimeFormatter;
+
+import java.util.List;
+
+/**
+ * Local index exporter for exporting query insights data to local OpenSearch indices.
+ */
+public final class LocalIndexExporter implements QueryInsightsExporter {
+    /**
+     * Logger of the local index exporter
+     */
+    private final Logger logger = LogManager.getLogger();
+    private final Client client;
+    private DateTimeFormatter indexPattern;
+
+    /**
+     * Constructor of LocalIndexExporter
+     *
+     * @param client OS client
+     * @param indexPattern the pattern of index to export to
+     */
+    public LocalIndexExporter(final Client client, final DateTimeFormatter indexPattern) {
+        this.indexPattern = indexPattern;
+        this.client = client;
+    }
+
+    /**
+     * Getter of indexPattern
+     *
+     * @return indexPattern
+     */
+    public DateTimeFormatter getIndexPattern() {
+        return indexPattern;
+    }
+
+    /**
+     * Setter of indexPattern
+     *
+     * @param indexPattern index pattern
+     * @return the current LocalIndexExporter
+     */
+    public LocalIndexExporter setIndexPattern(DateTimeFormatter indexPattern) {
+        this.indexPattern = indexPattern;
+        return this;
+    }
+
+    /**
+     * Export a list of SearchQueryRecord to a local index
+     *
+     * @param records list of {@link SearchQueryRecord}
+     */
+    @Override
+    public void export(final List<SearchQueryRecord> records) {
+        if (records == null || records.size() == 0) {
+            return;
+        }
+        try {
+            final String index = getDateTimeFromFormat();
+            final BulkRequestBuilder bulkRequestBuilder = client.prepareBulk().setTimeout(TimeValue.timeValueMinutes(1));
+            for (SearchQueryRecord record : records) {
+                bulkRequestBuilder.add(
+                    new IndexRequest(index).source(record.toXContent(XContentFactory.jsonBuilder(), ToXContent.EMPTY_PARAMS))
+                );
+            }
+            bulkRequestBuilder.execute(new ActionListener<BulkResponse>() {
+                @Override
+                public void onResponse(BulkResponse bulkItemResponses) {}
+
+                @Override
+                public void onFailure(Exception e) {
+                    logger.error("Failed to execute bulk operation for query insights data: ", e);
+                }
+            });
+        } catch (final Exception e) {
+            logger.error("Unable to index query insights data: ", e);
+        }
+    }
+
+    /**
+     * Close the exporter sink
+     */
+    @Override
+    public void close() {
+        logger.debug("Closing the LocalIndexExporter..");
+    }
+
+    private String getDateTimeFromFormat() {
+        return indexPattern.print(DateTime.now(DateTimeZone.UTC));
+    }
+}
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporter.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporter.java
new file mode 100644
index 0000000000000..42e5354eb1640
--- /dev/null
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporter.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.insights.core.exporter;
+
+import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
+
+import java.io.Closeable;
+import java.util.List;
+
+/**
+ * Base interface for Query Insights exporters
+ */
+public interface QueryInsightsExporter extends Closeable {
+    /**
+     * Export a list of SearchQueryRecord to the exporter sink
+     *
+     * @param records list of {@link SearchQueryRecord}
+     */
+    void export(final List<SearchQueryRecord> records);
+}
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporterFactory.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporterFactory.java
new file mode 100644
index 0000000000000..016911761a3d0
--- /dev/null
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporterFactory.java
@@ -0,0 +1,143 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.insights.core.exporter;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.client.Client;
+import org.opensearch.common.settings.Settings;
+import org.joda.time.format.DateTimeFormat;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Locale;
+import java.util.Set;
+
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.DEFAULT_TOP_N_QUERIES_INDEX_PATTERN;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.DEFAULT_TOP_QUERIES_EXPORTER_TYPE;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.EXPORTER_TYPE;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.EXPORT_INDEX;
+
+/**
+ * Factory class for validating and creating exporters based on provided settings
+ */
+public class QueryInsightsExporterFactory {
+    /**
+     * Logger of the query insights exporter factory
+     */
+    private final Logger logger = LogManager.getLogger();
+    final private Client client;
+    final private Set<QueryInsightsExporter> exporters;
+
+    /**
+     * Constructor of QueryInsightsExporterFactory
+     *
+     * @param client OS client
+     */
+    public QueryInsightsExporterFactory(final Client client) {
+        this.client = client;
+        this.exporters = new HashSet<>();
+    }
+
+    /**
+     * Validate exporter sink config
+     *
+     * @param settings exporter sink config {@link Settings}
+     * @throws IllegalArgumentException if provided exporter sink config settings are invalid
+     */
+    public void validateExporterConfig(final Settings settings) throws IllegalArgumentException {
+        // Disable exporter if the EXPORTER_TYPE setting is null
+        if (settings.get(EXPORTER_TYPE) == null) {
+            return;
+        }
+        SinkType type;
+        try {
+            type = SinkType.parse(settings.get(EXPORTER_TYPE, DEFAULT_TOP_QUERIES_EXPORTER_TYPE));
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException(
+                String.format(
+                    Locale.ROOT,
+                    "Invalid exporter type [%s], type should be one of %s",
+                    settings.get(EXPORTER_TYPE),
+                    SinkType.allSinkTypes()
+                )
+            );
+        }
+        switch (type) {
+            case LOCAL_INDEX:
+                final String indexPattern = settings.get(EXPORT_INDEX, DEFAULT_TOP_N_QUERIES_INDEX_PATTERN);
+                if (indexPattern.length() == 0) {
+                    throw new IllegalArgumentException("Empty index pattern configured for the exporter");
+                }
+                try {
+                    DateTimeFormat.forPattern(indexPattern);
+                } catch (Exception e) {
+                    throw new IllegalArgumentException(
+                        String.format(Locale.ROOT, "Invalid index pattern [%s] configured for the exporter", indexPattern)
+                    );
+                }
+        }
+    }
+
+    /**
+     * Create an exporter based on provided parameters
+     *
+     * @param type The type of exporter to create
+     * @param indexPattern the index pattern if creating a index exporter
+     * @return QueryInsightsExporter the created exporter sink
+     */
+    public QueryInsightsExporter createExporter(SinkType type, String indexPattern) {
+        if (SinkType.LOCAL_INDEX.equals(type)) {
+            QueryInsightsExporter exporter = new LocalIndexExporter(client, DateTimeFormat.forPattern(indexPattern));
+            this.exporters.add(exporter);
+            return exporter;
+        }
+        return DebugExporter.getInstance();
+    }
+
+    /**
+     * Update an exporter based on provided parameters
+     *
+     * @param exporter The exporter to update
+     * @param indexPattern the index pattern if creating a index exporter
+     * @return QueryInsightsExporter the updated exporter sink
+     */
+    public QueryInsightsExporter updateExporter(QueryInsightsExporter exporter, String indexPattern) {
+        if (exporter.getClass() == LocalIndexExporter.class) {
+            ((LocalIndexExporter) exporter).setIndexPattern(DateTimeFormat.forPattern(indexPattern));
+        }
+        return exporter;
+    }
+
+    /**
+     * Close an exporter
+     *
+     * @param exporter the exporter to close
+     */
+    public void closeExporter(QueryInsightsExporter exporter) throws IOException {
+        if (exporter != null) {
+            exporter.close();
+            this.exporters.remove(exporter);
+        }
+    }
+
+    /**
+     * Close all exporters
+     *
+     */
+    public void closeAllExporters() {
+        for (QueryInsightsExporter exporter : exporters) {
+            try {
+                closeExporter(exporter);
+            } catch (IOException e) {
+                logger.error("Fail to close query insights exporter, error: ", e);
+            }
+        }
+    }
+}
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/SinkType.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/SinkType.java
new file mode 100644
index 0000000000000..c90c9c76b6706
--- /dev/null
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/SinkType.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.insights.core.exporter;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Type of supported sinks
+ */
+public enum SinkType {
+    /** debug exporter */
+    DEBUG("debug"),
+    /** local index exporter */
+    LOCAL_INDEX("local_index");
+
+    private final String type;
+
+    SinkType(String type) {
+        this.type = type;
+    }
+
+    @Override
+    public String toString() {
+        return type;
+    }
+
+    /**
+     * Parse SinkType from String
+     * @param type the String representation of the SinkType
+     * @return SinkType
+     */
+    public static SinkType parse(final String type) {
+        return valueOf(type.toUpperCase(Locale.ROOT));
+    }
+
+    /**
+     * Get all valid SinkTypes
+     *
+     * @return A set contains all valid SinkTypes
+     */
+    public static Set<SinkType> allSinkTypes() {
+        return Arrays.stream(values()).collect(Collectors.toSet());
+    }
+
+    /**
+     * Get Sink type from exporter
+     *
+     * @param exporter the {@link QueryInsightsExporter}
+     * @return SinkType associated with this exporter
+     */
+    public static SinkType getSinkTypeFromExporter(QueryInsightsExporter exporter) {
+        if (exporter.getClass().equals(LocalIndexExporter.class)) {
+            return SinkType.LOCAL_INDEX;
+        }
+        return SinkType.DEBUG;
+    }
+}
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/package-info.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/package-info.java
new file mode 100644
index 0000000000000..7164411194f85
--- /dev/null
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/exporter/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Query Insights exporter
+ */
+package org.opensearch.plugin.insights.core.exporter;
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/listener/QueryInsightsListener.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/listener/QueryInsightsListener.java
index 9ec8673147c38..a1f810ad5987c 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/listener/QueryInsightsListener.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/listener/QueryInsightsListener.java
@@ -14,23 +14,27 @@
 import org.opensearch.action.search.SearchRequest;
 import org.opensearch.action.search.SearchRequestContext;
 import org.opensearch.action.search.SearchRequestOperationsListener;
+import org.opensearch.action.search.SearchTask;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.inject.Inject;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceInfo;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.plugin.insights.core.service.QueryInsightsService;
 import org.opensearch.plugin.insights.rules.model.Attribute;
 import org.opensearch.plugin.insights.rules.model.MetricType;
 import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
+import org.opensearch.tasks.Task;
 
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
-import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.TOP_N_LATENCY_QUERIES_ENABLED;
-import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.TOP_N_LATENCY_QUERIES_SIZE;
-import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.TOP_N_LATENCY_QUERIES_WINDOW_SIZE;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.getTopNEnabledSetting;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.getTopNSizeSetting;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.getTopNWindowSizeSetting;
 
 /**
  * The listener for query insights services.
@@ -45,6 +49,7 @@ public final class QueryInsightsListener extends SearchRequestOperationsListener
     private static final Logger log = LogManager.getLogger(QueryInsightsListener.class);
 
     private final QueryInsightsService queryInsightsService;
+    private final ClusterService clusterService;
 
     /**
      * Constructor for QueryInsightsListener
@@ -54,26 +59,32 @@ public final class QueryInsightsListener extends SearchRequestOperationsListener
      */
     @Inject
     public QueryInsightsListener(final ClusterService clusterService, final QueryInsightsService queryInsightsService) {
+        this.clusterService = clusterService;
         this.queryInsightsService = queryInsightsService;
-        clusterService.getClusterSettings()
-            .addSettingsUpdateConsumer(TOP_N_LATENCY_QUERIES_ENABLED, v -> this.setEnableTopQueries(MetricType.LATENCY, v));
-        clusterService.getClusterSettings()
-            .addSettingsUpdateConsumer(
-                TOP_N_LATENCY_QUERIES_SIZE,
-                v -> this.queryInsightsService.getTopQueriesService(MetricType.LATENCY).setTopNSize(v),
-                v -> this.queryInsightsService.getTopQueriesService(MetricType.LATENCY).validateTopNSize(v)
-            );
-        clusterService.getClusterSettings()
-            .addSettingsUpdateConsumer(
-                TOP_N_LATENCY_QUERIES_WINDOW_SIZE,
-                v -> this.queryInsightsService.getTopQueriesService(MetricType.LATENCY).setWindowSize(v),
-                v -> this.queryInsightsService.getTopQueriesService(MetricType.LATENCY).validateWindowSize(v)
-            );
-        this.setEnableTopQueries(MetricType.LATENCY, clusterService.getClusterSettings().get(TOP_N_LATENCY_QUERIES_ENABLED));
-        this.queryInsightsService.getTopQueriesService(MetricType.LATENCY)
-            .setTopNSize(clusterService.getClusterSettings().get(TOP_N_LATENCY_QUERIES_SIZE));
-        this.queryInsightsService.getTopQueriesService(MetricType.LATENCY)
-            .setWindowSize(clusterService.getClusterSettings().get(TOP_N_LATENCY_QUERIES_WINDOW_SIZE));
+        // Setting endpoints set up for top n queries, including enabling top n queries, window size and top n size
+        // Expected metricTypes are Latency, CPU and Memory.
+        for (MetricType type : MetricType.allMetricTypes()) {
+            clusterService.getClusterSettings()
+                .addSettingsUpdateConsumer(getTopNEnabledSetting(type), v -> this.setEnableTopQueries(type, v));
+            clusterService.getClusterSettings()
+                .addSettingsUpdateConsumer(
+                    getTopNSizeSetting(type),
+                    v -> this.queryInsightsService.setTopNSize(type, v),
+                    v -> this.queryInsightsService.validateTopNSize(type, v)
+                );
+            clusterService.getClusterSettings()
+                .addSettingsUpdateConsumer(
+                    getTopNWindowSizeSetting(type),
+                    v -> this.queryInsightsService.setWindowSize(type, v),
+                    v -> this.queryInsightsService.validateWindowSize(type, v)
+                );
+
+            this.setEnableTopQueries(type, clusterService.getClusterSettings().get(getTopNEnabledSetting(type)));
+            this.queryInsightsService.validateTopNSize(type, clusterService.getClusterSettings().get(getTopNSizeSetting(type)));
+            this.queryInsightsService.setTopNSize(type, clusterService.getClusterSettings().get(getTopNSizeSetting(type)));
+            this.queryInsightsService.validateWindowSize(type, clusterService.getClusterSettings().get(getTopNWindowSizeSetting(type)));
+            this.queryInsightsService.setWindowSize(type, clusterService.getClusterSettings().get(getTopNWindowSizeSetting(type)));
+        }
     }
 
     /**
@@ -123,6 +134,27 @@ public void onRequestStart(SearchRequestContext searchRequestContext) {}
 
     @Override
     public void onRequestEnd(final SearchPhaseContext context, final SearchRequestContext searchRequestContext) {
+        constructSearchQueryRecord(context, searchRequestContext);
+    }
+
+    @Override
+    public void onRequestFailure(final SearchPhaseContext context, final SearchRequestContext searchRequestContext) {
+        constructSearchQueryRecord(context, searchRequestContext);
+    }
+
+    private void constructSearchQueryRecord(final SearchPhaseContext context, final SearchRequestContext searchRequestContext) {
+        SearchTask searchTask = context.getTask();
+        List<TaskResourceInfo> tasksResourceUsages = searchRequestContext.getPhaseResourceUsage();
+        tasksResourceUsages.add(
+            new TaskResourceInfo(
+                searchTask.getAction(),
+                searchTask.getId(),
+                searchTask.getParentTaskId().getId(),
+                clusterService.localNode().getId(),
+                searchTask.getTotalResourceStats()
+            )
+        );
+
         final SearchRequest request = context.getRequest();
         try {
             Map<MetricType, Number> measurements = new HashMap<>();
@@ -132,16 +164,39 @@ public void onRequestEnd(final SearchPhaseContext context, final SearchRequestCo
                     TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - searchRequestContext.getAbsoluteStartNanos())
                 );
             }
+            if (queryInsightsService.isCollectionEnabled(MetricType.CPU)) {
+                measurements.put(
+                    MetricType.CPU,
+                    tasksResourceUsages.stream().map(a -> a.getTaskResourceUsage().getCpuTimeInNanos()).mapToLong(Long::longValue).sum()
+                );
+            }
+            if (queryInsightsService.isCollectionEnabled(MetricType.MEMORY)) {
+                measurements.put(
+                    MetricType.MEMORY,
+                    tasksResourceUsages.stream().map(a -> a.getTaskResourceUsage().getMemoryInBytes()).mapToLong(Long::longValue).sum()
+                );
+            }
             Map<Attribute, Object> attributes = new HashMap<>();
             attributes.put(Attribute.SEARCH_TYPE, request.searchType().toString().toLowerCase(Locale.ROOT));
             attributes.put(Attribute.SOURCE, request.source().toString(FORMAT_PARAMS));
             attributes.put(Attribute.TOTAL_SHARDS, context.getNumShards());
             attributes.put(Attribute.INDICES, request.indices());
             attributes.put(Attribute.PHASE_LATENCY_MAP, searchRequestContext.phaseTookMap());
+            attributes.put(Attribute.TASK_RESOURCE_USAGES, tasksResourceUsages);
+
+            Map<String, Object> labels = new HashMap<>();
+            // Retrieve user provided label if exists
+            String userProvidedLabel = context.getTask().getHeader(Task.X_OPAQUE_ID);
+            if (userProvidedLabel != null) {
+                labels.put(Task.X_OPAQUE_ID, userProvidedLabel);
+            }
+            attributes.put(Attribute.LABELS, labels);
+            // construct SearchQueryRecord from attributes and measurements
             SearchQueryRecord record = new SearchQueryRecord(request.getOrCreateAbsoluteStartMillis(), measurements, attributes);
             queryInsightsService.addRecord(record);
         } catch (Exception e) {
             log.error(String.format(Locale.ROOT, "fail to ingest query insight data, error: %s", e));
         }
     }
+
 }
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/service/QueryInsightsService.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/service/QueryInsightsService.java
index 525ca0d4a3d33..c63430a1a726c 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/service/QueryInsightsService.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/service/QueryInsightsService.java
@@ -8,14 +8,20 @@
 
 package org.opensearch.plugin.insights.core.service;
 
+import org.opensearch.client.Client;
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.plugin.insights.core.exporter.QueryInsightsExporterFactory;
 import org.opensearch.plugin.insights.rules.model.MetricType;
 import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
 import org.opensearch.plugin.insights.settings.QueryInsightsSettings;
 import org.opensearch.threadpool.Scheduler;
 import org.opensearch.threadpool.ThreadPool;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -23,6 +29,8 @@
 import java.util.Map;
 import java.util.concurrent.LinkedBlockingQueue;
 
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.getExporterSettings;
+
 /**
  * Service responsible for gathering, analyzing, storing and exporting
  * information related to search queries
@@ -56,21 +64,37 @@ public class QueryInsightsService extends AbstractLifecycleComponent {
      */
     protected volatile Scheduler.Cancellable scheduledFuture;
 
+    /**
+     * Query Insights exporter factory
+     */
+    final QueryInsightsExporterFactory queryInsightsExporterFactory;
+
     /**
      * Constructor of the QueryInsightsService
      *
-     * @param threadPool     The OpenSearch thread pool to run async tasks
+     * @param clusterSettings OpenSearch cluster level settings
+     * @param threadPool The OpenSearch thread pool to run async tasks
+     * @param client OS client
      */
     @Inject
-    public QueryInsightsService(final ThreadPool threadPool) {
+    public QueryInsightsService(final ClusterSettings clusterSettings, final ThreadPool threadPool, final Client client) {
         enableCollect = new HashMap<>();
         queryRecordsQueue = new LinkedBlockingQueue<>(QueryInsightsSettings.QUERY_RECORD_QUEUE_CAPACITY);
+        this.threadPool = threadPool;
+        this.queryInsightsExporterFactory = new QueryInsightsExporterFactory(client);
+        // initialize top n queries services and configurations consumers
         topQueriesServices = new HashMap<>();
         for (MetricType metricType : MetricType.allMetricTypes()) {
             enableCollect.put(metricType, false);
-            topQueriesServices.put(metricType, new TopQueriesService(metricType));
+            topQueriesServices.put(metricType, new TopQueriesService(metricType, threadPool, queryInsightsExporterFactory));
+        }
+        for (MetricType type : MetricType.allMetricTypes()) {
+            clusterSettings.addSettingsUpdateConsumer(
+                getExporterSettings(type),
+                (settings -> setExporter(type, settings)),
+                (settings -> validateExporterConfig(type, settings))
+            );
         }
-        this.threadPool = threadPool;
     }
 
     /**
@@ -157,6 +181,78 @@ public boolean isEnabled() {
         return false;
     }
 
+    /**
+     * Validate the window size config for a metricType
+     *
+     * @param type {@link MetricType}
+     * @param windowSize {@link TimeValue}
+     */
+    public void validateWindowSize(final MetricType type, final TimeValue windowSize) {
+        if (topQueriesServices.containsKey(type)) {
+            topQueriesServices.get(type).validateWindowSize(windowSize);
+        }
+    }
+
+    /**
+     * Set window size for a metricType
+     *
+     * @param type {@link MetricType}
+     * @param windowSize {@link TimeValue}
+     */
+    public void setWindowSize(final MetricType type, final TimeValue windowSize) {
+        if (topQueriesServices.containsKey(type)) {
+            topQueriesServices.get(type).setWindowSize(windowSize);
+        }
+    }
+
+    /**
+     * Validate the top n size config for a metricType
+     *
+     * @param type {@link MetricType}
+     * @param topNSize top n size
+     */
+    public void validateTopNSize(final MetricType type, final int topNSize) {
+        if (topQueriesServices.containsKey(type)) {
+            topQueriesServices.get(type).validateTopNSize(topNSize);
+        }
+    }
+
+    /**
+     * Set the top n size config for a metricType
+     *
+     * @param type {@link MetricType}
+     * @param topNSize top n size
+     */
+    public void setTopNSize(final MetricType type, final int topNSize) {
+        if (topQueriesServices.containsKey(type)) {
+            topQueriesServices.get(type).setTopNSize(topNSize);
+        }
+    }
+
+    /**
+     * Set the exporter config for a metricType
+     *
+     * @param type {@link MetricType}
+     * @param settings exporter settings
+     */
+    public void setExporter(final MetricType type, final Settings settings) {
+        if (topQueriesServices.containsKey(type)) {
+            topQueriesServices.get(type).setExporter(settings);
+        }
+    }
+
+    /**
+     * Validate the exporter config for a metricType
+     *
+     * @param type {@link MetricType}
+     * @param settings exporter settings
+     */
+    public void validateExporterConfig(final MetricType type, final Settings settings) {
+        if (topQueriesServices.containsKey(type)) {
+            topQueriesServices.get(type).validateExporterConfig(settings);
+        }
+    }
+
     @Override
     protected void doStart() {
         if (isEnabled()) {
@@ -176,5 +272,12 @@ protected void doStop() {
     }
 
     @Override
-    protected void doClose() {}
+    protected void doClose() throws IOException {
+        // close all top n queries service
+        for (TopQueriesService topQueriesService : topQueriesServices.values()) {
+            topQueriesService.close();
+        }
+        // close any unclosed resources
+        queryInsightsExporterFactory.closeAllExporters();
+    }
 }
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/service/TopQueriesService.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/service/TopQueriesService.java
index d2c30cbdf98e7..bbe8b8fc40dac 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/service/TopQueriesService.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/core/service/TopQueriesService.java
@@ -8,11 +8,19 @@
 
 package org.opensearch.plugin.insights.core.service;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.plugin.insights.core.exporter.QueryInsightsExporter;
+import org.opensearch.plugin.insights.core.exporter.QueryInsightsExporterFactory;
+import org.opensearch.plugin.insights.core.exporter.SinkType;
 import org.opensearch.plugin.insights.rules.model.MetricType;
 import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
 import org.opensearch.plugin.insights.settings.QueryInsightsSettings;
+import org.opensearch.threadpool.ThreadPool;
 
+import java.io.IOException;
 import java.time.Instant;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
@@ -27,6 +35,12 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.DEFAULT_TOP_N_QUERIES_INDEX_PATTERN;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.DEFAULT_TOP_QUERIES_EXPORTER_TYPE;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.EXPORTER_TYPE;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.EXPORT_INDEX;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.QUERY_INSIGHTS_EXECUTOR;
+
 /**
  * Service responsible for gathering and storing top N queries
  * with high latency or resource usage
@@ -34,6 +48,10 @@
  * @opensearch.internal
  */
 public class TopQueriesService {
+    /**
+     * Logger of the local index exporter
+     */
+    private final Logger logger = LogManager.getLogger();
     private boolean enabled;
     /**
      * The metric type to measure top n queries
@@ -63,12 +81,34 @@ public class TopQueriesService {
      */
     private final AtomicReference<List<SearchQueryRecord>> topQueriesHistorySnapshot;
 
-    TopQueriesService(final MetricType metricType) {
+    /**
+     * Factory for validating and creating exporters
+     */
+    private final QueryInsightsExporterFactory queryInsightsExporterFactory;
+
+    /**
+     * The internal OpenSearch thread pool that execute async processing and exporting tasks
+     */
+    private final ThreadPool threadPool;
+
+    /**
+     * Exporter for exporting top queries data
+     */
+    private QueryInsightsExporter exporter;
+
+    TopQueriesService(
+        final MetricType metricType,
+        final ThreadPool threadPool,
+        final QueryInsightsExporterFactory queryInsightsExporterFactory
+    ) {
         this.enabled = false;
         this.metricType = metricType;
+        this.threadPool = threadPool;
+        this.queryInsightsExporterFactory = queryInsightsExporterFactory;
         this.topNSize = QueryInsightsSettings.DEFAULT_TOP_N_SIZE;
         this.windowSize = QueryInsightsSettings.DEFAULT_WINDOW_SIZE;
         this.windowStart = -1L;
+        this.exporter = null;
         topQueriesStore = new PriorityQueue<>(topNSize, (a, b) -> SearchQueryRecord.compare(a, b, metricType));
         topQueriesCurrentSnapshot = new AtomicReference<>(new ArrayList<>());
         topQueriesHistorySnapshot = new AtomicReference<>(new ArrayList<>());
@@ -98,17 +138,15 @@ public int getTopNSize() {
      * @param size the wanted top N size
      */
     public void validateTopNSize(final int size) {
-        if (size > QueryInsightsSettings.MAX_N_SIZE) {
+        if (size < 1 || size > QueryInsightsSettings.MAX_N_SIZE) {
             throw new IllegalArgumentException(
                 "Top N size setting for ["
                     + metricType
                     + "]"
-                    + " should be smaller than max top N size ["
+                    + " should be between 1 and "
                     + QueryInsightsSettings.MAX_N_SIZE
-                    + "was ("
+                    + ", was ("
                     + size
-                    + " > "
-                    + QueryInsightsSettings.MAX_N_SIZE
                     + ")"
             );
         }
@@ -169,6 +207,47 @@ public void validateWindowSize(final TimeValue windowSize) {
         }
     }
 
+    /**
+     * Set up the top queries exporter based on provided settings
+     *
+     * @param settings exporter config {@link Settings}
+     */
+    public void setExporter(final Settings settings) {
+        if (settings.get(EXPORTER_TYPE) != null) {
+            SinkType expectedType = SinkType.parse(settings.get(EXPORTER_TYPE, DEFAULT_TOP_QUERIES_EXPORTER_TYPE));
+            if (exporter != null && expectedType == SinkType.getSinkTypeFromExporter(exporter)) {
+                queryInsightsExporterFactory.updateExporter(exporter, settings.get(EXPORT_INDEX, DEFAULT_TOP_N_QUERIES_INDEX_PATTERN));
+            } else {
+                try {
+                    queryInsightsExporterFactory.closeExporter(this.exporter);
+                } catch (IOException e) {
+                    logger.error("Fail to close the current exporter when updating exporter, error: ", e);
+                }
+                this.exporter = queryInsightsExporterFactory.createExporter(
+                    SinkType.parse(settings.get(EXPORTER_TYPE, DEFAULT_TOP_QUERIES_EXPORTER_TYPE)),
+                    settings.get(EXPORT_INDEX, DEFAULT_TOP_N_QUERIES_INDEX_PATTERN)
+                );
+            }
+        } else {
+            // Disable exporter if exporter type is set to null
+            try {
+                queryInsightsExporterFactory.closeExporter(this.exporter);
+                this.exporter = null;
+            } catch (IOException e) {
+                logger.error("Fail to close the current exporter when disabling exporter, error: ", e);
+            }
+        }
+    }
+
+    /**
+     * Validate provided settings for top queries exporter
+     *
+     * @param settings settings exporter config {@link Settings}
+     */
+    public void validateExporterConfig(Settings settings) {
+        queryInsightsExporterFactory.validateExporterConfig(settings);
+    }
+
     /**
      * Get all top queries records that are in the current top n queries store
      * Optionally include top N records from the last window.
@@ -254,6 +333,10 @@ private void rotateWindowIfNecessary(final long newWindowStart) {
             topQueriesStore.clear();
             topQueriesCurrentSnapshot.set(new ArrayList<>());
             windowStart = newWindowStart;
+            // export to the configured sink
+            if (exporter != null) {
+                threadPool.executor(QUERY_INSIGHTS_EXECUTOR).execute(() -> exporter.export(history));
+            }
         }
     }
 
@@ -279,4 +362,11 @@ private long calculateWindowStart(final long timestamp) {
     public List<SearchQueryRecord> getTopQueriesCurrentSnapshot() {
         return topQueriesCurrentSnapshot.get();
     }
+
+    /**
+     * Close the top n queries service
+     */
+    public void close() throws IOException {
+        queryInsightsExporterFactory.closeExporter(this.exporter);
+    }
 }
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/Attribute.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/Attribute.java
index c1d17edf9ff14..dcdb085fdc6fa 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/Attribute.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/Attribute.java
@@ -43,7 +43,15 @@ public enum Attribute {
     /**
      * The node id for this request
      */
-    NODE_ID;
+    NODE_ID,
+    /**
+     * Tasks level resource usages in this request
+     */
+    TASK_RESOURCE_USAGES,
+    /**
+     * Custom search request labels
+     */
+    LABELS;
 
     /**
      * Read an Attribute from a StreamInput
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/MetricType.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/MetricType.java
index cdd090fbf4804..4694c757f4ef2 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/MetricType.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/MetricType.java
@@ -35,7 +35,7 @@ public enum MetricType implements Comparator<Number> {
     /**
      * JVM heap usage metric type
      */
-    JVM;
+    MEMORY;
 
     /**
      * Read a MetricType from a StreamInput
@@ -93,10 +93,9 @@ public static Set<MetricType> allMetricTypes() {
     public int compare(final Number a, final Number b) {
         switch (this) {
             case LATENCY:
-                return Long.compare(a.longValue(), b.longValue());
-            case JVM:
             case CPU:
-                return Double.compare(a.doubleValue(), b.doubleValue());
+            case MEMORY:
+                return Long.compare(a.longValue(), b.longValue());
         }
         return -1;
     }
@@ -110,10 +109,9 @@ public int compare(final Number a, final Number b) {
     Number parseValue(final Object o) {
         switch (this) {
             case LATENCY:
-                return (Long) o;
-            case JVM:
             case CPU:
-                return (Double) o;
+            case MEMORY:
+                return (Long) o;
             default:
                 return (Number) o;
         }
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/SearchQueryRecord.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/SearchQueryRecord.java
index 060711edb5580..fec00a680ae58 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/SearchQueryRecord.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/model/SearchQueryRecord.java
@@ -8,9 +8,11 @@
 
 package org.opensearch.plugin.insights.rules.model;
 
+import org.opensearch.core.common.Strings;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -173,4 +175,9 @@ public boolean equals(final Object o) {
     public int hashCode() {
         return Objects.hash(timestamp, measurements, attributes);
     }
+
+    @Override
+    public String toString() {
+        return Strings.toString(MediaTypeRegistry.JSON, this);
+    }
 }
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/transport/top_queries/TransportTopQueriesAction.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/transport/top_queries/TransportTopQueriesAction.java
index 4b4a277263c0f..20465102d58ac 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/transport/top_queries/TransportTopQueriesAction.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/rules/transport/top_queries/TransportTopQueriesAction.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.plugin.insights.rules.transport.top_queries;
 
-import org.opensearch.OpenSearchException;
 import org.opensearch.action.FailedNodeException;
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.nodes.BaseNodeRequest;
@@ -22,14 +21,12 @@
 import org.opensearch.plugin.insights.rules.action.top_queries.TopQueriesAction;
 import org.opensearch.plugin.insights.rules.action.top_queries.TopQueriesRequest;
 import org.opensearch.plugin.insights.rules.action.top_queries.TopQueriesResponse;
-import org.opensearch.plugin.insights.rules.model.MetricType;
 import org.opensearch.plugin.insights.settings.QueryInsightsSettings;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
 import java.util.List;
-import java.util.Locale;
 
 /**
  * Transport action for cluster/node level top queries information.
@@ -81,17 +78,18 @@ protected TopQueriesResponse newResponse(
         final List<TopQueries> responses,
         final List<FailedNodeException> failures
     ) {
-        if (topQueriesRequest.getMetricType() == MetricType.LATENCY) {
-            return new TopQueriesResponse(
-                clusterService.getClusterName(),
-                responses,
-                failures,
-                clusterService.getClusterSettings().get(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_SIZE),
-                MetricType.LATENCY
-            );
-        } else {
-            throw new OpenSearchException(String.format(Locale.ROOT, "invalid metric type %s", topQueriesRequest.getMetricType()));
+        int size;
+        switch (topQueriesRequest.getMetricType()) {
+            case CPU:
+                size = clusterService.getClusterSettings().get(QueryInsightsSettings.TOP_N_CPU_QUERIES_SIZE);
+                break;
+            case MEMORY:
+                size = clusterService.getClusterSettings().get(QueryInsightsSettings.TOP_N_MEMORY_QUERIES_SIZE);
+                break;
+            default:
+                size = clusterService.getClusterSettings().get(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_SIZE);
         }
+        return new TopQueriesResponse(clusterService.getClusterName(), responses, failures, size, topQueriesRequest.getMetricType());
     }
 
     @Override
@@ -107,15 +105,10 @@ protected TopQueries newNodeResponse(final StreamInput in) throws IOException {
     @Override
     protected TopQueries nodeOperation(final NodeRequest nodeRequest) {
         final TopQueriesRequest request = nodeRequest.request;
-        if (request.getMetricType() == MetricType.LATENCY) {
-            return new TopQueries(
-                clusterService.localNode(),
-                queryInsightsService.getTopQueriesService(MetricType.LATENCY).getTopQueriesRecords(true)
-            );
-        } else {
-            throw new OpenSearchException(String.format(Locale.ROOT, "invalid metric type %s", request.getMetricType()));
-        }
-
+        return new TopQueries(
+            clusterService.localNode(),
+            queryInsightsService.getTopQueriesService(request.getMetricType()).getTopQueriesRecords(true)
+        );
     }
 
     /**
diff --git a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/settings/QueryInsightsSettings.java b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/settings/QueryInsightsSettings.java
index 52cc1fbde790f..25309b5721792 100644
--- a/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/settings/QueryInsightsSettings.java
+++ b/plugins/query-insights/src/main/java/org/opensearch/plugin/insights/settings/QueryInsightsSettings.java
@@ -9,7 +9,10 @@
 package org.opensearch.plugin.insights.settings;
 
 import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.plugin.insights.core.exporter.SinkType;
+import org.opensearch.plugin.insights.rules.model.MetricType;
 
 import java.util.Arrays;
 import java.util.HashSet;
@@ -79,6 +82,10 @@ public class QueryInsightsSettings {
     public static final String TOP_N_QUERIES_SETTING_PREFIX = "search.insights.top_queries";
     /** Default prefix for top N queries by latency feature */
     public static final String TOP_N_LATENCY_QUERIES_PREFIX = TOP_N_QUERIES_SETTING_PREFIX + ".latency";
+    /** Default prefix for top N queries by cpu feature */
+    public static final String TOP_N_CPU_QUERIES_PREFIX = TOP_N_QUERIES_SETTING_PREFIX + ".cpu";
+    /** Default prefix for top N queries by memory feature */
+    public static final String TOP_N_MEMORY_QUERIES_PREFIX = TOP_N_QUERIES_SETTING_PREFIX + ".memory";
     /**
      * Boolean setting for enabling top queries by latency.
      */
@@ -109,6 +116,187 @@ public class QueryInsightsSettings {
         Setting.Property.Dynamic
     );
 
+    /**
+     * Boolean setting for enabling top queries by cpu.
+     */
+    public static final Setting<Boolean> TOP_N_CPU_QUERIES_ENABLED = Setting.boolSetting(
+        TOP_N_CPU_QUERIES_PREFIX + ".enabled",
+        false,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Int setting to define the top n size for top queries by cpu.
+     */
+    public static final Setting<Integer> TOP_N_CPU_QUERIES_SIZE = Setting.intSetting(
+        TOP_N_CPU_QUERIES_PREFIX + ".top_n_size",
+        DEFAULT_TOP_N_SIZE,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Time setting to define the window size in seconds for top queries by cpu.
+     */
+    public static final Setting<TimeValue> TOP_N_CPU_QUERIES_WINDOW_SIZE = Setting.positiveTimeSetting(
+        TOP_N_CPU_QUERIES_PREFIX + ".window_size",
+        DEFAULT_WINDOW_SIZE,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    /**
+     * Boolean setting for enabling top queries by memory.
+     */
+    public static final Setting<Boolean> TOP_N_MEMORY_QUERIES_ENABLED = Setting.boolSetting(
+        TOP_N_MEMORY_QUERIES_PREFIX + ".enabled",
+        false,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Int setting to define the top n size for top queries by memory.
+     */
+    public static final Setting<Integer> TOP_N_MEMORY_QUERIES_SIZE = Setting.intSetting(
+        TOP_N_MEMORY_QUERIES_PREFIX + ".top_n_size",
+        DEFAULT_TOP_N_SIZE,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Time setting to define the window size in seconds for top queries by memory.
+     */
+    public static final Setting<TimeValue> TOP_N_MEMORY_QUERIES_WINDOW_SIZE = Setting.positiveTimeSetting(
+        TOP_N_MEMORY_QUERIES_PREFIX + ".window_size",
+        DEFAULT_WINDOW_SIZE,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    /**
+     * Config key for exporter type
+     */
+    public static final String EXPORTER_TYPE = "type";
+    /**
+     * Config key for export index
+     */
+    public static final String EXPORT_INDEX = "config.index";
+
+    /**
+     * Settings and defaults for top queries exporters
+     */
+    private static final String TOP_N_LATENCY_QUERIES_EXPORTER_PREFIX = TOP_N_LATENCY_QUERIES_PREFIX + ".exporter.";
+    /**
+     * Prefix for top n queries by cpu exporters
+     */
+    private static final String TOP_N_CPU_QUERIES_EXPORTER_PREFIX = TOP_N_CPU_QUERIES_PREFIX + ".exporter.";
+    /**
+     * Prefix for top n queries by memory exporters
+     */
+    private static final String TOP_N_MEMORY_QUERIES_EXPORTER_PREFIX = TOP_N_MEMORY_QUERIES_PREFIX + ".exporter.";
+    /**
+     * Default index pattern of top n queries
+     */
+    public static final String DEFAULT_TOP_N_QUERIES_INDEX_PATTERN = "'top_queries-'YYYY.MM.dd";
+    /**
+     * Default exporter type of top queries
+     */
+    public static final String DEFAULT_TOP_QUERIES_EXPORTER_TYPE = SinkType.LOCAL_INDEX.toString();
+
+    /**
+     * Settings for the exporter of top latency queries
+     */
+    public static final Setting<Settings> TOP_N_LATENCY_EXPORTER_SETTINGS = Setting.groupSetting(
+        TOP_N_LATENCY_QUERIES_EXPORTER_PREFIX,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Settings for the exporter of top cpu queries
+     */
+    public static final Setting<Settings> TOP_N_CPU_EXPORTER_SETTINGS = Setting.groupSetting(
+        TOP_N_CPU_QUERIES_EXPORTER_PREFIX,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Settings for the exporter of top cpu queries
+     */
+    public static final Setting<Settings> TOP_N_MEMORY_EXPORTER_SETTINGS = Setting.groupSetting(
+        TOP_N_MEMORY_QUERIES_EXPORTER_PREFIX,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Get the enabled setting based on type
+     * @param type MetricType
+     * @return enabled setting
+     */
+    public static Setting<Boolean> getTopNEnabledSetting(MetricType type) {
+        switch (type) {
+            case CPU:
+                return TOP_N_CPU_QUERIES_ENABLED;
+            case MEMORY:
+                return TOP_N_MEMORY_QUERIES_ENABLED;
+            default:
+                return TOP_N_LATENCY_QUERIES_ENABLED;
+        }
+    }
+
+    /**
+     * Get the top n size setting based on type
+     * @param type MetricType
+     * @return top n size setting
+     */
+    public static Setting<Integer> getTopNSizeSetting(MetricType type) {
+        switch (type) {
+            case CPU:
+                return TOP_N_CPU_QUERIES_SIZE;
+            case MEMORY:
+                return TOP_N_MEMORY_QUERIES_SIZE;
+            default:
+                return TOP_N_LATENCY_QUERIES_SIZE;
+        }
+    }
+
+    /**
+     * Get the window size setting based on type
+     * @param type MetricType
+     * @return top n queries window size setting
+     */
+    public static Setting<TimeValue> getTopNWindowSizeSetting(MetricType type) {
+        switch (type) {
+            case CPU:
+                return TOP_N_CPU_QUERIES_WINDOW_SIZE;
+            case MEMORY:
+                return TOP_N_MEMORY_QUERIES_WINDOW_SIZE;
+            default:
+                return TOP_N_LATENCY_QUERIES_WINDOW_SIZE;
+        }
+    }
+
+    /**
+     * Get the exporter settings based on type
+     * @param type MetricType
+     * @return exporter setting
+     */
+    public static Setting<Settings> getExporterSettings(MetricType type) {
+        switch (type) {
+            case CPU:
+                return TOP_N_CPU_EXPORTER_SETTINGS;
+            case MEMORY:
+                return TOP_N_MEMORY_EXPORTER_SETTINGS;
+            default:
+                return TOP_N_LATENCY_EXPORTER_SETTINGS;
+        }
+    }
+
     /**
      * Default constructor
      */
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/QueryInsightsPluginTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/QueryInsightsPluginTests.java
index 273b69e483e8c..2efe9085a39ee 100644
--- a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/QueryInsightsPluginTests.java
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/QueryInsightsPluginTests.java
@@ -21,6 +21,7 @@
 import org.opensearch.plugin.insights.settings.QueryInsightsSettings;
 import org.opensearch.plugins.ActionPlugin;
 import org.opensearch.rest.RestHandler;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.ExecutorBuilder;
 import org.opensearch.threadpool.ScalingExecutorBuilder;
@@ -46,12 +47,8 @@ public void setup() {
         Settings.Builder settingsBuilder = Settings.builder();
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_ENABLED);
-        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_SIZE);
-        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_WINDOW_SIZE);
-
-        clusterService = new ClusterService(settings, clusterSettings, threadPool);
-
+        QueryInsightsTestUtils.registerAllQueryInsightsSettings(clusterSettings);
+        clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, threadPool);
     }
 
     public void testGetSettings() {
@@ -59,7 +56,16 @@ public void testGetSettings() {
             Arrays.asList(
                 QueryInsightsSettings.TOP_N_LATENCY_QUERIES_ENABLED,
                 QueryInsightsSettings.TOP_N_LATENCY_QUERIES_SIZE,
-                QueryInsightsSettings.TOP_N_LATENCY_QUERIES_WINDOW_SIZE
+                QueryInsightsSettings.TOP_N_LATENCY_QUERIES_WINDOW_SIZE,
+                QueryInsightsSettings.TOP_N_LATENCY_EXPORTER_SETTINGS,
+                QueryInsightsSettings.TOP_N_CPU_QUERIES_ENABLED,
+                QueryInsightsSettings.TOP_N_CPU_QUERIES_SIZE,
+                QueryInsightsSettings.TOP_N_CPU_QUERIES_WINDOW_SIZE,
+                QueryInsightsSettings.TOP_N_CPU_EXPORTER_SETTINGS,
+                QueryInsightsSettings.TOP_N_MEMORY_QUERIES_ENABLED,
+                QueryInsightsSettings.TOP_N_MEMORY_QUERIES_SIZE,
+                QueryInsightsSettings.TOP_N_MEMORY_QUERIES_WINDOW_SIZE,
+                QueryInsightsSettings.TOP_N_MEMORY_EXPORTER_SETTINGS
             ),
             queryInsightsPlugin.getSettings()
         );
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/QueryInsightsTestUtils.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/QueryInsightsTestUtils.java
index 870ef5b9c8be9..7fa4e9841c20e 100644
--- a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/QueryInsightsTestUtils.java
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/QueryInsightsTestUtils.java
@@ -10,6 +10,7 @@
 
 import org.opensearch.action.search.SearchType;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.util.Maps;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -17,6 +18,7 @@
 import org.opensearch.plugin.insights.rules.model.Attribute;
 import org.opensearch.plugin.insights.rules.model.MetricType;
 import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
+import org.opensearch.plugin.insights.settings.QueryInsightsSettings;
 import org.opensearch.test.VersionUtils;
 
 import java.io.IOException;
@@ -36,7 +38,6 @@
 import static org.opensearch.test.OpenSearchTestCase.random;
 import static org.opensearch.test.OpenSearchTestCase.randomAlphaOfLengthBetween;
 import static org.opensearch.test.OpenSearchTestCase.randomArray;
-import static org.opensearch.test.OpenSearchTestCase.randomDouble;
 import static org.opensearch.test.OpenSearchTestCase.randomIntBetween;
 import static org.opensearch.test.OpenSearchTestCase.randomLong;
 import static org.opensearch.test.OpenSearchTestCase.randomLongBetween;
@@ -63,9 +64,9 @@ public static List<SearchQueryRecord> generateQueryInsightRecords(int lower, int
                 MetricType.LATENCY,
                 randomLongBetween(1000, 10000),
                 MetricType.CPU,
-                randomDouble(),
-                MetricType.JVM,
-                randomDouble()
+                randomLongBetween(1000, 10000),
+                MetricType.MEMORY,
+                randomLongBetween(1000, 10000)
             );
 
             Map<String, Long> phaseLatencyMap = new HashMap<>();
@@ -186,4 +187,19 @@ public static boolean checkRecordsEqualsWithoutOrder(
         }
         return true;
     }
+
+    public static void registerAllQueryInsightsSettings(ClusterSettings clusterSettings) {
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_ENABLED);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_SIZE);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_WINDOW_SIZE);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_EXPORTER_SETTINGS);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_CPU_QUERIES_ENABLED);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_CPU_QUERIES_SIZE);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_CPU_QUERIES_WINDOW_SIZE);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_CPU_EXPORTER_SETTINGS);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_MEMORY_QUERIES_ENABLED);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_MEMORY_QUERIES_SIZE);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_MEMORY_QUERIES_WINDOW_SIZE);
+        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_MEMORY_EXPORTER_SETTINGS);
+    }
 }
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/DebugExporterTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/DebugExporterTests.java
new file mode 100644
index 0000000000000..736e406289b2c
--- /dev/null
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/DebugExporterTests.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.insights.core.exporter;
+
+import org.opensearch.plugin.insights.QueryInsightsTestUtils;
+import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.util.List;
+
+/**
+ * Granular tests for the {@link DebugExporterTests} class.
+ */
+public class DebugExporterTests extends OpenSearchTestCase {
+    private DebugExporter debugExporter;
+
+    @Before
+    public void setup() {
+        debugExporter = DebugExporter.getInstance();
+    }
+
+    public void testExport() {
+        List<SearchQueryRecord> records = QueryInsightsTestUtils.generateQueryInsightRecords(2);
+        try {
+            debugExporter.export(records);
+        } catch (Exception e) {
+            fail("No exception should be thrown when exporting query insights data");
+        }
+    }
+}
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/LocalIndexExporterTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/LocalIndexExporterTests.java
new file mode 100644
index 0000000000000..9ea864a7083f4
--- /dev/null
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/LocalIndexExporterTests.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.insights.core.exporter;
+
+import org.opensearch.action.bulk.BulkAction;
+import org.opensearch.action.bulk.BulkRequestBuilder;
+import org.opensearch.action.bulk.BulkResponse;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.client.Client;
+import org.opensearch.plugin.insights.QueryInsightsTestUtils;
+import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
+import org.opensearch.test.OpenSearchTestCase;
+import org.joda.time.format.DateTimeFormat;
+import org.joda.time.format.DateTimeFormatter;
+import org.junit.Before;
+
+import java.util.List;
+
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+/**
+ * Granular tests for the {@link LocalIndexExporterTests} class.
+ */
+public class LocalIndexExporterTests extends OpenSearchTestCase {
+    private final DateTimeFormatter format = DateTimeFormat.forPattern("YYYY.MM.dd");
+    private final Client client = mock(Client.class);
+    private LocalIndexExporter localIndexExporter;
+
+    @Before
+    public void setup() {
+        localIndexExporter = new LocalIndexExporter(client, format);
+    }
+
+    public void testExportEmptyRecords() {
+        List<SearchQueryRecord> records = List.of();
+        try {
+            localIndexExporter.export(records);
+        } catch (Exception e) {
+            fail("No exception should be thrown when exporting empty query insights data");
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public void testExportRecords() {
+        BulkRequestBuilder bulkRequestBuilder = spy(new BulkRequestBuilder(client, BulkAction.INSTANCE));
+        final PlainActionFuture<BulkResponse> future = mock(PlainActionFuture.class);
+        when(future.actionGet()).thenReturn(null);
+        doAnswer(invocation -> future).when(bulkRequestBuilder).execute();
+        when(client.prepareBulk()).thenReturn(bulkRequestBuilder);
+
+        List<SearchQueryRecord> records = QueryInsightsTestUtils.generateQueryInsightRecords(2);
+        try {
+            localIndexExporter.export(records);
+        } catch (Exception e) {
+            fail("No exception should be thrown when exporting query insights data");
+        }
+        assertEquals(2, bulkRequestBuilder.numberOfActions());
+    }
+
+    @SuppressWarnings("unchecked")
+    public void testExportRecordsWithError() {
+        BulkRequestBuilder bulkRequestBuilder = spy(new BulkRequestBuilder(client, BulkAction.INSTANCE));
+        final PlainActionFuture<BulkResponse> future = mock(PlainActionFuture.class);
+        when(future.actionGet()).thenReturn(null);
+        doThrow(new RuntimeException()).when(bulkRequestBuilder).execute();
+        when(client.prepareBulk()).thenReturn(bulkRequestBuilder);
+
+        List<SearchQueryRecord> records = QueryInsightsTestUtils.generateQueryInsightRecords(2);
+        try {
+            localIndexExporter.export(records);
+        } catch (Exception e) {
+            fail("No exception should be thrown when exporting query insights data");
+        }
+    }
+
+    public void testClose() {
+        try {
+            localIndexExporter.close();
+        } catch (Exception e) {
+            fail("No exception should be thrown when closing local index exporter");
+        }
+    }
+
+    public void testGetAndSetIndexPattern() {
+        DateTimeFormatter newFormatter = mock(DateTimeFormatter.class);
+        localIndexExporter.setIndexPattern(newFormatter);
+        assert (localIndexExporter.getIndexPattern() == newFormatter);
+    }
+}
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporterFactoryTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporterFactoryTests.java
new file mode 100644
index 0000000000000..f01dd2c17509c
--- /dev/null
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/exporter/QueryInsightsExporterFactoryTests.java
@@ -0,0 +1,89 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.insights.core.exporter;
+
+import org.opensearch.client.Client;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.test.OpenSearchTestCase;
+import org.joda.time.format.DateTimeFormat;
+import org.junit.Before;
+
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.DEFAULT_TOP_QUERIES_EXPORTER_TYPE;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.EXPORTER_TYPE;
+import static org.opensearch.plugin.insights.settings.QueryInsightsSettings.EXPORT_INDEX;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Granular tests for the {@link QueryInsightsExporterFactoryTests} class.
+ */
+public class QueryInsightsExporterFactoryTests extends OpenSearchTestCase {
+    private final String format = "YYYY.MM.dd";
+
+    private final Client client = mock(Client.class);
+    private QueryInsightsExporterFactory queryInsightsExporterFactory;
+
+    @Before
+    public void setup() {
+        queryInsightsExporterFactory = new QueryInsightsExporterFactory(client);
+    }
+
+    public void testValidateConfigWhenResetExporter() {
+        Settings.Builder settingsBuilder = Settings.builder();
+        // empty settings
+        Settings settings = settingsBuilder.build();
+        try {
+            queryInsightsExporterFactory.validateExporterConfig(settings);
+        } catch (Exception e) {
+            fail("No exception should be thrown when setting is null");
+        }
+    }
+
+    public void testInvalidExporterTypeConfig() {
+        Settings.Builder settingsBuilder = Settings.builder();
+        Settings settings = settingsBuilder.put(EXPORTER_TYPE, "some_invalid_type").build();
+        assertThrows(IllegalArgumentException.class, () -> { queryInsightsExporterFactory.validateExporterConfig(settings); });
+    }
+
+    public void testInvalidLocalIndexConfig() {
+        Settings.Builder settingsBuilder = Settings.builder();
+        assertThrows(IllegalArgumentException.class, () -> {
+            queryInsightsExporterFactory.validateExporterConfig(
+                settingsBuilder.put(EXPORTER_TYPE, DEFAULT_TOP_QUERIES_EXPORTER_TYPE).put(EXPORT_INDEX, "").build()
+            );
+        });
+        assertThrows(IllegalArgumentException.class, () -> {
+            queryInsightsExporterFactory.validateExporterConfig(
+                settingsBuilder.put(EXPORTER_TYPE, DEFAULT_TOP_QUERIES_EXPORTER_TYPE).put(EXPORT_INDEX, "some_invalid_pattern").build()
+            );
+        });
+    }
+
+    public void testCreateAndCloseExporter() {
+        QueryInsightsExporter exporter1 = queryInsightsExporterFactory.createExporter(SinkType.LOCAL_INDEX, format);
+        assertTrue(exporter1 instanceof LocalIndexExporter);
+        QueryInsightsExporter exporter2 = queryInsightsExporterFactory.createExporter(SinkType.DEBUG, format);
+        assertTrue(exporter2 instanceof DebugExporter);
+        QueryInsightsExporter exporter3 = queryInsightsExporterFactory.createExporter(SinkType.DEBUG, format);
+        assertTrue(exporter3 instanceof DebugExporter);
+        try {
+            queryInsightsExporterFactory.closeExporter(exporter1);
+            queryInsightsExporterFactory.closeExporter(exporter2);
+            queryInsightsExporterFactory.closeAllExporters();
+        } catch (Exception e) {
+            fail("No exception should be thrown when closing exporter");
+        }
+    }
+
+    public void testUpdateExporter() {
+        LocalIndexExporter exporter = new LocalIndexExporter(client, DateTimeFormat.forPattern("yyyy-MM-dd"));
+        queryInsightsExporterFactory.updateExporter(exporter, "yyyy-MM-dd-HH");
+        assertEquals(DateTimeFormat.forPattern("yyyy-MM-dd-HH"), exporter.getIndexPattern());
+    }
+
+}
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/listener/QueryInsightsListenerTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/listener/QueryInsightsListenerTests.java
index f340950017a5c..86de44c680188 100644
--- a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/listener/QueryInsightsListenerTests.java
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/listener/QueryInsightsListenerTests.java
@@ -11,26 +11,44 @@
 import org.opensearch.action.search.SearchPhaseContext;
 import org.opensearch.action.search.SearchRequest;
 import org.opensearch.action.search.SearchRequestContext;
+import org.opensearch.action.search.SearchTask;
 import org.opensearch.action.search.SearchType;
+import org.opensearch.action.support.replication.ClusterStateCreationUtils;
+import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.tasks.TaskId;
+import org.opensearch.plugin.insights.QueryInsightsTestUtils;
 import org.opensearch.plugin.insights.core.service.QueryInsightsService;
 import org.opensearch.plugin.insights.core.service.TopQueriesService;
+import org.opensearch.plugin.insights.rules.model.Attribute;
 import org.opensearch.plugin.insights.rules.model.MetricType;
-import org.opensearch.plugin.insights.settings.QueryInsightsSettings;
+import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
 import org.opensearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
 import org.opensearch.search.aggregations.support.ValueType;
 import org.opensearch.search.builder.SearchSourceBuilder;
+import org.opensearch.tasks.Task;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
 import org.junit.Before;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Phaser;
+import java.util.concurrent.TimeUnit;
+
+import org.mockito.ArgumentCaptor;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
@@ -47,6 +65,7 @@ public class QueryInsightsListenerTests extends OpenSearchTestCase {
     private final SearchRequest searchRequest = mock(SearchRequest.class);
     private final QueryInsightsService queryInsightsService = mock(QueryInsightsService.class);
     private final TopQueriesService topQueriesService = mock(TopQueriesService.class);
+    private final ThreadPool threadPool = new TestThreadPool("QueryInsightsThreadPool");
     private ClusterService clusterService;
 
     @Before
@@ -54,14 +73,25 @@ public void setup() {
         Settings.Builder settingsBuilder = Settings.builder();
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_ENABLED);
-        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_SIZE);
-        clusterSettings.registerSetting(QueryInsightsSettings.TOP_N_LATENCY_QUERIES_WINDOW_SIZE);
-        clusterService = new ClusterService(settings, clusterSettings, null);
+        QueryInsightsTestUtils.registerAllQueryInsightsSettings(clusterSettings);
+        ClusterState state = ClusterStateCreationUtils.stateWithActivePrimary("test", true, 1 + randomInt(3), randomInt(2));
+        clusterService = ClusterServiceUtils.createClusterService(threadPool, state.getNodes().getLocalNode(), clusterSettings);
+        ClusterServiceUtils.setState(clusterService, state);
         when(queryInsightsService.isCollectionEnabled(MetricType.LATENCY)).thenReturn(true);
         when(queryInsightsService.getTopQueriesService(MetricType.LATENCY)).thenReturn(topQueriesService);
+
+        ThreadContext threadContext = new ThreadContext(Settings.EMPTY);
+        threadPool.getThreadContext().setHeaders(new Tuple<>(Collections.singletonMap(Task.X_OPAQUE_ID, "userLabel"), new HashMap<>()));
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        IOUtils.close(clusterService);
+        ThreadPool.terminate(threadPool, 10, TimeUnit.SECONDS);
     }
 
+    @SuppressWarnings("unchecked")
     public void testOnRequestEnd() throws InterruptedException {
         Long timestamp = System.currentTimeMillis() - 100L;
         SearchType searchType = SearchType.QUERY_THEN_FETCH;
@@ -69,6 +99,14 @@ public void testOnRequestEnd() throws InterruptedException {
         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         searchSourceBuilder.aggregation(new TermsAggregationBuilder("agg1").userValueTypeHint(ValueType.STRING).field("type.keyword"));
         searchSourceBuilder.size(0);
+        SearchTask task = new SearchTask(
+            0,
+            "n/a",
+            "n/a",
+            () -> "test",
+            TaskId.EMPTY_TASK_ID,
+            Collections.singletonMap(Task.X_OPAQUE_ID, "userLabel")
+        );
 
         String[] indices = new String[] { "index-1", "index-2" };
 
@@ -88,10 +126,19 @@ public void testOnRequestEnd() throws InterruptedException {
         when(searchRequestContext.phaseTookMap()).thenReturn(phaseLatencyMap);
         when(searchPhaseContext.getRequest()).thenReturn(searchRequest);
         when(searchPhaseContext.getNumShards()).thenReturn(numberOfShards);
+        when(searchPhaseContext.getTask()).thenReturn(task);
+        ArgumentCaptor<SearchQueryRecord> captor = ArgumentCaptor.forClass(SearchQueryRecord.class);
 
         queryInsightsListener.onRequestEnd(searchPhaseContext, searchRequestContext);
 
-        verify(queryInsightsService, times(1)).addRecord(any());
+        verify(queryInsightsService, times(1)).addRecord(captor.capture());
+        SearchQueryRecord generatedRecord = captor.getValue();
+        assertEquals(timestamp.longValue(), generatedRecord.getTimestamp());
+        assertEquals(numberOfShards, generatedRecord.getAttributes().get(Attribute.TOTAL_SHARDS));
+        assertEquals(searchType.toString().toLowerCase(Locale.ROOT), generatedRecord.getAttributes().get(Attribute.SEARCH_TYPE));
+        assertEquals(searchSourceBuilder.toString(), generatedRecord.getAttributes().get(Attribute.SOURCE));
+        Map<String, String> labels = (Map<String, String>) generatedRecord.getAttributes().get(Attribute.LABELS);
+        assertEquals("userLabel", labels.get(Task.X_OPAQUE_ID));
     }
 
     public void testConcurrentOnRequestEnd() throws InterruptedException {
@@ -101,6 +148,14 @@ public void testConcurrentOnRequestEnd() throws InterruptedException {
         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
         searchSourceBuilder.aggregation(new TermsAggregationBuilder("agg1").userValueTypeHint(ValueType.STRING).field("type.keyword"));
         searchSourceBuilder.size(0);
+        SearchTask task = new SearchTask(
+            0,
+            "n/a",
+            "n/a",
+            () -> "test",
+            TaskId.EMPTY_TASK_ID,
+            Collections.singletonMap(Task.X_OPAQUE_ID, "userLabel")
+        );
 
         String[] indices = new String[] { "index-1", "index-2" };
 
@@ -120,6 +175,7 @@ public void testConcurrentOnRequestEnd() throws InterruptedException {
         when(searchRequestContext.phaseTookMap()).thenReturn(phaseLatencyMap);
         when(searchPhaseContext.getRequest()).thenReturn(searchRequest);
         when(searchPhaseContext.getNumShards()).thenReturn(numberOfShards);
+        when(searchPhaseContext.getTask()).thenReturn(task);
 
         int numRequests = 50;
         Thread[] threads = new Thread[numRequests];
@@ -154,7 +210,7 @@ public void testSetEnabled() {
 
         when(queryInsightsService.isCollectionEnabled(MetricType.LATENCY)).thenReturn(false);
         when(queryInsightsService.isCollectionEnabled(MetricType.CPU)).thenReturn(false);
-        when(queryInsightsService.isCollectionEnabled(MetricType.JVM)).thenReturn(false);
+        when(queryInsightsService.isCollectionEnabled(MetricType.MEMORY)).thenReturn(false);
         queryInsightsListener.setEnableTopQueries(MetricType.LATENCY, false);
         assertFalse(queryInsightsListener.isEnabled());
     }
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/service/QueryInsightsServiceTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/service/QueryInsightsServiceTests.java
index c29b48b9690d1..75a5768f50681 100644
--- a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/service/QueryInsightsServiceTests.java
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/service/QueryInsightsServiceTests.java
@@ -8,6 +8,9 @@
 
 package org.opensearch.plugin.insights.core.service;
 
+import org.opensearch.client.Client;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.plugin.insights.QueryInsightsTestUtils;
 import org.opensearch.plugin.insights.rules.model.MetricType;
 import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
@@ -23,14 +26,19 @@
  */
 public class QueryInsightsServiceTests extends OpenSearchTestCase {
     private final ThreadPool threadPool = mock(ThreadPool.class);
+    private final Client client = mock(Client.class);
     private QueryInsightsService queryInsightsService;
 
     @Before
     public void setup() {
-        queryInsightsService = new QueryInsightsService(threadPool);
+        Settings.Builder settingsBuilder = Settings.builder();
+        Settings settings = settingsBuilder.build();
+        ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        QueryInsightsTestUtils.registerAllQueryInsightsSettings(clusterSettings);
+        queryInsightsService = new QueryInsightsService(clusterSettings, threadPool, client);
         queryInsightsService.enableCollection(MetricType.LATENCY, true);
         queryInsightsService.enableCollection(MetricType.CPU, true);
-        queryInsightsService.enableCollection(MetricType.JVM, true);
+        queryInsightsService.enableCollection(MetricType.MEMORY, true);
     }
 
     public void testAddRecordToLimitAndDrain() {
@@ -46,4 +54,12 @@ public void testAddRecordToLimitAndDrain() {
             queryInsightsService.getTopQueriesService(MetricType.LATENCY).getTopQueriesRecords(false).size()
         );
     }
+
+    public void testClose() {
+        try {
+            queryInsightsService.doClose();
+        } catch (Exception e) {
+            fail("No exception expected when closing query insights service");
+        }
+    }
 }
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/service/TopQueriesServiceTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/service/TopQueriesServiceTests.java
index 060df84a89485..8478fe1621698 100644
--- a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/service/TopQueriesServiceTests.java
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/core/service/TopQueriesServiceTests.java
@@ -11,24 +11,30 @@
 import org.opensearch.cluster.coordination.DeterministicTaskQueue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.plugin.insights.QueryInsightsTestUtils;
+import org.opensearch.plugin.insights.core.exporter.QueryInsightsExporterFactory;
 import org.opensearch.plugin.insights.rules.model.MetricType;
 import org.opensearch.plugin.insights.rules.model.SearchQueryRecord;
 import org.opensearch.plugin.insights.settings.QueryInsightsSettings;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.ThreadPool;
 import org.junit.Before;
 
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
+import static org.mockito.Mockito.mock;
+
 /**
  * Unit Tests for {@link QueryInsightsService}.
  */
 public class TopQueriesServiceTests extends OpenSearchTestCase {
     private TopQueriesService topQueriesService;
+    private final ThreadPool threadPool = mock(ThreadPool.class);
+    private final QueryInsightsExporterFactory queryInsightsExporterFactory = mock(QueryInsightsExporterFactory.class);
 
     @Before
     public void setup() {
-        topQueriesService = new TopQueriesService(MetricType.LATENCY);
+        topQueriesService = new TopQueriesService(MetricType.LATENCY, threadPool, queryInsightsExporterFactory);
         topQueriesService.setTopNSize(Integer.MAX_VALUE);
         topQueriesService.setWindowSize(new TimeValue(Long.MAX_VALUE));
         topQueriesService.setEnabled(true);
@@ -72,6 +78,10 @@ public void testValidateTopNSize() {
         assertThrows(IllegalArgumentException.class, () -> { topQueriesService.validateTopNSize(QueryInsightsSettings.MAX_N_SIZE + 1); });
     }
 
+    public void testValidateNegativeTopNSize() {
+        assertThrows(IllegalArgumentException.class, () -> { topQueriesService.validateTopNSize(-1); });
+    }
+
     public void testGetTopQueriesWhenNotEnabled() {
         topQueriesService.setEnabled(false);
         assertThrows(IllegalArgumentException.class, () -> { topQueriesService.getTopQueriesRecords(false); });
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/rules/model/SearchQueryRecordTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/rules/model/SearchQueryRecordTests.java
index 793d5878e2300..ad45b53ec5363 100644
--- a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/rules/model/SearchQueryRecordTests.java
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/rules/model/SearchQueryRecordTests.java
@@ -39,7 +39,7 @@ public void testSerializationAndEquals() throws Exception {
 
     public void testAllMetricTypes() {
         Set<MetricType> allMetrics = MetricType.allMetricTypes();
-        Set<MetricType> expected = new HashSet<>(Arrays.asList(MetricType.LATENCY, MetricType.CPU, MetricType.JVM));
+        Set<MetricType> expected = new HashSet<>(Arrays.asList(MetricType.LATENCY, MetricType.CPU, MetricType.MEMORY));
         assertEquals(expected, allMetrics);
     }
 
diff --git a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/rules/transport/top_queries/TransportTopQueriesActionTests.java b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/rules/transport/top_queries/TransportTopQueriesActionTests.java
index a5f36b6e8cce0..d05cf7b6a636f 100644
--- a/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/rules/transport/top_queries/TransportTopQueriesActionTests.java
+++ b/plugins/query-insights/src/test/java/org/opensearch/plugin/insights/rules/transport/top_queries/TransportTopQueriesActionTests.java
@@ -17,6 +17,7 @@
 import org.opensearch.plugin.insights.rules.action.top_queries.TopQueriesResponse;
 import org.opensearch.plugin.insights.rules.model.MetricType;
 import org.opensearch.plugin.insights.settings.QueryInsightsSettings;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
@@ -33,7 +34,7 @@ public class TransportTopQueriesActionTests extends OpenSearchTestCase {
     private final Settings.Builder settingsBuilder = Settings.builder();
     private final Settings settings = settingsBuilder.build();
     private final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-    private final ClusterService clusterService = new ClusterService(settings, clusterSettings, threadPool);
+    private final ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, threadPool);
     private final TransportService transportService = mock(TransportService.class);
     private final QueryInsightsService topQueriesByLatencyService = mock(QueryInsightsService.class);
     private final ActionFilters actionFilters = mock(ActionFilters.class);
diff --git a/plugins/repository-azure/build.gradle b/plugins/repository-azure/build.gradle
index 81444b637e90c..e5d3bd215f8cb 100644
--- a/plugins/repository-azure/build.gradle
+++ b/plugins/repository-azure/build.gradle
@@ -44,10 +44,11 @@ opensearchplugin {
 }
 
 dependencies {
-  api 'com.azure:azure-core:1.47.0'
+  api 'com.azure:azure-core:1.51.0'
   api 'com.azure:azure-json:1.1.0'
-  api 'com.azure:azure-storage-common:12.21.2'
-  api 'com.azure:azure-core-http-netty:1.12.8'
+  api 'com.azure:azure-xml:1.1.0'
+  api 'com.azure:azure-storage-common:12.25.1'
+  api 'com.azure:azure-core-http-netty:1.15.3'
   api "io.netty:netty-codec-dns:${versions.netty}"
   api "io.netty:netty-codec-socks:${versions.netty}"
   api "io.netty:netty-codec-http2:${versions.netty}"
@@ -56,19 +57,19 @@ dependencies {
   api "io.netty:netty-transport-native-unix-common:${versions.netty}"
   implementation project(':modules:transport-netty4')
   api 'com.azure:azure-storage-blob:12.23.0'
-  api 'com.azure:azure-identity:1.11.4'
+  api 'com.azure:azure-identity:1.13.0'
   // Start of transitive dependencies for azure-identity
-  api 'com.microsoft.azure:msal4j-persistence-extension:1.2.0'
+  api 'com.microsoft.azure:msal4j-persistence-extension:1.3.0'
   api "net.java.dev.jna:jna-platform:${versions.jna}"
-  api 'com.microsoft.azure:msal4j:1.14.3'
+  api 'com.microsoft.azure:msal4j:1.17.0'
   api 'com.nimbusds:oauth2-oidc-sdk:11.9.1'
-  api 'com.nimbusds:nimbus-jose-jwt:9.37.3'
+  api 'com.nimbusds:nimbus-jose-jwt:9.40'
   api 'com.nimbusds:content-type:2.3'
   api 'com.nimbusds:lang-tag:1.7'
   // Both msal4j:1.14.3 and oauth2-oidc-sdk:11.9.1 has compile dependency on different versions of json-smart,
   // selected the higher version which is 2.5.0
-  api 'net.minidev:json-smart:2.5.0'
-  api 'net.minidev:accessors-smart:2.5.0'
+  api 'net.minidev:json-smart:2.5.1'
+  api 'net.minidev:accessors-smart:2.5.1'
   api "org.ow2.asm:asm:${versions.asm}"
   // End of transitive dependencies for azure-identity
   api "io.projectreactor.netty:reactor-netty-core:${versions.reactor_netty}"
@@ -218,11 +219,6 @@ thirdPartyAudit {
     'org.bouncycastle.cert.X509CertificateHolder',
     'org.bouncycastle.cert.jcajce.JcaX509CertificateHolder',
     'org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder',
-    'org.bouncycastle.crypto.InvalidCipherTextException',
-    'org.bouncycastle.crypto.engines.AESEngine',
-    'org.bouncycastle.crypto.modes.GCMBlockCipher',
-    'org.bouncycastle.jcajce.provider.BouncyCastleFipsProvider',
-    'org.bouncycastle.jce.provider.BouncyCastleProvider',
     'org.bouncycastle.openssl.PEMKeyPair',
     'org.bouncycastle.openssl.PEMParser',
     'org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter',
diff --git a/plugins/repository-azure/licenses/accessors-smart-2.5.0.jar.sha1 b/plugins/repository-azure/licenses/accessors-smart-2.5.0.jar.sha1
deleted file mode 100644
index 1578c94fcdc7b..0000000000000
--- a/plugins/repository-azure/licenses/accessors-smart-2.5.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-aca011492dfe9c26f4e0659028a4fe0970829dd8
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/accessors-smart-2.5.1.jar.sha1 b/plugins/repository-azure/licenses/accessors-smart-2.5.1.jar.sha1
new file mode 100644
index 0000000000000..8f7452437323d
--- /dev/null
+++ b/plugins/repository-azure/licenses/accessors-smart-2.5.1.jar.sha1
@@ -0,0 +1 @@
+19b820261eb2e7de7d5bde11d1c06e4501dd7e5f
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-core-1.47.0.jar.sha1 b/plugins/repository-azure/licenses/azure-core-1.47.0.jar.sha1
deleted file mode 100644
index 42e35aacc63b1..0000000000000
--- a/plugins/repository-azure/licenses/azure-core-1.47.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-6b300175826f0bb0916fca2fa5f70885b716e93f
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-core-1.51.0.jar.sha1 b/plugins/repository-azure/licenses/azure-core-1.51.0.jar.sha1
new file mode 100644
index 0000000000000..7200f59af2f9a
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-core-1.51.0.jar.sha1
@@ -0,0 +1 @@
+ff5d0aedf75ca45ec0ace24673f790d2f7a57096
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-core-http-netty-1.12.8.jar.sha1 b/plugins/repository-azure/licenses/azure-core-http-netty-1.12.8.jar.sha1
deleted file mode 100644
index e6ee1dec64641..0000000000000
--- a/plugins/repository-azure/licenses/azure-core-http-netty-1.12.8.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-511ed2d02afb0f43f029df3d10ff80d2d3539f05
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-core-http-netty-1.15.3.jar.sha1 b/plugins/repository-azure/licenses/azure-core-http-netty-1.15.3.jar.sha1
new file mode 100644
index 0000000000000..3cea52ba67ce5
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-core-http-netty-1.15.3.jar.sha1
@@ -0,0 +1 @@
+03b5bd5f5c16eea71f130119dbfb1fe5239f806a
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-identity-1.11.4.jar.sha1 b/plugins/repository-azure/licenses/azure-identity-1.11.4.jar.sha1
deleted file mode 100644
index c8d98ba9c8ad2..0000000000000
--- a/plugins/repository-azure/licenses/azure-identity-1.11.4.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-59b5ce48888f638b80d85ef5aa0e22a265d3dc89
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-identity-1.13.0.jar.sha1 b/plugins/repository-azure/licenses/azure-identity-1.13.0.jar.sha1
new file mode 100644
index 0000000000000..b59c2a3be5c92
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-identity-1.13.0.jar.sha1
@@ -0,0 +1 @@
+54b44a74636322d06e9dc42d611a9f12a0966790
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-storage-common-12.21.2.jar.sha1 b/plugins/repository-azure/licenses/azure-storage-common-12.21.2.jar.sha1
deleted file mode 100644
index b3c73774764df..0000000000000
--- a/plugins/repository-azure/licenses/azure-storage-common-12.21.2.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-d2676d4fc40a501bd5d0437b8d2bfb9926022bea
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-storage-common-12.25.1.jar.sha1 b/plugins/repository-azure/licenses/azure-storage-common-12.25.1.jar.sha1
new file mode 100644
index 0000000000000..822a60d81ca27
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-storage-common-12.25.1.jar.sha1
@@ -0,0 +1 @@
+96e2df76ce9a8fa084ae289bb59295d565f2b8d5
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/azure-xml-1.1.0.jar.sha1 b/plugins/repository-azure/licenses/azure-xml-1.1.0.jar.sha1
new file mode 100644
index 0000000000000..4f9cfcac02f6e
--- /dev/null
+++ b/plugins/repository-azure/licenses/azure-xml-1.1.0.jar.sha1
@@ -0,0 +1 @@
+8218a00c07f9f66d5dc7ae2ba613da6890867497
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-annotations-2.17.1.jar.sha1 b/plugins/repository-azure/licenses/jackson-annotations-2.17.1.jar.sha1
deleted file mode 100644
index 4ceead1b7ae4f..0000000000000
--- a/plugins/repository-azure/licenses/jackson-annotations-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fca7ef6192c9ad05d07bc50da991bf937a84af3a
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-annotations-2.17.2.jar.sha1 b/plugins/repository-azure/licenses/jackson-annotations-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..411e1d62459fd
--- /dev/null
+++ b/plugins/repository-azure/licenses/jackson-annotations-2.17.2.jar.sha1
@@ -0,0 +1 @@
+147b7b9412ffff24339f8aba080b292448e08698
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-databind-2.17.1.jar.sha1 b/plugins/repository-azure/licenses/jackson-databind-2.17.1.jar.sha1
deleted file mode 100644
index 7cf1ac1b60301..0000000000000
--- a/plugins/repository-azure/licenses/jackson-databind-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-0524dcbcccdde7d45a679dfc333e4763feb09079
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-databind-2.17.2.jar.sha1 b/plugins/repository-azure/licenses/jackson-databind-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f2b4dbdc5decb
--- /dev/null
+++ b/plugins/repository-azure/licenses/jackson-databind-2.17.2.jar.sha1
@@ -0,0 +1 @@
+e6deb029e5901e027c129341fac39e515066b68c
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-dataformat-xml-2.17.1.jar.sha1 b/plugins/repository-azure/licenses/jackson-dataformat-xml-2.17.1.jar.sha1
deleted file mode 100644
index 3915ab2616beb..0000000000000
--- a/plugins/repository-azure/licenses/jackson-dataformat-xml-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e6a168dba62aa63743b9e2b83f4e0f0dfdc143d3
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-dataformat-xml-2.17.2.jar.sha1 b/plugins/repository-azure/licenses/jackson-dataformat-xml-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f9c31c168926d
--- /dev/null
+++ b/plugins/repository-azure/licenses/jackson-dataformat-xml-2.17.2.jar.sha1
@@ -0,0 +1 @@
+ad58f5bd089e743ac6e5999b2d1e3cf8515cea9a
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-datatype-jsr310-2.17.1.jar.sha1 b/plugins/repository-azure/licenses/jackson-datatype-jsr310-2.17.1.jar.sha1
deleted file mode 100644
index db26ebbf738f7..0000000000000
--- a/plugins/repository-azure/licenses/jackson-datatype-jsr310-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-0969b0c3cb8c75d759e9a6c585c44c9b9f3a4f75
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-datatype-jsr310-2.17.2.jar.sha1 b/plugins/repository-azure/licenses/jackson-datatype-jsr310-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..a61bf643d69e6
--- /dev/null
+++ b/plugins/repository-azure/licenses/jackson-datatype-jsr310-2.17.2.jar.sha1
@@ -0,0 +1 @@
+267b85e9ba2892a37be6d80aa9ca1438a0d8c210
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-module-jaxb-annotations-2.17.1.jar.sha1 b/plugins/repository-azure/licenses/jackson-module-jaxb-annotations-2.17.1.jar.sha1
deleted file mode 100644
index bb8ecfe34d295..0000000000000
--- a/plugins/repository-azure/licenses/jackson-module-jaxb-annotations-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f77e7bf0e64dfcf53bfdcf2764ad7ab92b78a4da
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/jackson-module-jaxb-annotations-2.17.2.jar.sha1 b/plugins/repository-azure/licenses/jackson-module-jaxb-annotations-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..d9d7975146c22
--- /dev/null
+++ b/plugins/repository-azure/licenses/jackson-module-jaxb-annotations-2.17.2.jar.sha1
@@ -0,0 +1 @@
+c2978b818ef2f2b2738b387c143624eab611d917
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/json-smart-2.5.0.jar.sha1 b/plugins/repository-azure/licenses/json-smart-2.5.0.jar.sha1
deleted file mode 100644
index 3ec055efa1255..0000000000000
--- a/plugins/repository-azure/licenses/json-smart-2.5.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-57a64f421b472849c40e77d2e7cce3a141b41e99
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/json-smart-2.5.1.jar.sha1 b/plugins/repository-azure/licenses/json-smart-2.5.1.jar.sha1
new file mode 100644
index 0000000000000..fe23968afce1e
--- /dev/null
+++ b/plugins/repository-azure/licenses/json-smart-2.5.1.jar.sha1
@@ -0,0 +1 @@
+4c11d2808d009132dfbbf947ebf37de6bf266c8e
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/msal4j-1.14.3.jar.sha1 b/plugins/repository-azure/licenses/msal4j-1.14.3.jar.sha1
deleted file mode 100644
index 2a6e42e3f2b48..0000000000000
--- a/plugins/repository-azure/licenses/msal4j-1.14.3.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-117b28c41bd760f979ed1b6467c5ec491f0d4d60
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/msal4j-1.17.0.jar.sha1 b/plugins/repository-azure/licenses/msal4j-1.17.0.jar.sha1
new file mode 100644
index 0000000000000..34101c989eecd
--- /dev/null
+++ b/plugins/repository-azure/licenses/msal4j-1.17.0.jar.sha1
@@ -0,0 +1 @@
+7d37157da92b719f250b0023234ac9dda922a2a5
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/msal4j-persistence-extension-1.2.0.jar.sha1 b/plugins/repository-azure/licenses/msal4j-persistence-extension-1.2.0.jar.sha1
deleted file mode 100644
index cfcf7548b7694..0000000000000
--- a/plugins/repository-azure/licenses/msal4j-persistence-extension-1.2.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-1111a95878de8745ddc9de132df18ebd9ca7024d
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/msal4j-persistence-extension-1.3.0.jar.sha1 b/plugins/repository-azure/licenses/msal4j-persistence-extension-1.3.0.jar.sha1
new file mode 100644
index 0000000000000..9c5909e7ff240
--- /dev/null
+++ b/plugins/repository-azure/licenses/msal4j-persistence-extension-1.3.0.jar.sha1
@@ -0,0 +1 @@
+8a8ef1517d27a5b4de1512ef94679bdb59f210b6
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-dns-4.1.110.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-dns-4.1.110.Final.jar.sha1
deleted file mode 100644
index c4ca8f15e85c5..0000000000000
--- a/plugins/repository-azure/licenses/netty-codec-dns-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-381c5bf8b7570c163fa7893a26d02b7ac36ff6eb
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-dns-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-dns-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..a42a41b6387c8
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-codec-dns-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+06724b184ee870ecc4d8fc36931beeb3c387b0ee
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-http2-4.1.110.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-http2-4.1.110.Final.jar.sha1
deleted file mode 100644
index ebd1e0d52efb2..0000000000000
--- a/plugins/repository-azure/licenses/netty-codec-http2-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e0849843eb5b1c036b12551baca98a9f7ff847a0
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-http2-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..d4767d06b22bf
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+7fa28b510f0f16f4d5d7188b86bef59e048f62f9
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-socks-4.1.110.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-socks-4.1.110.Final.jar.sha1
deleted file mode 100644
index 9f6e95ba38d2e..0000000000000
--- a/plugins/repository-azure/licenses/netty-codec-socks-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-4d54c8d5b95b14756043efb59b8c3e62ec67aa43
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-codec-socks-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-codec-socks-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5291a16c10448
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-codec-socks-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+9aed7e78c467d06a47a45b5b27466380a6427e2f
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-handler-proxy-4.1.110.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-handler-proxy-4.1.110.Final.jar.sha1
deleted file mode 100644
index f31396d94c2ec..0000000000000
--- a/plugins/repository-azure/licenses/netty-handler-proxy-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b7fb401dd47c79e6b99f2319ac3b561c50c31c30
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-handler-proxy-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-handler-proxy-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..cf50574b87da0
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-handler-proxy-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b23c87a85451b3b0e7c3e8e89698cea6831a8418
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-resolver-dns-4.1.110.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-resolver-dns-4.1.110.Final.jar.sha1
deleted file mode 100644
index 18d122acd2c44..0000000000000
--- a/plugins/repository-azure/licenses/netty-resolver-dns-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3e687cdc4ecdbbad07508a11b715bdf95fa20939
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..24e8177190e04
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+375872f1c16bb51aac016ff6ee4f5d28b1288d4d
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1
deleted file mode 100644
index 2c468962b1b64..0000000000000
--- a/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a7096e7c0a25a983647909d7513f5d4943d589c0
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1 b/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..8dad0e3104dc8
--- /dev/null
+++ b/plugins/repository-azure/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b50ff619cdcdc48e748cba3405c9988529f28f60
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/nimbus-jose-jwt-9.37.3.jar.sha1 b/plugins/repository-azure/licenses/nimbus-jose-jwt-9.37.3.jar.sha1
deleted file mode 100644
index 7278cd8994f71..0000000000000
--- a/plugins/repository-azure/licenses/nimbus-jose-jwt-9.37.3.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-700f71ffefd60c16bd8ce711a956967ea9071cec
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/nimbus-jose-jwt-9.40.jar.sha1 b/plugins/repository-azure/licenses/nimbus-jose-jwt-9.40.jar.sha1
new file mode 100644
index 0000000000000..83228caf233cc
--- /dev/null
+++ b/plugins/repository-azure/licenses/nimbus-jose-jwt-9.40.jar.sha1
@@ -0,0 +1 @@
+42b1dfa0360e4062951b070bac52dd8d96fd7b38
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/reactor-netty-core-1.1.19.jar.sha1 b/plugins/repository-azure/licenses/reactor-netty-core-1.1.19.jar.sha1
deleted file mode 100644
index cbcbfcd87d682..0000000000000
--- a/plugins/repository-azure/licenses/reactor-netty-core-1.1.19.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-639e2c63ade6f2a49d7e501ca2264b74d240b448
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/reactor-netty-core-1.1.22.jar.sha1 b/plugins/repository-azure/licenses/reactor-netty-core-1.1.22.jar.sha1
new file mode 100644
index 0000000000000..cc894568c5760
--- /dev/null
+++ b/plugins/repository-azure/licenses/reactor-netty-core-1.1.22.jar.sha1
@@ -0,0 +1 @@
+08356b59b29f86e7142c9daca0434653a64ae64b
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/reactor-netty-http-1.1.19.jar.sha1 b/plugins/repository-azure/licenses/reactor-netty-http-1.1.19.jar.sha1
deleted file mode 100644
index 1eeedfc0926f5..0000000000000
--- a/plugins/repository-azure/licenses/reactor-netty-http-1.1.19.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b4bbb1aeb64ecb2b3949c38983032a7f0b0ebd07
\ No newline at end of file
diff --git a/plugins/repository-azure/licenses/reactor-netty-http-1.1.22.jar.sha1 b/plugins/repository-azure/licenses/reactor-netty-http-1.1.22.jar.sha1
new file mode 100644
index 0000000000000..2402813f831ce
--- /dev/null
+++ b/plugins/repository-azure/licenses/reactor-netty-http-1.1.22.jar.sha1
@@ -0,0 +1 @@
+2faf64b3822b0512f15d72a325e2826eb8564413
\ No newline at end of file
diff --git a/plugins/repository-azure/src/internalClusterTest/java/org/opensearch/repositories/azure/AzureStorageCleanupThirdPartyTests.java b/plugins/repository-azure/src/internalClusterTest/java/org/opensearch/repositories/azure/AzureStorageCleanupThirdPartyTests.java
index 176e60a667aef..7f32f09602164 100644
--- a/plugins/repository-azure/src/internalClusterTest/java/org/opensearch/repositories/azure/AzureStorageCleanupThirdPartyTests.java
+++ b/plugins/repository-azure/src/internalClusterTest/java/org/opensearch/repositories/azure/AzureStorageCleanupThirdPartyTests.java
@@ -38,7 +38,6 @@
 import com.azure.storage.blob.models.BlobStorageException;
 import org.opensearch.action.ActionRunnable;
 import org.opensearch.action.support.PlainActionFuture;
-import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.MockSecureSettings;
 import org.opensearch.common.settings.SecureSettings;
@@ -47,6 +46,7 @@
 import org.opensearch.plugins.Plugin;
 import org.opensearch.repositories.AbstractThirdPartyRepositoryTestCase;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchIntegTestCase;
 import org.junit.AfterClass;
 
 import java.net.HttpURLConnection;
@@ -56,7 +56,6 @@
 import reactor.core.scheduler.Schedulers;
 
 import static org.hamcrest.Matchers.blankOrNullString;
-import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.not;
 
 public class AzureStorageCleanupThirdPartyTests extends AbstractThirdPartyRepositoryTestCase {
@@ -103,17 +102,11 @@ protected SecureSettings credentials() {
 
     @Override
     protected void createRepository(String repoName) {
-        AcknowledgedResponse putRepositoryResponse = client().admin()
-            .cluster()
-            .preparePutRepository(repoName)
-            .setType("azure")
-            .setSettings(
-                Settings.builder()
-                    .put("container", System.getProperty("test.azure.container"))
-                    .put("base_path", System.getProperty("test.azure.base"))
-            )
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        Settings.Builder settings = Settings.builder()
+            .put("container", System.getProperty("test.azure.container"))
+            .put("base_path", System.getProperty("test.azure.base"));
+
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), repoName, "azure", settings);
         if (Strings.hasText(System.getProperty("test.azure.sas_token"))) {
             ensureSasTokenPermissions();
         }
diff --git a/plugins/repository-azure/src/main/java/org/opensearch/repositories/azure/AzureStorageService.java b/plugins/repository-azure/src/main/java/org/opensearch/repositories/azure/AzureStorageService.java
index f39ed185d8b35..4f30247f0af08 100644
--- a/plugins/repository-azure/src/main/java/org/opensearch/repositories/azure/AzureStorageService.java
+++ b/plugins/repository-azure/src/main/java/org/opensearch/repositories/azure/AzureStorageService.java
@@ -141,6 +141,9 @@ public Void run() {
         // - https://github.com/Azure/azure-sdk-for-java/pull/25004
         // - https://github.com/Azure/azure-sdk-for-java/pull/24374
         Configuration.getGlobalConfiguration().put("AZURE_JACKSON_ADAPTER_USE_ACCESS_HELPER", "true");
+        // See please:
+        // - https://github.com/Azure/azure-sdk-for-java/issues/37464
+        Configuration.getGlobalConfiguration().put("AZURE_ENABLE_SHUTDOWN_HOOK_WITH_PRIVILEGE", "true");
     }
 
     public AzureStorageService(Settings settings) {
diff --git a/plugins/repository-azure/src/main/plugin-metadata/plugin-security.policy b/plugins/repository-azure/src/main/plugin-metadata/plugin-security.policy
index e8fbe35ebab1d..eedcfd98da150 100644
--- a/plugins/repository-azure/src/main/plugin-metadata/plugin-security.policy
+++ b/plugins/repository-azure/src/main/plugin-metadata/plugin-security.policy
@@ -38,6 +38,7 @@ grant {
   permission java.lang.RuntimePermission "accessDeclaredMembers";
   permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
   permission java.lang.RuntimePermission "setContextClassLoader";
+  permission java.lang.RuntimePermission "shutdownHooks";
 
   // azure client set Authenticator for proxy username/password
   permission java.net.NetPermission "setDefaultAuthenticator";
diff --git a/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureBlobContainerRetriesTests.java b/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureBlobContainerRetriesTests.java
index 5117768aa3351..a5d549a178366 100644
--- a/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureBlobContainerRetriesTests.java
+++ b/plugins/repository-azure/src/test/java/org/opensearch/repositories/azure/AzureBlobContainerRetriesTests.java
@@ -158,7 +158,7 @@ private BlobContainer createBlobContainer(final int maxRetries) {
             + "/";
         clientSettings.put(ENDPOINT_SUFFIX_SETTING.getConcreteSettingForNamespace(clientName).getKey(), endpoint);
         clientSettings.put(MAX_RETRIES_SETTING.getConcreteSettingForNamespace(clientName).getKey(), maxRetries);
-        clientSettings.put(TIMEOUT_SETTING.getConcreteSettingForNamespace(clientName).getKey(), TimeValue.timeValueMillis(2000));
+        clientSettings.put(TIMEOUT_SETTING.getConcreteSettingForNamespace(clientName).getKey(), TimeValue.timeValueMillis(5000));
 
         final MockSecureSettings secureSettings = new MockSecureSettings();
         secureSettings.setString(ACCOUNT_SETTING.getConcreteSettingForNamespace(clientName).getKey(), "account");
@@ -172,7 +172,7 @@ RequestRetryOptions createRetryPolicy(final AzureStorageSettings azureStorageSet
                 return new RequestRetryOptions(
                     RetryPolicyType.EXPONENTIAL,
                     azureStorageSettings.getMaxRetries(),
-                    1,
+                    5,
                     10L,
                     100L,
                     secondaryHost
diff --git a/plugins/repository-gcs/src/internalClusterTest/java/org/opensearch/repositories/gcs/GoogleCloudStorageThirdPartyTests.java b/plugins/repository-gcs/src/internalClusterTest/java/org/opensearch/repositories/gcs/GoogleCloudStorageThirdPartyTests.java
index 1e11b1d111d8f..860b30fdef9ca 100644
--- a/plugins/repository-gcs/src/internalClusterTest/java/org/opensearch/repositories/gcs/GoogleCloudStorageThirdPartyTests.java
+++ b/plugins/repository-gcs/src/internalClusterTest/java/org/opensearch/repositories/gcs/GoogleCloudStorageThirdPartyTests.java
@@ -32,19 +32,18 @@
 
 package org.opensearch.repositories.gcs;
 
-import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.common.settings.MockSecureSettings;
 import org.opensearch.common.settings.SecureSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.Strings;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.repositories.AbstractThirdPartyRepositoryTestCase;
+import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.util.Base64;
 import java.util.Collection;
 
 import static org.hamcrest.Matchers.blankOrNullString;
-import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.not;
 
 public class GoogleCloudStorageThirdPartyTests extends AbstractThirdPartyRepositoryTestCase {
@@ -84,16 +83,9 @@ protected SecureSettings credentials() {
 
     @Override
     protected void createRepository(final String repoName) {
-        AcknowledgedResponse putRepositoryResponse = client().admin()
-            .cluster()
-            .preparePutRepository("test-repo")
-            .setType("gcs")
-            .setSettings(
-                Settings.builder()
-                    .put("bucket", System.getProperty("test.google.bucket"))
-                    .put("base_path", System.getProperty("test.google.base", "/"))
-            )
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        Settings.Builder settings = Settings.builder()
+            .put("bucket", System.getProperty("test.google.bucket"))
+            .put("base_path", System.getProperty("test.google.base", "/"));
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo", "gcs", settings);
     }
 }
diff --git a/plugins/repository-hdfs/build.gradle b/plugins/repository-hdfs/build.gradle
index 3ab8f48cd5b9f..8e3f1c6d4cfe7 100644
--- a/plugins/repository-hdfs/build.gradle
+++ b/plugins/repository-hdfs/build.gradle
@@ -66,17 +66,17 @@ dependencies {
   }
   api 'org.apache.htrace:htrace-core4:4.2.0-incubating'
   api "org.apache.logging.log4j:log4j-core:${versions.log4j}"
-  api 'org.apache.avro:avro:1.11.3'
+  api 'org.apache.avro:avro:1.12.0'
   api 'com.google.code.gson:gson:2.11.0'
   runtimeOnly "com.google.guava:guava:${versions.guava}"
   api "commons-logging:commons-logging:${versions.commonslogging}"
-  api 'commons-cli:commons-cli:1.8.0'
+  api 'commons-cli:commons-cli:1.9.0'
   api "commons-codec:commons-codec:${versions.commonscodec}"
   api 'commons-collections:commons-collections:3.2.2'
   api "org.apache.commons:commons-compress:${versions.commonscompress}"
-  api 'org.apache.commons:commons-configuration2:2.10.1'
+  api 'org.apache.commons:commons-configuration2:2.11.0'
   api "commons-io:commons-io:${versions.commonsio}"
-  api 'org.apache.commons:commons-lang3:3.14.0'
+  api 'org.apache.commons:commons-lang3:3.15.0'
   implementation 'com.google.re2j:re2j:1.6'
   api 'javax.servlet:servlet-api:2.5'
   api "org.slf4j:slf4j-api:${versions.slf4j}"
@@ -425,19 +425,6 @@ thirdPartyAudit {
     'org.apache.hadoop.shaded.org.apache.curator.shaded.com.google.common.util.concurrent.AbstractFuture$UnsafeAtomicHelper',
     'org.apache.hadoop.shaded.org.apache.curator.shaded.com.google.common.util.concurrent.AbstractFuture$UnsafeAtomicHelper$1',
     'org.apache.hadoop.shaded.org.xbill.DNS.spi.DNSJavaNameServiceDescriptor',
-
-    'org.apache.avro.reflect.FieldAccessUnsafe',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeBooleanField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeByteField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeCachedField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeCharField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeCustomEncodedField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeDoubleField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeFloatField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeIntField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeLongField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeObjectField',
-    'org.apache.avro.reflect.FieldAccessUnsafe$UnsafeShortField',
   )
 }
 
diff --git a/plugins/repository-hdfs/licenses/avro-1.11.3.jar.sha1 b/plugins/repository-hdfs/licenses/avro-1.11.3.jar.sha1
deleted file mode 100644
index fb43ecbcf22c9..0000000000000
--- a/plugins/repository-hdfs/licenses/avro-1.11.3.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-02b463409b373bff9ece09f54a43d42da5cea55a
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/avro-1.12.0.jar.sha1 b/plugins/repository-hdfs/licenses/avro-1.12.0.jar.sha1
new file mode 100644
index 0000000000000..83f7bb3677159
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/avro-1.12.0.jar.sha1
@@ -0,0 +1 @@
+6e692a464b213f6df49f8e3e7fcf42df0dbb7639
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-cli-1.8.0.jar.sha1 b/plugins/repository-hdfs/licenses/commons-cli-1.8.0.jar.sha1
deleted file mode 100644
index 65102052409ea..0000000000000
--- a/plugins/repository-hdfs/licenses/commons-cli-1.8.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-41a4bff12057eecb6daaf9c7f36c237815be3da1
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-cli-1.9.0.jar.sha1 b/plugins/repository-hdfs/licenses/commons-cli-1.9.0.jar.sha1
new file mode 100644
index 0000000000000..9a97a11dbe8d5
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/commons-cli-1.9.0.jar.sha1
@@ -0,0 +1 @@
+e1cdfa8bf40ccbb7440b2d1232f9f45bb20a1844
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-configuration2-2.10.1.jar.sha1 b/plugins/repository-hdfs/licenses/commons-configuration2-2.10.1.jar.sha1
deleted file mode 100644
index d4c0f8417d357..0000000000000
--- a/plugins/repository-hdfs/licenses/commons-configuration2-2.10.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-2b681b3bcddeaa5bf5c2a2939cd77e2f9ad6efda
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-configuration2-2.11.0.jar.sha1 b/plugins/repository-hdfs/licenses/commons-configuration2-2.11.0.jar.sha1
new file mode 100644
index 0000000000000..eea24804c5228
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/commons-configuration2-2.11.0.jar.sha1
@@ -0,0 +1 @@
+af5a2c6abe587074c0be1107fcb27fa2fad91304
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-lang3-3.14.0.jar.sha1 b/plugins/repository-hdfs/licenses/commons-lang3-3.14.0.jar.sha1
deleted file mode 100644
index d783e07e40902..0000000000000
--- a/plugins/repository-hdfs/licenses/commons-lang3-3.14.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-1ed471194b02f2c6cb734a0cd6f6f107c673afae
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/commons-lang3-3.15.0.jar.sha1 b/plugins/repository-hdfs/licenses/commons-lang3-3.15.0.jar.sha1
new file mode 100644
index 0000000000000..4b1179c935946
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/commons-lang3-3.15.0.jar.sha1
@@ -0,0 +1 @@
+21581109b4be710ea4b195d5760392ec284f9f11
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/netty-all-4.1.110.Final.jar.sha1 b/plugins/repository-hdfs/licenses/netty-all-4.1.110.Final.jar.sha1
deleted file mode 100644
index 8f8d86e6065b2..0000000000000
--- a/plugins/repository-hdfs/licenses/netty-all-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-db3f4d3ad3d16e26991a64d50b749ae09e0e0c8e
\ No newline at end of file
diff --git a/plugins/repository-hdfs/licenses/netty-all-4.1.112.Final.jar.sha1 b/plugins/repository-hdfs/licenses/netty-all-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..7c36b789e839c
--- /dev/null
+++ b/plugins/repository-hdfs/licenses/netty-all-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+d6b2e543749a86957777a46cf68aaa337cc558cb
\ No newline at end of file
diff --git a/plugins/repository-hdfs/src/test/java/org/opensearch/repositories/hdfs/HdfsRepositoryTests.java b/plugins/repository-hdfs/src/test/java/org/opensearch/repositories/hdfs/HdfsRepositoryTests.java
index ab10691240649..60fdbea011a44 100644
--- a/plugins/repository-hdfs/src/test/java/org/opensearch/repositories/hdfs/HdfsRepositoryTests.java
+++ b/plugins/repository-hdfs/src/test/java/org/opensearch/repositories/hdfs/HdfsRepositoryTests.java
@@ -34,12 +34,12 @@
 import com.carrotsearch.randomizedtesting.annotations.ThreadLeakFilters;
 
 import org.opensearch.action.admin.cluster.repositories.cleanup.CleanupRepositoryResponse;
-import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.common.settings.MockSecureSettings;
 import org.opensearch.common.settings.SecureSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.repositories.AbstractThirdPartyRepositoryTestCase;
+import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.util.Collection;
 
@@ -61,20 +61,13 @@ protected SecureSettings credentials() {
 
     @Override
     protected void createRepository(String repoName) {
-        AcknowledgedResponse putRepositoryResponse = client().admin()
-            .cluster()
-            .preparePutRepository(repoName)
-            .setType("hdfs")
-            .setSettings(
-                Settings.builder()
-                    .put("uri", "hdfs:///")
-                    .put("conf.fs.AbstractFileSystem.hdfs.impl", TestingFs.class.getName())
-                    .put("path", "foo")
-                    .put("chunk_size", randomIntBetween(100, 1000) + "k")
-                    .put("compress", randomBoolean())
-            )
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        Settings.Builder settings = Settings.builder()
+            .put("uri", "hdfs:///")
+            .put("conf.fs.AbstractFileSystem.hdfs.impl", TestingFs.class.getName())
+            .put("path", "foo")
+            .put("chunk_size", randomIntBetween(100, 1000) + "k")
+            .put("compress", randomBoolean());
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), repoName, "hdfs", settings);
     }
 
     // HDFS repository doesn't have precise cleanup stats so we only check whether or not any blobs were removed
diff --git a/plugins/repository-hdfs/src/test/java/org/opensearch/repositories/hdfs/HdfsTests.java b/plugins/repository-hdfs/src/test/java/org/opensearch/repositories/hdfs/HdfsTests.java
index ce456f26af3a4..130bbbf1d2198 100644
--- a/plugins/repository-hdfs/src/test/java/org/opensearch/repositories/hdfs/HdfsTests.java
+++ b/plugins/repository-hdfs/src/test/java/org/opensearch/repositories/hdfs/HdfsTests.java
@@ -35,7 +35,6 @@
 
 import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
 import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse;
-import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.client.Client;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.common.settings.Settings;
@@ -45,6 +44,7 @@
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.repositories.blobstore.BlobStoreTestUtil;
 import org.opensearch.snapshots.SnapshotState;
+import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.OpenSearchSingleNodeTestCase;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -63,21 +63,13 @@ protected Collection<Class<? extends Plugin>> getPlugins() {
 
     public void testSimpleWorkflow() {
         Client client = client();
-
-        AcknowledgedResponse putRepositoryResponse = client.admin()
-            .cluster()
-            .preparePutRepository("test-repo")
-            .setType("hdfs")
-            .setSettings(
-                Settings.builder()
-                    .put("uri", "hdfs:///")
-                    .put("conf.fs.AbstractFileSystem.hdfs.impl", TestingFs.class.getName())
-                    .put("path", "foo")
-                    .put("chunk_size", randomIntBetween(100, 1000) + "k")
-                    .put("compress", randomBoolean())
-            )
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        Settings.Builder settings = Settings.builder()
+            .put("uri", "hdfs:///")
+            .put("conf.fs.AbstractFileSystem.hdfs.impl", TestingFs.class.getName())
+            .put("path", "foo")
+            .put("chunk_size", randomIntBetween(100, 1000) + "k")
+            .put("compress", randomBoolean());
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), "test-repo", "hdfs", settings);
 
         createIndex("test-idx-1");
         createIndex("test-idx-2");
@@ -168,7 +160,7 @@ public void testSimpleWorkflow() {
 
     public void testMissingUri() {
         try {
-            client().admin().cluster().preparePutRepository("test-repo").setType("hdfs").setSettings(Settings.EMPTY).get();
+            OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo", "hdfs", Settings.builder());
             fail();
         } catch (RepositoryException e) {
             assertTrue(e.getCause() instanceof IllegalArgumentException);
@@ -178,12 +170,8 @@ public void testMissingUri() {
 
     public void testEmptyUri() {
         try {
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("hdfs")
-                .setSettings(Settings.builder().put("uri", "/path").build())
-                .get();
+            Settings.Builder settings = Settings.builder().put("uri", "/path");
+            OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo", "hdfs", settings);
             fail();
         } catch (RepositoryException e) {
             assertTrue(e.getCause() instanceof IllegalArgumentException);
@@ -193,12 +181,8 @@ public void testEmptyUri() {
 
     public void testNonHdfsUri() {
         try {
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("hdfs")
-                .setSettings(Settings.builder().put("uri", "file:///").build())
-                .get();
+            Settings.Builder settings = Settings.builder().put("uri", "file:///");
+            OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo", "hdfs", settings);
             fail();
         } catch (RepositoryException e) {
             assertTrue(e.getCause() instanceof IllegalArgumentException);
@@ -208,12 +192,8 @@ public void testNonHdfsUri() {
 
     public void testPathSpecifiedInHdfs() {
         try {
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("hdfs")
-                .setSettings(Settings.builder().put("uri", "hdfs:///some/path").build())
-                .get();
+            Settings.Builder settings = Settings.builder().put("uri", "hdfs:///some/path");
+            OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo", "hdfs", settings);
             fail();
         } catch (RepositoryException e) {
             assertTrue(e.getCause() instanceof IllegalArgumentException);
@@ -223,12 +203,8 @@ public void testPathSpecifiedInHdfs() {
 
     public void testMissingPath() {
         try {
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("hdfs")
-                .setSettings(Settings.builder().put("uri", "hdfs:///").build())
-                .get();
+            Settings.Builder settings = Settings.builder().put("uri", "hdfs:///");
+            OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo", "hdfs", settings);
             fail();
         } catch (RepositoryException e) {
             assertTrue(e.getCause() instanceof IllegalArgumentException);
diff --git a/plugins/repository-s3/licenses/jackson-annotations-2.17.1.jar.sha1 b/plugins/repository-s3/licenses/jackson-annotations-2.17.1.jar.sha1
deleted file mode 100644
index 4ceead1b7ae4f..0000000000000
--- a/plugins/repository-s3/licenses/jackson-annotations-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-fca7ef6192c9ad05d07bc50da991bf937a84af3a
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/jackson-annotations-2.17.2.jar.sha1 b/plugins/repository-s3/licenses/jackson-annotations-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..411e1d62459fd
--- /dev/null
+++ b/plugins/repository-s3/licenses/jackson-annotations-2.17.2.jar.sha1
@@ -0,0 +1 @@
+147b7b9412ffff24339f8aba080b292448e08698
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/jackson-databind-2.17.1.jar.sha1 b/plugins/repository-s3/licenses/jackson-databind-2.17.1.jar.sha1
deleted file mode 100644
index 7cf1ac1b60301..0000000000000
--- a/plugins/repository-s3/licenses/jackson-databind-2.17.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-0524dcbcccdde7d45a679dfc333e4763feb09079
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/jackson-databind-2.17.2.jar.sha1 b/plugins/repository-s3/licenses/jackson-databind-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f2b4dbdc5decb
--- /dev/null
+++ b/plugins/repository-s3/licenses/jackson-databind-2.17.2.jar.sha1
@@ -0,0 +1 @@
+e6deb029e5901e027c129341fac39e515066b68c
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-buffer-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-buffer-4.1.110.Final.jar.sha1
deleted file mode 100644
index faaf70c858a6e..0000000000000
--- a/plugins/repository-s3/licenses/netty-buffer-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3d918a9ee057d995c362902b54634fc307132aac
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-buffer-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-buffer-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5c26883046fed
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-buffer-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+bdc12df04bb6858890b8aa108060b5b365a26102
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-4.1.110.Final.jar.sha1
deleted file mode 100644
index 7affbc14fa93a..0000000000000
--- a/plugins/repository-s3/licenses/netty-codec-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f1fa43b03e93ab88e805b6a4e3e83780c80b47d2
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..1fd224fdd0b44
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-codec-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+c87f2ec3d9a97bd2b793d16817abb2bab93a7fc3
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-http-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-http-4.1.110.Final.jar.sha1
deleted file mode 100644
index 07730a5606ce2..0000000000000
--- a/plugins/repository-s3/licenses/netty-codec-http-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-9d05cd927209ea25bbf342962c00b8e5a828c2a4
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-http-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-http-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..22d35128c3ad5
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-codec-http-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+81af1040bfa977f98dd0e1bd9639513ea862ca04
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-http2-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-http2-4.1.110.Final.jar.sha1
deleted file mode 100644
index ebd1e0d52efb2..0000000000000
--- a/plugins/repository-s3/licenses/netty-codec-http2-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e0849843eb5b1c036b12551baca98a9f7ff847a0
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-codec-http2-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..d4767d06b22bf
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+7fa28b510f0f16f4d5d7188b86bef59e048f62f9
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-common-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-common-4.1.110.Final.jar.sha1
deleted file mode 100644
index 568c0aa2a2c03..0000000000000
--- a/plugins/repository-s3/licenses/netty-common-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ec361e7e025c029be50c55c8480080cabcbc01e7
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-common-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-common-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..47af3100f0f2d
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-common-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b2798069092a981a832b7510d0462ee9efb7a80e
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-handler-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-handler-4.1.110.Final.jar.sha1
deleted file mode 100644
index 2d6050dd1e3a5..0000000000000
--- a/plugins/repository-s3/licenses/netty-handler-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-168db749c22652ee7fed1ebf7ec46ce856d75e51
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-handler-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-handler-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..8b30272861770
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-handler-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+3d5e2d5bcc6baeeb8c13a230980c6132a778e036
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-resolver-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-resolver-4.1.110.Final.jar.sha1
deleted file mode 100644
index c3ee8087a8b5d..0000000000000
--- a/plugins/repository-s3/licenses/netty-resolver-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-66c15921104cda0159b34e316541bc765dfaf3c0
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-resolver-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-resolver-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..1a094fa19a623
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-resolver-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+58a631d9d44c4ed7cc0dcc9cffa6641da9374d72
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-4.1.110.Final.jar.sha1
deleted file mode 100644
index 32c8fa2b876a2..0000000000000
--- a/plugins/repository-s3/licenses/netty-transport-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b91f04c39ac14d6a29d07184ef305953ee6e0348
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5fbfde0836e0c
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-transport-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+77cd136dd3843f5e7cbcf68c824975d745c49ddb
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.110.Final.jar.sha1
deleted file mode 100644
index 408f3aa5d1339..0000000000000
--- a/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3ca1cff0bf82bfd38e89f6946e54f24cbb3424a2
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..0196dacfe92ba
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-transport-classes-epoll-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+67e590356eb53c20aaabd67f61ae66f628e62e3d
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1
deleted file mode 100644
index 2c468962b1b64..0000000000000
--- a/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a7096e7c0a25a983647909d7513f5d4943d589c0
\ No newline at end of file
diff --git a/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1 b/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..8dad0e3104dc8
--- /dev/null
+++ b/plugins/repository-s3/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b50ff619cdcdc48e748cba3405c9988529f28f60
\ No newline at end of file
diff --git a/plugins/repository-s3/src/internalClusterTest/java/org/opensearch/repositories/s3/S3BlobStoreRepositoryTests.java b/plugins/repository-s3/src/internalClusterTest/java/org/opensearch/repositories/s3/S3BlobStoreRepositoryTests.java
index 1fc13359e5cd4..38e0786bb1f17 100644
--- a/plugins/repository-s3/src/internalClusterTest/java/org/opensearch/repositories/s3/S3BlobStoreRepositoryTests.java
+++ b/plugins/repository-s3/src/internalClusterTest/java/org/opensearch/repositories/s3/S3BlobStoreRepositoryTests.java
@@ -82,7 +82,6 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.stream.StreamSupport;
 
 import fixture.s3.S3HttpHandler;
@@ -228,7 +227,6 @@ public void testEnforcedCooldownPeriod() throws IOException {
         assertThat(repository.threadPool().relativeTimeInNanos() - beforeFastDelete, lessThan(TEST_COOLDOWN_PERIOD.getNanos()));
     }
 
-    @AwaitsFix(bugUrl = "https://github.com/opensearch-project/OpenSearch/issues/10735")
     @Override
     public void testRequestStats() throws Exception {
         final String repository = createRepository(randomName());
@@ -270,7 +268,12 @@ public void testRequestStats() throws Exception {
             } catch (RepositoryMissingException e) {
                 return null;
             }
-        }).filter(Objects::nonNull).map(Repository::stats).reduce(RepositoryStats::merge).get();
+        }).filter(b -> {
+            if (b instanceof BlobStoreRepository) {
+                return ((BlobStoreRepository) b).blobStore() != null;
+            }
+            return false;
+        }).map(Repository::stats).reduce(RepositoryStats::merge).get();
 
         Map<BlobStore.Metric, Map<String, Long>> extendedStats = repositoryStats.extendedStats;
         Map<String, Long> aggregatedStats = new HashMap<>();
@@ -312,6 +315,8 @@ protected S3Repository createRepository(
             ClusterService clusterService,
             RecoverySettings recoverySettings
         ) {
+            GenericStatsMetricPublisher genericStatsMetricPublisher = new GenericStatsMetricPublisher(10000L, 10, 10000L, 10);
+
             return new S3Repository(
                 metadata,
                 registry,
@@ -326,7 +331,7 @@ protected S3Repository createRepository(
                 false,
                 null,
                 null,
-                null
+                genericStatsMetricPublisher
             ) {
 
                 @Override
diff --git a/plugins/repository-s3/src/internalClusterTest/java/org/opensearch/repositories/s3/S3RepositoryThirdPartyTests.java b/plugins/repository-s3/src/internalClusterTest/java/org/opensearch/repositories/s3/S3RepositoryThirdPartyTests.java
index f7a84864a8569..7db9a0d3ba790 100644
--- a/plugins/repository-s3/src/internalClusterTest/java/org/opensearch/repositories/s3/S3RepositoryThirdPartyTests.java
+++ b/plugins/repository-s3/src/internalClusterTest/java/org/opensearch/repositories/s3/S3RepositoryThirdPartyTests.java
@@ -33,7 +33,6 @@
 
 import software.amazon.awssdk.services.s3.model.StorageClass;
 
-import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.common.SuppressForbidden;
 import org.opensearch.common.blobstore.BlobMetadata;
 import org.opensearch.common.blobstore.BlobPath;
@@ -43,6 +42,7 @@
 import org.opensearch.plugins.Plugin;
 import org.opensearch.repositories.AbstractThirdPartyRepositoryTestCase;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchIntegTestCase;
 import org.junit.Before;
 
 import java.util.Collection;
@@ -51,7 +51,6 @@
 import java.util.concurrent.TimeUnit;
 
 import static org.hamcrest.Matchers.blankOrNullString;
-import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.not;
 
 public class S3RepositoryThirdPartyTests extends AbstractThirdPartyRepositoryTestCase {
@@ -111,13 +110,7 @@ protected void createRepository(String repoName) {
                 settings.put("storage_class", storageClass);
             }
         }
-        AcknowledgedResponse putRepositoryResponse = client().admin()
-            .cluster()
-            .preparePutRepository("test-repo")
-            .setType("s3")
-            .setSettings(settings)
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo", "s3", settings);
     }
 
     @Override
diff --git a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3Repository.java b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3Repository.java
index 42f6b9a88a4a5..cecfb6012f730 100644
--- a/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3Repository.java
+++ b/plugins/repository-s3/src/main/java/org/opensearch/repositories/s3/S3Repository.java
@@ -44,6 +44,7 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.BlobStore;
 import org.opensearch.common.blobstore.BlobStoreException;
@@ -424,6 +425,7 @@ public void finalizeSnapshot(
         SnapshotInfo snapshotInfo,
         Version repositoryMetaVersion,
         Function<ClusterState, ClusterState> stateTransformer,
+        Priority repositoryUpdatePriority,
         ActionListener<RepositoryData> listener
     ) {
         if (SnapshotsService.useShardGenerations(repositoryMetaVersion) == false) {
@@ -436,6 +438,7 @@ public void finalizeSnapshot(
             snapshotInfo,
             repositoryMetaVersion,
             stateTransformer,
+            repositoryUpdatePriority,
             listener
         );
     }
diff --git a/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/RepositoryCredentialsTests.java b/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/RepositoryCredentialsTests.java
index 573a4f3f51a41..21017160d77e5 100644
--- a/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/RepositoryCredentialsTests.java
+++ b/plugins/repository-s3/src/test/java/org/opensearch/repositories/s3/RepositoryCredentialsTests.java
@@ -55,6 +55,7 @@
 import org.opensearch.rest.RestRequest;
 import org.opensearch.rest.RestResponse;
 import org.opensearch.rest.action.admin.cluster.RestGetRepositoriesAction;
+import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.OpenSearchSingleNodeTestCase;
 import org.opensearch.test.rest.FakeRestRequest;
 
@@ -68,7 +69,6 @@
 
 import static org.opensearch.repositories.s3.S3ClientSettings.ACCESS_KEY_SETTING;
 import static org.opensearch.repositories.s3.S3ClientSettings.SECRET_KEY_SETTING;
-import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.is;
@@ -277,14 +277,8 @@ public void sendResponse(RestResponse response) {
     }
 
     private void createRepository(final String name, final Settings repositorySettings) {
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository(name)
-                .setType(S3Repository.TYPE)
-                .setVerify(false)
-                .setSettings(repositorySettings)
-        );
+        Settings.Builder settings = Settings.builder().put(repositorySettings);
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), name, S3Repository.TYPE, false, settings);
     }
 
     /**
diff --git a/plugins/telemetry-otel/build.gradle b/plugins/telemetry-otel/build.gradle
index 735cbd92b691a..872d928aa093f 100644
--- a/plugins/telemetry-otel/build.gradle
+++ b/plugins/telemetry-otel/build.gradle
@@ -37,7 +37,7 @@ dependencies {
   runtimeOnly "com.squareup.okhttp3:okhttp:4.11.0"
   runtimeOnly "com.squareup.okio:okio-jvm:3.5.0"
   runtimeOnly "io.opentelemetry:opentelemetry-exporter-sender-okhttp:${versions.opentelemetry}"
-  api "io.opentelemetry:opentelemetry-extension-incubator:${versions.opentelemetry}-alpha"
+  api "io.opentelemetry:opentelemetry-api-incubator:${versions.opentelemetry}-alpha"
   testImplementation "io.opentelemetry:opentelemetry-sdk-testing:${versions.opentelemetry}"
 }
 
@@ -48,7 +48,9 @@ thirdPartyAudit {
    'io.opentelemetry.internal.shaded.jctools.queues.MpscArrayQueueProducerIndexField',
    'io.opentelemetry.internal.shaded.jctools.queues.MpscArrayQueueProducerLimitField',
    'io.opentelemetry.internal.shaded.jctools.util.UnsafeAccess',
-   'io.opentelemetry.internal.shaded.jctools.util.UnsafeRefArrayAccess'
+   'io.opentelemetry.internal.shaded.jctools.util.UnsafeRefArrayAccess',
+   'io.opentelemetry.exporter.internal.marshal.UnsafeAccess',
+   'io.opentelemetry.exporter.internal.marshal.UnsafeAccess$UnsafeHolder'
   )
 
   ignoreMissingClasses(
@@ -78,17 +80,15 @@ thirdPartyAudit {
     'org.conscrypt.ConscryptHostnameVerifier',
     'org.openjsse.javax.net.ssl.SSLParameters',
     'org.openjsse.javax.net.ssl.SSLSocket',
-    'io.opentelemetry.api.events.EventBuilder',
-    'io.opentelemetry.api.events.EventEmitter',
-    'io.opentelemetry.api.events.EventEmitterBuilder',
-    'io.opentelemetry.api.events.EventEmitterProvider',
     'io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties',
     'io.opentelemetry.sdk.autoconfigure.spi.logs.ConfigurableLogRecordExporterProvider',
     'io.opentelemetry.sdk.autoconfigure.spi.metrics.ConfigurableMetricExporterProvider',
     'io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider',
     'kotlin.io.path.PathsKt',
     'io.opentelemetry.sdk.autoconfigure.spi.traces.ConfigurableSpanExporterProvider',
-    'io.opentelemetry.sdk.autoconfigure.spi.internal.AutoConfigureListener'
+    'io.opentelemetry.sdk.autoconfigure.spi.internal.AutoConfigureListener',
+    'io.opentelemetry.sdk.autoconfigure.spi.internal.ComponentProvider',
+    'io.opentelemetry.sdk.autoconfigure.spi.internal.StructuredConfigProperties'
   )
 }
 
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-api-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-api-1.36.0.jar.sha1
deleted file mode 100644
index b577500d71e1d..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-api-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-59470f4aa3a9207f21936461b8fdcb36d46455ab
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-api-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-api-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..ead8fb235fa12
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-api-1.41.0.jar.sha1
@@ -0,0 +1 @@
+ec5ad3b420c9fba4b340e85a3199fd0f2accd023
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-api-incubator-1.41.0-alpha.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-api-incubator-1.41.0-alpha.jar.sha1
new file mode 100644
index 0000000000000..b601a4fb5246f
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-api-incubator-1.41.0-alpha.jar.sha1
@@ -0,0 +1 @@
+fd387313cc37a6e93062e9a80a2526634d22cb19
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-extension-incubator-LICENSE.txt b/plugins/telemetry-otel/licenses/opentelemetry-api-incubator-LICENSE.txt
similarity index 100%
rename from plugins/telemetry-otel/licenses/opentelemetry-extension-incubator-LICENSE.txt
rename to plugins/telemetry-otel/licenses/opentelemetry-api-incubator-LICENSE.txt
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-api-incubator-NOTICE.txt b/plugins/telemetry-otel/licenses/opentelemetry-api-incubator-NOTICE.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-context-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-context-1.36.0.jar.sha1
deleted file mode 100644
index d3156577248d5..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-context-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-8850bc4c65d0fd22ff987b4683206ec4e69f2689
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-context-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-context-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..74b7cb25cdfe5
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-context-1.41.0.jar.sha1
@@ -0,0 +1 @@
+3d7cf15ef425053e24e825160ca7b4ac08d721aa
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-common-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-common-1.36.0.jar.sha1
deleted file mode 100644
index f176b21d12dc4..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-exporter-common-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-8d1cb823ab18fa871a1549e7c522bf28f2b3d8fe
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-common-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-common-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..d8d8f75850cb6
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-exporter-common-1.41.0.jar.sha1
@@ -0,0 +1 @@
+cf92f4c1b60c2359c12f6f323f6a2a623c333910
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-logging-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-logging-1.36.0.jar.sha1
deleted file mode 100644
index cd25e0ab9f294..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-exporter-logging-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-bc045cae89ff6f18071760f6e4659dd880e88a1b
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-logging-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-logging-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..3e1212943f894
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-exporter-logging-1.41.0.jar.sha1
@@ -0,0 +1 @@
+8dee21440b811004ecc1c36c1cd44f9d3494546c
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-1.36.0.jar.sha1
deleted file mode 100644
index fabb394f9c2e0..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-5ee49902ba884d6c3e48499a9311a624396d9630
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..21a29cc8445e5
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-1.41.0.jar.sha1
@@ -0,0 +1 @@
+d86e60b6d49e389ebe5797d42a7288a20d30c162
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-common-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-common-1.36.0.jar.sha1
deleted file mode 100644
index 378ba4d43dcd1..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-common-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-2706e3b883d2bcd1a6b3e0bb4118ffbd7820550b
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-common-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-common-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..ae522ac698aa8
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-exporter-otlp-common-1.41.0.jar.sha1
@@ -0,0 +1 @@
+aeba3075b8dfd97779edadc0a3711d999bb0e396
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-sender-okhttp-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-sender-okhttp-1.36.0.jar.sha1
deleted file mode 100644
index a3d7e15e1a624..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-exporter-sender-okhttp-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-dcc924787b559278697b74dbc5bb6d046b236ef6
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-exporter-sender-okhttp-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-exporter-sender-okhttp-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..a741d0a167d60
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-exporter-sender-okhttp-1.41.0.jar.sha1
@@ -0,0 +1 @@
+368d7905d6a0a313c63e3a91f895a3a08500519e
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-extension-incubator-1.36.0-alpha.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-extension-incubator-1.36.0-alpha.jar.sha1
deleted file mode 100644
index 71ab3e184db9e..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-extension-incubator-1.36.0-alpha.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-d58f7c669e371f6ff61b705770af9a3c1f31df52
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-1.36.0.jar.sha1
deleted file mode 100644
index c9a75d1b4350a..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-sdk-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-4056d1b562b4da7720817d8af15d1d3ccdf4b776
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..972e7de1c74be
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-sdk-1.41.0.jar.sha1
@@ -0,0 +1 @@
+c740e8f7d0d914d6acd310ac53901bb8753c6e8d
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-common-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-common-1.36.0.jar.sha1
deleted file mode 100644
index c31584f59c0d8..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-sdk-common-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-11d6f8c7b029efcb5c6c449cadef155b781afb78
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-common-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-common-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..c56ca0b9e8169
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-sdk-common-1.41.0.jar.sha1
@@ -0,0 +1 @@
+b820861f85ba83db0ad896c47f723208d7473d5a
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-logs-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-logs-1.36.0.jar.sha1
deleted file mode 100644
index a134bb06ec635..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-sdk-logs-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-98e94479db1e68c4779efc44bf6b4fca83e98b54
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-logs-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-logs-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..39db6cb73727f
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-sdk-logs-1.41.0.jar.sha1
@@ -0,0 +1 @@
+f88ee292f5605c87dfe85c8d90131bce9f0b3b8e
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-metrics-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-metrics-1.36.0.jar.sha1
deleted file mode 100644
index d146241f52f29..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-sdk-metrics-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-4f8f5d30c3eeede7b2260d979d9f403cfa381c3d
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-metrics-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-metrics-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..6dcd496e033d3
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-sdk-metrics-1.41.0.jar.sha1
@@ -0,0 +1 @@
+9d1200befb28e3e9f61073ac3de23cc55e509dc7
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-trace-1.36.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-trace-1.36.0.jar.sha1
deleted file mode 100644
index 802761e38846c..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-sdk-trace-1.36.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e3068cbaedfac6a28c6483923982b2efb861d3f4
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-sdk-trace-1.41.0.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-sdk-trace-1.41.0.jar.sha1
new file mode 100644
index 0000000000000..161e400f87077
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-sdk-trace-1.41.0.jar.sha1
@@ -0,0 +1 @@
+d9bbc2e2e800317d72fbf3141ae8391e95fa6229
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-semconv-1.23.1-alpha.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-semconv-1.23.1-alpha.jar.sha1
deleted file mode 100644
index e730c83af905e..0000000000000
--- a/plugins/telemetry-otel/licenses/opentelemetry-semconv-1.23.1-alpha.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-218e361772670212a46be5940010222d68e66f2a
\ No newline at end of file
diff --git a/plugins/telemetry-otel/licenses/opentelemetry-semconv-1.27.0-alpha.jar.sha1 b/plugins/telemetry-otel/licenses/opentelemetry-semconv-1.27.0-alpha.jar.sha1
new file mode 100644
index 0000000000000..e986b4b53388e
--- /dev/null
+++ b/plugins/telemetry-otel/licenses/opentelemetry-semconv-1.27.0-alpha.jar.sha1
@@ -0,0 +1 @@
+906d916bee46f60260c09314284b5948c54a0662
\ No newline at end of file
diff --git a/plugins/telemetry-otel/src/internalClusterTest/java/org/opensearch/telemetry/metrics/TelemetryMetricsEnabledSanityIT.java b/plugins/telemetry-otel/src/internalClusterTest/java/org/opensearch/telemetry/metrics/TelemetryMetricsEnabledSanityIT.java
index 90143d907cd99..b0582624e21d5 100644
--- a/plugins/telemetry-otel/src/internalClusterTest/java/org/opensearch/telemetry/metrics/TelemetryMetricsEnabledSanityIT.java
+++ b/plugins/telemetry-otel/src/internalClusterTest/java/org/opensearch/telemetry/metrics/TelemetryMetricsEnabledSanityIT.java
@@ -23,10 +23,13 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.sdk.metrics.data.DoublePointData;
 import io.opentelemetry.sdk.metrics.data.MetricData;
 import io.opentelemetry.sdk.metrics.internal.data.ImmutableExponentialHistogramPointData;
@@ -147,6 +150,36 @@ public void testGauge() throws Exception {
 
     }
 
+    public void testGaugeWithValueAndTagSupplier() throws Exception {
+        String metricName = "test-gauge";
+        MetricsRegistry metricsRegistry = internalCluster().getInstance(MetricsRegistry.class);
+        InMemorySingletonMetricsExporter.INSTANCE.reset();
+        Tags tags = Tags.create().addTag("test", "integ-test");
+        final AtomicInteger testValue = new AtomicInteger(0);
+        Supplier<TaggedMeasurement> valueProvider = () -> {
+            return TaggedMeasurement.create(Double.valueOf(testValue.incrementAndGet()), tags);
+        };
+        Closeable gaugeCloseable = metricsRegistry.createGauge(metricName, "test", "ms", valueProvider);
+        // Sleep for about 2.2s to wait for metrics to be published.
+        Thread.sleep(2200);
+
+        InMemorySingletonMetricsExporter exporter = InMemorySingletonMetricsExporter.INSTANCE;
+
+        assertTrue(getMaxObservableGaugeValue(exporter, metricName) >= 2.0);
+
+        gaugeCloseable.close();
+        double observableGaugeValueAfterStop = getMaxObservableGaugeValue(exporter, metricName);
+
+        Map<AttributeKey<?>, Object> attributes = getMetricAttributes(exporter, metricName);
+
+        assertEquals("integ-test", attributes.get(AttributeKey.stringKey("test")));
+
+        // Sleep for about 1.2s to wait for metrics to see that closed observableGauge shouldn't execute the callable.
+        Thread.sleep(1200);
+        assertEquals(observableGaugeValueAfterStop, getMaxObservableGaugeValue(exporter, metricName), 0.0);
+
+    }
+
     private static double getMaxObservableGaugeValue(InMemorySingletonMetricsExporter exporter, String metricName) {
         List<MetricData> dataPoints = exporter.getFinishedMetricItems()
             .stream()
@@ -159,6 +192,15 @@ private static double getMaxObservableGaugeValue(InMemorySingletonMetricsExporte
         return totalValue;
     }
 
+    private static Map<AttributeKey<?>, Object> getMetricAttributes(InMemorySingletonMetricsExporter exporter, String metricName) {
+        List<MetricData> dataPoints = exporter.getFinishedMetricItems()
+            .stream()
+            .filter(a -> a.getName().contains(metricName))
+            .collect(Collectors.toList());
+        Attributes attributes = dataPoints.get(0).getDoubleGaugeData().getPoints().stream().findAny().get().getAttributes();
+        return attributes.asMap();
+    }
+
     @After
     public void reset() {
         InMemorySingletonMetricsExporter.INSTANCE.reset();
diff --git a/plugins/telemetry-otel/src/main/java/org/opensearch/telemetry/metrics/OTelMetricsTelemetry.java b/plugins/telemetry-otel/src/main/java/org/opensearch/telemetry/metrics/OTelMetricsTelemetry.java
index 6fe08040d7af5..3258e91738ba6 100644
--- a/plugins/telemetry-otel/src/main/java/org/opensearch/telemetry/metrics/OTelMetricsTelemetry.java
+++ b/plugins/telemetry-otel/src/main/java/org/opensearch/telemetry/metrics/OTelMetricsTelemetry.java
@@ -101,6 +101,17 @@ public Closeable createGauge(String name, String description, String unit, Suppl
         return () -> doubleObservableGauge.close();
     }
 
+    @Override
+    public Closeable createGauge(String name, String description, String unit, Supplier<TaggedMeasurement> value) {
+        ObservableDoubleGauge doubleObservableGauge = AccessController.doPrivileged(
+            (PrivilegedAction<ObservableDoubleGauge>) () -> otelMeter.gaugeBuilder(name)
+                .setUnit(unit)
+                .setDescription(description)
+                .buildWithCallback(record -> record.record(value.get().getValue(), OTelAttributesConverter.convert(value.get().getTags())))
+        );
+        return () -> doubleObservableGauge.close();
+    }
+
     @Override
     public void close() throws IOException {
         meterProvider.close();
diff --git a/plugins/telemetry-otel/src/test/java/org/opensearch/telemetry/metrics/OTelMetricsTelemetryTests.java b/plugins/telemetry-otel/src/test/java/org/opensearch/telemetry/metrics/OTelMetricsTelemetryTests.java
index 2e89a3c488d5c..794cafc1fb608 100644
--- a/plugins/telemetry-otel/src/test/java/org/opensearch/telemetry/metrics/OTelMetricsTelemetryTests.java
+++ b/plugins/telemetry-otel/src/test/java/org/opensearch/telemetry/metrics/OTelMetricsTelemetryTests.java
@@ -180,4 +180,34 @@ public void testGauge() throws Exception {
         closeable.close();
         verify(observableDoubleGauge).close();
     }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public void testGaugeWithValueAndTagsSupplier() throws Exception {
+        String observableGaugeName = "test-gauge";
+        String description = "test";
+        String unit = "1";
+        Meter mockMeter = mock(Meter.class);
+        OpenTelemetry mockOpenTelemetry = mock(OpenTelemetry.class);
+        ObservableDoubleGauge observableDoubleGauge = mock(ObservableDoubleGauge.class);
+        DoubleGaugeBuilder mockOTelDoubleGaugeBuilder = mock(DoubleGaugeBuilder.class);
+        MeterProvider meterProvider = mock(MeterProvider.class);
+        when(meterProvider.get(OTelTelemetryPlugin.INSTRUMENTATION_SCOPE_NAME)).thenReturn(mockMeter);
+        MetricsTelemetry metricsTelemetry = new OTelMetricsTelemetry(
+            new RefCountedReleasable("telemetry", mockOpenTelemetry, () -> {}),
+            meterProvider
+        );
+        when(mockMeter.gaugeBuilder(Mockito.contains(observableGaugeName))).thenReturn(mockOTelDoubleGaugeBuilder);
+        when(mockOTelDoubleGaugeBuilder.setDescription(description)).thenReturn(mockOTelDoubleGaugeBuilder);
+        when(mockOTelDoubleGaugeBuilder.setUnit(unit)).thenReturn(mockOTelDoubleGaugeBuilder);
+        when(mockOTelDoubleGaugeBuilder.buildWithCallback(any(Consumer.class))).thenReturn(observableDoubleGauge);
+
+        Closeable closeable = metricsTelemetry.createGauge(
+            observableGaugeName,
+            description,
+            unit,
+            () -> TaggedMeasurement.create(1.0, Tags.EMPTY)
+        );
+        closeable.close();
+        verify(observableDoubleGauge).close();
+    }
 }
diff --git a/plugins/transport-nio/licenses/netty-buffer-4.1.110.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-buffer-4.1.110.Final.jar.sha1
deleted file mode 100644
index faaf70c858a6e..0000000000000
--- a/plugins/transport-nio/licenses/netty-buffer-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3d918a9ee057d995c362902b54634fc307132aac
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-buffer-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-buffer-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5c26883046fed
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-buffer-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+bdc12df04bb6858890b8aa108060b5b365a26102
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-codec-4.1.110.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-codec-4.1.110.Final.jar.sha1
deleted file mode 100644
index 7affbc14fa93a..0000000000000
--- a/plugins/transport-nio/licenses/netty-codec-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f1fa43b03e93ab88e805b6a4e3e83780c80b47d2
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-codec-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-codec-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..1fd224fdd0b44
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-codec-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+c87f2ec3d9a97bd2b793d16817abb2bab93a7fc3
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-codec-http-4.1.110.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-codec-http-4.1.110.Final.jar.sha1
deleted file mode 100644
index 07730a5606ce2..0000000000000
--- a/plugins/transport-nio/licenses/netty-codec-http-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-9d05cd927209ea25bbf342962c00b8e5a828c2a4
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-codec-http-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-codec-http-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..22d35128c3ad5
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-codec-http-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+81af1040bfa977f98dd0e1bd9639513ea862ca04
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-common-4.1.110.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-common-4.1.110.Final.jar.sha1
deleted file mode 100644
index 568c0aa2a2c03..0000000000000
--- a/plugins/transport-nio/licenses/netty-common-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ec361e7e025c029be50c55c8480080cabcbc01e7
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-common-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-common-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..47af3100f0f2d
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-common-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b2798069092a981a832b7510d0462ee9efb7a80e
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-handler-4.1.110.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-handler-4.1.110.Final.jar.sha1
deleted file mode 100644
index 2d6050dd1e3a5..0000000000000
--- a/plugins/transport-nio/licenses/netty-handler-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-168db749c22652ee7fed1ebf7ec46ce856d75e51
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-handler-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-handler-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..8b30272861770
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-handler-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+3d5e2d5bcc6baeeb8c13a230980c6132a778e036
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-resolver-4.1.110.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-resolver-4.1.110.Final.jar.sha1
deleted file mode 100644
index c3ee8087a8b5d..0000000000000
--- a/plugins/transport-nio/licenses/netty-resolver-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-66c15921104cda0159b34e316541bc765dfaf3c0
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-resolver-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-resolver-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..1a094fa19a623
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-resolver-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+58a631d9d44c4ed7cc0dcc9cffa6641da9374d72
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-transport-4.1.110.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-transport-4.1.110.Final.jar.sha1
deleted file mode 100644
index 32c8fa2b876a2..0000000000000
--- a/plugins/transport-nio/licenses/netty-transport-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b91f04c39ac14d6a29d07184ef305953ee6e0348
\ No newline at end of file
diff --git a/plugins/transport-nio/licenses/netty-transport-4.1.112.Final.jar.sha1 b/plugins/transport-nio/licenses/netty-transport-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5fbfde0836e0c
--- /dev/null
+++ b/plugins/transport-nio/licenses/netty-transport-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+77cd136dd3843f5e7cbcf68c824975d745c49ddb
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/build.gradle b/plugins/transport-reactor-netty4/build.gradle
index 1a94def3fdff1..089e57f062a9f 100644
--- a/plugins/transport-reactor-netty4/build.gradle
+++ b/plugins/transport-reactor-netty4/build.gradle
@@ -46,7 +46,7 @@ dependencies {
   api "io.projectreactor.netty:reactor-netty-core:${versions.reactor_netty}"
 
   testImplementation "org.apache.logging.log4j:log4j-slf4j-impl:${versions.log4j}"
-  testImplementation "io.projectreactor:reactor-test:${versions.reactor}"
+  javaRestTestImplementation "io.projectreactor:reactor-test:${versions.reactor}"
   testImplementation project(":modules:transport-netty4")
 }
 
@@ -80,6 +80,10 @@ javaRestTest {
   systemProperty 'opensearch.set.netty.runtime.available.processors', 'false'
 }
 
+testClusters.javaRestTest {
+  setting 'http.type', 'reactor-netty4'
+}
+
 thirdPartyAudit {
   ignoreMissingClasses(
     'com.aayushatharva.brotli4j.Brotli4jLoader',
diff --git a/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.110.Final.jar.sha1
deleted file mode 100644
index faaf70c858a6e..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3d918a9ee057d995c362902b54634fc307132aac
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5c26883046fed
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-buffer-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+bdc12df04bb6858890b8aa108060b5b365a26102
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.110.Final.jar.sha1
deleted file mode 100644
index 7affbc14fa93a..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-f1fa43b03e93ab88e805b6a4e3e83780c80b47d2
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..1fd224fdd0b44
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-codec-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+c87f2ec3d9a97bd2b793d16817abb2bab93a7fc3
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.110.Final.jar.sha1
deleted file mode 100644
index c4ca8f15e85c5..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-381c5bf8b7570c163fa7893a26d02b7ac36ff6eb
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..a42a41b6387c8
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-codec-dns-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+06724b184ee870ecc4d8fc36931beeb3c387b0ee
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.110.Final.jar.sha1
deleted file mode 100644
index 07730a5606ce2..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-9d05cd927209ea25bbf342962c00b8e5a828c2a4
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..22d35128c3ad5
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-codec-http-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+81af1040bfa977f98dd0e1bd9639513ea862ca04
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.110.Final.jar.sha1
deleted file mode 100644
index ebd1e0d52efb2..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-e0849843eb5b1c036b12551baca98a9f7ff847a0
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..d4767d06b22bf
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-codec-http2-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+7fa28b510f0f16f4d5d7188b86bef59e048f62f9
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-common-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-common-4.1.110.Final.jar.sha1
deleted file mode 100644
index 568c0aa2a2c03..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-common-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-ec361e7e025c029be50c55c8480080cabcbc01e7
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-common-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-common-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..47af3100f0f2d
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-common-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b2798069092a981a832b7510d0462ee9efb7a80e
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.110.Final.jar.sha1
deleted file mode 100644
index 2d6050dd1e3a5..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-168db749c22652ee7fed1ebf7ec46ce856d75e51
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..8b30272861770
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-handler-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+3d5e2d5bcc6baeeb8c13a230980c6132a778e036
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.110.Final.jar.sha1
deleted file mode 100644
index c3ee8087a8b5d..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-66c15921104cda0159b34e316541bc765dfaf3c0
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..1a094fa19a623
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-resolver-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+58a631d9d44c4ed7cc0dcc9cffa6641da9374d72
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.110.Final.jar.sha1
deleted file mode 100644
index 18d122acd2c44..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3e687cdc4ecdbbad07508a11b715bdf95fa20939
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..24e8177190e04
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-resolver-dns-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+375872f1c16bb51aac016ff6ee4f5d28b1288d4d
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.110.Final.jar.sha1
deleted file mode 100644
index 32c8fa2b876a2..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b91f04c39ac14d6a29d07184ef305953ee6e0348
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..5fbfde0836e0c
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-transport-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+77cd136dd3843f5e7cbcf68c824975d745c49ddb
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1
deleted file mode 100644
index 2c468962b1b64..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.110.Final.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-a7096e7c0a25a983647909d7513f5d4943d589c0
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1 b/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
new file mode 100644
index 0000000000000..8dad0e3104dc8
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/netty-transport-native-unix-common-4.1.112.Final.jar.sha1
@@ -0,0 +1 @@
+b50ff619cdcdc48e748cba3405c9988529f28f60
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/reactor-netty-core-1.1.19.jar.sha1 b/plugins/transport-reactor-netty4/licenses/reactor-netty-core-1.1.19.jar.sha1
deleted file mode 100644
index cbcbfcd87d682..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/reactor-netty-core-1.1.19.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-639e2c63ade6f2a49d7e501ca2264b74d240b448
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/reactor-netty-core-1.1.22.jar.sha1 b/plugins/transport-reactor-netty4/licenses/reactor-netty-core-1.1.22.jar.sha1
new file mode 100644
index 0000000000000..cc894568c5760
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/reactor-netty-core-1.1.22.jar.sha1
@@ -0,0 +1 @@
+08356b59b29f86e7142c9daca0434653a64ae64b
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/reactor-netty-http-1.1.19.jar.sha1 b/plugins/transport-reactor-netty4/licenses/reactor-netty-http-1.1.19.jar.sha1
deleted file mode 100644
index 1eeedfc0926f5..0000000000000
--- a/plugins/transport-reactor-netty4/licenses/reactor-netty-http-1.1.19.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b4bbb1aeb64ecb2b3949c38983032a7f0b0ebd07
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/licenses/reactor-netty-http-1.1.22.jar.sha1 b/plugins/transport-reactor-netty4/licenses/reactor-netty-http-1.1.22.jar.sha1
new file mode 100644
index 0000000000000..2402813f831ce
--- /dev/null
+++ b/plugins/transport-reactor-netty4/licenses/reactor-netty-http-1.1.22.jar.sha1
@@ -0,0 +1 @@
+2faf64b3822b0512f15d72a325e2826eb8564413
\ No newline at end of file
diff --git a/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4BadRequestIT.java b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4BadRequestIT.java
new file mode 100644
index 0000000000000..b1d21fe4eee09
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4BadRequestIT.java
@@ -0,0 +1,127 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.rest;
+
+import org.opensearch.client.Request;
+import org.opensearch.client.RequestOptions;
+import org.opensearch.client.Response;
+import org.opensearch.client.ResponseException;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.http.HttpTransportSettings;
+import org.opensearch.test.rest.OpenSearchRestTestCase;
+import org.opensearch.test.rest.yaml.ObjectPath;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.util.Map;
+
+import static org.opensearch.core.rest.RestStatus.REQUEST_URI_TOO_LONG;
+import static org.hamcrest.Matchers.equalTo;
+
+public class ReactorNetty4BadRequestIT extends OpenSearchRestTestCase {
+
+    public void testBadRequest() throws IOException {
+        final Response response = client().performRequest(new Request("GET", "/_nodes/settings"));
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final Map<String, Object> map = objectPath.evaluate("nodes");
+        int maxMaxInitialLineLength = Integer.MIN_VALUE;
+        final Setting<ByteSizeValue> httpMaxInitialLineLength = HttpTransportSettings.SETTING_HTTP_MAX_INITIAL_LINE_LENGTH;
+        final String key = httpMaxInitialLineLength.getKey().substring("http.".length());
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            @SuppressWarnings("unchecked")
+            final Map<String, Object> settings = (Map<String, Object>) ((Map<String, Object>) entry.getValue()).get("settings");
+            final int maxIntialLineLength;
+            if (settings.containsKey("http")) {
+                @SuppressWarnings("unchecked")
+                final Map<String, Object> httpSettings = (Map<String, Object>) settings.get("http");
+                if (httpSettings.containsKey(key)) {
+                    maxIntialLineLength = ByteSizeValue.parseBytesSizeValue((String) httpSettings.get(key), key).bytesAsInt();
+                } else {
+                    maxIntialLineLength = httpMaxInitialLineLength.getDefault(Settings.EMPTY).bytesAsInt();
+                }
+            } else {
+                maxIntialLineLength = httpMaxInitialLineLength.getDefault(Settings.EMPTY).bytesAsInt();
+            }
+            maxMaxInitialLineLength = Math.max(maxMaxInitialLineLength, maxIntialLineLength);
+        }
+
+        final String path = "/" + new String(new byte[maxMaxInitialLineLength], Charset.forName("UTF-8")).replace('\0', 'a');
+        final ResponseException e = expectThrows(
+            ResponseException.class,
+            () -> client().performRequest(new Request(randomFrom("GET", "POST", "PUT"), path))
+        );
+        // The reactor-netty implementation does not provide a hook to customize or intercept request decoder errors at the moment (see
+        // please https://github.com/reactor/reactor-netty/issues/3327).
+        assertThat(e.getResponse().getStatusLine().getStatusCode(), equalTo(REQUEST_URI_TOO_LONG.getStatus()));
+    }
+
+    public void testInvalidParameterValue() throws IOException {
+        final Request request = new Request("GET", "/_cluster/settings");
+        request.addParameter("pretty", "neither-true-nor-false");
+        final ResponseException e = expectThrows(ResponseException.class, () -> client().performRequest(request));
+        final Response response = e.getResponse();
+        assertThat(response.getStatusLine().getStatusCode(), equalTo(400));
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final Map<String, Object> map = objectPath.evaluate("error");
+        assertThat(map.get("type"), equalTo("illegal_argument_exception"));
+        assertThat(map.get("reason"), equalTo("Failed to parse value [neither-true-nor-false] as only [true] or [false] are allowed."));
+    }
+
+    public void testInvalidHeaderValue() throws IOException {
+        final Request request = new Request("GET", "/_cluster/settings");
+        final RequestOptions.Builder options = request.getOptions().toBuilder();
+        options.addHeader("Content-Type", "\t");
+        request.setOptions(options);
+        final ResponseException e = expectThrows(ResponseException.class, () -> client().performRequest(request));
+        final Response response = e.getResponse();
+        assertThat(response.getStatusLine().getStatusCode(), equalTo(400));
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final Map<String, Object> map = objectPath.evaluate("error");
+        assertThat(map.get("type"), equalTo("content_type_header_exception"));
+        assertThat(map.get("reason"), equalTo("java.lang.IllegalArgumentException: invalid Content-Type header []"));
+    }
+
+    public void testUnsupportedContentType() throws IOException {
+        final Request request = new Request("POST", "/_bulk/stream");
+        final RequestOptions.Builder options = request.getOptions().toBuilder();
+        request.setOptions(options);
+        final ResponseException e = expectThrows(ResponseException.class, () -> client().performRequest(request));
+        final Response response = e.getResponse();
+        assertThat(response.getStatusLine().getStatusCode(), equalTo(406));
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final String error = objectPath.evaluate("error");
+        assertThat(error, equalTo("Content-Type header [] is not supported"));
+    }
+}
diff --git a/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4HeadBodyIsEmptyIT.java b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4HeadBodyIsEmptyIT.java
new file mode 100644
index 0000000000000..663eb9ef6e946
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4HeadBodyIsEmptyIT.java
@@ -0,0 +1,204 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.rest;
+
+import org.opensearch.client.Request;
+import org.opensearch.client.Response;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.test.rest.OpenSearchRestTestCase;
+import org.hamcrest.Matcher;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonMap;
+import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
+import static org.opensearch.core.rest.RestStatus.NOT_FOUND;
+import static org.opensearch.core.rest.RestStatus.OK;
+import static org.hamcrest.Matchers.greaterThan;
+
+public class ReactorNetty4HeadBodyIsEmptyIT extends OpenSearchRestTestCase {
+    public void testHeadRoot() throws IOException {
+        headTestCase("/", emptyMap(), greaterThan(0));
+        headTestCase("/", singletonMap("pretty", ""), greaterThan(0));
+        headTestCase("/", singletonMap("pretty", "true"), greaterThan(0));
+    }
+
+    private void createTestDoc() throws IOException {
+        createTestDoc("test");
+    }
+
+    private void createTestDoc(final String indexName) throws IOException {
+        try (XContentBuilder builder = jsonBuilder()) {
+            builder.startObject();
+            {
+                builder.field("test", "test");
+            }
+            builder.endObject();
+            Request request = new Request("PUT", "/" + indexName + "/_doc/" + "1");
+            request.setJsonEntity(builder.toString());
+            client().performRequest(request);
+        }
+    }
+
+    public void testDocumentExists() throws IOException {
+        createTestDoc();
+        headTestCase("/test/_doc/1", emptyMap(), greaterThan(0));
+        headTestCase("/test/_doc/1", singletonMap("pretty", "true"), greaterThan(0));
+        headTestCase("/test/_doc/2", emptyMap(), NOT_FOUND.getStatus(), greaterThan(0));
+    }
+
+    public void testIndexExists() throws IOException {
+        createTestDoc();
+        headTestCase("/test", emptyMap(), greaterThan(0));
+        headTestCase("/test", singletonMap("pretty", "true"), greaterThan(0));
+    }
+
+    public void testAliasExists() throws IOException {
+        createTestDoc();
+        try (XContentBuilder builder = jsonBuilder()) {
+            builder.startObject();
+            {
+                builder.startArray("actions");
+                {
+                    builder.startObject();
+                    {
+                        builder.startObject("add");
+                        {
+                            builder.field("index", "test");
+                            builder.field("alias", "test_alias");
+                        }
+                        builder.endObject();
+                    }
+                    builder.endObject();
+                }
+                builder.endArray();
+            }
+            builder.endObject();
+
+            Request request = new Request("POST", "/_aliases");
+            request.setJsonEntity(builder.toString());
+            client().performRequest(request);
+            headTestCase("/_alias/test_alias", emptyMap(), greaterThan(0));
+            headTestCase("/test/_alias/test_alias", emptyMap(), greaterThan(0));
+        }
+    }
+
+    public void testAliasDoesNotExist() throws IOException {
+        createTestDoc();
+        headTestCase("/_alias/test_alias", emptyMap(), NOT_FOUND.getStatus(), greaterThan(0));
+        headTestCase("/test/_alias/test_alias", emptyMap(), NOT_FOUND.getStatus(), greaterThan(0));
+    }
+
+    public void testTemplateExists() throws IOException {
+        try (XContentBuilder builder = jsonBuilder()) {
+            builder.startObject();
+            {
+                builder.array("index_patterns", "*");
+                builder.startObject("settings");
+                {
+                    builder.field("number_of_replicas", 0);
+                }
+                builder.endObject();
+            }
+            builder.endObject();
+
+            Request request = new Request("PUT", "/_template/template");
+            request.setJsonEntity(builder.toString());
+            client().performRequest(request);
+            headTestCase("/_template/template", emptyMap(), greaterThan(0));
+        }
+    }
+
+    public void testGetSourceAction() throws IOException {
+        createTestDoc();
+        headTestCase("/test/_source/1", emptyMap(), greaterThan(0));
+        headTestCase("/test/_source/2", emptyMap(), NOT_FOUND.getStatus(), greaterThan(0));
+
+        try (XContentBuilder builder = jsonBuilder()) {
+            builder.startObject();
+            {
+                builder.startObject("mappings");
+                {
+                    builder.startObject("_source");
+                    {
+                        builder.field("enabled", false);
+                    }
+                    builder.endObject();
+                }
+                builder.endObject();
+            }
+            builder.endObject();
+
+            Request request = new Request("PUT", "/test-no-source");
+            request.setJsonEntity(builder.toString());
+            client().performRequest(request);
+            createTestDoc("test-no-source");
+            headTestCase("/test-no-source/_source/1", emptyMap(), NOT_FOUND.getStatus(), greaterThan(0));
+        }
+    }
+
+    public void testException() throws IOException {
+        /*
+         * This will throw an index not found exception which will be sent on the channel; previously when handling HEAD requests that would
+         * throw an exception, the content was swallowed and a content length header of zero was returned. Instead of swallowing the content
+         * we now let it rise up to the upstream channel so that it can compute the content length that would be returned. This test case is
+         * a test for this situation.
+         */
+        headTestCase("/index-not-found-exception", emptyMap(), NOT_FOUND.getStatus(), greaterThan(0));
+    }
+
+    private void headTestCase(final String url, final Map<String, String> params, final Matcher<Integer> matcher) throws IOException {
+        headTestCase(url, params, OK.getStatus(), matcher);
+    }
+
+    private void headTestCase(
+        final String url,
+        final Map<String, String> params,
+        final int expectedStatusCode,
+        final Matcher<Integer> matcher,
+        final String... expectedWarnings
+    ) throws IOException {
+        Request request = new Request("HEAD", url);
+        for (Map.Entry<String, String> param : params.entrySet()) {
+            request.addParameter(param.getKey(), param.getValue());
+        }
+        request.setOptions(expectWarnings(expectedWarnings));
+        Response response = client().performRequest(request);
+        assertEquals(expectedStatusCode, response.getStatusLine().getStatusCode());
+        assertThat(Integer.valueOf(response.getHeader("Content-Length")), matcher);
+        assertNull("HEAD requests shouldn't have a response body but " + url + " did", response.getEntity());
+    }
+
+}
diff --git a/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingIT.java b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingIT.java
new file mode 100644
index 0000000000000..6f3895fffa437
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingIT.java
@@ -0,0 +1,300 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest;
+
+import org.opensearch.client.Request;
+import org.opensearch.client.Response;
+import org.opensearch.client.ResponseException;
+import org.opensearch.client.StreamingRequest;
+import org.opensearch.client.StreamingResponse;
+import org.opensearch.test.rest.OpenSearchRestTestCase;
+import org.opensearch.test.rest.yaml.ObjectPath;
+import org.junit.After;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import reactor.core.publisher.Flux;
+import reactor.test.StepVerifier;
+import reactor.test.scheduler.VirtualTimeScheduler;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+
+public class ReactorNetty4StreamingIT extends OpenSearchRestTestCase {
+    @After
+    @Override
+    public void tearDown() throws Exception {
+        final Request request = new Request("DELETE", "/test-streaming");
+        request.addParameter("ignore_unavailable", "true");
+
+        final Response response = client().performRequest(request);
+        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
+
+        super.tearDown();
+    }
+
+    public void testStreamingRequestNoBatching() throws IOException {
+        final VirtualTimeScheduler scheduler = VirtualTimeScheduler.create(true);
+
+        final Stream<String> stream = IntStream.range(1, 6)
+            .mapToObj(id -> "{ \"index\": { \"_index\": \"test-streaming\", \"_id\": \"" + id + "\" } }\n" + "{ \"name\": \"josh\" }\n");
+
+        final Duration delay = Duration.ofMillis(1);
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).delayElements(delay, scheduler).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+        streamingRequest.addParameter("refresh", "true");
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+        scheduler.advanceTimeBy(delay); /* emit first element */
+
+        StepVerifier.create(Flux.from(streamingResponse.getBody()).map(b -> new String(b.array(), StandardCharsets.UTF_8)))
+            .expectNextMatches(s -> s.contains("\"result\":\"created\"") && s.contains("\"_id\":\"1\""))
+            .then(() -> scheduler.advanceTimeBy(delay))
+            .expectNextMatches(s -> s.contains("\"result\":\"created\"") && s.contains("\"_id\":\"2\""))
+            .then(() -> scheduler.advanceTimeBy(delay))
+            .expectNextMatches(s -> s.contains("\"result\":\"created\"") && s.contains("\"_id\":\"3\""))
+            .then(() -> scheduler.advanceTimeBy(delay))
+            .expectNextMatches(s -> s.contains("\"result\":\"created\"") && s.contains("\"_id\":\"4\""))
+            .then(() -> scheduler.advanceTimeBy(delay))
+            .expectNextMatches(s -> s.contains("\"result\":\"created\"") && s.contains("\"_id\":\"5\""))
+            .then(() -> scheduler.advanceTimeBy(delay))
+            .expectComplete()
+            .verify();
+
+        assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(200));
+        assertThat(streamingResponse.getWarnings(), empty());
+
+        final Request request = new Request("GET", "/test-streaming/_count");
+        final Response response = client().performRequest(request);
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final Integer count = objectPath.evaluate("count");
+        assertThat(count, equalTo(5));
+    }
+
+    public void testStreamingRequestOneBatchBySize() throws IOException, InterruptedException {
+        final Stream<String> stream = IntStream.range(1, 6)
+            .mapToObj(id -> "{ \"index\": { \"_index\": \"test-streaming\", \"_id\": \"" + id + "\" } }\n" + "{ \"name\": \"josh\" }\n");
+
+        final Duration delay = Duration.ofMillis(1);
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).delayElements(delay).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+        streamingRequest.addParameter("refresh", "true");
+        streamingRequest.addParameter("batch_size", "5");
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+
+        StepVerifier.create(Flux.from(streamingResponse.getBody()).map(b -> new String(b.array(), StandardCharsets.UTF_8)))
+            .expectNextMatches(
+                s -> s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"1\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"2\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"3\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"4\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"5\"")
+            )
+            .expectComplete()
+            .verify();
+
+        assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(200));
+        assertThat(streamingResponse.getWarnings(), empty());
+
+        final Request request = new Request("GET", "/test-streaming/_count");
+        final Response response = client().performRequest(request);
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final Integer count = objectPath.evaluate("count");
+        assertThat(count, equalTo(5));
+    }
+
+    public void testStreamingRequestManyBatchesBySize() throws IOException {
+        final Stream<String> stream = IntStream.range(1, 6)
+            .mapToObj(id -> "{ \"index\": { \"_index\": \"test-streaming\", \"_id\": \"" + id + "\" } }\n" + "{ \"name\": \"josh\" }\n");
+
+        final Duration delay = Duration.ofMillis(1);
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).delayElements(delay).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+        streamingRequest.addParameter("refresh", "true");
+        streamingRequest.addParameter("batch_size", "3");
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+
+        StepVerifier.create(Flux.from(streamingResponse.getBody()).map(b -> new String(b.array(), StandardCharsets.UTF_8)))
+            .expectNextMatches(
+                s -> s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"1\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"2\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"3\"")
+            )
+            .expectNextMatches(
+                s -> s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"4\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"5\"")
+            )
+            .expectComplete()
+            .verify();
+
+        assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(200));
+        assertThat(streamingResponse.getWarnings(), empty());
+
+        final Request request = new Request("GET", "/test-streaming/_count");
+        final Response response = client().performRequest(request);
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final Integer count = objectPath.evaluate("count");
+        assertThat(count, equalTo(5));
+    }
+
+    public void testStreamingRequestManyBatchesByInterval() throws IOException {
+        final Stream<String> stream = IntStream.range(1, 6)
+            .mapToObj(id -> "{ \"index\": { \"_index\": \"test-streaming\", \"_id\": \"" + id + "\" } }\n" + "{ \"name\": \"josh\" }\n");
+
+        final Duration delay = Duration.ofMillis(500);
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).delayElements(delay).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+        streamingRequest.addParameter("refresh", "true");
+        streamingRequest.addParameter("batch_interval", "5s");
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+
+        // We don't check for a other documents here since those may appear in any of the chunks (it is very
+        // difficult to get the timing right). But at the end, the total number of the documents is being checked.
+        StepVerifier.create(Flux.from(streamingResponse.getBody()).map(b -> new String(b.array(), StandardCharsets.UTF_8)))
+            .expectNextMatches(
+                s -> s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"1\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"2\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"3\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"4\"")
+                    && s.contains("\"result\":\"created\"")
+                    && s.contains("\"_id\":\"5\"")
+            )
+            .expectComplete()
+            .verify();
+
+        assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(200));
+        assertThat(streamingResponse.getWarnings(), empty());
+
+        final Request request = new Request("GET", "/test-streaming/_count");
+        final Response response = client().performRequest(request);
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final Integer count = objectPath.evaluate("count");
+        assertThat(count, equalTo(5));
+    }
+
+    public void testStreamingRequestManyBatchesByIntervalAndSize() throws IOException {
+        final Stream<String> stream = IntStream.range(1, 6)
+            .mapToObj(id -> "{ \"index\": { \"_index\": \"test-streaming\", \"_id\": \"" + id + "\" } }\n" + "{ \"name\": \"josh\" }\n");
+
+        final Duration delay = Duration.ofSeconds(1);
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).delayElements(delay).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+        streamingRequest.addParameter("refresh", "true");
+        streamingRequest.addParameter("batch_interval", "3s");
+        streamingRequest.addParameter("batch_size", "5");
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+
+        // We don't check for a other documents here since those may appear in any of the chunks (it is very
+        // difficult to get the timing right). But at the end, the total number of the documents is being checked.
+        StepVerifier.create(Flux.from(streamingResponse.getBody()).map(b -> new String(b.array(), StandardCharsets.UTF_8)))
+            .expectNextMatches(s -> s.contains("\"result\":\"created\"") && s.contains("\"_id\":\"1\""))
+            .expectNextMatches(s -> s.contains("\"result\":\"created\"") && s.contains("\"_id\":\"5\""))
+            .expectComplete()
+            .verify();
+
+        assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(200));
+        assertThat(streamingResponse.getWarnings(), empty());
+
+        final Request request = new Request("GET", "/test-streaming/_count");
+        final Response response = client().performRequest(request);
+        final ObjectPath objectPath = ObjectPath.createFromResponse(response);
+        final Integer count = objectPath.evaluate("count");
+        assertThat(count, equalTo(5));
+    }
+
+    public void testStreamingBadRequest() throws IOException {
+        final Stream<String> stream = Stream.of(
+            "{ \"index\": { \"_index\": \"test-streaming\", \"_id\": \"1\" } }\n" + "{ \"name\": \"josh\"  }\n"
+        );
+
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+        streamingRequest.addParameter("refresh", "not-supported-policy");
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+        StepVerifier.create(Flux.from(streamingResponse.getBody()).map(b -> new String(b.array(), StandardCharsets.UTF_8)))
+            .expectErrorMatches(
+                ex -> ex instanceof ResponseException && ((ResponseException) ex).getResponse().getStatusLine().getStatusCode() == 400
+            )
+            .verify(Duration.ofSeconds(10));
+        assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(400));
+        assertThat(streamingResponse.getWarnings(), empty());
+    }
+
+    public void testStreamingBadStream() throws IOException {
+        final VirtualTimeScheduler scheduler = VirtualTimeScheduler.create(true);
+
+        final Stream<String> stream = Stream.of(
+            "{ \"index\": { \"_index\": \"test-streaming\", \"_id\": \"1\" } }\n" + "{ \"name\": \"josh\"  }\n",
+            "{ \"name\": \"josh\"  }\n"
+        );
+
+        final Duration delay = Duration.ofMillis(1);
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).delayElements(delay, scheduler).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+        scheduler.advanceTimeBy(delay); /* emit first element */
+
+        StepVerifier.create(Flux.from(streamingResponse.getBody()).map(b -> new String(b.array(), StandardCharsets.UTF_8)))
+            .expectNextMatches(s -> s.contains("\"result\":\"created\"") && s.contains("\"_id\":\"1\""))
+            .then(() -> scheduler.advanceTimeBy(delay))
+            .expectNextMatches(s -> s.contains("\"type\":\"illegal_argument_exception\""))
+            .then(() -> scheduler.advanceTimeBy(delay))
+            .expectComplete()
+            .verify();
+
+        assertThat(streamingResponse.getStatusLine().getStatusCode(), equalTo(200));
+        assertThat(streamingResponse.getWarnings(), empty());
+    }
+}
diff --git a/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingStressIT.java b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingStressIT.java
new file mode 100644
index 0000000000000..8a2b8b880f6af
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/javaRestTest/java/org/opensearch/rest/ReactorNetty4StreamingStressIT.java
@@ -0,0 +1,95 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest;
+
+import org.apache.http.ConnectionClosedException;
+import org.opensearch.client.Request;
+import org.opensearch.client.Response;
+import org.opensearch.client.StreamingRequest;
+import org.opensearch.client.StreamingResponse;
+import org.opensearch.test.rest.OpenSearchRestTestCase;
+import org.junit.After;
+
+import java.io.InterruptedIOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+
+import reactor.core.publisher.Flux;
+import reactor.test.subscriber.TestSubscriber;
+
+import static org.hamcrest.CoreMatchers.anyOf;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+
+public class ReactorNetty4StreamingStressIT extends OpenSearchRestTestCase {
+    @After
+    @Override
+    public void tearDown() throws Exception {
+        final Request request = new Request("DELETE", "/test-stress-streaming");
+        request.addParameter("ignore_unavailable", "true");
+
+        final Response response = adminClient().performRequest(request);
+        assertThat(response.getStatusLine().getStatusCode(), equalTo(200));
+
+        super.tearDown();
+    }
+
+    public void testCloseClientStreamingRequest() throws Exception {
+        final AtomicInteger id = new AtomicInteger(0);
+        final Stream<String> stream = Stream.generate(
+            () -> "{ \"index\": { \"_index\": \"test-stress-streaming\", \"_id\": \""
+                + id.incrementAndGet()
+                + "\" } }\n"
+                + "{ \"name\": \"josh\"  }\n"
+        );
+
+        final StreamingRequest<ByteBuffer> streamingRequest = new StreamingRequest<>(
+            "POST",
+            "/_bulk/stream",
+            Flux.fromStream(stream).delayElements(Duration.ofMillis(500)).map(s -> ByteBuffer.wrap(s.getBytes(StandardCharsets.UTF_8)))
+        );
+        streamingRequest.addParameter("refresh", "true");
+
+        final StreamingResponse<ByteBuffer> streamingResponse = client().streamRequest(streamingRequest);
+        TestSubscriber<ByteBuffer> subscriber = TestSubscriber.create();
+        streamingResponse.getBody().subscribe(subscriber);
+
+        final ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
+        try {
+            // Await for subscriber to receive at least one chunk
+            assertBusy(() -> assertThat(subscriber.getReceivedOnNext(), not(empty())));
+
+            // Close client forceably
+            executor.schedule(() -> {
+                client().close();
+                return null;
+            }, 2, TimeUnit.SECONDS);
+
+            // Await for subscriber to terminate
+            subscriber.block(Duration.ofSeconds(10));
+            assertThat(
+                subscriber.expectTerminalError(),
+                anyOf(instanceOf(InterruptedIOException.class), instanceOf(ConnectionClosedException.class))
+            );
+        } finally {
+            executor.shutdown();
+            if (executor.awaitTermination(1, TimeUnit.SECONDS) == false) {
+                executor.shutdownNow();
+            }
+        }
+    }
+}
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpChunk.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpChunk.java
new file mode 100644
index 0000000000000..1c4c1fd3e49e3
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpChunk.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http.reactor.netty4;
+
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.http.HttpChunk;
+
+import io.netty.buffer.ByteBuf;
+
+class ReactorNetty4HttpChunk implements HttpChunk {
+    private final BytesArray content;
+    private final boolean last;
+
+    ReactorNetty4HttpChunk(ByteBuf buf, boolean last) {
+        // Since the chunks could be batched and processing could be delayed, we are copying the content here
+        final byte[] content = new byte[buf.readableBytes()];
+        buf.readBytes(content);
+        this.content = new BytesArray(content);
+        this.last = last;
+    }
+
+    @Override
+    public BytesReference content() {
+        return content;
+    }
+
+    @Override
+    public void close() {}
+
+    @Override
+    public boolean isLast() {
+        return last;
+    }
+}
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpRequest.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpRequest.java
index 4406c555a5b04..491c7aa885103 100644
--- a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpRequest.java
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpRequest.java
@@ -44,6 +44,10 @@ class ReactorNetty4HttpRequest implements HttpRequest {
     private final Exception inboundException;
     private final boolean pooled;
 
+    ReactorNetty4HttpRequest(HttpServerRequest request) {
+        this(request, new HttpHeadersMap(request.requestHeaders()), new AtomicBoolean(false), false, Unpooled.EMPTY_BUFFER);
+    }
+
     ReactorNetty4HttpRequest(HttpServerRequest request, ByteBuf content) {
         this(request, new HttpHeadersMap(request.requestHeaders()), new AtomicBoolean(false), true, content);
     }
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpServerTransport.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpServerTransport.java
index bd1646d753016..7f4a8f6cdef02 100644
--- a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpServerTransport.java
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpServerTransport.java
@@ -26,6 +26,8 @@
 import org.opensearch.http.HttpServerChannel;
 import org.opensearch.http.reactor.netty4.ssl.SslUtils;
 import org.opensearch.plugins.SecureHttpTransportSettingsProvider;
+import org.opensearch.rest.RestHandler;
+import org.opensearch.rest.RestRequest.Method;
 import org.opensearch.telemetry.tracing.Tracer;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.reactor.SharedGroupFactory;
@@ -40,7 +42,9 @@
 import java.time.Duration;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
 
+import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.socket.nio.NioChannelOption;
@@ -351,24 +355,47 @@ public List<String> protocols() {
      * @return response publisher
      */
     protected Publisher<Void> incomingRequest(HttpServerRequest request, HttpServerResponse response) {
-        final NonStreamingRequestConsumer<HttpContent> consumer = new NonStreamingRequestConsumer<>(
-            this,
-            request,
-            response,
-            maxCompositeBufferComponents
+        final Method method = HttpConversionUtil.convertMethod(request.method());
+        final Optional<RestHandler> dispatchHandlerOpt = dispatcher.dispatchHandler(
+            request.uri(),
+            request.fullPath(),
+            method,
+            request.params()
         );
+        if (dispatchHandlerOpt.map(RestHandler::supportsStreaming).orElse(false)) {
+            final ReactorNetty4StreamingRequestConsumer<HttpContent> consumer = new ReactorNetty4StreamingRequestConsumer<>(
+                request,
+                response
+            );
+
+            request.receiveContent()
+                .switchIfEmpty(Mono.just(DefaultLastHttpContent.EMPTY_LAST_CONTENT))
+                .subscribe(consumer, error -> {}, () -> consumer.accept(DefaultLastHttpContent.EMPTY_LAST_CONTENT));
+
+            incomingStream(new ReactorNetty4HttpRequest(request), consumer.httpChannel());
+            return response.sendObject(consumer);
+        } else {
+            final ReactorNetty4NonStreamingRequestConsumer<HttpContent> consumer = new ReactorNetty4NonStreamingRequestConsumer<>(
+                this,
+                request,
+                response,
+                maxCompositeBufferComponents
+            );
+
+            request.receiveContent().switchIfEmpty(Mono.just(DefaultLastHttpContent.EMPTY_LAST_CONTENT)).subscribe(consumer);
 
-        request.receiveContent().switchIfEmpty(Mono.just(DefaultLastHttpContent.EMPTY_LAST_CONTENT)).subscribe(consumer);
-
-        return Mono.from(consumer).flatMap(hc -> {
-            final FullHttpResponse r = (FullHttpResponse) hc;
-            response.status(r.status());
-            response.trailerHeaders(c -> r.trailingHeaders().forEach(h -> c.add(h.getKey(), h.getValue())));
-            response.chunkedTransfer(false);
-            response.compression(true);
-            r.headers().forEach(h -> response.addHeader(h.getKey(), h.getValue()));
-            return Mono.from(response.sendObject(r.content()));
-        });
+            return Mono.from(consumer).flatMap(hc -> {
+                final FullHttpResponse r = (FullHttpResponse) hc;
+                response.status(r.status());
+                response.trailerHeaders(c -> r.trailingHeaders().forEach(h -> c.add(h.getKey(), h.getValue())));
+                response.chunkedTransfer(false);
+                response.compression(true);
+                r.headers().forEach(h -> response.addHeader(h.getKey(), h.getValue()));
+
+                final ByteBuf content = r.content().copy();
+                return Mono.from(response.sendObject(content));
+            });
+        }
     }
 
     /**
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/NonStreamingHttpChannel.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4NonStreamingHttpChannel.java
similarity index 83%
rename from plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/NonStreamingHttpChannel.java
rename to plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4NonStreamingHttpChannel.java
index 98b359319ff1b..3dae2d57cf6a6 100644
--- a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/NonStreamingHttpChannel.java
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4NonStreamingHttpChannel.java
@@ -23,13 +23,13 @@
 import reactor.netty.http.server.HttpServerRequest;
 import reactor.netty.http.server.HttpServerResponse;
 
-class NonStreamingHttpChannel implements HttpChannel {
+class ReactorNetty4NonStreamingHttpChannel implements HttpChannel {
     private final HttpServerRequest request;
     private final HttpServerResponse response;
     private final CompletableContext<Void> closeContext = new CompletableContext<>();
     private final FluxSink<HttpContent> emitter;
 
-    NonStreamingHttpChannel(HttpServerRequest request, HttpServerResponse response, FluxSink<HttpContent> emitter) {
+    ReactorNetty4NonStreamingHttpChannel(HttpServerRequest request, HttpServerResponse response, FluxSink<HttpContent> emitter) {
         this.request = request;
         this.response = response;
         this.emitter = emitter;
@@ -55,9 +55,14 @@ public void addCloseListener(ActionListener<Void> listener) {
 
     @Override
     public void sendResponse(HttpResponse response, ActionListener<Void> listener) {
-        emitter.next(createResponse(response));
-        listener.onResponse(null);
-        emitter.complete();
+        try {
+            emitter.next(createResponse(response));
+            listener.onResponse(null);
+            emitter.complete();
+        } catch (final Exception ex) {
+            emitter.error(ex);
+            listener.onFailure(ex);
+        }
     }
 
     @Override
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/NonStreamingRequestConsumer.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4NonStreamingRequestConsumer.java
similarity index 89%
rename from plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/NonStreamingRequestConsumer.java
rename to plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4NonStreamingRequestConsumer.java
index d43e23e800e65..c09e7755b1670 100644
--- a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/NonStreamingRequestConsumer.java
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4NonStreamingRequestConsumer.java
@@ -25,7 +25,7 @@
 import reactor.netty.http.server.HttpServerRequest;
 import reactor.netty.http.server.HttpServerResponse;
 
-class NonStreamingRequestConsumer<T extends HttpContent> implements Consumer<T>, Publisher<HttpContent>, Disposable {
+class ReactorNetty4NonStreamingRequestConsumer<T extends HttpContent> implements Consumer<T>, Publisher<HttpContent>, Disposable {
     private final HttpServerRequest request;
     private final HttpServerResponse response;
     private final CompositeByteBuf content;
@@ -34,7 +34,7 @@ class NonStreamingRequestConsumer<T extends HttpContent> implements Consumer<T>,
     private final AtomicBoolean disposed = new AtomicBoolean(false);
     private volatile FluxSink<HttpContent> emitter;
 
-    NonStreamingRequestConsumer(
+    ReactorNetty4NonStreamingRequestConsumer(
         AbstractHttpServerTransport transport,
         HttpServerRequest request,
         HttpServerResponse response,
@@ -64,12 +64,12 @@ public void accept(T message) {
         }
     }
 
-    public void process(HttpContent in, FluxSink<HttpContent> emitter) {
+    void process(HttpContent in, FluxSink<HttpContent> emitter) {
         // Consume request body in full before dispatching it
         content.addComponent(true, in.content().retain());
 
         if (in instanceof LastHttpContent) {
-            final NonStreamingHttpChannel channel = new NonStreamingHttpChannel(request, response, emitter);
+            final ReactorNetty4NonStreamingHttpChannel channel = new ReactorNetty4NonStreamingHttpChannel(request, response, emitter);
             final HttpRequest r = createRequest(request, content);
 
             try {
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingHttpChannel.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingHttpChannel.java
new file mode 100644
index 0000000000000..1aa03aa9967e2
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingHttpChannel.java
@@ -0,0 +1,134 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http.reactor.netty4;
+
+import org.opensearch.common.concurrent.CompletableContext;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.http.HttpChunk;
+import org.opensearch.http.HttpResponse;
+import org.opensearch.http.StreamingHttpChannel;
+import org.opensearch.transport.reactor.netty4.Netty4Utils;
+
+import java.net.InetSocketAddress;
+import java.util.List;
+import java.util.Map;
+
+import io.netty.buffer.Unpooled;
+import io.netty.handler.codec.http.DefaultHttpContent;
+import io.netty.handler.codec.http.FullHttpResponse;
+import io.netty.handler.codec.http.HttpContent;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.FluxSink;
+import reactor.netty.http.server.HttpServerRequest;
+import reactor.netty.http.server.HttpServerResponse;
+
+class ReactorNetty4StreamingHttpChannel implements StreamingHttpChannel {
+    private final HttpServerRequest request;
+    private final HttpServerResponse response;
+    private final CompletableContext<Void> closeContext = new CompletableContext<>();
+    private final Publisher<HttpChunk> receiver;
+    private final StreamingHttpContentSender sender;
+    private volatile FluxSink<HttpChunk> producer;
+    private volatile boolean lastChunkReceived = false;
+
+    ReactorNetty4StreamingHttpChannel(HttpServerRequest request, HttpServerResponse response, StreamingHttpContentSender sender) {
+        this.request = request;
+        this.response = response;
+        this.sender = sender;
+        this.receiver = Flux.create(producer -> this.producer = producer);
+        this.request.withConnection(connection -> Netty4Utils.addListener(connection.channel().closeFuture(), closeContext));
+    }
+
+    @Override
+    public boolean isOpen() {
+        return true;
+    }
+
+    @Override
+    public void close() {
+        request.withConnection(connection -> connection.channel().close());
+    }
+
+    @Override
+    public void addCloseListener(ActionListener<Void> listener) {
+        closeContext.addListener(ActionListener.toBiConsumer(listener));
+    }
+
+    @Override
+    public void sendChunk(HttpChunk chunk, ActionListener<Void> listener) {
+        sender.send(createContent(chunk), listener, chunk.isLast());
+    }
+
+    @Override
+    public void sendResponse(HttpResponse response, ActionListener<Void> listener) {
+        sender.send(createContent(response), listener, true);
+    }
+
+    @Override
+    public void prepareResponse(int status, Map<String, List<String>> headers) {
+        this.response.status(status);
+        headers.forEach((k, vs) -> vs.forEach(v -> this.response.addHeader(k, v)));
+    }
+
+    @Override
+    public InetSocketAddress getRemoteAddress() {
+        return (InetSocketAddress) response.remoteAddress();
+    }
+
+    @Override
+    public InetSocketAddress getLocalAddress() {
+        return (InetSocketAddress) response.hostAddress();
+    }
+
+    @Override
+    public void receiveChunk(HttpChunk message) {
+        try {
+            if (lastChunkReceived) {
+                return;
+            }
+
+            producer.next(message);
+            if (message.isLast()) {
+                lastChunkReceived = true;
+                producer.complete();
+            }
+        } catch (final Exception ex) {
+            producer.error(ex);
+        } finally {
+            message.close();
+        }
+    }
+
+    @Override
+    public boolean isReadable() {
+        return producer != null;
+    }
+
+    @Override
+    public boolean isWritable() {
+        return sender.isReady();
+    }
+
+    @Override
+    public void subscribe(Subscriber<? super HttpChunk> subscriber) {
+        receiver.subscribe(subscriber);
+    }
+
+    private static HttpContent createContent(HttpResponse response) {
+        final FullHttpResponse fullHttpResponse = (FullHttpResponse) response;
+        return new DefaultHttpContent(fullHttpResponse.content());
+    }
+
+    private static HttpContent createContent(HttpChunk chunk) {
+        return new DefaultHttpContent(Unpooled.copiedBuffer(BytesReference.toByteBuffers(chunk.content())));
+    }
+}
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingRequestConsumer.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingRequestConsumer.java
new file mode 100644
index 0000000000000..0559f89478838
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingRequestConsumer.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http.reactor.netty4;
+
+import org.opensearch.http.HttpChunk;
+import org.opensearch.http.StreamingHttpChannel;
+
+import java.util.function.Consumer;
+
+import io.netty.handler.codec.http.HttpContent;
+import io.netty.handler.codec.http.LastHttpContent;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import reactor.netty.http.server.HttpServerRequest;
+import reactor.netty.http.server.HttpServerResponse;
+
+class ReactorNetty4StreamingRequestConsumer<T extends HttpContent> implements Consumer<T>, Publisher<HttpContent> {
+    private final ReactorNetty4StreamingResponseProducer sender;
+    private final StreamingHttpChannel httpChannel;
+
+    ReactorNetty4StreamingRequestConsumer(HttpServerRequest request, HttpServerResponse response) {
+        this.sender = new ReactorNetty4StreamingResponseProducer();
+        this.httpChannel = new ReactorNetty4StreamingHttpChannel(request, response, sender);
+    }
+
+    @Override
+    public void accept(T message) {
+        if (message instanceof LastHttpContent) {
+            httpChannel.receiveChunk(createChunk(message, true));
+        } else if (message instanceof HttpContent) {
+            httpChannel.receiveChunk(createChunk(message, false));
+        }
+    }
+
+    @Override
+    public void subscribe(Subscriber<? super HttpContent> s) {
+        sender.subscribe(s);
+    }
+
+    HttpChunk createChunk(HttpContent chunk, boolean last) {
+        return new ReactorNetty4HttpChunk(chunk.content(), last);
+    }
+
+    StreamingHttpChannel httpChannel() {
+        return httpChannel;
+    }
+}
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingResponseProducer.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingResponseProducer.java
new file mode 100644
index 0000000000000..6aaccc500072b
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/ReactorNetty4StreamingResponseProducer.java
@@ -0,0 +1,58 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http.reactor.netty4;
+
+import org.opensearch.core.action.ActionListener;
+
+import io.netty.handler.codec.http.HttpContent;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.FluxSink;
+
+class ReactorNetty4StreamingResponseProducer implements StreamingHttpContentSender, Publisher<HttpContent> {
+    private final Publisher<HttpContent> sender;
+    private volatile FluxSink<HttpContent> emitter;
+
+    ReactorNetty4StreamingResponseProducer() {
+        this.sender = Flux.create(emitter -> register(emitter));
+    }
+
+    private void register(FluxSink<HttpContent> emitter) {
+        this.emitter = emitter;
+    }
+
+    @Override
+    public void send(HttpContent content, ActionListener<Void> listener, boolean isLast) {
+        try {
+            emitter.next(content);
+            listener.onResponse(null);
+            if (isLast) {
+                emitter.complete();
+            }
+        } catch (final Exception ex) {
+            emitter.error(ex);
+            listener.onFailure(ex);
+        }
+    }
+
+    @Override
+    public void subscribe(Subscriber<? super HttpContent> s) {
+        sender.subscribe(s);
+    }
+
+    @Override
+    public boolean isReady() {
+        return emitter != null;
+    }
+
+    FluxSink<HttpContent> emitter() {
+        return emitter;
+    }
+}
diff --git a/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/StreamingHttpContentSender.java b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/StreamingHttpContentSender.java
new file mode 100644
index 0000000000000..f07d6fbb88349
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/main/java/org/opensearch/http/reactor/netty4/StreamingHttpContentSender.java
@@ -0,0 +1,32 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http.reactor.netty4;
+
+import org.opensearch.core.action.ActionListener;
+
+import io.netty.handler.codec.http.HttpContent;
+
+/**
+ * The generic interface for chunked {@link HttpContent} producers (response streaming).
+ */
+interface StreamingHttpContentSender {
+    /**
+     * Sends the next {@link HttpContent} over the wire
+     * @param content next {@link HttpContent}
+     * @param listener action listener
+     * @param isLast {@code true} if this is the last chunk, {@code false} otherwise
+     */
+    void send(HttpContent content, ActionListener<Void> listener, boolean isLast);
+
+    /**
+     * Returns {@code true} is this channel is ready for streaming response data, {@code false} otherwise
+     * @return {@code true} is this channel is ready for streaming response data, {@code false} otherwise
+     */
+    boolean isReady();
+}
diff --git a/plugins/transport-reactor-netty4/src/test/java/org/opensearch/http/reactor/netty4/ReactorHttpClient.java b/plugins/transport-reactor-netty4/src/test/java/org/opensearch/http/reactor/netty4/ReactorHttpClient.java
index 920c895205023..0953e51484bd3 100644
--- a/plugins/transport-reactor-netty4/src/test/java/org/opensearch/http/reactor/netty4/ReactorHttpClient.java
+++ b/plugins/transport-reactor-netty4/src/test/java/org/opensearch/http/reactor/netty4/ReactorHttpClient.java
@@ -14,16 +14,22 @@
 package org.opensearch.http.reactor.netty4;
 
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.tasks.Task;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.Closeable;
+import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.net.InetSocketAddress;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.stream.Stream;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
@@ -36,6 +42,7 @@
 import io.netty.handler.codec.http.HttpContent;
 import io.netty.handler.codec.http.HttpHeaderNames;
 import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpRequest;
 import io.netty.handler.codec.http.HttpResponse;
 import io.netty.handler.codec.http.HttpVersion;
 import io.netty.handler.codec.http2.HttpConversionUtil;
@@ -121,6 +128,11 @@ public final FullHttpResponse send(InetSocketAddress remoteAddress, FullHttpRequ
         return responses.get(0);
     }
 
+    public final FullHttpResponse stream(InetSocketAddress remoteAddress, HttpRequest httpRequest, Stream<ToXContent> stream)
+        throws InterruptedException {
+        return sendRequestStream(remoteAddress, httpRequest, stream);
+    }
+
     public final FullHttpResponse send(InetSocketAddress remoteAddress, FullHttpRequest httpRequest, HttpContent content)
         throws InterruptedException {
         final List<FullHttpResponse> responses = sendRequests(
@@ -207,6 +219,46 @@ private List<FullHttpResponse> sendRequests(
         }
     }
 
+    private FullHttpResponse sendRequestStream(
+        final InetSocketAddress remoteAddress,
+        final HttpRequest request,
+        final Stream<ToXContent> stream
+    ) {
+        final NioEventLoopGroup eventLoopGroup = new NioEventLoopGroup(1);
+        try {
+            final HttpClient client = createClient(remoteAddress, eventLoopGroup);
+
+            return client.headers(h -> h.add(request.headers()))
+                .baseUrl(request.getUri())
+                .request(request.method())
+                .send(Flux.fromStream(stream).map(s -> {
+                    try (XContentBuilder builder = XContentType.JSON.contentBuilder()) {
+                        return Unpooled.wrappedBuffer(
+                            s.toXContent(builder, ToXContent.EMPTY_PARAMS).toString().getBytes(StandardCharsets.UTF_8)
+                        );
+                    } catch (final IOException ex) {
+                        throw new UncheckedIOException(ex);
+                    }
+                }))
+                .response(
+                    (r, c) -> c.aggregate()
+                        .map(
+                            b -> new DefaultFullHttpResponse(
+                                r.version(),
+                                r.status(),
+                                b.retain(),
+                                r.responseHeaders(),
+                                EmptyHttpHeaders.INSTANCE
+                            )
+                        )
+                )
+                .blockLast();
+
+        } finally {
+            eventLoopGroup.shutdownGracefully().awaitUninterruptibly();
+        }
+    }
+
     private HttpClient createClient(final InetSocketAddress remoteAddress, final NioEventLoopGroup eventLoopGroup) {
         final HttpClient client = HttpClient.newConnection()
             .resolver(DefaultAddressResolverGroup.INSTANCE)
diff --git a/plugins/transport-reactor-netty4/src/test/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpServerTransportStreamingTests.java b/plugins/transport-reactor-netty4/src/test/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpServerTransportStreamingTests.java
new file mode 100644
index 0000000000000..df0e4027cc474
--- /dev/null
+++ b/plugins/transport-reactor-netty4/src/test/java/org/opensearch/http/reactor/netty4/ReactorNetty4HttpServerTransportStreamingTests.java
@@ -0,0 +1,211 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http.reactor.netty4;
+
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.network.NetworkService;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.MockBigArrays;
+import org.opensearch.common.util.MockPageCacheRecycler;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.common.xcontent.support.XContentHttpChunk;
+import org.opensearch.core.common.transport.TransportAddress;
+import org.opensearch.core.indices.breaker.NoneCircuitBreakerService;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.http.HttpServerTransport;
+import org.opensearch.rest.RestChannel;
+import org.opensearch.rest.RestHandler;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.RestRequest.Method;
+import org.opensearch.rest.StreamingRestChannel;
+import org.opensearch.telemetry.tracing.noop.NoopTracer;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.rest.FakeRestRequest;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.reactor.SharedGroupFactory;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import io.netty.handler.codec.http.DefaultHttpRequest;
+import io.netty.handler.codec.http.FullHttpResponse;
+import io.netty.handler.codec.http.HttpMethod;
+import io.netty.handler.codec.http.HttpRequest;
+import io.netty.handler.codec.http.HttpResponseStatus;
+import io.netty.handler.codec.http.HttpVersion;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.Matchers.equalTo;
+
+/**
+ * Tests for the {@link ReactorNetty4HttpServerTransport} class with streaming support.
+ */
+public class ReactorNetty4HttpServerTransportStreamingTests extends OpenSearchTestCase {
+    private static final Function<String, ToXContent> XCONTENT_CONVERTER = (str) -> new ToXContent() {
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params params) throws IOException {
+            return builder.startObject().field("doc", str).endObject();
+        }
+    };
+
+    private NetworkService networkService;
+    private ThreadPool threadPool;
+    private MockBigArrays bigArrays;
+    private ClusterSettings clusterSettings;
+
+    @Before
+    public void setup() throws Exception {
+        networkService = new NetworkService(Collections.emptyList());
+        threadPool = new TestThreadPool("test");
+        bigArrays = new MockBigArrays(new MockPageCacheRecycler(Settings.EMPTY), new NoneCircuitBreakerService());
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+    }
+
+    @After
+    public void shutdown() throws Exception {
+        if (threadPool != null) {
+            threadPool.shutdownNow();
+        }
+        threadPool = null;
+        networkService = null;
+        bigArrays = null;
+        clusterSettings = null;
+    }
+
+    public void testRequestResponseStreaming() throws InterruptedException {
+        final String responseString = randomAlphaOfLength(4 * 1024);
+        final String url = "/stream/";
+
+        final ToXContent[] chunks = newChunks(responseString);
+        final HttpServerTransport.Dispatcher dispatcher = new HttpServerTransport.Dispatcher() {
+            @Override
+            public Optional<RestHandler> dispatchHandler(String uri, String rawPath, Method method, Map<String, String> params) {
+                return Optional.of(new RestHandler() {
+                    @Override
+                    public boolean supportsStreaming() {
+                        return true;
+                    }
+
+                    @Override
+                    public void handleRequest(RestRequest request, RestChannel channel, NodeClient client) throws Exception {
+                        logger.error("--> Unexpected request [{}]", request.uri());
+                        throw new AssertionError();
+                    }
+                });
+            }
+
+            @Override
+            public void dispatchRequest(final RestRequest request, final RestChannel channel, final ThreadContext threadContext) {
+                if (url.equals(request.uri())) {
+                    assertThat(channel, instanceOf(StreamingRestChannel.class));
+                    final StreamingRestChannel streamingChannel = (StreamingRestChannel) channel;
+
+                    // Await at most 5 seconds till channel is ready for writing the response stream, fail otherwise
+                    final Mono<?> ready = Mono.fromRunnable(() -> {
+                        while (!streamingChannel.isWritable()) {
+                            Thread.onSpinWait();
+                        }
+                    }).timeout(Duration.ofSeconds(5));
+
+                    threadPool.executor(ThreadPool.Names.WRITE)
+                        .execute(() -> Flux.concat(Flux.fromArray(newChunks(responseString)).map(e -> {
+                            try (XContentBuilder builder = channel.newBuilder(XContentType.JSON, true)) {
+                                return XContentHttpChunk.from(e.toXContent(builder, ToXContent.EMPTY_PARAMS));
+                            } catch (final IOException ex) {
+                                throw new UncheckedIOException(ex);
+                            }
+                        }), Mono.just(XContentHttpChunk.last()))
+                            .delaySubscription(ready)
+                            .subscribe(streamingChannel::sendChunk, null, () -> {
+                                if (channel.bytesOutput() instanceof Releasable) {
+                                    ((Releasable) channel.bytesOutput()).close();
+                                }
+                            }));
+                } else {
+                    logger.error("--> Unexpected successful uri [{}]", request.uri());
+                    throw new AssertionError();
+                }
+            }
+
+            @Override
+            public void dispatchBadRequest(final RestChannel channel, final ThreadContext threadContext, final Throwable cause) {
+                logger.error(
+                    new ParameterizedMessage("--> Unexpected bad request [{}]", FakeRestRequest.requestToString(channel.request())),
+                    cause
+                );
+                throw new AssertionError();
+            }
+
+        };
+
+        try (
+            ReactorNetty4HttpServerTransport transport = new ReactorNetty4HttpServerTransport(
+                Settings.EMPTY,
+                networkService,
+                bigArrays,
+                threadPool,
+                xContentRegistry(),
+                dispatcher,
+                clusterSettings,
+                new SharedGroupFactory(Settings.EMPTY),
+                NoopTracer.INSTANCE
+            )
+        ) {
+            transport.start();
+            final TransportAddress remoteAddress = randomFrom(transport.boundAddress().boundAddresses());
+
+            try (ReactorHttpClient client = ReactorHttpClient.create(false)) {
+                HttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, url);
+                final FullHttpResponse response = client.stream(remoteAddress.address(), request, Arrays.stream(chunks));
+                try {
+                    assertThat(response.status(), equalTo(HttpResponseStatus.OK));
+                    byte[] bytes = new byte[response.content().readableBytes()];
+                    response.content().readBytes(bytes);
+                    assertThat(new String(bytes, StandardCharsets.UTF_8), equalTo(Arrays.stream(newChunks(responseString)).map(s -> {
+                        try (XContentBuilder builder = XContentType.JSON.contentBuilder()) {
+                            return s.toXContent(builder, ToXContent.EMPTY_PARAMS).toString();
+                        } catch (final IOException ex) {
+                            throw new UncheckedIOException(ex);
+                        }
+                    }).collect(Collectors.joining("\r\n", "", "\r\n"))));
+                } finally {
+                    response.release();
+                }
+            }
+        }
+    }
+
+    private static ToXContent[] newChunks(final String responseString) {
+        final ToXContent[] chunks = new ToXContent[responseString.length() / 16];
+
+        for (int chunk = 0; chunk < responseString.length(); chunk += 16) {
+            chunks[chunk / 16] = XCONTENT_CONVERTER.apply(responseString.substring(chunk, chunk + 16));
+        }
+
+        return chunks;
+    }
+}
diff --git a/plugins/workload-management/build.gradle b/plugins/workload-management/build.gradle
new file mode 100644
index 0000000000000..cb14d22ef149f
--- /dev/null
+++ b/plugins/workload-management/build.gradle
@@ -0,0 +1,21 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+apply plugin: 'opensearch.yaml-rest-test'
+apply plugin: 'opensearch.internal-cluster-test'
+
+opensearchplugin {
+  description 'OpenSearch Workload Management Plugin.'
+  classname 'org.opensearch.plugin.wlm.WorkloadManagementPlugin'
+}
+
+dependencies {
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/WorkloadManagementPlugin.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/WorkloadManagementPlugin.java
new file mode 100644
index 0000000000000..c86490552f2f2
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/WorkloadManagementPlugin.java
@@ -0,0 +1,90 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm;
+
+import org.opensearch.action.ActionRequest;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.common.inject.Module;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.IndexScopedSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsFilter;
+import org.opensearch.core.action.ActionResponse;
+import org.opensearch.plugin.wlm.action.CreateQueryGroupAction;
+import org.opensearch.plugin.wlm.action.DeleteQueryGroupAction;
+import org.opensearch.plugin.wlm.action.GetQueryGroupAction;
+import org.opensearch.plugin.wlm.action.TransportCreateQueryGroupAction;
+import org.opensearch.plugin.wlm.action.TransportDeleteQueryGroupAction;
+import org.opensearch.plugin.wlm.action.TransportGetQueryGroupAction;
+import org.opensearch.plugin.wlm.action.TransportUpdateQueryGroupAction;
+import org.opensearch.plugin.wlm.action.UpdateQueryGroupAction;
+import org.opensearch.plugin.wlm.rest.RestCreateQueryGroupAction;
+import org.opensearch.plugin.wlm.rest.RestDeleteQueryGroupAction;
+import org.opensearch.plugin.wlm.rest.RestGetQueryGroupAction;
+import org.opensearch.plugin.wlm.rest.RestUpdateQueryGroupAction;
+import org.opensearch.plugin.wlm.service.QueryGroupPersistenceService;
+import org.opensearch.plugins.ActionPlugin;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.rest.RestController;
+import org.opensearch.rest.RestHandler;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Supplier;
+
+/**
+ * Plugin class for WorkloadManagement
+ */
+public class WorkloadManagementPlugin extends Plugin implements ActionPlugin {
+
+    /**
+     * Default constructor
+     */
+    public WorkloadManagementPlugin() {}
+
+    @Override
+    public List<ActionHandler<? extends ActionRequest, ? extends ActionResponse>> getActions() {
+        return List.of(
+            new ActionPlugin.ActionHandler<>(CreateQueryGroupAction.INSTANCE, TransportCreateQueryGroupAction.class),
+            new ActionPlugin.ActionHandler<>(GetQueryGroupAction.INSTANCE, TransportGetQueryGroupAction.class),
+            new ActionPlugin.ActionHandler<>(DeleteQueryGroupAction.INSTANCE, TransportDeleteQueryGroupAction.class),
+            new ActionPlugin.ActionHandler<>(UpdateQueryGroupAction.INSTANCE, TransportUpdateQueryGroupAction.class)
+        );
+    }
+
+    @Override
+    public List<RestHandler> getRestHandlers(
+        Settings settings,
+        RestController restController,
+        ClusterSettings clusterSettings,
+        IndexScopedSettings indexScopedSettings,
+        SettingsFilter settingsFilter,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        Supplier<DiscoveryNodes> nodesInCluster
+    ) {
+        return List.of(
+            new RestCreateQueryGroupAction(),
+            new RestGetQueryGroupAction(),
+            new RestDeleteQueryGroupAction(),
+            new RestUpdateQueryGroupAction()
+        );
+    }
+
+    @Override
+    public List<Setting<?>> getSettings() {
+        return List.of(QueryGroupPersistenceService.MAX_QUERY_GROUP_COUNT);
+    }
+
+    @Override
+    public Collection<Module> createGuiceModules() {
+        return List.of(new WorkloadManagementPluginModule());
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/WorkloadManagementPluginModule.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/WorkloadManagementPluginModule.java
new file mode 100644
index 0000000000000..b7c7805639eb2
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/WorkloadManagementPluginModule.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm;
+
+import org.opensearch.common.inject.AbstractModule;
+import org.opensearch.common.inject.Singleton;
+import org.opensearch.plugin.wlm.service.QueryGroupPersistenceService;
+
+/**
+ * Guice Module to manage WorkloadManagement related objects
+ */
+public class WorkloadManagementPluginModule extends AbstractModule {
+
+    /**
+     * Constructor for WorkloadManagementPluginModule
+     */
+    public WorkloadManagementPluginModule() {}
+
+    @Override
+    protected void configure() {
+        // Bind QueryGroupPersistenceService as a singleton to ensure a single instance is used,
+        // preventing multiple throttling key registrations in the constructor.
+        bind(QueryGroupPersistenceService.class).in(Singleton.class);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupAction.java
new file mode 100644
index 0000000000000..14cb8cfcd125a
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupAction.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionType;
+
+/**
+ * Transport action to create QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class CreateQueryGroupAction extends ActionType<CreateQueryGroupResponse> {
+
+    /**
+     * An instance of CreateQueryGroupAction
+     */
+    public static final CreateQueryGroupAction INSTANCE = new CreateQueryGroupAction();
+
+    /**
+     * Name for CreateQueryGroupAction
+     */
+    public static final String NAME = "cluster:admin/opensearch/wlm/query_group/_create";
+
+    /**
+     * Default constructor
+     */
+    private CreateQueryGroupAction() {
+        super(NAME, CreateQueryGroupResponse::new);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupRequest.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupRequest.java
new file mode 100644
index 0000000000000..d92283391dd3b
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupRequest.java
@@ -0,0 +1,82 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.common.UUIDs;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.XContentParser;
+import org.joda.time.Instant;
+
+import java.io.IOException;
+
+/**
+ * A request for create QueryGroup
+ * User input schema:
+ *  {
+ *    "name": "analytics",
+ *    "resiliency_mode": "enforced",
+ *    "resource_limits": {
+ *           "cpu" : 0.4,
+ *           "memory" : 0.2
+ *      }
+ *  }
+ *
+ * @opensearch.experimental
+ */
+public class CreateQueryGroupRequest extends ActionRequest {
+    private final QueryGroup queryGroup;
+
+    /**
+     * Constructor for CreateQueryGroupRequest
+     * @param queryGroup - A {@link QueryGroup} object
+     */
+    CreateQueryGroupRequest(QueryGroup queryGroup) {
+        this.queryGroup = queryGroup;
+    }
+
+    /**
+     * Constructor for CreateQueryGroupRequest
+     * @param in - A {@link StreamInput} object
+     */
+    CreateQueryGroupRequest(StreamInput in) throws IOException {
+        super(in);
+        queryGroup = new QueryGroup(in);
+    }
+
+    /**
+     * Generate a CreateQueryGroupRequest from XContent
+     * @param parser - A {@link XContentParser} object
+     */
+    public static CreateQueryGroupRequest fromXContent(XContentParser parser) throws IOException {
+        QueryGroup.Builder builder = QueryGroup.Builder.fromXContent(parser);
+        return new CreateQueryGroupRequest(builder._id(UUIDs.randomBase64UUID()).updatedAt(Instant.now().getMillis()).build());
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        return null;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        queryGroup.writeTo(out);
+    }
+
+    /**
+     * QueryGroup getter
+     */
+    public QueryGroup getQueryGroup() {
+        return queryGroup;
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupResponse.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupResponse.java
new file mode 100644
index 0000000000000..9a2a8178c0a29
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/CreateQueryGroupResponse.java
@@ -0,0 +1,74 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.core.action.ActionResponse;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Response for the create API for QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class CreateQueryGroupResponse extends ActionResponse implements ToXContent, ToXContentObject {
+    private final QueryGroup queryGroup;
+    private final RestStatus restStatus;
+
+    /**
+     * Constructor for CreateQueryGroupResponse
+     * @param queryGroup - The QueryGroup to be included in the response
+     * @param restStatus - The restStatus for the response
+     */
+    public CreateQueryGroupResponse(final QueryGroup queryGroup, RestStatus restStatus) {
+        this.queryGroup = queryGroup;
+        this.restStatus = restStatus;
+    }
+
+    /**
+     * Constructor for CreateQueryGroupResponse
+     * @param in - A {@link StreamInput} object
+     */
+    public CreateQueryGroupResponse(StreamInput in) throws IOException {
+        queryGroup = new QueryGroup(in);
+        restStatus = RestStatus.readFrom(in);
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        queryGroup.writeTo(out);
+        RestStatus.writeTo(out, restStatus);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        return queryGroup.toXContent(builder, params);
+    }
+
+    /**
+     * queryGroup getter
+     */
+    public QueryGroup getQueryGroup() {
+        return queryGroup;
+    }
+
+    /**
+     * restStatus getter
+     */
+    public RestStatus getRestStatus() {
+        return restStatus;
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupAction.java
new file mode 100644
index 0000000000000..c78952a2f89ad
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupAction.java
@@ -0,0 +1,38 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionType;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+
+/**
+ * Transport action for delete QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class DeleteQueryGroupAction extends ActionType<AcknowledgedResponse> {
+
+    /**
+     /**
+     * An instance of DeleteQueryGroupAction
+     */
+    public static final DeleteQueryGroupAction INSTANCE = new DeleteQueryGroupAction();
+
+    /**
+     * Name for DeleteQueryGroupAction
+     */
+    public static final String NAME = "cluster:admin/opensearch/wlm/query_group/_delete";
+
+    /**
+     * Default constructor
+     */
+    private DeleteQueryGroupAction() {
+        super(NAME, AcknowledgedResponse::new);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupRequest.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupRequest.java
new file mode 100644
index 0000000000000..e514943c2c7e9
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupRequest.java
@@ -0,0 +1,65 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.support.master.AcknowledgedRequest;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+
+/**
+ * Request for delete QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class DeleteQueryGroupRequest extends AcknowledgedRequest<DeleteQueryGroupRequest> {
+    private final String name;
+
+    /**
+     * Default constructor for DeleteQueryGroupRequest
+     * @param name - name for the QueryGroup to get
+     */
+    public DeleteQueryGroupRequest(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Constructor for DeleteQueryGroupRequest
+     * @param in - A {@link StreamInput} object
+     */
+    public DeleteQueryGroupRequest(StreamInput in) throws IOException {
+        super(in);
+        name = in.readOptionalString();
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        if (name == null) {
+            ActionRequestValidationException actionRequestValidationException = new ActionRequestValidationException();
+            actionRequestValidationException.addValidationError("QueryGroup name is missing");
+            return actionRequestValidationException;
+        }
+        return null;
+    }
+
+    /**
+     * Name getter
+     */
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeOptionalString(name);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupAction.java
new file mode 100644
index 0000000000000..0200185580f7d
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupAction.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionType;
+
+/**
+ * Transport action to get QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class GetQueryGroupAction extends ActionType<GetQueryGroupResponse> {
+
+    /**
+     * An instance of GetQueryGroupAction
+     */
+    public static final GetQueryGroupAction INSTANCE = new GetQueryGroupAction();
+
+    /**
+     * Name for GetQueryGroupAction
+     */
+    public static final String NAME = "cluster:admin/opensearch/wlm/query_group/_get";
+
+    /**
+     * Default constructor
+     */
+    private GetQueryGroupAction() {
+        super(NAME, GetQueryGroupResponse::new);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupRequest.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupRequest.java
new file mode 100644
index 0000000000000..0524c615a84e7
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupRequest.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.support.clustermanager.ClusterManagerNodeReadRequest;
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+
+/**
+ * Request for get QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class GetQueryGroupRequest extends ClusterManagerNodeReadRequest<GetQueryGroupRequest> {
+    final String name;
+
+    /**
+     * Default constructor for GetQueryGroupRequest
+     * @param name - name for the QueryGroup to get
+     */
+    public GetQueryGroupRequest(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Constructor for GetQueryGroupRequest
+     * @param in - A {@link StreamInput} object
+     */
+    public GetQueryGroupRequest(StreamInput in) throws IOException {
+        super(in);
+        name = in.readOptionalString();
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        if (name != null) {
+            QueryGroup.validateName(name);
+        }
+        return null;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeOptionalString(name);
+    }
+
+    /**
+     * Name getter
+     */
+    public String getName() {
+        return name;
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupResponse.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupResponse.java
new file mode 100644
index 0000000000000..547c501e6a28e
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/GetQueryGroupResponse.java
@@ -0,0 +1,82 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.core.action.ActionResponse;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Collection;
+
+/**
+ * Response for the get API for QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class GetQueryGroupResponse extends ActionResponse implements ToXContent, ToXContentObject {
+    private final Collection<QueryGroup> queryGroups;
+    private final RestStatus restStatus;
+
+    /**
+     * Constructor for GetQueryGroupResponse
+     * @param queryGroups - The QueryGroup list to be fetched
+     * @param restStatus - The rest status of the request
+     */
+    public GetQueryGroupResponse(final Collection<QueryGroup> queryGroups, RestStatus restStatus) {
+        this.queryGroups = queryGroups;
+        this.restStatus = restStatus;
+    }
+
+    /**
+     * Constructor for GetQueryGroupResponse
+     * @param in - A {@link StreamInput} object
+     */
+    public GetQueryGroupResponse(StreamInput in) throws IOException {
+        this.queryGroups = in.readList(QueryGroup::new);
+        restStatus = RestStatus.readFrom(in);
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeCollection(queryGroups);
+        RestStatus.writeTo(out, restStatus);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.startArray("query_groups");
+        for (QueryGroup group : queryGroups) {
+            group.toXContent(builder, params);
+        }
+        builder.endArray();
+        builder.endObject();
+        return builder;
+    }
+
+    /**
+     * queryGroups getter
+     */
+    public Collection<QueryGroup> getQueryGroups() {
+        return queryGroups;
+    }
+
+    /**
+     * restStatus getter
+     */
+    public RestStatus getRestStatus() {
+        return restStatus;
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportCreateQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportCreateQueryGroupAction.java
new file mode 100644
index 0000000000000..190ff17261bb4
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportCreateQueryGroupAction.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.HandledTransportAction;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.plugin.wlm.service.QueryGroupPersistenceService;
+import org.opensearch.tasks.Task;
+import org.opensearch.transport.TransportService;
+
+/**
+ * Transport action to create QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class TransportCreateQueryGroupAction extends HandledTransportAction<CreateQueryGroupRequest, CreateQueryGroupResponse> {
+
+    private final QueryGroupPersistenceService queryGroupPersistenceService;
+
+    /**
+     * Constructor for TransportCreateQueryGroupAction
+     *
+     * @param actionName - action name
+     * @param transportService - a {@link TransportService} object
+     * @param actionFilters - a {@link ActionFilters} object
+     * @param queryGroupPersistenceService - a {@link QueryGroupPersistenceService} object
+     */
+    @Inject
+    public TransportCreateQueryGroupAction(
+        String actionName,
+        TransportService transportService,
+        ActionFilters actionFilters,
+        QueryGroupPersistenceService queryGroupPersistenceService
+    ) {
+        super(CreateQueryGroupAction.NAME, transportService, actionFilters, CreateQueryGroupRequest::new);
+        this.queryGroupPersistenceService = queryGroupPersistenceService;
+    }
+
+    @Override
+    protected void doExecute(Task task, CreateQueryGroupRequest request, ActionListener<CreateQueryGroupResponse> listener) {
+        queryGroupPersistenceService.persistInClusterStateMetadata(request.getQueryGroup(), listener);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportDeleteQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportDeleteQueryGroupAction.java
new file mode 100644
index 0000000000000..e4d3908d4a208
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportDeleteQueryGroupAction.java
@@ -0,0 +1,91 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.clustermanager.TransportClusterManagerNodeAction;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.plugin.wlm.service.QueryGroupPersistenceService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+
+/**
+ * Transport action for delete QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class TransportDeleteQueryGroupAction extends TransportClusterManagerNodeAction<DeleteQueryGroupRequest, AcknowledgedResponse> {
+
+    private final QueryGroupPersistenceService queryGroupPersistenceService;
+
+    /**
+     * Constructor for TransportDeleteQueryGroupAction
+     *
+     * @param clusterService - a {@link ClusterService} object
+     * @param transportService - a {@link TransportService} object
+     * @param actionFilters - a {@link ActionFilters} object
+     * @param threadPool - a {@link ThreadPool} object
+     * @param indexNameExpressionResolver - a {@link IndexNameExpressionResolver} object
+     * @param queryGroupPersistenceService - a {@link QueryGroupPersistenceService} object
+     */
+    @Inject
+    public TransportDeleteQueryGroupAction(
+        ClusterService clusterService,
+        TransportService transportService,
+        ActionFilters actionFilters,
+        ThreadPool threadPool,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        QueryGroupPersistenceService queryGroupPersistenceService
+    ) {
+        super(
+            DeleteQueryGroupAction.NAME,
+            transportService,
+            clusterService,
+            threadPool,
+            actionFilters,
+            DeleteQueryGroupRequest::new,
+            indexNameExpressionResolver
+        );
+        this.queryGroupPersistenceService = queryGroupPersistenceService;
+    }
+
+    @Override
+    protected void clusterManagerOperation(
+        DeleteQueryGroupRequest request,
+        ClusterState state,
+        ActionListener<AcknowledgedResponse> listener
+    ) throws Exception {
+        queryGroupPersistenceService.deleteInClusterStateMetadata(request, listener);
+    }
+
+    @Override
+    protected String executor() {
+        return ThreadPool.Names.SAME;
+    }
+
+    @Override
+    protected AcknowledgedResponse read(StreamInput in) throws IOException {
+        return new AcknowledgedResponse(in);
+    }
+
+    @Override
+    protected ClusterBlockException checkBlock(DeleteQueryGroupRequest request, ClusterState state) {
+        return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_WRITE);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportGetQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportGetQueryGroupAction.java
new file mode 100644
index 0000000000000..51bb21b255511
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportGetQueryGroupAction.java
@@ -0,0 +1,98 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.ResourceNotFoundException;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.clustermanager.TransportClusterManagerNodeReadAction;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.plugin.wlm.service.QueryGroupPersistenceService;
+import org.opensearch.search.pipeline.SearchPipelineService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.Collection;
+
+/**
+ * Transport action to get QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class TransportGetQueryGroupAction extends TransportClusterManagerNodeReadAction<GetQueryGroupRequest, GetQueryGroupResponse> {
+    private static final Logger logger = LogManager.getLogger(SearchPipelineService.class);
+
+    /**
+     * Constructor for TransportGetQueryGroupAction
+     *
+     * @param clusterService - a {@link ClusterService} object
+     * @param transportService - a {@link TransportService} object
+     * @param actionFilters - a {@link ActionFilters} object
+     * @param threadPool - a {@link ThreadPool} object
+     * @param indexNameExpressionResolver - a {@link IndexNameExpressionResolver} object
+     */
+    @Inject
+    public TransportGetQueryGroupAction(
+        ClusterService clusterService,
+        TransportService transportService,
+        ActionFilters actionFilters,
+        ThreadPool threadPool,
+        IndexNameExpressionResolver indexNameExpressionResolver
+    ) {
+        super(
+            GetQueryGroupAction.NAME,
+            transportService,
+            clusterService,
+            threadPool,
+            actionFilters,
+            GetQueryGroupRequest::new,
+            indexNameExpressionResolver,
+            true
+        );
+    }
+
+    @Override
+    protected String executor() {
+        return ThreadPool.Names.SAME;
+    }
+
+    @Override
+    protected GetQueryGroupResponse read(StreamInput in) throws IOException {
+        return new GetQueryGroupResponse(in);
+    }
+
+    @Override
+    protected ClusterBlockException checkBlock(GetQueryGroupRequest request, ClusterState state) {
+        return state.blocks().globalBlockedException(ClusterBlockLevel.METADATA_READ);
+    }
+
+    @Override
+    protected void clusterManagerOperation(GetQueryGroupRequest request, ClusterState state, ActionListener<GetQueryGroupResponse> listener)
+        throws Exception {
+        final String name = request.getName();
+        final Collection<QueryGroup> resultGroups = QueryGroupPersistenceService.getFromClusterStateMetadata(name, state);
+
+        if (resultGroups.isEmpty() && name != null && !name.isEmpty()) {
+            logger.warn("No QueryGroup exists with the provided name: {}", name);
+            throw new ResourceNotFoundException("No QueryGroup exists with the provided name: " + name);
+        }
+        listener.onResponse(new GetQueryGroupResponse(resultGroups, RestStatus.OK));
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportUpdateQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportUpdateQueryGroupAction.java
new file mode 100644
index 0000000000000..a6aa2da8fdc08
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/TransportUpdateQueryGroupAction.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.HandledTransportAction;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.plugin.wlm.service.QueryGroupPersistenceService;
+import org.opensearch.tasks.Task;
+import org.opensearch.transport.TransportService;
+
+/**
+ * Transport action to update QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class TransportUpdateQueryGroupAction extends HandledTransportAction<UpdateQueryGroupRequest, UpdateQueryGroupResponse> {
+
+    private final QueryGroupPersistenceService queryGroupPersistenceService;
+
+    /**
+     * Constructor for TransportUpdateQueryGroupAction
+     *
+     * @param actionName - action name
+     * @param transportService - a {@link TransportService} object
+     * @param actionFilters - a {@link ActionFilters} object
+     * @param queryGroupPersistenceService - a {@link QueryGroupPersistenceService} object
+     */
+    @Inject
+    public TransportUpdateQueryGroupAction(
+        String actionName,
+        TransportService transportService,
+        ActionFilters actionFilters,
+        QueryGroupPersistenceService queryGroupPersistenceService
+    ) {
+        super(UpdateQueryGroupAction.NAME, transportService, actionFilters, UpdateQueryGroupRequest::new);
+        this.queryGroupPersistenceService = queryGroupPersistenceService;
+    }
+
+    @Override
+    protected void doExecute(Task task, UpdateQueryGroupRequest request, ActionListener<UpdateQueryGroupResponse> listener) {
+        queryGroupPersistenceService.updateInClusterStateMetadata(request, listener);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupAction.java
new file mode 100644
index 0000000000000..ff472f206131c
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupAction.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionType;
+
+/**
+ * Transport action to update QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class UpdateQueryGroupAction extends ActionType<UpdateQueryGroupResponse> {
+
+    /**
+     * An instance of UpdateQueryGroupAction
+     */
+    public static final UpdateQueryGroupAction INSTANCE = new UpdateQueryGroupAction();
+
+    /**
+     * Name for UpdateQueryGroupAction
+     */
+    public static final String NAME = "cluster:admin/opensearch/wlm/query_group/_update";
+
+    /**
+     * Default constructor
+     */
+    private UpdateQueryGroupAction() {
+        super(NAME, UpdateQueryGroupResponse::new);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupRequest.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupRequest.java
new file mode 100644
index 0000000000000..048b599f095fd
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupRequest.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.wlm.MutableQueryGroupFragment;
+
+import java.io.IOException;
+
+/**
+ * A request for update QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class UpdateQueryGroupRequest extends ActionRequest {
+    private final String name;
+    private final MutableQueryGroupFragment mutableQueryGroupFragment;
+
+    /**
+     * Constructor for UpdateQueryGroupRequest
+     * @param name - QueryGroup name for UpdateQueryGroupRequest
+     * @param mutableQueryGroupFragment - MutableQueryGroupFragment for UpdateQueryGroupRequest
+     */
+    UpdateQueryGroupRequest(String name, MutableQueryGroupFragment mutableQueryGroupFragment) {
+        this.name = name;
+        this.mutableQueryGroupFragment = mutableQueryGroupFragment;
+    }
+
+    /**
+     * Constructor for UpdateQueryGroupRequest
+     * @param in - A {@link StreamInput} object
+     */
+    UpdateQueryGroupRequest(StreamInput in) throws IOException {
+        this(in.readString(), new MutableQueryGroupFragment(in));
+    }
+
+    /**
+     * Generate a UpdateQueryGroupRequest from XContent
+     * @param parser - A {@link XContentParser} object
+     * @param name - name of the QueryGroup to be updated
+     */
+    public static UpdateQueryGroupRequest fromXContent(XContentParser parser, String name) throws IOException {
+        QueryGroup.Builder builder = QueryGroup.Builder.fromXContent(parser);
+        return new UpdateQueryGroupRequest(name, builder.getMutableQueryGroupFragment());
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        QueryGroup.validateName(name);
+        return null;
+    }
+
+    /**
+     * name getter
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * mutableQueryGroupFragment getter
+     */
+    public MutableQueryGroupFragment getmMutableQueryGroupFragment() {
+        return mutableQueryGroupFragment;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(name);
+        mutableQueryGroupFragment.writeTo(out);
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupResponse.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupResponse.java
new file mode 100644
index 0000000000000..9071f52ecb5a7
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupResponse.java
@@ -0,0 +1,74 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.core.action.ActionResponse;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+/**
+ * Response for the update API for QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class UpdateQueryGroupResponse extends ActionResponse implements ToXContent, ToXContentObject {
+    private final QueryGroup queryGroup;
+    private final RestStatus restStatus;
+
+    /**
+     * Constructor for UpdateQueryGroupResponse
+     * @param queryGroup - the QueryGroup to be updated
+     * @param restStatus - the rest status for the response
+     */
+    public UpdateQueryGroupResponse(final QueryGroup queryGroup, RestStatus restStatus) {
+        this.queryGroup = queryGroup;
+        this.restStatus = restStatus;
+    }
+
+    /**
+     * Constructor for UpdateQueryGroupResponse
+     * @param in - a {@link StreamInput} object
+     */
+    public UpdateQueryGroupResponse(StreamInput in) throws IOException {
+        queryGroup = new QueryGroup(in);
+        restStatus = RestStatus.readFrom(in);
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        queryGroup.writeTo(out);
+        RestStatus.writeTo(out, restStatus);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        return queryGroup.toXContent(builder, params);
+    }
+
+    /**
+     * queryGroup getter
+     */
+    public QueryGroup getQueryGroup() {
+        return queryGroup;
+    }
+
+    /**
+     * restStatus getter
+     */
+    public RestStatus getRestStatus() {
+        return restStatus;
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/package-info.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/package-info.java
new file mode 100644
index 0000000000000..9921500df8a81
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/action/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Package for the action classes of WorkloadManagementPlugin
+ */
+package org.opensearch.plugin.wlm.action;
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/package-info.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/package-info.java
new file mode 100644
index 0000000000000..84c99967b226b
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Base package for WorkloadManagementPlugin
+ */
+package org.opensearch.plugin.wlm;
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestCreateQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestCreateQueryGroupAction.java
new file mode 100644
index 0000000000000..b0e0af4f9d17f
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestCreateQueryGroupAction.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.rest;
+
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.plugin.wlm.action.CreateQueryGroupAction;
+import org.opensearch.plugin.wlm.action.CreateQueryGroupRequest;
+import org.opensearch.plugin.wlm.action.CreateQueryGroupResponse;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.BytesRestResponse;
+import org.opensearch.rest.RestChannel;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.RestResponse;
+import org.opensearch.rest.action.RestResponseListener;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.opensearch.rest.RestRequest.Method.POST;
+import static org.opensearch.rest.RestRequest.Method.PUT;
+
+/**
+ * Rest action to create a QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class RestCreateQueryGroupAction extends BaseRestHandler {
+
+    /**
+     * Constructor for RestCreateQueryGroupAction
+     */
+    public RestCreateQueryGroupAction() {}
+
+    @Override
+    public String getName() {
+        return "create_query_group";
+    }
+
+    /**
+     * The list of {@link Route}s that this RestHandler is responsible for handling.
+     */
+    @Override
+    public List<Route> routes() {
+        return List.of(new Route(POST, "_wlm/query_group/"), new Route(PUT, "_wlm/query_group/"));
+    }
+
+    @Override
+    protected RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException {
+        try (XContentParser parser = request.contentParser()) {
+            CreateQueryGroupRequest createQueryGroupRequest = CreateQueryGroupRequest.fromXContent(parser);
+            return channel -> client.execute(CreateQueryGroupAction.INSTANCE, createQueryGroupRequest, createQueryGroupResponse(channel));
+        }
+    }
+
+    private RestResponseListener<CreateQueryGroupResponse> createQueryGroupResponse(final RestChannel channel) {
+        return new RestResponseListener<>(channel) {
+            @Override
+            public RestResponse buildResponse(final CreateQueryGroupResponse response) throws Exception {
+                return new BytesRestResponse(RestStatus.OK, response.toXContent(channel.newBuilder(), ToXContent.EMPTY_PARAMS));
+            }
+        };
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestDeleteQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestDeleteQueryGroupAction.java
new file mode 100644
index 0000000000000..8ad621cf8a1e4
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestDeleteQueryGroupAction.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.rest;
+
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.plugin.wlm.action.DeleteQueryGroupAction;
+import org.opensearch.plugin.wlm.action.DeleteQueryGroupRequest;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.action.RestToXContentListener;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.opensearch.rest.RestRequest.Method.DELETE;
+
+/**
+ * Rest action to delete a QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class RestDeleteQueryGroupAction extends BaseRestHandler {
+
+    /**
+     * Constructor for RestDeleteQueryGroupAction
+     */
+    public RestDeleteQueryGroupAction() {}
+
+    @Override
+    public String getName() {
+        return "delete_query_group";
+    }
+
+    /**
+     * The list of {@link Route}s that this RestHandler is responsible for handling.
+     */
+    @Override
+    public List<Route> routes() {
+        return List.of(new Route(DELETE, "_wlm/query_group/{name}"));
+    }
+
+    @Override
+    protected RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException {
+        DeleteQueryGroupRequest deleteQueryGroupRequest = new DeleteQueryGroupRequest(request.param("name"));
+        deleteQueryGroupRequest.clusterManagerNodeTimeout(
+            request.paramAsTime("cluster_manager_timeout", deleteQueryGroupRequest.clusterManagerNodeTimeout())
+        );
+        deleteQueryGroupRequest.timeout(request.paramAsTime("timeout", deleteQueryGroupRequest.timeout()));
+        return channel -> client.execute(DeleteQueryGroupAction.INSTANCE, deleteQueryGroupRequest, new RestToXContentListener<>(channel));
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestGetQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestGetQueryGroupAction.java
new file mode 100644
index 0000000000000..c87973e113138
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestGetQueryGroupAction.java
@@ -0,0 +1,68 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.rest;
+
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.plugin.wlm.action.GetQueryGroupAction;
+import org.opensearch.plugin.wlm.action.GetQueryGroupRequest;
+import org.opensearch.plugin.wlm.action.GetQueryGroupResponse;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.BytesRestResponse;
+import org.opensearch.rest.RestChannel;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.RestResponse;
+import org.opensearch.rest.action.RestResponseListener;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.opensearch.rest.RestRequest.Method.GET;
+
+/**
+ * Rest action to get a QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class RestGetQueryGroupAction extends BaseRestHandler {
+
+    /**
+     * Constructor for RestGetQueryGroupAction
+     */
+    public RestGetQueryGroupAction() {}
+
+    @Override
+    public String getName() {
+        return "get_query_group";
+    }
+
+    /**
+     * The list of {@link Route}s that this RestHandler is responsible for handling.
+     */
+    @Override
+    public List<Route> routes() {
+        return List.of(new Route(GET, "_wlm/query_group/{name}"), new Route(GET, "_wlm/query_group/"));
+    }
+
+    @Override
+    protected RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException {
+        final GetQueryGroupRequest getQueryGroupRequest = new GetQueryGroupRequest(request.param("name"));
+        return channel -> client.execute(GetQueryGroupAction.INSTANCE, getQueryGroupRequest, getQueryGroupResponse(channel));
+    }
+
+    private RestResponseListener<GetQueryGroupResponse> getQueryGroupResponse(final RestChannel channel) {
+        return new RestResponseListener<>(channel) {
+            @Override
+            public RestResponse buildResponse(final GetQueryGroupResponse response) throws Exception {
+                return new BytesRestResponse(RestStatus.OK, response.toXContent(channel.newBuilder(), ToXContent.EMPTY_PARAMS));
+            }
+        };
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestUpdateQueryGroupAction.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestUpdateQueryGroupAction.java
new file mode 100644
index 0000000000000..55b4bc5a295c4
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/RestUpdateQueryGroupAction.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.rest;
+
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.plugin.wlm.action.UpdateQueryGroupAction;
+import org.opensearch.plugin.wlm.action.UpdateQueryGroupRequest;
+import org.opensearch.plugin.wlm.action.UpdateQueryGroupResponse;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.BytesRestResponse;
+import org.opensearch.rest.RestChannel;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.RestResponse;
+import org.opensearch.rest.action.RestResponseListener;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.opensearch.rest.RestRequest.Method.POST;
+import static org.opensearch.rest.RestRequest.Method.PUT;
+
+/**
+ * Rest action to update a QueryGroup
+ *
+ * @opensearch.experimental
+ */
+public class RestUpdateQueryGroupAction extends BaseRestHandler {
+
+    /**
+     * Constructor for RestUpdateQueryGroupAction
+     */
+    public RestUpdateQueryGroupAction() {}
+
+    @Override
+    public String getName() {
+        return "update_query_group";
+    }
+
+    /**
+     * The list of {@link Route}s that this RestHandler is responsible for handling.
+     */
+    @Override
+    public List<Route> routes() {
+        return List.of(new Route(POST, "_wlm/query_group/{name}"), new Route(PUT, "_wlm/query_group/{name}"));
+    }
+
+    @Override
+    protected RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) throws IOException {
+        try (XContentParser parser = request.contentParser()) {
+            UpdateQueryGroupRequest updateQueryGroupRequest = UpdateQueryGroupRequest.fromXContent(parser, request.param("name"));
+            return channel -> client.execute(UpdateQueryGroupAction.INSTANCE, updateQueryGroupRequest, updateQueryGroupResponse(channel));
+        }
+    }
+
+    private RestResponseListener<UpdateQueryGroupResponse> updateQueryGroupResponse(final RestChannel channel) {
+        return new RestResponseListener<>(channel) {
+            @Override
+            public RestResponse buildResponse(final UpdateQueryGroupResponse response) throws Exception {
+                return new BytesRestResponse(RestStatus.OK, response.toXContent(channel.newBuilder(), ToXContent.EMPTY_PARAMS));
+            }
+        };
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/package-info.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/package-info.java
new file mode 100644
index 0000000000000..7d7cb9028fdb8
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/rest/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Package for the rest classes of WorkloadManagementPlugin
+ */
+package org.opensearch.plugin.wlm.rest;
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/service/QueryGroupPersistenceService.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/service/QueryGroupPersistenceService.java
new file mode 100644
index 0000000000000..f9332ff3022dc
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/service/QueryGroupPersistenceService.java
@@ -0,0 +1,358 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.service;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.ResourceNotFoundException;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.cluster.AckedClusterStateUpdateTask;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ClusterStateUpdateTask;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
+import org.opensearch.cluster.service.ClusterManagerTaskThrottler.ThrottlingKey;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.plugin.wlm.action.CreateQueryGroupResponse;
+import org.opensearch.plugin.wlm.action.DeleteQueryGroupRequest;
+import org.opensearch.plugin.wlm.action.UpdateQueryGroupRequest;
+import org.opensearch.plugin.wlm.action.UpdateQueryGroupResponse;
+import org.opensearch.wlm.MutableQueryGroupFragment;
+import org.opensearch.wlm.ResourceType;
+
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import static org.opensearch.cluster.metadata.QueryGroup.updateExistingQueryGroup;
+
+/**
+ * This class defines the functions for QueryGroup persistence
+ */
+public class QueryGroupPersistenceService {
+    static final String SOURCE = "query-group-persistence-service";
+    private static final String CREATE_QUERY_GROUP_THROTTLING_KEY = "create-query-group";
+    private static final String DELETE_QUERY_GROUP_THROTTLING_KEY = "delete-query-group";
+    private static final String UPDATE_QUERY_GROUP_THROTTLING_KEY = "update-query-group";
+    private static final Logger logger = LogManager.getLogger(QueryGroupPersistenceService.class);
+    /**
+     *  max QueryGroup count setting name
+     */
+    public static final String QUERY_GROUP_COUNT_SETTING_NAME = "node.query_group.max_count";
+    /**
+     * default max queryGroup count on any node at any given point in time
+     */
+    private static final int DEFAULT_MAX_QUERY_GROUP_COUNT_VALUE = 100;
+    /**
+     * min queryGroup count on any node at any given point in time
+     */
+    private static final int MIN_QUERY_GROUP_COUNT_VALUE = 1;
+    /**
+     *  max QueryGroup count setting
+     */
+    public static final Setting<Integer> MAX_QUERY_GROUP_COUNT = Setting.intSetting(
+        QUERY_GROUP_COUNT_SETTING_NAME,
+        DEFAULT_MAX_QUERY_GROUP_COUNT_VALUE,
+        0,
+        QueryGroupPersistenceService::validateMaxQueryGroupCount,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+    private final ClusterService clusterService;
+    private volatile int maxQueryGroupCount;
+    final ThrottlingKey createQueryGroupThrottlingKey;
+    final ThrottlingKey deleteQueryGroupThrottlingKey;
+    final ThrottlingKey updateQueryGroupThrottlingKey;
+
+    /**
+     * Constructor for QueryGroupPersistenceService
+     *
+     * @param clusterService {@link ClusterService} - The cluster service to be used by QueryGroupPersistenceService
+     * @param settings {@link Settings} - The settings to be used by QueryGroupPersistenceService
+     * @param clusterSettings {@link ClusterSettings} - The cluster settings to be used by QueryGroupPersistenceService
+     */
+    @Inject
+    public QueryGroupPersistenceService(
+        final ClusterService clusterService,
+        final Settings settings,
+        final ClusterSettings clusterSettings
+    ) {
+        this.clusterService = clusterService;
+        this.createQueryGroupThrottlingKey = clusterService.registerClusterManagerTask(CREATE_QUERY_GROUP_THROTTLING_KEY, true);
+        this.deleteQueryGroupThrottlingKey = clusterService.registerClusterManagerTask(DELETE_QUERY_GROUP_THROTTLING_KEY, true);
+        this.updateQueryGroupThrottlingKey = clusterService.registerClusterManagerTask(UPDATE_QUERY_GROUP_THROTTLING_KEY, true);
+        setMaxQueryGroupCount(MAX_QUERY_GROUP_COUNT.get(settings));
+        clusterSettings.addSettingsUpdateConsumer(MAX_QUERY_GROUP_COUNT, this::setMaxQueryGroupCount);
+    }
+
+    /**
+     * Set maxQueryGroupCount to be newMaxQueryGroupCount
+     * @param newMaxQueryGroupCount - the max number of QueryGroup allowed
+     */
+    public void setMaxQueryGroupCount(int newMaxQueryGroupCount) {
+        validateMaxQueryGroupCount(newMaxQueryGroupCount);
+        this.maxQueryGroupCount = newMaxQueryGroupCount;
+    }
+
+    /**
+     * Validator for maxQueryGroupCount
+     * @param maxQueryGroupCount - the maxQueryGroupCount number to be verified
+     */
+    private static void validateMaxQueryGroupCount(int maxQueryGroupCount) {
+        if (maxQueryGroupCount > DEFAULT_MAX_QUERY_GROUP_COUNT_VALUE || maxQueryGroupCount < MIN_QUERY_GROUP_COUNT_VALUE) {
+            throw new IllegalArgumentException(QUERY_GROUP_COUNT_SETTING_NAME + " should be in range [1-100].");
+        }
+    }
+
+    /**
+     * Update cluster state to include the new QueryGroup
+     * @param queryGroup {@link QueryGroup} - the QueryGroup we're currently creating
+     * @param listener - ActionListener for CreateQueryGroupResponse
+     */
+    public void persistInClusterStateMetadata(QueryGroup queryGroup, ActionListener<CreateQueryGroupResponse> listener) {
+        clusterService.submitStateUpdateTask(SOURCE, new ClusterStateUpdateTask(Priority.NORMAL) {
+            @Override
+            public ClusterState execute(ClusterState currentState) throws Exception {
+                return saveQueryGroupInClusterState(queryGroup, currentState);
+            }
+
+            @Override
+            public ThrottlingKey getClusterManagerThrottlingKey() {
+                return createQueryGroupThrottlingKey;
+            }
+
+            @Override
+            public void onFailure(String source, Exception e) {
+                logger.warn("failed to save QueryGroup object due to error: {}, for source: {}.", e.getMessage(), source);
+                listener.onFailure(e);
+            }
+
+            @Override
+            public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
+                CreateQueryGroupResponse response = new CreateQueryGroupResponse(queryGroup, RestStatus.OK);
+                listener.onResponse(response);
+            }
+        });
+    }
+
+    /**
+     * This method will be executed before we submit the new cluster state
+     * @param queryGroup - the QueryGroup we're currently creating
+     * @param currentClusterState - the cluster state before the update
+     */
+    ClusterState saveQueryGroupInClusterState(final QueryGroup queryGroup, final ClusterState currentClusterState) {
+        final Map<String, QueryGroup> existingQueryGroups = currentClusterState.metadata().queryGroups();
+        String groupName = queryGroup.getName();
+
+        // check if maxQueryGroupCount will breach
+        if (existingQueryGroups.size() == maxQueryGroupCount) {
+            logger.warn("{} value exceeded its assigned limit of {}.", QUERY_GROUP_COUNT_SETTING_NAME, maxQueryGroupCount);
+            throw new IllegalStateException("Can't create more than " + maxQueryGroupCount + " QueryGroups in the system.");
+        }
+
+        // check for duplicate name
+        Optional<QueryGroup> findExistingGroup = existingQueryGroups.values()
+            .stream()
+            .filter(group -> group.getName().equals(groupName))
+            .findFirst();
+        if (findExistingGroup.isPresent()) {
+            logger.warn("QueryGroup with name {} already exists. Not creating a new one.", groupName);
+            throw new IllegalArgumentException("QueryGroup with name " + groupName + " already exists. Not creating a new one.");
+        }
+
+        // check if there's any resource allocation that exceed limit of 1.0
+        validateTotalUsage(existingQueryGroups, groupName, queryGroup.getResourceLimits());
+
+        return ClusterState.builder(currentClusterState)
+            .metadata(Metadata.builder(currentClusterState.metadata()).put(queryGroup).build())
+            .build();
+    }
+
+    /**
+     * Get the QueryGroups with the specified name from cluster state
+     * @param name - the QueryGroup name we are getting
+     * @param currentState - current cluster state
+     */
+    public static Collection<QueryGroup> getFromClusterStateMetadata(String name, ClusterState currentState) {
+        final Map<String, QueryGroup> currentGroups = currentState.getMetadata().queryGroups();
+        if (name == null || name.isEmpty()) {
+            return currentGroups.values();
+        }
+        return currentGroups.values()
+            .stream()
+            .filter(group -> group.getName().equals(name))
+            .findAny()
+            .stream()
+            .collect(Collectors.toList());
+    }
+
+    /**
+     * Modify cluster state to delete the QueryGroup
+     * @param deleteQueryGroupRequest - request to delete a QueryGroup
+     * @param listener - ActionListener for AcknowledgedResponse
+     */
+    public void deleteInClusterStateMetadata(
+        DeleteQueryGroupRequest deleteQueryGroupRequest,
+        ActionListener<AcknowledgedResponse> listener
+    ) {
+        clusterService.submitStateUpdateTask(SOURCE, new AckedClusterStateUpdateTask<>(deleteQueryGroupRequest, listener) {
+            @Override
+            public ClusterState execute(ClusterState currentState) {
+                return deleteQueryGroupInClusterState(deleteQueryGroupRequest.getName(), currentState);
+            }
+
+            @Override
+            public ClusterManagerTaskThrottler.ThrottlingKey getClusterManagerThrottlingKey() {
+                return deleteQueryGroupThrottlingKey;
+            }
+
+            @Override
+            protected AcknowledgedResponse newResponse(boolean acknowledged) {
+                return new AcknowledgedResponse(acknowledged);
+            }
+        });
+    }
+
+    /**
+     * Modify cluster state to delete the QueryGroup, and return the new cluster state
+     * @param name - the name for QueryGroup to be deleted
+     * @param currentClusterState - current cluster state
+     */
+    ClusterState deleteQueryGroupInClusterState(final String name, final ClusterState currentClusterState) {
+        final Metadata metadata = currentClusterState.metadata();
+        final QueryGroup queryGroupToRemove = metadata.queryGroups()
+            .values()
+            .stream()
+            .filter(queryGroup -> queryGroup.getName().equals(name))
+            .findAny()
+            .orElseThrow(() -> new ResourceNotFoundException("No QueryGroup exists with the provided name: " + name));
+
+        return ClusterState.builder(currentClusterState).metadata(Metadata.builder(metadata).remove(queryGroupToRemove).build()).build();
+    }
+
+    /**
+     * Modify cluster state to update the QueryGroup
+     * @param toUpdateGroup {@link QueryGroup} - the QueryGroup that we want to update
+     * @param listener - ActionListener for UpdateQueryGroupResponse
+     */
+    public void updateInClusterStateMetadata(UpdateQueryGroupRequest toUpdateGroup, ActionListener<UpdateQueryGroupResponse> listener) {
+        clusterService.submitStateUpdateTask(SOURCE, new ClusterStateUpdateTask(Priority.NORMAL) {
+            @Override
+            public ClusterState execute(ClusterState currentState) {
+                return updateQueryGroupInClusterState(toUpdateGroup, currentState);
+            }
+
+            @Override
+            public ThrottlingKey getClusterManagerThrottlingKey() {
+                return updateQueryGroupThrottlingKey;
+            }
+
+            @Override
+            public void onFailure(String source, Exception e) {
+                logger.warn("Failed to update QueryGroup due to error: {}, for source: {}", e.getMessage(), source);
+                listener.onFailure(e);
+            }
+
+            @Override
+            public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
+                String name = toUpdateGroup.getName();
+                Optional<QueryGroup> findUpdatedGroup = newState.metadata()
+                    .queryGroups()
+                    .values()
+                    .stream()
+                    .filter(group -> group.getName().equals(name))
+                    .findFirst();
+                assert findUpdatedGroup.isPresent();
+                QueryGroup updatedGroup = findUpdatedGroup.get();
+                UpdateQueryGroupResponse response = new UpdateQueryGroupResponse(updatedGroup, RestStatus.OK);
+                listener.onResponse(response);
+            }
+        });
+    }
+
+    /**
+     * Modify cluster state to update the existing QueryGroup
+     * @param updateQueryGroupRequest {@link QueryGroup} - the QueryGroup that we want to update
+     * @param currentState - current cluster state
+     */
+    ClusterState updateQueryGroupInClusterState(UpdateQueryGroupRequest updateQueryGroupRequest, ClusterState currentState) {
+        final Metadata metadata = currentState.metadata();
+        final Map<String, QueryGroup> existingGroups = currentState.metadata().queryGroups();
+        String name = updateQueryGroupRequest.getName();
+        MutableQueryGroupFragment mutableQueryGroupFragment = updateQueryGroupRequest.getmMutableQueryGroupFragment();
+
+        final QueryGroup existingGroup = existingGroups.values()
+            .stream()
+            .filter(group -> group.getName().equals(name))
+            .findFirst()
+            .orElseThrow(() -> new ResourceNotFoundException("No QueryGroup exists with the provided name: " + name));
+
+        validateTotalUsage(existingGroups, name, mutableQueryGroupFragment.getResourceLimits());
+        return ClusterState.builder(currentState)
+            .metadata(
+                Metadata.builder(metadata)
+                    .remove(existingGroup)
+                    .put(updateExistingQueryGroup(existingGroup, mutableQueryGroupFragment))
+                    .build()
+            )
+            .build();
+    }
+
+    /**
+     * This method checks if there's any resource allocation that exceed limit of 1.0
+     * @param existingQueryGroups - existing QueryGroups in the system
+     * @param resourceLimits - the QueryGroup we're creating or updating
+     */
+    private void validateTotalUsage(Map<String, QueryGroup> existingQueryGroups, String name, Map<ResourceType, Double> resourceLimits) {
+        if (resourceLimits == null || resourceLimits.isEmpty()) {
+            return;
+        }
+        final Map<ResourceType, Double> totalUsage = new EnumMap<>(ResourceType.class);
+        totalUsage.putAll(resourceLimits);
+        for (QueryGroup currGroup : existingQueryGroups.values()) {
+            if (!currGroup.getName().equals(name)) {
+                for (ResourceType resourceType : resourceLimits.keySet()) {
+                    totalUsage.compute(resourceType, (k, v) -> v + currGroup.getResourceLimits().getOrDefault(resourceType, 0.0));
+                }
+            }
+        }
+        totalUsage.forEach((resourceType, total) -> {
+            if (total > 1.0) {
+                logger.warn("Total resource allocation for {} will go above the max limit of 1.0.", resourceType.getName());
+                throw new IllegalArgumentException(
+                    "Total resource allocation for " + resourceType.getName() + " will go above the max limit of 1.0."
+                );
+            }
+        });
+    }
+
+    /**
+     * maxQueryGroupCount getter
+     */
+    public int getMaxQueryGroupCount() {
+        return maxQueryGroupCount;
+    }
+
+    /**
+     * clusterService getter
+     */
+    public ClusterService getClusterService() {
+        return clusterService;
+    }
+}
diff --git a/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/service/package-info.java b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/service/package-info.java
new file mode 100644
index 0000000000000..5848e9c936623
--- /dev/null
+++ b/plugins/workload-management/src/main/java/org/opensearch/plugin/wlm/service/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Package for the service classes of WorkloadManagementPlugin
+ */
+package org.opensearch.plugin.wlm.service;
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/QueryGroupTestUtils.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/QueryGroupTestUtils.java
new file mode 100644
index 0000000000000..c6eb3140e943d
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/QueryGroupTestUtils.java
@@ -0,0 +1,166 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm;
+
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.cluster.service.ClusterApplierService;
+import org.opensearch.cluster.service.ClusterManagerService;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.plugin.wlm.service.QueryGroupPersistenceService;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.wlm.MutableQueryGroupFragment;
+import org.opensearch.wlm.ResourceType;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static org.opensearch.cluster.metadata.QueryGroup.builder;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+public class QueryGroupTestUtils {
+    public static final String NAME_ONE = "query_group_one";
+    public static final String NAME_TWO = "query_group_two";
+    public static final String _ID_ONE = "AgfUO5Ja9yfsYlONlYi3TQ==";
+    public static final String _ID_TWO = "G5iIqHy4g7eK1qIAAAAIH53=1";
+    public static final String NAME_NONE_EXISTED = "query_group_none_existed";
+    public static final long TIMESTAMP_ONE = 4513232413L;
+    public static final long TIMESTAMP_TWO = 4513232415L;
+    public static final QueryGroup queryGroupOne = builder().name(NAME_ONE)
+        ._id(_ID_ONE)
+        .mutableQueryGroupFragment(
+            new MutableQueryGroupFragment(MutableQueryGroupFragment.ResiliencyMode.MONITOR, Map.of(ResourceType.MEMORY, 0.3))
+        )
+        .updatedAt(TIMESTAMP_ONE)
+        .build();
+
+    public static final QueryGroup queryGroupTwo = builder().name(NAME_TWO)
+        ._id(_ID_TWO)
+        .mutableQueryGroupFragment(
+            new MutableQueryGroupFragment(MutableQueryGroupFragment.ResiliencyMode.MONITOR, Map.of(ResourceType.MEMORY, 0.6))
+        )
+        .updatedAt(TIMESTAMP_TWO)
+        .build();
+
+    public static List<QueryGroup> queryGroupList() {
+        List<QueryGroup> list = new ArrayList<>();
+        list.add(queryGroupOne);
+        list.add(queryGroupTwo);
+        return list;
+    }
+
+    public static ClusterState clusterState() {
+        final Metadata metadata = Metadata.builder().queryGroups(Map.of(_ID_ONE, queryGroupOne, _ID_TWO, queryGroupTwo)).build();
+        return ClusterState.builder(new ClusterName("_name")).metadata(metadata).build();
+    }
+
+    public static Set<Setting<?>> clusterSettingsSet() {
+        Set<Setting<?>> set = new HashSet<>(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        set.add(QueryGroupPersistenceService.MAX_QUERY_GROUP_COUNT);
+        assertFalse(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS.contains(QueryGroupPersistenceService.MAX_QUERY_GROUP_COUNT));
+        return set;
+    }
+
+    public static Settings settings() {
+        return Settings.builder().build();
+    }
+
+    public static ClusterSettings clusterSettings() {
+        return new ClusterSettings(settings(), clusterSettingsSet());
+    }
+
+    public static QueryGroupPersistenceService queryGroupPersistenceService() {
+        ClusterApplierService clusterApplierService = new ClusterApplierService(
+            "name",
+            settings(),
+            clusterSettings(),
+            mock(ThreadPool.class)
+        );
+        clusterApplierService.setInitialState(clusterState());
+        ClusterService clusterService = new ClusterService(
+            settings(),
+            clusterSettings(),
+            mock(ClusterManagerService.class),
+            clusterApplierService
+        );
+        return new QueryGroupPersistenceService(clusterService, settings(), clusterSettings());
+    }
+
+    public static Tuple<QueryGroupPersistenceService, ClusterState> preparePersistenceServiceSetup(Map<String, QueryGroup> queryGroups) {
+        Metadata metadata = Metadata.builder().queryGroups(queryGroups).build();
+        Settings settings = Settings.builder().build();
+        ClusterState clusterState = ClusterState.builder(new ClusterName("_name")).metadata(metadata).build();
+        ClusterSettings clusterSettings = new ClusterSettings(settings, clusterSettingsSet());
+        ClusterApplierService clusterApplierService = new ClusterApplierService(
+            "name",
+            settings(),
+            clusterSettings(),
+            mock(ThreadPool.class)
+        );
+        clusterApplierService.setInitialState(clusterState);
+        ClusterService clusterService = new ClusterService(
+            settings(),
+            clusterSettings(),
+            mock(ClusterManagerService.class),
+            clusterApplierService
+        );
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            settings,
+            clusterSettings
+        );
+        return new Tuple<QueryGroupPersistenceService, ClusterState>(queryGroupPersistenceService, clusterState);
+    }
+
+    public static void assertEqualResourceLimits(
+        Map<ResourceType, Double> resourceLimitMapOne,
+        Map<ResourceType, Double> resourceLimitMapTwo
+    ) {
+        assertTrue(resourceLimitMapOne.keySet().containsAll(resourceLimitMapTwo.keySet()));
+        assertTrue(resourceLimitMapOne.values().containsAll(resourceLimitMapTwo.values()));
+    }
+
+    public static void assertEqualQueryGroups(
+        Collection<QueryGroup> collectionOne,
+        Collection<QueryGroup> collectionTwo,
+        boolean assertUpdateAt
+    ) {
+        assertEquals(collectionOne.size(), collectionTwo.size());
+        List<QueryGroup> listOne = new ArrayList<>(collectionOne);
+        List<QueryGroup> listTwo = new ArrayList<>(collectionTwo);
+        listOne.sort(Comparator.comparing(QueryGroup::getName));
+        listTwo.sort(Comparator.comparing(QueryGroup::getName));
+        for (int i = 0; i < listOne.size(); i++) {
+            if (assertUpdateAt) {
+                QueryGroup one = listOne.get(i);
+                QueryGroup two = listTwo.get(i);
+                assertEquals(one.getName(), two.getName());
+                assertEquals(one.getResourceLimits(), two.getResourceLimits());
+                assertEquals(one.getResiliencyMode(), two.getResiliencyMode());
+                assertEquals(one.get_id(), two.get_id());
+            } else {
+                assertEquals(listOne.get(i), listTwo.get(i));
+            }
+        }
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/CreateQueryGroupRequestTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/CreateQueryGroupRequestTests.java
new file mode 100644
index 0000000000000..dd9de4bf8fb1a
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/CreateQueryGroupRequestTests.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.assertEqualQueryGroups;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.queryGroupOne;
+
+public class CreateQueryGroupRequestTests extends OpenSearchTestCase {
+
+    /**
+     * Test case to verify the serialization and deserialization of CreateQueryGroupRequest.
+     */
+    public void testSerialization() throws IOException {
+        CreateQueryGroupRequest request = new CreateQueryGroupRequest(queryGroupOne);
+        BytesStreamOutput out = new BytesStreamOutput();
+        request.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        CreateQueryGroupRequest otherRequest = new CreateQueryGroupRequest(streamInput);
+        List<QueryGroup> list1 = new ArrayList<>();
+        List<QueryGroup> list2 = new ArrayList<>();
+        list1.add(queryGroupOne);
+        list2.add(otherRequest.getQueryGroup());
+        assertEqualQueryGroups(list1, list2, false);
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/CreateQueryGroupResponseTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/CreateQueryGroupResponseTests.java
new file mode 100644
index 0000000000000..3a2ce215d21b5
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/CreateQueryGroupResponseTests.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.plugin.wlm.QueryGroupTestUtils;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.Mockito.mock;
+
+public class CreateQueryGroupResponseTests extends OpenSearchTestCase {
+
+    /**
+     * Test case to verify serialization and deserialization of CreateQueryGroupResponse.
+     */
+    public void testSerialization() throws IOException {
+        CreateQueryGroupResponse response = new CreateQueryGroupResponse(QueryGroupTestUtils.queryGroupOne, RestStatus.OK);
+        BytesStreamOutput out = new BytesStreamOutput();
+        response.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        CreateQueryGroupResponse otherResponse = new CreateQueryGroupResponse(streamInput);
+        assertEquals(response.getRestStatus(), otherResponse.getRestStatus());
+        QueryGroup responseGroup = response.getQueryGroup();
+        QueryGroup otherResponseGroup = otherResponse.getQueryGroup();
+        List<QueryGroup> listOne = new ArrayList<>();
+        List<QueryGroup> listTwo = new ArrayList<>();
+        listOne.add(responseGroup);
+        listTwo.add(otherResponseGroup);
+        QueryGroupTestUtils.assertEqualQueryGroups(listOne, listTwo, false);
+    }
+
+    /**
+     * Test case to validate the toXContent method of CreateQueryGroupResponse.
+     */
+    public void testToXContentCreateQueryGroup() throws IOException {
+        XContentBuilder builder = JsonXContent.contentBuilder().prettyPrint();
+        CreateQueryGroupResponse response = new CreateQueryGroupResponse(QueryGroupTestUtils.queryGroupOne, RestStatus.OK);
+        String actual = response.toXContent(builder, mock(ToXContent.Params.class)).toString();
+        String expected = "{\n"
+            + "  \"_id\" : \"AgfUO5Ja9yfsYlONlYi3TQ==\",\n"
+            + "  \"name\" : \"query_group_one\",\n"
+            + "  \"resiliency_mode\" : \"monitor\",\n"
+            + "  \"resource_limits\" : {\n"
+            + "    \"memory\" : 0.3\n"
+            + "  },\n"
+            + "  \"updated_at\" : 4513232413\n"
+            + "}";
+        assertEquals(expected, actual);
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupRequestTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupRequestTests.java
new file mode 100644
index 0000000000000..bc2e4f0faca4c
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/DeleteQueryGroupRequestTests.java
@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.plugin.wlm.QueryGroupTestUtils;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+
+public class DeleteQueryGroupRequestTests extends OpenSearchTestCase {
+
+    /**
+     * Test case to verify the serialization and deserialization of DeleteQueryGroupRequest.
+     */
+    public void testSerialization() throws IOException {
+        DeleteQueryGroupRequest request = new DeleteQueryGroupRequest(QueryGroupTestUtils.NAME_ONE);
+        assertEquals(QueryGroupTestUtils.NAME_ONE, request.getName());
+        BytesStreamOutput out = new BytesStreamOutput();
+        request.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        DeleteQueryGroupRequest otherRequest = new DeleteQueryGroupRequest(streamInput);
+        assertEquals(request.getName(), otherRequest.getName());
+    }
+
+    /**
+     * Test case to validate a DeleteQueryGroupRequest.
+     */
+    public void testSerializationWithNull() throws IOException {
+        DeleteQueryGroupRequest request = new DeleteQueryGroupRequest((String) null);
+        ActionRequestValidationException actionRequestValidationException = request.validate();
+        assertFalse(actionRequestValidationException.getMessage().isEmpty());
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/GetQueryGroupRequestTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/GetQueryGroupRequestTests.java
new file mode 100644
index 0000000000000..32b5f7ec9e2c3
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/GetQueryGroupRequestTests.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.plugin.wlm.QueryGroupTestUtils;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+
+public class GetQueryGroupRequestTests extends OpenSearchTestCase {
+
+    /**
+     * Test case to verify the serialization and deserialization of GetQueryGroupRequest.
+     */
+    public void testSerialization() throws IOException {
+        GetQueryGroupRequest request = new GetQueryGroupRequest(QueryGroupTestUtils.NAME_ONE);
+        assertEquals(QueryGroupTestUtils.NAME_ONE, request.getName());
+        BytesStreamOutput out = new BytesStreamOutput();
+        request.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        GetQueryGroupRequest otherRequest = new GetQueryGroupRequest(streamInput);
+        assertEquals(request.getName(), otherRequest.getName());
+    }
+
+    /**
+     * Test case to verify the serialization and deserialization of GetQueryGroupRequest when name is null.
+     */
+    public void testSerializationWithNull() throws IOException {
+        GetQueryGroupRequest request = new GetQueryGroupRequest((String) null);
+        assertNull(request.getName());
+        BytesStreamOutput out = new BytesStreamOutput();
+        request.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        GetQueryGroupRequest otherRequest = new GetQueryGroupRequest(streamInput);
+        assertEquals(request.getName(), otherRequest.getName());
+    }
+
+    /**
+     * Test case the validation function of GetQueryGroupRequest
+     */
+    public void testValidation() {
+        GetQueryGroupRequest request = new GetQueryGroupRequest("a".repeat(51));
+        assertThrows(IllegalArgumentException.class, request::validate);
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/GetQueryGroupResponseTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/GetQueryGroupResponseTests.java
new file mode 100644
index 0000000000000..1a2ac282d86a4
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/GetQueryGroupResponseTests.java
@@ -0,0 +1,151 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.plugin.wlm.QueryGroupTestUtils;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.mockito.Mockito.mock;
+
+public class GetQueryGroupResponseTests extends OpenSearchTestCase {
+
+    /**
+     * Test case to verify the serialization and deserialization of GetQueryGroupResponse.
+     */
+    public void testSerializationSingleQueryGroup() throws IOException {
+        List<QueryGroup> list = new ArrayList<>();
+        list.add(QueryGroupTestUtils.queryGroupOne);
+        GetQueryGroupResponse response = new GetQueryGroupResponse(list, RestStatus.OK);
+        assertEquals(response.getQueryGroups(), list);
+
+        BytesStreamOutput out = new BytesStreamOutput();
+        response.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+
+        GetQueryGroupResponse otherResponse = new GetQueryGroupResponse(streamInput);
+        assertEquals(response.getRestStatus(), otherResponse.getRestStatus());
+        QueryGroupTestUtils.assertEqualQueryGroups(response.getQueryGroups(), otherResponse.getQueryGroups(), false);
+    }
+
+    /**
+     * Test case to verify the serialization and deserialization of GetQueryGroupResponse when the result contains multiple QueryGroups.
+     */
+    public void testSerializationMultipleQueryGroup() throws IOException {
+        GetQueryGroupResponse response = new GetQueryGroupResponse(QueryGroupTestUtils.queryGroupList(), RestStatus.OK);
+        assertEquals(response.getQueryGroups(), QueryGroupTestUtils.queryGroupList());
+
+        BytesStreamOutput out = new BytesStreamOutput();
+        response.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+
+        GetQueryGroupResponse otherResponse = new GetQueryGroupResponse(streamInput);
+        assertEquals(response.getRestStatus(), otherResponse.getRestStatus());
+        assertEquals(2, otherResponse.getQueryGroups().size());
+        QueryGroupTestUtils.assertEqualQueryGroups(response.getQueryGroups(), otherResponse.getQueryGroups(), false);
+    }
+
+    /**
+     * Test case to verify the serialization and deserialization of GetQueryGroupResponse when the result is empty.
+     */
+    public void testSerializationNull() throws IOException {
+        List<QueryGroup> list = new ArrayList<>();
+        GetQueryGroupResponse response = new GetQueryGroupResponse(list, RestStatus.OK);
+        assertEquals(response.getQueryGroups(), list);
+
+        BytesStreamOutput out = new BytesStreamOutput();
+        response.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+
+        GetQueryGroupResponse otherResponse = new GetQueryGroupResponse(streamInput);
+        assertEquals(response.getRestStatus(), otherResponse.getRestStatus());
+        assertEquals(0, otherResponse.getQueryGroups().size());
+    }
+
+    /**
+     * Test case to verify the toXContent of GetQueryGroupResponse.
+     */
+    public void testToXContentGetSingleQueryGroup() throws IOException {
+        List<QueryGroup> queryGroupList = new ArrayList<>();
+        queryGroupList.add(QueryGroupTestUtils.queryGroupOne);
+        XContentBuilder builder = JsonXContent.contentBuilder().prettyPrint();
+        GetQueryGroupResponse response = new GetQueryGroupResponse(queryGroupList, RestStatus.OK);
+        String actual = response.toXContent(builder, mock(ToXContent.Params.class)).toString();
+        String expected = "{\n"
+            + "  \"query_groups\" : [\n"
+            + "    {\n"
+            + "      \"_id\" : \"AgfUO5Ja9yfsYlONlYi3TQ==\",\n"
+            + "      \"name\" : \"query_group_one\",\n"
+            + "      \"resiliency_mode\" : \"monitor\",\n"
+            + "      \"resource_limits\" : {\n"
+            + "        \"memory\" : 0.3\n"
+            + "      },\n"
+            + "      \"updated_at\" : 4513232413\n"
+            + "    }\n"
+            + "  ]\n"
+            + "}";
+        assertEquals(expected, actual);
+    }
+
+    /**
+     * Test case to verify the toXContent of GetQueryGroupResponse when the result contains multiple QueryGroups.
+     */
+    public void testToXContentGetMultipleQueryGroup() throws IOException {
+        List<QueryGroup> queryGroupList = new ArrayList<>();
+        queryGroupList.add(QueryGroupTestUtils.queryGroupOne);
+        queryGroupList.add(QueryGroupTestUtils.queryGroupTwo);
+        XContentBuilder builder = JsonXContent.contentBuilder().prettyPrint();
+        GetQueryGroupResponse response = new GetQueryGroupResponse(queryGroupList, RestStatus.OK);
+        String actual = response.toXContent(builder, mock(ToXContent.Params.class)).toString();
+        String expected = "{\n"
+            + "  \"query_groups\" : [\n"
+            + "    {\n"
+            + "      \"_id\" : \"AgfUO5Ja9yfsYlONlYi3TQ==\",\n"
+            + "      \"name\" : \"query_group_one\",\n"
+            + "      \"resiliency_mode\" : \"monitor\",\n"
+            + "      \"resource_limits\" : {\n"
+            + "        \"memory\" : 0.3\n"
+            + "      },\n"
+            + "      \"updated_at\" : 4513232413\n"
+            + "    },\n"
+            + "    {\n"
+            + "      \"_id\" : \"G5iIqHy4g7eK1qIAAAAIH53=1\",\n"
+            + "      \"name\" : \"query_group_two\",\n"
+            + "      \"resiliency_mode\" : \"monitor\",\n"
+            + "      \"resource_limits\" : {\n"
+            + "        \"memory\" : 0.6\n"
+            + "      },\n"
+            + "      \"updated_at\" : 4513232415\n"
+            + "    }\n"
+            + "  ]\n"
+            + "}";
+        assertEquals(expected, actual);
+    }
+
+    /**
+     * Test case to verify toXContent of GetQueryGroupResponse when the result contains zero QueryGroup.
+     */
+    public void testToXContentGetZeroQueryGroup() throws IOException {
+        XContentBuilder builder = JsonXContent.contentBuilder().prettyPrint();
+        GetQueryGroupResponse otherResponse = new GetQueryGroupResponse(new ArrayList<>(), RestStatus.OK);
+        String actual = otherResponse.toXContent(builder, mock(ToXContent.Params.class)).toString();
+        String expected = "{\n" + "  \"query_groups\" : [ ]\n" + "}";
+        assertEquals(expected, actual);
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/QueryGroupActionTestUtils.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/QueryGroupActionTestUtils.java
new file mode 100644
index 0000000000000..08d128ca7ed59
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/QueryGroupActionTestUtils.java
@@ -0,0 +1,17 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.wlm.MutableQueryGroupFragment;
+
+public class QueryGroupActionTestUtils {
+    public static UpdateQueryGroupRequest updateQueryGroupRequest(String name, MutableQueryGroupFragment mutableQueryGroupFragment) {
+        return new UpdateQueryGroupRequest(name, mutableQueryGroupFragment);
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/TransportDeleteQueryGroupActionTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/TransportDeleteQueryGroupActionTests.java
new file mode 100644
index 0000000000000..253d65f8da80f
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/TransportDeleteQueryGroupActionTests.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.plugin.wlm.service.QueryGroupPersistenceService;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+public class TransportDeleteQueryGroupActionTests extends OpenSearchTestCase {
+
+    ClusterService clusterService = mock(ClusterService.class);
+    TransportService transportService = mock(TransportService.class);
+    ActionFilters actionFilters = mock(ActionFilters.class);
+    ThreadPool threadPool = mock(ThreadPool.class);
+    IndexNameExpressionResolver indexNameExpressionResolver = mock(IndexNameExpressionResolver.class);
+    QueryGroupPersistenceService queryGroupPersistenceService = mock(QueryGroupPersistenceService.class);
+
+    TransportDeleteQueryGroupAction action = new TransportDeleteQueryGroupAction(
+        clusterService,
+        transportService,
+        actionFilters,
+        threadPool,
+        indexNameExpressionResolver,
+        queryGroupPersistenceService
+    );
+
+    /**
+     * Test case to validate the construction for TransportDeleteQueryGroupAction
+     */
+    public void testConstruction() {
+        assertNotNull(action);
+        assertEquals(ThreadPool.Names.SAME, action.executor());
+    }
+
+    /**
+     * Test case to validate the clusterManagerOperation function in TransportDeleteQueryGroupAction
+     */
+    public void testClusterManagerOperation() throws Exception {
+        DeleteQueryGroupRequest request = new DeleteQueryGroupRequest("testGroup");
+        @SuppressWarnings("unchecked")
+        ActionListener<AcknowledgedResponse> listener = mock(ActionListener.class);
+        ClusterState clusterState = mock(ClusterState.class);
+        action.clusterManagerOperation(request, clusterState, listener);
+        verify(queryGroupPersistenceService).deleteInClusterStateMetadata(eq(request), eq(listener));
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/TransportGetQueryGroupActionTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/TransportGetQueryGroupActionTests.java
new file mode 100644
index 0000000000000..755b11a5f4b89
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/TransportGetQueryGroupActionTests.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.ResourceNotFoundException;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.NAME_NONE_EXISTED;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.NAME_ONE;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.clusterState;
+import static org.mockito.Mockito.mock;
+
+public class TransportGetQueryGroupActionTests extends OpenSearchTestCase {
+
+    /**
+     * Test case for ClusterManagerOperation function
+     */
+    @SuppressWarnings("unchecked")
+    public void testClusterManagerOperation() throws Exception {
+        GetQueryGroupRequest getQueryGroupRequest1 = new GetQueryGroupRequest(NAME_NONE_EXISTED);
+        GetQueryGroupRequest getQueryGroupRequest2 = new GetQueryGroupRequest(NAME_ONE);
+        TransportGetQueryGroupAction transportGetQueryGroupAction = new TransportGetQueryGroupAction(
+            mock(ClusterService.class),
+            mock(TransportService.class),
+            mock(ActionFilters.class),
+            mock(ThreadPool.class),
+            mock(IndexNameExpressionResolver.class)
+        );
+        assertThrows(
+            ResourceNotFoundException.class,
+            () -> transportGetQueryGroupAction.clusterManagerOperation(getQueryGroupRequest1, clusterState(), mock(ActionListener.class))
+        );
+        transportGetQueryGroupAction.clusterManagerOperation(getQueryGroupRequest2, clusterState(), mock(ActionListener.class));
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupRequestTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupRequestTests.java
new file mode 100644
index 0000000000000..b99f079e81984
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupRequestTests.java
@@ -0,0 +1,97 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.wlm.MutableQueryGroupFragment;
+import org.opensearch.wlm.MutableQueryGroupFragment.ResiliencyMode;
+import org.opensearch.wlm.ResourceType;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.NAME_ONE;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.queryGroupOne;
+
+public class UpdateQueryGroupRequestTests extends OpenSearchTestCase {
+
+    /**
+     * Test case to verify the serialization and deserialization of UpdateQueryGroupRequest.
+     */
+    public void testSerialization() throws IOException {
+        UpdateQueryGroupRequest request = new UpdateQueryGroupRequest(NAME_ONE, queryGroupOne.getMutableQueryGroupFragment());
+        BytesStreamOutput out = new BytesStreamOutput();
+        request.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        UpdateQueryGroupRequest otherRequest = new UpdateQueryGroupRequest(streamInput);
+        assertEquals(request.getName(), otherRequest.getName());
+        assertEquals(request.getmMutableQueryGroupFragment(), otherRequest.getmMutableQueryGroupFragment());
+    }
+
+    /**
+     * Test case to verify the serialization and deserialization of UpdateQueryGroupRequest with only name field.
+     */
+    public void testSerializationOnlyName() throws IOException {
+        UpdateQueryGroupRequest request = new UpdateQueryGroupRequest(NAME_ONE, new MutableQueryGroupFragment(null, new HashMap<>()));
+        BytesStreamOutput out = new BytesStreamOutput();
+        request.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        UpdateQueryGroupRequest otherRequest = new UpdateQueryGroupRequest(streamInput);
+        assertEquals(request.getName(), otherRequest.getName());
+        assertEquals(request.getmMutableQueryGroupFragment(), otherRequest.getmMutableQueryGroupFragment());
+    }
+
+    /**
+     * Test case to verify the serialization and deserialization of UpdateQueryGroupRequest with only resourceLimits field.
+     */
+    public void testSerializationOnlyResourceLimit() throws IOException {
+        UpdateQueryGroupRequest request = new UpdateQueryGroupRequest(
+            NAME_ONE,
+            new MutableQueryGroupFragment(null, Map.of(ResourceType.MEMORY, 0.4))
+        );
+        BytesStreamOutput out = new BytesStreamOutput();
+        request.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        UpdateQueryGroupRequest otherRequest = new UpdateQueryGroupRequest(streamInput);
+        assertEquals(request.getName(), otherRequest.getName());
+        assertEquals(request.getmMutableQueryGroupFragment(), otherRequest.getmMutableQueryGroupFragment());
+    }
+
+    /**
+     * Tests invalid ResourceType.
+     */
+    public void testInvalidResourceLimitList() {
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> new UpdateQueryGroupRequest(
+                NAME_ONE,
+                new MutableQueryGroupFragment(
+                    ResiliencyMode.MONITOR,
+                    Map.of(ResourceType.MEMORY, 0.3, ResourceType.fromName("random"), 0.4)
+                )
+            )
+        );
+    }
+
+    /**
+     * Tests invalid resiliencyMode.
+     */
+    public void testInvalidEnforcement() {
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> new UpdateQueryGroupRequest(
+                NAME_ONE,
+                new MutableQueryGroupFragment(ResiliencyMode.fromName("random"), Map.of(ResourceType.fromName("memory"), 0.3))
+            )
+        );
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupResponseTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupResponseTests.java
new file mode 100644
index 0000000000000..a7ab4c6a682ef
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/action/UpdateQueryGroupResponseTests.java
@@ -0,0 +1,67 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.action;
+
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.plugin.wlm.QueryGroupTestUtils;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.queryGroupOne;
+import static org.mockito.Mockito.mock;
+
+public class UpdateQueryGroupResponseTests extends OpenSearchTestCase {
+
+    /**
+     * Test case to verify the serialization and deserialization of UpdateQueryGroupResponse.
+     */
+    public void testSerialization() throws IOException {
+        UpdateQueryGroupResponse response = new UpdateQueryGroupResponse(queryGroupOne, RestStatus.OK);
+        BytesStreamOutput out = new BytesStreamOutput();
+        response.writeTo(out);
+        StreamInput streamInput = out.bytes().streamInput();
+        UpdateQueryGroupResponse otherResponse = new UpdateQueryGroupResponse(streamInput);
+        assertEquals(response.getRestStatus(), otherResponse.getRestStatus());
+        QueryGroup responseGroup = response.getQueryGroup();
+        QueryGroup otherResponseGroup = otherResponse.getQueryGroup();
+        List<QueryGroup> list1 = new ArrayList<>();
+        List<QueryGroup> list2 = new ArrayList<>();
+        list1.add(responseGroup);
+        list2.add(otherResponseGroup);
+        QueryGroupTestUtils.assertEqualQueryGroups(list1, list2, false);
+    }
+
+    /**
+     * Test case to verify the toXContent method of UpdateQueryGroupResponse.
+     */
+    public void testToXContentUpdateSingleQueryGroup() throws IOException {
+        XContentBuilder builder = JsonXContent.contentBuilder().prettyPrint();
+        UpdateQueryGroupResponse otherResponse = new UpdateQueryGroupResponse(queryGroupOne, RestStatus.OK);
+        String actual = otherResponse.toXContent(builder, mock(ToXContent.Params.class)).toString();
+        String expected = "{\n"
+            + "  \"_id\" : \"AgfUO5Ja9yfsYlONlYi3TQ==\",\n"
+            + "  \"name\" : \"query_group_one\",\n"
+            + "  \"resiliency_mode\" : \"monitor\",\n"
+            + "  \"resource_limits\" : {\n"
+            + "    \"memory\" : 0.3\n"
+            + "  },\n"
+            + "  \"updated_at\" : 4513232413\n"
+            + "}";
+        assertEquals(expected, actual);
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/rest/RestDeleteQueryGroupActionTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/rest/RestDeleteQueryGroupActionTests.java
new file mode 100644
index 0000000000000..72191e076bb87
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/rest/RestDeleteQueryGroupActionTests.java
@@ -0,0 +1,85 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.rest;
+
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.CheckedConsumer;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.plugin.wlm.action.DeleteQueryGroupAction;
+import org.opensearch.plugin.wlm.action.DeleteQueryGroupRequest;
+import org.opensearch.rest.RestChannel;
+import org.opensearch.rest.RestHandler;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.action.RestToXContentListener;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.rest.FakeRestRequest;
+
+import java.util.List;
+
+import org.mockito.ArgumentCaptor;
+
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.NAME_ONE;
+import static org.opensearch.rest.RestRequest.Method.DELETE;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+public class RestDeleteQueryGroupActionTests extends OpenSearchTestCase {
+    /**
+     * Test case to validate the construction for RestDeleteQueryGroupAction
+     */
+    public void testConstruction() {
+        RestDeleteQueryGroupAction action = new RestDeleteQueryGroupAction();
+        assertNotNull(action);
+        assertEquals("delete_query_group", action.getName());
+        List<RestHandler.Route> routes = action.routes();
+        assertEquals(1, routes.size());
+        RestHandler.Route route = routes.get(0);
+        assertEquals(DELETE, route.getMethod());
+        assertEquals("_wlm/query_group/{name}", route.getPath());
+    }
+
+    /**
+     * Test case to validate the prepareRequest logic for RestDeleteQueryGroupAction
+     */
+    @SuppressWarnings("unchecked")
+    public void testPrepareRequest() throws Exception {
+        RestDeleteQueryGroupAction restDeleteQueryGroupAction = new RestDeleteQueryGroupAction();
+        NodeClient nodeClient = mock(NodeClient.class);
+        RestRequest realRequest = new FakeRestRequest();
+        realRequest.params().put("name", NAME_ONE);
+        ;
+        RestRequest spyRequest = spy(realRequest);
+
+        doReturn(TimeValue.timeValueSeconds(30)).when(spyRequest).paramAsTime(eq("cluster_manager_timeout"), any(TimeValue.class));
+        doReturn(TimeValue.timeValueSeconds(60)).when(spyRequest).paramAsTime(eq("timeout"), any(TimeValue.class));
+
+        CheckedConsumer<RestChannel, Exception> consumer = restDeleteQueryGroupAction.prepareRequest(spyRequest, nodeClient);
+        assertNotNull(consumer);
+        ArgumentCaptor<DeleteQueryGroupRequest> requestCaptor = ArgumentCaptor.forClass(DeleteQueryGroupRequest.class);
+        ArgumentCaptor<RestToXContentListener<AcknowledgedResponse>> listenerCaptor = ArgumentCaptor.forClass(RestToXContentListener.class);
+        doNothing().when(nodeClient).execute(eq(DeleteQueryGroupAction.INSTANCE), requestCaptor.capture(), listenerCaptor.capture());
+
+        consumer.accept(mock(RestChannel.class));
+        DeleteQueryGroupRequest capturedRequest = requestCaptor.getValue();
+        assertEquals(NAME_ONE, capturedRequest.getName());
+        assertEquals(TimeValue.timeValueSeconds(30), capturedRequest.clusterManagerNodeTimeout());
+        assertEquals(TimeValue.timeValueSeconds(60), capturedRequest.timeout());
+        verify(nodeClient).execute(
+            eq(DeleteQueryGroupAction.INSTANCE),
+            any(DeleteQueryGroupRequest.class),
+            any(RestToXContentListener.class)
+        );
+    }
+}
diff --git a/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/service/QueryGroupPersistenceServiceTests.java b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/service/QueryGroupPersistenceServiceTests.java
new file mode 100644
index 0000000000000..08b51fd46cfcf
--- /dev/null
+++ b/plugins/workload-management/src/test/java/org/opensearch/plugin/wlm/service/QueryGroupPersistenceServiceTests.java
@@ -0,0 +1,515 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugin.wlm.service;
+
+import org.opensearch.ResourceNotFoundException;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.cluster.AckedClusterStateUpdateTask;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ClusterStateUpdateTask;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.QueryGroup;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.plugin.wlm.QueryGroupTestUtils;
+import org.opensearch.plugin.wlm.action.CreateQueryGroupResponse;
+import org.opensearch.plugin.wlm.action.DeleteQueryGroupRequest;
+import org.opensearch.plugin.wlm.action.UpdateQueryGroupRequest;
+import org.opensearch.plugin.wlm.action.UpdateQueryGroupResponse;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.wlm.MutableQueryGroupFragment;
+import org.opensearch.wlm.MutableQueryGroupFragment.ResiliencyMode;
+import org.opensearch.wlm.ResourceType;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import org.mockito.ArgumentCaptor;
+
+import static org.opensearch.cluster.metadata.QueryGroup.builder;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.NAME_NONE_EXISTED;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.NAME_ONE;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.NAME_TWO;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils._ID_ONE;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils._ID_TWO;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.assertEqualQueryGroups;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.clusterSettings;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.clusterSettingsSet;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.clusterState;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.preparePersistenceServiceSetup;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.queryGroupList;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.queryGroupOne;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.queryGroupPersistenceService;
+import static org.opensearch.plugin.wlm.QueryGroupTestUtils.queryGroupTwo;
+import static org.opensearch.plugin.wlm.action.QueryGroupActionTestUtils.updateQueryGroupRequest;
+import static org.opensearch.plugin.wlm.service.QueryGroupPersistenceService.QUERY_GROUP_COUNT_SETTING_NAME;
+import static org.opensearch.plugin.wlm.service.QueryGroupPersistenceService.SOURCE;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.argThat;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+public class QueryGroupPersistenceServiceTests extends OpenSearchTestCase {
+
+    /**
+     * Test case to validate the creation logic of a QueryGroup
+     */
+    public void testCreateQueryGroup() {
+        Tuple<QueryGroupPersistenceService, ClusterState> setup = preparePersistenceServiceSetup(new HashMap<>());
+        QueryGroupPersistenceService queryGroupPersistenceService1 = setup.v1();
+        ClusterState clusterState = setup.v2();
+        ClusterState newClusterState = queryGroupPersistenceService1.saveQueryGroupInClusterState(queryGroupOne, clusterState);
+        Map<String, QueryGroup> updatedGroupsMap = newClusterState.getMetadata().queryGroups();
+        assertEquals(1, updatedGroupsMap.size());
+        assertTrue(updatedGroupsMap.containsKey(_ID_ONE));
+        List<QueryGroup> listOne = new ArrayList<>();
+        List<QueryGroup> listTwo = new ArrayList<>();
+        listOne.add(queryGroupOne);
+        listTwo.add(updatedGroupsMap.get(_ID_ONE));
+        assertEqualQueryGroups(listOne, listTwo, false);
+    }
+
+    /**
+     * Test case to validate the logic for adding a new QueryGroup to a cluster state that already contains
+     * an existing QueryGroup
+     */
+    public void testCreateAnotherQueryGroup() {
+        Tuple<QueryGroupPersistenceService, ClusterState> setup = preparePersistenceServiceSetup(Map.of(_ID_ONE, queryGroupOne));
+        QueryGroupPersistenceService queryGroupPersistenceService1 = setup.v1();
+        ClusterState clusterState = setup.v2();
+        ClusterState newClusterState = queryGroupPersistenceService1.saveQueryGroupInClusterState(queryGroupTwo, clusterState);
+        Map<String, QueryGroup> updatedGroups = newClusterState.getMetadata().queryGroups();
+        assertEquals(2, updatedGroups.size());
+        assertTrue(updatedGroups.containsKey(_ID_TWO));
+        Collection<QueryGroup> values = updatedGroups.values();
+        assertEqualQueryGroups(queryGroupList(), new ArrayList<>(values), false);
+    }
+
+    /**
+     * Test case to ensure the error is thrown when we try to create another QueryGroup with duplicate name
+     */
+    public void testCreateQueryGroupDuplicateName() {
+        Tuple<QueryGroupPersistenceService, ClusterState> setup = preparePersistenceServiceSetup(Map.of(_ID_ONE, queryGroupOne));
+        QueryGroupPersistenceService queryGroupPersistenceService1 = setup.v1();
+        ClusterState clusterState = setup.v2();
+        QueryGroup toCreate = builder().name(NAME_ONE)
+            ._id("W5iIqHyhgi4K1qIAAAAIHw==")
+            .mutableQueryGroupFragment(new MutableQueryGroupFragment(ResiliencyMode.MONITOR, Map.of(ResourceType.MEMORY, 0.3)))
+            .updatedAt(1690934400000L)
+            .build();
+        assertThrows(RuntimeException.class, () -> queryGroupPersistenceService1.saveQueryGroupInClusterState(toCreate, clusterState));
+    }
+
+    /**
+     * Test case to ensure the error is thrown when we try to create another QueryGroup that will make
+     * the total resource limits go above 1
+     */
+    public void testCreateQueryGroupOverflowAllocation() {
+        Tuple<QueryGroupPersistenceService, ClusterState> setup = preparePersistenceServiceSetup(Map.of(_ID_TWO, queryGroupTwo));
+        QueryGroup toCreate = builder().name(NAME_ONE)
+            ._id("W5iIqHyhgi4K1qIAAAAIHw==")
+            .mutableQueryGroupFragment(new MutableQueryGroupFragment(ResiliencyMode.MONITOR, Map.of(ResourceType.MEMORY, 0.41)))
+            .updatedAt(1690934400000L)
+            .build();
+
+        QueryGroupPersistenceService queryGroupPersistenceService1 = setup.v1();
+        ClusterState clusterState = setup.v2();
+        assertThrows(RuntimeException.class, () -> queryGroupPersistenceService1.saveQueryGroupInClusterState(toCreate, clusterState));
+    }
+
+    /**
+     * Test case to ensure the error is thrown when we already have the max allowed number of QueryGroups, but
+     * we want to create another one
+     */
+    public void testCreateQueryGroupOverflowCount() {
+        QueryGroup toCreate = builder().name(NAME_NONE_EXISTED)
+            ._id("W5iIqHyhgi4K1qIAAAAIHw==")
+            .mutableQueryGroupFragment(new MutableQueryGroupFragment(ResiliencyMode.MONITOR, Map.of(ResourceType.MEMORY, 0.5)))
+            .updatedAt(1690934400000L)
+            .build();
+        Metadata metadata = Metadata.builder().queryGroups(Map.of(_ID_ONE, queryGroupOne, _ID_TWO, queryGroupTwo)).build();
+        Settings settings = Settings.builder().put(QUERY_GROUP_COUNT_SETTING_NAME, 2).build();
+        ClusterSettings clusterSettings = new ClusterSettings(settings, clusterSettingsSet());
+        ClusterService clusterService = new ClusterService(settings, clusterSettings, mock(ThreadPool.class));
+        ClusterState clusterState = ClusterState.builder(new ClusterName("_name")).metadata(metadata).build();
+        QueryGroupPersistenceService queryGroupPersistenceService1 = new QueryGroupPersistenceService(
+            clusterService,
+            settings,
+            clusterSettings
+        );
+        assertThrows(RuntimeException.class, () -> queryGroupPersistenceService1.saveQueryGroupInClusterState(toCreate, clusterState));
+    }
+
+    /**
+     * Tests the invalid value of {@code node.query_group.max_count}
+     */
+    public void testInvalidMaxQueryGroupCount() {
+        Settings settings = Settings.builder().put(QUERY_GROUP_COUNT_SETTING_NAME, 2).build();
+        ClusterSettings clusterSettings = new ClusterSettings(settings, clusterSettingsSet());
+        ClusterService clusterService = new ClusterService(settings, clusterSettings, mock(ThreadPool.class));
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            settings,
+            clusterSettings
+        );
+        assertThrows(IllegalArgumentException.class, () -> queryGroupPersistenceService.setMaxQueryGroupCount(-1));
+    }
+
+    /**
+     * Tests the valid value of {@code node.query_group.max_count}
+     */
+    public void testValidMaxSandboxCountSetting() {
+        Settings settings = Settings.builder().put(QUERY_GROUP_COUNT_SETTING_NAME, 100).build();
+        ClusterService clusterService = new ClusterService(settings, clusterSettings(), mock(ThreadPool.class));
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            settings,
+            clusterSettings()
+        );
+        queryGroupPersistenceService.setMaxQueryGroupCount(50);
+        assertEquals(50, queryGroupPersistenceService.getMaxQueryGroupCount());
+    }
+
+    /**
+     * Tests PersistInClusterStateMetadata function
+     */
+    public void testPersistInClusterStateMetadata() {
+        ClusterService clusterService = mock(ClusterService.class);
+        @SuppressWarnings("unchecked")
+        ActionListener<CreateQueryGroupResponse> listener = mock(ActionListener.class);
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            QueryGroupTestUtils.settings(),
+            clusterSettings()
+        );
+        queryGroupPersistenceService.persistInClusterStateMetadata(queryGroupOne, listener);
+        verify(clusterService).submitStateUpdateTask(eq(SOURCE), any());
+    }
+
+    /**
+     * Tests PersistInClusterStateMetadata function with inner functions
+     */
+    public void testPersistInClusterStateMetadataInner() {
+        ClusterService clusterService = mock(ClusterService.class);
+        @SuppressWarnings("unchecked")
+        ActionListener<CreateQueryGroupResponse> listener = mock(ActionListener.class);
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            QueryGroupTestUtils.settings(),
+            clusterSettings()
+        );
+        ArgumentCaptor<ClusterStateUpdateTask> captor = ArgumentCaptor.forClass(ClusterStateUpdateTask.class);
+        queryGroupPersistenceService.persistInClusterStateMetadata(queryGroupOne, listener);
+        verify(clusterService, times(1)).submitStateUpdateTask(eq(SOURCE), captor.capture());
+        ClusterStateUpdateTask capturedTask = captor.getValue();
+        assertEquals(queryGroupPersistenceService.createQueryGroupThrottlingKey, capturedTask.getClusterManagerThrottlingKey());
+
+        doAnswer(invocation -> {
+            ClusterStateUpdateTask task = invocation.getArgument(1);
+            task.clusterStateProcessed(SOURCE, mock(ClusterState.class), mock(ClusterState.class));
+            return null;
+        }).when(clusterService).submitStateUpdateTask(anyString(), any());
+        queryGroupPersistenceService.persistInClusterStateMetadata(queryGroupOne, listener);
+        verify(listener).onResponse(any(CreateQueryGroupResponse.class));
+    }
+
+    /**
+     * Tests PersistInClusterStateMetadata function with failure
+     */
+    public void testPersistInClusterStateMetadataFailure() {
+        ClusterService clusterService = mock(ClusterService.class);
+        @SuppressWarnings("unchecked")
+        ActionListener<CreateQueryGroupResponse> listener = mock(ActionListener.class);
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            QueryGroupTestUtils.settings(),
+            clusterSettings()
+        );
+        doAnswer(invocation -> {
+            ClusterStateUpdateTask task = invocation.getArgument(1);
+            Exception exception = new RuntimeException("Test Exception");
+            task.onFailure(SOURCE, exception);
+            return null;
+        }).when(clusterService).submitStateUpdateTask(anyString(), any());
+        queryGroupPersistenceService.persistInClusterStateMetadata(queryGroupOne, listener);
+        verify(listener).onFailure(any(RuntimeException.class));
+    }
+
+    /**
+     * Tests getting a single QueryGroup
+     */
+    public void testGetSingleQueryGroup() {
+        Collection<QueryGroup> groupsCollections = QueryGroupPersistenceService.getFromClusterStateMetadata(NAME_ONE, clusterState());
+        List<QueryGroup> groups = new ArrayList<>(groupsCollections);
+        assertEquals(1, groups.size());
+        QueryGroup queryGroup = groups.get(0);
+        List<QueryGroup> listOne = new ArrayList<>();
+        List<QueryGroup> listTwo = new ArrayList<>();
+        listOne.add(QueryGroupTestUtils.queryGroupOne);
+        listTwo.add(queryGroup);
+        QueryGroupTestUtils.assertEqualQueryGroups(listOne, listTwo, false);
+    }
+
+    /**
+     * Tests getting all QueryGroups
+     */
+    public void testGetAllQueryGroups() {
+        assertEquals(2, QueryGroupTestUtils.clusterState().metadata().queryGroups().size());
+        Collection<QueryGroup> groupsCollections = QueryGroupPersistenceService.getFromClusterStateMetadata(null, clusterState());
+        List<QueryGroup> res = new ArrayList<>(groupsCollections);
+        assertEquals(2, res.size());
+        Set<String> currentNAME = res.stream().map(QueryGroup::getName).collect(Collectors.toSet());
+        assertTrue(currentNAME.contains(QueryGroupTestUtils.NAME_ONE));
+        assertTrue(currentNAME.contains(QueryGroupTestUtils.NAME_TWO));
+        QueryGroupTestUtils.assertEqualQueryGroups(QueryGroupTestUtils.queryGroupList(), res, false);
+    }
+
+    /**
+     * Tests getting a QueryGroup with invalid name
+     */
+    public void testGetNonExistedQueryGroups() {
+        Collection<QueryGroup> groupsCollections = QueryGroupPersistenceService.getFromClusterStateMetadata(
+            NAME_NONE_EXISTED,
+            clusterState()
+        );
+        List<QueryGroup> groups = new ArrayList<>(groupsCollections);
+        assertEquals(0, groups.size());
+    }
+
+    /**
+     * Tests setting maxQueryGroupCount
+     */
+    public void testMaxQueryGroupCount() {
+        assertThrows(IllegalArgumentException.class, () -> QueryGroupTestUtils.queryGroupPersistenceService().setMaxQueryGroupCount(-1));
+        QueryGroupPersistenceService queryGroupPersistenceService = QueryGroupTestUtils.queryGroupPersistenceService();
+        queryGroupPersistenceService.setMaxQueryGroupCount(50);
+        assertEquals(50, queryGroupPersistenceService.getMaxQueryGroupCount());
+    }
+
+    /**
+     * Tests delete a single QueryGroup
+     */
+    public void testDeleteSingleQueryGroup() {
+        ClusterState newClusterState = queryGroupPersistenceService().deleteQueryGroupInClusterState(NAME_TWO, clusterState());
+        Map<String, QueryGroup> afterDeletionGroups = newClusterState.getMetadata().queryGroups();
+        assertFalse(afterDeletionGroups.containsKey(_ID_TWO));
+        assertEquals(1, afterDeletionGroups.size());
+        List<QueryGroup> oldQueryGroups = new ArrayList<>();
+        oldQueryGroups.add(queryGroupOne);
+        assertEqualQueryGroups(new ArrayList<>(afterDeletionGroups.values()), oldQueryGroups, false);
+    }
+
+    /**
+     * Tests delete a QueryGroup with invalid name
+     */
+    public void testDeleteNonExistedQueryGroup() {
+        assertThrows(
+            ResourceNotFoundException.class,
+            () -> queryGroupPersistenceService().deleteQueryGroupInClusterState(NAME_NONE_EXISTED, clusterState())
+        );
+    }
+
+    /**
+     * Tests DeleteInClusterStateMetadata function
+     */
+    @SuppressWarnings("unchecked")
+    public void testDeleteInClusterStateMetadata() throws Exception {
+        DeleteQueryGroupRequest request = new DeleteQueryGroupRequest(NAME_ONE);
+        ClusterService clusterService = mock(ClusterService.class);
+
+        ActionListener<AcknowledgedResponse> listener = mock(ActionListener.class);
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            QueryGroupTestUtils.settings(),
+            clusterSettings()
+        );
+        doAnswer(invocation -> {
+            AckedClusterStateUpdateTask<?> task = invocation.getArgument(1);
+            ClusterState initialState = clusterState();
+            ClusterState newState = task.execute(initialState);
+            assertNotNull(newState);
+            assertEquals(queryGroupPersistenceService.deleteQueryGroupThrottlingKey, task.getClusterManagerThrottlingKey());
+            task.onAllNodesAcked(null);
+            verify(listener).onResponse(argThat(response -> response.isAcknowledged()));
+            return null;
+        }).when(clusterService).submitStateUpdateTask(anyString(), any());
+        queryGroupPersistenceService.deleteInClusterStateMetadata(request, listener);
+        verify(clusterService).submitStateUpdateTask(eq(SOURCE), any(AckedClusterStateUpdateTask.class));
+    }
+
+    /**
+     * Tests updating a QueryGroup with all fields
+     */
+    public void testUpdateQueryGroupAllFields() {
+        QueryGroup updated = builder().name(NAME_ONE)
+            ._id(_ID_ONE)
+            .mutableQueryGroupFragment(new MutableQueryGroupFragment(ResiliencyMode.ENFORCED, Map.of(ResourceType.MEMORY, 0.15)))
+            .updatedAt(1690934400000L)
+            .build();
+        UpdateQueryGroupRequest updateQueryGroupRequest = updateQueryGroupRequest(NAME_ONE, updated.getMutableQueryGroupFragment());
+        ClusterState newClusterState = queryGroupPersistenceService().updateQueryGroupInClusterState(
+            updateQueryGroupRequest,
+            clusterState()
+        );
+        List<QueryGroup> updatedQueryGroups = new ArrayList<>(newClusterState.getMetadata().queryGroups().values());
+        assertEquals(2, updatedQueryGroups.size());
+        List<QueryGroup> expectedList = new ArrayList<>();
+        expectedList.add(queryGroupTwo);
+        expectedList.add(updated);
+        assertEqualQueryGroups(expectedList, updatedQueryGroups, true);
+    }
+
+    /**
+     * Tests updating a QueryGroup with only updated resourceLimits
+     */
+    public void testUpdateQueryGroupResourceLimitsOnly() {
+        QueryGroup updated = builder().name(NAME_ONE)
+            ._id(_ID_ONE)
+            .mutableQueryGroupFragment(new MutableQueryGroupFragment(ResiliencyMode.MONITOR, Map.of(ResourceType.MEMORY, 0.15)))
+            .updatedAt(1690934400000L)
+            .build();
+        UpdateQueryGroupRequest updateQueryGroupRequest = updateQueryGroupRequest(NAME_ONE, updated.getMutableQueryGroupFragment());
+        ClusterState newClusterState = queryGroupPersistenceService().updateQueryGroupInClusterState(
+            updateQueryGroupRequest,
+            clusterState()
+        );
+        List<QueryGroup> updatedQueryGroups = new ArrayList<>(newClusterState.getMetadata().queryGroups().values());
+        assertEquals(2, updatedQueryGroups.size());
+        Optional<QueryGroup> findUpdatedGroupOne = newClusterState.metadata()
+            .queryGroups()
+            .values()
+            .stream()
+            .filter(group -> group.getName().equals(NAME_ONE))
+            .findFirst();
+        Optional<QueryGroup> findUpdatedGroupTwo = newClusterState.metadata()
+            .queryGroups()
+            .values()
+            .stream()
+            .filter(group -> group.getName().equals(NAME_TWO))
+            .findFirst();
+        assertTrue(findUpdatedGroupOne.isPresent());
+        assertTrue(findUpdatedGroupTwo.isPresent());
+        List<QueryGroup> list1 = new ArrayList<>();
+        list1.add(updated);
+        List<QueryGroup> list2 = new ArrayList<>();
+        list2.add(findUpdatedGroupOne.get());
+        assertEqualQueryGroups(list1, list2, true);
+    }
+
+    /**
+     * Tests updating a QueryGroup with invalid name
+     */
+    public void testUpdateQueryGroupNonExistedName() {
+        QueryGroupPersistenceService queryGroupPersistenceService = queryGroupPersistenceService();
+        UpdateQueryGroupRequest updateQueryGroupRequest = updateQueryGroupRequest(
+            NAME_NONE_EXISTED,
+            new MutableQueryGroupFragment(ResiliencyMode.MONITOR, Map.of(ResourceType.MEMORY, 0.15))
+        );
+        assertThrows(
+            RuntimeException.class,
+            () -> queryGroupPersistenceService.updateQueryGroupInClusterState(updateQueryGroupRequest, clusterState())
+        );
+        List<QueryGroup> updatedQueryGroups = new ArrayList<>(
+            queryGroupPersistenceService.getClusterService().state().metadata().queryGroups().values()
+        );
+        assertEquals(2, updatedQueryGroups.size());
+        List<QueryGroup> expectedList = new ArrayList<>();
+        expectedList.add(queryGroupTwo);
+        expectedList.add(queryGroupOne);
+        assertEqualQueryGroups(expectedList, updatedQueryGroups, true);
+    }
+
+    /**
+     * Tests UpdateInClusterStateMetadata function
+     */
+    public void testUpdateInClusterStateMetadata() {
+        ClusterService clusterService = mock(ClusterService.class);
+        @SuppressWarnings("unchecked")
+        ActionListener<UpdateQueryGroupResponse> listener = mock(ActionListener.class);
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            QueryGroupTestUtils.settings(),
+            clusterSettings()
+        );
+        queryGroupPersistenceService.updateInClusterStateMetadata(null, listener);
+        verify(clusterService).submitStateUpdateTask(eq(SOURCE), any());
+    }
+
+    /**
+     * Tests UpdateInClusterStateMetadata function with inner functions
+     */
+    public void testUpdateInClusterStateMetadataInner() {
+        ClusterService clusterService = mock(ClusterService.class);
+        @SuppressWarnings("unchecked")
+        ActionListener<UpdateQueryGroupResponse> listener = mock(ActionListener.class);
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            QueryGroupTestUtils.settings(),
+            clusterSettings()
+        );
+        UpdateQueryGroupRequest updateQueryGroupRequest = updateQueryGroupRequest(
+            NAME_TWO,
+            new MutableQueryGroupFragment(ResiliencyMode.SOFT, new HashMap<>())
+        );
+        ArgumentCaptor<ClusterStateUpdateTask> captor = ArgumentCaptor.forClass(ClusterStateUpdateTask.class);
+        queryGroupPersistenceService.updateInClusterStateMetadata(updateQueryGroupRequest, listener);
+        verify(clusterService, times(1)).submitStateUpdateTask(eq(SOURCE), captor.capture());
+        ClusterStateUpdateTask capturedTask = captor.getValue();
+        assertEquals(queryGroupPersistenceService.updateQueryGroupThrottlingKey, capturedTask.getClusterManagerThrottlingKey());
+
+        doAnswer(invocation -> {
+            ClusterStateUpdateTask task = invocation.getArgument(1);
+            task.clusterStateProcessed(SOURCE, clusterState(), clusterState());
+            return null;
+        }).when(clusterService).submitStateUpdateTask(anyString(), any());
+        queryGroupPersistenceService.updateInClusterStateMetadata(updateQueryGroupRequest, listener);
+        verify(listener).onResponse(any(UpdateQueryGroupResponse.class));
+    }
+
+    /**
+     * Tests UpdateInClusterStateMetadata function with failure
+     */
+    public void testUpdateInClusterStateMetadataFailure() {
+        ClusterService clusterService = mock(ClusterService.class);
+        @SuppressWarnings("unchecked")
+        ActionListener<UpdateQueryGroupResponse> listener = mock(ActionListener.class);
+        QueryGroupPersistenceService queryGroupPersistenceService = new QueryGroupPersistenceService(
+            clusterService,
+            QueryGroupTestUtils.settings(),
+            clusterSettings()
+        );
+        UpdateQueryGroupRequest updateQueryGroupRequest = updateQueryGroupRequest(
+            NAME_TWO,
+            new MutableQueryGroupFragment(ResiliencyMode.SOFT, new HashMap<>())
+        );
+        doAnswer(invocation -> {
+            ClusterStateUpdateTask task = invocation.getArgument(1);
+            Exception exception = new RuntimeException("Test Exception");
+            task.onFailure(SOURCE, exception);
+            return null;
+        }).when(clusterService).submitStateUpdateTask(anyString(), any());
+        queryGroupPersistenceService.updateInClusterStateMetadata(updateQueryGroupRequest, listener);
+        verify(listener).onFailure(any(RuntimeException.class));
+    }
+}
diff --git a/plugins/workload-management/src/yamlRestTest/java/org/opensearch/plugin/wlm/WorkloadManagementClientYamlTestSuiteIT.java b/plugins/workload-management/src/yamlRestTest/java/org/opensearch/plugin/wlm/WorkloadManagementClientYamlTestSuiteIT.java
new file mode 100644
index 0000000000000..9ec4a36ff6a5b
--- /dev/null
+++ b/plugins/workload-management/src/yamlRestTest/java/org/opensearch/plugin/wlm/WorkloadManagementClientYamlTestSuiteIT.java
@@ -0,0 +1,52 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.plugin.wlm;
+
+import com.carrotsearch.randomizedtesting.annotations.Name;
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
+
+import org.opensearch.test.rest.yaml.ClientYamlTestCandidate;
+import org.opensearch.test.rest.yaml.OpenSearchClientYamlSuiteTestCase;
+
+/** Runs yaml rest tests */
+public class WorkloadManagementClientYamlTestSuiteIT extends OpenSearchClientYamlSuiteTestCase {
+
+    public WorkloadManagementClientYamlTestSuiteIT(@Name("yaml") ClientYamlTestCandidate testCandidate) {
+        super(testCandidate);
+    }
+
+    @ParametersFactory
+    public static Iterable<Object[]> parameters() throws Exception {
+        return OpenSearchClientYamlSuiteTestCase.createParameters();
+    }
+}
diff --git a/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/create_query_group_context.json b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/create_query_group_context.json
new file mode 100644
index 0000000000000..bb4620c01f2d6
--- /dev/null
+++ b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/create_query_group_context.json
@@ -0,0 +1,18 @@
+{
+  "create_query_group_context": {
+    "stability": "experimental",
+    "url": {
+      "paths": [
+        {
+          "path": "/_wlm/query_group",
+          "methods": ["PUT", "POST"],
+          "parts": {}
+        }
+      ]
+    },
+    "params":{},
+    "body":{
+      "description":"The QueryGroup schema"
+    }
+  }
+}
diff --git a/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/delete_query_group_context.json b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/delete_query_group_context.json
new file mode 100644
index 0000000000000..16930427fc2fe
--- /dev/null
+++ b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/delete_query_group_context.json
@@ -0,0 +1,22 @@
+{
+  "delete_query_group_context": {
+    "stability": "experimental",
+    "url": {
+      "paths": [
+        {
+          "path": "/_wlm/query_group/{name}",
+          "methods": [
+            "DELETE"
+          ],
+          "parts": {
+            "name": {
+              "type": "string",
+              "description": "QueryGroup name"
+            }
+          }
+        }
+      ]
+    },
+    "params":{}
+  }
+}
diff --git a/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/get_query_group_context.json b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/get_query_group_context.json
new file mode 100644
index 0000000000000..e0d552be616b2
--- /dev/null
+++ b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/get_query_group_context.json
@@ -0,0 +1,25 @@
+{
+  "get_query_group_context": {
+    "stability": "experimental",
+    "url": {
+      "paths": [
+        {
+          "path": "/_wlm/query_group",
+          "methods": ["GET"],
+          "parts": {}
+        },
+        {
+          "path": "/_wlm/query_group/{name}",
+          "methods": ["GET"],
+          "parts": {
+            "name": {
+              "type": "string",
+              "description": "QueryGroup name"
+            }
+          }
+        }
+      ]
+    },
+    "params":{}
+  }
+}
diff --git a/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/update_query_group_context.json b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/update_query_group_context.json
new file mode 100644
index 0000000000000..fbfa2dde292ee
--- /dev/null
+++ b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/api/update_query_group_context.json
@@ -0,0 +1,23 @@
+{
+  "update_query_group_context": {
+    "stability": "experimental",
+    "url": {
+      "paths": [
+        {
+          "path": "/_wlm/query_group/{name}",
+          "methods": ["PUT", "POST"],
+          "parts": {
+            "name": {
+              "type": "string",
+              "description": "QueryGroup name"
+            }
+          }
+        }
+      ]
+    },
+    "params":{},
+    "body":{
+      "description":"The updated QueryGroup schema"
+    }
+  }
+}
diff --git a/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/test/wlm/10_query_group.yml b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/test/wlm/10_query_group.yml
new file mode 100644
index 0000000000000..40ec665351094
--- /dev/null
+++ b/plugins/workload-management/src/yamlRestTest/resources/rest-api-spec/test/wlm/10_query_group.yml
@@ -0,0 +1,156 @@
+"test CRUD Operations for QueryGroup API ":
+  - skip:
+      version: " - 2.16.99"
+      reason: "QueryGroup WorkloadManagement feature was added in 2.17"
+
+  - do:
+      create_query_group_context:
+        body:
+          {
+            "name": "analytics",
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": 0.4,
+              "memory": 0.2
+            }
+          }
+
+  - match: { name: "analytics" }
+  - match: { resiliency_mode: "monitor" }
+  - match: { resource_limits.cpu: 0.4 }
+  - match: { resource_limits.memory: 0.2 }
+
+  - do:
+      get_query_group_context:
+        name: "analytics"
+
+  - match: { query_groups.0.name: "analytics" }
+  - match: { query_groups.0.resiliency_mode: "monitor" }
+  - match: { query_groups.0.resource_limits.cpu: 0.4 }
+  - match: { query_groups.0.resource_limits.memory: 0.2 }
+
+  - do:
+      update_query_group_context:
+        name: "analytics"
+        body:
+          {
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": 0.42,
+              "memory": 0.22
+            }
+          }
+
+  - match: { name: "analytics" }
+  - match: { resiliency_mode: "monitor" }
+  - match: { resource_limits.cpu: 0.42 }
+  - match: { resource_limits.memory: 0.22 }
+
+  - do:
+      catch: /resource_not_found_exception/
+      update_query_group_context:
+        name: "analytics5"
+        body:
+          {
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": 0.42,
+              "memory": 0.22
+            }
+          }
+
+  - do:
+      catch: /illegal_argument_exception/
+      update_query_group_context:
+        name: "analytics"
+        body:
+          {
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": 1.1
+            }
+          }
+
+  - do:
+      catch: /illegal_argument_exception/
+      create_query_group_context:
+        body:
+          {
+            "name": "analytics",
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": 0.4,
+              "memory": 0.2
+            }
+          }
+
+  - do:
+      catch: /illegal_argument_exception/
+      create_query_group_context:
+        body:
+          {
+            "name": "analytics2",
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": 0.61,
+              "memory": 0.2
+            }
+          }
+
+  - do:
+      catch: /illegal_argument_exception/
+      create_query_group_context:
+        body:
+          {
+            "name": "analytics2",
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": -0.1,
+              "memory": 0.2
+            }
+          }
+
+  - do:
+      catch: /illegal_argument_exception/
+      create_query_group_context:
+        body:
+          {
+            "name": "",
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": 0.1,
+              "memory": 0.2
+            }
+          }
+
+  - do:
+      create_query_group_context:
+        body:
+          {
+            "name": "analytics2",
+            "resiliency_mode": "monitor",
+            "resource_limits": {
+              "cpu": 0.35,
+              "memory": 0.25
+            }
+          }
+
+  - match: { name: "analytics2" }
+  - match: { resiliency_mode: "monitor" }
+  - match: { resource_limits.cpu: 0.35 }
+  - match: { resource_limits.memory: 0.25 }
+
+  - do:
+      get_query_group_context:
+        name: "analytics2"
+
+  - match: { query_groups.0.name: "analytics2" }
+  - match: { query_groups.0.resiliency_mode: "monitor" }
+  - match: { query_groups.0.resource_limits.cpu: 0.35 }
+  - match: { query_groups.0.resource_limits.memory: 0.25 }
+
+  - do:
+      delete_query_group_context:
+        name: "analytics2"
+
+  - match: { acknowledged: true }
diff --git a/qa/os/src/test/java/org/opensearch/packaging/util/FileUtils.java b/qa/os/src/test/java/org/opensearch/packaging/util/FileUtils.java
index 5169ce18fff79..dd5248738569e 100644
--- a/qa/os/src/test/java/org/opensearch/packaging/util/FileUtils.java
+++ b/qa/os/src/test/java/org/opensearch/packaging/util/FileUtils.java
@@ -380,7 +380,7 @@ public static String escapePath(Path path) {
     }
 
     /**
-     * Recursively copy the the source directory to the target directory, preserving permissions.
+     * Recursively copy the source directory to the target directory, preserving permissions.
      */
     public static void copyDirectory(Path source, Path target) throws IOException {
         Files.walkFileTree(source, new SimpleFileVisitor<Path>() {
diff --git a/qa/repository-multi-version/src/test/java/org/opensearch/upgrades/MultiVersionRepositoryAccessIT.java b/qa/repository-multi-version/src/test/java/org/opensearch/upgrades/MultiVersionRepositoryAccessIT.java
index 7a32b92d8aa75..e20e113d00e5a 100644
--- a/qa/repository-multi-version/src/test/java/org/opensearch/upgrades/MultiVersionRepositoryAccessIT.java
+++ b/qa/repository-multi-version/src/test/java/org/opensearch/upgrades/MultiVersionRepositoryAccessIT.java
@@ -33,6 +33,7 @@
 package org.opensearch.upgrades;
 
 import org.opensearch.OpenSearchStatusException;
+import com.sun.jna.StringArray;
 import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequest;
 import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotStatus;
@@ -46,6 +47,7 @@
 import org.opensearch.client.RestClient;
 import org.opensearch.client.RestHighLevelClient;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.Strings;
 import org.opensearch.core.xcontent.DeprecationHandler;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.common.xcontent.json.JsonXContent;
@@ -145,14 +147,14 @@ public void testCreateAndRestoreSnapshot() throws IOException {
                 case STEP2_NEW_CLUSTER:
                 case STEP4_NEW_CLUSTER:
                     assertSnapshotStatusSuccessful(client, repoName,
-                        snapshots.stream().map(sn -> (String) sn.get("snapshot")).toArray(String[]::new));
+                        snapshots.stream().map(sn -> (String) sn.get("snapshot")).toArray(String[]::new), Strings.EMPTY_ARRAY);
                     break;
                 case STEP1_OLD_CLUSTER:
-                    assertSnapshotStatusSuccessful(client, repoName, "snapshot-" + TEST_STEP);
+                    assertSnapshotStatusSuccessful(client, repoName,  new String[] {"snapshot-" + TEST_STEP}, Strings.EMPTY_ARRAY);
                     break;
                 case STEP3_OLD_CLUSTER:
                     assertSnapshotStatusSuccessful(
-                        client, repoName, "snapshot-" + TEST_STEP, "snapshot-" + TestStep.STEP3_OLD_CLUSTER);
+                        client, repoName, new String[] {"snapshot-" + TEST_STEP, "snapshot-" + TestStep.STEP3_OLD_CLUSTER}, Strings.EMPTY_ARRAY);
                     break;
             }
             if (TEST_STEP == TestStep.STEP3_OLD_CLUSTER) {
@@ -190,10 +192,10 @@ public void testReadOnlyRepo() throws IOException {
                     break;
             }
             if (TEST_STEP == TestStep.STEP1_OLD_CLUSTER || TEST_STEP == TestStep.STEP3_OLD_CLUSTER) {
-                assertSnapshotStatusSuccessful(client, repoName, "snapshot-" + TestStep.STEP1_OLD_CLUSTER);
+                assertSnapshotStatusSuccessful(client, repoName, new String[] {"snapshot-" + TestStep.STEP1_OLD_CLUSTER}, Strings.EMPTY_ARRAY);
             } else {
                 assertSnapshotStatusSuccessful(client, repoName,
-                    "snapshot-" + TestStep.STEP1_OLD_CLUSTER, "snapshot-" + TestStep.STEP2_NEW_CLUSTER);
+                    new String[] {"snapshot-" + TestStep.STEP1_OLD_CLUSTER, "snapshot-" + TestStep.STEP2_NEW_CLUSTER}, Strings.EMPTY_ARRAY);
             }
             if (TEST_STEP == TestStep.STEP3_OLD_CLUSTER) {
                 ensureSnapshotRestoreWorks(repoName, "snapshot-" + TestStep.STEP1_OLD_CLUSTER, shards);
@@ -218,7 +220,7 @@ public void testUpgradeMovesRepoToNewMetaVersion() throws IOException {
                 // Every step creates one snapshot
                 assertThat(snapshots, hasSize(TEST_STEP.ordinal() + 1));
                 assertSnapshotStatusSuccessful(client, repoName,
-                    snapshots.stream().map(sn -> (String) sn.get("snapshot")).toArray(String[]::new));
+                    snapshots.stream().map(sn -> (String) sn.get("snapshot")).toArray(String[]::new), Strings.EMPTY_ARRAY);
                 if (TEST_STEP == TestStep.STEP1_OLD_CLUSTER) {
                     ensureSnapshotRestoreWorks(repoName, "snapshot-" + TestStep.STEP1_OLD_CLUSTER, shards);
                 } else {
@@ -253,9 +255,9 @@ public void testUpgradeMovesRepoToNewMetaVersion() throws IOException {
     }
 
     private static void assertSnapshotStatusSuccessful(RestHighLevelClient client, String repoName,
-                                                       String... snapshots) throws IOException {
+                                                       String[] snapshots, String[] indices) throws IOException {
         final SnapshotsStatusResponse statusResponse = client.snapshot()
-            .status(new SnapshotsStatusRequest(repoName, snapshots), RequestOptions.DEFAULT);
+            .status((new SnapshotsStatusRequest(repoName, snapshots)).indices(indices), RequestOptions.DEFAULT);
         for (SnapshotStatus status : statusResponse.getSnapshots()) {
             assertThat(status.getShardsStats().getFailedShards(), is(0));
         }
diff --git a/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/ClusterStateIT.java b/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/ClusterStateIT.java
new file mode 100644
index 0000000000000..2d606d27a34e0
--- /dev/null
+++ b/qa/rolling-upgrade/src/test/java/org/opensearch/upgrades/ClusterStateIT.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.upgrades;
+
+import org.opensearch.client.Request;
+import org.opensearch.client.Response;
+
+import java.util.Map;
+
+public class ClusterStateIT extends AbstractRollingTestCase{
+    public void testTemplateMetadataUpgrades() throws Exception {
+        if (CLUSTER_TYPE == ClusterType.OLD) {
+            String templateName = "my_template";
+            Request putIndexTemplate = new Request("PUT", "_template/" + templateName);
+            putIndexTemplate.setJsonEntity("{\"index_patterns\": [\"pattern-1\", \"log-*\"]}");
+            client().performRequest(putIndexTemplate);
+            verifyTemplateMetadataInClusterState();
+        } else {
+            verifyTemplateMetadataInClusterState();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void verifyTemplateMetadataInClusterState() throws Exception {
+        Request request = new Request("GET", "_cluster/state/metadata");
+        Response response = client().performRequest(request);
+        assertOK(response);
+        Map<String, Object> metadata = (Map<String, Object>) entityAsMap(response).get("metadata");
+        assertNotNull(metadata.get("templates"));
+    }
+}
diff --git a/qa/smoke-test-http/build.gradle b/qa/smoke-test-http/build.gradle
index f48ddc26d929b..496fda6bb717d 100644
--- a/qa/smoke-test-http/build.gradle
+++ b/qa/smoke-test-http/build.gradle
@@ -35,6 +35,7 @@ apply plugin: 'opensearch.test-with-dependencies'
 
 dependencies {
   testImplementation project(path: ':modules:transport-netty4') // for http
+  testImplementation project(path: ':plugins:transport-reactor-netty4') // for http
   testImplementation project(path: ':plugins:transport-nio')
   testImplementation project(path: ':plugins:identity-shiro') // for http
 }
diff --git a/qa/smoke-test-http/src/test/java/org/opensearch/http/DanglingIndicesRestIT.java b/qa/smoke-test-http/src/test/java/org/opensearch/http/DanglingIndicesRestIT.java
index 42c7fd667fd8f..741660f972bfb 100644
--- a/qa/smoke-test-http/src/test/java/org/opensearch/http/DanglingIndicesRestIT.java
+++ b/qa/smoke-test-http/src/test/java/org/opensearch/http/DanglingIndicesRestIT.java
@@ -152,8 +152,8 @@ public void testDanglingIndicesCanBeImported() throws Exception {
      * 1, then create two indices and delete them both while one node in
      * the cluster is stopped. The deletion of the second pushes the deletion
      * of the first out of the graveyard. When the stopped node is resumed,
-     * only the second index will be found into the graveyard and the the
-     * other will be considered dangling, and can therefore be listed and
+     * only the second index will be found into the graveyard and the other
+     * will be considered dangling, and can therefore be listed and
      * deleted through the API
      */
     public void testDanglingIndicesCanBeDeleted() throws Exception {
diff --git a/qa/smoke-test-http/src/test/java/org/opensearch/http/HttpSmokeTestCase.java b/qa/smoke-test-http/src/test/java/org/opensearch/http/HttpSmokeTestCase.java
index 951c2df53ba59..cff664a8882fd 100644
--- a/qa/smoke-test-http/src/test/java/org/opensearch/http/HttpSmokeTestCase.java
+++ b/qa/smoke-test-http/src/test/java/org/opensearch/http/HttpSmokeTestCase.java
@@ -38,6 +38,7 @@
 import org.opensearch.transport.Netty4Plugin;
 import org.opensearch.transport.nio.MockNioTransportPlugin;
 import org.opensearch.transport.nio.NioTransportPlugin;
+import org.opensearch.transport.reactor.ReactorNetty4Plugin;
 import org.junit.BeforeClass;
 
 import java.util.Arrays;
@@ -53,7 +54,7 @@ public abstract class HttpSmokeTestCase extends OpenSearchIntegTestCase {
     @BeforeClass
     public static void setUpTransport() {
         nodeTransportTypeKey = getTypeKey(randomFrom(getTestTransportPlugin(), Netty4Plugin.class, NioTransportPlugin.class));
-        nodeHttpTypeKey = getHttpTypeKey(randomFrom(Netty4Plugin.class, NioTransportPlugin.class));
+        nodeHttpTypeKey = getHttpTypeKey(randomFrom(Netty4Plugin.class, NioTransportPlugin.class, ReactorNetty4Plugin.class));
         clientTypeKey = getTypeKey(randomFrom(getTestTransportPlugin(), Netty4Plugin.class, NioTransportPlugin.class));
     }
 
@@ -71,6 +72,8 @@ private static String getTypeKey(Class<? extends Plugin> clazz) {
     private static String getHttpTypeKey(Class<? extends Plugin> clazz) {
         if (clazz.equals(NioTransportPlugin.class)) {
             return NioTransportPlugin.NIO_HTTP_TRANSPORT_NAME;
+        } else if (clazz.equals(ReactorNetty4Plugin.class)) {
+            return ReactorNetty4Plugin.REACTOR_NETTY_HTTP_TRANSPORT_NAME;
         } else {
             assert clazz.equals(Netty4Plugin.class);
             return Netty4Plugin.NETTY_HTTP_TRANSPORT_NAME;
@@ -92,7 +95,7 @@ protected Settings nodeSettings(int nodeOrdinal) {
 
     @Override
     protected Collection<Class<? extends Plugin>> nodePlugins() {
-        return Arrays.asList(getTestTransportPlugin(), Netty4Plugin.class, NioTransportPlugin.class);
+        return Arrays.asList(getTestTransportPlugin(), Netty4Plugin.class, NioTransportPlugin.class, ReactorNetty4Plugin.class);
     }
 
     @Override
diff --git a/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.java b/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.java
index 2772f902e7ea1..eb91ea3055483 100644
--- a/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.java
+++ b/qa/smoke-test-http/src/test/java/org/opensearch/http/IdentityAuthenticationIT.java
@@ -26,6 +26,8 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.transport.Netty4Plugin;
 import org.opensearch.transport.nio.NioTransportPlugin;
+import org.opensearch.transport.reactor.ReactorNetty4Plugin;
+
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.core.StringContains.containsString;
 
@@ -42,7 +44,7 @@ protected Settings nodeSettings(int nodeOrdinal) {
 
     @Override
     protected Collection<Class<? extends Plugin>> nodePlugins() {
-        return Arrays.asList(OpenSearchTestCase.getTestTransportPlugin(), Netty4Plugin.class, NioTransportPlugin.class, ShiroIdentityPlugin.class);
+        return Arrays.asList(OpenSearchTestCase.getTestTransportPlugin(), Netty4Plugin.class, NioTransportPlugin.class, ReactorNetty4Plugin.class, ShiroIdentityPlugin.class);
     }
 
 
diff --git a/qa/wildfly/src/main/webapp/WEB-INF/jboss-deployment-structure.xml b/qa/wildfly/src/main/webapp/WEB-INF/jboss-deployment-structure.xml
index a08090100989a..4fabd038cf915 100644
--- a/qa/wildfly/src/main/webapp/WEB-INF/jboss-deployment-structure.xml
+++ b/qa/wildfly/src/main/webapp/WEB-INF/jboss-deployment-structure.xml
@@ -3,5 +3,8 @@
         <exclusions>
             <module name="org.jboss.resteasy.resteasy-jackson2-provider" />
         </exclusions>
+        <dependencies>
+            <module name="org.reactivestreams"/>
+        </dependencies>
     </deployment>
 </jboss-deployment-structure>
diff --git a/release-notes/opensearch.release-notes-1.3.17.md b/release-notes/opensearch.release-notes-1.3.17.md
new file mode 100644
index 0000000000000..5218b9e3be20c
--- /dev/null
+++ b/release-notes/opensearch.release-notes-1.3.17.md
@@ -0,0 +1,6 @@
+## 2024-05-30 Version 1.3.17 Release Notes
+
+### Upgrades
+- OpenJDK Update (April 2024 Patch releases), update to Eclipse Temurin 11.0.23+9 ([#13406](https://github.com/opensearch-project/OpenSearch/pull/13406))
+- Upgrade BouncyCastle dependencies from 1.75 to 1.78.1 resolving [CVE-2024-30172], [CVE-2024-30171] and [CVE-2024-29857]
+- Bump `netty` from 4.1.109.Final to 4.1.110.Final ([#13802](https://github.com/opensearch-project/OpenSearch/pull/13802))
diff --git a/release-notes/opensearch.release-notes-1.3.18.md b/release-notes/opensearch.release-notes-1.3.18.md
new file mode 100644
index 0000000000000..75c38dd285a63
--- /dev/null
+++ b/release-notes/opensearch.release-notes-1.3.18.md
@@ -0,0 +1,4 @@
+## 2024-07-09 Version 1.3.18 Release Notes
+
+### Upgrades
+- Bump `netty` from 4.1.110.Final to 4.1.111.Final ([#14356](https://github.com/opensearch-project/OpenSearch/pull/14356))
diff --git a/release-notes/opensearch.release-notes-2.14.0.md b/release-notes/opensearch.release-notes-2.14.0.md
index 8ef0215baa67a..c5fc3e895c45d 100644
--- a/release-notes/opensearch.release-notes-2.14.0.md
+++ b/release-notes/opensearch.release-notes-2.14.0.md
@@ -84,4 +84,5 @@
 - Improve the error messages for _stats with closed indices ([#13012](https://github.com/opensearch-project/OpenSearch/pull/13012))
 - Ignore BaseRestHandler unconsumed content check as it's always consumed. ([#13290](https://github.com/opensearch-project/OpenSearch/pull/13290))
 - Fix mapper_parsing_exception when using flat_object fields with names longer than 11 characters ([#13259](https://github.com/opensearch-project/OpenSearch/pull/13259))
-- DATETIME_FORMATTER_CACHING_SETTING experimental feature should not default to 'true' ([#13532](https://github.com/opensearch-project/OpenSearch/pull/13532))
\ No newline at end of file
+- DATETIME_FORMATTER_CACHING_SETTING experimental feature should not default to 'true' ([#13532](https://github.com/opensearch-project/OpenSearch/pull/13532))
+- Fix negative RequestStats metric issue ([#13553](https://github.com/opensearch-project/OpenSearch/pull/13553))
diff --git a/release-notes/opensearch.release-notes-2.15.0.md b/release-notes/opensearch.release-notes-2.15.0.md
new file mode 100644
index 0000000000000..e3b7cfc0558f3
--- /dev/null
+++ b/release-notes/opensearch.release-notes-2.15.0.md
@@ -0,0 +1,75 @@
+## 2024-06-12 Version 2.15.0 Release Notes
+
+## [2.15.0]
+### Added
+- Add leader and follower check failure counter metrics ([#12439](https://github.com/opensearch-project/OpenSearch/pull/12439))
+- Add latency metrics for instrumenting critical clusterManager code paths ([#12333](https://github.com/opensearch-project/OpenSearch/pull/12333))
+- Add support for Azure Managed Identity in repository-azure ([#12423](https://github.com/opensearch-project/OpenSearch/issues/12423))
+- Add useCompoundFile index setting ([#13478](https://github.com/opensearch-project/OpenSearch/pull/13478))
+- Make outbound side of transport protocol dependent ([#13293](https://github.com/opensearch-project/OpenSearch/pull/13293))
+- [Remote Store] Upload translog checkpoint as object metadata to translog.tlog([#13637](https://github.com/opensearch-project/OpenSearch/pull/13637))
+- [Remote Store] Add dynamic cluster settings to set timeout for segments upload to Remote Store ([#13679](https://github.com/opensearch-project/OpenSearch/pull/13679))
+- Add getMetadataFields to MapperService ([#13819](https://github.com/opensearch-project/OpenSearch/pull/13819))
+- Add "wildcard" field type that supports efficient wildcard, prefix, and regexp queries ([#13461](https://github.com/opensearch-project/OpenSearch/pull/13461))
+- Allow setting query parameters on requests ([#13776](https://github.com/opensearch-project/OpenSearch/issues/13776))
+- Add dynamic action retry timeout setting ([#14022](https://github.com/opensearch-project/OpenSearch/issues/14022))
+- Add capability to disable source recovery_source for an index ([#13590](https://github.com/opensearch-project/OpenSearch/pull/13590))
+- Add remote routing table for remote state publication with experimental feature flag ([#13304](https://github.com/opensearch-project/OpenSearch/pull/13304))
+- Add upload flow for writing routing table to remote store ([#13870](https://github.com/opensearch-project/OpenSearch/pull/13870))
+- Add dynamic action retry timeout setting ([#14022](https://github.com/opensearch-project/OpenSearch/issues/14022))
+- [Remote Store] Add support to disable flush based on translog reader count ([#14027](https://github.com/opensearch-project/OpenSearch/pull/14027))
+- Add recovery chunk size setting ([#13997](https://github.com/opensearch-project/OpenSearch/pull/13997))
+- [Query Insights] Add exporter support for top n queries ([#12982](https://github.com/opensearch-project/OpenSearch/pull/12982))
+- [Query Insights] Add X-Opaque-Id to search request metadata for top n queries ([#13374](https://github.com/opensearch-project/OpenSearch/pull/13374))
+- [Streaming Indexing] Enhance RestAction with request / response streaming support ([#13772](https://github.com/opensearch-project/OpenSearch/pull/13772))
+- Move Remote Store Migration from DocRep to GA and modify remote migration settings name ([#14100](https://github.com/opensearch-project/OpenSearch/pull/14100))
+- [Remote State] Add async remote state deletion task running on an interval, configurable by a setting ([#13995](https://github.com/opensearch-project/OpenSearch/pull/13995))
+- Add remote routing table for remote state publication with experimental feature flag ([#13304](https://github.com/opensearch-project/OpenSearch/pull/13304))
+- Add support for query level resource usage tracking ([#13172](https://github.com/opensearch-project/OpenSearch/pull/13172))
+- [Query Insights] Add cpu and memory metrics to top n queries ([#13739](https://github.com/opensearch-project/OpenSearch/pull/13739))
+- Derived field object type support ([#13720](https://github.com/opensearch-project/OpenSearch/pull/13720))
+- Support Dynamic Pruning in Cardinality Aggregation ([#13821](https://github.com/opensearch-project/OpenSearch/pull/13821))
+
+### Dependencies
+- Bump `com.github.spullara.mustache.java:compiler` from 0.9.10 to 0.9.13 ([#13329](https://github.com/opensearch-project/OpenSearch/pull/13329), [#13559](https://github.com/opensearch-project/OpenSearch/pull/13559))
+- Bump `org.apache.commons:commons-text` from 1.11.0 to 1.12.0 ([#13557](https://github.com/opensearch-project/OpenSearch/pull/13557))
+- Bump `org.hdrhistogram:HdrHistogram` from 2.1.12 to 2.2.2 ([#13556](https://github.com/opensearch-project/OpenSearch/pull/13556), [#13986](https://github.com/opensearch-project/OpenSearch/pull/13986))
+- Bump `com.gradle.enterprise` from 3.17.2 to 3.17.4 ([#13641](https://github.com/opensearch-project/OpenSearch/pull/13641), [#13753](https://github.com/opensearch-project/OpenSearch/pull/13753))
+- Bump `org.apache.hadoop:hadoop-minicluster` from 3.3.6 to 3.4.0 ([#13642](https://github.com/opensearch-project/OpenSearch/pull/13642))
+- Bump `mockito` from 5.11.0 to 5.12.0 ([#13665](https://github.com/opensearch-project/OpenSearch/pull/13665))
+- Bump `com.google.code.gson:gson` from 2.10.1 to 2.11.0 ([#13752](https://github.com/opensearch-project/OpenSearch/pull/13752))
+- Bump `ch.qos.logback:logback-core` from 1.5.3 to 1.5.6 ([#13756](https://github.com/opensearch-project/OpenSearch/pull/13756))
+- Bump `netty` from 4.1.109.Final to 4.1.110.Final ([#13802](https://github.com/opensearch-project/OpenSearch/pull/13802))
+- Bump `jackson` from 2.17.0 to 2.17.1 ([#13817](https://github.com/opensearch-project/OpenSearch/pull/13817))
+- Bump `reactor` from 3.5.15 to 3.5.17 ([#13825](https://github.com/opensearch-project/OpenSearch/pull/13825))
+- Bump `reactor-netty` from 1.1.17 to 1.1.19 ([#13825](https://github.com/opensearch-project/OpenSearch/pull/13825))
+- Bump `commons-cli:commons-cli` from 1.7.0 to 1.8.0 ([#13840](https://github.com/opensearch-project/OpenSearch/pull/13840))
+- Bump `org.apache.xmlbeans:xmlbeans` from 5.2.0 to 5.2.1 ([#13839](https://github.com/opensearch-project/OpenSearch/pull/13839))
+- Bump `actions/checkout` from 3 to 4 ([#13935](https://github.com/opensearch-project/OpenSearch/pull/13935))
+- Bump `com.netflix.nebula.ospackage-base` from 11.9.0 to 11.9.1 ([#13933](https://github.com/opensearch-project/OpenSearch/pull/13933))
+- Bump `com.azure:azure-core-http-netty` from 1.12.8 to 1.15.1 ([#14128](https://github.com/opensearch-project/OpenSearch/pull/14128))
+- Bump `tim-actions/get-pr-commits` from 1.1.0 to 1.3.1 ([#14126](https://github.com/opensearch-project/OpenSearch/pull/14126))
+
+### Changed
+- Add ability for Boolean and date field queries to run when only doc_values are enabled ([#11650](https://github.com/opensearch-project/OpenSearch/pull/11650))
+- Refactor implementations of query phase searcher, allow QueryCollectorContext to have zero collectors ([#13481](https://github.com/opensearch-project/OpenSearch/pull/13481))
+- Adds support to inject telemetry instances to plugins ([#13636](https://github.com/opensearch-project/OpenSearch/pull/13636))
+- Adds support to provide tags with value in Gauge metric. ([#13994](https://github.com/opensearch-project/OpenSearch/pull/13994))
+- Move cache removal notifications outside lru lock ([#14017](https://github.com/opensearch-project/OpenSearch/pull/14017))
+
+### Removed
+- Remove handling of index.mapper.dynamic in AutoCreateIndex([#13067](https://github.com/opensearch-project/OpenSearch/pull/13067))
+
+### Fixed
+- Fix get field mapping API returns 404 error in mixed cluster with multiple versions ([#13624](https://github.com/opensearch-project/OpenSearch/pull/13624))
+- Allow clearing `remote_store.compatibility_mode` setting ([#13646](https://github.com/opensearch-project/OpenSearch/pull/13646))
+- Painless: ensure type "UnmodifiableMap" for params ([#13885](https://github.com/opensearch-project/OpenSearch/pull/13885))
+- Don't return negative scores from `multi_match` query with `cross_fields` type  ([#13829](https://github.com/opensearch-project/OpenSearch/pull/13829))
+- Pass parent filter to inner hit query ([#13903](https://github.com/opensearch-project/OpenSearch/pull/13903))
+- Fix NPE on restore searchable snapshot ([#13911](https://github.com/opensearch-project/OpenSearch/pull/13911))
+- Fix double invocation of postCollection when MultiBucketCollector is present ([#14015](https://github.com/opensearch-project/OpenSearch/pull/14015))
+- Fix ReplicaShardBatchAllocator to batch shards without duplicates ([#13710](https://github.com/opensearch-project/OpenSearch/pull/13710))
+- Java high-level REST client bulk() is not respecting the bulkRequest.requireAlias(true) method call ([#14146](https://github.com/opensearch-project/OpenSearch/pull/14146))
+- Fix ShardNotFoundException during request cache clean up ([#14219](https://github.com/opensearch-project/OpenSearch/pull/14219))
+- Fix Concurrent Modification Exception in Indices Request Cache([#14032](https://github.com/opensearch-project/OpenSearch/pull/14221))
+- Fix the rewrite method for MatchOnlyText field query ([#14248](https://github.com/opensearch-project/OpenSearch/pull/14248))
diff --git a/release-notes/opensearch.release-notes-2.16.0.md b/release-notes/opensearch.release-notes-2.16.0.md
new file mode 100644
index 0000000000000..193aa6b53714c
--- /dev/null
+++ b/release-notes/opensearch.release-notes-2.16.0.md
@@ -0,0 +1,92 @@
+## 2024-07-24 Version 2.16.0 Release Notes
+
+## [2.16.0]
+### Added
+- Add fingerprint ingest processor ([#13724](https://github.com/opensearch-project/OpenSearch/pull/13724))
+- [Remote Store] Rate limiter for remote store low priority uploads ([#14374](https://github.com/opensearch-project/OpenSearch/pull/14374/))
+- Apply the date histogram rewrite optimization to range aggregation ([#13865](https://github.com/opensearch-project/OpenSearch/pull/13865))
+- [Writable Warm] Add composite directory implementation and integrate it with FileCache ([12782](https://github.com/opensearch-project/OpenSearch/pull/12782))
+- [Workload Management] Add QueryGroup schema ([13669](https://github.com/opensearch-project/OpenSearch/pull/13669))
+- Add batching supported processor base type AbstractBatchingProcessor ([#14554](https://github.com/opensearch-project/OpenSearch/pull/14554))
+- Fix race condition while parsing derived fields from search definition ([14445](https://github.com/opensearch-project/OpenSearch/pull/14445))
+- Add `strict_allow_templates` dynamic mapping option ([#14555](https://github.com/opensearch-project/OpenSearch/pull/14555))
+- Add allowlist setting for ingest-common and search-pipeline-common processors ([#14439](https://github.com/opensearch-project/OpenSearch/issues/14439))
+- [Workload Management] add queryGroupId header propagator across requests and nodes ([#14614](https://github.com/opensearch-project/OpenSearch/pull/14614))
+- Create SystemIndexRegistry with helper method matchesSystemIndex ([#14415](https://github.com/opensearch-project/OpenSearch/pull/14415))
+- Print reason why parent task was cancelled ([#14604](https://github.com/opensearch-project/OpenSearch/issues/14604))
+- Add matchesPluginSystemIndexPattern to SystemIndexRegistry ([#14750](https://github.com/opensearch-project/OpenSearch/pull/14750))
+- Add Plugin interface for loading application based configuration templates (([#14659](https://github.com/opensearch-project/OpenSearch/issues/14659)))
+- Refactor remote-routing-table service inline with remote state interfaces([#14668](https://github.com/opensearch-project/OpenSearch/pull/14668))
+- Add shard-diff path to diff manifest to reduce number of read calls remote store (([#14684](https://github.com/opensearch-project/OpenSearch/pull/14684)))
+- Add SortResponseProcessor to Search Pipelines (([#14785](https://github.com/opensearch-project/OpenSearch/issues/14785)))
+- Add prefix mode verification setting for repository verification (([#14790](https://github.com/opensearch-project/OpenSearch/pull/14790)))
+- Add SplitResponseProcessor to Search Pipelines (([#14800](https://github.com/opensearch-project/OpenSearch/issues/14800)))
+- Optimize TransportNodesAction to not send DiscoveryNodes for NodeStats, NodesInfo and ClusterStats call ([14749](https://github.com/opensearch-project/OpenSearch/pull/14749))
+- Reduce logging in DEBUG for MasterService:run ([#14795](https://github.com/opensearch-project/OpenSearch/pull/14795))
+- Refactor remote-routing-table service inline with remote state interfaces([#14668](https://github.com/opensearch-project/OpenSearch/pull/14668))
+- Add rest, transport layer changes for hot to warm tiering - dedicated setup (([#13980](https://github.com/opensearch-project/OpenSearch/pull/13980))
+- Enabling term version check on local state for all ClusterManager Read Transport Actions ([#14273](https://github.com/opensearch-project/OpenSearch/pull/14273))
+- Optimize Cluster Stats Indices to precomute node level stats ([#14426](https://github.com/opensearch-project/OpenSearch/pull/14426))
+- Create listener to refresh search thread resource usage ([#14832](https://github.com/opensearch-project/OpenSearch/pull/14832))
+- Add logic to create index templates (v2) using context field ([#14811](https://github.com/opensearch-project/OpenSearch/pull/14811))
+
+### Dependencies
+- Update to Apache Lucene 9.11.1 ([#14042](https://github.com/opensearch-project/OpenSearch/pull/14042), [#14576](https://github.com/opensearch-project/OpenSearch/pull/14576))
+- Bump `netty` from 4.1.110.Final to 4.1.111.Final ([#14356](https://github.com/opensearch-project/OpenSearch/pull/14356))
+- Bump `org.wiremock:wiremock-standalone` from 3.3.1 to 3.6.0 ([#14361](https://github.com/opensearch-project/OpenSearch/pull/14361))
+- Bump `reactor` from 3.5.17 to 3.5.19 ([#14395](https://github.com/opensearch-project/OpenSearch/pull/14395), [#14697](https://github.com/opensearch-project/OpenSearch/pull/14697))
+- Bump `reactor-netty` from 1.1.19 to 1.1.21 ([#14395](https://github.com/opensearch-project/OpenSearch/pull/14395), [#14697](https://github.com/opensearch-project/OpenSearch/pull/14697))
+- Bump `commons-net:commons-net` from 3.10.0 to 3.11.1 ([#14396](https://github.com/opensearch-project/OpenSearch/pull/14396))
+- Bump `com.nimbusds:nimbus-jose-jwt` from 9.37.3 to 9.40 ([#14398](https://github.com/opensearch-project/OpenSearch/pull/14398))
+- Bump `org.apache.commons:commons-configuration2` from 2.10.1 to 2.11.0 ([#14399](https://github.com/opensearch-project/OpenSearch/pull/14399))
+- Bump `com.gradle.develocity` from 3.17.4 to 3.17.5 ([#14397](https://github.com/opensearch-project/OpenSearch/pull/14397))
+- Bump `opentelemetry` from 1.36.0 to 1.40.0 ([#14457](https://github.com/opensearch-project/OpenSearch/pull/14457), [#14674](https://github.com/opensearch-project/OpenSearch/pull/14674))
+- Bump `opentelemetry-semconv` from 1.25.0-alpha to 1.26.0-alpha ([#14674](https://github.com/opensearch-project/OpenSearch/pull/14674))
+- Bump `azure-identity` from 1.11.4 to 1.13.0, Bump `msal4j` from 1.14.3 to 1.15.1, Bump `msal4j-persistence-extension` from 1.2.0 to 1.3.0 ([#14506](https://github.com/opensearch-project/OpenSearch/pull/14673))
+- Bump `com.azure:azure-storage-common` from 12.21.2 to 12.25.1 ([#14517](https://github.com/opensearch-project/OpenSearch/pull/14517))
+- Bump `com.microsoft.azure:msal4j` from 1.15.1 to 1.16.0 ([#14610](https://github.com/opensearch-project/OpenSearch/pull/14610))
+- Bump `com.github.spullara.mustache.java:compiler` from 0.9.13 to 0.9.14 ([#14672](https://github.com/opensearch-project/OpenSearch/pull/14672))
+- Bump `net.minidev:accessors-smart` from 2.5.0 to 2.5.1 ([#14673](https://github.com/opensearch-project/OpenSearch/pull/14673))
+- Bump `jackson` from 2.17.1 to 2.17.2 ([#14687](https://github.com/opensearch-project/OpenSearch/pull/14687))
+- Bump `net.minidev:json-smart` from 2.5.0 to 2.5.1 ([#14748](https://github.com/opensearch-project/OpenSearch/pull/14748))
+
+### Changed
+- [Tiered Caching] Move query recomputation logic outside write lock ([#14187](https://github.com/opensearch-project/OpenSearch/pull/14187))
+- unsignedLongRangeQuery now returns MatchNoDocsQuery if the lower bounds are greater than the upper bounds ([#14416](https://github.com/opensearch-project/OpenSearch/pull/14416))
+- Make the class CommunityIdProcessor final ([#14448](https://github.com/opensearch-project/OpenSearch/pull/14448))
+- Updated the `indices.query.bool.max_clause_count` setting from being static to dynamically updateable ([#13568](https://github.com/opensearch-project/OpenSearch/pull/13568))
+- Allow @InternalApi annotation on classes not meant to be constructed outside of the OpenSearch core ([#14575](https://github.com/opensearch-project/OpenSearch/pull/14575))
+- Add @InternalApi annotation to japicmp exclusions ([#14597](https://github.com/opensearch-project/OpenSearch/pull/14597))
+- Allow system index warning in OpenSearchRestTestCase.refreshAllIndices ([#14635](https://github.com/opensearch-project/OpenSearch/pull/14635))
+- Make reroute iteration time-bound for large shard allocations ([#14848](https://github.com/opensearch-project/OpenSearch/pull/14848))
+
+### Deprecated
+- Deprecate batch_size parameter on bulk API ([#14725](https://github.com/opensearch-project/OpenSearch/pull/14725))
+
+### Removed
+- Remove query categorization changes ([#14759](https://github.com/opensearch-project/OpenSearch/pull/14759))
+
+### Fixed
+- Fix bug in SBP cancellation logic ([#13259](https://github.com/opensearch-project/OpenSearch/pull/13474))
+- Fix handling of Short and Byte data types in ScriptProcessor ingest pipeline ([#14379](https://github.com/opensearch-project/OpenSearch/issues/14379))
+- Switch to iterative version of WKT format parser ([#14086](https://github.com/opensearch-project/OpenSearch/pull/14086))
+- Fix match_phrase_prefix_query not working on text field with multiple values and index_prefixes ([#10959](https://github.com/opensearch-project/OpenSearch/pull/10959))
+- Fix the computed max shards of cluster to avoid int overflow ([#14155](https://github.com/opensearch-project/OpenSearch/pull/14155))
+- Fixed rest-high-level client searchTemplate & mtermVectors endpoints to have a leading slash ([#14465](https://github.com/opensearch-project/OpenSearch/pull/14465))
+- Write shard level metadata blob when snapshotting searchable snapshot indexes ([#13190](https://github.com/opensearch-project/OpenSearch/pull/13190))
+- Fix aggs result of NestedAggregator with sub NestedAggregator ([#13324](https://github.com/opensearch-project/OpenSearch/pull/13324))
+- Fix fs info reporting negative available size ([#11573](https://github.com/opensearch-project/OpenSearch/pull/11573))
+- Add ListPitInfo::getKeepAlive() getter ([#14495](https://github.com/opensearch-project/OpenSearch/pull/14495))
+- Fix FuzzyQuery in keyword field will use IndexOrDocValuesQuery when both of index and doc_value are true ([#14378](https://github.com/opensearch-project/OpenSearch/pull/14378))
+- Fix file cache initialization ([#14004](https://github.com/opensearch-project/OpenSearch/pull/14004))
+- Handle NPE in GetResult if "found" field is missing ([#14552](https://github.com/opensearch-project/OpenSearch/pull/14552))
+- Fix create or update alias API doesn't throw exception for unsupported parameters ([#14719](https://github.com/opensearch-project/OpenSearch/pull/14719))
+- Refactoring FilterPath.parse by using an iterative approach ([#14200](https://github.com/opensearch-project/OpenSearch/pull/14200))
+- Refactoring Grok.validatePatternBank by using an iterative approach ([#14206](https://github.com/opensearch-project/OpenSearch/pull/14206))
+- Fix NPE when creating index with index.number_of_replicas set to null ([#14812](https://github.com/opensearch-project/OpenSearch/pull/14812))
+- Update help output for _cat ([#14722](https://github.com/opensearch-project/OpenSearch/pull/14722))
+- Fix bulk upsert ignores the default_pipeline and final_pipeline when auto-created index matches the index template ([#12891](https://github.com/opensearch-project/OpenSearch/pull/12891))
+- Fix NPE in ReplicaShardAllocator ([#14385](https://github.com/opensearch-project/OpenSearch/pull/14385))
+- Use circuit breaker in InternalHistogram when adding empty buckets ([#14754](https://github.com/opensearch-project/OpenSearch/pull/14754))
+- Create new IndexInput for multi part upload ([#14888](https://github.com/opensearch-project/OpenSearch/pull/14888))
+- Fix searchable snapshot failure with scripted fields ([#14411](https://github.com/opensearch-project/OpenSearch/pull/14411))
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_alias.json b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_alias.json
index c3ccd25da9f86..14427b00f1bb3 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_alias.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/indices.put_alias.json
@@ -1,7 +1,7 @@
 {
   "indices.put_alias":{
     "documentation":{
-      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/alias/",
+      "url":"https://opensearch.org/docs/latest/api-reference/index-apis/update-alias/",
       "description":"Creates or updates an alias."
     },
     "stability":"stable",
@@ -40,6 +40,62 @@
               "description":"The name of the alias to be created or updated"
             }
           }
+        },
+        {
+          "path":"/{index}/_alias",
+          "methods":[
+            "PUT"
+          ],
+          "parts":{
+            "index":{
+              "type":"list",
+              "description":"A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices."
+            }
+          }
+        },
+        {
+          "path":"/{index}/_aliases",
+          "methods":[
+            "PUT"
+          ],
+          "parts":{
+            "index":{
+              "type":"list",
+              "description":"A comma-separated list of index names the alias should point to (supports wildcards); use `_all` to perform the operation on all indices."
+            }
+          }
+        },
+        {
+          "path":"/_alias/{name}",
+          "methods":[
+            "PUT",
+            "POST"
+          ],
+          "parts":{
+            "name":{
+              "type":"string",
+              "description":"The name of the alias to be created or updated"
+            }
+          }
+        },
+        {
+          "path":"/_aliases/{name}",
+          "methods":[
+            "PUT",
+            "POST"
+          ],
+          "parts":{
+            "name":{
+              "type":"string",
+              "description":"The name of the alias to be created or updated"
+            }
+          }
+        },
+        {
+          "path":"/_alias",
+          "methods":[
+            "PUT"
+          ]
         }
       ]
     },
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.status.json b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.status.json
index 1ac6042941013..354d3c35d2bda 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.status.json
+++ b/rest-api-spec/src/main/resources/rest-api-spec/api/snapshot.status.json
@@ -40,6 +40,26 @@
               "description":"A comma-separated list of snapshot names"
             }
           }
+        },
+        {
+          "path":"/_snapshot/{repository}/{snapshot}/{index}/_status",
+          "methods":[
+            "GET"
+          ],
+          "parts":{
+            "repository":{
+              "type":"string",
+              "description":"A repository name"
+            },
+            "snapshot":{
+              "type":"string",
+              "description":"A snapshot name"
+            },
+            "index":{
+              "type": "list",
+              "description":"A comma-separated list of index names"
+            }
+          }
         }
       ]
     },
@@ -58,7 +78,7 @@
       },
       "ignore_unavailable":{
         "type":"boolean",
-        "description":"Whether to ignore unavailable snapshots, defaults to false which means a SnapshotMissingException is thrown"
+        "description":"Whether to ignore unavailable snapshots and indices, defaults to false which means a SnapshotMissingException or IndexNotFoundException is thrown"
       }
     }
   }
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/index/100_partial_flat_object.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/index/100_partial_flat_object.yml
index 91e4127da9c32..6fc2654bcfc8f 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/index/100_partial_flat_object.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/index/100_partial_flat_object.yml
@@ -88,7 +88,16 @@ setup:
             } ]
           }
         }
-
+  - do:
+      index:
+        index: test_partial_flat_object
+        id: 4
+        body: {
+          "issue": {
+            "number": 999,
+            "labels": null
+          }
+        }
   - do:
       indices.refresh:
         index: test_partial_flat_object
@@ -105,8 +114,8 @@ teardown:
 # and no dynamic fields were created.
 "Mappings":
   - skip:
-      version: " - 2.99.99"
-      reason: "flat_object is introduced in 3.0.0 in main branch"
+      version: " - 2.16.99"
+      reason: "flat_object field with null (doc 4) throws exception before 2.17"
 
   - do:
       indices.get_mapping:
@@ -122,8 +131,8 @@ teardown:
 ---
 "Supported queries":
   - skip:
-      version: " - 2.99.99"
-      reason: "flat_object is introduced in 3.0.0 in main branch"
+      version: " - 2.16.99"
+      reason: "flat_object field with null (doc 4) throws exception before 2.17"
 
 
   # Verify Document Count
@@ -135,7 +144,7 @@ teardown:
           }
         }
 
-  - length: { hits.hits: 3 }
+  - length: { hits.hits: 4 }
 
   # Match Query with exact dot path.
   - do:
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/index/105_partial_flat_object_nested.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/index/105_partial_flat_object_nested.yml
index ce172c2773e1f..549ddbdde7bab 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/index/105_partial_flat_object_nested.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/index/105_partial_flat_object_nested.yml
@@ -89,8 +89,8 @@ teardown:
 # and no dynamic fields were created.
 "Mappings":
   - skip:
-      version: " - 2.99.99"
-      reason: "flat_object is introduced in 3.0.0 in main branch"
+      version: " - 2.6.99"
+      reason: "flat_object is introduced in 2.7"
 
   - do:
       indices.get_mapping:
@@ -106,8 +106,8 @@ teardown:
 ---
 "Supported queries":
   - skip:
-      version: " - 2.99.99"
-      reason: "flat_object is introduced in 3.0.0 in main branch"
+      version: " - 2.6.99"
+      reason: "flat_object is introduced in 2.7"
 
 
   # Verify Document Count
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/index/110_strict_allow_templates.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/index/110_strict_allow_templates.yml
new file mode 100644
index 0000000000000..623cb97c37728
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/index/110_strict_allow_templates.yml
@@ -0,0 +1,155 @@
+---
+"Index documents with setting dynamic parameter to strict_allow_templates in the mapping of the index":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+
+  - do:
+      indices.create:
+        index:    test_1
+        body:
+          mappings:
+            dynamic: strict_allow_templates
+            dynamic_templates: [
+              {
+                strings: {
+                  "match": "stringField*",
+                  "match_mapping_type": "string",
+                  "mapping": {
+                    "type": "keyword"
+                  }
+                }
+              },
+              {
+                object: {
+                  "match": "objectField*",
+                  "match_mapping_type": "object",
+                  "mapping": {
+                    "type": "object",
+                    "properties": {
+                      "bar1": {
+                        "type": "keyword"
+                      },
+                      "bar2": {
+                        "type": "text"
+                      }
+                    }
+                  }
+                }
+              },
+              {
+                boolean: {
+                  "match": "booleanField*",
+                  "match_mapping_type": "boolean",
+                  "mapping": {
+                    "type": "boolean"
+                  }
+                }
+              },
+              {
+                double: {
+                  "match": "doubleField*",
+                  "match_mapping_type": "double",
+                  "mapping": {
+                    "type": "double"
+                  }
+                }
+              },
+              {
+                long: {
+                  "match": "longField*",
+                  "match_mapping_type": "long",
+                  "mapping": {
+                    "type": "long"
+                  }
+                }
+              },
+              {
+                array: {
+                  "match": "arrayField*",
+                  "mapping": {
+                    "type": "keyword"
+                  }
+                }
+              },
+              {
+                date: {
+                  "match": "dateField*",
+                  "match_mapping_type": "date",
+                  "mapping": {
+                    "type": "date"
+                  }
+                }
+              }
+            ]
+            properties:
+              test1:
+                type: text
+
+  - do:
+      catch: /mapping set to strict_allow_templates, dynamic introduction of \[test2\] within \[\_doc\] is not allowed/
+      index:
+        index:   test_1
+        id:      1
+        body:    {
+          stringField: bar,
+          objectField: {
+            bar1: "bar1",
+            bar2: "bar2"
+          },
+          test1: test1,
+          test2: test2
+        }
+
+  - do:
+      index:
+        index:   test_1
+        id:      1
+        body:    {
+          stringField: bar,
+          objectField: {
+            bar1: "bar1",
+            bar2: "bar2"
+          },
+          booleanField: true,
+          doubleField: 1.0,
+          longField: 100,
+          arrayField: ["1","2"],
+          dateField: "2024-06-25T05:11:51.243Z",
+          test1: test1
+        }
+
+  - do:
+      get:
+        index: test_1
+        id: 1
+  - match: { _source: {
+      stringField: bar,
+      objectField: {
+        bar1: "bar1",
+        bar2: "bar2"
+      },
+      booleanField: true,
+      doubleField: 1.0,
+      longField: 100,
+      arrayField: [ "1","2" ],
+      dateField: "2024-06-25T05:11:51.243Z",
+      test1: test1
+    }
+  }
+
+  - do:
+      indices.get_mapping: {
+        index: test_1
+      }
+
+  - match: {test_1.mappings.dynamic:     strict_allow_templates}
+  - match: {test_1.mappings.properties.stringField.type:     keyword}
+  - match: {test_1.mappings.properties.objectField.properties.bar1.type:     keyword}
+  - match: {test_1.mappings.properties.objectField.properties.bar2.type:     text}
+  - match: {test_1.mappings.properties.booleanField.type:     boolean}
+  - match: {test_1.mappings.properties.doubleField.type:     double}
+  - match: {test_1.mappings.properties.longField.type:     long}
+  - match: {test_1.mappings.properties.arrayField.type:     keyword}
+  - match: {test_1.mappings.properties.dateField.type:     date}
+  - match: {test_1.mappings.properties.test1.type:     text}
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/index/115_constant_keyword.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/index/115_constant_keyword.yml
new file mode 100644
index 0000000000000..e60981dbbf50c
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/index/115_constant_keyword.yml
@@ -0,0 +1,332 @@
+# The test setup includes two parts:
+# part1: test mapping and indexing
+# part2: test query
+---
+"Mappings and Indexing":
+  - skip:
+      version: " - 2.15.99"
+      reason: "fixed in 2.16.0"
+
+  # Create indices with constant_keyword field type
+  - do:
+      indices.create:
+        index: test
+        body:
+          mappings:
+            properties:
+              genre:
+                type: "constant_keyword"
+                value: "1"
+
+  # Index documents to test integer and string are both ok.
+  - do:
+      index:
+        index: test
+        id: 1
+        body: {
+          "genre": "1"
+        }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        body: {
+          "genre": 1
+        }
+
+  # Refresh
+  - do:
+      indices.refresh:
+        index: test
+
+  # Check mapping
+  - do:
+      indices.get_mapping:
+        index: test
+  - is_true: test.mappings
+  - match: { test.mappings.properties.genre.type: constant_keyword }
+  - length: { test.mappings.properties.genre: 2 }
+
+  # Verify Document Count
+  - do:
+      search:
+        index: test
+        body: {
+          query: {
+            match_all: {}
+          }
+        }
+
+  - length: { hits.hits: 2 }
+  - match: { hits.hits.0._source.genre: "1" }
+  - match: { hits.hits.1._source.genre: 1 }
+
+  # Delete Index when connection is teardown
+  - do:
+      indices.delete:
+        index: test
+
+---
+"Queries":
+  - skip:
+      version: " - 2.16.99"
+      reason: "rangeQuery and regexpQuery are introduced in 2.17.0"
+
+  - do:
+      indices.create:
+        index: test1
+        body:
+          mappings:
+            properties:
+              genre:
+                type: "constant_keyword"
+                value: "d3efault"
+
+  # Index documents to test query.
+  - do:
+      index:
+        index: test1
+        id: 1
+        body: {
+          "genre": "d3efault"
+        }
+
+  # Refresh
+  - do:
+      indices.refresh:
+        index: test1
+
+  # Test rangeQuery
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                gte: "d3efault"
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 1 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                from: "d3efault",
+                "include_lower": "false"
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 0 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                lte: "d3efault"
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 1 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                to: "d3efault",
+                include_upper: "false"
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 0 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                from: "d3efault",
+                to: "d3efault",
+                include_lower: "false",
+                include_upper: "true"
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 0 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                from: "d3efault",
+                to: "d3efault",
+                include_lower: "true",
+                include_upper: "false"
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 0 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                from: null,
+                to: null
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 1 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                from: "d3efault",
+                to: "d3efault",
+                include_lower: "true",
+                include_upper: "true"
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 1 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            range: {
+              genre: {
+                from: "d3efaul",
+                to: "d3efault1",
+                include_lower: "true",
+                include_upper: "true"
+              }
+            }
+          }
+        }
+
+  - length: { hits.hits: 1 }
+
+  # Test regexpQuery
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            regexp: {
+              "genre":"d.*"
+            }
+          }
+        }
+
+  - length: { hits.hits: 1 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            regexp: {
+              "genre":"d\\defau[a-z]?t"
+            }
+          }
+        }
+
+  - length: { hits.hits: 1 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            regexp: {
+              "genre":"d\\defa[a-z]?t"
+            }
+          }
+        }
+
+  - length: { hits.hits: 0 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            regexp: {
+              "genre":"d3efa[a-z]{3,3}"
+            }
+          }
+        }
+
+  - length: { hits.hits: 1 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            regexp: {
+              "genre":"d3efa[a-z]{4,4}"
+            }
+          }
+        }
+
+  - length: { hits.hits: 0 }
+
+  - do:
+      search:
+        index: test1
+        body: {
+          query: {
+            match_all: {}
+          }
+        }
+
+  - length: { hits.hits: 1 }
+  - match: { hits.hits.0._source.genre: "d3efault" }
+
+  # Delete Index when connection is teardown
+  - do:
+      indices.delete:
+        index: test1
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/index/120_field_name.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/index/120_field_name.yml
new file mode 100644
index 0000000000000..040e883b4a4c2
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/index/120_field_name.yml
@@ -0,0 +1,38 @@
+---
+"Index documents with field name containing only dot fail with an IllegalArgumentException":
+  - skip:
+      version: " - 2.16.99"
+      reason: "introduced in 2.17.0"
+
+  - do:
+      indices.create:
+        index:    test_1
+
+  - do:
+      catch: /field name cannot contain only the character \[.\]/
+      index:
+        index:   test_1
+        id:      1
+        body:    {
+          .: bar
+        }
+
+  - do:
+      catch: /field name cannot contain only the character \[.\]/
+      index:
+        index:   test_1
+        id:      1
+        body:    {
+          ..: bar
+        }
+
+  - do:
+      catch: /field name cannot contain only the character \[.\]/
+      index:
+        index:   test_1
+        id:      1
+        body:    {
+          foo: {
+            .: bar
+          }
+        }
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/index/90_flat_object.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/index/90_flat_object.yml
index 0a5f7444efd17..83d3d273ebd93 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/index/90_flat_object.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/index/90_flat_object.yml
@@ -97,8 +97,8 @@ teardown:
 ---
 "Supported queries":
   - skip:
-      version: " - 2.99.99"
-      reason: "flat_object is introduced in 3.0.0 in main branch"
+      version: " - 2.6.99"
+      reason: "flat_object is introduced in 2.7"
 
   # Verify Document Count
   - do:
@@ -607,8 +607,8 @@ teardown:
 ---
 "Unsupported":
   - skip:
-      version: " - 2.99.99"
-      reason: "flat_object is introduced in 3.0.0 in main branch"
+      version: " - 2.6.99"
+      reason: "flat_object is introduced in 2.7"
 
   # Mapping parameters (such as index/search analyzers) are currently not supported
   # The plan is to support them in the next version
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/index/91_flat_object_null_value.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/index/91_flat_object_null_value.yml
new file mode 100644
index 0000000000000..716b6fb51cb43
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/index/91_flat_object_null_value.yml
@@ -0,0 +1,426 @@
+---
+# The test setup includes:
+# - Create flat_object mapping for flat_object_null_value index
+# - Index 19 example documents related to null value
+# - Refresh the index so it is ready for search tests
+
+setup:
+  - skip:
+      version: " - 2.99.99"
+      reason: "null value in flat_object is processed in 3.0.0 "
+  - do:
+      indices.create:
+        index: flat_object_null_value
+        body:
+          mappings:
+            properties:
+              record:
+                type: "flat_object"
+              order:
+                type: "integer"
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 1
+        body: {
+          "record": null,
+          "order" : 1
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 2
+        body: {
+          "record": {
+            "name": null
+          },
+          "order" : 2
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 3
+        body: {
+          "record": {
+            "name": null,
+            "age":"5",
+            "name1": null
+          },
+          "order" : 3
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 4
+        body: {
+          "record": {
+            "name": [
+              null,
+              {
+                "d": {
+                  "name": "dsds"
+                }
+              }
+            ]
+          },
+          "order" : 4
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 5
+        body: {
+          "record": {
+            "name": [
+              {
+                "d": {
+                  "name": "dsds"
+                }
+              },
+              null
+            ]
+          },
+          "order" : 5
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 6
+        body: {
+          "record": {
+            "name": [
+              {
+                "name": "age1"
+              },
+              null,
+              {
+                "d": {
+                  "name": "dsds"
+                }
+              }
+            ]
+          },
+          "order" : 6
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 7
+        body: {
+          "record": {
+            "name": null,
+            "age":"3"
+          },
+          "order" : 7
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 8
+        body: {
+          "record": {
+            "age":"3",
+            "name": null
+          },
+          "order" : 8
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 9
+        body: {
+          "record": {
+            "name": [
+              null,
+              3
+            ],
+            "age": 4
+          },
+          "order" : 9
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 10
+        body: {
+          "record": {
+            "age": 4,
+            "name": [
+              null,
+              3
+            ]
+          },
+          "order" : 10
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 11
+        body: {
+          "record": {
+            "name": null
+          },
+          "order": 11
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 12
+        body: {
+          "record": {
+            "r1": {
+              "labels": [
+                null
+              ]
+            }
+          },
+          "order": 12
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 13
+        body: {
+          "record": {
+            "labels": [
+              null
+            ]
+          },
+          "order": 13
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 14
+        body: {
+          "record": {
+            "r1": {
+              "name": null,
+              "labels": [
+                null
+              ]
+            }
+          },
+          "order": 14
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 15
+        body: {
+          "record": {
+            "age": "4",
+            "labels": [
+              null
+            ]
+          },
+          "order": 15
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 16
+        body: {
+          "record": {
+            "labels": [
+              null
+            ],
+            "age": "4"
+          },
+          "order": 16
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 17
+        body: {
+          "record": {
+            "name": {
+              "name1": [
+                null,
+                "dsdsdsd"
+              ]
+            }
+          },
+          "order": 17
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 18
+        body: {
+          "record": {
+            "name": {
+              "name1": {
+                "name2": null
+              }
+            }
+          },
+          "order": 18
+        }
+
+  - do:
+      index:
+        index: flat_object_null_value
+        id: 19
+        body: {
+          "record": {
+            "name": {
+              "name1": [
+                [],
+                [
+                  "dsdsdsd",
+                  null
+                ]
+              ]
+            }
+          },
+          "order": 19
+        }
+
+  - do:
+      indices.refresh:
+        index: flat_object_null_value
+---
+# Delete Index when connection is teardown
+teardown:
+  - do:
+      indices.delete:
+        index: flat_object_null_value
+
+
+---
+# Verify that mappings under the catalog field did not expand
+# and no dynamic fields were created.
+"Mappings":
+  - skip:
+      version: " - 2.99.99"
+      reason: "null value in flat_object is processed in 3.0.0"
+
+  - do:
+      indices.get_mapping:
+        index: flat_object_null_value
+  - is_true: flat_object_null_value.mappings
+  - match: { flat_object_null_value.mappings.properties.record.type: flat_object }
+  # https://github.com/opensearch-project/OpenSearch/tree/main/rest-api-spec/src/main/resources/rest-api-spec/test#length
+  - length: { flat_object_null_value.mappings.properties: 2 }
+
+
+---
+"Supported queries":
+  - skip:
+      version: " - 2.99.99"
+      reason: "null value in flat_object is processed in 3.0.0"
+
+  # Verify Document Count
+  - do:
+      search:
+        body: {
+          size: 30,
+          query: {
+            match_all: { }
+          }
+        }
+
+  - length: { hits.hits: 19 }
+
+  # Exists Query with no dot path.
+  - do:
+      search:
+        body: {
+          _source: true,
+          size: 30,
+          query: {
+            exists: { "field": "record" }
+          },
+          sort: [{ order: asc}]
+        }
+
+  - length: { hits.hits: 12 }
+  - match: { hits.hits.0._source.record: { "name": null, "age": "5", "name1": null } }
+  - match: { hits.hits.1._source.record.name: [ null, { "d": { "name": "dsds" } } ] }
+  - match: { hits.hits.2._source.record.name: [ { "d": { "name": "dsds" } }, null ] }
+  - match: { hits.hits.3._source.record.name: [ { "name": "age1" }, null, { "d": { "name": "dsds" } } ] }
+  - match: { hits.hits.4._source.record: { "name": null, "age": "3" } }
+  - match: { hits.hits.5._source.record: { "age": "3", "name": null } }
+  - match: { hits.hits.6._source.record: { "name": [ null, 3 ], "age": 4 } }
+  - match: { hits.hits.7._source.record: { "age": 4, "name": [ null, 3 ] } }
+  - match: { hits.hits.8._source.record: { "age": "4", "labels": [ null ] } }
+  - match: { hits.hits.9._source.record: { "labels": [ null ], "age": "4" } }
+  - match: { hits.hits.10._source.record.name: { "name1": [ null, "dsdsdsd" ] } }
+  - match: { hits.hits.11._source.record.name: { "name1": [ [], [ "dsdsdsd", null ] ] } }
+
+  # Exists Query with dot path.
+  - do:
+      search:
+        body: {
+          _source: true,
+          query: {
+            exists: { "field": "record.d" }
+          },
+          sort: [{ order: asc}]
+        }
+
+  - length: { hits.hits: 3 }
+  - match: { hits.hits.0._source.record.name: [ null, { "d": { "name": "dsds" } } ] }
+  - match: { hits.hits.1._source.record.name: [ { "d": { "name": "dsds" } }, null ] }
+  - match: { hits.hits.2._source.record.name: [ { "name": "age1" }, null, { "d": { "name": "dsds" } } ] }
+
+  # Term Query without exact dot path.
+  - do:
+      search:
+        body: {
+          _source: true,
+          query: {
+            term: { record: "dsdsdsd" }
+          },
+          sort: [{ order: asc}]
+        }
+
+  - length: { hits.hits: 2 }
+  - match: { hits.hits.0._source.record.name: { "name1": [ null, "dsdsdsd" ] } }
+  - match: { hits.hits.1._source.record.name: { "name1": [ [], [ "dsdsdsd", null ] ] } }
+
+  # Term Query with exact dot path.
+  - do:
+      search:
+        body: {
+          _source: true,
+          query: {
+            term: { record.name.name1: "dsdsdsd" }
+          },
+          sort: [{ order: asc}]
+        }
+
+  - length: { hits.hits: 2 }
+  - match: { hits.hits.0._source.record.name: { "name1": [ null, "dsdsdsd" ] } }
+  - match: { hits.hits.1._source.record.name: { "name1": [ [], [ "dsdsdsd", null ] ] } }
+
+  # Test "null" string search.
+  - do:
+      search:
+        body: {
+          _source: true,
+          query: {
+            term: { record: "null" }
+          }
+        }
+
+  - length: { hits.hits: 0 }
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/indices.delete_index_template/10_basic.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/indices.delete_index_template/10_basic.yml
new file mode 100644
index 0000000000000..6239eb7b8cd22
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/indices.delete_index_template/10_basic.yml
@@ -0,0 +1,58 @@
+setup:
+  - skip:
+      features: allowed_warnings
+  - do:
+      allowed_warnings:
+        - "index template [test_template_1] has index patterns [test-*] matching patterns from existing older templates [global] with patterns (global => [*]); this template [test_template_1] will take precedence during new index creation"
+      indices.put_index_template:
+        name: test_template_1
+        body:
+          index_patterns: test-*
+          template:
+            settings:
+              number_of_shards:   1
+              number_of_replicas: 0
+          "priority": 50
+
+  - do:
+      allowed_warnings:
+        - "index template [test_template_2] has index patterns [test-*] matching patterns from existing older templates [global] with patterns (global => [*]); this template [test_template_2] will take precedence during new index creation"
+      indices.put_index_template:
+        name: test_template_2
+        body:
+          index_patterns: test-*
+          data_stream: {}
+          template:
+            settings:
+              number_of_shards:   1
+              number_of_replicas: 0
+          "priority": 51
+
+---
+teardown:
+  - do:
+      indices.delete_data_stream:
+        name: test-1
+        ignore: 404
+  - do:
+      indices.delete_index_template:
+        name: test_template_1
+        ignore: 404
+  - do:
+      indices.delete_index_template:
+        name: test_template_2
+        ignore: 404
+
+---
+"Delete index template which is not used by data stream but index pattern matches":
+  - skip:
+      version: " - 2.16.99"
+      reason: "fixed in 2.17.0"
+
+  - do:
+      indices.create_data_stream:
+        name: test-1
+
+  - do:
+      indices.delete_index_template:
+        name: test_template_1
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_alias/10_basic.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_alias/10_basic.yml
index 77338a6ddae0b..41f87c1df28ed 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_alias/10_basic.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_alias/10_basic.yml
@@ -28,6 +28,36 @@
 
   - match: {test_index.aliases.test_alias: {}}
 
+  - do:
+      indices.put_alias:
+        index: test_index
+        body: {"alias": "test_alias_1"}
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias_1
+
+  - match: {test_index.aliases.test_alias_1: {}}
+
+  - do:
+      indices.put_alias:
+        name: test_alias_2
+        body: {"index": "test_index"}
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias_2
+
+  - match: {test_index.aliases.test_alias_2: {}}
+
+  - do:
+      catch: bad_request
+      indices.put_alias:
+        index: null
+        name: null
+
 ---
 "Can't create alias with invalid characters":
 
@@ -102,3 +132,179 @@
         index: test_index
         name: test_alias
   - match: {test_index.aliases.test_alias: {"filter": {"range": {"date_nanos_field": {"gt": "now-7d/d"}}}}}
+
+---
+"Can set index_routing":
+  - do:
+      indices.create:
+        index: test_index
+
+  - do:
+      indices.put_alias:
+        index: test_index
+        name: test_alias
+        body:
+          index_routing: "test"
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias
+  - match: {test_index.aliases.test_alias: { 'index_routing': "test" }}
+
+---
+"Can set routing":
+  - do:
+      indices.create:
+        index: test_index
+
+  - do:
+      indices.put_alias:
+        index: test_index
+        name: test_alias
+        body:
+          routing: "test"
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias
+  - match: {test_index.aliases.test_alias: { 'index_routing': "test", 'search_routing': "test" }}
+
+---
+"Can set search_routing":
+  - do:
+      indices.create:
+        index: test_index
+
+  - do:
+      indices.put_alias:
+        index: test_index
+        name: test_alias
+        body:
+          search_routing: "test"
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias
+  - match: {test_index.aliases.test_alias: { 'search_routing': "test" }}
+
+---
+"Index parameter supports multiple values":
+  - do:
+      indices.create:
+        index: test_index
+  - do:
+      indices.create:
+        index: test_index1
+
+  - do:
+      indices.put_alias:
+        index: test_index,test_index1
+        name: test_alias
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias
+  - match: {test_index.aliases.test_alias: { }}
+  - do:
+      indices.get_alias:
+        index: test_index1
+        name: test_alias
+  - match: {test_index1.aliases.test_alias: { }}
+
+  - do:
+      indices.put_alias:
+        body: {"index": "test_index,test_index1", "alias": "test_alias_1"}
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias_1
+  - match: {test_index.aliases.test_alias_1: { }}
+  - do:
+      indices.get_alias:
+        index: test_index1
+        name: test_alias_1
+  - match: {test_index1.aliases.test_alias_1: { }}
+
+---
+"Index and alias in request body can override path parameters":
+  - do:
+      indices.create:
+        index: test_index
+
+  - do:
+      indices.put_alias:
+        index: test_index_unknown
+        name: test_alias
+        body: {"index": "test_index"}
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias
+  - match: {test_index.aliases.test_alias: { }}
+
+  - do:
+      indices.put_alias:
+        index: test_index
+        name: test_alias_unknown
+        body: {"alias": "test_alias_2"}
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias_2
+  - match: {test_index.aliases.test_alias_2: { }}
+
+  - do:
+      indices.put_alias:
+        body: {"index": "test_index", "alias": "test_alias_3"}
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias_3
+  - match: {test_index.aliases.test_alias_3: { }}
+
+---
+"Can set is_hidden":
+  - skip:
+      version: " - 2.15.99"
+      reason: "Fix was introduced in 2.16.0"
+  - do:
+      indices.create:
+        index: test_index
+
+  - do:
+      indices.put_alias:
+        index: test_index
+        name: test_alias
+        body:
+          is_hidden: true
+
+  - do:
+      indices.get_alias:
+        index: test_index
+        name: test_alias
+  - match: {test_index.aliases.test_alias: { 'is_hidden': true }}
+
+---
+"Throws exception with invalid parameters":
+  - skip:
+      version: " - 2.15.99"
+      reason: "Fix was introduced in 2.16.0"
+
+  - do:
+      indices.create:
+        index: test_index
+
+  - do:
+      catch: /unknown field \[abc\]/
+      indices.put_alias:
+        index: test_index
+        name: test_alias
+        body: {"abc": 1}
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_mapping/all_path_options.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_mapping/all_path_options.yml
index ca7a21df20ea4..89b47fde2a72c 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_mapping/all_path_options.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/indices.put_mapping/all_path_options.yml
@@ -159,3 +159,34 @@ setup:
       indices.get_mapping: {}
 
   - match: {test_index1.mappings.properties.text.type:     text}
+
+---
+"post a mapping with setting dynamic to strict_allow_templates":
+  - skip:
+      version: " - 2.15.99"
+      reason: "introduced in 2.16.0"
+  - do:
+      indices.put_mapping:
+        index: test_index1
+        body:
+          dynamic: strict_allow_templates
+          dynamic_templates: [
+            {
+              strings: {
+                "match": "foo*",
+                "match_mapping_type": "string",
+                "mapping": {
+                  "type": "keyword"
+                }
+              }
+            }
+          ]
+          properties:
+            test1:
+              type: text
+
+  - do:
+      indices.get_mapping: {}
+
+  - match: {test_index1.mappings.dynamic:     strict_allow_templates}
+  - match: {test_index1.mappings.properties.test1.type:     text}
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
index ebe5edc4370b7..298c5eddc113d 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
@@ -658,6 +658,7 @@ setup:
           settings:
             number_of_replicas: 0
             number_of_shards: 1
+            refresh_interval: -1
           mappings:
             properties:
               date:
@@ -677,6 +678,11 @@ setup:
           - '{"index": {}}'
           - '{"date": "2016-03-01"}'
 
+  - do:
+      indices.forcemerge:
+        index: test_2
+        max_num_segments: 1
+
   - do:
       search:
         index: test_2
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/230_composite.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/230_composite.yml
index ec2d940c16160..2fd941156cb9f 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/230_composite.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/230_composite.yml
@@ -1083,6 +1083,7 @@ setup:
           settings:
             number_of_replicas: 0
             number_of_shards: 1
+            refresh_interval: -1
           mappings:
             properties:
               date:
@@ -1100,6 +1101,12 @@ setup:
           - '{"date": "2016-02-01"}'
           - '{"index": {}}'
           - '{"date": "2016-03-01"}'
+
+  - do:
+      indices.forcemerge:
+        index: test_2
+        max_num_segments: 1
+
   - do:
       search:
         index: test_2
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/330_auto_date_histogram.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/330_auto_date_histogram.yml
index 250689e655476..c69c3406d2a12 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/330_auto_date_histogram.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/330_auto_date_histogram.yml
@@ -106,8 +106,41 @@ setup:
       version: " - 2.14.99"
       reason: debug info for filter rewrite added in 3.0.0 (to be backported to 2.14.0)
 
+  - do:
+      indices.create:
+        index: test_profile
+        body:
+          settings:
+            number_of_shards: 1
+            number_of_replicas: 0
+            refresh_interval: -1
+          mappings:
+            properties:
+              date:
+                type: date
+
+  - do:
+      bulk:
+        index: test_profile
+        refresh: true
+        body:
+          - '{"index": {}}'
+          - '{"date": "2020-03-01", "v": 1}'
+          - '{"index": {}}'
+          - '{"date": "2020-03-02", "v": 2}'
+          - '{"index": {}}'
+          - '{"date": "2020-03-08", "v": 3}'
+          - '{"index": {}}'
+          - '{"date": "2020-03-09", "v": 4}'
+
+  - do:
+      indices.forcemerge:
+        index: test_profile
+        max_num_segments: 1
+
   - do:
       search:
+        index: test_profile
         body:
           profile: true
           size: 0
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/360_date_histogram.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/360_date_histogram.yml
index 0ea9d3de00926..52d68f4e32812 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/360_date_histogram.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/360_date_histogram.yml
@@ -61,3 +61,94 @@ setup:
   - match: { aggregations.histo.buckets.8.doc_count: 1 }
   - match: { aggregations.histo.buckets.12.key_as_string: "2016-06-01T00:00:00.000Z" }
   - match: { aggregations.histo.buckets.12.doc_count: 1 }
+
+---
+"Date histogram aggregation w/ filter query test":
+  - do:
+      bulk:
+        refresh: true
+        index: dhisto-agg-w-query
+        body:
+          - '{"index": {}}'
+          - '{"routing": "route1", "date": "2024-08-12", "dow": "monday"}'
+          - '{"index": {}}'
+          - '{"routing": "route1", "date": "2024-08-14", "dow": "wednesday"}'
+          - '{"index": {}}'
+          - '{"routing": "route1", "date": "2024-08-19", "dow": "monday"}'
+          - '{"index": {}}'
+          - '{"routing": "route2", "date": "2024-08-13", "dow": "tuesday"}'
+          - '{"index": {}}'
+          - '{"routing": "route2", "date": "2024-08-15", "dow": "thursday"}'
+
+  - do:
+      search:
+        index: dhisto-agg-w-query
+        body:
+          query:
+            bool:
+              must:
+                match_all: {}
+              filter:
+                - terms:
+                    routing:
+                      - "route1"
+          aggregations:
+            weekHisto:
+              date_histogram:
+                field: date
+                calendar_interval: week
+          _source: false
+
+  - match: { hits.total.value: 3 }
+  - match: { aggregations.weekHisto.buckets.0.doc_count: 2 }
+  - match: { aggregations.weekHisto.buckets.1.doc_count: 1 }
+
+---
+"Date histogram aggregation w/ shared field range test":
+  - skip:
+      version: " - 2.16.99"
+      reason: "Bugfix not backported to 2.16"
+
+  - do:
+      bulk:
+        refresh: true
+        index: dhisto-agg-w-query
+        body:
+          - '{"index": {}}'
+          - '{"date": "2024-10-31"}'
+          - '{"index": {}}'
+          - '{"date": "2024-11-11"}'
+          - '{"index": {}}'
+          - '{"date": "2024-11-28"}'
+          - '{"index": {}}'
+          - '{"date": "2024-12-25"}'
+          - '{"index": {}}'
+          - '{"date": "2025-01-01"}'
+          - '{"index": {}}'
+          - '{"date": "2025-02-14"}'
+
+  - do:
+      search:
+        index: dhisto-agg-w-query
+        body:
+          profile: true
+          query:
+            range:
+              date:
+                gte: "2024-01-01"
+                lt: "2025-01-01"
+          aggregations:
+            monthHisto:
+              date_histogram:
+                field: date
+                calendar_interval: month
+          _source: false
+
+  - match: { hits.total.value: 4 }
+  - match: { aggregations.monthHisto.buckets.0.doc_count: 1 }
+  - match: { aggregations.monthHisto.buckets.1.doc_count: 2 }
+  - match: { aggregations.monthHisto.buckets.2.doc_count: 1 }
+  - match: { profile.shards.0.aggregations.0.debug.optimized_segments: 1 }
+  - match: { profile.shards.0.aggregations.0.debug.unoptimized_segments: 0 }
+  - match: { profile.shards.0.aggregations.0.debug.leaf_visited: 0 }
+  - match: { profile.shards.0.aggregations.0.debug.inner_visited: 0 }
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/40_range.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/40_range.yml
index 7d887d56ae8fe..daba12e5fb753 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/40_range.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/40_range.yml
@@ -14,6 +14,9 @@ setup:
                 date:
                   type: date
                   format: epoch_second
+                scaled_field:
+                  type: scaled_float
+                  scaling_factor: 100
 
   - do:
       cluster.health:
@@ -528,3 +531,224 @@ setup:
   - is_false:  aggregations.unsigned_long_range.buckets.2.to
 
   - match: { aggregations.unsigned_long_range.buckets.2.doc_count: 0 }
+
+---
+"Double range profiler shows filter rewrite info":
+  - skip:
+      version: " - 2.99.99"
+      reason: debug info for filter rewrite added in 3.0.0 (to be backported to 2.15.0)
+
+  - do:
+      indices.create:
+        index: test_profile
+        body:
+          settings:
+            number_of_replicas: 0
+            number_of_shards: 1
+            refresh_interval: -1
+          mappings:
+            properties:
+              ip:
+                type: ip
+              double:
+                type: double
+              date:
+                type: date
+                format: epoch_second
+
+  - do:
+      bulk:
+        index: test_profile
+        refresh: true
+        body:
+          - '{"index": {}}'
+          - '{"double" : 42}'
+          - '{"index": {}}'
+          - '{"double" : 100}'
+          - '{"index": {}}'
+          - '{"double" : 50}'
+
+  - do:
+      indices.forcemerge:
+        index: test_profile
+        max_num_segments: 1
+
+  - do:
+      search:
+        index: test_profile
+        body:
+          size: 0
+          profile: true
+          aggs:
+            double_range:
+              range:
+                field: double
+                ranges:
+                  - to: 50
+                  - from: 50
+                    to: 150
+                  - from: 150
+
+  - length: { aggregations.double_range.buckets: 3 }
+
+  - match: { aggregations.double_range.buckets.0.key: "*-50.0" }
+  - is_false: aggregations.double_range.buckets.0.from
+  - match: { aggregations.double_range.buckets.0.to: 50.0 }
+  - match: { aggregations.double_range.buckets.0.doc_count: 1 }
+  - match: { aggregations.double_range.buckets.1.key: "50.0-150.0" }
+  - match: { aggregations.double_range.buckets.1.from: 50.0 }
+  - match: { aggregations.double_range.buckets.1.to: 150.0 }
+  - match: { aggregations.double_range.buckets.1.doc_count: 2 }
+  - match: { aggregations.double_range.buckets.2.key: "150.0-*" }
+  - match: { aggregations.double_range.buckets.2.from: 150.0 }
+  - is_false:  aggregations.double_range.buckets.2.to
+  - match: { aggregations.double_range.buckets.2.doc_count: 0 }
+
+  - match: { profile.shards.0.aggregations.0.debug.optimized_segments: 1 }
+  - match: { profile.shards.0.aggregations.0.debug.unoptimized_segments: 0 }
+  - match: { profile.shards.0.aggregations.0.debug.leaf_visited: 1 }
+  - match: { profile.shards.0.aggregations.0.debug.inner_visited: 0 }
+
+---
+"Scaled Float Range Aggregation":
+  - do:
+      index:
+        index: test
+        id: 1
+        body: { "scaled_field": 1 }
+
+  - do:
+      index:
+        index: test
+        id: 2
+        body: { "scaled_field": 1.53 }
+
+  - do:
+      index:
+        index: test
+        id: 3
+        body: { "scaled_field": -2.1 }
+
+  - do:
+      index:
+        index: test
+        id: 4
+        body: { "scaled_field": 1.53 }
+
+  - do:
+      indices.refresh: { }
+
+  - do:
+      search:
+        index: test
+        body:
+          size: 0
+          aggs:
+            my_range:
+              range:
+                field: scaled_field
+                ranges:
+                  - to: 0
+                  - from: 0
+                    to: 1
+                  - from: 1
+                    to: 1.5
+                  - from: 1.5
+
+  - length: { aggregations.my_range.buckets: 4 }
+
+  - match: { aggregations.my_range.buckets.0.key: "*-0.0" }
+  - is_false: aggregations.my_range.buckets.0.from
+  - match: { aggregations.my_range.buckets.0.to: 0.0 }
+  - match: { aggregations.my_range.buckets.0.doc_count: 1 }
+  - match: { aggregations.my_range.buckets.1.key: "0.0-1.0" }
+  - match: { aggregations.my_range.buckets.1.from: 0.0 }
+  - match: { aggregations.my_range.buckets.1.to: 1.0 }
+  - match: { aggregations.my_range.buckets.1.doc_count: 0 }
+  - match: { aggregations.my_range.buckets.2.key: "1.0-1.5" }
+  - match: { aggregations.my_range.buckets.2.from: 1.0 }
+  - match: { aggregations.my_range.buckets.2.to: 1.5 }
+  - match: { aggregations.my_range.buckets.2.doc_count: 1 }
+  - match: { aggregations.my_range.buckets.3.key: "1.5-*" }
+  - match: { aggregations.my_range.buckets.3.from: 1.5 }
+  - is_false:  aggregations.my_range.buckets.3.to
+  - match: { aggregations.my_range.buckets.3.doc_count: 2 }
+
+---
+"Filter query w/ aggregation test":
+  - skip:
+      version: " - 2.16.99"
+      reason: "Bugfix not backported to 2.16"
+
+  - do:
+      bulk:
+        refresh: true
+        index: range-agg-w-query
+        body:
+          - '{"index": {}}'
+          - '{"routing": "route1", "v": -10, "date": "2024-10-29"}'
+          - '{"index": {}}'
+          - '{"routing": "route1", "v": -5, "date": "2024-10-30"}'
+          - '{"index": {}}'
+          - '{"routing": "route1", "v": 10, "date": "2024-10-31"}'
+          - '{"index": {}}'
+          - '{"routing": "route2", "v": 15, "date": "2024-11-01"}'
+          - '{"index": {}}'
+          - '{"routing": "route2", "v": 20, "date": "2024-11-02"}'
+
+  - do:
+      search:
+        index: range-agg-w-query
+        body:
+          query:
+            bool:
+              must:
+                match_all: {}
+              filter:
+                - terms:
+                    routing:
+                      - "route1"
+          aggregations:
+            NegPosAgg:
+              range:
+                field: v
+                keyed: true
+                ranges:
+                  - to: 0
+                    key: "0"
+                  - from: 0
+                    key: "1"
+          _source: false
+
+  - match: { hits.total.value: 3 }
+  - match: { aggregations.NegPosAgg.buckets.0.doc_count: 2 }
+  - match: { aggregations.NegPosAgg.buckets.1.doc_count: 1 }
+
+  - do:
+      search:
+        index: range-agg-w-query
+        body:
+          query:
+            bool:
+              must:
+                match_all: {}
+              filter:
+                - terms:
+                    routing:
+                      - "route1"
+          aggregations:
+            HalloweenAgg:
+              date_range:
+                field: date
+                format: "yyyy-MM-dd"
+                keyed: true
+                ranges:
+                  - to: "2024-11-01"
+                    key: "to-october"
+                  - from: "2024-11-01"
+                    key: "from-september"
+          _source: false
+
+  - match: { hits.total.value: 3 }
+  - match: { aggregations.HalloweenAgg.buckets.to-october.doc_count: 3 }
+  - match: { aggregations.HalloweenAgg.buckets.from-september.doc_count: 0 }
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search/190_index_prefix_search.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search/190_index_prefix_search.yml
index 4532a26451c05..5cfe09b8ac371 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search/190_index_prefix_search.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search/190_index_prefix_search.yml
@@ -10,7 +10,12 @@ setup:
                 index_prefixes:
                   min_chars: 2
                   max_chars: 5
-
+              text_with_pos_inc_gap:
+                type: text
+                position_increment_gap: 201
+                index_prefixes:
+                  min_chars: 2
+                  max_chars: 5
   - do:
       index:
           index:  test
@@ -23,6 +28,18 @@ setup:
         id:     2
         body:   { text: sentence with UPPERCASE WORDS }
 
+  - do:
+      index:
+        index:  test
+        id:     3
+        body:   { text: ["foo", "b-12"] }
+
+  - do:
+      index:
+        index:  test
+        id:     4
+        body:   { text_with_pos_inc_gap: ["foo", "b-12"] }
+
   - do:
       indices.refresh:
         index: [test]
@@ -116,3 +133,36 @@ setup:
               ]
 
   - match: {hits.total: 1}
+
+# related issue: https://github.com/opensearch-project/OpenSearch/issues/9203
+---
+"search index prefixes with multiple values":
+  - skip:
+      version: " - 2.99.99"
+      reason: "the bug was fixed in 3.0.0"
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            match_phrase_prefix:
+              text: "b-12"
+
+  - match: {hits.total: 1}
+
+---
+"search index prefixes with multiple values and custom position_increment_gap":
+  - skip:
+      version: " - 2.99.99"
+      reason: "the bug was fixed in 3.0.0"
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            match_phrase_prefix:
+              text_with_pos_inc_gap: "b-12"
+
+  - match: {hits.total: 1}
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search/270_wildcard_fieldtype_queries.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search/270_wildcard_fieldtype_queries.yml
new file mode 100644
index 0000000000000..c449a06cf633d
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search/270_wildcard_fieldtype_queries.yml
@@ -0,0 +1,239 @@
+setup:
+  - skip:
+      version: " - 2.99.99"
+      reason: "Added in 2.15, but need to skip pre-3.0 before backport"
+
+  - do:
+      indices.create:
+        index: test
+        body:
+          mappings:
+            properties:
+              my_field:
+                type: wildcard
+                fields:
+                  lower:
+                    type: wildcard
+                    normalizer: lowercase
+                  doc_values:
+                    type: wildcard
+                    doc_values: true
+
+  - do:
+      index:
+        index: test
+        id: 1
+        body:
+          my_field: "org.opensearch.transport.NodeDisconnectedException: [node_s0][127.0.0.1:39953][disconnected] disconnected"
+  - do:
+      index:
+        index: test
+        id: 2
+        body:
+          my_field: "[2024-06-08T06:31:37,443][INFO ][o.o.c.c.Coordinator      ] [node_s2] cluster-manager node [{node_s0}{Nj7FjR7hRP2lh_zur8KN_g}{OTGOoWmmSsWP_RQ3tIKJ9g}{127.0.0.1}{127.0.0.1:39953}{imr}{shard_indexing_pressure_enabled=true}] failed, restarting discovery"
+
+  - do:
+      index:
+        index: test
+        id: 3
+        body:
+          my_field: "[2024-06-08T06:31:37,451][INFO ][o.o.c.s.ClusterApplierService] [node_s2] cluster-manager node changed {previous [{node_s0}{Nj7FjR7hRP2lh_zur8KN_g}{OTGOoWmmSsWP_RQ3tIKJ9g}{127.0.0.1}{127.0.0.1:39953}{imr}{shard_indexing_pressure_enabled=true}], current []}, term: 1, version: 24, reason: becoming candidate: onLeaderFailure"
+  - do:
+      index:
+        index: test
+        id: 4
+        body:
+          my_field: "[2024-06-08T06:31:37,452][WARN ][o.o.c.NodeConnectionsService] [node_s1] failed to connect to {node_s0}{Nj7FjR7hRP2lh_zur8KN_g}{OTGOoWmmSsWP_RQ3tIKJ9g}{127.0.0.1}{127.0.0.1:39953}{imr}{shard_indexing_pressure_enabled=true} (tried [1] times)"
+  - do:
+      index:
+        index: test
+        id: 5
+        body:
+          my_field: "AbCd"
+  - do:
+      index:
+        index: test
+        id: 6
+        body:
+          other_field: "test"
+  - do:
+      indices.refresh: {}
+
+---
+"term query matches exact value":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            term:
+              my_field: "AbCd"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._id: "5" }
+
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            term:
+              my_field.doc_values: "AbCd"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._id: "5" }
+
+---
+"term query matches lowercase-normalized value":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            term:
+              my_field.lower: "abcd"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._id: "5" }
+
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            term:
+              my_field.lower: "ABCD"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._id: "5" }
+
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            term:
+              my_field: "abcd"
+  - match: { hits.total.value: 0 }
+
+---
+"wildcard query matches":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            wildcard:
+              my_field:
+                value: "*Node*Exception*"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._id: "1" }
+
+---
+"wildcard query matches lowercase-normalized field":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            wildcard:
+              my_field.lower:
+                value: "*node*exception*"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._id: "1" }
+
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            wildcard:
+              my_field.lower:
+                value: "*NODE*EXCEPTION*"
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._id: "1" }
+
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            wildcard:
+              my_field:
+                value: "*node*exception*"
+  - match: { hits.total.value: 0 }
+
+---
+"prefix query matches":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            prefix:
+              my_field:
+                value: "[2024-06-08T"
+  - match: { hits.total.value: 3 }
+
+---
+"regexp query matches":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            regexp:
+              my_field:
+                value: ".*06-08.*cluster-manager node.*"
+  - match: { hits.total.value: 2 }
+
+---
+"regexp query matches lowercase-normalized field":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            regexp:
+              my_field.lower:
+                value: ".*06-08.*Cluster-Manager Node.*"
+  - match: { hits.total.value: 2 }
+
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            regexp:
+              my_field:
+                value: ".*06-08.*Cluster-Manager Node.*"
+  - match: { hits.total.value: 0 }
+
+---
+"wildcard match-all works":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            wildcard:
+              my_field:
+                value: "*"
+  - match: { hits.total.value: 5 }
+---
+"regexp match-all works":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            regexp:
+              my_field:
+                value: ".*"
+  - match: { hits.total.value: 5 }
+---
+"terms query on wildcard field matches":
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            terms: { my_field: ["AbCd"] }
+  - match: { hits.total.value: 1 }
+  - match: { hits.hits.0._id: "5" }
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search/370_approximate_range.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search/370_approximate_range.yml
new file mode 100644
index 0000000000000..ba896dfcad506
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search/370_approximate_range.yml
@@ -0,0 +1,72 @@
+---
+"search with approximate range":
+  - do:
+      indices.create:
+        index: test
+        body:
+          mappings:
+            properties:
+              date:
+                type: date
+                index: true
+                doc_values: true
+
+  - do:
+      bulk:
+        index: test
+        refresh: true
+        body:
+          - '{"index": {"_index": "test", "_id": "1" }}'
+          - '{ "date": "2018-10-29T12:12:12.987Z" }'
+          - '{ "index": { "_index": "test", "_id": "2" }}'
+          - '{ "date": "2020-10-29T12:12:12.987Z" }'
+          - '{ "index": { "_index": "test", "_id": "3" } }'
+          - '{ "date": "2024-10-29T12:12:12.987Z" }'
+
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          query:
+            range: {
+              date: {
+                gte: "2018-10-29T12:12:12.987Z"
+              },
+            }
+
+  - match: { hits.total: 3 }
+
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          sort: [{ date: asc }]
+          query:
+            range: {
+              date: {
+                gte: "2018-10-29T12:12:12.987Z"
+              },
+            }
+
+
+  - match: { hits.total: 3 }
+  - match: { hits.hits.0._id: "1" }
+
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: test
+        body:
+          sort: [{ date: desc }]
+          query:
+            range: {
+              date: {
+                gte: "2018-10-29T12:12:12.987Z",
+                lte: "2020-10-29T12:12:12.987Z"
+              },
+            }
+
+  - match: { hits.total: 2 }
+  - match: { hits.hits.0._id: "2" }
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search/370_bitmap_filtering.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search/370_bitmap_filtering.yml
new file mode 100644
index 0000000000000..d728070adb188
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search/370_bitmap_filtering.yml
@@ -0,0 +1,184 @@
+---
+setup:
+  - skip:
+      version: " - 2.99.99"
+      reason: The bitmap filtering feature is available in 2.17 and later.
+  - do:
+      indices.create:
+        index: students
+        body:
+          settings:
+            number_of_shards: 1
+            number_of_replicas: 0
+          mappings:
+            properties:
+              student_id:
+                type: integer
+  - do:
+      bulk:
+        refresh: true
+        body:
+          - { "index": { "_index": "students", "_id": "1" } }
+          - { "name": "Jane Doe", "student_id": 111 }
+          - { "index": { "_index": "students", "_id": "2" } }
+          - { "name": "Mary Major", "student_id": 222 }
+          - { "index": { "_index": "students", "_id": "3" } }
+          - { "name": "John Doe", "student_id": 333 }
+  - do:
+      indices.create:
+        index: classes
+        body:
+          settings:
+            number_of_shards: 1
+            number_of_replicas: 0
+          mappings:
+            properties:
+              enrolled:
+                type: binary
+                store: true
+  - do:
+      bulk:
+        refresh: true
+        body:
+          - { "index": { "_index": "classes", "_id": "101" } }
+          -  { "enrolled": "OjAAAAEAAAAAAAEAEAAAAG8A3gA=" } # 111,222
+          -  { "index": { "_index": "classes", "_id": "102" } }
+          -  { "enrolled": "OjAAAAEAAAAAAAAAEAAAAG8A" }     # 111
+          -  { "index": { "_index": "classes", "_id": "103" } }
+          -  { "enrolled": "OjAAAAEAAAAAAAAAEAAAAE0B" }     # 333
+          -  { "index": { "_index": "classes", "_id": "104" } }
+          -  { "enrolled": "OjAAAAEAAAAAAAEAEAAAAN4ATQE=" } # 222,333
+  - do:
+      cluster.health:
+        wait_for_status: green
+
+---
+"Terms lookup on a binary field with bitmap":
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: students
+        body: {
+          "query": {
+            "terms": {
+              "student_id": {
+                "index": "classes",
+                "id": "101",
+                "path": "enrolled",
+                "store": true
+              },
+              "value_type": "bitmap"
+            }
+          }
+        }
+  - match: { hits.total: 2 }
+  - match: { hits.hits.0._source.name: Jane Doe }
+  - match: { hits.hits.0._source.student_id: 111 }
+  - match: { hits.hits.1._source.name: Mary Major }
+  - match: { hits.hits.1._source.student_id: 222 }
+
+---
+"Terms query accepting bitmap as value":
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: students
+        body: {
+          "query": {
+            "terms": {
+              "student_id": ["OjAAAAEAAAAAAAEAEAAAAG8A3gA="],
+              "value_type": "bitmap"
+            }
+          }
+        }
+  - match: { hits.total: 2 }
+  - match: { hits.hits.0._source.name: Jane Doe }
+  - match: { hits.hits.0._source.student_id: 111 }
+  - match: { hits.hits.1._source.name: Mary Major }
+  - match: { hits.hits.1._source.student_id: 222 }
+
+---
+"Boolean must bitmap filtering":
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: students
+        body: {
+          "query": {
+            "bool": {
+              "must": [
+                {
+                  "terms": {
+                    "student_id": {
+                      "index": "classes",
+                      "id": "101",
+                      "path": "enrolled",
+                      "store": true
+                    },
+                    "value_type": "bitmap"
+                  }
+                }
+              ],
+              "must_not": [
+                {
+                  "terms": {
+                    "student_id": {
+                      "index": "classes",
+                      "id": "104",
+                      "path": "enrolled",
+                      "store": true
+                    },
+                    "value_type": "bitmap"
+                  }
+                }
+              ]
+            }
+          }
+        }
+  - match: { hits.total: 1 }
+  - match: { hits.hits.0._source.name: Jane Doe }
+  - match: { hits.hits.0._source.student_id: 111 }
+
+---
+"Boolean should bitmap filtering":
+  - do:
+      search:
+        rest_total_hits_as_int: true
+        index: students
+        body: {
+          "query": {
+            "bool": {
+              "should": [
+                {
+                  "terms": {
+                    "student_id": {
+                      "index": "classes",
+                      "id": "101",
+                      "path": "enrolled",
+                      "store": true
+                    },
+                    "value_type": "bitmap"
+                  }
+                },
+                {
+                  "terms": {
+                    "student_id": {
+                      "index": "classes",
+                      "id": "104",
+                      "path": "enrolled",
+                      "store": true
+                    },
+                    "value_type": "bitmap"
+                  }
+                }
+              ]
+            }
+          }
+        }
+  - match: { hits.total: 3 }
+  - match: { hits.hits.0._source.name: Mary Major }
+  - match: { hits.hits.0._source.student_id: 222 }
+  - match: { hits.hits.1._source.name: Jane Doe }
+  - match: { hits.hits.1._source.student_id: 111 }
+  - match: { hits.hits.2._source.name: John Doe }
+  - match: { hits.hits.2._source.student_id: 333 }
diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search/50_multi_match.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search/50_multi_match.yml
new file mode 100644
index 0000000000000..34acb5985b555
--- /dev/null
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search/50_multi_match.yml
@@ -0,0 +1,35 @@
+"Cross fields do not return negative scores":
+  - skip:
+      version: " - 2.99.99"
+      reason: "This fix is in 2.15. Until we do the BWC dance, we need to skip all pre-3.0, though."
+  - do:
+      index:
+        index: test
+        id: 1
+        body: { "color" : "orange red yellow" }
+  - do:
+      index:
+        index: test
+        id: 2
+        body: { "color": "orange red purple", "shape": "red square" }
+  - do:
+      index:
+        index: test
+        id: 3
+        body: { "color" : "orange red yellow purple" }
+  - do:
+      indices.refresh: { }
+  - do:
+      search:
+        index: test
+        body:
+          query:
+            multi_match:
+              query: "red"
+              type: "cross_fields"
+              fields: [ "color", "shape^100"]
+              tie_breaker: 0.1
+          explain: true
+  - match: { hits.total.value: 3 }
+  - match: { hits.hits.0._id: "2" }
+  - gt: { hits.hits.2._score: 0.0 }
diff --git a/server/build.gradle b/server/build.gradle
index 50a7999322629..a96ff29e6fdd5 100644
--- a/server/build.gradle
+++ b/server/build.gradle
@@ -36,7 +36,7 @@ plugins {
   id('opensearch.publish')
   id('opensearch.internal-cluster-test')
   id('opensearch.optional-dependencies')
-  id('me.champeau.gradle.japicmp') version '0.4.2'
+  id('me.champeau.gradle.japicmp') version '0.4.3'
 }
 
 publishing {
@@ -96,9 +96,9 @@ dependencies {
   api "joda-time:joda-time:${versions.joda}"
 
   // percentiles aggregation
-  api 'com.tdunning:t-digest:3.2'
-  // precentil ranks aggregation
-  api 'org.hdrhistogram:HdrHistogram:2.2.1'
+  api "com.tdunning:t-digest:${versions.tdigest}"
+  // percentile ranks aggregation
+  api "org.hdrhistogram:HdrHistogram:${versions.hdrhistogram}"
 
   // lucene spatial
   api "org.locationtech.spatial4j:spatial4j:${versions.spatial4j}", optional
@@ -125,6 +125,9 @@ dependencies {
   api "com.google.protobuf:protobuf-java:${versions.protobuf}"
   api "jakarta.annotation:jakarta.annotation-api:${versions.jakarta_annotation}"
 
+  // https://mvnrepository.com/artifact/org.roaringbitmap/RoaringBitmap
+  implementation 'org.roaringbitmap:RoaringBitmap:1.2.1'
+
   testImplementation(project(":test:framework")) {
     // tests use the locally compiled version of server
     exclude group: 'org.opensearch', module: 'server'
@@ -393,14 +396,18 @@ tasks.named("thirdPartyAudit").configure {
 }
 
 tasks.named("dependencyLicenses").configure {
+    mapping from: /jackson-.*/, to: 'jackson'
     mapping from: /reactor-.*/, to: 'reactor'
     mapping from: /lucene-.*/, to: 'lucene'
-    dependencies = project.configurations.runtimeClasspath.fileCollection {
-        it.group.startsWith('org.opensearch') == false ||
-                // keep the following org.opensearch jars in
-                (it.name == 'jna' ||
-                        it.name == 'securesm')
-    }
+    dependencies = project.configurations.runtimeClasspath.incoming.artifactView {
+        componentFilter {
+            it instanceof ModuleComponentIdentifier &&
+                (it.group.startsWith('org.opensearch') == false ||
+                    // keep the following org.opensearch jars in
+                    (it.name == 'jna' ||
+                            it.name == 'securesm'))
+        }
+    }.files
 }
 
 tasks.named("filepermissions").configure {
@@ -441,6 +448,7 @@ tasks.register("japicmp", me.champeau.gradle.japicmp.JapicmpTask) {
     failOnModification = true
     ignoreMissingClasses = true
     annotationIncludes = ['@org.opensearch.common.annotation.PublicApi', '@org.opensearch.common.annotation.DeprecatedApi']
+    annotationExcludes = ['@org.opensearch.common.annotation.InternalApi']
     txtOutputFile = layout.buildDirectory.file("reports/java-compatibility/report.txt")
     htmlOutputFile = layout.buildDirectory.file("reports/java-compatibility/report.html")
     dependsOn downloadJapicmpCompareTarget
diff --git a/server/licenses/HdrHistogram-2.2.1.jar.sha1 b/server/licenses/HdrHistogram-2.2.1.jar.sha1
deleted file mode 100644
index 68225950d4744..0000000000000
--- a/server/licenses/HdrHistogram-2.2.1.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-0eb1feb351f64176c377772a30174e582c0274d5
\ No newline at end of file
diff --git a/server/licenses/HdrHistogram-2.2.2.jar.sha1 b/server/licenses/HdrHistogram-2.2.2.jar.sha1
new file mode 100644
index 0000000000000..2c895841bce81
--- /dev/null
+++ b/server/licenses/HdrHistogram-2.2.2.jar.sha1
@@ -0,0 +1 @@
+7959933ebcc0f05b2eaa5af0a0c8689fa257b15c
diff --git a/server/licenses/RoaringBitmap-1.2.1.jar.sha1 b/server/licenses/RoaringBitmap-1.2.1.jar.sha1
new file mode 100644
index 0000000000000..ef8cd48c7a388
--- /dev/null
+++ b/server/licenses/RoaringBitmap-1.2.1.jar.sha1
@@ -0,0 +1 @@
+828eb489b5e8c8762f2471010e9c7f20c7de596d
\ No newline at end of file
diff --git a/server/licenses/RoaringBitmap-LICENSE.txt b/server/licenses/RoaringBitmap-LICENSE.txt
new file mode 100644
index 0000000000000..3bdd0036295a6
--- /dev/null
+++ b/server/licenses/RoaringBitmap-LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2013-2016 the RoaringBitmap authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/server/licenses/RoaringBitmap-NOTICE.txt b/server/licenses/RoaringBitmap-NOTICE.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/server/licenses/jackson-LICENSE b/server/licenses/jackson-LICENSE
new file mode 100644
index 0000000000000..f5f45d26a49d6
--- /dev/null
+++ b/server/licenses/jackson-LICENSE
@@ -0,0 +1,8 @@
+This copy of Jackson JSON processor streaming parser/generator is licensed under the
+Apache (Software) License, version 2.0 ("the License").
+See the License for details about distribution rights, and the
+specific rights regarding derivate works.
+
+You may obtain a copy of the License at:
+
+http://www.apache.org/licenses/LICENSE-2.0
diff --git a/server/licenses/jackson-NOTICE b/server/licenses/jackson-NOTICE
new file mode 100644
index 0000000000000..4c976b7b4cc58
--- /dev/null
+++ b/server/licenses/jackson-NOTICE
@@ -0,0 +1,20 @@
+# Jackson JSON processor
+
+Jackson is a high-performance, Free/Open Source JSON processing library.
+It was originally written by Tatu Saloranta (tatu.saloranta@iki.fi), and has
+been in development since 2007.
+It is currently developed by a community of developers, as well as supported
+commercially by FasterXML.com.
+
+## Licensing
+
+Jackson core and extension components may licensed under different licenses.
+To find the details that apply to this artifact see the accompanying LICENSE file.
+For more information, including possible other licensing options, contact
+FasterXML.com (http://fasterxml.com).
+
+## Credits
+
+A list of contributors may be found from CREDITS file, which is included
+in some artifacts (usually source distributions); but is always available
+from the source code management (SCM) system project uses.
diff --git a/server/licenses/jackson-core-2.17.2.jar.sha1 b/server/licenses/jackson-core-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..e15f2340980bc
--- /dev/null
+++ b/server/licenses/jackson-core-2.17.2.jar.sha1
@@ -0,0 +1 @@
+969a35cb35c86512acbadcdbbbfb044c877db814
\ No newline at end of file
diff --git a/server/licenses/jackson-dataformat-cbor-2.17.2.jar.sha1 b/server/licenses/jackson-dataformat-cbor-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..069e088413ef1
--- /dev/null
+++ b/server/licenses/jackson-dataformat-cbor-2.17.2.jar.sha1
@@ -0,0 +1 @@
+57fa7c1b5104bbc4599278d13933a937ee058e68
\ No newline at end of file
diff --git a/server/licenses/jackson-dataformat-smile-2.17.2.jar.sha1 b/server/licenses/jackson-dataformat-smile-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..28d8c8382aed3
--- /dev/null
+++ b/server/licenses/jackson-dataformat-smile-2.17.2.jar.sha1
@@ -0,0 +1 @@
+20e956b9b6f67138edd39fab7a506ded19638bcb
\ No newline at end of file
diff --git a/server/licenses/jackson-dataformat-yaml-2.17.2.jar.sha1 b/server/licenses/jackson-dataformat-yaml-2.17.2.jar.sha1
new file mode 100644
index 0000000000000..f3e25b7eb253c
--- /dev/null
+++ b/server/licenses/jackson-dataformat-yaml-2.17.2.jar.sha1
@@ -0,0 +1 @@
+78d2c73dbec62044d7cf3b544b2e0d24a1a093b0
\ No newline at end of file
diff --git a/server/licenses/jopt-simple-5.0.4.jar.sha1 b/server/licenses/jopt-simple-5.0.4.jar.sha1
new file mode 100644
index 0000000000000..7ade81efe4d0d
--- /dev/null
+++ b/server/licenses/jopt-simple-5.0.4.jar.sha1
@@ -0,0 +1 @@
+4fdac2fbe92dfad86aa6e9301736f6b4342a3f5c
\ No newline at end of file
diff --git a/server/licenses/jopt-simple-LICENSE.txt b/server/licenses/jopt-simple-LICENSE.txt
new file mode 100644
index 0000000000000..85f923a95268a
--- /dev/null
+++ b/server/licenses/jopt-simple-LICENSE.txt
@@ -0,0 +1,24 @@
+/*
+ The MIT License
+
+ Copyright (c) 2004-2015 Paul R. Holser, Jr.
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
diff --git a/server/licenses/jopt-simple-NOTICE.txt b/server/licenses/jopt-simple-NOTICE.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/server/licenses/lucene-analysis-common-9.10.0.jar.sha1 b/server/licenses/lucene-analysis-common-9.10.0.jar.sha1
deleted file mode 100644
index d33a965b3506c..0000000000000
--- a/server/licenses/lucene-analysis-common-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-92e559808a23f61c818ef90a9ccab3669a25caa0
\ No newline at end of file
diff --git a/server/licenses/lucene-analysis-common-9.11.1.jar.sha1 b/server/licenses/lucene-analysis-common-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..4de19f1f8ab33
--- /dev/null
+++ b/server/licenses/lucene-analysis-common-9.11.1.jar.sha1
@@ -0,0 +1 @@
+51286aca019db66311f71496191b4bd7adaf3dcf
\ No newline at end of file
diff --git a/server/licenses/lucene-backward-codecs-9.10.0.jar.sha1 b/server/licenses/lucene-backward-codecs-9.10.0.jar.sha1
deleted file mode 100644
index 01b6cbb54f3e9..0000000000000
--- a/server/licenses/lucene-backward-codecs-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-6570ebf974d07025ad4cd9ffaa9927546b534704
\ No newline at end of file
diff --git a/server/licenses/lucene-backward-codecs-9.11.1.jar.sha1 b/server/licenses/lucene-backward-codecs-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..9059fc3393307
--- /dev/null
+++ b/server/licenses/lucene-backward-codecs-9.11.1.jar.sha1
@@ -0,0 +1 @@
+948fda53ceeb0fa1b835af5376abec771b2c3fb1
\ No newline at end of file
diff --git a/server/licenses/lucene-core-9.10.0.jar.sha1 b/server/licenses/lucene-core-9.10.0.jar.sha1
deleted file mode 100644
index 31b6bcd29f418..0000000000000
--- a/server/licenses/lucene-core-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-64e5624754d59386be5d9159c68f81ff96298704
\ No newline at end of file
diff --git a/server/licenses/lucene-core-9.11.1.jar.sha1 b/server/licenses/lucene-core-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..82de964a2b755
--- /dev/null
+++ b/server/licenses/lucene-core-9.11.1.jar.sha1
@@ -0,0 +1 @@
+8f52ba14b21774f41ce33cf5ca111cbdefeed7f9
\ No newline at end of file
diff --git a/server/licenses/lucene-grouping-9.10.0.jar.sha1 b/server/licenses/lucene-grouping-9.10.0.jar.sha1
deleted file mode 100644
index 21f2062273355..0000000000000
--- a/server/licenses/lucene-grouping-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-b82838299e4fa423fc574c1c07405410823f74ce
\ No newline at end of file
diff --git a/server/licenses/lucene-grouping-9.11.1.jar.sha1 b/server/licenses/lucene-grouping-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..0e37fd52666a4
--- /dev/null
+++ b/server/licenses/lucene-grouping-9.11.1.jar.sha1
@@ -0,0 +1 @@
+0bdf9db0134523d2a41123dca1018f4c771c7b23
\ No newline at end of file
diff --git a/server/licenses/lucene-highlighter-9.10.0.jar.sha1 b/server/licenses/lucene-highlighter-9.10.0.jar.sha1
deleted file mode 100644
index 2148a8ef957f0..0000000000000
--- a/server/licenses/lucene-highlighter-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-2f21ade4b4896f1ece2b3a823e1640c762c9d0cf
\ No newline at end of file
diff --git a/server/licenses/lucene-highlighter-9.11.1.jar.sha1 b/server/licenses/lucene-highlighter-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..d6f2dab59539f
--- /dev/null
+++ b/server/licenses/lucene-highlighter-9.11.1.jar.sha1
@@ -0,0 +1 @@
+e16cc9c531998a76eb5528147b5f07596f95fad8
\ No newline at end of file
diff --git a/server/licenses/lucene-join-9.10.0.jar.sha1 b/server/licenses/lucene-join-9.10.0.jar.sha1
deleted file mode 100644
index 93b8f50522800..0000000000000
--- a/server/licenses/lucene-join-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-541b722bb842817e2ec899cd4d0de2a136953f53
\ No newline at end of file
diff --git a/server/licenses/lucene-join-9.11.1.jar.sha1 b/server/licenses/lucene-join-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..59fe75206ca0a
--- /dev/null
+++ b/server/licenses/lucene-join-9.11.1.jar.sha1
@@ -0,0 +1 @@
+f7d63c04f3cc2ec8d7df73178db20de34cf60667
\ No newline at end of file
diff --git a/server/licenses/lucene-memory-9.10.0.jar.sha1 b/server/licenses/lucene-memory-9.10.0.jar.sha1
deleted file mode 100644
index 82ca74ccdfc42..0000000000000
--- a/server/licenses/lucene-memory-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-06620029b6c7d84480fb7ad1ba0d72963111b765
\ No newline at end of file
diff --git a/server/licenses/lucene-memory-9.11.1.jar.sha1 b/server/licenses/lucene-memory-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..342fa399d1eec
--- /dev/null
+++ b/server/licenses/lucene-memory-9.11.1.jar.sha1
@@ -0,0 +1 @@
+4221baad5c40849f641f0f5c1b8e2f2dfcf1e73a
\ No newline at end of file
diff --git a/server/licenses/lucene-misc-9.10.0.jar.sha1 b/server/licenses/lucene-misc-9.10.0.jar.sha1
deleted file mode 100644
index 2d69a4cfa1148..0000000000000
--- a/server/licenses/lucene-misc-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-3621206c534d253a0205f8a0293c146ff34d8b03
\ No newline at end of file
diff --git a/server/licenses/lucene-misc-9.11.1.jar.sha1 b/server/licenses/lucene-misc-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..c8b6b747cae8b
--- /dev/null
+++ b/server/licenses/lucene-misc-9.11.1.jar.sha1
@@ -0,0 +1 @@
+a3ecdb999c3d3435ead88771ce215834bd8be7b8
\ No newline at end of file
diff --git a/server/licenses/lucene-queries-9.10.0.jar.sha1 b/server/licenses/lucene-queries-9.10.0.jar.sha1
deleted file mode 100644
index d7c38977e4fc8..0000000000000
--- a/server/licenses/lucene-queries-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-bbe2360c60a43bf41fbf05d5f0b4f471547217ba
\ No newline at end of file
diff --git a/server/licenses/lucene-queries-9.11.1.jar.sha1 b/server/licenses/lucene-queries-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..d21f8bb64fad2
--- /dev/null
+++ b/server/licenses/lucene-queries-9.11.1.jar.sha1
@@ -0,0 +1 @@
+027fc885a0442a0442f426f7fea9743f6fcf3c43
\ No newline at end of file
diff --git a/server/licenses/lucene-queryparser-9.10.0.jar.sha1 b/server/licenses/lucene-queryparser-9.10.0.jar.sha1
deleted file mode 100644
index b02a3cd926375..0000000000000
--- a/server/licenses/lucene-queryparser-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-c50f82d244ea5adac2d2d9295de85ddccc2d45cb
\ No newline at end of file
diff --git a/server/licenses/lucene-queryparser-9.11.1.jar.sha1 b/server/licenses/lucene-queryparser-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..b9480ba05f067
--- /dev/null
+++ b/server/licenses/lucene-queryparser-9.11.1.jar.sha1
@@ -0,0 +1 @@
+ad6e5b135e1e284d4462d717086ce13a3ce01b4a
\ No newline at end of file
diff --git a/server/licenses/lucene-sandbox-9.10.0.jar.sha1 b/server/licenses/lucene-sandbox-9.10.0.jar.sha1
deleted file mode 100644
index 74b9e925398b1..0000000000000
--- a/server/licenses/lucene-sandbox-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-80bc56b23b34cddab97557e5ada7cd0558dbf5e5
\ No newline at end of file
diff --git a/server/licenses/lucene-sandbox-9.11.1.jar.sha1 b/server/licenses/lucene-sandbox-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..1cf3a0e6dd381
--- /dev/null
+++ b/server/licenses/lucene-sandbox-9.11.1.jar.sha1
@@ -0,0 +1 @@
+9d6a88d9cb7f206c12d13c4fe48f8c7a973ebdb5
\ No newline at end of file
diff --git a/server/licenses/lucene-spatial-extras-9.10.0.jar.sha1 b/server/licenses/lucene-spatial-extras-9.10.0.jar.sha1
deleted file mode 100644
index 76e9fea920bb8..0000000000000
--- a/server/licenses/lucene-spatial-extras-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-055e6aa874b6ec9ddafc2e115055de1445c2df49
\ No newline at end of file
diff --git a/server/licenses/lucene-spatial-extras-9.11.1.jar.sha1 b/server/licenses/lucene-spatial-extras-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..30600cfd91dea
--- /dev/null
+++ b/server/licenses/lucene-spatial-extras-9.11.1.jar.sha1
@@ -0,0 +1 @@
+d3938d4f63a29a6e8396416ec6e6e835826e7734
\ No newline at end of file
diff --git a/server/licenses/lucene-spatial3d-9.10.0.jar.sha1 b/server/licenses/lucene-spatial3d-9.10.0.jar.sha1
deleted file mode 100644
index 3268b8bd557d0..0000000000000
--- a/server/licenses/lucene-spatial3d-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-06945a8b2a703062ce4b286ecceae7182b4f5f44
\ No newline at end of file
diff --git a/server/licenses/lucene-spatial3d-9.11.1.jar.sha1 b/server/licenses/lucene-spatial3d-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..eea332a853803
--- /dev/null
+++ b/server/licenses/lucene-spatial3d-9.11.1.jar.sha1
@@ -0,0 +1 @@
+d9c48cf29e8736e6ce6cd81c614367b10210523c
\ No newline at end of file
diff --git a/server/licenses/lucene-suggest-9.10.0.jar.sha1 b/server/licenses/lucene-suggest-9.10.0.jar.sha1
deleted file mode 100644
index aaa10c449adb3..0000000000000
--- a/server/licenses/lucene-suggest-9.10.0.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-d2068ad997165a414927e8c0072d0b88741af069
\ No newline at end of file
diff --git a/server/licenses/lucene-suggest-9.11.1.jar.sha1 b/server/licenses/lucene-suggest-9.11.1.jar.sha1
new file mode 100644
index 0000000000000..7b401a4be996f
--- /dev/null
+++ b/server/licenses/lucene-suggest-9.11.1.jar.sha1
@@ -0,0 +1 @@
+9cceafd67d032d2a507e81f797e05eb284849987
\ No newline at end of file
diff --git a/server/licenses/reactor-core-3.5.17.jar.sha1 b/server/licenses/reactor-core-3.5.17.jar.sha1
deleted file mode 100644
index 6663356bab047..0000000000000
--- a/server/licenses/reactor-core-3.5.17.jar.sha1
+++ /dev/null
@@ -1 +0,0 @@
-2cf9b080e3a2d8a5a39948260db5fd1dae54c3ac
\ No newline at end of file
diff --git a/server/licenses/reactor-core-3.5.20.jar.sha1 b/server/licenses/reactor-core-3.5.20.jar.sha1
new file mode 100644
index 0000000000000..0c80be89f66c8
--- /dev/null
+++ b/server/licenses/reactor-core-3.5.20.jar.sha1
@@ -0,0 +1 @@
+1fc0f91e2b93778a974339d2c24363d7f34f90b4
\ No newline at end of file
diff --git a/server/licenses/snakeyaml-2.1.jar.sha1 b/server/licenses/snakeyaml-2.1.jar.sha1
new file mode 100644
index 0000000000000..5586b210a9736
--- /dev/null
+++ b/server/licenses/snakeyaml-2.1.jar.sha1
@@ -0,0 +1 @@
+c79f47315517560b5bd6a62376ee385e48105437
\ No newline at end of file
diff --git a/server/licenses/snakeyaml-LICENSE.txt b/server/licenses/snakeyaml-LICENSE.txt
new file mode 100644
index 0000000000000..d9a10c0d8e868
--- /dev/null
+++ b/server/licenses/snakeyaml-LICENSE.txt
@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/server/licenses/snakeyaml-NOTICE.txt b/server/licenses/snakeyaml-NOTICE.txt
new file mode 100644
index 0000000000000..b51464eee1f00
--- /dev/null
+++ b/server/licenses/snakeyaml-NOTICE.txt
@@ -0,0 +1,24 @@
+***The art of simplicity is a puzzle of complexity.***
+
+## Overview ##
+[YAML](http://yaml.org) is a data serialization format designed for human readability and interaction with scripting languages.
+
+SnakeYAML is a YAML processor for the Java Virtual Machine.
+
+## SnakeYAML features ##
+
+* a **complete** [YAML 1.1 processor](http://yaml.org/spec/1.1/current.html). In particular, SnakeYAML can parse all examples from the specification.
+* Unicode support including UTF-8/UTF-16 input/output.
+* high-level API for serializing and deserializing native Java objects.
+* support for all types from the [YAML types repository](http://yaml.org/type/index.html).
+* relatively sensible error messages.
+
+## Info ##
+ * [Changes](https://bitbucket.org/asomov/snakeyaml/wiki/Changes)
+ * [Documentation](https://bitbucket.org/asomov/snakeyaml/wiki/Documentation)
+
+## Contribute ##
+* Mercurial DVCS is used to dance with the [source code](https://bitbucket.org/asomov/snakeyaml/src).
+* If you find a bug in SnakeYAML, please [file a bug report](https://bitbucket.org/asomov/snakeyaml/issues?status=new&status=open).
+* You may discuss SnakeYAML at
+[the mailing list](http://groups.google.com/group/snakeyaml-core).
\ No newline at end of file
diff --git a/server/licenses/zstd-jni-1.5.5-5.jar.sha1 b/server/licenses/zstd-jni-1.5.5-5.jar.sha1
new file mode 100644
index 0000000000000..498c60c34e3da
--- /dev/null
+++ b/server/licenses/zstd-jni-1.5.5-5.jar.sha1
@@ -0,0 +1 @@
+74ffdc5f140080adacf5278287aadd950179f848
\ No newline at end of file
diff --git a/server/licenses/zstd-jni-LICENSE.txt b/server/licenses/zstd-jni-LICENSE.txt
new file mode 100644
index 0000000000000..c4dd507c1c72f
--- /dev/null
+++ b/server/licenses/zstd-jni-LICENSE.txt
@@ -0,0 +1,29 @@
+-----------------------------------------------------------------------------
+** Beginning of "BSD License" text. **
+
+Zstd-jni: JNI bindings to Zstd Library
+
+Copyright (c) 2015-present, Luben Karavelov/ All rights reserved.
+
+BSD License
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/server/licenses/zstd-jni-NOTICE.txt b/server/licenses/zstd-jni-NOTICE.txt
new file mode 100644
index 0000000000000..389c97cbc892d
--- /dev/null
+++ b/server/licenses/zstd-jni-NOTICE.txt
@@ -0,0 +1 @@
+The code for the JNI bindings to Zstd library was originally authored by Luben Karavelov
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/IndicesRequestIT.java b/server/src/internalClusterTest/java/org/opensearch/action/IndicesRequestIT.java
index 6e4d66b74d7c1..89249dd76caac 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/IndicesRequestIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/IndicesRequestIT.java
@@ -84,6 +84,8 @@
 import org.opensearch.action.search.SearchResponse;
 import org.opensearch.action.search.SearchTransportService;
 import org.opensearch.action.search.SearchType;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionAction;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionRequest;
 import org.opensearch.action.support.replication.TransportReplicationActionTests;
 import org.opensearch.action.termvectors.MultiTermVectorsAction;
 import org.opensearch.action.termvectors.MultiTermVectorsRequest;
@@ -195,6 +197,7 @@ public void cleanUp() {
     }
 
     public void testGetFieldMappings() {
+
         String getFieldMappingsShardAction = GetFieldMappingsAction.NAME + "[index][s]";
         interceptTransportActions(getFieldMappingsShardAction);
 
@@ -545,13 +548,14 @@ public void testDeleteIndex() {
     }
 
     public void testGetMappings() {
-        interceptTransportActions(GetMappingsAction.NAME);
-
+        interceptTransportActions(GetTermVersionAction.NAME, GetMappingsAction.NAME);
         GetMappingsRequest getMappingsRequest = new GetMappingsRequest().indices(randomIndicesOrAliases());
         internalCluster().coordOnlyNodeClient().admin().indices().getMappings(getMappingsRequest).actionGet();
 
         clearInterceptedActions();
-        assertSameIndices(getMappingsRequest, GetMappingsAction.NAME);
+
+        assertActionInvocation(GetTermVersionAction.NAME, GetTermVersionRequest.class);
+        assertNoActionInvocation(GetMappingsAction.NAME);
     }
 
     public void testPutMapping() {
@@ -565,8 +569,8 @@ public void testPutMapping() {
     }
 
     public void testGetSettings() {
-        interceptTransportActions(GetSettingsAction.NAME);
 
+        interceptTransportActions(GetSettingsAction.NAME);
         GetSettingsRequest getSettingsRequest = new GetSettingsRequest().indices(randomIndicesOrAliases());
         internalCluster().coordOnlyNodeClient().admin().indices().getSettings(getSettingsRequest).actionGet();
 
@@ -662,6 +666,21 @@ private static void assertSameIndices(IndicesRequest originalRequest, boolean op
         }
     }
 
+    private static void assertActionInvocation(String action, Class<? extends TransportRequest> requestClass) {
+        List<TransportRequest> requests = consumeTransportRequests(action);
+        assertFalse(requests.isEmpty());
+        for (TransportRequest internalRequest : requests) {
+            assertTrue(internalRequest.getClass() == requestClass);
+        }
+    }
+
+    private static void assertNoActionInvocation(String... actions) {
+        for (String action : actions) {
+            List<TransportRequest> requests = consumeTransportRequests(action);
+            assertTrue(requests.isEmpty());
+        }
+    }
+
     private static void assertIndicesSubset(List<String> indices, String... actions) {
         // indices returned by each bulk shard request need to be a subset of the original indices
         for (String action : actions) {
@@ -781,7 +800,6 @@ public List<TransportInterceptor> getTransportInterceptors(
         }
 
         private final Set<String> actions = new HashSet<>();
-
         private final Map<String, List<TransportRequest>> requests = new HashMap<>();
 
         @Override
@@ -831,6 +849,7 @@ public void messageReceived(T request, TransportChannel channel, Task task) thro
                     }
                 }
                 requestHandler.messageReceived(request, channel, task);
+
             }
         }
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksIT.java
index bdb36b62ada21..d8a4bed4740bf 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksIT.java
@@ -327,7 +327,7 @@ public void testFailedToStartChildTaskAfterCancelled() throws Exception {
         mainAction.startSubTask(taskId, subRequest, future);
         TransportException te = expectThrows(TransportException.class, future::actionGet);
         assertThat(te.getCause(), instanceOf(TaskCancelledException.class));
-        assertThat(te.getCause().getMessage(), equalTo("The parent task was cancelled, shouldn't start any child tasks"));
+        assertThat(te.getCause().getMessage(), equalTo("The parent task was cancelled, shouldn't start any child tasks, by user request"));
         allowEntireRequest(rootRequest);
         waitForRootTask(rootTaskFuture);
         ensureAllBansRemoved();
@@ -386,7 +386,7 @@ static void waitForRootTask(ActionFuture<TestResponse> rootTask) {
             assertThat(
                 cause.getMessage(),
                 anyOf(
-                    equalTo("The parent task was cancelled, shouldn't start any child tasks"),
+                    equalTo("The parent task was cancelled, shouldn't start any child tasks, by user request"),
                     containsString("Task cancelled before it started:"),
                     equalTo("Task was cancelled while executing")
                 )
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/repositories/RepositoryBlocksIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/repositories/RepositoryBlocksIT.java
index 36fe3748e9d10..6c0a156eb6752 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/repositories/RepositoryBlocksIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/repositories/RepositoryBlocksIT.java
@@ -55,13 +55,17 @@ public void testPutRepositoryWithBlocks() {
         logger.info("-->  registering a repository is blocked when the cluster is read only");
         try {
             setClusterReadOnly(true);
+            Settings.Builder settings = Settings.builder().put("location", randomRepoPath());
             assertBlocked(
-                client().admin()
-                    .cluster()
-                    .preparePutRepository("test-repo-blocks")
-                    .setType("fs")
-                    .setVerify(false)
-                    .setSettings(Settings.builder().put("location", randomRepoPath())),
+                OpenSearchIntegTestCase.putRepositoryRequestBuilder(
+                    client().admin().cluster(),
+                    "test-repo-blocks",
+                    "fs",
+                    false,
+                    settings,
+                    null,
+                    false
+                ),
                 Metadata.CLUSTER_READ_ONLY_BLOCK
             );
         } finally {
@@ -69,25 +73,13 @@ public void testPutRepositoryWithBlocks() {
         }
 
         logger.info("-->  registering a repository is allowed when the cluster is not read only");
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo-blocks")
-                .setType("fs")
-                .setVerify(false)
-                .setSettings(Settings.builder().put("location", randomRepoPath()))
-        );
+        Settings.Builder settings = Settings.builder().put("location", randomRepoPath());
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo-blocks", "fs", false, settings);
     }
 
     public void testVerifyRepositoryWithBlocks() {
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo-blocks")
-                .setType("fs")
-                .setVerify(false)
-                .setSettings(Settings.builder().put("location", randomRepoPath()))
-        );
+        Settings.Builder settings = Settings.builder().put("location", randomRepoPath());
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo-blocks", "fs", false, settings);
 
         // This test checks that the Get Repository operation is never blocked, even if the cluster is read only.
         try {
@@ -104,14 +96,8 @@ public void testVerifyRepositoryWithBlocks() {
     }
 
     public void testDeleteRepositoryWithBlocks() {
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo-blocks")
-                .setType("fs")
-                .setVerify(false)
-                .setSettings(Settings.builder().put("location", randomRepoPath()))
-        );
+        Settings.Builder settings = Settings.builder().put("location", randomRepoPath());
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo-blocks", "fs", false, settings);
 
         logger.info("-->  deleting a repository is blocked when the cluster is read only");
         try {
@@ -126,14 +112,8 @@ public void testDeleteRepositoryWithBlocks() {
     }
 
     public void testGetRepositoryWithBlocks() {
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo-blocks")
-                .setType("fs")
-                .setVerify(false)
-                .setSettings(Settings.builder().put("location", randomRepoPath()))
-        );
+        Settings.Builder settings = Settings.builder().put("location", randomRepoPath());
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), "test-repo-blocks", "fs", false, settings);
 
         // This test checks that the Get Repository operation is never blocked, even if the cluster is read only.
         try {
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsActionIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsActionIT.java
new file mode 100644
index 0000000000000..b86521dedf739
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsActionIT.java
@@ -0,0 +1,129 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.cluster.shards;
+
+import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.Strings;
+import org.opensearch.core.tasks.TaskCancelledException;
+import org.opensearch.test.InternalTestCluster;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+import static org.opensearch.cluster.routing.UnassignedInfo.INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING;
+import static org.opensearch.common.unit.TimeValue.timeValueMillis;
+import static org.opensearch.search.SearchService.NO_TIMEOUT;
+
+@OpenSearchIntegTestCase.ClusterScope(numDataNodes = 0, scope = OpenSearchIntegTestCase.Scope.TEST)
+public class TransportCatShardsActionIT extends OpenSearchIntegTestCase {
+
+    public void testCatShardsWithSuccessResponse() throws InterruptedException {
+        internalCluster().startClusterManagerOnlyNodes(1);
+        List<String> nodes = internalCluster().startDataOnlyNodes(3);
+        createIndex(
+            "test",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 2)
+                .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "60m")
+                .build()
+        );
+        ensureGreen("test");
+
+        final CatShardsRequest shardsRequest = new CatShardsRequest();
+        shardsRequest.setCancelAfterTimeInterval(NO_TIMEOUT);
+        shardsRequest.setIndices(Strings.EMPTY_ARRAY);
+        CountDownLatch latch = new CountDownLatch(1);
+        client().execute(CatShardsAction.INSTANCE, shardsRequest, new ActionListener<CatShardsResponse>() {
+            @Override
+            public void onResponse(CatShardsResponse catShardsResponse) {
+                ClusterStateResponse clusterStateResponse = catShardsResponse.getClusterStateResponse();
+                IndicesStatsResponse indicesStatsResponse = catShardsResponse.getIndicesStatsResponse();
+                for (ShardRouting shard : clusterStateResponse.getState().routingTable().allShards()) {
+                    assertEquals("test", shard.getIndexName());
+                    assertNotNull(indicesStatsResponse.asMap().get(shard));
+                }
+                latch.countDown();
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                fail();
+                latch.countDown();
+            }
+        });
+        latch.await();
+    }
+
+    public void testCatShardsWithTimeoutException() throws IOException, AssertionError, InterruptedException {
+        List<String> masterNodes = internalCluster().startClusterManagerOnlyNodes(1);
+        List<String> nodes = internalCluster().startDataOnlyNodes(3);
+        createIndex(
+            "test",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 2)
+                .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "60m")
+                .build()
+        );
+        ensureGreen("test");
+
+        Settings clusterManagerDataPathSettings = internalCluster().dataPathSettings(masterNodes.get(0));
+        // Dropping master node to delay in cluster state call.
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(masterNodes.get(0)));
+
+        CountDownLatch latch = new CountDownLatch(2);
+        new Thread(() -> {
+            try {
+                // Ensures the cancellation timeout expires.
+                Thread.sleep(2000);
+                // Starting master node to proceed in cluster state call.
+                internalCluster().startClusterManagerOnlyNode(
+                    Settings.builder().put("node.name", masterNodes.get(0)).put(clusterManagerDataPathSettings).build()
+                );
+                latch.countDown();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+        }).start();
+
+        final CatShardsRequest shardsRequest = new CatShardsRequest();
+        TimeValue timeoutInterval = timeValueMillis(1000);
+        shardsRequest.setCancelAfterTimeInterval(timeoutInterval);
+        shardsRequest.clusterManagerNodeTimeout(timeValueMillis(2500));
+        shardsRequest.setIndices(Strings.EMPTY_ARRAY);
+        client().execute(CatShardsAction.INSTANCE, shardsRequest, new ActionListener<CatShardsResponse>() {
+            @Override
+            public void onResponse(CatShardsResponse catShardsResponse) {
+                // onResponse should not be called.
+                latch.countDown();
+                throw new AssertionError(
+                    "The cat shards action is expected to fail with a TaskCancelledException, but it received a successful response instead."
+                );
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                assertSame(e.getClass(), TaskCancelledException.class);
+                assertEquals(e.getMessage(), "Cancellation timeout of " + timeoutInterval + " is expired");
+                latch.countDown();
+            }
+        });
+        latch.await();
+    }
+
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/snapshots/SnapshotBlocksIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/snapshots/SnapshotBlocksIT.java
index 78fb01b07b6b1..0f29f02b284a4 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/snapshots/SnapshotBlocksIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/snapshots/SnapshotBlocksIT.java
@@ -80,13 +80,8 @@ protected void setUpRepository() throws Exception {
 
         logger.info("--> register a repository");
 
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository(REPOSITORY_NAME)
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", randomRepoPath()))
-        );
+        Settings.Builder settings = Settings.builder().put("location", randomRepoPath());
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), REPOSITORY_NAME, "fs", settings);
 
         logger.info("--> verify the repository");
         VerifyRepositoryResponse verifyResponse = client().admin().cluster().prepareVerifyRepository(REPOSITORY_NAME).get();
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java
index 085a32593063a..f23cdbb50b37a 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIT.java
@@ -88,7 +88,11 @@ public void testNodeCounts() {
         Map<String, Integer> expectedCounts = getExpectedCounts(1, 1, 1, 1, 1, 0, 0);
         int numNodes = randomIntBetween(1, 5);
 
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(response.getNodesStats().getCounts(), total, expectedCounts);
 
         for (int i = 0; i < numNodes; i++) {
@@ -153,7 +157,11 @@ public void testNodeCountsWithDeprecatedMasterRole() throws ExecutionException,
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 0, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse response = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(response.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(DiscoveryNodeRole.MASTER_ROLE.roleName());
@@ -176,15 +184,60 @@ private void assertShardStats(ClusterStatsIndices.ShardStats stats, int indices,
         assertThat(stats.getReplication(), Matchers.equalTo(replicationFactor));
     }
 
-    public void testIndicesShardStats() throws ExecutionException, InterruptedException {
+    public void testIndicesShardStatsWithoutNodeLevelAggregations() {
+        internalCluster().startNode();
+        ensureGreen();
+        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(false).get();
+        assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
+
+        prepareCreate("test1").setSettings(Settings.builder().put("number_of_shards", 2).put("number_of_replicas", 1)).get();
+
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(false).get();
+        assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.YELLOW));
+        assertThat(response.indicesStats.getDocs().getCount(), Matchers.equalTo(0L));
+        assertThat(response.indicesStats.getIndexCount(), Matchers.equalTo(1));
+        assertShardStats(response.getIndicesStats().getShards(), 1, 2, 2, 0.0);
+
+        // add another node, replicas should get assigned
+        internalCluster().startNode();
+        ensureGreen();
+        index("test1", "type", "1", "f", "f");
+        refresh(); // make the doc visible
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(false).get();
+        assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
+        assertThat(response.indicesStats.getDocs().getCount(), Matchers.equalTo(1L));
+        assertShardStats(response.getIndicesStats().getShards(), 1, 4, 2, 1.0);
+
+        prepareCreate("test2").setSettings(Settings.builder().put("number_of_shards", 3).put("number_of_replicas", 0)).get();
+        ensureGreen();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(false).get();
+        assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
+        assertThat(response.indicesStats.getIndexCount(), Matchers.equalTo(2));
+        assertShardStats(response.getIndicesStats().getShards(), 2, 7, 5, 2.0 / 5);
+
+        assertThat(response.getIndicesStats().getShards().getAvgIndexPrimaryShards(), Matchers.equalTo(2.5));
+        assertThat(response.getIndicesStats().getShards().getMinIndexPrimaryShards(), Matchers.equalTo(2));
+        assertThat(response.getIndicesStats().getShards().getMaxIndexPrimaryShards(), Matchers.equalTo(3));
+
+        assertThat(response.getIndicesStats().getShards().getAvgIndexShards(), Matchers.equalTo(3.5));
+        assertThat(response.getIndicesStats().getShards().getMinIndexShards(), Matchers.equalTo(3));
+        assertThat(response.getIndicesStats().getShards().getMaxIndexShards(), Matchers.equalTo(4));
+
+        assertThat(response.getIndicesStats().getShards().getAvgIndexReplication(), Matchers.equalTo(0.5));
+        assertThat(response.getIndicesStats().getShards().getMinIndexReplication(), Matchers.equalTo(0.0));
+        assertThat(response.getIndicesStats().getShards().getMaxIndexReplication(), Matchers.equalTo(1.0));
+
+    }
+
+    public void testIndicesShardStatsWithNodeLevelAggregations() {
         internalCluster().startNode();
         ensureGreen();
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(true).get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
 
         prepareCreate("test1").setSettings(Settings.builder().put("number_of_shards", 2).put("number_of_replicas", 1)).get();
 
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(true).get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.YELLOW));
         assertThat(response.indicesStats.getDocs().getCount(), Matchers.equalTo(0L));
         assertThat(response.indicesStats.getIndexCount(), Matchers.equalTo(1));
@@ -195,14 +248,14 @@ public void testIndicesShardStats() throws ExecutionException, InterruptedExcept
         ensureGreen();
         index("test1", "type", "1", "f", "f");
         refresh(); // make the doc visible
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(true).get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
         assertThat(response.indicesStats.getDocs().getCount(), Matchers.equalTo(1L));
         assertShardStats(response.getIndicesStats().getShards(), 1, 4, 2, 1.0);
 
         prepareCreate("test2").setSettings(Settings.builder().put("number_of_shards", 3).put("number_of_replicas", 0)).get();
         ensureGreen();
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(true).get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
         assertThat(response.indicesStats.getIndexCount(), Matchers.equalTo(2));
         assertShardStats(response.getIndicesStats().getShards(), 2, 7, 5, 2.0 / 5);
@@ -225,7 +278,11 @@ public void testValuesSmokeScreen() throws IOException, ExecutionException, Inte
         internalCluster().startNodes(randomIntBetween(1, 3));
         index("test1", "type", "1", "f", "f");
 
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         String msg = response.toString();
         assertThat(msg, response.getTimestamp(), Matchers.greaterThan(946681200000L)); // 1 Jan 2000
         assertThat(msg, response.indicesStats.getStore().getSizeInBytes(), Matchers.greaterThan(0L));
@@ -265,13 +322,21 @@ public void testAllocatedProcessors() throws Exception {
         internalCluster().startNode(Settings.builder().put(OpenSearchExecutors.NODE_PROCESSORS_SETTING.getKey(), 7).build());
         waitForNodes(1);
 
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertThat(response.getNodesStats().getOs().getAllocatedProcessors(), equalTo(7));
     }
 
     public void testClusterStatusWhenStateNotRecovered() throws Exception {
         internalCluster().startClusterManagerOnlyNode(Settings.builder().put("gateway.recover_after_nodes", 2).build());
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertThat(response.getStatus(), equalTo(ClusterHealthStatus.RED));
 
         if (randomBoolean()) {
@@ -281,14 +346,18 @@ public void testClusterStatusWhenStateNotRecovered() throws Exception {
         }
         // wait for the cluster status to settle
         ensureGreen();
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(randomBoolean()).get();
         assertThat(response.getStatus(), equalTo(ClusterHealthStatus.GREEN));
     }
 
     public void testFieldTypes() {
         internalCluster().startNode();
         ensureGreen();
-        ClusterStatsResponse response = client().admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse response = client().admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertThat(response.getStatus(), Matchers.equalTo(ClusterHealthStatus.GREEN));
         assertTrue(response.getIndicesStats().getMappings().getFieldTypeStats().isEmpty());
 
@@ -301,7 +370,7 @@ public void testFieldTypes() {
                     + "\"eggplant\":{\"type\":\"integer\"}}}}}"
             )
             .get();
-        response = client().admin().cluster().prepareClusterStats().get();
+        response = client().admin().cluster().prepareClusterStats().useAggregatedNodeLevelResponses(randomBoolean()).get();
         assertThat(response.getIndicesStats().getMappings().getFieldTypeStats().size(), equalTo(3));
         Set<IndexFeatureStats> stats = response.getIndicesStats().getMappings().getFieldTypeStats();
         for (IndexFeatureStats stat : stats) {
@@ -329,7 +398,11 @@ public void testNodeRolesWithMasterLegacySettings() throws ExecutionException, I
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 1, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse clusterStatsResponse = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(
@@ -359,7 +432,11 @@ public void testNodeRolesWithClusterManagerRole() throws ExecutionException, Int
         Map<String, Integer> expectedCounts = getExpectedCounts(0, 1, 1, 0, 1, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse clusterStatsResponse = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedCounts);
 
         Set<String> expectedRoles = Set.of(
@@ -383,7 +460,11 @@ public void testNodeRolesWithSeedDataNodeLegacySettings() throws ExecutionExcept
         Map<String, Integer> expectedRoleCounts = getExpectedCounts(1, 1, 1, 0, 1, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse clusterStatsResponse = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedRoleCounts);
 
         Set<String> expectedRoles = Set.of(
@@ -410,7 +491,11 @@ public void testNodeRolesWithDataNodeLegacySettings() throws ExecutionException,
         Map<String, Integer> expectedRoleCounts = getExpectedCounts(1, 1, 1, 0, 1, 0, 0);
 
         Client client = client();
-        ClusterStatsResponse clusterStatsResponse = client.admin().cluster().prepareClusterStats().get();
+        ClusterStatsResponse clusterStatsResponse = client.admin()
+            .cluster()
+            .prepareClusterStats()
+            .useAggregatedNodeLevelResponses(randomBoolean())
+            .get();
         assertCounts(clusterStatsResponse.getNodesStats().getCounts(), total, expectedRoleCounts);
 
         Set<Set<String>> expectedNodesRoles = Set.of(
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/CreateIndexIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/CreateIndexIT.java
index d0f4c98444b2e..f20e5ccf819c0 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/CreateIndexIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/CreateIndexIT.java
@@ -41,15 +41,23 @@
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.applicationtemplates.ClusterStateSystemTemplateLoader;
+import org.opensearch.cluster.applicationtemplates.SystemTemplate;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateMetadata;
+import org.opensearch.cluster.applicationtemplates.TemplateRepositoryMetadata;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.MappingMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.index.IndexNotFoundException;
 import org.opensearch.index.IndexService;
+import org.opensearch.index.IndexSettings;
 import org.opensearch.index.mapper.MapperParsingException;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.query.RangeQueryBuilder;
@@ -58,7 +66,10 @@
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
 import org.opensearch.test.OpenSearchIntegTestCase.Scope;
 
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
 import java.util.Map;
+import java.util.UUID;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiFunction;
@@ -405,4 +416,77 @@ public void testIndexNameInResponse() {
         assertEquals("Should have index name in response", "foo", response.index());
     }
 
+    public void testCreateIndexWithNullReplicaCountPickUpClusterReplica() {
+        int numReplicas = 3;
+        String indexName = "test-idx-1";
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(Settings.builder().put("cluster.default_number_of_replicas", numReplicas).build())
+                .get()
+        );
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
+            .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), (String) null)
+            .build();
+        assertAcked(client().admin().indices().prepareCreate(indexName).setSettings(settings).get());
+        IndicesService indicesService = internalCluster().getInstance(IndicesService.class, internalCluster().getClusterManagerName());
+        for (IndexService indexService : indicesService) {
+            assertEquals(indexName, indexService.index().getName());
+            assertEquals(
+                numReplicas,
+                (int) indexService.getIndexSettings().getSettings().getAsInt(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, null)
+            );
+        }
+    }
+
+    public void testCreateIndexWithContextSettingsAndTemplate() throws Exception {
+        int numReplicas = 1;
+        String indexName = "test-idx-1";
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 1)
+            .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), (String) null)
+            .build();
+        Context context = new Context("test");
+
+        String templateContent = "{\n"
+            + "  \"template\": {\n"
+            + "    \"settings\": {\n"
+            + "      \"merge.policy\": \"log_byte_size\"\n"
+            + "    }\n"
+            + "  },\n"
+            + "  \"_meta\": {\n"
+            + "    \"_type\": \"@abc_template\",\n"
+            + "    \"_version\": 1\n"
+            + "  },\n"
+            + "  \"version\": 1\n"
+            + "}\n";
+
+        ClusterStateSystemTemplateLoader loader = new ClusterStateSystemTemplateLoader(
+            internalCluster().clusterManagerClient(),
+            () -> internalCluster().getInstance(ClusterService.class).state()
+        );
+        loader.loadTemplate(
+            new SystemTemplate(
+                BytesReference.fromByteBuffer(ByteBuffer.wrap(templateContent.getBytes(StandardCharsets.UTF_8))),
+                SystemTemplateMetadata.fromComponentTemplateInfo("test", 1L),
+                new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L)
+            )
+        );
+
+        assertAcked(client().admin().indices().prepareCreate(indexName).setSettings(settings).setContext(context).get());
+
+        IndicesService indicesService = internalCluster().getInstance(IndicesService.class, internalCluster().getClusterManagerName());
+
+        for (IndexService indexService : indicesService) {
+            assertEquals(indexName, indexService.index().getName());
+            assertEquals(
+                numReplicas,
+                (int) indexService.getIndexSettings().getSettings().getAsInt(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, null)
+            );
+            assertEquals(context, indexService.getMetadata().context());
+            assertEquals("log_byte_size", indexService.getMetadata().getSettings().get(IndexSettings.INDEX_MERGE_POLICY.getKey()));
+        }
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/RemoteCloneIndexIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/RemoteCloneIndexIT.java
index a1122f279c7e4..abce2fc878f27 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/RemoteCloneIndexIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/RemoteCloneIndexIT.java
@@ -42,24 +42,32 @@
 import org.opensearch.Version;
 import org.opensearch.action.admin.cluster.health.ClusterHealthRequest;
 import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
+import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
 import org.opensearch.action.admin.indices.settings.get.GetSettingsResponse;
 import org.opensearch.action.admin.indices.shrink.ResizeType;
 import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
 import org.opensearch.client.Requests;
+import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.index.query.TermsQueryBuilder;
 import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
+import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.VersionUtils;
+import org.junit.Before;
 
 import java.util.concurrent.ExecutionException;
 
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteCloneIndexIT extends RemoteStoreBaseIntegTestCase {
@@ -69,6 +77,11 @@ protected boolean forbidPrivateIndexSettings() {
         return false;
     }
 
+    @Before
+    public void setup() {
+        asyncUploadMockFsRepo = false;
+    }
+
     public void testCreateCloneIndex() {
         Version version = VersionUtils.randomIndexCompatibleVersion(random());
         int numPrimaryShards = randomIntBetween(1, 5);
@@ -140,6 +153,80 @@ public void testCreateCloneIndex() {
 
     }
 
+    @AwaitsFix(bugUrl = "https://github.com/opensearch-project/OpenSearch/issues/15056")
+    public void testCreateCloneIndexLowPriorityRateLimit() {
+        Version version = VersionUtils.randomIndexCompatibleVersion(random());
+        int numPrimaryShards = 1;
+        prepareCreate("source").setSettings(
+            Settings.builder().put(indexSettings()).put("number_of_shards", numPrimaryShards).put("index.version.created", version)
+        ).get();
+        final int docs = randomIntBetween(0, 128);
+        for (int i = 0; i < docs; i++) {
+            client().prepareIndex("source").setSource("{\"foo\" : \"bar\", \"i\" : " + i + "}", MediaTypeRegistry.JSON).get();
+        }
+        ByteSizeValue shardSize = client().admin().indices().prepareStats("source").execute().actionGet().getShards()[0].getStats()
+            .getStore()
+            .size();
+        logger.info("Shard size is {}", shardSize);
+        internalCluster().ensureAtLeastNumDataNodes(2);
+        // ensure all shards are allocated otherwise the ensure green below might not succeed since we require the merge node
+        // if we change the setting too quickly we will end up with one replica unassigned which can't be assigned anymore due
+        // to the require._name below.
+        ensureGreen();
+        // relocate all shards to one node such that we can merge it.
+        client().admin().indices().prepareUpdateSettings("source").setSettings(Settings.builder().put("index.blocks.write", true)).get();
+        ensureGreen();
+
+        // disable rebalancing to be able to capture the right stats. balancing can move the target primary
+        // making it hard to pin point the source shards.
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(Settings.builder().put(EnableAllocationDecider.CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), "none"))
+            .get();
+        try {
+            // apply rate limiter
+            setLowPriorityUploadRate(REPOSITORY_NAME, "1kb");
+            assertAcked(
+                client().admin()
+                    .indices()
+                    .prepareResizeIndex("source", "target")
+                    .setResizeType(ResizeType.CLONE)
+                    .setSettings(Settings.builder().put("index.number_of_replicas", 0).putNull("index.blocks.write").build())
+                    .get()
+            );
+            ensureGreen();
+            long uploadPauseTime = 0L;
+            for (RepositoriesService repositoriesService : internalCluster().getDataNodeInstances(RepositoriesService.class)) {
+                uploadPauseTime += repositoriesService.repository(REPOSITORY_NAME).getLowPriorityRemoteUploadThrottleTimeInNanos();
+            }
+            assertThat(uploadPauseTime, greaterThan(TimeValue.timeValueSeconds(randomIntBetween(5, 10)).nanos()));
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        } finally {
+            // clean up
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(
+                    Settings.builder()
+                        .put(EnableAllocationDecider.CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING.getKey(), (String) null)
+                        .put(RecoverySettings.INDICES_INTERNAL_REMOTE_UPLOAD_TIMEOUT.getKey(), (String) null)
+                )
+                .get();
+        }
+    }
+
+    protected void setLowPriorityUploadRate(String repoName, String value) throws ExecutionException, InterruptedException {
+        GetRepositoriesRequest gr = new GetRepositoriesRequest(new String[] { repoName });
+        GetRepositoriesResponse res = client().admin().cluster().getRepositories(gr).get();
+        RepositoryMetadata rmd = res.repositories().get(0);
+        Settings.Builder settings = Settings.builder()
+            .put("location", rmd.settings().get("location"))
+            .put("max_remote_low_priority_upload_bytes_per_sec", value);
+        createRepository(repoName, rmd.type(), settings);
+    }
+
     public void testCreateCloneIndexFailure() throws ExecutionException, InterruptedException {
         asyncUploadMockFsRepo = false;
         Version version = VersionUtils.randomIndexCompatibleVersion(random());
@@ -194,7 +281,7 @@ public void testCreateCloneIndexFailure() throws ExecutionException, Interrupted
             throw new RuntimeException(e);
         } finally {
             setFailRate(REPOSITORY_NAME, 0);
-            ensureGreen();
+            ensureGreen(TimeValue.timeValueSeconds(40));
             // clean up
             client().admin()
                 .cluster()
diff --git a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/RemoteSplitIndexIT.java b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/RemoteSplitIndexIT.java
index dc3c8793a93f6..3038db4583cf4 100644
--- a/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/RemoteSplitIndexIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/action/admin/indices/create/RemoteSplitIndexIT.java
@@ -46,6 +46,7 @@
 import org.opensearch.action.index.IndexRequest;
 import org.opensearch.action.index.IndexRequestBuilder;
 import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.client.Client;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
@@ -65,16 +66,20 @@
 import org.opensearch.index.seqno.SeqNoStats;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.VersionUtils;
+import org.junit.After;
+import org.junit.Before;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.concurrent.TimeUnit;
 import java.util.function.BiFunction;
 import java.util.stream.IntStream;
 
@@ -89,12 +94,35 @@
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteSplitIndexIT extends RemoteStoreBaseIntegTestCase {
+    @Before
+    public void setup() {
+        asyncUploadMockFsRepo = false;
+    }
 
     @Override
     protected boolean forbidPrivateIndexSettings() {
         return false;
     }
 
+    @After
+    public void cleanUp() throws Exception {
+        // Delete is async.
+        assertAcked(
+            client().admin().indices().prepareDelete("*").setIndicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN_CLOSED_HIDDEN).get()
+        );
+        // With pinned timestamp, we can have tlog files even after deletion.
+        if (RemoteStoreSettings.isPinnedTimestampsEnabled() == false) {
+            assertBusy(() -> {
+                try {
+                    assertEquals(0, getFileCount(translogRepoPath));
+                } catch (IOException e) {
+                    fail();
+                }
+            }, 30, TimeUnit.SECONDS);
+        }
+        super.teardown();
+    }
+
     public Settings indexSettings() {
         return Settings.builder()
             .put(super.indexSettings())
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/allocation/ClusterRerouteIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/allocation/ClusterRerouteIT.java
index dbcb030d8a4f7..f4b5f112f5785 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/allocation/ClusterRerouteIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/allocation/ClusterRerouteIT.java
@@ -273,7 +273,8 @@ public void testDelayWithALargeAmountOfShards() throws Exception {
         internalCluster().stopRandomNode(InternalTestCluster.nameFilter(node_1));
 
         // This might run slowly on older hardware
-        ensureGreen(TimeValue.timeValueMinutes(2));
+        // In some case, the shards will be rebalanced back and forth, it seems like a very low probability bug.
+        ensureGreen(TimeValue.timeValueMinutes(2), false);
     }
 
     private void rerouteWithAllocateLocalGateway(Settings commonSettings) throws Exception {
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/allocation/SearchReplicaFilteringAllocationIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/allocation/SearchReplicaFilteringAllocationIT.java
new file mode 100644
index 0000000000000..5f65d6647f26d
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/allocation/SearchReplicaFilteringAllocationIT.java
@@ -0,0 +1,125 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.allocation;
+
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REPLICATION_TYPE;
+import static org.opensearch.cluster.routing.allocation.decider.SearchReplicaAllocationDecider.SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class SearchReplicaFilteringAllocationIT extends OpenSearchIntegTestCase {
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder().put(super.featureFlagSettings()).put(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL, Boolean.TRUE).build();
+    }
+
+    public void testSearchReplicaDedicatedIncludes() {
+        List<String> nodesIds = internalCluster().startNodes(3);
+        final String node_0 = nodesIds.get(0);
+        final String node_1 = nodesIds.get(1);
+        final String node_2 = nodesIds.get(2);
+        assertEquals(3, cluster().size());
+
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(
+                Settings.builder().put(SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING.getKey() + "_name", node_1 + "," + node_0)
+            )
+            .execute()
+            .actionGet();
+
+        createIndex(
+            "test",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                .put(IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS, 1)
+                .put(SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+                .build()
+        );
+        ensureGreen("test");
+        // ensure primary is not on node 0 or 1,
+        IndexShardRoutingTable routingTable = getRoutingTable();
+        assertEquals(node_2, getNodeName(routingTable.primaryShard().currentNodeId()));
+
+        String existingSearchReplicaNode = getNodeName(routingTable.searchOnlyReplicas().get(0).currentNodeId());
+        String emptyAllowedNode = existingSearchReplicaNode.equals(node_0) ? node_1 : node_0;
+
+        // set the included nodes to the other open node, search replica should relocate to that node.
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(Settings.builder().put(SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING.getKey() + "_name", emptyAllowedNode))
+            .execute()
+            .actionGet();
+        ensureGreen("test");
+
+        routingTable = getRoutingTable();
+        assertEquals(node_2, getNodeName(routingTable.primaryShard().currentNodeId()));
+        assertEquals(emptyAllowedNode, getNodeName(routingTable.searchOnlyReplicas().get(0).currentNodeId()));
+    }
+
+    public void testSearchReplicaDedicatedIncludes_DoNotAssignToOtherNodes() {
+        List<String> nodesIds = internalCluster().startNodes(3);
+        final String node_0 = nodesIds.get(0);
+        final String node_1 = nodesIds.get(1);
+        final String node_2 = nodesIds.get(2);
+        assertEquals(3, cluster().size());
+
+        // set filter on 1 node and set search replica count to 2 - should leave 1 unassigned
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(Settings.builder().put(SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING.getKey() + "_name", node_1))
+            .execute()
+            .actionGet();
+
+        logger.info("--> creating an index with no replicas");
+        createIndex(
+            "test",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                .put(IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS, 2)
+                .put(SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+                .build()
+        );
+        ensureYellowAndNoInitializingShards("test");
+        IndexShardRoutingTable routingTable = getRoutingTable();
+        assertEquals(2, routingTable.searchOnlyReplicas().size());
+        List<ShardRouting> assignedSearchShards = routingTable.searchOnlyReplicas()
+            .stream()
+            .filter(ShardRouting::assignedToNode)
+            .collect(Collectors.toList());
+        assertEquals(1, assignedSearchShards.size());
+        assertEquals(node_1, getNodeName(assignedSearchShards.get(0).currentNodeId()));
+        assertEquals(1, routingTable.searchOnlyReplicas().stream().filter(ShardRouting::unassigned).count());
+    }
+
+    private IndexShardRoutingTable getRoutingTable() {
+        IndexShardRoutingTable routingTable = getClusterState().routingTable().index("test").getShards().get(0);
+        return routingTable;
+    }
+
+    private String getNodeName(String id) {
+        return getClusterState().nodes().get(id).getName();
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/AwarenessAttributeDecommissionIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/AwarenessAttributeDecommissionIT.java
index b33d57ed43189..beed6e6846b46 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/AwarenessAttributeDecommissionIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/coordination/AwarenessAttributeDecommissionIT.java
@@ -539,18 +539,7 @@ private void assertNodesRemovedAfterZoneDecommission(boolean originalClusterMana
             assertEquals(originalClusterManager, currentClusterManager);
         }
 
-        // Will wait for all events to complete
-        client(activeNode).admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).get();
-
-        // Recommissioning the zone back to gracefully succeed the test once above tests succeeds
-        DeleteDecommissionStateResponse deleteDecommissionStateResponse = client(currentClusterManager).execute(
-            DeleteDecommissionStateAction.INSTANCE,
-            new DeleteDecommissionStateRequest()
-        ).get();
-        assertTrue(deleteDecommissionStateResponse.isAcknowledged());
-
-        // will wait for cluster to stabilise with a timeout of 2 min as by then all nodes should have joined the cluster
-        ensureStableCluster(15, TimeValue.timeValueMinutes(2));
+        deleteDecommissionStateAndWaitForStableCluster(currentClusterManager, 15);
     }
 
     public void testDecommissionFailedWhenDifferentAttributeAlreadyDecommissioned() throws Exception {
@@ -617,18 +606,7 @@ public void testDecommissionFailedWhenDifferentAttributeAlreadyDecommissioned()
             )
         );
 
-        // Will wait for all events to complete
-        client(node_in_c).admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).get();
-
-        // Recommissioning the zone back to gracefully succeed the test once above tests succeeds
-        DeleteDecommissionStateResponse deleteDecommissionStateResponse = client(node_in_c).execute(
-            DeleteDecommissionStateAction.INSTANCE,
-            new DeleteDecommissionStateRequest()
-        ).get();
-        assertTrue(deleteDecommissionStateResponse.isAcknowledged());
-
-        // will wait for cluster to stabilise with a timeout of 2 min as by then all nodes should have joined the cluster
-        ensureStableCluster(6, TimeValue.timeValueMinutes(2));
+        deleteDecommissionStateAndWaitForStableCluster(node_in_c, 6);
     }
 
     public void testDecommissionStatusUpdatePublishedToAllNodes() throws ExecutionException, InterruptedException {
@@ -748,20 +726,7 @@ public void testDecommissionStatusUpdatePublishedToAllNodes() throws ExecutionEx
         );
         logger.info("--> Verified the decommissioned node has in_progress state.");
 
-        // Will wait for all events to complete
-        client(activeNode).admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).get();
-        logger.info("--> Got LANGUID event");
-        // Recommissioning the zone back to gracefully succeed the test once above tests succeeds
-        DeleteDecommissionStateResponse deleteDecommissionStateResponse = client(activeNode).execute(
-            DeleteDecommissionStateAction.INSTANCE,
-            new DeleteDecommissionStateRequest()
-        ).get();
-        assertTrue(deleteDecommissionStateResponse.isAcknowledged());
-        logger.info("--> Deleting decommission done.");
-
-        // will wait for cluster to stabilise with a timeout of 2 min (findPeerInterval for decommissioned nodes)
-        // as by then all nodes should have joined the cluster
-        ensureStableCluster(6, TimeValue.timeValueSeconds(121));
+        deleteDecommissionStateAndWaitForStableCluster(activeNode, 6);
     }
 
     public void testDecommissionFailedWhenAttributeNotWeighedAway() throws Exception {
@@ -983,15 +948,7 @@ public void testDecommissionAcknowledgedIfWeightsNotSetForNonRoutingNode() throw
         assertEquals(clusterState.nodes().getDataNodes().size(), 3);
         assertEquals(clusterState.nodes().getClusterManagerNodes().size(), 2);
 
-        // Recommissioning the zone back to gracefully succeed the test once above tests succeeds
-        DeleteDecommissionStateResponse deleteDecommissionStateResponse = client(dataNodes.get(0)).execute(
-            DeleteDecommissionStateAction.INSTANCE,
-            new DeleteDecommissionStateRequest()
-        ).get();
-        assertTrue(deleteDecommissionStateResponse.isAcknowledged());
-
-        // will wait for cluster to stabilise with a timeout of 2 min as by then all nodes should have joined the cluster
-        ensureStableCluster(6, TimeValue.timeValueMinutes(2));
+        deleteDecommissionStateAndWaitForStableCluster(dataNodes.get(0), 6);
     }
 
     public void testConcurrentDecommissionAction() throws Exception {
@@ -1019,7 +976,7 @@ public void testConcurrentDecommissionAction() throws Exception {
                 .build()
         );
         logger.info("--> start 3 data nodes on zones 'a' & 'b' & 'c'");
-        internalCluster().startNodes(
+        final String bZoneDataNode = internalCluster().startNodes(
             Settings.builder()
                 .put(commonSettings)
                 .put("node.attr.zone", "a")
@@ -1035,7 +992,7 @@ public void testConcurrentDecommissionAction() throws Exception {
                 .put("node.attr.zone", "c")
                 .put(onlyRole(commonSettings, DiscoveryNodeRole.DATA_ROLE))
                 .build()
-        );
+        ).get(1);
 
         ensureStableCluster(6);
         ClusterHealthResponse health = client().admin()
@@ -1100,6 +1057,25 @@ public void testConcurrentDecommissionAction() throws Exception {
         assertEquals(concurrentRuns, numRequestAcknowledged.get() + numRequestUnAcknowledged.get() + numRequestFailed.get());
         assertEquals(concurrentRuns - 1, numRequestFailed.get());
         assertEquals(1, numRequestAcknowledged.get() + numRequestUnAcknowledged.get());
+
+        deleteDecommissionStateAndWaitForStableCluster(bZoneDataNode, 6);
+    }
+
+    private void deleteDecommissionStateAndWaitForStableCluster(String activeNodeName, int expectedClusterSize) throws ExecutionException,
+        InterruptedException {
+        client(activeNodeName).admin().cluster().prepareHealth().setWaitForEvents(Priority.LANGUID).get();
+
+        // Recommissioning the zone back to gracefully succeed the test once above tests succeeds
+        DeleteDecommissionStateResponse deleteDecommissionStateResponse = client(activeNodeName).execute(
+            DeleteDecommissionStateAction.INSTANCE,
+            new DeleteDecommissionStateRequest()
+        ).get();
+        assertTrue(deleteDecommissionStateResponse.isAcknowledged());
+        logger.info("--> Deleting decommission done.");
+
+        // will wait for cluster to stabilise with a timeout of 2 min (findPeerInterval for decommissioned nodes)
+        // as by then all nodes should have joined the cluster
+        ensureStableCluster(expectedClusterSize, TimeValue.timeValueSeconds(121));
     }
 
     private static class WaitForFailedDecommissionState implements ClusterStateObserver.Listener {
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderIT.java
index 2d268a26a5755..ea45173cdbf7f 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderIT.java
@@ -365,13 +365,8 @@ public void testRestoreSnapshotAllocationDoesNotExceedWatermark() throws Excepti
         final String dataNodeName = internalCluster().startDataOnlyNode();
         ensureStableCluster(3);
 
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository("repo")
-                .setType(FsRepository.TYPE)
-                .setSettings(Settings.builder().put("location", randomRepoPath()).put("compress", randomBoolean()))
-        );
+        Settings.Builder settings = Settings.builder().put("location", randomRepoPath()).put("compress", randomBoolean());
+        createRepository("repo", FsRepository.TYPE, settings);
 
         final InternalClusterInfoService clusterInfoService = (InternalClusterInfoService) internalCluster()
             .getCurrentClusterManagerNodeInstance(ClusterInfoService.class);
diff --git a/server/src/internalClusterTest/java/org/opensearch/cluster/shards/ClusterShardLimitIT.java b/server/src/internalClusterTest/java/org/opensearch/cluster/shards/ClusterShardLimitIT.java
index 5eef7074e1dd6..3718dce538053 100644
--- a/server/src/internalClusterTest/java/org/opensearch/cluster/shards/ClusterShardLimitIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/cluster/shards/ClusterShardLimitIT.java
@@ -494,8 +494,7 @@ public void testRestoreSnapshotOverLimit() {
         repoSettings.put("location", randomRepoPath());
         repoSettings.put("compress", randomBoolean());
         repoSettings.put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES);
-
-        assertAcked(client.admin().cluster().preparePutRepository("test-repo").setType("fs").setSettings(repoSettings.build()));
+        createRepository("test-repo", "fs", repoSettings);
 
         int dataNodes = client().admin().cluster().prepareState().get().getState().getNodes().getDataNodes().size();
         ShardCounts counts = ShardCounts.forDataNodeCount(dataNodes);
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/RecoveryFromGatewayIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/RecoveryFromGatewayIT.java
index bc0557ddc2afa..bcf23a37c0010 100644
--- a/server/src/internalClusterTest/java/org/opensearch/gateway/RecoveryFromGatewayIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/RecoveryFromGatewayIT.java
@@ -55,7 +55,10 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
 import org.opensearch.cluster.routing.UnassignedInfo;
+import org.opensearch.cluster.routing.allocation.AllocateUnassignedDecision;
+import org.opensearch.cluster.routing.allocation.AllocationDecision;
 import org.opensearch.cluster.routing.allocation.ExistingShardsAllocator;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.Settings;
@@ -98,6 +101,9 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BooleanSupplier;
+import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
 import static java.util.Collections.emptyMap;
@@ -105,8 +111,10 @@
 import static org.opensearch.cluster.coordination.ClusterBootstrapService.INITIAL_CLUSTER_MANAGER_NODES_SETTING;
 import static org.opensearch.cluster.health.ClusterHealthStatus.GREEN;
 import static org.opensearch.cluster.health.ClusterHealthStatus.RED;
+import static org.opensearch.cluster.health.ClusterHealthStatus.YELLOW;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
+import static org.opensearch.cluster.routing.UnassignedInfo.INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING;
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
 import static org.opensearch.gateway.GatewayRecoveryTestUtils.corruptShard;
 import static org.opensearch.gateway.GatewayRecoveryTestUtils.getDiscoveryNodes;
@@ -753,6 +761,7 @@ public void testMessyElectionsStillMakeClusterGoGreen() throws Exception {
             Settings.builder()
                 .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
                 .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms")
                 .put(UnassignedInfo.INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "100ms")
                 .build()
         );
@@ -761,7 +770,7 @@ public void testMessyElectionsStillMakeClusterGoGreen() throws Exception {
         ensureGreen("test");
     }
 
-    public void testBatchModeEnabled() throws Exception {
+    public void testBatchModeEnabledWithoutTimeout() throws Exception {
         internalCluster().startClusterManagerOnlyNodes(
             1,
             Settings.builder().put(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.getKey(), true).build()
@@ -789,11 +798,86 @@ public void testBatchModeEnabled() throws Exception {
         );
         assertTrue(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.get(internalCluster().clusterService().getSettings()));
         assertEquals(1, gatewayAllocator.getNumberOfStartedShardBatches());
-        assertEquals(1, gatewayAllocator.getNumberOfStoreShardBatches());
+        // Replica shard would be marked ineligible since there are no data nodes.
+        // It would then be removed from any batch and batches would get deleted, so we would have 0 replica batches
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
 
-        // Now start both data nodes and ensure batch mode is working
-        logger.info("--> restarting the stopped nodes");
+        // Now start one data node
+        logger.info("--> restarting the first stopped node");
+        internalCluster().startDataOnlyNode(Settings.builder().put("node.name", dataOnlyNodes.get(0)).put(node0DataPathSettings).build());
+        ensureStableCluster(2);
+        ensureYellow("test");
+        assertEquals(0, gatewayAllocator.getNumberOfStartedShardBatches());
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
+        assertEquals(0, gatewayAllocator.getNumberOfInFlightFetches());
+
+        // calling reroute and asserting on reroute response
+        logger.info("--> calling reroute while cluster is yellow");
+        clusterRerouteResponse = client().admin().cluster().prepareReroute().setRetryFailed(true).get();
+        assertTrue(clusterRerouteResponse.isAcknowledged());
+
+        // Now start last data node and ensure batch mode is working and cluster goes green
+        logger.info("--> restarting the second stopped node");
+        internalCluster().startDataOnlyNode(Settings.builder().put("node.name", dataOnlyNodes.get(1)).put(node1DataPathSettings).build());
+        ensureStableCluster(3);
+        ensureGreen("test");
+        assertEquals(0, gatewayAllocator.getNumberOfStartedShardBatches());
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
+        assertEquals(0, gatewayAllocator.getNumberOfInFlightFetches());
+    }
+
+    public void testBatchModeEnabledWithSufficientTimeoutAndClusterGreen() throws Exception {
+        internalCluster().startClusterManagerOnlyNodes(
+            1,
+            Settings.builder()
+                .put(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.getKey(), true)
+                .put(ShardsBatchGatewayAllocator.PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.getKey(), "20s")
+                .put(ShardsBatchGatewayAllocator.REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.getKey(), "20s")
+                .build()
+        );
+        List<String> dataOnlyNodes = internalCluster().startDataOnlyNodes(2);
+        createIndex(
+            "test",
+            Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1).build()
+        );
+        ensureGreen("test");
+        Settings node0DataPathSettings = internalCluster().dataPathSettings(dataOnlyNodes.get(0));
+        Settings node1DataPathSettings = internalCluster().dataPathSettings(dataOnlyNodes.get(1));
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(dataOnlyNodes.get(0)));
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(dataOnlyNodes.get(1)));
+        ensureRed("test");
+        ensureStableCluster(1);
+
+        logger.info("--> Now do a protective reroute");
+        ClusterRerouteResponse clusterRerouteResponse = client().admin().cluster().prepareReroute().setRetryFailed(true).get();
+        assertTrue(clusterRerouteResponse.isAcknowledged());
+
+        ShardsBatchGatewayAllocator gatewayAllocator = internalCluster().getInstance(
+            ShardsBatchGatewayAllocator.class,
+            internalCluster().getClusterManagerName()
+        );
+        assertTrue(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.get(internalCluster().clusterService().getSettings()));
+        assertEquals(1, gatewayAllocator.getNumberOfStartedShardBatches());
+        // Replica shard would be marked ineligible since there are no data nodes.
+        // It would then be removed from any batch and batches would get deleted, so we would have 0 replica batches
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
+
+        // Now start one data nodes and ensure batch mode is working
+        logger.info("--> restarting the first stopped node");
         internalCluster().startDataOnlyNode(Settings.builder().put("node.name", dataOnlyNodes.get(0)).put(node0DataPathSettings).build());
+        ensureStableCluster(2);
+        ensureYellow("test");
+        assertEquals(0, gatewayAllocator.getNumberOfStartedShardBatches());
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
+        assertEquals(0, gatewayAllocator.getNumberOfInFlightFetches());
+
+        // calling reroute and asserting on reroute response
+        logger.info("--> calling reroute while cluster is yellow");
+        clusterRerouteResponse = client().admin().cluster().prepareReroute().setRetryFailed(true).get();
+        assertTrue(clusterRerouteResponse.isAcknowledged());
+
+        // Now start last data node and ensure batch mode is working and cluster goes green
+        logger.info("--> restarting the second stopped node");
         internalCluster().startDataOnlyNode(Settings.builder().put("node.name", dataOnlyNodes.get(1)).put(node1DataPathSettings).build());
         ensureStableCluster(3);
         ensureGreen("test");
@@ -802,6 +886,89 @@ public void testBatchModeEnabled() throws Exception {
         assertEquals(0, gatewayAllocator.getNumberOfInFlightFetches());
     }
 
+    public void testBatchModeEnabledWithDisabledTimeoutAndClusterGreen() throws Exception {
+
+        internalCluster().startClusterManagerOnlyNodes(
+            1,
+            Settings.builder().put(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.getKey(), true).build()
+        );
+        List<String> dataOnlyNodes = internalCluster().startDataOnlyNodes(2);
+        createNIndices(50, "test"); // this will create 50p, 50r shards
+        ensureStableCluster(3);
+        IndicesStatsResponse indicesStats = dataNodeClient().admin().indices().prepareStats().get();
+        assertThat(indicesStats.getSuccessfulShards(), equalTo(100));
+        ClusterHealthResponse health = client().admin()
+            .cluster()
+            .health(Requests.clusterHealthRequest().waitForGreenStatus().timeout("1m"))
+            .actionGet();
+        assertFalse(health.isTimedOut());
+        assertEquals(GREEN, health.getStatus());
+
+        String clusterManagerName = internalCluster().getClusterManagerName();
+        Settings clusterManagerDataPathSettings = internalCluster().dataPathSettings(clusterManagerName);
+        Settings node0DataPathSettings = internalCluster().dataPathSettings(dataOnlyNodes.get(0));
+        Settings node1DataPathSettings = internalCluster().dataPathSettings(dataOnlyNodes.get(1));
+
+        internalCluster().stopCurrentClusterManagerNode();
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(dataOnlyNodes.get(0)));
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(dataOnlyNodes.get(1)));
+
+        // Now start cluster manager node and post that verify batches created
+        internalCluster().startClusterManagerOnlyNodes(
+            1,
+            Settings.builder()
+                .put("node.name", clusterManagerName)
+                .put(clusterManagerDataPathSettings)
+                .put(ShardsBatchGatewayAllocator.GATEWAY_ALLOCATOR_BATCH_SIZE.getKey(), 5)
+                .put(ShardsBatchGatewayAllocator.PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.getKey(), "-1")
+                .put(ShardsBatchGatewayAllocator.REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.getKey(), "-1")
+                .put(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.getKey(), true)
+                .build()
+        );
+        ensureStableCluster(1);
+
+        logger.info("--> Now do a protective reroute"); // to avoid any race condition in test
+        ClusterRerouteResponse clusterRerouteResponse = client().admin().cluster().prepareReroute().setRetryFailed(true).get();
+        assertTrue(clusterRerouteResponse.isAcknowledged());
+
+        ShardsBatchGatewayAllocator gatewayAllocator = internalCluster().getInstance(
+            ShardsBatchGatewayAllocator.class,
+            internalCluster().getClusterManagerName()
+        );
+
+        assertTrue(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.get(internalCluster().clusterService().getSettings()));
+        assertEquals(10, gatewayAllocator.getNumberOfStartedShardBatches());
+        // All replica shards would be marked ineligible since there are no data nodes.
+        // They would then be removed from any batch and batches would get deleted, so we would have 0 replica batches
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
+        health = client(internalCluster().getClusterManagerName()).admin().cluster().health(Requests.clusterHealthRequest()).actionGet();
+        assertFalse(health.isTimedOut());
+        assertEquals(RED, health.getStatus());
+        assertEquals(100, health.getUnassignedShards());
+        assertEquals(0, health.getInitializingShards());
+        assertEquals(0, health.getActiveShards());
+        assertEquals(0, health.getRelocatingShards());
+        assertEquals(0, health.getNumberOfDataNodes());
+
+        // Now start both data nodes and ensure batch mode is working
+        logger.info("--> restarting the stopped nodes");
+        internalCluster().startDataOnlyNode(Settings.builder().put("node.name", dataOnlyNodes.get(0)).put(node0DataPathSettings).build());
+        internalCluster().startDataOnlyNode(Settings.builder().put("node.name", dataOnlyNodes.get(1)).put(node1DataPathSettings).build());
+        ensureStableCluster(3);
+
+        // wait for cluster to turn green
+        health = client().admin().cluster().health(Requests.clusterHealthRequest().waitForGreenStatus().timeout("5m")).actionGet();
+        assertFalse(health.isTimedOut());
+        assertEquals(GREEN, health.getStatus());
+        assertEquals(0, health.getUnassignedShards());
+        assertEquals(0, health.getInitializingShards());
+        assertEquals(100, health.getActiveShards());
+        assertEquals(0, health.getRelocatingShards());
+        assertEquals(2, health.getNumberOfDataNodes());
+        assertEquals(0, gatewayAllocator.getNumberOfStartedShardBatches());
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
+    }
+
     public void testBatchModeDisabled() throws Exception {
         internalCluster().startClusterManagerOnlyNodes(
             1,
@@ -843,6 +1010,92 @@ public void testBatchModeDisabled() throws Exception {
         ensureGreen("test");
     }
 
+    public void testMultipleReplicaShardAssignmentWithDelayedAllocationAndDifferentNodeStartTimeInBatchMode() throws Exception {
+        internalCluster().startClusterManagerOnlyNodes(
+            1,
+            Settings.builder().put(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.getKey(), true).build()
+        );
+        internalCluster().startDataOnlyNodes(6);
+        createIndex(
+            "test",
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 3)
+                .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "60m")
+                .build()
+        );
+        ensureGreen("test");
+
+        List<String> nodesWithReplicaShards = findNodesWithShard(false);
+        Settings replicaNode0DataPathSettings = internalCluster().dataPathSettings(nodesWithReplicaShards.get(0));
+        Settings replicaNode1DataPathSettings = internalCluster().dataPathSettings(nodesWithReplicaShards.get(1));
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(nodesWithReplicaShards.get(0)));
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(nodesWithReplicaShards.get(1)));
+
+        ensureStableCluster(5);
+
+        logger.info("--> explicitly triggering reroute");
+        ClusterRerouteResponse clusterRerouteResponse = client().admin().cluster().prepareReroute().setRetryFailed(true).get();
+        assertTrue(clusterRerouteResponse.isAcknowledged());
+
+        ClusterHealthResponse health = client().admin().cluster().health(Requests.clusterHealthRequest().timeout("5m")).actionGet();
+        assertFalse(health.isTimedOut());
+        assertEquals(YELLOW, health.getStatus());
+        assertEquals(2, health.getUnassignedShards());
+        // shard should be unassigned because of Allocation_Delayed
+        BooleanSupplier delayedShardAllocationStatusVerificationSupplier = () -> AllocationDecision.ALLOCATION_DELAYED.equals(
+            client().admin()
+                .cluster()
+                .prepareAllocationExplain()
+                .setIndex("test")
+                .setShard(0)
+                .setPrimary(false)
+                .get()
+                .getExplanation()
+                .getShardAllocationDecision()
+                .getAllocateDecision()
+                .getAllocationDecision()
+        );
+        waitUntil(delayedShardAllocationStatusVerificationSupplier, 2, TimeUnit.MINUTES);
+
+        logger.info("--> restarting the node 1");
+        internalCluster().startDataOnlyNode(
+            Settings.builder().put("node.name", nodesWithReplicaShards.get(0)).put(replicaNode0DataPathSettings).build()
+        );
+        clusterRerouteResponse = client().admin().cluster().prepareReroute().setRetryFailed(true).get();
+        assertTrue(clusterRerouteResponse.isAcknowledged());
+        ensureStableCluster(6);
+        waitUntil(
+            () -> client().admin().cluster().health(Requests.clusterHealthRequest().timeout("5m")).actionGet().getActiveShards() == 3,
+            2,
+            TimeUnit.MINUTES
+        );
+        health = client().admin().cluster().health(Requests.clusterHealthRequest().timeout("5m")).actionGet();
+        assertFalse(health.isTimedOut());
+        assertEquals(YELLOW, health.getStatus());
+        assertEquals(1, health.getUnassignedShards());
+        assertEquals(1, health.getDelayedUnassignedShards());
+        waitUntil(delayedShardAllocationStatusVerificationSupplier, 2, TimeUnit.MINUTES);
+        logger.info("--> restarting the node 0");
+        internalCluster().startDataOnlyNode(
+            Settings.builder().put("node.name", nodesWithReplicaShards.get(1)).put(replicaNode1DataPathSettings).build()
+        );
+        ensureStableCluster(7);
+        ensureGreen("test");
+    }
+
+    public void testAllocationExplainReturnsNoWhenExtraReplicaShardInNonBatchMode() throws Exception {
+        // Non batch mode - This test is to validate that we don't return AWAITING_INFO in allocation explain API when the deciders are
+        // returning NO
+        this.allocationExplainReturnsNoWhenExtraReplicaShard(false);
+    }
+
+    public void testAllocationExplainReturnsNoWhenExtraReplicaShardInBatchMode() throws Exception {
+        // Batch mode - This test is to validate that we don't return AWAITING_INFO in allocation explain API when the deciders are
+        // returning NO
+        this.allocationExplainReturnsNoWhenExtraReplicaShard(true);
+    }
+
     public void testNBatchesCreationAndAssignment() throws Exception {
         // we will reduce batch size to 5 to make sure we have enough batches to test assignment
         // Total number of primary shards = 50 (50 indices*1)
@@ -896,7 +1149,9 @@ public void testNBatchesCreationAndAssignment() throws Exception {
         );
         assertTrue(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.get(internalCluster().clusterService().getSettings()));
         assertEquals(10, gatewayAllocator.getNumberOfStartedShardBatches());
-        assertEquals(10, gatewayAllocator.getNumberOfStoreShardBatches());
+        // All replica shards would be marked ineligible since there are no data nodes.
+        // They would then be removed from any batch and batches would get deleted, so we would have 0 replica batches
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
         health = client(internalCluster().getClusterManagerName()).admin().cluster().health(Requests.clusterHealthRequest()).actionGet();
         assertFalse(health.isTimedOut());
         assertEquals(RED, health.getStatus());
@@ -985,7 +1240,9 @@ public void testCulpritShardInBatch() throws Exception {
         );
         assertTrue(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.get(internalCluster().clusterService().getSettings()));
         assertEquals(1, gatewayAllocator.getNumberOfStartedShardBatches());
-        assertEquals(1, gatewayAllocator.getNumberOfStoreShardBatches());
+        // Replica shard would be marked ineligible since there are no data nodes.
+        // It would then be removed from any batch and batches would get deleted, so we would have 0 replica batches
+        assertEquals(0, gatewayAllocator.getNumberOfStoreShardBatches());
         assertTrue(clusterRerouteResponse.isAcknowledged());
         health = client(internalCluster().getClusterManagerName()).admin().cluster().health(Requests.clusterHealthRequest()).actionGet();
         assertFalse(health.isTimedOut());
@@ -1293,4 +1550,107 @@ private void prepareIndex(String indexName, int numberOfPrimaryShards) {
         index(indexName, "type", "1", Collections.emptyMap());
         flush(indexName);
     }
+
+    private List<String> findNodesWithShard(final boolean primary) {
+        ClusterState state = client().admin().cluster().prepareState().get().getState();
+        List<ShardRouting> startedShards = state.routingTable().shardsWithState(ShardRoutingState.STARTED);
+        List<ShardRouting> requiredStartedShards = startedShards.stream()
+            .filter(startedShard -> startedShard.primary() == primary)
+            .collect(Collectors.toList());
+        Collections.shuffle(requiredStartedShards, random());
+        return requiredStartedShards.stream().map(shard -> state.nodes().get(shard.currentNodeId()).getName()).collect(Collectors.toList());
+    }
+
+    private void allocationExplainReturnsNoWhenExtraReplicaShard(boolean batchModeEnabled) throws Exception {
+        internalCluster().startClusterManagerOnlyNodes(
+            1,
+            Settings.builder().put(ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.getKey(), batchModeEnabled).build()
+        );
+        internalCluster().startDataOnlyNodes(5);
+        createIndex(
+            "test",
+            Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 4).build()
+        );
+        ensureGreen("test");
+        ensureStableCluster(6);
+
+        // Stop one of the nodes to make the cluster yellow
+        // We cannot directly create an index with replica = data node count because then the whole flow will get skipped due to
+        // INDEX_CREATED
+        List<String> nodesWithReplicaShards = findNodesWithShard(false);
+        Settings replicaNodeDataPathSettings = internalCluster().dataPathSettings(nodesWithReplicaShards.get(0));
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(nodesWithReplicaShards.get(0)));
+
+        ensureStableCluster(5);
+        ensureYellow("test");
+
+        logger.info("--> calling allocation explain API");
+        // shard should have decision NO because there is no valid node for the extra replica to go to
+        AllocateUnassignedDecision aud = client().admin()
+            .cluster()
+            .prepareAllocationExplain()
+            .setIndex("test")
+            .setShard(0)
+            .setPrimary(false)
+            .get()
+            .getExplanation()
+            .getShardAllocationDecision()
+            .getAllocateDecision();
+
+        assertEquals(AllocationDecision.NO, aud.getAllocationDecision());
+        assertEquals("cannot allocate because allocation is not permitted to any of the nodes", aud.getExplanation());
+
+        // Now creating a new index with too many replicas and trying again
+        createIndex(
+            "test2",
+            Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 5).build()
+        );
+
+        ensureYellowAndNoInitializingShards("test2");
+
+        logger.info("--> calling allocation explain API again");
+        // shard should have decision NO because there are 6 replicas and 4 data nodes
+        aud = client().admin()
+            .cluster()
+            .prepareAllocationExplain()
+            .setIndex("test2")
+            .setShard(0)
+            .setPrimary(false)
+            .get()
+            .getExplanation()
+            .getShardAllocationDecision()
+            .getAllocateDecision();
+
+        assertEquals(AllocationDecision.NO, aud.getAllocationDecision());
+        assertEquals("cannot allocate because allocation is not permitted to any of the nodes", aud.getExplanation());
+
+        logger.info("--> restarting the stopped node");
+        internalCluster().startDataOnlyNode(
+            Settings.builder().put("node.name", nodesWithReplicaShards.get(0)).put(replicaNodeDataPathSettings).build()
+        );
+
+        ensureStableCluster(6);
+        ensureGreen("test");
+
+        logger.info("--> calling allocation explain API 3rd time");
+        // shard should still have decision NO because there are 6 replicas and 5 data nodes
+        aud = client().admin()
+            .cluster()
+            .prepareAllocationExplain()
+            .setIndex("test2")
+            .setShard(0)
+            .setPrimary(false)
+            .get()
+            .getExplanation()
+            .getShardAllocationDecision()
+            .getAllocateDecision();
+
+        assertEquals(AllocationDecision.NO, aud.getAllocationDecision());
+        assertEquals("cannot allocate because allocation is not permitted to any of the nodes", aud.getExplanation());
+
+        internalCluster().startDataOnlyNodes(1);
+
+        ensureStableCluster(7);
+        ensureGreen("test2");
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerIT.java
new file mode 100644
index 0000000000000..a50466573c575
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerIT.java
@@ -0,0 +1,300 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
+import org.opensearch.cluster.coordination.PersistedStateStats;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.discovery.DiscoveryStats;
+import org.opensearch.gateway.remote.model.RemoteRoutingTableBlobStore;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.junit.Before;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.CLUSTER_STATE_CLEANUP_INTERVAL_DEFAULT;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.RETAINED_MANIFESTS;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.SKIP_CLEANUP_STATE_CHANGES;
+import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
+import static org.opensearch.gateway.remote.RemoteUploadStats.REMOTE_UPLOAD;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+import static org.opensearch.indices.IndicesService.CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class RemoteClusterStateCleanupManagerIT extends RemoteStoreBaseIntegTestCase {
+
+    private static final String INDEX_NAME = "test-index";
+    private final RemoteStoreEnums.PathType pathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
+
+    @Before
+    public void setup() {
+        asyncUploadMockFsRepo = false;
+    }
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        return Settings.builder().put(super.nodeSettings(nodeOrdinal)).put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true).build();
+    }
+
+    private Map<String, Long> initialTestSetup(int shardCount, int replicaCount, int dataNodeCount, int clusterManagerNodeCount) {
+        prepareCluster(clusterManagerNodeCount, dataNodeCount, INDEX_NAME, replicaCount, shardCount);
+        Map<String, Long> indexStats = indexData(1, false, INDEX_NAME);
+        assertEquals(shardCount * (replicaCount + 1), getNumShards(INDEX_NAME).totalNumShards);
+        ensureGreen(INDEX_NAME);
+        return indexStats;
+    }
+
+    private void initialTestSetup(int shardCount, int replicaCount, int dataNodeCount, int clusterManagerNodeCount, Settings settings) {
+        prepareCluster(clusterManagerNodeCount, dataNodeCount, INDEX_NAME, replicaCount, shardCount, settings);
+        ensureGreen(INDEX_NAME);
+    }
+
+    public void testRemoteCleanupTaskUpdated() {
+        int shardCount = randomIntBetween(1, 2);
+        int replicaCount = 1;
+        int dataNodeCount = shardCount * (replicaCount + 1);
+        int clusterManagerNodeCount = 1;
+
+        initialTestSetup(shardCount, replicaCount, dataNodeCount, clusterManagerNodeCount);
+        RemoteClusterStateCleanupManager remoteClusterStateCleanupManager = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateCleanupManager.class
+        );
+
+        assertEquals(CLUSTER_STATE_CLEANUP_INTERVAL_DEFAULT, remoteClusterStateCleanupManager.getStaleFileDeletionTask().getInterval());
+        assertTrue(remoteClusterStateCleanupManager.getStaleFileDeletionTask().isScheduled());
+
+        // now disable
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING.getKey(), -1))
+            .get();
+
+        assertEquals(-1, remoteClusterStateCleanupManager.getStaleFileDeletionTask().getInterval().getMillis());
+        assertFalse(remoteClusterStateCleanupManager.getStaleFileDeletionTask().isScheduled());
+
+        // now set Clean up interval to 1 min
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING.getKey(), "1m"))
+            .get();
+        assertEquals(1, remoteClusterStateCleanupManager.getStaleFileDeletionTask().getInterval().getMinutes());
+    }
+
+    public void testRemoteCleanupDeleteStale() throws Exception {
+        int shardCount = randomIntBetween(1, 2);
+        int replicaCount = 1;
+        int dataNodeCount = shardCount * (replicaCount + 1);
+        int clusterManagerNodeCount = 1;
+
+        initialTestSetup(shardCount, replicaCount, dataNodeCount, clusterManagerNodeCount);
+
+        // update cluster state 21 times to ensure that clean up has run after this will upload 42 manifest files
+        // to repository, if manifest files are less than that it means clean up has run
+        updateClusterStateNTimes(RETAINED_MANIFESTS + SKIP_CLEANUP_STATE_CHANGES + 1);
+
+        RepositoriesService repositoriesService = internalCluster().getClusterManagerNodeInstance(RepositoriesService.class);
+        BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(REPOSITORY_NAME);
+        BlobPath baseMetadataPath = repository.basePath()
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(getClusterState().getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add("cluster-state")
+            .add(getClusterState().metadata().clusterUUID());
+        BlobPath manifestContainerPath = baseMetadataPath.add("manifest");
+        RemoteClusterStateCleanupManager remoteClusterStateCleanupManager = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateCleanupManager.class
+        );
+
+        // set cleanup interval to 100 ms to make the test faster
+        ClusterUpdateSettingsResponse response = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING.getKey(), "100ms"))
+            .get();
+
+        assertTrue(response.isAcknowledged());
+        assertBusy(() -> assertEquals(100, remoteClusterStateCleanupManager.getStaleFileDeletionTask().getInterval().getMillis()));
+
+        assertBusy(() -> {
+            int manifestFiles = repository.blobStore().blobContainer(manifestContainerPath).listBlobsByPrefix("manifest").size();
+            logger.info("number of current manifest file: {}", manifestFiles);
+            // we can't guarantee that we have same number of manifest as Retained manifest in our repo as there can be other queued task
+            // other than replica count change which can upload new manifest files, that's why we check that number of manifests is between
+            // Retained manifests and Retained manifests + 2 * Skip cleanup state changes (each cluster state update uploads 2 manifests)
+            assertTrue(
+                "Current number of manifest files: " + manifestFiles,
+                manifestFiles >= RETAINED_MANIFESTS && manifestFiles < RETAINED_MANIFESTS + 2 * SKIP_CLEANUP_STATE_CHANGES
+            );
+        });
+
+        // disable the clean up to avoid race condition during shutdown
+        response = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING.getKey(), "-1"))
+            .get();
+
+        assertTrue(response.isAcknowledged());
+    }
+
+    public void testRemoteCleanupDeleteStaleIndexRoutingFiles() throws Exception {
+        clusterSettingsSuppliedByTest = true;
+        Path segmentRepoPath = randomRepoPath();
+        Path translogRepoPath = randomRepoPath();
+        Path remoteRoutingTableRepoPath = randomRepoPath();
+        Settings.Builder settingsBuilder = Settings.builder();
+        settingsBuilder.put(
+            buildRemoteStoreNodeAttributes(
+                REPOSITORY_NAME,
+                segmentRepoPath,
+                REPOSITORY_2_NAME,
+                translogRepoPath,
+                REMOTE_ROUTING_TABLE_REPO,
+                remoteRoutingTableRepoPath,
+                false
+            )
+        );
+        settingsBuilder.put(
+            RemoteRoutingTableBlobStore.REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING.getKey(),
+            RemoteStoreEnums.PathType.HASHED_PREFIX.toString()
+        )
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, REMOTE_ROUTING_TABLE_REPO)
+            .put(REMOTE_PUBLICATION_EXPERIMENTAL, true);
+
+        int shardCount = randomIntBetween(1, 2);
+        int replicaCount = 1;
+        int dataNodeCount = shardCount * (replicaCount + 1);
+        int clusterManagerNodeCount = 1;
+        initialTestSetup(shardCount, replicaCount, dataNodeCount, clusterManagerNodeCount, settingsBuilder.build());
+
+        // update cluster state 21 times to ensure that clean up has run after this will upload 42 manifest files
+        // to repository, if manifest files are less than that it means clean up has run
+        updateClusterStateNTimes(RETAINED_MANIFESTS + SKIP_CLEANUP_STATE_CHANGES + 1);
+
+        RepositoriesService repositoriesService = internalCluster().getClusterManagerNodeInstance(RepositoriesService.class);
+        BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(REPOSITORY_NAME);
+        BlobPath baseMetadataPath = getBaseMetadataPath(repository);
+
+        BlobStoreRepository routingTableRepository = (BlobStoreRepository) repositoriesService.repository(REMOTE_ROUTING_TABLE_REPO);
+        List<IndexRoutingTable> indexRoutingTables = new ArrayList<>(getClusterState().routingTable().indicesRouting().values());
+        BlobPath indexRoutingPath = getIndexRoutingPath(baseMetadataPath, indexRoutingTables.get(0).getIndex().getUUID());
+        assertBusy(() -> {
+            // There would be >=3 files as shards will transition from UNASSIGNED -> INIT -> STARTED state
+            assertTrue(routingTableRepository.blobStore().blobContainer(indexRoutingPath).listBlobs().size() >= 3);
+        });
+
+        RemoteClusterStateCleanupManager remoteClusterStateCleanupManager = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateCleanupManager.class
+        );
+
+        // set cleanup interval to 100 ms to make the test faster
+        ClusterUpdateSettingsResponse response = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING.getKey(), "100ms"))
+            .get();
+
+        assertTrue(response.isAcknowledged());
+        assertBusy(() -> assertEquals(100, remoteClusterStateCleanupManager.getStaleFileDeletionTask().getInterval().getMillis()));
+
+        String clusterManagerNode = internalCluster().getClusterManagerName();
+        NodesStatsResponse nodesStatsResponse = client().admin()
+            .cluster()
+            .prepareNodesStats(clusterManagerNode)
+            .addMetric(NodesStatsRequest.Metric.DISCOVERY.metricName())
+            .get();
+        verifyIndexRoutingFilesDeletion(routingTableRepository, indexRoutingPath, nodesStatsResponse);
+
+        // disable the clean up to avoid race condition during shutdown
+        response = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING.getKey(), "-1"))
+            .get();
+        assertTrue(response.isAcknowledged());
+    }
+
+    private void verifyIndexRoutingFilesDeletion(
+        BlobStoreRepository routingTableRepository,
+        BlobPath indexRoutingPath,
+        NodesStatsResponse nodesStatsResponse
+    ) throws Exception {
+        assertBusy(() -> { assertEquals(1, routingTableRepository.blobStore().blobContainer(indexRoutingPath).listBlobs().size()); });
+
+        // Verify index routing files delete stats
+        DiscoveryStats discoveryStats = nodesStatsResponse.getNodes().get(0).getDiscoveryStats();
+        assertNotNull(discoveryStats.getClusterStateStats());
+        for (PersistedStateStats persistedStateStats : discoveryStats.getClusterStateStats().getPersistenceStats()) {
+            if (Objects.equals(persistedStateStats.getStatsName(), REMOTE_UPLOAD)) {
+                Map<String, AtomicLong> extendedFields = persistedStateStats.getExtendedFields();
+                assertTrue(extendedFields.containsKey(RemoteUploadStats.INDEX_ROUTING_FILES_CLEANUP_ATTEMPT_FAILED_COUNT));
+                long cleanupAttemptFailedCount = extendedFields.get(RemoteUploadStats.INDEX_ROUTING_FILES_CLEANUP_ATTEMPT_FAILED_COUNT)
+                    .get();
+                assertEquals(0, cleanupAttemptFailedCount);
+            }
+        }
+    }
+
+    private void updateClusterStateNTimes(int n) {
+        int newReplicaCount = randomIntBetween(0, 3);
+        for (int i = n; i > 0; i--) {
+            ClusterUpdateSettingsResponse response = client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(Settings.builder().put(CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING.getKey(), i, TimeUnit.SECONDS))
+                .get();
+            assertTrue(response.isAcknowledged());
+        }
+    }
+
+    private BlobPath getBaseMetadataPath(BlobStoreRepository repository) {
+        return repository.basePath()
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(getClusterState().getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add("cluster-state")
+            .add(getClusterState().metadata().clusterUUID());
+    }
+
+    private BlobPath getIndexRoutingPath(BlobPath baseMetadataPath, String indexUUID) {
+        return pathType.path(
+            RemoteStorePathStrategy.BasePathInput.builder()
+                .basePath(baseMetadataPath.add(INDEX_ROUTING_TABLE))
+                .indexUUID(indexUUID)
+                .build(),
+            RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64
+        );
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateServiceIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateServiceIT.java
index 07377caaba0bc..f6c7355ea06f6 100644
--- a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateServiceIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteClusterStateServiceIT.java
@@ -10,7 +10,6 @@
 
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
-import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.discovery.DiscoveryStats;
@@ -20,13 +19,20 @@
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.junit.Before;
 
+import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.util.Base64;
 import java.util.Map;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
 import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.METADATA_FILE_PREFIX;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_METADATA;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteClusterStateServiceIT extends RemoteStoreBaseIntegTestCase {
@@ -43,16 +49,6 @@ protected Settings nodeSettings(int nodeOrdinal) {
         return Settings.builder().put(super.nodeSettings(nodeOrdinal)).put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true).build();
     }
 
-    private void prepareCluster(int numClusterManagerNodes, int numDataOnlyNodes, String indices, int replicaCount, int shardCount) {
-        internalCluster().startClusterManagerOnlyNodes(numClusterManagerNodes);
-        internalCluster().startDataOnlyNodes(numDataOnlyNodes);
-        for (String index : indices.split(",")) {
-            createIndex(index, remoteStoreIndexSettings(replicaCount, shardCount));
-            ensureYellowAndNoInitializingShards(index);
-            ensureGreen(index);
-        }
-    }
-
     private Map<String, Long> initialTestSetup(int shardCount, int replicaCount, int dataNodeCount, int clusterManagerNodeCount) {
         prepareCluster(clusterManagerNodeCount, dataNodeCount, INDEX_NAME, replicaCount, shardCount);
         Map<String, Long> indexStats = indexData(1, false, INDEX_NAME);
@@ -61,49 +57,6 @@ private Map<String, Long> initialTestSetup(int shardCount, int replicaCount, int
         return indexStats;
     }
 
-    public void testFullClusterRestoreStaleDelete() throws Exception {
-        int shardCount = randomIntBetween(1, 2);
-        int replicaCount = 1;
-        int dataNodeCount = shardCount * (replicaCount + 1);
-        int clusterManagerNodeCount = 1;
-
-        initialTestSetup(shardCount, replicaCount, dataNodeCount, clusterManagerNodeCount);
-        setReplicaCount(0);
-        setReplicaCount(2);
-        setReplicaCount(0);
-        setReplicaCount(1);
-        setReplicaCount(0);
-        setReplicaCount(1);
-        setReplicaCount(0);
-        setReplicaCount(2);
-        setReplicaCount(0);
-
-        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
-            RemoteClusterStateService.class
-        );
-
-        RepositoriesService repositoriesService = internalCluster().getClusterManagerNodeInstance(RepositoriesService.class);
-
-        BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(REPOSITORY_NAME);
-        BlobPath baseMetadataPath = repository.basePath()
-            .add(
-                Base64.getUrlEncoder()
-                    .withoutPadding()
-                    .encodeToString(getClusterState().getClusterName().value().getBytes(StandardCharsets.UTF_8))
-            )
-            .add("cluster-state")
-            .add(getClusterState().metadata().clusterUUID());
-
-        assertEquals(10, repository.blobStore().blobContainer(baseMetadataPath.add("manifest")).listBlobsByPrefix("manifest").size());
-
-        Map<String, IndexMetadata> indexMetadataMap = remoteClusterStateService.getLatestClusterState(
-            cluster().getClusterName(),
-            getClusterState().metadata().clusterUUID()
-        ).getMetadata().getIndices();
-        assertEquals(0, indexMetadataMap.values().stream().findFirst().get().getNumberOfReplicas());
-        assertEquals(shardCount, indexMetadataMap.values().stream().findFirst().get().getNumberOfShards());
-    }
-
     public void testRemoteStateStats() {
         int shardCount = randomIntBetween(1, 2);
         int replicaCount = 1;
@@ -187,6 +140,45 @@ public void testRemoteStateStatsFromAllNodes() {
         }
     }
 
+    public void testRemoteClusterStateMetadataSplit() throws IOException {
+        initialTestSetup(1, 0, 1, 1);
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RepositoriesService repositoriesService = internalCluster().getClusterManagerNodeInstance(RepositoriesService.class);
+        BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(REPOSITORY_NAME);
+        BlobPath globalMetadataPath = repository.basePath()
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(getClusterState().getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add("cluster-state")
+            .add(getClusterState().metadata().clusterUUID())
+            .add("global-metadata");
+
+        Map<String, Integer> metadataFiles = repository.blobStore()
+            .blobContainer(globalMetadataPath)
+            .listBlobs()
+            .keySet()
+            .stream()
+            .map(fileName -> {
+                logger.info(fileName);
+                return fileName.split(DELIMITER)[0];
+            })
+            .collect(Collectors.toMap(Function.identity(), key -> 1, Integer::sum));
+
+        assertTrue(metadataFiles.containsKey(COORDINATION_METADATA));
+        assertEquals(1, (int) metadataFiles.get(COORDINATION_METADATA));
+        assertTrue(metadataFiles.containsKey(SETTING_METADATA));
+        assertEquals(1, (int) metadataFiles.get(SETTING_METADATA));
+        assertTrue(metadataFiles.containsKey(TEMPLATES_METADATA));
+        assertEquals(1, (int) metadataFiles.get(TEMPLATES_METADATA));
+        assertTrue(metadataFiles.keySet().stream().anyMatch(key -> key.startsWith(CUSTOM_METADATA)));
+        assertFalse(metadataFiles.containsKey(METADATA_FILE_PREFIX));
+    }
+
     private void validateNodesStatsResponse(NodesStatsResponse nodesStatsResponse) {
         // _nodes/stats/discovery must never fail due to any exception
         assertFalse(nodesStatsResponse.toString().contains("exception"));
@@ -194,12 +186,4 @@ private void validateNodesStatsResponse(NodesStatsResponse nodesStatsResponse) {
         assertNotNull(nodesStatsResponse.getNodes().get(0));
         assertNotNull(nodesStatsResponse.getNodes().get(0).getDiscoveryStats());
     }
-
-    private void setReplicaCount(int replicaCount) {
-        client().admin()
-            .indices()
-            .prepareUpdateSettings(INDEX_NAME)
-            .setSettings(Settings.builder().put(SETTING_NUMBER_OF_REPLICAS, replicaCount))
-            .get();
-    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteRoutingTableServiceIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteRoutingTableServiceIT.java
new file mode 100644
index 0000000000000..4d4ad89cc0abb
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteRoutingTableServiceIT.java
@@ -0,0 +1,439 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
+import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.gateway.remote.model.RemoteRoutingTableBlobStore;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
+import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+import static org.opensearch.indices.IndicesService.CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class RemoteRoutingTableServiceIT extends RemoteStoreBaseIntegTestCase {
+    private static final String INDEX_NAME = "test-index";
+    private static final String INDEX_NAME_1 = "test-index-1";
+    List<BlobPath> indexRoutingPaths;
+    AtomicInteger indexRoutingFiles = new AtomicInteger();
+    private final RemoteStoreEnums.PathType pathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
+
+    @Before
+    public void setup() {
+        asyncUploadMockFsRepo = false;
+    }
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
+            .put(
+                RemoteRoutingTableBlobStore.REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING.getKey(),
+                RemoteStoreEnums.PathType.HASHED_PREFIX.toString()
+            )
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, REMOTE_ROUTING_TABLE_REPO)
+            .put(REMOTE_PUBLICATION_EXPERIMENTAL, true)
+            .put(
+                RemoteClusterStateService.REMOTE_CLUSTER_STATE_CHECKSUM_VALIDATION_MODE_SETTING.getKey(),
+                RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE
+            )
+            .build();
+    }
+
+    public void testRemoteRoutingTableIndexLifecycle() throws Exception {
+        BlobStoreRepository repository = prepareClusterAndVerifyRepository();
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+
+        List<RoutingTable> routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Update index settings
+        updateIndexSettings(INDEX_NAME, IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 2);
+        ensureGreen(INDEX_NAME);
+        assertBusy(() -> {
+            int indexRoutingFilesAfterUpdate = repository.blobStore().blobContainer(indexRoutingPaths.get(0)).listBlobs().size();
+            // At-least 3 new index routing files will be created as shards will transition from INIT -> UNASSIGNED -> STARTED state
+            assertTrue(indexRoutingFilesAfterUpdate >= indexRoutingFiles.get() + 3);
+        });
+
+        latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+
+        routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Delete the index and assert its deletion
+        deleteIndexAndVerify(remoteManifestManager);
+
+        routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+    }
+
+    public void testRemoteRoutingTableWithMultipleIndex() throws Exception {
+        BlobStoreRepository repository = prepareClusterAndVerifyRepository();
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+
+        List<RoutingTable> routingTables = getRoutingTableFromAllNodes();
+        // Verify indices in routing table
+        Set<String> expectedIndicesInRoutingTable = Set.of(INDEX_NAME);
+        assertEquals(routingTables.get(0).getIndicesRouting().keySet(), expectedIndicesInRoutingTable);
+        // Verify routing table across all nodes is equal
+        assertTrue(areRoutingTablesSame(routingTables));
+
+        // Create new index
+        createIndex(INDEX_NAME_1, remoteStoreIndexSettings(1, 5));
+        ensureGreen(INDEX_NAME_1);
+
+        latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+
+        updateIndexRoutingPaths(repository);
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 2, deletedIndexNames, true);
+        routingTables = getRoutingTableFromAllNodes();
+        // Verify indices in routing table
+        expectedIndicesInRoutingTable = Set.of(INDEX_NAME, INDEX_NAME_1);
+        assertEquals(routingTables.get(0).getIndicesRouting().keySet(), expectedIndicesInRoutingTable);
+        // Verify routing table across all nodes is equal
+        assertTrue(areRoutingTablesSame(routingTables));
+    }
+
+    public void testRemoteRoutingTableEmptyRoutingTableDiff() throws Exception {
+        prepareClusterAndVerifyRepository();
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+
+        List<RoutingTable> routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Update cluster settings
+        ClusterUpdateSettingsResponse response = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING.getKey(), 0, TimeUnit.SECONDS))
+            .get();
+        assertTrue(response.isAcknowledged());
+
+        latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, false);
+
+        routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+    }
+
+    public void testRemoteRoutingTableIndexNodeRestart() throws Exception {
+        BlobStoreRepository repository = prepareClusterAndVerifyRepository();
+
+        List<RoutingTable> routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Ensure node comes healthy after restart
+        Set<String> dataNodes = internalCluster().getDataNodeNames();
+        internalCluster().restartNode(randomFrom(dataNodes));
+        ensureGreen();
+        ensureGreen(INDEX_NAME);
+
+        // ensure restarted node joins and the cluster is stable
+        assertEquals(3, internalCluster().clusterService().state().nodes().getDataNodes().size());
+        ensureStableCluster(4);
+        assertRemoteStoreRepositoryOnAllNodes(REMOTE_ROUTING_TABLE_REPO);
+
+        assertBusy(() -> {
+            int indexRoutingFilesAfterNodeDrop = repository.blobStore().blobContainer(indexRoutingPaths.get(0)).listBlobs().size();
+            assertTrue(indexRoutingFilesAfterNodeDrop > indexRoutingFiles.get());
+        });
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+    }
+
+    public void testRemoteRoutingTableIndexMasterRestart() throws Exception {
+        BlobStoreRepository repository = prepareClusterAndVerifyRepository();
+
+        List<RoutingTable> routingTableVersions = getRoutingTableFromAllNodes();
+        assertTrue(areRoutingTablesSame(routingTableVersions));
+
+        // Ensure node comes healthy after restart
+        String clusterManagerName = internalCluster().getClusterManagerName();
+        internalCluster().restartNode(clusterManagerName);
+        ensureGreen();
+        ensureGreen(INDEX_NAME);
+
+        // ensure master is elected and the cluster is stable
+        assertNotNull(internalCluster().clusterService().state().nodes().getClusterManagerNode());
+        ensureStableCluster(4);
+        assertRemoteStoreRepositoryOnAllNodes(REMOTE_ROUTING_TABLE_REPO);
+
+        assertBusy(() -> {
+            int indexRoutingFilesAfterNodeDrop = repository.blobStore().blobContainer(indexRoutingPaths.get(0)).listBlobs().size();
+            assertTrue(indexRoutingFilesAfterNodeDrop > indexRoutingFiles.get());
+        });
+
+        RemoteClusterStateService remoteClusterStateService = internalCluster().getClusterManagerNodeInstance(
+            RemoteClusterStateService.class
+        );
+        RemoteManifestManager remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        List<String> expectedIndexNames = new ArrayList<>();
+        List<String> deletedIndexNames = new ArrayList<>();
+        verifyUpdatesInManifestFile(latestManifest, expectedIndexNames, 1, deletedIndexNames, true);
+    }
+
+    private BlobStoreRepository prepareClusterAndVerifyRepository() throws Exception {
+        clusterSettingsSuppliedByTest = true;
+        Path segmentRepoPath = randomRepoPath();
+        Path translogRepoPath = randomRepoPath();
+        Path remoteRoutingTableRepoPath = randomRepoPath();
+        Settings settings = buildRemoteStoreNodeAttributes(
+            REPOSITORY_NAME,
+            segmentRepoPath,
+            REPOSITORY_2_NAME,
+            translogRepoPath,
+            REMOTE_ROUTING_TABLE_REPO,
+            remoteRoutingTableRepoPath,
+            false
+        );
+        prepareCluster(1, 3, INDEX_NAME, 1, 5, settings);
+        ensureGreen(INDEX_NAME);
+
+        RepositoriesService repositoriesService = internalCluster().getClusterManagerNodeInstance(RepositoriesService.class);
+        BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(REMOTE_ROUTING_TABLE_REPO);
+
+        BlobPath baseMetadataPath = getBaseMetadataPath(repository);
+        List<IndexRoutingTable> indexRoutingTables = new ArrayList<>(getClusterState().routingTable().indicesRouting().values());
+        indexRoutingPaths = new ArrayList<>();
+        for (IndexRoutingTable indexRoutingTable : indexRoutingTables) {
+            indexRoutingPaths.add(getIndexRoutingPath(baseMetadataPath.add(INDEX_ROUTING_TABLE), indexRoutingTable.getIndex().getUUID()));
+        }
+
+        assertBusy(() -> {
+            int totalRoutingFiles = calculateTotalRoutingFiles(repository);
+            indexRoutingFiles.set(totalRoutingFiles);
+            // There would be >=3 files as shards will transition from UNASSIGNED -> INIT -> STARTED state
+            assertTrue(indexRoutingFiles.get() >= 3);
+        });
+        assertRemoteStoreRepositoryOnAllNodes(REMOTE_ROUTING_TABLE_REPO);
+        return repository;
+    }
+
+    private BlobPath getBaseMetadataPath(BlobStoreRepository repository) {
+        return repository.basePath()
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(getClusterState().getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add("cluster-state")
+            .add(getClusterState().metadata().clusterUUID());
+    }
+
+    private BlobPath getIndexRoutingPath(BlobPath indexRoutingPath, String indexUUID) {
+        RemoteStoreEnums.PathHashAlgorithm pathHashAlgo = RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+        return pathType.path(
+            RemoteStorePathStrategy.BasePathInput.builder().basePath(indexRoutingPath).indexUUID(indexUUID).build(),
+            pathHashAlgo
+        );
+    }
+
+    private void verifyUpdatesInManifestFile(
+        Optional<ClusterMetadataManifest> latestManifest,
+        List<String> expectedIndexNames,
+        int expectedIndicesRoutingFilesInManifest,
+        List<String> expectedDeletedIndex,
+        boolean isRoutingTableDiffFileExpected
+    ) {
+        assertTrue(latestManifest.isPresent());
+        ClusterMetadataManifest manifest = latestManifest.get();
+
+        assertEquals(expectedDeletedIndex, manifest.getDiffManifest().getIndicesDeleted());
+        assertEquals(expectedIndicesRoutingFilesInManifest, manifest.getIndicesRouting().size());
+
+        // Check if all paths in manifest.getIndicesRouting() are present in indexRoutingPaths
+        for (ClusterMetadataManifest.UploadedIndexMetadata uploadedFilename : manifest.getIndicesRouting()) {
+            boolean pathFound = false;
+            for (BlobPath indexRoutingPath : indexRoutingPaths) {
+                if (uploadedFilename.getUploadedFilename().contains(indexRoutingPath.buildAsString())) {
+                    pathFound = true;
+                    break;
+                }
+            }
+            assertTrue("Uploaded file not found in indexRoutingPaths: " + uploadedFilename.getUploadedFilename(), pathFound);
+        }
+        assertEquals(isRoutingTableDiffFileExpected, manifest.getDiffManifest().getIndicesRoutingDiffPath() != null);
+    }
+
+    private List<RoutingTable> getRoutingTableFromAllNodes() throws ExecutionException, InterruptedException {
+        String[] allNodes = internalCluster().getNodeNames();
+        List<RoutingTable> routingTables = new ArrayList<>();
+        for (String node : allNodes) {
+            RoutingTable routingTable = internalCluster().client(node)
+                .admin()
+                .cluster()
+                .state(new ClusterStateRequest().local(true))
+                .get()
+                .getState()
+                .routingTable();
+            routingTables.add(routingTable);
+        }
+        return routingTables;
+    }
+
+    private void updateIndexRoutingPaths(BlobStoreRepository repository) {
+        BlobPath baseMetadataPath = getBaseMetadataPath(repository);
+        List<IndexRoutingTable> indexRoutingTables = new ArrayList<>(getClusterState().routingTable().indicesRouting().values());
+
+        indexRoutingPaths.clear(); // Clear the list to avoid stale data
+        for (IndexRoutingTable indexRoutingTable : indexRoutingTables) {
+            indexRoutingPaths.add(getIndexRoutingPath(baseMetadataPath.add(INDEX_ROUTING_TABLE), indexRoutingTable.getIndex().getUUID()));
+        }
+    }
+
+    private int calculateTotalRoutingFiles(BlobStoreRepository repository) throws IOException {
+        int totalRoutingFiles = 0;
+        for (BlobPath path : indexRoutingPaths) {
+            totalRoutingFiles += repository.blobStore().blobContainer(path).listBlobs().size();
+        }
+        return totalRoutingFiles;
+    }
+
+    private boolean areRoutingTablesSame(List<RoutingTable> routingTables) {
+        if (routingTables == null || routingTables.isEmpty()) {
+            return false;
+        }
+
+        RoutingTable firstRoutingTable = routingTables.get(0);
+        for (RoutingTable routingTable : routingTables) {
+            if (!compareRoutingTables(firstRoutingTable, routingTable)) {
+                logger.info("Responses are not the same: {} {}", firstRoutingTable, routingTable);
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean compareRoutingTables(RoutingTable a, RoutingTable b) {
+        if (a == b) return true;
+        if (b == null || a.getClass() != b.getClass()) return false;
+        if (a.version() != b.version()) return false;
+        if (a.indicesRouting().size() != b.indicesRouting().size()) return false;
+
+        for (Map.Entry<String, IndexRoutingTable> entry : a.indicesRouting().entrySet()) {
+            IndexRoutingTable thisIndexRoutingTable = entry.getValue();
+            IndexRoutingTable thatIndexRoutingTable = b.indicesRouting().get(entry.getKey());
+            if (!thatIndexRoutingTable.equals(thatIndexRoutingTable)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private void updateIndexSettings(String indexName, String settingKey, int settingValue) {
+        client().admin()
+            .indices()
+            .prepareUpdateSettings(indexName)
+            .setSettings(Settings.builder().put(settingKey, settingValue))
+            .execute()
+            .actionGet();
+    }
+
+    private void deleteIndexAndVerify(RemoteManifestManager remoteManifestManager) {
+        client().admin().indices().prepareDelete(INDEX_NAME).execute().actionGet();
+        assertFalse(client().admin().indices().prepareExists(INDEX_NAME).get().isExists());
+
+        // Verify index is marked deleted in manifest
+        Optional<ClusterMetadataManifest> latestManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            getClusterState().getClusterName().value(),
+            getClusterState().getMetadata().clusterUUID()
+        );
+        assertTrue(latestManifest.isPresent());
+        ClusterMetadataManifest manifest = latestManifest.get();
+        assertTrue(manifest.getDiffManifest().getIndicesDeleted().contains(INDEX_NAME));
+        assertTrue(manifest.getIndicesRouting().isEmpty());
+    }
+
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteStatePublicationIT.java b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteStatePublicationIT.java
new file mode 100644
index 0000000000000..0e6321867a33b
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/gateway/remote/RemoteStatePublicationIT.java
@@ -0,0 +1,212 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.client.Client;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.discovery.DiscoveryStats;
+import org.opensearch.gateway.remote.model.RemoteClusterMetadataManifest;
+import org.opensearch.indices.recovery.RecoverySettings;
+import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.fs.ReloadableFsRepository;
+import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
+import org.opensearch.test.OpenSearchIntegTestCase.Scope;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.Locale;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.DISCOVERY_NODES;
+import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.model.RemoteClusterBlocks.CLUSTER_BLOCKS;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_METADATA;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+
+@ClusterScope(scope = Scope.TEST, numDataNodes = 0)
+public class RemoteStatePublicationIT extends RemoteStoreBaseIntegTestCase {
+
+    private static String INDEX_NAME = "test-index";
+    private boolean isRemoteStateEnabled = true;
+    private String isRemotePublicationEnabled = "true";
+
+    @Before
+    public void setup() {
+        asyncUploadMockFsRepo = false;
+        isRemoteStateEnabled = true;
+        isRemotePublicationEnabled = "true";
+    }
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder()
+            .put(super.featureFlagSettings())
+            .put(FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL, isRemotePublicationEnabled)
+            .build();
+    }
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        String routingTableRepoName = "remote-routing-repo";
+        String routingTableRepoTypeAttributeKey = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+            routingTableRepoName
+        );
+        String routingTableRepoSettingsAttributeKeyPrefix = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+            routingTableRepoName
+        );
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), isRemoteStateEnabled)
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, routingTableRepoName)
+            .put(routingTableRepoTypeAttributeKey, ReloadableFsRepository.TYPE)
+            .put(routingTableRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath)
+            .put(
+                RemoteClusterStateService.REMOTE_CLUSTER_STATE_CHECKSUM_VALIDATION_MODE_SETTING.getKey(),
+                RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE
+            )
+            .build();
+    }
+
+    public void testPublication() throws Exception {
+        // create cluster with multi node (3 master + 2 data)
+        prepareCluster(3, 2, INDEX_NAME, 1, 2);
+        ensureStableCluster(5);
+        ensureGreen(INDEX_NAME);
+        // update settings on a random node
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .updateSettings(
+                    new ClusterUpdateSettingsRequest().persistentSettings(
+                        Settings.builder().put(RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey(), "10mb").build()
+                    )
+                )
+                .actionGet()
+        );
+
+        RepositoriesService repositoriesService = internalCluster().getClusterManagerNodeInstance(RepositoriesService.class);
+        BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(REPOSITORY_NAME);
+
+        Map<String, Integer> globalMetadataFiles = getMetadataFiles(repository, RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN);
+
+        assertTrue(globalMetadataFiles.containsKey(COORDINATION_METADATA));
+        assertTrue(globalMetadataFiles.containsKey(SETTING_METADATA));
+        assertTrue(globalMetadataFiles.containsKey(TRANSIENT_SETTING_METADATA));
+        assertTrue(globalMetadataFiles.containsKey(TEMPLATES_METADATA));
+        assertTrue(globalMetadataFiles.keySet().stream().anyMatch(key -> key.startsWith(CUSTOM_METADATA)));
+
+        Map<String, Integer> ephemeralMetadataFiles = getMetadataFiles(
+            repository,
+            RemoteClusterStateUtils.CLUSTER_STATE_EPHEMERAL_PATH_TOKEN
+        );
+
+        assertTrue(ephemeralMetadataFiles.containsKey(CLUSTER_BLOCKS));
+        assertTrue(ephemeralMetadataFiles.containsKey(DISCOVERY_NODES));
+
+        Map<String, Integer> manifestFiles = getMetadataFiles(repository, RemoteClusterMetadataManifest.MANIFEST);
+        assertTrue(manifestFiles.containsKey(RemoteClusterMetadataManifest.MANIFEST));
+
+        // get settings from each node and verify that it is updated
+        Settings settings = clusterService().getSettings();
+        logger.info("settings : {}", settings);
+        for (Client client : clients()) {
+            ClusterStateResponse response = client.admin().cluster().prepareState().clear().setMetadata(true).get();
+            String refreshSetting = response.getState()
+                .metadata()
+                .settings()
+                .get(RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey());
+            assertEquals("10mb", refreshSetting);
+        }
+    }
+
+    public void testRemotePublicationDisableIfRemoteStateDisabled() {
+        // only disable remote state
+        isRemoteStateEnabled = false;
+        // create cluster with multi node with in-consistent settings
+        prepareCluster(3, 2, INDEX_NAME, 1, 2);
+        // assert cluster is stable, ensuring publication falls back to legacy transport with inconsistent settings
+        ensureStableCluster(5);
+        ensureGreen(INDEX_NAME);
+
+        assertNull(internalCluster().getCurrentClusterManagerNodeInstance(RemoteClusterStateService.class));
+    }
+
+    public void testRemotePublicationDownloadStats() {
+        int shardCount = randomIntBetween(1, 2);
+        int replicaCount = 1;
+        int dataNodeCount = shardCount * (replicaCount + 1);
+        int clusterManagerNodeCount = 1;
+        prepareCluster(clusterManagerNodeCount, dataNodeCount, INDEX_NAME, replicaCount, shardCount);
+        String dataNode = internalCluster().getDataNodeNames().stream().collect(Collectors.toList()).get(0);
+
+        NodesStatsResponse nodesStatsResponseDataNode = client().admin()
+            .cluster()
+            .prepareNodesStats(dataNode)
+            .addMetric(NodesStatsRequest.Metric.DISCOVERY.metricName())
+            .get();
+
+        assertDataNodeDownloadStats(nodesStatsResponseDataNode);
+
+    }
+
+    private void assertDataNodeDownloadStats(NodesStatsResponse nodesStatsResponse) {
+        // assert cluster state stats for data node
+        DiscoveryStats dataNodeDiscoveryStats = nodesStatsResponse.getNodes().get(0).getDiscoveryStats();
+        assertNotNull(dataNodeDiscoveryStats.getClusterStateStats());
+        assertEquals(0, dataNodeDiscoveryStats.getClusterStateStats().getUpdateSuccess());
+        assertTrue(dataNodeDiscoveryStats.getClusterStateStats().getPersistenceStats().get(0).getSuccessCount() > 0);
+        assertEquals(0, dataNodeDiscoveryStats.getClusterStateStats().getPersistenceStats().get(0).getFailedCount());
+        assertTrue(dataNodeDiscoveryStats.getClusterStateStats().getPersistenceStats().get(0).getTotalTimeInMillis() > 0);
+
+        assertTrue(dataNodeDiscoveryStats.getClusterStateStats().getPersistenceStats().get(1).getSuccessCount() > 0);
+        assertEquals(0, dataNodeDiscoveryStats.getClusterStateStats().getPersistenceStats().get(1).getFailedCount());
+        assertTrue(dataNodeDiscoveryStats.getClusterStateStats().getPersistenceStats().get(1).getTotalTimeInMillis() > 0);
+    }
+
+    private Map<String, Integer> getMetadataFiles(BlobStoreRepository repository, String subDirectory) throws IOException {
+        BlobPath metadataPath = repository.basePath()
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(getClusterState().getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add(RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN)
+            .add(getClusterState().metadata().clusterUUID())
+            .add(subDirectory);
+        return repository.blobStore().blobContainer(metadataPath).listBlobs().keySet().stream().map(fileName -> {
+            logger.info(fileName);
+            return fileName.split(DELIMITER)[0];
+        }).collect(Collectors.toMap(Function.identity(), key -> 1, Integer::sum));
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/index/mapper/StarTreeMapperIT.java b/server/src/internalClusterTest/java/org/opensearch/index/mapper/StarTreeMapperIT.java
new file mode 100644
index 0000000000000..0d69b762ab4f2
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/index/mapper/StarTreeMapperIT.java
@@ -0,0 +1,743 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.action.index.IndexResponse;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.IndexService;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.query.QueryBuilders;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.search.SearchHit;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+
+/**
+ * Integration tests for star tree mapper
+ */
+public class StarTreeMapperIT extends OpenSearchIntegTestCase {
+    private static final String TEST_INDEX = "test";
+    Settings settings = Settings.builder()
+        .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+        .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(512, ByteSizeUnit.MB))
+        .build();
+
+    private static XContentBuilder createMinimalTestMapping(boolean invalidDim, boolean invalidMetric, boolean keywordDim) {
+        try {
+            return jsonBuilder().startObject()
+                .startObject("composite")
+                .startObject("startree-1")
+                .field("type", "star_tree")
+                .startObject("config")
+                .startArray("ordered_dimensions")
+                .startObject()
+                .field("name", "numeric_dv_1")
+                .endObject()
+                .startObject()
+                .field("name", "numeric_dv_2")
+                .endObject()
+                .startObject()
+                .field("name", getDim(invalidDim, keywordDim))
+                .endObject()
+                .endArray()
+                .startArray("metrics")
+                .startObject()
+                .field("name", getDim(invalidMetric, false))
+                .endObject()
+                .endArray()
+                .endObject()
+                .endObject()
+                .endObject()
+                .startObject("properties")
+                .startObject("timestamp")
+                .field("type", "date")
+                .endObject()
+                .startObject("numeric_dv")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric_dv_1")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric_dv_2")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric")
+                .field("type", "integer")
+                .field("doc_values", false)
+                .endObject()
+                .startObject("keyword_dv")
+                .field("type", "keyword")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("keyword")
+                .field("type", "keyword")
+                .field("doc_values", false)
+                .endObject()
+                .endObject()
+                .endObject();
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    private static XContentBuilder createMaxDimTestMapping() {
+        try {
+            return jsonBuilder().startObject()
+                .startObject("composite")
+                .startObject("startree-1")
+                .field("type", "star_tree")
+                .startObject("config")
+                .startArray("ordered_dimensions")
+                .startObject()
+                .field("name", "dim4")
+                .endObject()
+                .startObject()
+                .field("name", "dim2")
+                .endObject()
+                .startObject()
+                .field("name", "dim3")
+                .endObject()
+                .endArray()
+                .startArray("metrics")
+                .startObject()
+                .field("name", "dim2")
+                .endObject()
+                .startObject()
+                .field("name", "dim3")
+                .endObject()
+                .startObject()
+                .field("name", "dim4")
+                .endObject()
+                .endArray()
+                .endObject()
+                .endObject()
+                .endObject()
+                .startObject("properties")
+                .startObject("timestamp")
+                .field("type", "date")
+                .endObject()
+                .startObject("dim2")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("dim3")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("dim4")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .endObject()
+                .endObject();
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    private static XContentBuilder createTestMappingWithoutStarTree(boolean invalidDim, boolean invalidMetric, boolean keywordDim) {
+        try {
+            return jsonBuilder().startObject()
+                .startObject("properties")
+                .startObject("timestamp")
+                .field("type", "date")
+                .endObject()
+                .startObject("numeric_dv")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric")
+                .field("type", "integer")
+                .field("doc_values", false)
+                .endObject()
+                .startObject("keyword_dv")
+                .field("type", "keyword")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("keyword")
+                .field("type", "keyword")
+                .field("doc_values", false)
+                .endObject()
+                .endObject()
+                .endObject();
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    private static XContentBuilder createUpdateTestMapping(boolean changeDim, boolean sameStarTree) {
+        try {
+            return jsonBuilder().startObject()
+                .startObject("composite")
+                .startObject(sameStarTree ? "startree-1" : "startree-2")
+                .field("type", "star_tree")
+                .startObject("config")
+                .startArray("ordered_dimensions")
+                .startObject()
+                .field("name", "numeric_dv1")
+                .endObject()
+                .startObject()
+                .field("name", changeDim ? "numeric_new" : getDim(false, false))
+                .endObject()
+                .endArray()
+                .startArray("metrics")
+                .startObject()
+                .field("name", getDim(false, false))
+                .endObject()
+                .endArray()
+                .endObject()
+                .endObject()
+                .endObject()
+                .startObject("properties")
+                .startObject("timestamp")
+                .field("type", "date")
+                .endObject()
+                .startObject("numeric_dv")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric_dv1")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric")
+                .field("type", "integer")
+                .field("doc_values", false)
+                .endObject()
+                .startObject("numeric_new")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("keyword_dv")
+                .field("type", "keyword")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("keyword")
+                .field("type", "keyword")
+                .field("doc_values", false)
+                .endObject()
+                .endObject()
+                .endObject();
+        } catch (IOException e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    private XContentBuilder getMappingWithDuplicateFields(boolean isDuplicateDim, boolean isDuplicateMetric) {
+        XContentBuilder mapping = null;
+        try {
+            mapping = jsonBuilder().startObject()
+                .startObject("composite")
+                .startObject("startree-1")
+                .field("type", "star_tree")
+                .startObject("config")
+                .startArray("ordered_dimensions")
+                .startObject()
+                .field("name", "numeric_dv2")
+                .endObject()
+                .startObject()
+                .field("name", "numeric_dv")
+                .endObject()
+                .startObject()
+                .field("name", isDuplicateDim ? "numeric_dv" : "numeric_dv1")  // Duplicate dimension
+                .endObject()
+                .endArray()
+                .startArray("metrics")
+                .startObject()
+                .field("name", "numeric_dv")
+                .endObject()
+                .startObject()
+                .field("name", isDuplicateMetric ? "numeric_dv" : "numeric_dv1")  // Duplicate metric
+                .endObject()
+                .endArray()
+                .endObject()
+                .endObject()
+                .endObject()
+                .startObject("properties")
+                .startObject("timestamp")
+                .field("type", "date")
+                .endObject()
+                .startObject("numeric_dv")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric_dv2")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric_dv1")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .endObject()
+                .endObject();
+        } catch (IOException e) {
+            fail("Failed to create mapping: " + e.getMessage());
+        }
+        return mapping;
+    }
+
+    private static String getDim(boolean hasDocValues, boolean isKeyword) {
+        if (hasDocValues) {
+            return "numeric";
+        } else if (isKeyword) {
+            return "keyword";
+        }
+        return "numeric_dv";
+    }
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder().put(super.featureFlagSettings()).put(FeatureFlags.STAR_TREE_INDEX, "true").build();
+    }
+
+    @Before
+    public final void setupNodeSettings() {
+        Settings request = Settings.builder().put(CompositeIndexSettings.STAR_TREE_INDEX_ENABLED_SETTING.getKey(), true).build();
+        assertAcked(client().admin().cluster().prepareUpdateSettings().setPersistentSettings(request).get());
+    }
+
+    public void testValidCompositeIndex() {
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get();
+        Iterable<IndicesService> dataNodeInstances = internalCluster().getDataNodeInstances(IndicesService.class);
+        for (IndicesService service : dataNodeInstances) {
+            final Index index = resolveIndex("test");
+            if (service.hasIndex(index)) {
+                IndexService indexService = service.indexService(index);
+                Set<CompositeMappedFieldType> fts = indexService.mapperService().getCompositeFieldTypes();
+
+                for (CompositeMappedFieldType ft : fts) {
+                    assertTrue(ft instanceof StarTreeMapper.StarTreeFieldType);
+                    StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) ft;
+                    assertEquals("numeric_dv_1", starTreeFieldType.getDimensions().get(0).getField());
+                    assertEquals("numeric_dv_2", starTreeFieldType.getDimensions().get(1).getField());
+                    assertEquals(2, starTreeFieldType.getMetrics().size());
+                    assertEquals("numeric_dv", starTreeFieldType.getMetrics().get(0).getField());
+
+                    // Assert default metrics
+                    List<MetricStat> expectedMetrics = Arrays.asList(MetricStat.VALUE_COUNT, MetricStat.SUM, MetricStat.AVG);
+                    assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+
+                    assertEquals("_doc_count", starTreeFieldType.getMetrics().get(1).getField());
+                    assertEquals(List.of(MetricStat.DOC_COUNT), starTreeFieldType.getMetrics().get(1).getMetrics());
+
+                    assertEquals(10000, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+                    assertEquals(
+                        StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP,
+                        starTreeFieldType.getStarTreeConfig().getBuildMode()
+                    );
+                    assertEquals(Collections.emptySet(), starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims());
+                }
+            }
+        }
+    }
+
+    public void testCompositeIndexWithIndexNotSpecified() {
+        Settings settings = Settings.builder()
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(512, ByteSizeUnit.MB))
+            .build();
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get()
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: Set 'index.composite_index' as true as part of index settings to use star tree index",
+            ex.getMessage()
+        );
+    }
+
+    public void testCompositeIndexWithHigherTranslogFlushSize() {
+        Settings settings = Settings.builder()
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(513, ByteSizeUnit.MB))
+            .build();
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get()
+        );
+        assertEquals("You can configure 'index.translog.flush_threshold_size' with upto '512mb' for composite index", ex.getMessage());
+    }
+
+    public void testCompositeIndexWithArraysInCompositeField() throws IOException {
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get();
+        // Attempt to index a document with an array field
+        XContentBuilder doc = jsonBuilder().startObject()
+            .field("timestamp", "2023-06-01T12:00:00Z")
+            .startArray("numeric_dv")
+            .value(10)
+            .value(20)
+            .value(30)
+            .endArray()
+            .endObject();
+
+        // Index the document and refresh
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> client().prepareIndex(TEST_INDEX).setSource(doc).get()
+        );
+        assertEquals(
+            "object mapping for [_doc] with array for [numeric_dv] cannot be accepted as field is also part of composite index mapping which does not accept arrays",
+            ex.getMessage()
+        );
+    }
+
+    public void testCompositeIndexWithArraysInNonCompositeField() throws IOException {
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get();
+        // Attempt to index a document with an array field
+        XContentBuilder doc = jsonBuilder().startObject()
+            .field("timestamp", "2023-06-01T12:00:00Z")
+            .startArray("numeric")
+            .value(10)
+            .value(20)
+            .value(30)
+            .endArray()
+            .endObject();
+
+        // Index the document and refresh
+        IndexResponse indexResponse = client().prepareIndex(TEST_INDEX).setSource(doc).get();
+
+        assertEquals(RestStatus.CREATED, indexResponse.status());
+
+        client().admin().indices().prepareRefresh(TEST_INDEX).get();
+        // Verify the document was indexed
+        SearchResponse searchResponse = client().prepareSearch(TEST_INDEX).setQuery(QueryBuilders.matchAllQuery()).get();
+
+        assertEquals(1, searchResponse.getHits().getTotalHits().value);
+
+        // Verify the values in the indexed document
+        SearchHit hit = searchResponse.getHits().getAt(0);
+        assertEquals("2023-06-01T12:00:00Z", hit.getSourceAsMap().get("timestamp"));
+
+        List<Integer> values = (List<Integer>) hit.getSourceAsMap().get("numeric");
+        assertEquals(3, values.size());
+        assertTrue(values.contains(10));
+        assertTrue(values.contains(20));
+        assertTrue(values.contains(30));
+    }
+
+    public void testUpdateIndexWithAdditionOfStarTree() {
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get();
+
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> client().admin().indices().preparePutMapping(TEST_INDEX).setSource(createUpdateTestMapping(false, false)).get()
+        );
+        assertEquals("Index cannot have more than [1] star tree fields", ex.getMessage());
+    }
+
+    public void testUpdateIndexWithNewerStarTree() {
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createTestMappingWithoutStarTree(false, false, false)).get();
+
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> client().admin().indices().preparePutMapping(TEST_INDEX).setSource(createUpdateTestMapping(false, false)).get()
+        );
+        assertEquals(
+            "Composite fields must be specified during index creation, addition of new composite fields during update is not supported",
+            ex.getMessage()
+        );
+    }
+
+    public void testUpdateIndexWhenMappingIsDifferent() {
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get();
+
+        // update some field in the mapping
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> client().admin().indices().preparePutMapping(TEST_INDEX).setSource(createUpdateTestMapping(true, true)).get()
+        );
+        assertTrue(ex.getMessage().contains("Cannot update parameter [config] from"));
+    }
+
+    public void testUpdateIndexWhenMappingIsSame() {
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get();
+
+        // update some field in the mapping
+        AcknowledgedResponse putMappingResponse = client().admin()
+            .indices()
+            .preparePutMapping(TEST_INDEX)
+            .setSource(createMinimalTestMapping(false, false, false))
+            .get();
+        assertAcked(putMappingResponse);
+
+        Iterable<IndicesService> dataNodeInstances = internalCluster().getDataNodeInstances(IndicesService.class);
+        for (IndicesService service : dataNodeInstances) {
+            final Index index = resolveIndex("test");
+            if (service.hasIndex(index)) {
+                IndexService indexService = service.indexService(index);
+                Set<CompositeMappedFieldType> fts = indexService.mapperService().getCompositeFieldTypes();
+
+                for (CompositeMappedFieldType ft : fts) {
+                    assertTrue(ft instanceof StarTreeMapper.StarTreeFieldType);
+                    StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) ft;
+                    assertEquals("numeric_dv_1", starTreeFieldType.getDimensions().get(0).getField());
+                    assertEquals("numeric_dv_2", starTreeFieldType.getDimensions().get(1).getField());
+                    assertEquals("numeric_dv", starTreeFieldType.getMetrics().get(0).getField());
+
+                    // Assert default metrics
+                    List<MetricStat> expectedMetrics = Arrays.asList(MetricStat.VALUE_COUNT, MetricStat.SUM, MetricStat.AVG);
+                    assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+                    assertEquals(10000, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+                    assertEquals(
+                        StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP,
+                        starTreeFieldType.getStarTreeConfig().getBuildMode()
+                    );
+                    assertEquals(Collections.emptySet(), starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims());
+                }
+            }
+        }
+    }
+
+    public void testInvalidDimCompositeIndex() {
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(true, false, false)).get()
+        );
+        assertEquals(
+            "Aggregations not supported for the dimension field [numeric] with field type [integer] as part of star tree field",
+            ex.getMessage()
+        );
+    }
+
+    public void testMaxDimsCompositeIndex() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings)
+                .setMapping(createMaxDimTestMapping())
+                .setSettings(
+                    Settings.builder()
+                        .put(StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_SETTING.getKey(), 2)
+                        .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+                        .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(512, ByteSizeUnit.MB))
+                )
+                .get()
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: ordered_dimensions cannot have more than 2 dimensions for star tree field [startree-1]",
+            ex.getMessage()
+        );
+    }
+
+    public void testMaxMetricsCompositeIndex() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings)
+                .setMapping(createMaxDimTestMapping())
+                .setSettings(
+                    Settings.builder()
+                        .put(StarTreeIndexSettings.STAR_TREE_MAX_BASE_METRICS_SETTING.getKey(), 4)
+                        .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+                        .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(512, ByteSizeUnit.MB))
+                )
+                .get()
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: There cannot be more than [4] base metrics for star tree field [startree-1]",
+            ex.getMessage()
+        );
+    }
+
+    public void testUnsupportedDim() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, true)).get()
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: unsupported field type associated with dimension [keyword] as part of star tree field [startree-1]",
+            ex.getMessage()
+        );
+    }
+
+    public void testInvalidMetric() {
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, true, false)).get()
+        );
+        assertEquals(
+            "Aggregations not supported for the metrics field [numeric] with field type [integer] as part of star tree field",
+            ex.getMessage()
+        );
+    }
+
+    public void testDuplicateDimensions() {
+        XContentBuilder finalMapping = getMappingWithDuplicateFields(true, false);
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings).setMapping(finalMapping).setSettings(settings).get()
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: Duplicate dimension [numeric_dv] present as part star tree index field [startree-1]",
+            ex.getMessage()
+        );
+    }
+
+    public void testDuplicateMetrics() {
+        XContentBuilder finalMapping = getMappingWithDuplicateFields(false, true);
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings).setMapping(finalMapping).setSettings(settings).get()
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: Duplicate metrics [numeric_dv] present as part star tree index field [startree-1]",
+            ex.getMessage()
+        );
+    }
+
+    public void testValidTranslogFlushThresholdSize() {
+        Settings indexSettings = Settings.builder()
+            .put(settings)
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(256, ByteSizeUnit.MB))
+            .build();
+
+        AcknowledgedResponse response = prepareCreate(TEST_INDEX).setSettings(indexSettings)
+            .setMapping(createMinimalTestMapping(false, false, false))
+            .get();
+
+        assertTrue(response.isAcknowledged());
+    }
+
+    public void testInvalidTranslogFlushThresholdSize() {
+        Settings indexSettings = Settings.builder()
+            .put(settings)
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(1024, ByteSizeUnit.MB))
+            .build();
+
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(indexSettings).setMapping(createMinimalTestMapping(false, false, false)).get()
+        );
+
+        assertTrue(
+            ex.getMessage().contains("You can configure 'index.translog.flush_threshold_size' with upto '512mb' for composite index")
+        );
+    }
+
+    public void testTranslogFlushThresholdSizeWithDefaultCompositeSettingLow() {
+        Settings updatedSettings = Settings.builder()
+            .put(CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "130m")
+            .build();
+
+        ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest().transientSettings(updatedSettings);
+
+        client().admin().cluster().updateSettings(updateSettingsRequest).actionGet();
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get()
+        );
+
+        assertEquals("You can configure 'index.translog.flush_threshold_size' with upto '130mb' for composite index", ex.getMessage());
+    }
+
+    public void testUpdateTranslogFlushThresholdSize() {
+        prepareCreate(TEST_INDEX).setSettings(settings).setMapping(createMinimalTestMapping(false, false, false)).get();
+
+        // Update to a valid value
+        AcknowledgedResponse validUpdateResponse = client().admin()
+            .indices()
+            .prepareUpdateSettings(TEST_INDEX)
+            .setSettings(Settings.builder().put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "256mb"))
+            .get();
+        assertTrue(validUpdateResponse.isAcknowledged());
+
+        // Try to update to an invalid value
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> client().admin()
+                .indices()
+                .prepareUpdateSettings(TEST_INDEX)
+                .setSettings(Settings.builder().put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "1024mb"))
+                .get()
+        );
+
+        assertTrue(
+            ex.getMessage().contains("You can configure 'index.translog.flush_threshold_size' with upto '512mb' for composite index")
+        );
+
+        // update cluster settings to higher value
+        Settings updatedSettings = Settings.builder()
+            .put(CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "1030m")
+            .build();
+
+        ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest().transientSettings(updatedSettings);
+
+        client().admin().cluster().updateSettings(updateSettingsRequest).actionGet();
+
+        // update index threshold flush to higher value
+        validUpdateResponse = client().admin()
+            .indices()
+            .prepareUpdateSettings(TEST_INDEX)
+            .setSettings(Settings.builder().put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "1024mb"))
+            .get();
+        assertTrue(validUpdateResponse.isAcknowledged());
+    }
+
+    public void testMinimumTranslogFlushThresholdSize() {
+        Settings indexSettings = Settings.builder()
+            .put(settings)
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(56, ByteSizeUnit.BYTES))
+            .build();
+
+        AcknowledgedResponse response = prepareCreate(TEST_INDEX).setSettings(indexSettings)
+            .setMapping(createMinimalTestMapping(false, false, false))
+            .get();
+
+        assertTrue(response.isAcknowledged());
+    }
+
+    public void testBelowMinimumTranslogFlushThresholdSize() {
+        Settings indexSettings = Settings.builder()
+            .put(settings)
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(55, ByteSizeUnit.BYTES))
+            .build();
+
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> prepareCreate(TEST_INDEX).setSettings(indexSettings).setMapping(createMinimalTestMapping(false, false, false)).get()
+        );
+
+        assertEquals("failed to parse value [55b] for setting [index.translog.flush_threshold_size], must be >= [56b]", ex.getMessage());
+    }
+
+    @After
+    public final void cleanupNodeSettings() {
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(Settings.builder().putNull("*"))
+                .setTransientSettings(Settings.builder().putNull("*"))
+        );
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/index/store/CorruptedFileIT.java b/server/src/internalClusterTest/java/org/opensearch/index/store/CorruptedFileIT.java
index f46f413f4d23f..3ee506f58a9d7 100644
--- a/server/src/internalClusterTest/java/org/opensearch/index/store/CorruptedFileIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/index/store/CorruptedFileIT.java
@@ -577,18 +577,12 @@ public void testCorruptFileThenSnapshotAndRestore() throws ExecutionException, I
         // the other problem here why we can't corrupt segments.X files is that the snapshot flushes again before
         // it snapshots and that will write a new segments.X+1 file
         logger.info("-->  creating repository");
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("fs")
-                .setSettings(
-                    Settings.builder()
-                        .put("location", randomRepoPath().toAbsolutePath())
-                        .put("compress", randomBoolean())
-                        .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
-                )
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", randomRepoPath().toAbsolutePath())
+            .put("compress", randomBoolean())
+            .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES);
+        createRepository("test-repo", "fs", settings);
+
         logger.info("--> snapshot");
         final CreateSnapshotResponse createSnapshotResponse = client().admin()
             .cluster()
@@ -761,18 +755,11 @@ public void testPrimaryCorruptionDuringReplicationDoesNotFailReplicaShard() thro
         // Create a snapshot repository. This repo is used to take a snapshot after
         // corrupting a file, which causes the node to notice the corrupt data and
         // close the shard.
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("fs")
-                .setSettings(
-                    Settings.builder()
-                        .put("location", randomRepoPath().toAbsolutePath())
-                        .put("compress", randomBoolean())
-                        .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
-                )
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", randomRepoPath().toAbsolutePath())
+            .put("compress", randomBoolean())
+            .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES);
+        createRepository("test-repo", "fs", settings);
 
         client().prepareIndex("test").setSource("field", "value").execute();
         indexingInFlight.await();
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/CacheStatsAPIIndicesRequestCacheIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/CacheStatsAPIIndicesRequestCacheIT.java
index de7a52761c77c..28bac3c7441b6 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/CacheStatsAPIIndicesRequestCacheIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/CacheStatsAPIIndicesRequestCacheIT.java
@@ -12,6 +12,8 @@
 
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest;
+import org.opensearch.action.admin.indices.forcemerge.ForceMergeResponse;
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.search.SearchResponse;
 import org.opensearch.client.Client;
@@ -20,14 +22,16 @@
 import org.opensearch.common.cache.CacheType;
 import org.opensearch.common.cache.service.NodeCacheStats;
 import org.opensearch.common.cache.stats.ImmutableCacheStats;
-import org.opensearch.common.cache.stats.ImmutableCacheStatsHolderTests;
+import org.opensearch.common.cache.stats.ImmutableCacheStatsHolder;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.common.xcontent.XContentHelper;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.IndexSettings;
 import org.opensearch.index.cache.request.RequestCacheStats;
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.test.OpenSearchIntegTestCase;
@@ -56,6 +60,10 @@ public static Collection<Object[]> parameters() {
         return Arrays.<Object[]>asList(new Object[] { Settings.builder().put(FeatureFlags.PLUGGABLE_CACHE, "true").build() });
     }
 
+    /**
+     * Test aggregating by indices, indices+shards, shards, or no levels, and check the resulting stats
+     * are as we expect.
+     */
     public void testCacheStatsAPIWIthOnHeapCache() throws Exception {
         String index1Name = "index1";
         String index2Name = "index2";
@@ -73,84 +81,60 @@ public void testCacheStatsAPIWIthOnHeapCache() throws Exception {
         searchIndex(client, index2Name, "");
 
         // First, aggregate by indices only
-        Map<String, Object> xContentMap = getNodeCacheStatsXContentMap(client, List.of(IndicesRequestCache.INDEX_DIMENSION_NAME));
+        ImmutableCacheStatsHolder indicesStats = getNodeCacheStatsResult(client, List.of(IndicesRequestCache.INDEX_DIMENSION_NAME));
 
-        List<String> index1Keys = List.of(CacheType.INDICES_REQUEST_CACHE.getValue(), IndicesRequestCache.INDEX_DIMENSION_NAME, index1Name);
+        List<String> index1Dimensions = List.of(index1Name);
         // Since we searched twice, we expect to see 1 hit, 1 miss and 1 entry for index 1
         ImmutableCacheStats expectedStats = new ImmutableCacheStats(1, 1, 0, 0, 1);
-        checkCacheStatsAPIResponse(xContentMap, index1Keys, expectedStats, false, true);
+        checkCacheStatsAPIResponse(indicesStats, index1Dimensions, expectedStats, false, true);
         // Get the request size for one request, so we can reuse it for next index
-        int requestSize = (int) ((Map<String, Object>) ImmutableCacheStatsHolderTests.getValueFromNestedXContentMap(
-            xContentMap,
-            index1Keys
-        )).get(ImmutableCacheStats.Fields.SIZE_IN_BYTES);
+        long requestSize = indicesStats.getStatsForDimensionValues(List.of(index1Name)).getSizeInBytes();
         assertTrue(requestSize > 0);
 
-        List<String> index2Keys = List.of(CacheType.INDICES_REQUEST_CACHE.getValue(), IndicesRequestCache.INDEX_DIMENSION_NAME, index2Name);
+        List<String> index2Dimensions = List.of(index2Name);
         // We searched once in index 2, we expect 1 miss + 1 entry
         expectedStats = new ImmutableCacheStats(0, 1, 0, requestSize, 1);
-        checkCacheStatsAPIResponse(xContentMap, index2Keys, expectedStats, true, true);
+        checkCacheStatsAPIResponse(indicesStats, index2Dimensions, expectedStats, true, true);
 
         // The total stats for the node should be 1 hit, 2 misses, and 2 entries
         expectedStats = new ImmutableCacheStats(1, 2, 0, 2 * requestSize, 2);
-        List<String> totalStatsKeys = List.of(CacheType.INDICES_REQUEST_CACHE.getValue());
-        checkCacheStatsAPIResponse(xContentMap, totalStatsKeys, expectedStats, true, true);
+        List<String> totalStatsKeys = List.of();
+        checkCacheStatsAPIResponse(indicesStats, totalStatsKeys, expectedStats, true, true);
 
         // Aggregate by shards only
-        xContentMap = getNodeCacheStatsXContentMap(client, List.of(IndicesRequestCache.SHARD_ID_DIMENSION_NAME));
+        ImmutableCacheStatsHolder shardsStats = getNodeCacheStatsResult(client, List.of(IndicesRequestCache.SHARD_ID_DIMENSION_NAME));
 
-        List<String> index1Shard0Keys = List.of(
-            CacheType.INDICES_REQUEST_CACHE.getValue(),
-            IndicesRequestCache.SHARD_ID_DIMENSION_NAME,
-            "[" + index1Name + "][0]"
-        );
+        List<String> index1Shard0Dimensions = List.of("[" + index1Name + "][0]");
 
         expectedStats = new ImmutableCacheStats(1, 1, 0, requestSize, 1);
-        checkCacheStatsAPIResponse(xContentMap, index1Shard0Keys, expectedStats, true, true);
+        checkCacheStatsAPIResponse(shardsStats, index1Shard0Dimensions, expectedStats, true, true);
 
-        List<String> index2Shard0Keys = List.of(
-            CacheType.INDICES_REQUEST_CACHE.getValue(),
-            IndicesRequestCache.SHARD_ID_DIMENSION_NAME,
-            "[" + index2Name + "][0]"
-        );
+        List<String> index2Shard0Dimensions = List.of("[" + index2Name + "][0]");
         expectedStats = new ImmutableCacheStats(0, 1, 0, requestSize, 1);
-        checkCacheStatsAPIResponse(xContentMap, index2Shard0Keys, expectedStats, true, true);
+        checkCacheStatsAPIResponse(shardsStats, index2Shard0Dimensions, expectedStats, true, true);
 
         // Aggregate by indices and shards
-        xContentMap = getNodeCacheStatsXContentMap(
+        ImmutableCacheStatsHolder indicesAndShardsStats = getNodeCacheStatsResult(
             client,
             List.of(IndicesRequestCache.INDEX_DIMENSION_NAME, IndicesRequestCache.SHARD_ID_DIMENSION_NAME)
         );
 
-        index1Keys = List.of(
-            CacheType.INDICES_REQUEST_CACHE.getValue(),
-            IndicesRequestCache.INDEX_DIMENSION_NAME,
-            index1Name,
-            IndicesRequestCache.SHARD_ID_DIMENSION_NAME,
-            "[" + index1Name + "][0]"
-        );
+        index1Dimensions = List.of(index1Name, "[" + index1Name + "][0]");
 
         expectedStats = new ImmutableCacheStats(1, 1, 0, requestSize, 1);
-        checkCacheStatsAPIResponse(xContentMap, index1Keys, expectedStats, true, true);
-
-        index2Keys = List.of(
-            CacheType.INDICES_REQUEST_CACHE.getValue(),
-            IndicesRequestCache.INDEX_DIMENSION_NAME,
-            index2Name,
-            IndicesRequestCache.SHARD_ID_DIMENSION_NAME,
-            "[" + index2Name + "][0]"
-        );
+        checkCacheStatsAPIResponse(indicesAndShardsStats, index1Dimensions, expectedStats, true, true);
 
+        index2Dimensions = List.of(index2Name, "[" + index2Name + "][0]");
         expectedStats = new ImmutableCacheStats(0, 1, 0, requestSize, 1);
-        checkCacheStatsAPIResponse(xContentMap, index2Keys, expectedStats, true, true);
-
+        checkCacheStatsAPIResponse(indicesAndShardsStats, index2Dimensions, expectedStats, true, true);
     }
 
-    // TODO: Add testCacheStatsAPIWithTieredCache when TSC stats implementation PR is merged
-
+    /**
+     * Check the new stats API returns the same values as the old stats API. In particular,
+     * check that the new and old APIs are both correctly estimating memory size,
+     * using the logic that includes the overhead memory in ICacheKey.
+     */
     public void testStatsMatchOldApi() throws Exception {
-        // The main purpose of this test is to check that the new and old APIs are both correctly estimating memory size,
-        // using the logic that includes the overhead memory in ICacheKey.
         String index = "index";
         Client client = client();
         startIndex(client, index);
@@ -173,8 +157,7 @@ public void testStatsMatchOldApi() throws Exception {
             .getRequestCache();
         assertNotEquals(0, oldApiStats.getMemorySizeInBytes());
 
-        List<String> xContentMapKeys = List.of(CacheType.INDICES_REQUEST_CACHE.getValue());
-        Map<String, Object> xContentMap = getNodeCacheStatsXContentMap(client, List.of());
+        ImmutableCacheStatsHolder statsHolder = getNodeCacheStatsResult(client, List.of());
         ImmutableCacheStats expected = new ImmutableCacheStats(
             oldApiStats.getHitCount(),
             oldApiStats.getMissCount(),
@@ -183,9 +166,13 @@ public void testStatsMatchOldApi() throws Exception {
             0
         );
         // Don't check entries, as the old API doesn't track this
-        checkCacheStatsAPIResponse(xContentMap, xContentMapKeys, expected, true, false);
+        checkCacheStatsAPIResponse(statsHolder, List.of(), expected, true, false);
     }
 
+    /**
+     * Test the XContent in the response behaves correctly when we pass null levels.
+     * Only the total cache stats should be returned.
+     */
     public void testNullLevels() throws Exception {
         String index = "index";
         Client client = client();
@@ -194,9 +181,81 @@ public void testNullLevels() throws Exception {
         for (int i = 0; i < numKeys; i++) {
             searchIndex(client, index, String.valueOf(i));
         }
-        Map<String, Object> xContentMap = getNodeCacheStatsXContentMap(client, null);
+        Map<String, Object> xContentMap = getStatsXContent(getNodeCacheStatsResult(client, null));
         // Null levels should result in only the total cache stats being returned -> 6 fields inside the response.
-        assertEquals(6, ((Map<String, Object>) xContentMap.get("request_cache")).size());
+        assertEquals(6, xContentMap.size());
+    }
+
+    /**
+     * Test clearing the cache using API sets memory size and number of items to 0, but leaves other stats
+     * unaffected.
+     */
+    public void testCacheClear() throws Exception {
+        String index = "index";
+        Client client = client();
+
+        startIndex(client, index);
+
+        int expectedHits = 2;
+        int expectedMisses = 7;
+        // Search for the same doc to give hits
+        for (int i = 0; i < expectedHits + 1; i++) {
+            searchIndex(client, index, "");
+        }
+        // Search for new docs
+        for (int i = 0; i < expectedMisses - 1; i++) {
+            searchIndex(client, index, String.valueOf(i));
+        }
+
+        ImmutableCacheStats expectedTotal = new ImmutableCacheStats(expectedHits, expectedMisses, 0, 0, expectedMisses);
+        ImmutableCacheStatsHolder statsHolder = getNodeCacheStatsResult(client, List.of());
+        // Don't check the memory size, just assert it's nonzero
+        checkCacheStatsAPIResponse(statsHolder, List.of(), expectedTotal, false, true);
+        long originalMemorySize = statsHolder.getTotalSizeInBytes();
+        assertNotEquals(0, originalMemorySize);
+
+        // Clear cache
+        ClearIndicesCacheRequest clearIndicesCacheRequest = new ClearIndicesCacheRequest(index);
+        client.admin().indices().clearCache(clearIndicesCacheRequest).actionGet();
+
+        // Now size and items should be 0
+        expectedTotal = new ImmutableCacheStats(expectedHits, expectedMisses, 0, 0, 0);
+        statsHolder = getNodeCacheStatsResult(client, List.of());
+        checkCacheStatsAPIResponse(statsHolder, List.of(), expectedTotal, true, true);
+    }
+
+    /**
+     * Test the cache stats responses are in the expected place in XContent when we call the overall API
+     * GET /_nodes/stats. They should be at nodes.[node_id].caches.request_cache.
+     */
+    public void testNodesStatsResponse() throws Exception {
+        String index = "index";
+        Client client = client();
+
+        startIndex(client, index);
+
+        NodesStatsResponse nodeStatsResponse = client.admin()
+            .cluster()
+            .prepareNodesStats("data:true")
+            .all() // This mimics /_nodes/stats
+            .get();
+        XContentBuilder builder = XContentFactory.jsonBuilder();
+        Map<String, String> paramMap = new HashMap<>();
+        ToXContent.Params params = new ToXContent.MapParams(paramMap);
+
+        builder.startObject();
+        nodeStatsResponse.toXContent(builder, params);
+        builder.endObject();
+        Map<String, Object> xContentMap = XContentHelper.convertToMap(MediaTypeRegistry.JSON.xContent(), builder.toString(), true);
+        // Values should be at nodes.[node_id].caches.request_cache
+        // Get the node id
+        Map<String, Object> nodesResponse = (Map<String, Object>) xContentMap.get("nodes");
+        assertEquals(1, nodesResponse.size());
+        String nodeId = nodesResponse.keySet().toArray(String[]::new)[0];
+        Map<String, Object> cachesResponse = (Map<String, Object>) ((Map<String, Object>) nodesResponse.get(nodeId)).get("caches");
+        assertNotNull(cachesResponse);
+        // Request cache should be present in the response
+        assertTrue(cachesResponse.containsKey("request_cache"));
     }
 
     private void startIndex(Client client, String indexName) throws InterruptedException {
@@ -210,10 +269,14 @@ private void startIndex(Client client, String indexName) throws InterruptedExcep
                         .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
                         .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
                         .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
                 )
                 .get()
         );
         indexRandom(true, client.prepareIndex(indexName).setSource("k", "hello"));
+        // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
+        ForceMergeResponse forceMergeResponse = client.admin().indices().prepareForceMerge(indexName).setFlush(true).get();
         ensureSearchable(indexName);
     }
 
@@ -227,8 +290,7 @@ private SearchResponse searchIndex(Client client, String index, String searchSuf
         return resp;
     }
 
-    private static Map<String, Object> getNodeCacheStatsXContentMap(Client client, List<String> aggregationLevels) throws IOException {
-
+    private static ImmutableCacheStatsHolder getNodeCacheStatsResult(Client client, List<String> aggregationLevels) throws IOException {
         CommonStatsFlags statsFlags = new CommonStatsFlags();
         statsFlags.includeAllCacheTypes();
         String[] flagsLevels;
@@ -248,16 +310,16 @@ private static Map<String, Object> getNodeCacheStatsXContentMap(Client client, L
         // Can always get the first data node as there's only one in this test suite
         assertEquals(1, nodeStatsResponse.getNodes().size());
         NodeCacheStats ncs = nodeStatsResponse.getNodes().get(0).getNodeCacheStats();
+        return ncs.getStatsByCache(CacheType.INDICES_REQUEST_CACHE);
+    }
 
+    private static Map<String, Object> getStatsXContent(ImmutableCacheStatsHolder statsHolder) throws IOException {
         XContentBuilder builder = XContentFactory.jsonBuilder();
         Map<String, String> paramMap = new HashMap<>();
-        if (aggregationLevels != null && !aggregationLevels.isEmpty()) {
-            paramMap.put("level", String.join(",", aggregationLevels));
-        }
         ToXContent.Params params = new ToXContent.MapParams(paramMap);
 
         builder.startObject();
-        ncs.toXContent(builder, params);
+        statsHolder.toXContent(builder, params);
         builder.endObject();
 
         String resultString = builder.toString();
@@ -265,27 +327,22 @@ private static Map<String, Object> getNodeCacheStatsXContentMap(Client client, L
     }
 
     private static void checkCacheStatsAPIResponse(
-        Map<String, Object> xContentMap,
-        List<String> xContentMapKeys,
+        ImmutableCacheStatsHolder statsHolder,
+        List<String> dimensionValues,
         ImmutableCacheStats expectedStats,
         boolean checkMemorySize,
         boolean checkEntries
     ) {
-        // Assumes the keys point to a level whose keys are the field values ("size_in_bytes", "evictions", etc) and whose values store
-        // those stats
-        Map<String, Object> aggregatedStatsResponse = (Map<String, Object>) ImmutableCacheStatsHolderTests.getValueFromNestedXContentMap(
-            xContentMap,
-            xContentMapKeys
-        );
+        ImmutableCacheStats aggregatedStatsResponse = statsHolder.getStatsForDimensionValues(dimensionValues);
         assertNotNull(aggregatedStatsResponse);
-        assertEquals(expectedStats.getHits(), (int) aggregatedStatsResponse.get(ImmutableCacheStats.Fields.HIT_COUNT));
-        assertEquals(expectedStats.getMisses(), (int) aggregatedStatsResponse.get(ImmutableCacheStats.Fields.MISS_COUNT));
-        assertEquals(expectedStats.getEvictions(), (int) aggregatedStatsResponse.get(ImmutableCacheStats.Fields.EVICTIONS));
+        assertEquals(expectedStats.getHits(), (int) aggregatedStatsResponse.getHits());
+        assertEquals(expectedStats.getMisses(), (int) aggregatedStatsResponse.getMisses());
+        assertEquals(expectedStats.getEvictions(), (int) aggregatedStatsResponse.getEvictions());
         if (checkMemorySize) {
-            assertEquals(expectedStats.getSizeInBytes(), (int) aggregatedStatsResponse.get(ImmutableCacheStats.Fields.SIZE_IN_BYTES));
+            assertEquals(expectedStats.getSizeInBytes(), (int) aggregatedStatsResponse.getSizeInBytes());
         }
         if (checkEntries) {
-            assertEquals(expectedStats.getItems(), (int) aggregatedStatsResponse.get(ImmutableCacheStats.Fields.ITEM_COUNT));
+            assertEquals(expectedStats.getItems(), (int) aggregatedStatsResponse.getItems());
         }
     }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/IndicesOptionsIntegrationIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/IndicesOptionsIntegrationIT.java
index 06d2d2a90de87..0d3c8307c060f 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/IndicesOptionsIntegrationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/IndicesOptionsIntegrationIT.java
@@ -51,7 +51,6 @@
 import org.opensearch.action.search.SearchRequestBuilder;
 import org.opensearch.action.search.SearchResponse;
 import org.opensearch.action.support.IndicesOptions;
-import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
@@ -271,14 +270,8 @@ public void testSpecifiedIndexUnavailableSnapshotRestore() throws Exception {
         createIndex("test1");
         ensureGreen("test1");
         waitForRelocation();
+        createRepository("dummy-repo", "fs", Settings.builder().put("location", randomRepoPath()));
 
-        AcknowledgedResponse putRepositoryResponse = client().admin()
-            .cluster()
-            .preparePutRepository("dummy-repo")
-            .setType("fs")
-            .setSettings(Settings.builder().put("location", randomRepoPath()))
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
         client().admin().cluster().prepareCreateSnapshot("dummy-repo", "snap1").setWaitForCompletion(true).get();
 
         verify(snapshot("snap2", "test1", "test2"), true);
@@ -391,13 +384,8 @@ public void testWildcardBehaviourSnapshotRestore() throws Exception {
         ensureGreen("foobar");
         waitForRelocation();
 
-        AcknowledgedResponse putRepositoryResponse = client().admin()
-            .cluster()
-            .preparePutRepository("dummy-repo")
-            .setType("fs")
-            .setSettings(Settings.builder().put("location", randomRepoPath()))
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        createRepository("dummy-repo", "fs", Settings.builder().put("location", randomRepoPath()));
+
         client().admin().cluster().prepareCreateSnapshot("dummy-repo", "snap1").setWaitForCompletion(true).get();
 
         IndicesOptions options = IndicesOptions.fromOptions(false, false, true, false);
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/IndicesRequestCacheCleanupIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/IndicesRequestCacheCleanupIT.java
new file mode 100644
index 0000000000000..988ea99130b13
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/IndicesRequestCacheCleanupIT.java
@@ -0,0 +1,732 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.indices;
+
+import org.opensearch.action.admin.cluster.node.stats.NodeStats;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest;
+import org.opensearch.action.admin.indices.forcemerge.ForceMergeResponse;
+import org.opensearch.action.admin.indices.segments.IndicesSegmentsRequest;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.client.Client;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.index.IndexNotFoundException;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.MergePolicyProvider;
+import org.opensearch.index.cache.request.RequestCacheStats;
+import org.opensearch.index.query.QueryBuilders;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.test.InternalSettingsPlugin;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.opensearch.test.hamcrest.OpenSearchAssertions;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.concurrent.TimeUnit;
+
+import static org.opensearch.indices.IndicesRequestCache.INDICES_REQUEST_CACHE_STALENESS_THRESHOLD_SETTING;
+import static org.opensearch.indices.IndicesService.INDICES_CACHE_CLEANUP_INTERVAL_SETTING_KEY;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertSearchResponse;
+import static org.hamcrest.Matchers.equalTo;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0, supportsDedicatedMasters = false)
+public class IndicesRequestCacheCleanupIT extends OpenSearchIntegTestCase {
+
+    private static final long MAX_ITERATIONS = 5;
+
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return Arrays.asList(InternalSettingsPlugin.class);
+    }
+
+    public void testCacheWithInvalidation() throws Exception {
+        Client client = client();
+        String index = "index";
+        setupIndex(client, index);
+        ensureSearchable(index);
+        // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
+        forceMerge(client, index);
+        SearchResponse resp = client.prepareSearch(index).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", "hello")).get();
+        assertSearchResponse(resp);
+        OpenSearchAssertions.assertAllSuccessful(resp);
+        assertThat(resp.getHits().getTotalHits().value, equalTo(1L));
+
+        assertCacheState(client, index, 0, 1);
+        // Index but don't refresh
+        indexRandom(false, client.prepareIndex(index).setSource("k", "hello2"));
+        resp = client.prepareSearch(index).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", "hello")).get();
+        assertSearchResponse(resp);
+        // Should expect hit as here as refresh didn't happen
+        assertCacheState(client, index, 1, 1);
+
+        // assert segment counts stay the same
+        assertEquals(1, getSegmentCount(client, index));
+        // Explicit refresh would invalidate cache
+        refreshAndWaitForReplication();
+        // Hit same query again
+        resp = client.prepareSearch(index).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", "hello")).get();
+        assertSearchResponse(resp);
+        // Should expect miss as key has changed due to change in IndexReader.CacheKey (due to refresh)
+        assertCacheState(client, index, 1, 2);
+    }
+
+    // calling cache clear api, when staleness threshold is lower than staleness, it should clean the stale keys from cache
+    public void testCacheClearAPIRemovesStaleKeysWhenStalenessThresholdIsLow() throws Exception {
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    // Set interval much larger than test timeout to effectively disable it
+                    TimeValue.timeValueDays(1)
+                )
+        );
+        Client client = client(node);
+        String index1 = "index1";
+        String index2 = "index2";
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // create first cache entry in index1
+        createCacheEntry(client, index1, "hello");
+        assertCacheState(client, index1, 0, 1);
+        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1 > 0);
+
+        // create second cache entry in index1
+        createCacheEntry(client, index1, "there");
+        assertCacheState(client, index1, 0, 2);
+        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
+
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+
+        ClearIndicesCacheRequest clearIndicesCacheRequest = new ClearIndicesCacheRequest(index2);
+        client.admin().indices().clearCache(clearIndicesCacheRequest).actionGet();
+
+        // assert segment counts stay the same
+        assertEquals(1, getSegmentCount(client, index1));
+        assertEquals(1, getSegmentCount(client, index2));
+        // cache cleaner should have cleaned up the stale key from index 2
+        assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+        // cache cleaner should NOT have cleaned from index 1
+        assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+    }
+
+    // when staleness threshold is lower than staleness, it should clean the stale keys from cache
+    public void testStaleKeysCleanupWithLowThreshold() throws Exception {
+        int cacheCleanIntervalInMillis = 1;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        Client client = client(node);
+        String index1 = "index1";
+        String index2 = "index2";
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // create first cache entry in index1
+        createCacheEntry(client, index1, "hello");
+        assertCacheState(client, index1, 0, 1);
+        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1 > 0);
+
+        // create second cache entry in index1
+        createCacheEntry(client, index1, "there");
+        assertCacheState(client, index1, 0, 2);
+        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
+
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+
+        // create 1 stale key
+        indexRandom(false, client.prepareIndex(index2).setId("1").setSource("d", "hello"));
+        forceMerge(client, index2);
+        // sleep until cache cleaner would have cleaned up the stale key from index 2
+        assertBusy(() -> {
+            // assert segment counts stay the same
+            assertEquals(1, getSegmentCount(client, index1));
+            assertEquals(2, getSegmentCount(client, index2));
+            // cache cleaner should have cleaned up the stale key from index 2
+            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+            // cache cleaner should NOT have cleaned from index 1
+            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+        // sleep until cache cleaner would have cleaned up the stale key from index 2
+    }
+
+    // when staleness threshold is equal to staleness, it should clean the stale keys from cache
+    public void testCacheCleanupOnEqualStalenessAndThreshold() throws Exception {
+        int cacheCleanIntervalInMillis = 1;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.33)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        Client client = client(node);
+        String index1 = "index1";
+        String index2 = "index2";
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // create first cache entry in index1
+        createCacheEntry(client, index1, "hello");
+        assertCacheState(client, index1, 0, 1);
+        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1 > 0);
+
+        // create second cache entry in index1
+        createCacheEntry(client, index1, "there");
+        assertCacheState(client, index1, 0, 2);
+        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
+
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+
+        // create 1 stale key
+        indexRandom(false, client.prepareIndex(index2).setId("1").setSource("d", "hello"));
+        forceMerge(client, index2);
+        // sleep until cache cleaner would have cleaned up the stale key from index 2
+        assertBusy(() -> {
+            // assert segment counts stay the same
+            assertEquals(1, getSegmentCount(client, index1));
+            assertEquals(2, getSegmentCount(client, index2));
+            // cache cleaner should have cleaned up the stale key from index 2
+            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+            // cache cleaner should NOT have cleaned from index 1
+            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    // when staleness threshold is higher than staleness, it should NOT clean the cache
+    public void testCacheCleanupSkipsWithHighStalenessThreshold() throws Exception {
+        int cacheCleanIntervalInMillis = 1;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.90)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        Client client = client(node);
+        String index1 = "index1";
+        String index2 = "index2";
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // create first cache entry in index1
+        createCacheEntry(client, index1, "hello");
+        assertCacheState(client, index1, 0, 1);
+        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1 > 0);
+
+        // create second cache entry in index1
+        createCacheEntry(client, index1, "there");
+        assertCacheState(client, index1, 0, 2);
+        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
+
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+
+        // force refresh so that it creates 1 stale key
+        flushAndRefresh(index2);
+        // sleep until cache cleaner would have cleaned up the stale key from index 2
+        assertBusy(() -> {
+            // assert segment counts stay the same
+            assertEquals(1, getSegmentCount(client, index1));
+            assertEquals(1, getSegmentCount(client, index2));
+            // cache cleaner should NOT have cleaned up the stale key from index 2
+            assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+            // cache cleaner should NOT have cleaned from index 1
+            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    // when staleness threshold is explicitly set to 0, cache cleaner regularly cleans up stale keys.
+    public void testCacheCleanupOnZeroStalenessThreshold() throws Exception {
+        int cacheCleanIntervalInMillis = 50;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        Client client = client(node);
+        String index1 = "index1";
+        String index2 = "index2";
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // create 10 index1 cache entries
+        for (int i = 1; i <= 10; i++) {
+            long cacheSizeBefore = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+            createCacheEntry(client, index1, "hello" + i);
+            assertCacheState(client, index1, 0, i);
+            long cacheSizeAfter = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+            assertTrue(cacheSizeAfter > cacheSizeBefore);
+        }
+
+        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+
+        // create 1 stale key
+        indexRandom(false, client.prepareIndex(index2).setId("1").setSource("d", "hello"));
+        forceMerge(client, index2);
+        // sleep until cache cleaner would have cleaned up the stale key from index 2
+        assertBusy(() -> {
+            // assert segment counts stay the same
+            assertEquals(1, getSegmentCount(client, index1));
+            assertEquals(2, getSegmentCount(client, index2));
+            // cache cleaner should have cleaned up the stale key from index 2
+            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+            // cache cleaner should NOT have cleaned from index 1
+            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    // when staleness threshold is not explicitly set, cache cleaner regularly cleans up stale keys
+    public void testStaleKeysRemovalWithoutExplicitThreshold() throws Exception {
+        int cacheCleanIntervalInMillis = 1;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        String index1 = "index1";
+        String index2 = "index2";
+        Client client = client(node);
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // create first cache entry in index1
+        createCacheEntry(client, index1, "hello");
+        assertCacheState(client, index1, 0, 1);
+        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1 > 0);
+
+        // create second cache entry in index1
+        createCacheEntry(client, index1, "there");
+        assertCacheState(client, index1, 0, 2);
+        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
+
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+
+        // force refresh so that it creates 1 stale key
+        indexRandom(false, client.prepareIndex(index2).setId("1").setSource("d", "hello"));
+        forceMerge(client, index2);
+        // sleep until cache cleaner would have cleaned up the stale key from index 2
+        assertBusy(() -> {
+            assertEquals(1, getSegmentCount(client, index1));
+            assertEquals(2, getSegmentCount(client, index2));
+            // cache cleaner should have cleaned up the stale key from index 2
+            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+            // cache cleaner should NOT have cleaned from index 1
+            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    // when cache cleaner interval setting is not set, cache cleaner is configured appropriately with the fall-back setting
+    public void testCacheCleanupWithDefaultSettings() throws Exception {
+        int cacheCleanIntervalInMillis = 1;
+        String node = internalCluster().startNode(
+            Settings.builder().put(INDICES_CACHE_CLEANUP_INTERVAL_SETTING_KEY, TimeValue.timeValueMillis(cacheCleanIntervalInMillis))
+        );
+        Client client = client(node);
+        String index1 = "index1";
+        String index2 = "index2";
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // create first cache entry in index1
+        createCacheEntry(client, index1, "hello");
+        assertCacheState(client, index1, 0, 1);
+        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1 > 0);
+
+        // create second cache entry in index1
+        createCacheEntry(client, index1, "there");
+        assertCacheState(client, index1, 0, 2);
+        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
+
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+
+        // create 1 stale key
+        indexRandom(false, client.prepareIndex(index2).setId("1").setSource("d", "hello"));
+        forceMerge(client, index2);
+        // sleep until cache cleaner would have cleaned up the stale key from index 2
+        assertBusy(() -> {
+            // assert segment counts stay the same
+            assertEquals(1, getSegmentCount(client, index1));
+            assertEquals(2, getSegmentCount(client, index2));
+            // cache cleaner should have cleaned up the stale key from index 2
+            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+            // cache cleaner should NOT have cleaned from index 1
+            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    // staleness threshold updates flows through to the cache cleaner
+    public void testDynamicStalenessThresholdUpdate() throws Exception {
+        int cacheCleanIntervalInMillis = 1;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.90)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        Client client = client(node);
+        String index1 = "index1";
+        String index2 = "index2";
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // create first cache entry in index1
+        createCacheEntry(client, index1, "hello");
+        assertCacheState(client, index1, 0, 1);
+        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1 > 0);
+
+        // create second cache entry in index1
+        createCacheEntry(client, index1, "there");
+        assertCacheState(client, index1, 0, 2);
+        assertTrue(getRequestCacheStats(client, index1).getMemorySizeInBytes() > memorySizeForIndex1);
+
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(finalMemorySizeForIndex1 > 0);
+
+        // create 1 stale key
+        indexRandom(false, client.prepareIndex(index2).setId("1").setSource("d", "hello"));
+        forceMerge(client, index2);
+        assertBusy(() -> {
+            // cache cleaner should NOT have cleaned up the stale key from index 2
+            assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+
+        // Update indices.requests.cache.cleanup.staleness_threshold to "10%"
+        ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
+        updateSettingsRequest.persistentSettings(Settings.builder().put(INDICES_REQUEST_CACHE_STALENESS_THRESHOLD_SETTING.getKey(), 0.10));
+        assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+
+        assertBusy(() -> {
+            // assert segment counts stay the same
+            assertEquals(1, getSegmentCount(client, index1));
+            assertEquals(2, getSegmentCount(client, index2));
+            // cache cleaner should have cleaned up the stale key from index 2
+            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+            // cache cleaner should NOT have cleaned from index 1
+            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    // staleness threshold dynamic updates should throw exceptions on invalid input
+    public void testInvalidStalenessThresholdUpdateThrowsException() throws Exception {
+        // Update indices.requests.cache.cleanup.staleness_threshold to "10%" with illegal argument
+        assertThrows("Ratio should be in [0-1.0]", IllegalArgumentException.class, () -> {
+            ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
+            updateSettingsRequest.persistentSettings(
+                Settings.builder().put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 10)
+            );
+            client().admin().cluster().updateSettings(updateSettingsRequest).actionGet();
+        });
+    }
+
+    // closing the Index after caching will clean up from Indices Request Cache
+    public void testCacheClearanceAfterIndexClosure() throws Exception {
+        int cacheCleanIntervalInMillis = 100;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        Client client = client(node);
+        String index = "index";
+        setupIndex(client, index);
+
+        // assert there are no entries in the cache for index
+        assertEquals(0, getRequestCacheStats(client, index).getMemorySizeInBytes());
+        // assert there are no entries in the cache from other indices in the node
+        assertEquals(0, getNodeCacheStats(client).getMemorySizeInBytes());
+        // create first cache entry in index
+        createCacheEntry(client, index, "hello");
+        assertCacheState(client, index, 0, 1);
+        assertTrue(getRequestCacheStats(client, index).getMemorySizeInBytes() > 0);
+        assertTrue(getNodeCacheStats(client).getMemorySizeInBytes() > 0);
+
+        // close index
+        assertAcked(client.admin().indices().prepareClose(index));
+        // request cache stats cannot be access since Index should be closed
+        try {
+            getRequestCacheStats(client, index);
+        } catch (Exception e) {
+            assert (e instanceof IndexClosedException);
+        }
+        // sleep until cache cleaner would have cleaned up the stale key from index
+        assertBusy(() -> {
+            // cache cleaner should have cleaned up the stale keys from index
+            assertEquals(0, getNodeCacheStats(client).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    // deleting the Index after caching will clean up from Indices Request Cache
+    public void testCacheCleanupAfterIndexDeletion() throws Exception {
+        int cacheCleanIntervalInMillis = 100;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        Client client = client(node);
+        String index = "index";
+        setupIndex(client, index);
+
+        // assert there are no entries in the cache for index
+        assertEquals(0, getRequestCacheStats(client, index).getMemorySizeInBytes());
+        // assert there are no entries in the cache from other indices in the node
+        assertEquals(0, getNodeCacheStats(client).getMemorySizeInBytes());
+        // create first cache entry in index
+        createCacheEntry(client, index, "hello");
+        assertCacheState(client, index, 0, 1);
+        assertTrue(getRequestCacheStats(client, index).getMemorySizeInBytes() > 0);
+        assertTrue(getNodeCacheStats(client).getMemorySizeInBytes() > 0);
+
+        // delete index
+        assertAcked(client.admin().indices().prepareDelete(index));
+        // request cache stats cannot be access since Index should be deleted
+        try {
+            getRequestCacheStats(client, index);
+        } catch (Exception e) {
+            assert (e instanceof IndexNotFoundException);
+        }
+
+        // sleep until cache cleaner would have cleaned up the stale key from index
+        assertBusy(() -> {
+            // cache cleaner should have cleaned up the stale keys from index
+            assertEquals(0, getNodeCacheStats(client).getMemorySizeInBytes());
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    // when staleness threshold is lower than staleness, it should clean the cache from all indices having stale keys
+    public void testStaleKeysCleanupWithMultipleIndices() throws Exception {
+        int cacheCleanIntervalInMillis = 10;
+        String node = internalCluster().startNode(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
+                .put(
+                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
+                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
+                )
+        );
+        Client client = client(node);
+        String index1 = "index1";
+        String index2 = "index2";
+        setupIndex(client, index1);
+        setupIndex(client, index2);
+
+        // assert cache is empty for index1
+        assertEquals(0, getRequestCacheStats(client, index1).getMemorySizeInBytes());
+        // create first cache entry in index1
+        createCacheEntry(client, index1, "hello");
+        assertCacheState(client, index1, 0, 1);
+        long memorySizeForIndex1With1Entries = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1With1Entries > 0);
+
+        // create second cache entry in index1
+        createCacheEntry(client, index1, "there");
+        assertCacheState(client, index1, 0, 2);
+        long memorySizeForIndex1With2Entries = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+        assertTrue(memorySizeForIndex1With2Entries > memorySizeForIndex1With1Entries);
+
+        // assert cache is empty for index2
+        assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+        // create first cache entry in index2
+        createCacheEntry(client, index2, "hello");
+        assertCacheState(client, index2, 0, 1);
+        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
+
+        // invalidate the cache for index1
+        indexRandom(false, client.prepareIndex(index1).setId("1").setSource("d", "hello"));
+        forceMerge(client, index1);
+        // Assert cache is cleared up
+        assertBusy(
+            () -> { assertEquals(0, getRequestCacheStats(client, index1).getMemorySizeInBytes()); },
+            cacheCleanIntervalInMillis * MAX_ITERATIONS,
+            TimeUnit.MILLISECONDS
+        );
+
+        // invalidate the cache for index2
+        indexRandom(false, client.prepareIndex(index2).setId("1").setSource("d", "hello"));
+        forceMerge(client, index2);
+
+        // create another cache entry in index 1 same as memorySizeForIndex1With1Entries, this should not be cleaned up.
+        createCacheEntry(client, index1, "hello");
+
+        // sleep until cache cleaner would have cleaned up the stale key from index2
+        assertBusy(() -> {
+            // assert segment counts stay the same
+            assertEquals(2, getSegmentCount(client, index1));
+            assertEquals(2, getSegmentCount(client, index2));
+            // cache cleaner should have cleaned up the stale key from index2 and hence cache should be empty
+            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
+            // cache cleaner should have only cleaned up the stale entities for index1
+            long currentMemorySizeInBytesForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
+            // assert the memory size of index1 to only contain 1 entry added after flushAndRefresh
+            assertEquals(memorySizeForIndex1With1Entries, currentMemorySizeInBytesForIndex1);
+        }, cacheCleanIntervalInMillis * MAX_ITERATIONS, TimeUnit.MILLISECONDS);
+    }
+
+    private void setupIndex(Client client, String index) throws Exception {
+        assertAcked(
+            client.admin()
+                .indices()
+                .prepareCreate(index)
+                .setMapping("k", "type=keyword")
+                .setSettings(
+                    Settings.builder()
+                        .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
+                        .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+                        .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
+                        // Disable background segment merges invalidating the cache
+                        .put(MergePolicyProvider.INDEX_MERGE_ENABLED, false)
+                )
+                .get()
+        );
+        indexRandom(false, client.prepareIndex(index).setSource("k", "hello"));
+        indexRandom(false, client.prepareIndex(index).setSource("k", "there"));
+        ensureSearchable(index);
+        forceMerge(client, index);
+    }
+
+    private int getSegmentCount(Client client, String indexName) {
+        return client.admin()
+            .indices()
+            .segments(new IndicesSegmentsRequest(indexName))
+            .actionGet()
+            .getIndices()
+            .get(indexName)
+            .getShards()
+            .get(0)
+            .getShards()[0].getSegments()
+            .size();
+    }
+
+    private void forceMerge(Client client, String index) {
+        ForceMergeResponse forceMergeResponse = client.admin().indices().prepareForceMerge(index).setFlush(true).get();
+        OpenSearchAssertions.assertAllSuccessful(forceMergeResponse);
+        refreshAndWaitForReplication();
+    }
+
+    private void createCacheEntry(Client client, String index, String value) {
+        SearchResponse resp = client.prepareSearch(index).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", value)).get();
+        assertSearchResponse(resp);
+        OpenSearchAssertions.assertAllSuccessful(resp);
+    }
+
+    private static void assertCacheState(Client client, String index, long expectedHits, long expectedMisses) {
+        RequestCacheStats requestCacheStats = getRequestCacheStats(client, index);
+        // Check the hit count and miss count together so if they are not
+        // correct we can see both values
+        assertEquals(
+            Arrays.asList(expectedHits, expectedMisses, 0L),
+            Arrays.asList(requestCacheStats.getHitCount(), requestCacheStats.getMissCount(), requestCacheStats.getEvictions())
+        );
+
+    }
+
+    private static RequestCacheStats getRequestCacheStats(Client client, String index) {
+        return client.admin().indices().prepareStats(index).setRequestCache(true).get().getTotal().getRequestCache();
+    }
+
+    private static RequestCacheStats getNodeCacheStats(Client client) {
+        NodesStatsResponse stats = client.admin().cluster().prepareNodesStats().execute().actionGet();
+        for (NodeStats stat : stats.getNodes()) {
+            if (stat.getNode().isDataNode()) {
+                return stat.getIndices().getRequestCache();
+            }
+        }
+        return null;
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/IndicesRequestCacheIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/IndicesRequestCacheIT.java
index 766ca2c1189e5..3ac4277889b25 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/IndicesRequestCacheIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/IndicesRequestCacheIT.java
@@ -34,10 +34,15 @@
 
 import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
 
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.Weight;
 import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.action.admin.cluster.node.stats.NodeStats;
 import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
-import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
 import org.opensearch.action.admin.indices.alias.Alias;
 import org.opensearch.action.admin.indices.cache.clear.ClearIndicesCacheRequest;
 import org.opensearch.action.admin.indices.forcemerge.ForceMergeResponse;
@@ -55,9 +60,12 @@
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.env.NodeEnvironment;
-import org.opensearch.index.IndexNotFoundException;
+import org.opensearch.index.IndexSettings;
 import org.opensearch.index.cache.request.RequestCacheStats;
+import org.opensearch.index.query.QueryBuilder;
 import org.opensearch.index.query.QueryBuilders;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.index.query.TermQueryBuilder;
 import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
 import org.opensearch.search.aggregations.bucket.histogram.DateHistogramInterval;
 import org.opensearch.search.aggregations.bucket.histogram.Histogram;
@@ -66,6 +74,7 @@
 import org.opensearch.test.ParameterizedStaticSettingsOpenSearchIntegTestCase;
 import org.opensearch.test.hamcrest.OpenSearchAssertions;
 
+import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.ZoneId;
@@ -75,13 +84,10 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
-import java.util.concurrent.TimeUnit;
 
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
 import static org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider.CLUSTER_ROUTING_ALLOCATION_ENABLE_SETTING;
-import static org.opensearch.indices.IndicesRequestCache.INDICES_REQUEST_CACHE_STALENESS_THRESHOLD_SETTING;
-import static org.opensearch.indices.IndicesService.INDICES_CACHE_CLEANUP_INTERVAL_SETTING_KEY;
 import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
 import static org.opensearch.search.aggregations.AggregationBuilders.dateHistogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.dateRange;
@@ -126,6 +132,8 @@ public void testCacheAggs() throws Exception {
                         .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
                         .put(SETTING_NUMBER_OF_SHARDS, 1)
                         .put(SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
                 )
                 .get()
         );
@@ -135,6 +143,8 @@ public void testCacheAggs() throws Exception {
             client.prepareIndex(index).setSource("f", "2014-05-13T00:00:00.000Z")
         );
         ensureSearchable(index);
+        // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
+        forceMerge(client, index);
 
         // This is not a random example: serialization with time zones writes shared strings
         // which used to not work well with the query cache because of the handles stream output
@@ -197,6 +207,8 @@ public void testQueryRewrite() throws Exception {
                         .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 5)
                         .put("index.number_of_routing_shards", 5)
                         .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
                 )
                 .get()
         );
@@ -214,12 +226,8 @@ public void testQueryRewrite() throws Exception {
         );
         ensureSearchable(index);
         assertCacheState(client, index, 0, 0);
-
         // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
-        ForceMergeResponse forceMergeResponse = client.admin().indices().prepareForceMerge(index).setFlush(true).get();
-        OpenSearchAssertions.assertAllSuccessful(forceMergeResponse);
-        refreshAndWaitForReplication();
-        ensureSearchable(index);
+        forceMerge(client, index);
 
         assertCacheState(client, index, 0, 0);
 
@@ -268,6 +276,8 @@ public void testQueryRewriteMissingValues() throws Exception {
                         .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
                         .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
                         .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
                 )
                 .get()
         );
@@ -287,10 +297,7 @@ public void testQueryRewriteMissingValues() throws Exception {
         assertCacheState(client, index, 0, 0);
 
         // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
-        ForceMergeResponse forceMergeResponse = client.admin().indices().prepareForceMerge(index).setFlush(true).get();
-        OpenSearchAssertions.assertAllSuccessful(forceMergeResponse);
-        refreshAndWaitForReplication();
-        ensureSearchable(index);
+        forceMerge(client, index);
 
         assertCacheState(client, index, 0, 0);
 
@@ -335,6 +342,8 @@ public void testQueryRewriteDates() throws Exception {
                         .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
                         .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
                         .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
                 )
                 .get()
         );
@@ -354,10 +363,7 @@ public void testQueryRewriteDates() throws Exception {
         assertCacheState(client, index, 0, 0);
 
         // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
-        ForceMergeResponse forceMergeResponse = client.admin().indices().prepareForceMerge(index).setFlush(true).get();
-        OpenSearchAssertions.assertAllSuccessful(forceMergeResponse);
-        refreshAndWaitForReplication();
-        ensureSearchable(index);
+        forceMerge(client, index);
 
         assertCacheState(client, index, 0, 0);
 
@@ -399,6 +405,8 @@ public void testQueryRewriteDatesWithNow() throws Exception {
             .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
             .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
             .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            // Disable index refreshing to avoid cache being invalidated mid-test
+            .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
             .build();
         assertAcked(client.admin().indices().prepareCreate("index-1").setMapping("d", "type=date").setSettings(settings).get());
         assertAcked(client.admin().indices().prepareCreate("index-2").setMapping("d", "type=date").setSettings(settings).get());
@@ -480,6 +488,7 @@ public void testCanCache() throws Exception {
             .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 2)
             .put("index.number_of_routing_shards", 2)
             .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
             .build();
         String index = "index";
         assertAcked(client.admin().indices().prepareCreate(index).setMapping("s", "type=date").setSettings(settings).get());
@@ -499,10 +508,7 @@ public void testCanCache() throws Exception {
         assertCacheState(client, index, 0, 0);
 
         // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
-        ForceMergeResponse forceMergeResponse = client.admin().indices().prepareForceMerge(index).setFlush(true).get();
-        OpenSearchAssertions.assertAllSuccessful(forceMergeResponse);
-        refreshAndWaitForReplication();
-        ensureSearchable(index);
+        forceMerge(client, index);
 
         assertCacheState(client, index, 0, 0);
 
@@ -644,11 +650,15 @@ public void testProfileDisableCache() throws Exception {
                         .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
                         .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
                         .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
                 )
                 .get()
         );
         indexRandom(true, client.prepareIndex(index).setSource("k", "hello"));
         ensureSearchable(index);
+        // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
+        forceMerge(client, index);
 
         int expectedHits = 0;
         int expectedMisses = 0;
@@ -672,557 +682,7 @@ public void testProfileDisableCache() throws Exception {
             assertCacheState(client, index, expectedHits, expectedMisses);
         }
     }
-
-    public void testCacheWithInvalidation() throws Exception {
-        Client client = client();
-        String index = "index";
-        assertAcked(
-            client.admin()
-                .indices()
-                .prepareCreate(index)
-                .setMapping("k", "type=keyword")
-                .setSettings(
-                    Settings.builder()
-                        .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
-                        .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
-                        .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
-                        .put("index.refresh_interval", -1)
-                )
-                .get()
-        );
-        indexRandom(true, client.prepareIndex(index).setSource("k", "hello"));
-        ensureSearchable(index);
-        SearchResponse resp = client.prepareSearch(index).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", "hello")).get();
-        assertSearchResponse(resp);
-        OpenSearchAssertions.assertAllSuccessful(resp);
-        assertThat(resp.getHits().getTotalHits().value, equalTo(1L));
-
-        assertCacheState(client, index, 0, 1);
-        // Index but don't refresh
-        indexRandom(false, client.prepareIndex(index).setSource("k", "hello2"));
-        resp = client.prepareSearch(index).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", "hello")).get();
-        assertSearchResponse(resp);
-        // Should expect hit as here as refresh didn't happen
-        assertCacheState(client, index, 1, 1);
-
-        // Explicit refresh would invalidate cache
-        refreshAndWaitForReplication();
-        // Hit same query again
-        resp = client.prepareSearch(index).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", "hello")).get();
-        assertSearchResponse(resp);
-        // Should expect miss as key has changed due to change in IndexReader.CacheKey (due to refresh)
-        assertCacheState(client, index, 1, 2);
-    }
-
-    // calling cache clear api, when staleness threshold is lower than staleness, it should clean the stale keys from cache
-    public void testCacheClearAPIRemovesStaleKeysWhenStalenessThresholdIsLow() throws Exception {
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    // setting intentionally high to avoid cache cleaner interfering
-                    TimeValue.timeValueMillis(300)
-                )
-        );
-        Client client = client(node);
-        String index1 = "index1";
-        String index2 = "index2";
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // create first cache entry in index1
-        createCacheEntry(client, index1, "hello");
-        assertCacheState(client, index1, 0, 1);
-        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1 > 0);
-
-        // create second cache entry in index1
-        createCacheEntry(client, index1, "there");
-        assertCacheState(client, index1, 0, 2);
-        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
-
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-
-        ClearIndicesCacheRequest clearIndicesCacheRequest = new ClearIndicesCacheRequest(index2);
-        client.admin().indices().clearCache(clearIndicesCacheRequest).actionGet();
-
-        // cache cleaner should have cleaned up the stale key from index 2
-        assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-        // cache cleaner should NOT have cleaned from index 1
-        assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-    }
-
-    // when staleness threshold is lower than staleness, it should clean the stale keys from cache
-    public void testStaleKeysCleanupWithLowThreshold() throws Exception {
-        int cacheCleanIntervalInMillis = 1;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        Client client = client(node);
-        String index1 = "index1";
-        String index2 = "index2";
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // create first cache entry in index1
-        createCacheEntry(client, index1, "hello");
-        assertCacheState(client, index1, 0, 1);
-        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1 > 0);
-
-        // create second cache entry in index1
-        createCacheEntry(client, index1, "there");
-        assertCacheState(client, index1, 0, 2);
-        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
-
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-
-        // force refresh so that it creates 1 stale key
-        flushAndRefresh(index2);
-        // sleep until cache cleaner would have cleaned up the stale key from index 2
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale key from index 2
-            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-            // cache cleaner should NOT have cleaned from index 1
-            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-        // sleep until cache cleaner would have cleaned up the stale key from index 2
-    }
-
-    // when staleness threshold is equal to staleness, it should clean the stale keys from cache
-    public void testCacheCleanupOnEqualStalenessAndThreshold() throws Exception {
-        int cacheCleanIntervalInMillis = 1;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.33)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        Client client = client(node);
-        String index1 = "index1";
-        String index2 = "index2";
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // create first cache entry in index1
-        createCacheEntry(client, index1, "hello");
-        assertCacheState(client, index1, 0, 1);
-        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1 > 0);
-
-        // create second cache entry in index1
-        createCacheEntry(client, index1, "there");
-        assertCacheState(client, index1, 0, 2);
-        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
-
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-
-        // force refresh so that it creates 1 stale key
-        flushAndRefresh(index2);
-        // sleep until cache cleaner would have cleaned up the stale key from index 2
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale key from index 2
-            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-            // cache cleaner should NOT have cleaned from index 1
-            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
-    // when staleness threshold is higher than staleness, it should NOT clean the cache
-    public void testCacheCleanupSkipsWithHighStalenessThreshold() throws Exception {
-        int cacheCleanIntervalInMillis = 1;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.90)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        Client client = client(node);
-        String index1 = "index1";
-        String index2 = "index2";
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // create first cache entry in index1
-        createCacheEntry(client, index1, "hello");
-        assertCacheState(client, index1, 0, 1);
-        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1 > 0);
-
-        // create second cache entry in index1
-        createCacheEntry(client, index1, "there");
-        assertCacheState(client, index1, 0, 2);
-        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
-
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-
-        // force refresh so that it creates 1 stale key
-        flushAndRefresh(index2);
-        // sleep until cache cleaner would have cleaned up the stale key from index 2
-        assertBusy(() -> {
-            // cache cleaner should NOT have cleaned up the stale key from index 2
-            assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-            // cache cleaner should NOT have cleaned from index 1
-            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
-    // when staleness threshold is explicitly set to 0, cache cleaner regularly cleans up stale keys.
-    public void testCacheCleanupOnZeroStalenessThreshold() throws Exception {
-        int cacheCleanIntervalInMillis = 50;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        Client client = client(node);
-        String index1 = "index1";
-        String index2 = "index2";
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // create 10 index1 cache entries
-        for (int i = 1; i <= 10; i++) {
-            long cacheSizeBefore = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-            createCacheEntry(client, index1, "hello" + i);
-            assertCacheState(client, index1, 0, i);
-            long cacheSizeAfter = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-            assertTrue(cacheSizeAfter > cacheSizeBefore);
-        }
-
-        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-
-        // force refresh so that it creates 1 stale key
-        flushAndRefresh(index2);
-        // sleep until cache cleaner would have cleaned up the stale key from index 2
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale key from index 2
-            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-            // cache cleaner should NOT have cleaned from index 1
-            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
-    // when staleness threshold is not explicitly set, cache cleaner regularly cleans up stale keys
-    public void testStaleKeysRemovalWithoutExplicitThreshold() throws Exception {
-        int cacheCleanIntervalInMillis = 1;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        String index1 = "index1";
-        String index2 = "index2";
-        Client client = client(node);
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // create first cache entry in index1
-        createCacheEntry(client, index1, "hello");
-        assertCacheState(client, index1, 0, 1);
-        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1 > 0);
-
-        // create second cache entry in index1
-        createCacheEntry(client, index1, "there");
-        assertCacheState(client, index1, 0, 2);
-        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
-
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-
-        // force refresh so that it creates 1 stale key
-        flushAndRefresh(index2);
-        // sleep until cache cleaner would have cleaned up the stale key from index 2
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale key from index 2
-            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-            // cache cleaner should NOT have cleaned from index 1
-            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
-    // when cache cleaner interval setting is not set, cache cleaner is configured appropriately with the fall-back setting
-    public void testCacheCleanupWithDefaultSettings() throws Exception {
-        int cacheCleanIntervalInMillis = 1;
-        String node = internalCluster().startNode(
-            Settings.builder().put(INDICES_CACHE_CLEANUP_INTERVAL_SETTING_KEY, TimeValue.timeValueMillis(cacheCleanIntervalInMillis))
-        );
-        Client client = client(node);
-        String index1 = "index1";
-        String index2 = "index2";
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // create first cache entry in index1
-        createCacheEntry(client, index1, "hello");
-        assertCacheState(client, index1, 0, 1);
-        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1 > 0);
-
-        // create second cache entry in index1
-        createCacheEntry(client, index1, "there");
-        assertCacheState(client, index1, 0, 2);
-        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(finalMemorySizeForIndex1 > memorySizeForIndex1);
-
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-
-        // force refresh so that it creates 1 stale key
-        flushAndRefresh(index2);
-        // sleep until cache cleaner would have cleaned up the stale key from index 2
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale key from index 2
-            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-            // cache cleaner should NOT have cleaned from index 1
-            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
-    // staleness threshold updates flows through to the cache cleaner
-    public void testDynamicStalenessThresholdUpdate() throws Exception {
-        int cacheCleanIntervalInMillis = 1;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.90)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        Client client = client(node);
-        String index1 = "index1";
-        String index2 = "index2";
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // create first cache entry in index1
-        createCacheEntry(client, index1, "hello");
-        assertCacheState(client, index1, 0, 1);
-        long memorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1 > 0);
-
-        // create second cache entry in index1
-        createCacheEntry(client, index1, "there");
-        assertCacheState(client, index1, 0, 2);
-        assertTrue(getRequestCacheStats(client, index1).getMemorySizeInBytes() > memorySizeForIndex1);
-
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        long finalMemorySizeForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(finalMemorySizeForIndex1 > 0);
-
-        // force refresh so that it creates 1 stale key
-        flushAndRefresh(index2);
-        assertBusy(() -> {
-            // cache cleaner should NOT have cleaned up the stale key from index 2
-            assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-
-        // Update indices.requests.cache.cleanup.staleness_threshold to "10%"
-        ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
-        updateSettingsRequest.persistentSettings(Settings.builder().put(INDICES_REQUEST_CACHE_STALENESS_THRESHOLD_SETTING.getKey(), 0.10));
-        assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
-
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale key from index 2
-            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-            // cache cleaner should NOT have cleaned from index 1
-            assertEquals(finalMemorySizeForIndex1, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
-    // staleness threshold dynamic updates should throw exceptions on invalid input
-    public void testInvalidStalenessThresholdUpdateThrowsException() throws Exception {
-        // Update indices.requests.cache.cleanup.staleness_threshold to "10%" with illegal argument
-        assertThrows("Ratio should be in [0-1.0]", IllegalArgumentException.class, () -> {
-            ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
-            updateSettingsRequest.persistentSettings(
-                Settings.builder().put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 10)
-            );
-            client().admin().cluster().updateSettings(updateSettingsRequest).actionGet();
-        });
-    }
-
-    // closing the Index after caching will clean up from Indices Request Cache
-    public void testCacheClearanceAfterIndexClosure() throws Exception {
-        int cacheCleanIntervalInMillis = 100;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        Client client = client(node);
-        String index = "index";
-        setupIndex(client, index);
-
-        // assert there are no entries in the cache for index
-        assertEquals(0, getRequestCacheStats(client, index).getMemorySizeInBytes());
-        // assert there are no entries in the cache from other indices in the node
-        assertEquals(0, getNodeCacheStats(client).getMemorySizeInBytes());
-        // create first cache entry in index
-        createCacheEntry(client, index, "hello");
-        assertCacheState(client, index, 0, 1);
-        assertTrue(getRequestCacheStats(client, index).getMemorySizeInBytes() > 0);
-        assertTrue(getNodeCacheStats(client).getMemorySizeInBytes() > 0);
-
-        // close index
-        assertAcked(client.admin().indices().prepareClose(index));
-        // request cache stats cannot be access since Index should be closed
-        try {
-            getRequestCacheStats(client, index);
-        } catch (Exception e) {
-            assert (e instanceof IndexClosedException);
-        }
-        // sleep until cache cleaner would have cleaned up the stale key from index
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale keys from index
-            assertEquals(0, getNodeCacheStats(client).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
-    // deleting the Index after caching will clean up from Indices Request Cache
-    public void testCacheCleanupAfterIndexDeletion() throws Exception {
-        int cacheCleanIntervalInMillis = 100;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        Client client = client(node);
-        String index = "index";
-        setupIndex(client, index);
-
-        // assert there are no entries in the cache for index
-        assertEquals(0, getRequestCacheStats(client, index).getMemorySizeInBytes());
-        // assert there are no entries in the cache from other indices in the node
-        assertEquals(0, getNodeCacheStats(client).getMemorySizeInBytes());
-        // create first cache entry in index
-        createCacheEntry(client, index, "hello");
-        assertCacheState(client, index, 0, 1);
-        assertTrue(getRequestCacheStats(client, index).getMemorySizeInBytes() > 0);
-        assertTrue(getNodeCacheStats(client).getMemorySizeInBytes() > 0);
-
-        // delete index
-        assertAcked(client.admin().indices().prepareDelete(index));
-        // request cache stats cannot be access since Index should be deleted
-        try {
-            getRequestCacheStats(client, index);
-        } catch (Exception e) {
-            assert (e instanceof IndexNotFoundException);
-        }
-
-        // sleep until cache cleaner would have cleaned up the stale key from index
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale keys from index
-            assertEquals(0, getNodeCacheStats(client).getMemorySizeInBytes());
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
-    // when staleness threshold is lower than staleness, it should clean the cache from all indices having stale keys
-    public void testStaleKeysCleanupWithMultipleIndices() throws Exception {
-        int cacheCleanIntervalInMillis = 10;
-        String node = internalCluster().startNode(
-            Settings.builder()
-                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_STALENESS_THRESHOLD_SETTING_KEY, 0.10)
-                .put(
-                    IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY,
-                    TimeValue.timeValueMillis(cacheCleanIntervalInMillis)
-                )
-        );
-        Client client = client(node);
-        String index1 = "index1";
-        String index2 = "index2";
-        setupIndex(client, index1);
-        setupIndex(client, index2);
-
-        // assert cache is empty for index1
-        assertEquals(0, getRequestCacheStats(client, index1).getMemorySizeInBytes());
-        // create first cache entry in index1
-        createCacheEntry(client, index1, "hello");
-        assertCacheState(client, index1, 0, 1);
-        long memorySizeForIndex1With1Entries = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1With1Entries > 0);
-
-        // create second cache entry in index1
-        createCacheEntry(client, index1, "there");
-        assertCacheState(client, index1, 0, 2);
-        long memorySizeForIndex1With2Entries = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-        assertTrue(memorySizeForIndex1With2Entries > memorySizeForIndex1With1Entries);
-
-        // assert cache is empty for index2
-        assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-        // create first cache entry in index2
-        createCacheEntry(client, index2, "hello");
-        assertCacheState(client, index2, 0, 1);
-        assertTrue(getRequestCacheStats(client, index2).getMemorySizeInBytes() > 0);
-
-        // force refresh both index1 and index2
-        flushAndRefresh(index1, index2);
-        // create another cache entry in index 1 same as memorySizeForIndex1With1Entries, this should not be cleaned up.
-        createCacheEntry(client, index1, "hello");
-        // sleep until cache cleaner would have cleaned up the stale key from index2
-        assertBusy(() -> {
-            // cache cleaner should have cleaned up the stale key from index2 and hence cache should be empty
-            assertEquals(0, getRequestCacheStats(client, index2).getMemorySizeInBytes());
-            // cache cleaner should have only cleaned up the stale entities for index1
-            long currentMemorySizeInBytesForIndex1 = getRequestCacheStats(client, index1).getMemorySizeInBytes();
-            // assert the memory size of index1 to only contain 1 entry added after flushAndRefresh
-            assertEquals(memorySizeForIndex1With1Entries, currentMemorySizeInBytesForIndex1);
-            // cache for index1 should not be empty since there was an item cached after flushAndRefresh
-            assertTrue(currentMemorySizeInBytesForIndex1 > 0);
-        }, cacheCleanIntervalInMillis * 2, TimeUnit.MILLISECONDS);
-    }
-
+  
     public void testDeleteAndCreateSameIndexShardOnSameNode() throws Exception {
         String node_1 = internalCluster().startNode(Settings.builder().build());
         Client client = client(node_1);
@@ -1238,7 +698,12 @@ public void testDeleteAndCreateSameIndexShardOnSameNode() throws Exception {
         logger.info("Creating an index: {} with 2 shards", indexName);
         createIndex(
             indexName,
-            Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 2).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0).build()
+            Settings.builder()
+                .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 2)
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                // Disable index refreshing to avoid cache being invalidated mid-test
+                .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
+                .build()
         );
 
         ensureGreen(indexName);
@@ -1246,6 +711,9 @@ public void testDeleteAndCreateSameIndexShardOnSameNode() throws Exception {
         logger.info("Writing few docs and searching those which will cache items in RequestCache");
         indexRandom(true, client.prepareIndex(indexName).setSource("k", "hello"));
         indexRandom(true, client.prepareIndex(indexName).setSource("y", "hello again"));
+        ensureSearchable(indexName);
+        // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
+        forceMerge(client, indexName);
         SearchResponse resp = client.prepareSearch(indexName).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", "hello")).get();
         assertSearchResponse(resp);
         resp = client.prepareSearch(indexName).setRequestCache(true).setQuery(QueryBuilders.termQuery("y", "hello")).get();
@@ -1280,8 +748,8 @@ public void testDeleteAndCreateSameIndexShardOnSameNode() throws Exception {
         final Index index = state.metadata().index(indexName).getIndex();
 
         assertBusy(() -> {
-            assertThat(Files.exists(shardDirectory(node_1, index, 0)), equalTo(false));
-            assertThat(Files.exists(shardDirectory(node_2, index, 0)), equalTo(true));
+            assertFalse(Arrays.stream(shardDirectory(node_1, index, 0)).anyMatch(Files::exists));
+            assertEquals(1, Arrays.stream(shardDirectory(node_2, index, 0)).filter(Files::exists).count());
         });
 
         logger.info("Moving the shard: {} again from node:{} to node:{}", indexName + "#0", node_2, node_1);
@@ -1294,11 +762,10 @@ public void testDeleteAndCreateSameIndexShardOnSameNode() throws Exception {
             .setWaitForNoInitializingShards(true)
             .get();
         assertThat(clusterHealth.isTimedOut(), equalTo(false));
-        assertThat(Files.exists(shardDirectory(node_1, index, 0)), equalTo(true));
 
         assertBusy(() -> {
-            assertThat(Files.exists(shardDirectory(node_1, index, 0)), equalTo(true));
-            assertThat(Files.exists(shardDirectory(node_2, index, 0)), equalTo(false));
+            assertEquals(1, Arrays.stream(shardDirectory(node_1, index, 0)).filter(Files::exists).count());
+            assertFalse(Arrays.stream(shardDirectory(node_2, index, 0)).anyMatch(Files::exists));
         });
 
         logger.info("Clearing the cache for index:{}. And verify the request stats doesn't go negative", indexName);
@@ -1311,14 +778,10 @@ public void testDeleteAndCreateSameIndexShardOnSameNode() throws Exception {
         assertTrue(stats.getMemorySizeInBytes() == 0);
     }
 
-    private Path shardDirectory(String server, Index index, int shard) {
-        NodeEnvironment env = internalCluster().getInstance(NodeEnvironment.class, server);
-        final Path[] paths = env.availableShardPaths(new ShardId(index, shard));
-        assert paths.length == 1;
-        return paths[0];
-    }
-
-    private void setupIndex(Client client, String index) throws Exception {
+    public void testTimedOutQuery() throws Exception {
+        // A timed out query should be cached and then invalidated
+        Client client = client();
+        String index = "index";
         assertAcked(
             client.admin()
                 .indices()
@@ -1329,18 +792,57 @@ private void setupIndex(Client client, String index) throws Exception {
                         .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
                         .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
                         .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                        // Disable index refreshing to avoid cache being invalidated mid-test
+                        .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), TimeValue.timeValueMillis(-1))
                 )
                 .get()
         );
         indexRandom(true, client.prepareIndex(index).setSource("k", "hello"));
-        indexRandom(true, client.prepareIndex(index).setSource("k", "there"));
         ensureSearchable(index);
+        // Force merge the index to ensure there can be no background merges during the subsequent searches that would invalidate the cache
+        forceMerge(client, index);
+
+        QueryBuilder timeoutQueryBuilder = new TermQueryBuilder("k", "hello") {
+            @Override
+            protected Query doToQuery(QueryShardContext context) {
+                return new TermQuery(new Term("k", "hello")) {
+                    @Override
+                    public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
+                        // Create the weight before sleeping. Otherwise, TermStates.build() (in the call to super.createWeight()) will
+                        // sometimes throw an exception on timeout, rather than timing out gracefully.
+                        Weight result = super.createWeight(searcher, scoreMode, boost);
+                        try {
+                            Thread.sleep(500);
+                        } catch (InterruptedException ignored) {}
+                        return result;
+                    }
+                };
+            }
+        };
+
+        SearchResponse resp = client.prepareSearch(index)
+            .setRequestCache(true)
+            .setQuery(timeoutQueryBuilder)
+            .setTimeout(TimeValue.ZERO)
+            .get();
+        assertTrue(resp.isTimedOut());
+        RequestCacheStats requestCacheStats = getRequestCacheStats(client, index);
+        // The cache should be empty as the timed-out query was invalidated
+        assertEquals(0, requestCacheStats.getMemorySizeInBytes());
     }
 
-    private void createCacheEntry(Client client, String index, String value) {
-        SearchResponse resp = client.prepareSearch(index).setRequestCache(true).setQuery(QueryBuilders.termQuery("k", value)).get();
-        assertSearchResponse(resp);
-        OpenSearchAssertions.assertAllSuccessful(resp);
+    private Path[] shardDirectory(String server, Index index, int shard) {
+        NodeEnvironment env = internalCluster().getInstance(NodeEnvironment.class, server);
+        final Path[] paths = env.availableShardPaths(new ShardId(index, shard));
+        // the available paths of the shard may be bigger than the 1,
+        // it depends on `InternalTestCluster.numDataPaths`.
+        return paths;
+    }
+
+    private void forceMerge(Client client, String index) {
+        ForceMergeResponse forceMergeResponse = client.admin().indices().prepareForceMerge(index).setFlush(true).get();
+        OpenSearchAssertions.assertAllSuccessful(forceMergeResponse);
+        refreshAndWaitForReplication();
     }
 
     private static void assertCacheState(Client client, String index, long expectedHits, long expectedMisses) {
@@ -1367,4 +869,4 @@ private static RequestCacheStats getNodeCacheStats(Client client) {
         }
         return null;
     }
-}
+}
\ No newline at end of file
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/recovery/DanglingIndicesIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/recovery/DanglingIndicesIT.java
index 8fd7961cab3a7..7bdf33edf1534 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/recovery/DanglingIndicesIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/recovery/DanglingIndicesIT.java
@@ -298,8 +298,8 @@ public void testMustAcceptDataLossToImportDanglingIndex() throws Exception {
      * 1, then create two indices and delete them both while one node in
      * the cluster is stopped. The deletion of the second pushes the deletion
      * of the first out of the graveyard. When the stopped node is resumed,
-     * only the second index will be found into the graveyard and the the
-     * other will be considered dangling, and can therefore be listed and
+     * only the second index will be found into the graveyard and the other
+     * will be considered dangling, and can therefore be listed and
      * deleted through the API
      */
     public void testDanglingIndexCanBeDeleted() throws Exception {
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/recovery/IndexRecoveryIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/recovery/IndexRecoveryIT.java
index 8ce87f37d77cd..68b29851c6c04 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/recovery/IndexRecoveryIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/recovery/IndexRecoveryIT.java
@@ -104,7 +104,6 @@
 import org.opensearch.indices.recovery.RecoveryState.Stage;
 import org.opensearch.indices.replication.common.ReplicationLuceneIndex;
 import org.opensearch.node.NodeClosedException;
-import org.opensearch.node.RecoverySettingsChunkSizePlugin;
 import org.opensearch.plugins.AnalysisPlugin;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.plugins.PluginsService;
@@ -156,7 +155,7 @@
 import static java.util.stream.Collectors.toList;
 import static org.opensearch.action.DocWriteResponse.Result.CREATED;
 import static org.opensearch.action.DocWriteResponse.Result.UPDATED;
-import static org.opensearch.node.RecoverySettingsChunkSizePlugin.CHUNK_SIZE_SETTING;
+import static org.opensearch.indices.recovery.RecoverySettings.INDICES_RECOVERY_CHUNK_SIZE_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
 import static org.hamcrest.Matchers.empty;
@@ -187,7 +186,6 @@ protected Collection<Class<? extends Plugin>> nodePlugins() {
         return Arrays.asList(
             MockTransportService.TestPlugin.class,
             MockFSIndexStore.TestPlugin.class,
-            RecoverySettingsChunkSizePlugin.class,
             TestAnalysisPlugin.class,
             InternalSettingsPlugin.class,
             MockEngineFactoryPlugin.class
@@ -263,7 +261,7 @@ private void slowDownRecovery(ByteSizeValue shardSize) {
                         // one chunk per sec..
                         .put(RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey(), chunkSize, ByteSizeUnit.BYTES)
                         // small chunks
-                        .put(CHUNK_SIZE_SETTING.getKey(), new ByteSizeValue(chunkSize, ByteSizeUnit.BYTES))
+                        .put(INDICES_RECOVERY_CHUNK_SIZE_SETTING.getKey(), new ByteSizeValue(chunkSize, ByteSizeUnit.BYTES))
                 )
                 .get()
                 .isAcknowledged()
@@ -278,7 +276,10 @@ private void restoreRecoverySpeed() {
                 .setTransientSettings(
                     Settings.builder()
                         .put(RecoverySettings.INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING.getKey(), "20mb")
-                        .put(CHUNK_SIZE_SETTING.getKey(), RecoverySettings.DEFAULT_CHUNK_SIZE)
+                        .put(
+                            INDICES_RECOVERY_CHUNK_SIZE_SETTING.getKey(),
+                            RecoverySettings.INDICES_RECOVERY_CHUNK_SIZE_SETTING.getDefault(Settings.EMPTY)
+                        )
                 )
                 .get()
                 .isAcknowledged()
@@ -740,14 +741,7 @@ public void testSnapshotRecovery() throws Exception {
         String nodeA = internalCluster().startNode();
 
         logger.info("--> create repository");
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository(REPO_NAME)
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", randomRepoPath()).put("compress", false))
-                .get()
-        );
+        createRepository(REPO_NAME, "fs", Settings.builder().put("location", randomRepoPath()).put("compress", false));
 
         ensureGreen();
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SearchReplicaReplicationIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SearchReplicaReplicationIT.java
new file mode 100644
index 0000000000000..a1b512c326ac5
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SearchReplicaReplicationIT.java
@@ -0,0 +1,85 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.replication;
+
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.junit.After;
+import org.junit.Before;
+
+import java.nio.file.Path;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class SearchReplicaReplicationIT extends SegmentReplicationBaseIT {
+
+    private static final String REPOSITORY_NAME = "test-remote-store-repo";
+    protected Path absolutePath;
+
+    private Boolean useRemoteStore;
+
+    @Before
+    public void randomizeRemoteStoreEnabled() {
+        useRemoteStore = randomBoolean();
+    }
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        if (useRemoteStore) {
+            if (absolutePath == null) {
+                absolutePath = randomRepoPath().toAbsolutePath();
+            }
+            return Settings.builder()
+                .put(super.nodeSettings(nodeOrdinal))
+                .put(remoteStoreClusterSettings(REPOSITORY_NAME, absolutePath))
+                .build();
+        }
+        return super.nodeSettings(nodeOrdinal);
+    }
+
+    @After
+    public void teardown() {
+        if (useRemoteStore) {
+            clusterAdmin().prepareCleanupRepository(REPOSITORY_NAME).get();
+        }
+    }
+
+    @Override
+    public Settings indexSettings() {
+        return Settings.builder()
+            .put(super.indexSettings())
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS, 1)
+            .build();
+    }
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder().put(super.featureFlagSettings()).put(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL, true).build();
+    }
+
+    public void testReplication() throws Exception {
+        internalCluster().startClusterManagerOnlyNode();
+        final String primary = internalCluster().startDataOnlyNode();
+        createIndex(INDEX_NAME);
+        ensureYellowAndNoInitializingShards(INDEX_NAME);
+        final String replica = internalCluster().startDataOnlyNode();
+        ensureGreen(INDEX_NAME);
+
+        final int docCount = 10;
+        for (int i = 0; i < docCount; i++) {
+            client().prepareIndex(INDEX_NAME).setId(Integer.toString(i)).setSource("field", "value" + i).execute().get();
+        }
+        refresh(INDEX_NAME);
+        waitForSearchableDocs(docCount, primary, replica);
+    }
+
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java
index 70da3b0e38472..2421a1a507372 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/replication/SegmentReplicationIT.java
@@ -1405,7 +1405,7 @@ public void testPitCreatedOnReplica() throws Exception {
             .setPointInTime(new PointInTimeBuilder(pitResponse.getId()).setKeepAlive(TimeValue.timeValueDays(1)))
             .setRequestCache(false)
             .get();
-        PitTestsUtil.assertUsingGetAllPits(client(replica), pitResponse.getId(), pitResponse.getCreationTime());
+        PitTestsUtil.assertUsingGetAllPits(client(replica), pitResponse.getId(), pitResponse.getCreationTime(), TimeValue.timeValueDays(1));
         assertSegments(false, INDEX_NAME, 1, client(replica), pitResponse.getId());
 
         List<String> currentFiles = List.of(replicaShard.store().directory().listAll());
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/settings/SearchOnlyReplicaFeatureFlagIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/settings/SearchOnlyReplicaFeatureFlagIT.java
new file mode 100644
index 0000000000000..40341a210d472
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/settings/SearchOnlyReplicaFeatureFlagIT.java
@@ -0,0 +1,67 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.settings;
+
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REPLICATION_TYPE;
+import static org.opensearch.cluster.routing.allocation.decider.SearchReplicaAllocationDecider.SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.SUITE, numDataNodes = 1)
+public class SearchOnlyReplicaFeatureFlagIT extends OpenSearchIntegTestCase {
+
+    private static final String TEST_INDEX = "test_index";
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder()
+            .put(super.featureFlagSettings())
+            .put(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL, Boolean.FALSE)
+            .build();
+    }
+
+    public void testCreateFeatureFlagDisabled() {
+        Settings settings = Settings.builder().put(indexSettings()).put(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL, false).build();
+        IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, () -> createIndex(TEST_INDEX, settings));
+        assertTrue(exception.getMessage().contains("unknown setting"));
+    }
+
+    public void testUpdateFeatureFlagDisabled() {
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+            .build();
+
+        createIndex(TEST_INDEX, settings);
+        IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, () -> {
+            client().admin()
+                .indices()
+                .prepareUpdateSettings(TEST_INDEX)
+                .setSettings(Settings.builder().put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 1))
+                .get();
+        });
+        assertTrue(exception.getMessage().contains("unknown setting"));
+    }
+
+    public void testFilterAllocationSettingNotRegistered() {
+        expectThrows(IllegalArgumentException.class, () -> {
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().put(SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING.getKey() + "_name", "node"))
+                .execute()
+                .actionGet();
+        });
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/settings/SearchOnlyReplicaIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/settings/SearchOnlyReplicaIT.java
new file mode 100644
index 0000000000000..6bd91df1de66f
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/settings/SearchOnlyReplicaIT.java
@@ -0,0 +1,245 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.settings;
+
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.action.support.WriteRequest;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.Preference;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.index.query.QueryBuilders;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.InternalTestCluster;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.io.IOException;
+
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REPLICATION_TYPE;
+import static org.opensearch.cluster.routing.UnassignedInfo.INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class SearchOnlyReplicaIT extends OpenSearchIntegTestCase {
+
+    private static final String TEST_INDEX = "test_index";
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder().put(super.featureFlagSettings()).put(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL, Boolean.TRUE).build();
+    }
+
+    private final String expectedFailureMessage =
+        "To set index.number_of_search_only_replicas, index.replication.type must be set to SEGMENT";
+
+    @Override
+    public Settings indexSettings() {
+        return Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS, 1)
+            .put(INDEX_DELAYED_NODE_LEFT_TIMEOUT_SETTING.getKey(), "0ms") // so that after we punt a node we can immediately try to
+                                                                          // reallocate after node left.
+            .put(SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+            .build();
+    }
+
+    public void testCreateDocRepFails() {
+        Settings settings = Settings.builder().put(indexSettings()).put(SETTING_REPLICATION_TYPE, ReplicationType.DOCUMENT).build();
+
+        IllegalArgumentException illegalArgumentException = expectThrows(
+            IllegalArgumentException.class,
+            () -> createIndex(TEST_INDEX, settings)
+        );
+        assertEquals(expectedFailureMessage, illegalArgumentException.getMessage());
+    }
+
+    public void testUpdateDocRepFails() {
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(SETTING_REPLICATION_TYPE, ReplicationType.DOCUMENT)
+            .build();
+        // create succeeds
+        createIndex(TEST_INDEX, settings);
+
+        // update fails
+        IllegalArgumentException illegalArgumentException = expectThrows(IllegalArgumentException.class, () -> {
+            client().admin()
+                .indices()
+                .prepareUpdateSettings(TEST_INDEX)
+                .setSettings(Settings.builder().put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 1))
+                .get();
+        });
+        assertEquals(expectedFailureMessage, illegalArgumentException.getMessage());
+    }
+
+    public void testFailoverWithSearchReplica_WithWriterReplicas() throws IOException {
+        int numSearchReplicas = 1;
+        int numWriterReplicas = 1;
+        internalCluster().startClusterManagerOnlyNode();
+        String primaryNodeName = internalCluster().startDataOnlyNode();
+        createIndex(
+            TEST_INDEX,
+            Settings.builder()
+                .put(indexSettings())
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numWriterReplicas)
+                .put(IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS, numSearchReplicas)
+                .build()
+        );
+        ensureYellow(TEST_INDEX);
+        // add 2 nodes for the replicas
+        internalCluster().startDataOnlyNodes(2);
+        ensureGreen(TEST_INDEX);
+
+        // assert shards are on separate nodes & all active
+        assertActiveShardCounts(numSearchReplicas, numWriterReplicas);
+
+        // stop the primary and ensure search shard is not promoted:
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(primaryNodeName));
+        ensureYellowAndNoInitializingShards(TEST_INDEX);
+
+        assertActiveShardCounts(numSearchReplicas, 0); // 1 repl is inactive that was promoted to primary
+        // add back a node
+        internalCluster().startDataOnlyNode();
+        ensureGreen(TEST_INDEX);
+    }
+
+    public void testFailoverWithSearchReplica_WithoutWriterReplicas() throws IOException {
+        int numSearchReplicas = 1;
+        int numWriterReplicas = 0;
+        internalCluster().startClusterManagerOnlyNode();
+        String primaryNodeName = internalCluster().startDataOnlyNode();
+        createIndex(
+            TEST_INDEX,
+            Settings.builder()
+                .put(indexSettings())
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numWriterReplicas)
+                .put(IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS, numSearchReplicas)
+                .build()
+        );
+        ensureYellow(TEST_INDEX);
+        client().prepareIndex(TEST_INDEX).setId("1").setSource("foo", "bar").setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE).get();
+        // start a node for our search replica
+        String replica = internalCluster().startDataOnlyNode();
+        ensureGreen(TEST_INDEX);
+        assertActiveSearchShards(numSearchReplicas);
+        assertHitCount(client(replica).prepareSearch(TEST_INDEX).setSize(0).setPreference("_only_local").get(), 1);
+
+        // stop the primary and ensure search shard is not promoted:
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(primaryNodeName));
+        ensureRed(TEST_INDEX);
+        assertActiveSearchShards(numSearchReplicas);
+        // while red our search shard is still searchable
+        assertHitCount(client(replica).prepareSearch(TEST_INDEX).setSize(0).setPreference("_only_local").get(), 1);
+    }
+
+    public void testSearchReplicaScaling() {
+        internalCluster().startNodes(2);
+        createIndex(TEST_INDEX);
+        ensureGreen(TEST_INDEX);
+        // assert settings
+        Metadata metadata = client().admin().cluster().prepareState().get().getState().metadata();
+        int numSearchReplicas = Integer.parseInt(metadata.index(TEST_INDEX).getSettings().get(SETTING_NUMBER_OF_SEARCH_REPLICAS));
+        assertEquals(1, numSearchReplicas);
+
+        // assert cluster state & routing table
+        assertActiveSearchShards(1);
+
+        // Add another node and search replica
+        internalCluster().startDataOnlyNode();
+        client().admin()
+            .indices()
+            .prepareUpdateSettings(TEST_INDEX)
+            .setSettings(Settings.builder().put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 2))
+            .get();
+
+        ensureGreen(TEST_INDEX);
+        assertActiveSearchShards(2);
+
+        // remove all search shards
+        client().admin()
+            .indices()
+            .prepareUpdateSettings(TEST_INDEX)
+            .setSettings(Settings.builder().put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 0))
+            .get();
+        ensureGreen(TEST_INDEX);
+        assertActiveSearchShards(0);
+    }
+
+    public void testSearchReplicaRoutingPreference() throws IOException {
+        int numSearchReplicas = 1;
+        int numWriterReplicas = 1;
+        internalCluster().startClusterManagerOnlyNode();
+        String primaryNodeName = internalCluster().startDataOnlyNode();
+        createIndex(
+            TEST_INDEX,
+            Settings.builder()
+                .put(indexSettings())
+                .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numWriterReplicas)
+                .put(IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS, numSearchReplicas)
+                .build()
+        );
+        ensureYellow(TEST_INDEX);
+        client().prepareIndex(TEST_INDEX).setId("1").setSource("foo", "bar").setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE).get();
+        // add 2 nodes for the replicas
+        internalCluster().startDataOnlyNodes(2);
+        ensureGreen(TEST_INDEX);
+
+        assertActiveShardCounts(numSearchReplicas, numWriterReplicas);
+
+        // set preference to search replica here - we default to this when there are
+        // search replicas but tests will randomize this value if unset
+        SearchResponse response = client().prepareSearch(TEST_INDEX)
+            .setPreference(Preference.SEARCH_REPLICA.type())
+            .setQuery(QueryBuilders.matchAllQuery())
+            .get();
+
+        String nodeId = response.getHits().getAt(0).getShard().getNodeId();
+        IndexShardRoutingTable indexShardRoutingTable = getIndexShardRoutingTable();
+        assertEquals(nodeId, indexShardRoutingTable.searchOnlyReplicas().get(0).currentNodeId());
+    }
+
+    /**
+     * Helper to assert counts of active shards for each type.
+     */
+    private void assertActiveShardCounts(int expectedSearchReplicaCount, int expectedWriteReplicaCount) {
+        // assert routing table
+        IndexShardRoutingTable indexShardRoutingTable = getIndexShardRoutingTable();
+        // assert search replica count
+        int activeCount = expectedSearchReplicaCount + expectedWriteReplicaCount;
+        assertEquals(expectedSearchReplicaCount, indexShardRoutingTable.searchOnlyReplicas().stream().filter(ShardRouting::active).count());
+        assertEquals(expectedWriteReplicaCount, indexShardRoutingTable.writerReplicas().stream().filter(ShardRouting::active).count());
+        assertEquals(
+            expectedWriteReplicaCount + expectedSearchReplicaCount,
+            indexShardRoutingTable.replicaShards().stream().filter(ShardRouting::active).count()
+        );
+
+        // assert routing nodes
+        ClusterState clusterState = getClusterState();
+        assertEquals(activeCount, clusterState.getRoutingNodes().shards(r -> r.active() && !r.primary()).size());
+        assertEquals(expectedSearchReplicaCount, clusterState.getRoutingNodes().shards(r -> r.active() && r.isSearchOnly()).size());
+        assertEquals(
+            expectedWriteReplicaCount,
+            clusterState.getRoutingNodes().shards(r -> r.active() && !r.primary() && !r.isSearchOnly()).size()
+        );
+    }
+
+    private void assertActiveSearchShards(int expectedSearchReplicaCount) {
+        assertActiveShardCounts(expectedSearchReplicaCount, 0);
+    }
+
+    private IndexShardRoutingTable getIndexShardRoutingTable() {
+        return getClusterState().routingTable().index(TEST_INDEX).shards().values().stream().findFirst().get();
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/indices/settings/UpdateSettingsIT.java b/server/src/internalClusterTest/java/org/opensearch/indices/settings/UpdateSettingsIT.java
index 6e94c50eec42a..f9b818b210464 100644
--- a/server/src/internalClusterTest/java/org/opensearch/indices/settings/UpdateSettingsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/indices/settings/UpdateSettingsIT.java
@@ -35,12 +35,18 @@
 import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.action.admin.indices.settings.get.GetSettingsResponse;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.applicationtemplates.ClusterStateSystemTemplateLoader;
+import org.opensearch.cluster.applicationtemplates.SystemTemplate;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateMetadata;
+import org.opensearch.cluster.applicationtemplates.TemplateRepositoryMetadata;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Priority;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.IndexService;
 import org.opensearch.index.VersionType;
@@ -50,10 +56,14 @@
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.threadpool.ThreadPool;
 
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.UUID;
 
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_BLOCKS_METADATA;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_BLOCKS_READ;
@@ -98,6 +108,58 @@ public void testInvalidDynamicUpdate() {
         assertNotEquals(indexMetadata.getSettings().get("index.dummy"), "invalid dynamic value");
     }
 
+    public void testDynamicUpdateWithContextSettingOverlap() throws IOException {
+        String templateContent = "{\n"
+            + "  \"template\": {\n"
+            + "    \"settings\": {\n"
+            + "      \"index.merge.policy\": \"log_byte_size\"\n"
+            + "    }\n"
+            + "  },\n"
+            + "  \"_meta\": {\n"
+            + "    \"_type\": \"@abc_template\",\n"
+            + "    \"_version\": 1\n"
+            + "  },\n"
+            + "  \"version\": 1\n"
+            + "}\n";
+
+        ClusterStateSystemTemplateLoader loader = new ClusterStateSystemTemplateLoader(
+            internalCluster().clusterManagerClient(),
+            () -> internalCluster().getInstance(ClusterService.class).state()
+        );
+        loader.loadTemplate(
+            new SystemTemplate(
+                BytesReference.fromByteBuffer(ByteBuffer.wrap(templateContent.getBytes(StandardCharsets.UTF_8))),
+                SystemTemplateMetadata.fromComponentTemplateInfo("testcontext", 1L),
+                new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L)
+            )
+        );
+
+        createIndex("test", new Context("testcontext"));
+
+        IllegalArgumentException validationException = expectThrows(
+            IllegalArgumentException.class,
+            () -> client().admin()
+                .indices()
+                .prepareUpdateSettings("test")
+                .setSettings(Settings.builder().put("index.merge.policy", "tiered"))
+                .execute()
+                .actionGet()
+        );
+        assertTrue(
+            validationException.getMessage()
+                .contains("Cannot apply context template as user provide settings have overlap with the included context template")
+        );
+
+        assertAcked(
+            client().admin()
+                .indices()
+                .prepareUpdateSettings("test")
+                .setSettings(Settings.builder().put("index.refresh_interval", "60s"))
+                .execute()
+                .actionGet()
+        );
+    }
+
     @Override
     protected Collection<Class<? extends Plugin>> nodePlugins() {
         return Arrays.asList(DummySettingPlugin.class, FinalSettingPlugin.class);
diff --git a/server/src/internalClusterTest/java/org/opensearch/ingest/IngestClientIT.java b/server/src/internalClusterTest/java/org/opensearch/ingest/IngestClientIT.java
index 9481a6116cdbc..0eb37a7b25618 100644
--- a/server/src/internalClusterTest/java/org/opensearch/ingest/IngestClientIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/ingest/IngestClientIT.java
@@ -60,15 +60,18 @@
 import org.opensearch.plugins.Plugin;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.ParameterizedStaticSettingsOpenSearchIntegTestCase;
+import org.hamcrest.MatcherAssert;
 
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
 import static org.opensearch.test.NodeRoles.nonIngestNode;
+import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.notNullValue;
@@ -159,6 +162,14 @@ public void testSimulate() throws Exception {
     }
 
     public void testBulkWithIngestFailures() throws Exception {
+        runBulkTestWithRandomDocs(false);
+    }
+
+    public void testBulkWithIngestFailuresWithBatchSize() throws Exception {
+        runBulkTestWithRandomDocs(true);
+    }
+
+    private void runBulkTestWithRandomDocs(boolean shouldSetBatchSize) throws Exception {
         createIndex("index");
 
         BytesReference source = BytesReference.bytes(
@@ -177,6 +188,9 @@ public void testBulkWithIngestFailures() throws Exception {
 
         int numRequests = scaledRandomIntBetween(32, 128);
         BulkRequest bulkRequest = new BulkRequest();
+        if (shouldSetBatchSize) {
+            bulkRequest.batchSize(scaledRandomIntBetween(2, numRequests));
+        }
         for (int i = 0; i < numRequests; i++) {
             IndexRequest indexRequest = new IndexRequest("index").id(Integer.toString(i)).setPipeline("_id");
             indexRequest.source(Requests.INDEX_CONTENT_TYPE, "field", "value", "fail", i % 2 == 0);
@@ -200,6 +214,9 @@ public void testBulkWithIngestFailures() throws Exception {
                 );
                 assertThat(indexResponse, notNullValue());
                 assertThat(indexResponse.getId(), equalTo(Integer.toString(i)));
+                // verify field of successful doc
+                Map<String, Object> successDoc = client().prepareGet("index", indexResponse.getId()).get().getSourceAsMap();
+                assertThat(successDoc.get("processed"), equalTo(true));
                 assertEquals(DocWriteResponse.Result.CREATED, indexResponse.getResult());
             }
         }
@@ -209,6 +226,58 @@ public void testBulkWithIngestFailures() throws Exception {
         assertTrue(deletePipelineResponse.isAcknowledged());
     }
 
+    public void testBulkWithIngestFailuresAndDropBatch() throws Exception {
+        createIndex("index");
+
+        BytesReference source = BytesReference.bytes(
+            jsonBuilder().startObject()
+                .field("description", "my_pipeline")
+                .startArray("processors")
+                .startObject()
+                .startObject("test")
+                .endObject()
+                .endObject()
+                .endArray()
+                .endObject()
+        );
+        PutPipelineRequest putPipelineRequest = new PutPipelineRequest("_id", source, MediaTypeRegistry.JSON);
+        client().admin().cluster().putPipeline(putPipelineRequest).get();
+
+        BulkRequest bulkRequest = new BulkRequest();
+        bulkRequest.batchSize(3);
+        bulkRequest.add(
+            new IndexRequest("index").id("_fail").setPipeline("_id").source(Requests.INDEX_CONTENT_TYPE, "field", "value", "fail", true)
+        );
+        bulkRequest.add(
+            new IndexRequest("index").id("_success").setPipeline("_id").source(Requests.INDEX_CONTENT_TYPE, "field", "value", "fail", false)
+        );
+        bulkRequest.add(
+            new IndexRequest("index").id("_drop").setPipeline("_id").source(Requests.INDEX_CONTENT_TYPE, "field", "value", "drop", true)
+        );
+
+        BulkResponse response = client().bulk(bulkRequest).actionGet();
+        MatcherAssert.assertThat(response.getItems().length, equalTo(bulkRequest.requests().size()));
+
+        Map<String, BulkItemResponse> results = Arrays.stream(response.getItems())
+            .collect(Collectors.toMap(BulkItemResponse::getId, r -> r));
+
+        MatcherAssert.assertThat(results.keySet(), containsInAnyOrder("_fail", "_success", "_drop"));
+        assertNotNull(results.get("_fail").getFailure());
+        assertNull(results.get("_success").getFailure());
+        assertNull(results.get("_drop").getFailure());
+
+        // verify dropped doc not in index
+        assertNull(client().prepareGet("index", "_drop").get().getSourceAsMap());
+
+        // verify field of successful doc
+        Map<String, Object> successDoc = client().prepareGet("index", "_success").get().getSourceAsMap();
+        assertThat(successDoc.get("processed"), equalTo(true));
+
+        // cleanup
+        AcknowledgedResponse deletePipelineResponse = client().admin().cluster().prepareDeletePipeline("_id").get();
+        assertTrue(deletePipelineResponse.isAcknowledged());
+    }
+
     public void testBulkWithUpsert() throws Exception {
         createIndex("index");
 
@@ -246,6 +315,87 @@ public void testBulkWithUpsert() throws Exception {
         assertThat(upserted.get("processed"), equalTo(true));
     }
 
+    public void testSingleDocIngestFailure() throws Exception {
+        createIndex("test");
+        BytesReference source = BytesReference.bytes(
+            jsonBuilder().startObject()
+                .field("description", "my_pipeline")
+                .startArray("processors")
+                .startObject()
+                .startObject("test")
+                .endObject()
+                .endObject()
+                .endArray()
+                .endObject()
+        );
+        PutPipelineRequest putPipelineRequest = new PutPipelineRequest("_id", source, MediaTypeRegistry.JSON);
+        client().admin().cluster().putPipeline(putPipelineRequest).get();
+
+        GetPipelineRequest getPipelineRequest = new GetPipelineRequest("_id");
+        GetPipelineResponse getResponse = client().admin().cluster().getPipeline(getPipelineRequest).get();
+        assertThat(getResponse.isFound(), is(true));
+        assertThat(getResponse.pipelines().size(), equalTo(1));
+        assertThat(getResponse.pipelines().get(0).getId(), equalTo("_id"));
+
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> client().prepareIndex("test")
+                .setId("1")
+                .setPipeline("_id")
+                .setSource(Requests.INDEX_CONTENT_TYPE, "field", "value", "fail", true)
+                .get()
+        );
+
+        DeletePipelineRequest deletePipelineRequest = new DeletePipelineRequest("_id");
+        AcknowledgedResponse response = client().admin().cluster().deletePipeline(deletePipelineRequest).get();
+        assertThat(response.isAcknowledged(), is(true));
+
+        getResponse = client().admin().cluster().prepareGetPipeline("_id").get();
+        assertThat(getResponse.isFound(), is(false));
+        assertThat(getResponse.pipelines().size(), equalTo(0));
+    }
+
+    public void testSingleDocIngestDrop() throws Exception {
+        createIndex("test");
+        BytesReference source = BytesReference.bytes(
+            jsonBuilder().startObject()
+                .field("description", "my_pipeline")
+                .startArray("processors")
+                .startObject()
+                .startObject("test")
+                .endObject()
+                .endObject()
+                .endArray()
+                .endObject()
+        );
+        PutPipelineRequest putPipelineRequest = new PutPipelineRequest("_id", source, MediaTypeRegistry.JSON);
+        client().admin().cluster().putPipeline(putPipelineRequest).get();
+
+        GetPipelineRequest getPipelineRequest = new GetPipelineRequest("_id");
+        GetPipelineResponse getResponse = client().admin().cluster().getPipeline(getPipelineRequest).get();
+        assertThat(getResponse.isFound(), is(true));
+        assertThat(getResponse.pipelines().size(), equalTo(1));
+        assertThat(getResponse.pipelines().get(0).getId(), equalTo("_id"));
+
+        DocWriteResponse indexResponse = client().prepareIndex("test")
+            .setId("1")
+            .setPipeline("_id")
+            .setSource(Requests.INDEX_CONTENT_TYPE, "field", "value", "drop", true)
+            .get();
+        assertEquals(DocWriteResponse.Result.NOOP, indexResponse.getResult());
+
+        Map<String, Object> doc = client().prepareGet("test", "1").get().getSourceAsMap();
+        assertNull(doc);
+
+        DeletePipelineRequest deletePipelineRequest = new DeletePipelineRequest("_id");
+        AcknowledgedResponse response = client().admin().cluster().deletePipeline(deletePipelineRequest).get();
+        assertThat(response.isAcknowledged(), is(true));
+
+        getResponse = client().admin().cluster().prepareGetPipeline("_id").get();
+        assertThat(getResponse.isFound(), is(false));
+        assertThat(getResponse.pipelines().size(), equalTo(0));
+    }
+
     public void test() throws Exception {
         BytesReference source = BytesReference.bytes(
             jsonBuilder().startObject()
diff --git a/server/src/internalClusterTest/java/org/opensearch/nodestats/NodeStatsIT.java b/server/src/internalClusterTest/java/org/opensearch/nodestats/NodeStatsIT.java
index f270cb1399072..22c1679babb52 100644
--- a/server/src/internalClusterTest/java/org/opensearch/nodestats/NodeStatsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/nodestats/NodeStatsIT.java
@@ -10,6 +10,9 @@
 
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.action.DocWriteResponse;
+import org.opensearch.action.admin.cluster.node.stats.NodeStats;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsResponse;
+import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.bulk.BulkItemResponse;
 import org.opensearch.action.bulk.BulkRequest;
 import org.opensearch.action.bulk.BulkResponse;
@@ -19,21 +22,35 @@
 import org.opensearch.action.index.IndexResponse;
 import org.opensearch.action.update.UpdateRequest;
 import org.opensearch.action.update.UpdateResponse;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.IndexNotFoundException;
 import org.opensearch.index.engine.DocumentMissingException;
 import org.opensearch.index.engine.VersionConflictEngineException;
 import org.opensearch.index.shard.IndexingStats.Stats.DocStatusStats;
+import org.opensearch.indices.NodeIndicesStats;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
 import org.opensearch.test.OpenSearchIntegTestCase.Scope;
 import org.hamcrest.MatcherAssert;
 
+import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicLong;
 
 import static java.util.Collections.singletonMap;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
 
@@ -243,6 +260,280 @@ public void testNodeIndicesStatsDocStatusStatsCreateDeleteUpdate() {
         }
     }
 
+    public void testNodeIndicesStatsDocStatsWithAggregations() {
+        {  // Testing Create
+            final String INDEX = "create_index";
+            final String ID = "id";
+            DocStatusStats expectedDocStatusStats = new DocStatusStats();
+
+            IndexResponse response = client().index(new IndexRequest(INDEX).id(ID).source(SOURCE).create(true)).actionGet();
+            expectedDocStatusStats.inc(response.status());
+
+            CommonStatsFlags commonStatsFlags = new CommonStatsFlags();
+            commonStatsFlags.setIncludeIndicesStatsByLevel(true);
+
+            DocStatusStats docStatusStats = client().admin()
+                .cluster()
+                .prepareNodesStats()
+                .setIndices(commonStatsFlags)
+                .execute()
+                .actionGet()
+                .getNodes()
+                .get(0)
+                .getIndices()
+                .getIndexing()
+                .getTotal()
+                .getDocStatusStats();
+
+            assertTrue(
+                Arrays.equals(
+                    docStatusStats.getDocStatusCounter(),
+                    expectedDocStatusStats.getDocStatusCounter(),
+                    Comparator.comparingLong(AtomicLong::longValue)
+                )
+            );
+        }
+    }
+
+    /**
+     * Default behavior - without consideration of request level param on level, the NodeStatsRequest always
+     * returns ShardStats which is aggregated on the coordinator node when creating the XContent.
+     */
+    public void testNodeIndicesStatsXContentWithoutAggregationOnNodes() {
+        List<String> testLevels = new ArrayList<>();
+        testLevels.add("null");
+        testLevels.add(NodeIndicesStats.StatsLevel.NODE.getRestName());
+        testLevels.add(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+        testLevels.add(NodeIndicesStats.StatsLevel.SHARDS.getRestName());
+        testLevels.add("unknown");
+
+        internalCluster().startNode();
+        ensureGreen();
+        String indexName = "test1";
+        assertAcked(
+            prepareCreate(
+                indexName,
+                clusterService().state().getNodes().getSize(),
+                Settings.builder().put("number_of_shards", 2).put("number_of_replicas", clusterService().state().getNodes().getSize() - 1)
+            )
+        );
+        ensureGreen();
+        ClusterState clusterState = client().admin().cluster().prepareState().get().getState();
+
+        testLevels.forEach(testLevel -> {
+            NodesStatsResponse response;
+            if (!testLevel.equals("null")) {
+                ArrayList<String> level_arg = new ArrayList<>();
+                level_arg.add(testLevel);
+
+                CommonStatsFlags commonStatsFlags = new CommonStatsFlags();
+                commonStatsFlags.setLevels(level_arg.toArray(new String[0]));
+                response = client().admin().cluster().prepareNodesStats().setIndices(commonStatsFlags).get();
+            } else {
+                response = client().admin().cluster().prepareNodesStats().get();
+            }
+
+            NodeStats nodeStats = response.getNodes().get(0);
+            assertNotNull(nodeStats.getIndices().getShardStats(clusterState.metadata().index(indexName).getIndex()));
+            try {
+                // Without any param - default is level = nodes
+                XContentBuilder builder = XContentFactory.jsonBuilder();
+                builder.startObject();
+                builder = nodeStats.getIndices().toXContent(builder, ToXContent.EMPTY_PARAMS);
+                builder.endObject();
+
+                Map<String, Object> xContentMap = xContentBuilderToMap(builder);
+                LinkedHashMap indicesStatsMap = (LinkedHashMap) xContentMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+                assertFalse(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.INDICES));
+                assertFalse(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.SHARDS));
+
+                // With param containing level as 'indices', the indices stats are returned
+                builder = XContentFactory.jsonBuilder();
+                builder.startObject();
+                builder = nodeStats.getIndices()
+                    .toXContent(
+                        builder,
+                        new ToXContent.MapParams(Collections.singletonMap("level", NodeIndicesStats.StatsLevel.INDICES.getRestName()))
+                    );
+                builder.endObject();
+
+                xContentMap = xContentBuilderToMap(builder);
+                indicesStatsMap = (LinkedHashMap) xContentMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+                assertTrue(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.INDICES.getRestName()));
+                assertFalse(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.SHARDS.getRestName()));
+
+                LinkedHashMap indexLevelStats = (LinkedHashMap) indicesStatsMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+                assertTrue(indexLevelStats.containsKey(indexName));
+
+                // With param containing level as 'shards', the shard stats are returned
+                builder = XContentFactory.jsonBuilder();
+                builder.startObject();
+                builder = nodeStats.getIndices()
+                    .toXContent(
+                        builder,
+                        new ToXContent.MapParams(Collections.singletonMap("level", NodeIndicesStats.StatsLevel.SHARDS.getRestName()))
+                    );
+                builder.endObject();
+
+                xContentMap = xContentBuilderToMap(builder);
+                indicesStatsMap = (LinkedHashMap) xContentMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+                assertFalse(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.INDICES.getRestName()));
+                assertTrue(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.SHARDS.getRestName()));
+
+                LinkedHashMap shardLevelStats = (LinkedHashMap) indicesStatsMap.get(NodeIndicesStats.StatsLevel.SHARDS.getRestName());
+                assertTrue(shardLevelStats.containsKey(indexName));
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    /**
+     * Aggregated behavior - to avoid unnecessary IO in the form of shard-stats when not required, we not honor the levels on the
+     * individual data nodes instead and pre-compute information as required.
+     */
+    public void testNodeIndicesStatsXContentWithAggregationOnNodes() {
+        List<MockStatsLevel> testLevels = new ArrayList<>();
+
+        testLevels.add(MockStatsLevel.NULL);
+        testLevels.add(MockStatsLevel.NODE);
+        testLevels.add(MockStatsLevel.INDICES);
+        testLevels.add(MockStatsLevel.SHARDS);
+
+        internalCluster().startNode();
+        ensureGreen();
+        String indexName = "test1";
+        assertAcked(
+            prepareCreate(
+                indexName,
+                clusterService().state().getNodes().getSize(),
+                Settings.builder().put("number_of_shards", 2).put("number_of_replicas", clusterService().state().getNodes().getSize() - 1)
+            )
+        );
+        ensureGreen();
+
+        testLevels.forEach(testLevel -> {
+            NodesStatsResponse response;
+            CommonStatsFlags commonStatsFlags = new CommonStatsFlags();
+            commonStatsFlags.setIncludeIndicesStatsByLevel(true);
+            if (!testLevel.equals(MockStatsLevel.NULL)) {
+                ArrayList<String> level_arg = new ArrayList<>();
+                level_arg.add(testLevel.getRestName());
+
+                commonStatsFlags.setLevels(level_arg.toArray(new String[0]));
+            }
+            response = client().admin().cluster().prepareNodesStats().setIndices(commonStatsFlags).get();
+
+            NodeStats nodeStats = response.getNodes().get(0);
+            try {
+                XContentBuilder builder = XContentFactory.jsonBuilder();
+
+                builder.startObject();
+
+                if (!testLevel.equals(MockStatsLevel.SHARDS)) {
+                    final XContentBuilder failedBuilder = builder;
+                    assertThrows(
+                        "Expected shard stats in response for generating [SHARDS] field",
+                        AssertionError.class,
+                        () -> nodeStats.getIndices()
+                            .toXContent(
+                                failedBuilder,
+                                new ToXContent.MapParams(
+                                    Collections.singletonMap("level", NodeIndicesStats.StatsLevel.SHARDS.getRestName())
+                                )
+                            )
+                    );
+                } else {
+                    builder = nodeStats.getIndices()
+                        .toXContent(
+                            builder,
+                            new ToXContent.MapParams(Collections.singletonMap("level", NodeIndicesStats.StatsLevel.SHARDS.getRestName()))
+                        );
+                    builder.endObject();
+
+                    Map<String, Object> xContentMap = xContentBuilderToMap(builder);
+                    LinkedHashMap indicesStatsMap = (LinkedHashMap) xContentMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+                    LinkedHashMap indicesStats = (LinkedHashMap) indicesStatsMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+                    LinkedHashMap shardStats = (LinkedHashMap) indicesStatsMap.get(NodeIndicesStats.StatsLevel.SHARDS.getRestName());
+
+                    assertFalse(shardStats.isEmpty());
+                    assertNull(indicesStats);
+                }
+
+                builder = XContentFactory.jsonBuilder();
+                builder.startObject();
+
+                if (!(testLevel.equals(MockStatsLevel.SHARDS) || testLevel.equals(MockStatsLevel.INDICES))) {
+                    final XContentBuilder failedBuilder = builder;
+                    assertThrows(
+                        "Expected shard stats or index stats in response for generating INDICES field",
+                        AssertionError.class,
+                        () -> nodeStats.getIndices()
+                            .toXContent(
+                                failedBuilder,
+                                new ToXContent.MapParams(
+                                    Collections.singletonMap("level", NodeIndicesStats.StatsLevel.INDICES.getRestName())
+                                )
+                            )
+                    );
+                } else {
+                    builder = nodeStats.getIndices()
+                        .toXContent(
+                            builder,
+                            new ToXContent.MapParams(Collections.singletonMap("level", NodeIndicesStats.StatsLevel.INDICES.getRestName()))
+                        );
+                    builder.endObject();
+
+                    Map<String, Object> xContentMap = xContentBuilderToMap(builder);
+                    LinkedHashMap indicesStatsMap = (LinkedHashMap) xContentMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+                    LinkedHashMap indicesStats = (LinkedHashMap) indicesStatsMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+                    LinkedHashMap shardStats = (LinkedHashMap) indicesStatsMap.get(NodeIndicesStats.StatsLevel.SHARDS.getRestName());
+
+                    switch (testLevel) {
+                        case SHARDS:
+                        case INDICES:
+                            assertNull(shardStats);
+                            assertFalse(indicesStats.isEmpty());
+                            break;
+                    }
+                }
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    public void testNodeIndicesStatsUnknownLevelThrowsException() {
+        MockStatsLevel testLevel = MockStatsLevel.UNKNOWN;
+        internalCluster().startNode();
+        ensureGreen();
+        String indexName = "test1";
+        assertAcked(
+            prepareCreate(
+                indexName,
+                clusterService().state().getNodes().getSize(),
+                Settings.builder().put("number_of_shards", 2).put("number_of_replicas", clusterService().state().getNodes().getSize() - 1)
+            )
+        );
+        ensureGreen();
+
+        NodesStatsResponse response;
+        CommonStatsFlags commonStatsFlags = new CommonStatsFlags();
+        commonStatsFlags.setIncludeIndicesStatsByLevel(true);
+        ArrayList<String> level_arg = new ArrayList<>();
+        level_arg.add(testLevel.getRestName());
+
+        commonStatsFlags.setLevels(level_arg.toArray(new String[0]));
+        response = client().admin().cluster().prepareNodesStats().setIndices(commonStatsFlags).get();
+
+        assertTrue(response.hasFailures());
+        assertEquals("Level provided is not supported by NodeIndicesStats", response.failures().get(0).getCause().getCause().getMessage());
+    }
+
+    private Map<String, Object> xContentBuilderToMap(XContentBuilder xContentBuilder) {
+        return XContentHelper.convertToMap(BytesReference.bytes(xContentBuilder), true, xContentBuilder.contentType()).v2();
+    }
+
     private void assertDocStatusStats() {
         DocStatusStats docStatusStats = client().admin()
             .cluster()
@@ -273,4 +564,22 @@ private void updateExpectedDocStatusCounter(Exception e) {
         expectedDocStatusStats.inc(ExceptionsHelper.status(e));
     }
 
+    private enum MockStatsLevel {
+        INDICES(NodeIndicesStats.StatsLevel.INDICES.getRestName()),
+        SHARDS(NodeIndicesStats.StatsLevel.SHARDS.getRestName()),
+        NODE(NodeIndicesStats.StatsLevel.NODE.getRestName()),
+        NULL("null"),
+        UNKNOWN("unknown");
+
+        private final String restName;
+
+        MockStatsLevel(String restName) {
+            this.restName = restName;
+        }
+
+        public String getRestName() {
+            return restName;
+        }
+    }
+
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionForClusterManagerIT.java b/server/src/internalClusterTest/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionForClusterManagerIT.java
index 4d1964326820e..e3a4216e772fb 100644
--- a/server/src/internalClusterTest/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionForClusterManagerIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionForClusterManagerIT.java
@@ -12,7 +12,11 @@
 import org.apache.logging.log4j.Logger;
 import org.opensearch.action.admin.indices.alias.get.GetAliasesRequest;
 import org.opensearch.action.admin.indices.alias.get.GetAliasesResponse;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionAction;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionResponse;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.cluster.coordination.ClusterStateTermVersion;
+import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
@@ -20,6 +24,7 @@
 import org.opensearch.node.IoUsageStats;
 import org.opensearch.node.ResourceUsageCollectorService;
 import org.opensearch.node.resource.tracker.ResourceTrackerSettings;
+import org.opensearch.plugins.Plugin;
 import org.opensearch.ratelimitting.admissioncontrol.controllers.CpuBasedAdmissionController;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlActionType;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
@@ -29,9 +34,13 @@
 import org.opensearch.rest.action.admin.indices.RestGetAliasesAction;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.rest.FakeRestRequest;
+import org.opensearch.test.transport.MockTransportService;
+import org.opensearch.transport.TransportService;
 import org.junit.Before;
 
+import java.util.Collection;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
@@ -62,6 +71,10 @@ public class AdmissionForClusterManagerIT extends OpenSearchIntegTestCase {
         .put(CLUSTER_ADMIN_CPU_USAGE_LIMIT.getKey(), 50)
         .build();
 
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return List.of(MockTransportService.TestPlugin.class);
+    }
+
     @Before
     public void init() {
         String clusterManagerNode = internalCluster().startClusterManagerOnlyNode(
@@ -79,6 +92,25 @@ public void init() {
 
         // Enable admission control
         client().admin().cluster().prepareUpdateSettings().setTransientSettings(ENFORCE_ADMISSION_CONTROL).execute().actionGet();
+        MockTransportService primaryService = (MockTransportService) internalCluster().getInstance(
+            TransportService.class,
+            clusterManagerNode
+        );
+
+        // Force always fetch from ClusterManager
+        ClusterService clusterService = internalCluster().clusterService();
+        GetTermVersionResponse oosTerm = new GetTermVersionResponse(
+            new ClusterStateTermVersion(
+                clusterService.state().getClusterName(),
+                clusterService.state().metadata().clusterUUID(),
+                clusterService.state().term() - 1,
+                clusterService.state().version() - 1
+            )
+        );
+        primaryService.addRequestHandlingBehavior(
+            GetTermVersionAction.NAME,
+            (handler, request, channel, task) -> channel.sendResponse(oosTerm)
+        );
     }
 
     public void testAdmissionControlEnforced() throws Exception {
@@ -86,8 +118,8 @@ public void testAdmissionControlEnforced() throws Exception {
 
         // Write API on ClusterManager
         assertAcked(prepareCreate("test").setMapping("field", "type=text").setAliases("{\"alias1\" : {}}"));
-
         // Read API on ClusterManager
+
         GetAliasesRequest aliasesRequest = new GetAliasesRequest();
         aliasesRequest.aliases("alias1");
         try {
@@ -170,8 +202,8 @@ public void testAdmissionControlResponseStatus() throws Exception {
 
             @Override
             public void sendResponse(RestResponse response) {
-                waitForResponse.countDown();
                 aliasResponse.set(response);
+                waitForResponse.countDown();
             }
         };
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/recovery/FullRollingRestartIT.java b/server/src/internalClusterTest/java/org/opensearch/recovery/FullRollingRestartIT.java
index 0752ab7c9d0f1..d9e3cec426edf 100644
--- a/server/src/internalClusterTest/java/org/opensearch/recovery/FullRollingRestartIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/recovery/FullRollingRestartIT.java
@@ -36,6 +36,7 @@
 
 import org.opensearch.action.admin.cluster.health.ClusterHealthRequestBuilder;
 import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
+import org.opensearch.action.admin.indices.create.CreateIndexResponse;
 import org.opensearch.action.admin.indices.recovery.RecoveryResponse;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
@@ -45,6 +46,8 @@
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.indices.recovery.RecoveryState;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
 import org.opensearch.test.OpenSearchIntegTestCase.Scope;
@@ -253,4 +256,144 @@ public void testNoRebalanceOnRollingRestart() throws Exception {
             );
         }
     }
+
+    public void testFullRollingRestart_withNoRecoveryPayloadAndSource() throws Exception {
+        internalCluster().startNode();
+        XContentBuilder builder = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("_source")
+            .field("enabled")
+            .value(false)
+            .field("recovery_source_enabled")
+            .value(false)
+            .endObject()
+            .endObject();
+        CreateIndexResponse response = prepareCreate("test").setMapping(builder).get();
+        logger.info("Create index response is : {}", response);
+
+        final String healthTimeout = "1m";
+
+        for (int i = 0; i < 1000; i++) {
+            client().prepareIndex("test")
+                .setId(Long.toString(i))
+                .setSource(MapBuilder.<String, Object>newMapBuilder().put("test", "value" + i).map())
+                .execute()
+                .actionGet();
+        }
+
+        for (int i = 1000; i < 2000; i++) {
+            client().prepareIndex("test")
+                .setId(Long.toString(i))
+                .setSource(MapBuilder.<String, Object>newMapBuilder().put("test", "value" + i).map())
+                .execute()
+                .actionGet();
+        }
+        // ensuring all docs are committed to file system
+        flush();
+
+        logger.info("--> now start adding nodes");
+        internalCluster().startNode();
+        internalCluster().startNode();
+
+        // make sure the cluster state is green, and all has been recovered
+        assertTimeout(
+            client().admin()
+                .cluster()
+                .prepareHealth()
+                .setWaitForEvents(Priority.LANGUID)
+                .setTimeout(healthTimeout)
+                .setWaitForGreenStatus()
+                .setWaitForNoRelocatingShards(true)
+                .setWaitForNodes("3")
+        );
+
+        logger.info("--> add two more nodes");
+        internalCluster().startNode();
+        internalCluster().startNode();
+
+        // make sure the cluster state is green, and all has been recovered
+        assertTimeout(
+            client().admin()
+                .cluster()
+                .prepareHealth()
+                .setWaitForEvents(Priority.LANGUID)
+                .setTimeout(healthTimeout)
+                .setWaitForGreenStatus()
+                .setWaitForNoRelocatingShards(true)
+                .setWaitForNodes("5")
+        );
+
+        logger.info("--> refreshing and checking data");
+        refreshAndWaitForReplication();
+        for (int i = 0; i < 10; i++) {
+            assertHitCount(client().prepareSearch().setSize(0).setQuery(matchAllQuery()).get(), 2000L);
+        }
+
+        // now start shutting nodes down
+        internalCluster().stopRandomDataNode();
+        // make sure the cluster state is green, and all has been recovered
+        assertTimeout(
+            client().admin()
+                .cluster()
+                .prepareHealth()
+                .setWaitForEvents(Priority.LANGUID)
+                .setTimeout(healthTimeout)
+                .setWaitForGreenStatus()
+                .setWaitForNoRelocatingShards(true)
+                .setWaitForNodes("4")
+        );
+
+        internalCluster().stopRandomDataNode();
+        // make sure the cluster state is green, and all has been recovered
+        assertTimeout(
+            client().admin()
+                .cluster()
+                .prepareHealth()
+                .setWaitForEvents(Priority.LANGUID)
+                .setTimeout(healthTimeout)
+                .setWaitForGreenStatus()
+                .setWaitForNoRelocatingShards(true)
+                .setWaitForNodes("3")
+        );
+
+        logger.info("--> stopped two nodes, verifying data");
+        refreshAndWaitForReplication();
+        for (int i = 0; i < 10; i++) {
+            assertHitCount(client().prepareSearch().setSize(0).setQuery(matchAllQuery()).get(), 2000L);
+        }
+
+        // closing the 3rd node
+        internalCluster().stopRandomDataNode();
+        // make sure the cluster state is green, and all has been recovered
+        assertTimeout(
+            client().admin()
+                .cluster()
+                .prepareHealth()
+                .setWaitForEvents(Priority.LANGUID)
+                .setTimeout(healthTimeout)
+                .setWaitForGreenStatus()
+                .setWaitForNoRelocatingShards(true)
+                .setWaitForNodes("2")
+        );
+
+        internalCluster().stopRandomDataNode();
+
+        // make sure the cluster state is yellow, and all has been recovered
+        assertTimeout(
+            client().admin()
+                .cluster()
+                .prepareHealth()
+                .setWaitForEvents(Priority.LANGUID)
+                .setTimeout(healthTimeout)
+                .setWaitForYellowStatus()
+                .setWaitForNoRelocatingShards(true)
+                .setWaitForNodes("1")
+        );
+
+        logger.info("--> one node left, verifying data");
+        refreshAndWaitForReplication();
+        for (int i = 0; i < 10; i++) {
+            assertHitCount(client().prepareSearch().setSize(0).setQuery(matchAllQuery()).get(), 2000L);
+        }
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/recovery/TruncatedRecoveryIT.java b/server/src/internalClusterTest/java/org/opensearch/recovery/TruncatedRecoveryIT.java
index bf0533143cf91..692beb86279b9 100644
--- a/server/src/internalClusterTest/java/org/opensearch/recovery/TruncatedRecoveryIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/recovery/TruncatedRecoveryIT.java
@@ -46,7 +46,6 @@
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.indices.recovery.FileChunkRequest;
 import org.opensearch.indices.recovery.PeerRecoveryTargetService;
-import org.opensearch.node.RecoverySettingsChunkSizePlugin;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.ParameterizedStaticSettingsOpenSearchIntegTestCase;
@@ -61,7 +60,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import static org.opensearch.node.RecoverySettingsChunkSizePlugin.CHUNK_SIZE_SETTING;
+import static org.opensearch.indices.recovery.RecoverySettings.INDICES_RECOVERY_CHUNK_SIZE_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
@@ -81,7 +80,7 @@ public static Collection<Object[]> parameters() {
 
     @Override
     protected Collection<Class<? extends Plugin>> nodePlugins() {
-        return Arrays.asList(MockTransportService.TestPlugin.class, RecoverySettingsChunkSizePlugin.class);
+        return Arrays.asList(MockTransportService.TestPlugin.class);
     }
 
     /**
@@ -96,7 +95,8 @@ public void testCancelRecoveryAndResume() throws Exception {
                 .cluster()
                 .prepareUpdateSettings()
                 .setTransientSettings(
-                    Settings.builder().put(CHUNK_SIZE_SETTING.getKey(), new ByteSizeValue(randomIntBetween(50, 300), ByteSizeUnit.BYTES))
+                    Settings.builder()
+                        .put(INDICES_RECOVERY_CHUNK_SIZE_SETTING.getKey(), new ByteSizeValue(randomIntBetween(50, 300), ByteSizeUnit.BYTES))
                 )
                 .get()
                 .isAcknowledged()
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
index 611dfc2756b29..17a9c3ddbe317 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/MigrationBaseTestCase.java
@@ -9,19 +9,31 @@
 package org.opensearch.remotemigration;
 
 import org.opensearch.action.DocWriteResponse;
+import org.opensearch.action.admin.cluster.health.ClusterHealthRequest;
+import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
+import org.opensearch.action.admin.indices.get.GetIndexRequest;
+import org.opensearch.action.admin.indices.get.GetIndexResponse;
 import org.opensearch.action.bulk.BulkRequest;
 import org.opensearch.action.bulk.BulkResponse;
 import org.opensearch.action.delete.DeleteResponse;
 import org.opensearch.action.index.IndexRequest;
 import org.opensearch.action.index.IndexResponse;
+import org.opensearch.client.Requests;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.health.ClusterHealthStatus;
+import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.routing.RoutingNode;
+import org.opensearch.common.Priority;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.IndexService;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.indices.IndicesService;
 import org.opensearch.repositories.fs.ReloadableFsRepository;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.junit.Before;
@@ -34,11 +46,14 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
 import static org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider.CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING;
+import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
 import static org.opensearch.repositories.fs.ReloadableFsRepository.REPOSITORIES_FAILRATE_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+import static org.hamcrest.Matchers.equalTo;
 
 public class MigrationBaseTestCase extends OpenSearchIntegTestCase {
     protected static final String REPOSITORY_NAME = "test-remote-store-repo";
@@ -78,18 +93,14 @@ protected Settings nodeSettings(int nodeOrdinal) {
                 .put(super.nodeSettings(nodeOrdinal))
                 .put(extraSettings)
                 .put(remoteStoreClusterSettings(REPOSITORY_NAME, segmentRepoPath, REPOSITORY_2_NAME, translogRepoPath))
+                .put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
                 .build();
         } else {
             logger.info("Adding docrep node");
-            return Settings.builder().put(super.nodeSettings(nodeOrdinal)).build();
+            return Settings.builder().put(super.nodeSettings(nodeOrdinal)).put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true).build();
         }
     }
 
-    @Override
-    protected Settings featureFlagSettings() {
-        return Settings.builder().put(super.featureFlagSettings()).put(FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-    }
-
     protected void setFailRate(String repoName, int value) throws ExecutionException, InterruptedException {
         GetRepositoriesRequest gr = new GetRepositoriesRequest(new String[] { repoName });
         GetRepositoriesResponse res = client().admin().cluster().getRepositories(gr).get();
@@ -97,9 +108,7 @@ protected void setFailRate(String repoName, int value) throws ExecutionException
         Settings.Builder settings = Settings.builder()
             .put("location", rmd.settings().get("location"))
             .put(REPOSITORIES_FAILRATE_SETTING.getKey(), value);
-        assertAcked(
-            client().admin().cluster().preparePutRepository(repoName).setType(ReloadableFsRepository.TYPE).setSettings(settings).get()
-        );
+        createRepository(repoName, ReloadableFsRepository.TYPE, settings);
     }
 
     public void initDocRepToRemoteMigration() {
@@ -118,6 +127,10 @@ public void initDocRepToRemoteMigration() {
         );
     }
 
+    public ClusterHealthStatus ensureGreen(String... indices) {
+        return ensureGreen(TimeValue.timeValueSeconds(60), indices);
+    }
+
     public BulkResponse indexBulk(String indexName, int numDocs) {
         BulkRequest bulkRequest = new BulkRequest();
         for (int i = 0; i < numDocs; i++) {
@@ -184,14 +197,13 @@ private Thread getIndexingThread() {
                     indexSingleDoc(indexName);
                     long currentDocCount = indexedDocs.incrementAndGet();
                     if (currentDocCount > 0 && currentDocCount % refreshFrequency == 0) {
-                        logger.info("--> [iteration {}] flushing index", currentDocCount);
                         if (rarely()) {
                             client().admin().indices().prepareFlush(indexName).get();
+                            logger.info("Completed ingestion of {} docs. Flushing now", currentDocCount);
                         } else {
                             client().admin().indices().prepareRefresh(indexName).get();
                         }
                     }
-                    logger.info("Completed ingestion of {} docs", currentDocCount);
                 }
             });
         }
@@ -221,4 +233,73 @@ public void stopShardRebalancing() {
                 .get()
         );
     }
+
+    public ClusterHealthStatus waitForRelocation() {
+        ClusterHealthRequest request = Requests.clusterHealthRequest()
+            .waitForNoRelocatingShards(true)
+            .timeout(TimeValue.timeValueSeconds(60))
+            .waitForEvents(Priority.LANGUID);
+        ClusterHealthResponse actionGet = client().admin().cluster().health(request).actionGet();
+        if (actionGet.isTimedOut()) {
+            logger.info(
+                "waitForRelocation timed out, cluster state:\n{}\n{}",
+                client().admin().cluster().prepareState().get().getState(),
+                client().admin().cluster().preparePendingClusterTasks().get()
+            );
+            assertThat("timed out waiting for relocation", actionGet.isTimedOut(), equalTo(false));
+        }
+        return actionGet.getStatus();
+    }
+
+    public ClusterHealthStatus waitForRelocation(TimeValue t) {
+        ClusterHealthRequest request = Requests.clusterHealthRequest()
+            .waitForNoRelocatingShards(true)
+            .timeout(t)
+            .waitForEvents(Priority.LANGUID);
+        ClusterHealthResponse actionGet = client().admin().cluster().health(request).actionGet();
+        if (actionGet.isTimedOut()) {
+            logger.info(
+                "waitForRelocation timed out, cluster state:\n{}\n{}",
+                client().admin().cluster().prepareState().get().getState(),
+                client().admin().cluster().preparePendingClusterTasks().get()
+            );
+            assertThat("timed out waiting for relocation", actionGet.isTimedOut(), equalTo(false));
+        }
+        return actionGet.getStatus();
+    }
+
+    protected IndexShard getIndexShard(String dataNode, String indexName) throws ExecutionException, InterruptedException {
+        String clusterManagerName = internalCluster().getClusterManagerName();
+        IndicesService indicesService = internalCluster().getInstance(IndicesService.class, dataNode);
+        GetIndexResponse getIndexResponse = client(clusterManagerName).admin().indices().getIndex(new GetIndexRequest()).get();
+        String uuid = getIndexResponse.getSettings().get(indexName).get(IndexMetadata.SETTING_INDEX_UUID);
+        IndexService indexService = indicesService.indexService(new Index(indexName, uuid));
+        return indexService.getShard(0);
+    }
+
+    public void changeReplicaCountAndEnsureGreen(int replicaCount, String indexName) {
+        assertAcked(
+            client().admin()
+                .indices()
+                .prepareUpdateSettings(indexName)
+                .setSettings(Settings.builder().put(SETTING_NUMBER_OF_REPLICAS, replicaCount))
+        );
+        ensureGreen(indexName);
+    }
+
+    public void completeDocRepToRemoteMigration() {
+        assertTrue(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(
+                    Settings.builder()
+                        .putNull(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey())
+                        .putNull(MIGRATION_DIRECTION_SETTING.getKey())
+                )
+                .get()
+                .isAcknowledged()
+        );
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteDualReplicationIT.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteDualReplicationIT.java
index 5094a7cf29c6a..d046f41ce0590 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteDualReplicationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteDualReplicationIT.java
@@ -18,6 +18,7 @@
 import org.opensearch.cluster.routing.allocation.command.MoveAllocationCommand;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.index.IndexService;
+import org.opensearch.index.ReplicationStats;
 import org.opensearch.index.remote.RemoteSegmentStats;
 import org.opensearch.index.seqno.RetentionLease;
 import org.opensearch.index.seqno.RetentionLeases;
@@ -665,6 +666,43 @@ public void testFailoverRemotePrimaryToDocrepReplicaReseedToRemotePrimary() thro
         });
     }
 
+    /*
+    Performs the same experiment as testRemotePrimaryDocRepReplica.
+
+    This ensures that the primary shard for the index has moved over to remote
+    enabled node whereas the replica copy is still left behind on the docrep nodes
+
+    At this stage, segrep lag computation shouldn't consider the docrep shard copy while calculating bytes lag
+     */
+    public void testZeroSegrepLagForShardsWithMixedReplicationGroup() throws Exception {
+        testRemotePrimaryDocRepReplica();
+        String remoteNodeName = internalCluster().client()
+            .admin()
+            .cluster()
+            .prepareNodesStats()
+            .get()
+            .getNodes()
+            .stream()
+            .filter(nodeStats -> nodeStats.getNode().isRemoteStoreNode())
+            .findFirst()
+            .get()
+            .getNode()
+            .getName();
+        ReplicationStats replicationStats = internalCluster().client()
+            .admin()
+            .cluster()
+            .prepareNodesStats(remoteNodeName)
+            .get()
+            .getNodes()
+            .get(0)
+            .getIndices()
+            .getSegments()
+            .getReplicationStats();
+        assertEquals(0, replicationStats.getMaxBytesBehind());
+        assertEquals(0, replicationStats.getTotalBytesBehind());
+        assertEquals(0, replicationStats.getMaxReplicationLag());
+    }
+
     private void assertReplicaAndPrimaryConsistency(String indexName, int firstBatch, int secondBatch) throws Exception {
         assertBusy(() -> {
             Map<ShardRouting, ShardStats> shardStatsMap = internalCluster().client()
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteMigrationIndexMetadataUpdateIT.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteMigrationIndexMetadataUpdateIT.java
index 53f4ef3fe281f..b55219e1cb37f 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteMigrationIndexMetadataUpdateIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteMigrationIndexMetadataUpdateIT.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.remotemigration;
 
+import org.opensearch.action.admin.cluster.configuration.AddVotingConfigExclusionsAction;
+import org.opensearch.action.admin.cluster.configuration.AddVotingConfigExclusionsRequest;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.health.ClusterHealthStatus;
 import org.opensearch.cluster.metadata.IndexMetadata;
@@ -15,14 +17,21 @@
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.allocation.command.MoveAllocationCommand;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.util.FileSystemUtils;
+import org.opensearch.index.remote.RemoteIndexPath;
+import org.opensearch.index.remote.RemoteIndexPathUploader;
+import org.opensearch.index.remote.RemoteStoreEnums;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.test.InternalTestCluster;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
+import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
@@ -454,6 +463,156 @@ public void testRemotePathMetadataAddedWithFirstPrimaryMovingToRemote() throws E
         assertRemoteProperties(indexName);
     }
 
+    /**
+     * Scenario:
+     * creates an index on docrep node with non-remote cluster-manager.
+     * make the cluster mixed, add remote cluster-manager and data nodes.
+     * <p>
+     * exclude docrep nodes, assert that remote index path file exists
+     * when shards start relocating to the remote nodes.
+     */
+    public void testRemoteIndexPathFileExistsAfterMigration() throws Exception {
+        String docrepClusterManager = internalCluster().startClusterManagerOnlyNode();
+
+        logger.info("---> Starting 2 docrep nodes");
+        addRemote = false;
+        internalCluster().startDataOnlyNodes(2, Settings.builder().put("node.attr._type", "docrep").build());
+        internalCluster().validateClusterFormed();
+
+        logger.info("---> Creating index with 1 primary and 1 replica");
+        String indexName = "migration-index";
+        Settings oneReplica = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .build();
+        createIndexAndAssertDocrepProperties(indexName, oneReplica);
+
+        String indexUUID = internalCluster().client()
+            .admin()
+            .indices()
+            .prepareGetSettings(indexName)
+            .get()
+            .getSetting(indexName, IndexMetadata.SETTING_INDEX_UUID);
+
+        logger.info("---> Starting indexing in parallel");
+        AsyncIndexingService indexingService = new AsyncIndexingService(indexName);
+        indexingService.startIndexing();
+
+        logger.info("---> Adding 2 remote enabled nodes to the cluster & cluster manager");
+        initDocRepToRemoteMigration();
+        addRemote = true;
+        internalCluster().startClusterManagerOnlyNode();
+        internalCluster().startDataOnlyNodes(2, Settings.builder().put("node.attr._type", "remote").build());
+        internalCluster().validateClusterFormed();
+
+        assertTrue(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(
+                    Settings.builder().put(CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING.getKey(), RemoteStoreEnums.PathType.HASHED_PREFIX)
+                )
+                .get()
+                .isAcknowledged()
+        );
+
+        // elect cluster manager with remote-cluster state enabled
+        internalCluster().client()
+            .execute(AddVotingConfigExclusionsAction.INSTANCE, new AddVotingConfigExclusionsRequest(docrepClusterManager))
+            .get();
+
+        internalCluster().validateClusterFormed();
+
+        logger.info("---> Excluding docrep nodes from allocation");
+        excludeNodeSet("type", "docrep");
+
+        waitForRelocation();
+        waitNoPendingTasksOnAll();
+        indexingService.stopIndexing();
+
+        // validate remote index path file exists
+        logger.info("---> Asserting remote index path file exists");
+        String fileNamePrefix = String.join(RemoteIndexPathUploader.DELIMITER, indexUUID, "7", RemoteIndexPath.DEFAULT_VERSION);
+
+        assertTrue(FileSystemUtils.exists(translogRepoPath.resolve(RemoteIndexPath.DIR)));
+        Path[] files = FileSystemUtils.files(translogRepoPath.resolve(RemoteIndexPath.DIR));
+        assertEquals(1, files.length);
+        assertTrue(Arrays.stream(files).anyMatch(file -> file.toString().contains(fileNamePrefix)));
+
+        assertTrue(FileSystemUtils.exists(segmentRepoPath.resolve(RemoteIndexPath.DIR)));
+        files = FileSystemUtils.files(segmentRepoPath.resolve(RemoteIndexPath.DIR));
+        assertEquals(1, files.length);
+        assertTrue(Arrays.stream(files).anyMatch(file -> file.toString().contains(fileNamePrefix)));
+    }
+
+    /**
+     * Scenario:
+     * Creates an index with 1 pri 1 rep setup with 3 docrep nodes (1 cluster manager + 2 data nodes),
+     * initiate migration and create 3 remote nodes (1 cluster manager + 2 data nodes) and moves over
+     * only primary shard copy of the index
+     * After the primary shard copy is relocated, decrease replica count to 0, stop all docrep nodes
+     * and conclude migration. Remote store index settings should be applied to the index at this point.
+     */
+    public void testIndexSettingsUpdateDuringReplicaCountDecrement() throws Exception {
+        String indexName = "migration-index-replica-decrement";
+        String docrepClusterManager = internalCluster().startClusterManagerOnlyNode();
+
+        logger.info("---> Starting 2 docrep nodes");
+        List<String> docrepNodeNames = internalCluster().startDataOnlyNodes(2);
+        internalCluster().validateClusterFormed();
+
+        logger.info("---> Creating index with 1 primary and 1 replica");
+        Settings oneReplica = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .build();
+        createIndexAndAssertDocrepProperties(indexName, oneReplica);
+
+        int docsToIndex = randomIntBetween(10, 100);
+        logger.info("---> Indexing {} on both indices", docsToIndex);
+        indexBulk(indexName, docsToIndex);
+
+        logger.info(
+            "---> Stopping shard rebalancing to ensure shards do not automatically move over to newer nodes after they are launched"
+        );
+        stopShardRebalancing();
+
+        logger.info("---> Starting 3 remote store enabled nodes");
+        initDocRepToRemoteMigration();
+        setAddRemote(true);
+        internalCluster().startClusterManagerOnlyNode();
+        List<String> remoteNodeNames = internalCluster().startDataOnlyNodes(2);
+        internalCluster().validateClusterFormed();
+
+        String primaryNode = primaryNodeName(indexName);
+
+        logger.info("---> Moving over primary to remote store enabled nodes");
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareReroute()
+                .add(new MoveAllocationCommand(indexName, 0, primaryNode, remoteNodeNames.get(0)))
+                .execute()
+                .actionGet()
+        );
+        waitForRelocation();
+        waitNoPendingTasksOnAll();
+
+        logger.info("---> Reducing replica count to 0 for the index");
+        changeReplicaCountAndEnsureGreen(0, indexName);
+
+        logger.info("---> Stopping all docrep nodes");
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(docrepClusterManager));
+        for (String node : docrepNodeNames) {
+            internalCluster().stopRandomNode(InternalTestCluster.nameFilter(node));
+        }
+        internalCluster().validateClusterFormed();
+        completeDocRepToRemoteMigration();
+        waitNoPendingTasksOnAll();
+        assertRemoteProperties(indexName);
+    }
+
     private void createIndexAndAssertDocrepProperties(String index, Settings settings) {
         createIndexAssertHealthAndDocrepProperties(index, settings, this::ensureGreen);
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemotePrimaryLocalRecoveryIT.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemotePrimaryLocalRecoveryIT.java
index 024fc68602a19..8ab093b8495cb 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemotePrimaryLocalRecoveryIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemotePrimaryLocalRecoveryIT.java
@@ -19,6 +19,7 @@
 import org.opensearch.core.util.FileSystemUtils;
 import org.opensearch.index.remote.RemoteSegmentStats;
 import org.opensearch.index.translog.RemoteTranslogStats;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.test.InternalTestCluster;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
@@ -67,6 +68,7 @@ public void testLocalRecoveryRollingRestartAndNodeFailure() throws Exception {
                 assertTrue(remoteSegmentStats.getUploadBytesSucceeded() > 0);
             }
 
+            String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
             assertBusy(() -> {
                 String shardPath = getShardLevelBlobPath(
                     client(),
@@ -74,7 +76,8 @@ public void testLocalRecoveryRollingRestartAndNodeFailure() throws Exception {
                     new BlobPath(),
                     String.valueOf(shardRouting.getId()),
                     SEGMENTS,
-                    DATA
+                    DATA,
+                    segmentsPathFixedPrefix
                 ).buildAsString();
                 Path segmentDataRepoPath = segmentRepoPath.resolve(shardPath);
                 List<String> segmentsNFilesInRepo = Arrays.stream(FileSystemUtils.files(segmentDataRepoPath))
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemotePrimaryRelocationIT.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemotePrimaryRelocationIT.java
index 293691ace2edd..fa3b9368ded47 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemotePrimaryRelocationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemotePrimaryRelocationIT.java
@@ -8,14 +8,11 @@
 
 package org.opensearch.remotemigration;
 
-import org.opensearch.action.DocWriteResponse;
 import org.opensearch.action.admin.cluster.health.ClusterHealthRequest;
 import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
 import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
-import org.opensearch.action.delete.DeleteResponse;
-import org.opensearch.action.index.IndexResponse;
 import org.opensearch.client.Client;
 import org.opensearch.client.Requests;
 import org.opensearch.cluster.routing.allocation.command.MoveAllocationCommand;
@@ -66,8 +63,8 @@ public void testRemotePrimaryRelocation() throws Exception {
 
         AtomicInteger numAutoGenDocs = new AtomicInteger();
         final AtomicBoolean finished = new AtomicBoolean(false);
-        Thread indexingThread = getIndexingThread(finished, numAutoGenDocs);
-
+        AsyncIndexingService asyncIndexingService = new AsyncIndexingService("test");
+        asyncIndexingService.startIndexing();
         refresh("test");
 
         // add remote node in mixed mode cluster
@@ -102,16 +99,7 @@ public void testRemotePrimaryRelocation() throws Exception {
             .add(new MoveAllocationCommand("test", 0, primaryNodeName("test"), remoteNode))
             .execute()
             .actionGet();
-        ClusterHealthResponse clusterHealthResponse = client().admin()
-            .cluster()
-            .prepareHealth()
-            .setTimeout(TimeValue.timeValueSeconds(60))
-            .setWaitForEvents(Priority.LANGUID)
-            .setWaitForNoRelocatingShards(true)
-            .execute()
-            .actionGet();
-
-        assertEquals(0, clusterHealthResponse.getRelocatingShards());
+        waitForRelocation();
         assertEquals(remoteNode, primaryNodeName("test"));
         logger.info("-->  relocation from docrep to remote  complete");
 
@@ -126,37 +114,29 @@ public void testRemotePrimaryRelocation() throws Exception {
             .add(new MoveAllocationCommand("test", 0, remoteNode, remoteNode2))
             .execute()
             .actionGet();
-        clusterHealthResponse = client().admin()
-            .cluster()
-            .prepareHealth()
-            .setTimeout(TimeValue.timeValueSeconds(60))
-            .setWaitForEvents(Priority.LANGUID)
-            .setWaitForNoRelocatingShards(true)
-            .execute()
-            .actionGet();
-
-        assertEquals(0, clusterHealthResponse.getRelocatingShards());
+        waitForRelocation();
         assertEquals(remoteNode2, primaryNodeName("test"));
 
         logger.info("-->  relocation from remote to remote  complete");
 
         finished.set(true);
-        indexingThread.join();
+        asyncIndexingService.stopIndexing();
         refresh("test");
-        OpenSearchAssertions.assertHitCount(client().prepareSearch("test").setTrackTotalHits(true).get(), numAutoGenDocs.get());
+        OpenSearchAssertions.assertHitCount(
+            client().prepareSearch("test").setTrackTotalHits(true).get(),
+            asyncIndexingService.getIndexedDocs()
+        );
         OpenSearchAssertions.assertHitCount(
             client().prepareSearch("test")
                 .setTrackTotalHits(true)// extra paranoia ;)
                 .setQuery(QueryBuilders.termQuery("auto", true))
                 .get(),
-            numAutoGenDocs.get()
+            asyncIndexingService.getIndexedDocs()
         );
-
     }
 
     public void testMixedModeRelocation_RemoteSeedingFail() throws Exception {
         String docRepNode = internalCluster().startNode();
-        Client client = internalCluster().client(docRepNode);
         ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
         updateSettingsRequest.persistentSettings(Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed"));
         assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
@@ -165,9 +145,8 @@ public void testMixedModeRelocation_RemoteSeedingFail() throws Exception {
         client().admin().indices().prepareCreate("test").setSettings(indexSettings()).setMapping("field", "type=text").get();
         ensureGreen("test");
 
-        AtomicInteger numAutoGenDocs = new AtomicInteger();
-        final AtomicBoolean finished = new AtomicBoolean(false);
-        Thread indexingThread = getIndexingThread(finished, numAutoGenDocs);
+        AsyncIndexingService asyncIndexingService = new AsyncIndexingService("test");
+        asyncIndexingService.startIndexing();
 
         refresh("test");
 
@@ -209,27 +188,11 @@ public void testMixedModeRelocation_RemoteSeedingFail() throws Exception {
         assertEquals(actionGet.getRelocatingShards(), 0);
         assertEquals(docRepNode, primaryNodeName("test"));
 
-        finished.set(true);
-        indexingThread.join();
+        asyncIndexingService.stopIndexing();
         client().admin()
             .cluster()
             .prepareUpdateSettings()
             .setTransientSettings(Settings.builder().put(RecoverySettings.INDICES_INTERNAL_REMOTE_UPLOAD_TIMEOUT.getKey(), (String) null))
             .get();
     }
-
-    private static Thread getIndexingThread(AtomicBoolean finished, AtomicInteger numAutoGenDocs) {
-        Thread indexingThread = new Thread(() -> {
-            while (finished.get() == false && numAutoGenDocs.get() < 10_000) {
-                IndexResponse indexResponse = client().prepareIndex("test").setId("id").setSource("field", "value").get();
-                assertEquals(DocWriteResponse.Result.CREATED, indexResponse.getResult());
-                DeleteResponse deleteResponse = client().prepareDelete("test", "id").get();
-                assertEquals(DocWriteResponse.Result.DELETED, deleteResponse.getResult());
-                client().prepareIndex("test").setSource("auto", true).get();
-                numAutoGenDocs.incrementAndGet();
-            }
-        });
-        indexingThread.start();
-        return indexingThread;
-    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteReplicaRecoveryIT.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteReplicaRecoveryIT.java
index 196ecb991bbc0..d6e25c0cab3ac 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteReplicaRecoveryIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteReplicaRecoveryIT.java
@@ -8,32 +8,24 @@
 
 package org.opensearch.remotemigration;
 
-import com.carrotsearch.randomizedtesting.generators.RandomNumbers;
-
-import org.opensearch.action.DocWriteResponse;
-import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.action.admin.indices.replication.SegmentReplicationStatsResponse;
 import org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequest;
-import org.opensearch.action.delete.DeleteResponse;
-import org.opensearch.action.index.IndexResponse;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.routing.allocation.command.MoveAllocationCommand;
-import org.opensearch.common.Priority;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.unit.TimeValue;
+import org.opensearch.index.SegmentReplicationPerGroupStats;
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.hamcrest.OpenSearchAssertions;
 
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.TimeUnit;
 
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0, autoManageMasterNodes = false)
-
 public class RemoteReplicaRecoveryIT extends MigrationBaseTestCase {
 
     protected int maximumNumberOfShards() {
@@ -52,6 +44,7 @@ protected int minimumNumberOfReplicas() {
     Brings up new replica copies on remote and docrep nodes, when primary is on a remote node
     Live indexing is happening meanwhile
     */
+    @AwaitsFix(bugUrl = "https://github.com/opensearch-project/OpenSearch/issues/13473")
     public void testReplicaRecovery() throws Exception {
         internalCluster().setBootstrapClusterManagerNodeIndex(0);
         String primaryNode = internalCluster().startNode();
@@ -63,10 +56,8 @@ public void testReplicaRecovery() throws Exception {
         client().admin().indices().prepareCreate("test").setSettings(indexSettings()).setMapping("field", "type=text").get();
         String replicaNode = internalCluster().startNode();
         ensureGreen("test");
-
-        AtomicInteger numAutoGenDocs = new AtomicInteger();
-        final AtomicBoolean finished = new AtomicBoolean(false);
-        Thread indexingThread = getThread(finished, numAutoGenDocs);
+        AsyncIndexingService asyncIndexingService = new AsyncIndexingService("test");
+        asyncIndexingService.startIndexing();
 
         refresh("test");
 
@@ -78,12 +69,10 @@ public void testReplicaRecovery() throws Exception {
         updateSettingsRequest.persistentSettings(Settings.builder().put(MIGRATION_DIRECTION_SETTING.getKey(), "remote_store"));
         assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
 
-        String remoteNode2 = internalCluster().startNode();
+        internalCluster().startNode();
         internalCluster().validateClusterFormed();
 
         // identify the primary
-
-        Thread.sleep(RandomNumbers.randomIntBetween(random(), 0, 2000));
         logger.info("-->  relocating primary from {} to {} ", primaryNode, remoteNode);
         client().admin()
             .cluster()
@@ -91,18 +80,9 @@ public void testReplicaRecovery() throws Exception {
             .add(new MoveAllocationCommand("test", 0, primaryNode, remoteNode))
             .execute()
             .actionGet();
-        ClusterHealthResponse clusterHealthResponse = client().admin()
-            .cluster()
-            .prepareHealth()
-            .setTimeout(TimeValue.timeValueSeconds(60))
-            .setWaitForEvents(Priority.LANGUID)
-            .setWaitForNoRelocatingShards(true)
-            .execute()
-            .actionGet();
 
-        assertEquals(0, clusterHealthResponse.getRelocatingShards());
+        waitForRelocation();
         logger.info("-->  relocation of primary from docrep to remote  complete");
-        Thread.sleep(RandomNumbers.randomIntBetween(random(), 0, 2000));
 
         logger.info("--> getting up the new replicas now to doc rep node as well as remote node ");
         // Increase replica count to 3
@@ -118,63 +98,34 @@ public void testReplicaRecovery() throws Exception {
             )
             .get();
 
-        client().admin()
-            .cluster()
-            .prepareHealth()
-            .setTimeout(TimeValue.timeValueSeconds(60))
-            .setWaitForEvents(Priority.LANGUID)
-            .setWaitForGreenStatus()
-            .execute()
-            .actionGet();
-        logger.info("-->  replica  is up now on another docrep now as well as remote node");
-
-        assertEquals(0, clusterHealthResponse.getRelocatingShards());
+        waitForRelocation();
+        asyncIndexingService.stopIndexing();
+        refresh("test");
 
-        Thread.sleep(RandomNumbers.randomIntBetween(random(), 0, 2000));
+        // segrep lag should be zero
+        assertBusy(() -> {
+            SegmentReplicationStatsResponse segmentReplicationStatsResponse = dataNodeClient().admin()
+                .indices()
+                .prepareSegmentReplicationStats("test")
+                .setDetailed(true)
+                .execute()
+                .actionGet();
+            SegmentReplicationPerGroupStats perGroupStats = segmentReplicationStatsResponse.getReplicationStats().get("test").get(0);
+            assertEquals(segmentReplicationStatsResponse.getReplicationStats().size(), 1);
+            perGroupStats.getReplicaStats().stream().forEach(e -> assertEquals(e.getCurrentReplicationLagMillis(), 0));
+        }, 20, TimeUnit.SECONDS);
 
-        // Stop replicas on docrep now.
-        // ToDo : Remove once we have dual replication enabled
-        client().admin()
-            .indices()
-            .updateSettings(
-                new UpdateSettingsRequest("test").settings(
-                    Settings.builder()
-                        .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
-                        .put("index.routing.allocation.exclude._name", primaryNode + "," + replicaNode)
-                        .build()
-                )
-            )
-            .get();
-
-        finished.set(true);
-        indexingThread.join();
-        refresh("test");
-        OpenSearchAssertions.assertHitCount(client().prepareSearch("test").setTrackTotalHits(true).get(), numAutoGenDocs.get());
+        OpenSearchAssertions.assertHitCount(
+            client().prepareSearch("test").setTrackTotalHits(true).get(),
+            asyncIndexingService.getIndexedDocs()
+        );
         OpenSearchAssertions.assertHitCount(
             client().prepareSearch("test")
                 .setTrackTotalHits(true)// extra paranoia ;)
                 .setQuery(QueryBuilders.termQuery("auto", true))
-                // .setPreference("_prefer_nodes:" + (remoteNode+ "," + remoteNode2))
                 .get(),
-            numAutoGenDocs.get()
+            asyncIndexingService.getIndexedDocs()
         );
 
     }
-
-    private Thread getThread(AtomicBoolean finished, AtomicInteger numAutoGenDocs) {
-        Thread indexingThread = new Thread(() -> {
-            while (finished.get() == false && numAutoGenDocs.get() < 100) {
-                IndexResponse indexResponse = client().prepareIndex("test").setId("id").setSource("field", "value").get();
-                assertEquals(DocWriteResponse.Result.CREATED, indexResponse.getResult());
-                DeleteResponse deleteResponse = client().prepareDelete("test", "id").get();
-                assertEquals(DocWriteResponse.Result.DELETED, deleteResponse.getResult());
-                client().prepareIndex("test").setSource("auto", true).get();
-                numAutoGenDocs.incrementAndGet();
-                logger.info("Indexed {} docs here", numAutoGenDocs.get());
-            }
-        });
-        indexingThread.start();
-        return indexingThread;
-    }
-
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteStoreMigrationSettingsUpdateIT.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteStoreMigrationSettingsUpdateIT.java
index 377bd9529ca7a..c701a8d92c336 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteStoreMigrationSettingsUpdateIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteStoreMigrationSettingsUpdateIT.java
@@ -21,7 +21,6 @@
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode.MIXED;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode.STRICT;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.Direction.REMOTE_STORE;
-import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteStoreMigrationSettingsUpdateIT extends RemoteStoreMigrationShardAllocationBaseTestCase {
@@ -92,11 +91,7 @@ public void testNewRestoredIndexIsRemoteStoreBackedForRemoteStoreDirectionAndMix
         String snapshotName = "test-snapshot";
         String snapshotRepoName = "test-restore-snapshot-repo";
         Path snapshotRepoNameAbsolutePath = randomRepoPath().toAbsolutePath();
-        assertAcked(
-            clusterAdmin().preparePutRepository(snapshotRepoName)
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", snapshotRepoNameAbsolutePath))
-        );
+        createRepository(snapshotRepoName, "fs", Settings.builder().put("location", snapshotRepoNameAbsolutePath));
 
         logger.info("Create snapshot of non remote stored backed index");
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteStoreMigrationTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteStoreMigrationTestCase.java
index 4b1c91f1d57ca..7d29e5d328492 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteStoreMigrationTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/RemoteStoreMigrationTestCase.java
@@ -8,16 +8,16 @@
 
 package org.opensearch.remotemigration;
 
-import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesRequest;
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
 import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
 import org.opensearch.client.Client;
 import org.opensearch.cluster.metadata.IndexMetadata;
-import org.opensearch.common.Priority;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.index.query.QueryBuilders;
+import org.opensearch.index.shard.IndexShard;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.snapshots.SnapshotInfo;
 import org.opensearch.test.OpenSearchIntegTestCase;
@@ -27,6 +27,7 @@
 import java.util.List;
 import java.util.Map;
 
+import static org.opensearch.cluster.routing.allocation.decider.ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_RECOVERIES_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
@@ -42,6 +43,15 @@ protected int minimumNumberOfReplicas() {
         return 1;
     }
 
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder().put(super.featureFlagSettings()).put(FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
+    }
+
+    protected int maximumNumberOfShards() {
+        return 5;
+    }
+
     public void testMixedModeAddRemoteNodes() throws Exception {
         internalCluster().setBootstrapClusterManagerNodeIndex(0);
         List<String> cmNodes = internalCluster().startNodes(1);
@@ -106,15 +116,10 @@ public void testNoShallowSnapshotInMixedMode() throws Exception {
         logger.info("Create shallow snapshot setting enabled repo");
         String shallowSnapshotRepoName = "shallow-snapshot-repo-name";
         Path shallowSnapshotRepoPath = randomRepoPath();
-        assertAcked(
-            clusterAdmin().preparePutRepository(shallowSnapshotRepoName)
-                .setType("fs")
-                .setSettings(
-                    Settings.builder()
-                        .put("location", shallowSnapshotRepoPath)
-                        .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), Boolean.TRUE)
-                )
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", shallowSnapshotRepoPath)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), Boolean.TRUE);
+        createRepository(shallowSnapshotRepoName, "fs", settings);
 
         logger.info("Verify shallow snapshot creation");
         final String snapshot1 = "snapshot1";
@@ -149,7 +154,11 @@ public void testEndToEndRemoteMigration() throws Exception {
         internalCluster().setBootstrapClusterManagerNodeIndex(0);
         List<String> docRepNodes = internalCluster().startNodes(2);
         ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
-        updateSettingsRequest.persistentSettings(Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed"));
+        updateSettingsRequest.persistentSettings(
+            Settings.builder()
+                .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed")
+                .put(CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_RECOVERIES_SETTING.getKey(), maximumNumberOfShards())
+        );
         assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
         client().admin().indices().prepareCreate("test").setSettings(indexSettings()).setMapping("field", "type=text").get();
         ensureGreen("test");
@@ -183,16 +192,7 @@ public void testEndToEndRemoteMigration() throws Exception {
                 )
                 .get()
         );
-
-        ClusterHealthResponse clusterHealthResponse = client().admin()
-            .cluster()
-            .prepareHealth()
-            .setTimeout(TimeValue.timeValueSeconds(45))
-            .setWaitForEvents(Priority.LANGUID)
-            .setWaitForNoRelocatingShards(true)
-            .execute()
-            .actionGet();
-        assertTrue(clusterHealthResponse.getRelocatingShards() == 0);
+        waitForRelocation(TimeValue.timeValueSeconds(90));
         logger.info("---> Stopping indexing thread");
         asyncIndexingService.stopIndexing();
         Map<String, Integer> shardCountByNodeId = getShardCountByNodeId();
@@ -212,4 +212,12 @@ public void testEndToEndRemoteMigration() throws Exception {
             asyncIndexingService.getIndexedDocs()
         );
     }
+
+    public void testRemoteSettingPropagatedToIndexShardAfterMigration() throws Exception {
+        testEndToEndRemoteMigration();
+        IndexShard indexShard = getIndexShard(primaryNodeName("test"), "test");
+        assertTrue(indexShard.indexSettings().isRemoteStoreEnabled());
+        assertEquals(MigrationBaseTestCase.REPOSITORY_NAME, indexShard.indexSettings().getRemoteStoreRepository());
+        assertEquals(MigrationBaseTestCase.REPOSITORY_2_NAME, indexShard.indexSettings().getRemoteStoreTranslogRepository());
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotemigration/ResizeIndexMigrationTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotemigration/ResizeIndexMigrationTestCase.java
index b817906a8f828..b804e6dbc1231 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotemigration/ResizeIndexMigrationTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotemigration/ResizeIndexMigrationTestCase.java
@@ -12,6 +12,7 @@
 import org.opensearch.action.admin.indices.shrink.ResizeType;
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
@@ -27,6 +28,11 @@ public class ResizeIndexMigrationTestCase extends MigrationBaseTestCase {
     private final static String DOC_REP_DIRECTION = "docrep";
     private final static String MIXED_MODE = "mixed";
 
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder().put(super.featureFlagSettings()).put(FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
+    }
+
     /*
     * This test will verify the resize request failure, when cluster mode is mixed
     * and index is on DocRep node, and migration to remote store is in progress.
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
index f8e5079b01a36..0acb578e2e7bf 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteRestoreSnapshotIT.java
@@ -10,19 +10,23 @@
 
 import org.opensearch.action.DocWriteResponse;
 import org.opensearch.action.admin.cluster.remotestore.restore.RestoreRemoteStoreRequest;
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
 import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotResponse;
 import org.opensearch.action.admin.indices.delete.DeleteIndexRequest;
+import org.opensearch.action.admin.indices.recovery.RecoveryResponse;
 import org.opensearch.action.delete.DeleteResponse;
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.client.Client;
 import org.opensearch.client.Requests;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.rest.RestStatus;
 import org.opensearch.index.IndexService;
@@ -31,7 +35,14 @@
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.indices.recovery.RecoveryState;
 import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.Repository;
+import org.opensearch.repositories.RepositoryData;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.snapshots.AbstractSnapshotIntegTestCase;
 import org.opensearch.snapshots.SnapshotInfo;
 import org.opensearch.snapshots.SnapshotRestoreException;
@@ -46,6 +57,7 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -63,6 +75,8 @@
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteRestoreSnapshotIT extends AbstractSnapshotIntegTestCase {
@@ -429,13 +443,15 @@ public void testRestoreInSameRemoteStoreEnabledIndex() throws IOException {
 
     void assertRemoteSegmentsAndTranslogUploaded(String idx) throws IOException {
         Client client = client();
-        String path = getShardLevelBlobPath(client, idx, new BlobPath(), "0", TRANSLOG, METADATA).buildAsString();
+        String translogPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.get(getNodeSettings());
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
+        String path = getShardLevelBlobPath(client, idx, new BlobPath(), "0", TRANSLOG, METADATA, translogPathFixedPrefix).buildAsString();
         Path remoteTranslogMetadataPath = Path.of(remoteRepoPath + "/" + path);
-        path = getShardLevelBlobPath(client, idx, new BlobPath(), "0", TRANSLOG, DATA).buildAsString();
+        path = getShardLevelBlobPath(client, idx, new BlobPath(), "0", TRANSLOG, DATA, translogPathFixedPrefix).buildAsString();
         Path remoteTranslogDataPath = Path.of(remoteRepoPath + "/" + path);
-        path = getShardLevelBlobPath(client, idx, new BlobPath(), "0", SEGMENTS, METADATA).buildAsString();
+        path = getShardLevelBlobPath(client, idx, new BlobPath(), "0", SEGMENTS, METADATA, segmentsPathFixedPrefix).buildAsString();
         Path segmentMetadataPath = Path.of(remoteRepoPath + "/" + path);
-        path = getShardLevelBlobPath(client, idx, new BlobPath(), "0", SEGMENTS, DATA).buildAsString();
+        path = getShardLevelBlobPath(client, idx, new BlobPath(), "0", SEGMENTS, DATA, segmentsPathFixedPrefix).buildAsString();
         Path segmentDataPath = Path.of(remoteRepoPath + "/" + path);
 
         try (
@@ -579,6 +595,37 @@ public void testRestoreShallowSnapshotRepository() throws ExecutionException, In
         ensureGreen(restoredIndexName1);
         assertDocsPresentInIndex(client, restoredIndexName1, numDocsInIndex1);
 
+        // ensure recovery details are non-zero
+        RecoveryResponse recoveryResponse = client().admin().indices().prepareRecoveries(restoredIndexName1).execute().actionGet();
+        assertEquals(1, recoveryResponse.getTotalShards());
+        assertEquals(1, recoveryResponse.getSuccessfulShards());
+        assertEquals(0, recoveryResponse.getFailedShards());
+        assertEquals(1, recoveryResponse.shardRecoveryStates().size());
+        assertTrue(recoveryResponse.shardRecoveryStates().containsKey(restoredIndexName1));
+        assertEquals(1, recoveryResponse.shardRecoveryStates().get(restoredIndexName1).size());
+
+        RecoveryState recoveryState = recoveryResponse.shardRecoveryStates().get(restoredIndexName1).get(0);
+        assertEquals(RecoveryState.Stage.DONE, recoveryState.getStage());
+        assertEquals(0, recoveryState.getShardId().getId());
+        assertTrue(recoveryState.getPrimary());
+        assertEquals(RecoverySource.Type.SNAPSHOT, recoveryState.getRecoverySource().getType());
+        assertThat(recoveryState.getIndex().time(), greaterThanOrEqualTo(0L));
+
+        // ensure populated file details
+        assertTrue(recoveryState.getIndex().totalFileCount() > 0);
+        assertTrue(recoveryState.getIndex().totalRecoverFiles() > 0);
+        assertTrue(recoveryState.getIndex().recoveredFileCount() > 0);
+        assertThat(recoveryState.getIndex().recoveredFilesPercent(), greaterThanOrEqualTo(0.0f));
+        assertThat(recoveryState.getIndex().recoveredFilesPercent(), lessThanOrEqualTo(100.0f));
+        assertFalse(recoveryState.getIndex().fileDetails().isEmpty());
+
+        // ensure populated bytes details
+        assertTrue(recoveryState.getIndex().recoveredBytes() > 0L);
+        assertTrue(recoveryState.getIndex().totalBytes() > 0L);
+        assertTrue(recoveryState.getIndex().totalRecoverBytes() > 0L);
+        assertThat(recoveryState.getIndex().recoveredBytesPercent(), greaterThanOrEqualTo(0.0f));
+        assertThat(recoveryState.getIndex().recoveredBytesPercent(), lessThanOrEqualTo(100.0f));
+
         // indexing some new docs and validating
         indexDocuments(client, restoredIndexName1, numDocsInIndex1, numDocsInIndex1 + 2);
         ensureGreen(restoredIndexName1);
@@ -746,4 +793,533 @@ public void testInvalidRestoreRequestScenarios() throws Exception {
         assertTrue(exception.getMessage().contains("cannot remove setting [index.remote_store.segment.repository]" + " on restore"));
     }
 
+    public void testCreateSnapshotV2() throws Exception {
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String indexName3 = "testindex3";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot1";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+        createIndex(indexName1, indexSettings);
+
+        Settings indexSettings2 = getIndexSettings(15, 0).build();
+        createIndex(indexName2, indexSettings2);
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexDocuments(client, indexName1, numDocsInIndex1);
+        indexDocuments(client, indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        SnapshotInfo snapshotInfo = createSnapshot(snapshotRepoName, snapshotName1, Collections.emptyList());
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.getPinnedTimestamp(), greaterThan(0L));
+
+        indexDocuments(client, indexName1, 10);
+        indexDocuments(client, indexName2, 20);
+
+        createIndex(indexName3, indexSettings);
+        indexDocuments(client, indexName3, 10);
+
+        String snapshotName2 = "test-create-snapshot2";
+
+        // verify response status if waitForCompletion is not true
+        RestStatus createSnapshotResponseStatus = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName2)
+            .get()
+            .status();
+        assertEquals(RestStatus.ACCEPTED, createSnapshotResponseStatus);
+    }
+
+    public void testMixedSnapshotCreationWithV2RepositorySetting() throws Exception {
+
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String indexName3 = "testindex3";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot-v1";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), false);
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+        createIndex(indexName1, indexSettings);
+
+        Settings indexSettings2 = getIndexSettings(15, 0).build();
+        createIndex(indexName2, indexSettings2);
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexDocuments(client, indexName1, numDocsInIndex1);
+        indexDocuments(client, indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        SnapshotInfo snapshotInfo = createSnapshot(snapshotRepoName, snapshotName1, Collections.emptyList());
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.getPinnedTimestamp(), equalTo(0L));
+
+        // enable shallow_snapshot_v2
+        settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        indexDocuments(client, indexName1, 10);
+        indexDocuments(client, indexName2, 20);
+
+        createIndex(indexName3, indexSettings);
+        indexDocuments(client, indexName3, 10);
+
+        String snapshotName2 = "test-create-snapshot-v2";
+
+        // verify even if waitForCompletion is not true, the request executes in a sync manner
+        CreateSnapshotResponse createSnapshotResponse2 = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName2)
+            .setWaitForCompletion(true)
+            .get();
+        snapshotInfo = createSnapshotResponse2.getSnapshotInfo();
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName2));
+        assertThat(snapshotInfo.getPinnedTimestamp(), greaterThan(0L));
+
+    }
+
+    public void testConcurrentSnapshotV2CreateOperation() throws InterruptedException, ExecutionException {
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+        createIndex(indexName1, indexSettings);
+
+        Settings indexSettings2 = getIndexSettings(15, 0).build();
+        createIndex(indexName2, indexSettings2);
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexDocuments(client, indexName1, numDocsInIndex1);
+        indexDocuments(client, indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        int concurrentSnapshots = 5;
+
+        // Prepare threads for concurrent snapshot creation
+        List<Thread> threads = new ArrayList<>();
+
+        for (int i = 0; i < concurrentSnapshots; i++) {
+            int snapshotIndex = i;
+            Thread thread = new Thread(() -> {
+                try {
+                    String snapshotName = "snapshot-concurrent-" + snapshotIndex;
+                    CreateSnapshotResponse createSnapshotResponse2 = client().admin()
+                        .cluster()
+                        .prepareCreateSnapshot(snapshotRepoName, snapshotName)
+                        .setWaitForCompletion(true)
+                        .get();
+                    SnapshotInfo snapshotInfo = createSnapshotResponse2.getSnapshotInfo();
+                    assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+                    assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+                    assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+                    assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName));
+                    assertThat(snapshotInfo.getPinnedTimestamp(), greaterThan(0L));
+                } catch (Exception e) {}
+            });
+            threads.add(thread);
+        }
+        // start all threads
+        for (Thread thread : threads) {
+            thread.start();
+        }
+
+        // Wait for all threads to complete
+        for (Thread thread : threads) {
+            thread.join();
+        }
+
+        // Validate that only one snapshot has been created
+        Repository repository = internalCluster().getInstance(RepositoriesService.class).repository(snapshotRepoName);
+        PlainActionFuture<RepositoryData> repositoryDataPlainActionFuture = new PlainActionFuture<>();
+        repository.getRepositoryData(repositoryDataPlainActionFuture);
+
+        RepositoryData repositoryData = repositoryDataPlainActionFuture.get();
+        assertThat(repositoryData.getSnapshotIds().size(), greaterThanOrEqualTo(1));
+    }
+
+    public void testCreateSnapshotV2WithRedIndex() throws Exception {
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot1";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+        createIndex(indexName1, indexSettings);
+
+        Settings indexSettings2 = getIndexSettings(15, 0).build();
+        createIndex(indexName2, indexSettings2);
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexDocuments(client, indexName1, numDocsInIndex1);
+        indexDocuments(client, indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        internalCluster().ensureAtLeastNumDataNodes(0);
+        ensureRed(indexName1);
+        ensureRed(indexName2);
+        CreateSnapshotResponse createSnapshotResponse2 = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName1)
+            .setWaitForCompletion(true)
+            .get();
+        SnapshotInfo snapshotInfo = createSnapshotResponse2.getSnapshotInfo();
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName1));
+        assertThat(snapshotInfo.getPinnedTimestamp(), greaterThan(0L));
+    }
+
+    public void testCreateSnapshotV2WithIndexingLoad() throws Exception {
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot1";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+        createIndex(indexName1, indexSettings);
+
+        Settings indexSettings2 = getIndexSettings(15, 0).build();
+        createIndex(indexName2, indexSettings2);
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexDocuments(client, indexName1, numDocsInIndex1);
+        indexDocuments(client, indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        Thread indexingThread = new Thread(() -> {
+            try {
+                for (int i = 0; i < 50; i++) {
+                    internalCluster().client().prepareIndex("test-index-load").setSource("field", "value" + i).execute().actionGet();
+                }
+            } catch (Exception e) {
+                fail("indexing failed due to exception: " + e.getMessage());
+            }
+        });
+
+        // Start indexing
+        indexingThread.start();
+
+        // Wait for a bit to let some documents be indexed
+        Thread.sleep(1000);
+
+        // Create a snapshot while indexing is ongoing
+        CreateSnapshotResponse createSnapshotResponse2 = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName1)
+            .setWaitForCompletion(true)
+            .get();
+
+        SnapshotInfo snapshotInfo = createSnapshotResponse2.getSnapshotInfo();
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName1));
+        assertThat(snapshotInfo.getPinnedTimestamp(), greaterThan(0L));
+        assertTrue(snapshotInfo.indices().contains("test-index-load"));
+        assertTrue(snapshotInfo.indices().contains(indexName1));
+        assertTrue(snapshotInfo.indices().contains(indexName2));
+        indexingThread.join();
+
+    }
+
+    public void testCreateSnapshotV2WithShallowCopySettingDisabled() throws Exception {
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot1";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), false)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+        createIndex(indexName1, indexSettings);
+
+        Settings indexSettings2 = getIndexSettings(15, 0).build();
+        createIndex(indexName2, indexSettings2);
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexDocuments(client, indexName1, numDocsInIndex1);
+        indexDocuments(client, indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        // Will create full copy snapshot if `REMOTE_STORE_INDEX_SHALLOW_COPY` is false but `SHALLOW_SNAPSHOT_V2` is true
+        SnapshotInfo snapshotInfo = createSnapshot(snapshotRepoName, snapshotName1, Collections.emptyList());
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.getPinnedTimestamp(), equalTo(0L));
+
+        // Validate that snapshot is present in repository data
+        Repository repository = internalCluster().getInstance(RepositoriesService.class).repository(snapshotRepoName);
+        PlainActionFuture<RepositoryData> repositoryDataPlainActionFuture = new PlainActionFuture<>();
+        repository.getRepositoryData(repositoryDataPlainActionFuture);
+
+        RepositoryData repositoryData = repositoryDataPlainActionFuture.get();
+        assertTrue(repositoryData.getSnapshotIds().contains(snapshotInfo.snapshotId()));
+    }
+
+    public void testClusterManagerFailoverDuringSnapshotCreation() throws Exception {
+
+        internalCluster().startClusterManagerOnlyNodes(3, pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot1";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+        createIndex(indexName1, indexSettings);
+
+        Settings indexSettings2 = getIndexSettings(15, 0).build();
+        createIndex(indexName2, indexSettings2);
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexDocuments(client, indexName1, numDocsInIndex1);
+        indexDocuments(client, indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        ensureStableCluster(4, internalCluster().getClusterManagerName());
+
+        final SnapshotInfo[] snapshotInfo = new SnapshotInfo[1];
+        final Boolean[] snapshotFailed = new Boolean[1];
+        snapshotFailed[0] = false;
+        Thread snapshotThread = new Thread(() -> {
+            try {
+                // Start snapshot creation
+                CreateSnapshotResponse createSnapshotResponse = client().admin()
+                    .cluster()
+                    .prepareCreateSnapshot(snapshotRepoName, snapshotName1)
+                    .setWaitForCompletion(true)
+                    .get();
+                snapshotInfo[0] = createSnapshotResponse.getSnapshotInfo();
+
+            } catch (Exception e) {
+                snapshotFailed[0] = true;
+            }
+        });
+        snapshotThread.start();
+        Thread.sleep(100);
+
+        internalCluster().stopCurrentClusterManagerNode();
+
+        // Wait for the cluster to elect a new Cluster Manager and stabilize
+        ensureStableCluster(3, internalCluster().getClusterManagerName());
+
+        // Wait for the snapshot thread to complete
+        snapshotThread.join();
+
+        // Validate that the snapshot was created or handled gracefully
+        Repository repository = internalCluster().getInstance(RepositoriesService.class).repository(snapshotRepoName);
+        PlainActionFuture<RepositoryData> repositoryDataPlainActionFuture = new PlainActionFuture<>();
+        repository.getRepositoryData(repositoryDataPlainActionFuture);
+
+        RepositoryData repositoryData = repositoryDataPlainActionFuture.get();
+        if (snapshotFailed[0]) {
+            assertFalse(repositoryData.getSnapshotIds().contains(snapshotInfo[0].snapshotId()));
+        } else {
+            assertTrue(repositoryData.getSnapshotIds().contains(snapshotInfo[0].snapshotId()));
+        }
+    }
+
+    public void testConcurrentV1SnapshotAndV2RepoSettingUpdate() throws Exception {
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        internalCluster().startDataOnlyNode(pinnedTimestampSettings());
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot-v1";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+        Settings.Builder settings = Settings.builder()
+            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), false);
+        createRepository(snapshotRepoName, FsRepository.TYPE, settings);
+
+        Client client = client();
+        Settings indexSettings = getIndexSettings(20, 0).build();
+
+        for (int i = 0; i < 10; i++) {
+            createIndex("index" + i, indexSettings);
+        }
+        ensureStableCluster(3);
+        for (int i = 0; i < 10; i++) {
+            indexDocuments(client, "index" + i, 15);
+        }
+
+        ensureStableCluster(3);
+        for (int i = 0; i < 10; i++) {
+            ensureGreen("index" + i);
+        }
+        final CreateSnapshotResponse[] snapshotV1Response = new CreateSnapshotResponse[1];
+        // Create a separate thread to create the first snapshot
+        Thread createV1SnapshotThread = new Thread(() -> {
+            try {
+                snapshotV1Response[0] = client().admin()
+                    .cluster()
+                    .prepareCreateSnapshot(snapshotRepoName, snapshotName1)
+                    .setWaitForCompletion(true)
+                    .get();
+
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        });
+
+        // Create a separate thread to enable shallow_snapshot_v2
+        Thread enableV2Thread = new Thread(() -> {
+            try {
+
+                assertThrows(
+                    IllegalStateException.class,
+                    () -> createRepository(
+                        snapshotRepoName,
+                        FsRepository.TYPE,
+                        Settings.builder()
+                            .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+                            .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+                            .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+                            .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+                            .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true)
+                    )
+                );
+
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        });
+
+        createV1SnapshotThread.start();
+
+        Thread.sleep(100);
+
+        enableV2Thread.start();
+
+        enableV2Thread.join();
+        createV1SnapshotThread.join();
+    }
+
+    private Settings pinnedTimestampSettings() {
+        Settings settings = Settings.builder()
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true)
+            .build();
+        return settings;
+    }
+
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
index 740aee69f7d80..ba06bb463e5a8 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreBaseIntegTestCase.java
@@ -69,6 +69,7 @@
 public class RemoteStoreBaseIntegTestCase extends OpenSearchIntegTestCase {
     protected static final String REPOSITORY_NAME = "test-remote-store-repo";
     protected static final String REPOSITORY_2_NAME = "test-remote-store-repo-2";
+    protected static final String REMOTE_ROUTING_TABLE_REPO = "remote-routing-table-repo";
     protected static final int SHARD_COUNT = 1;
     protected static int REPLICA_COUNT = 1;
     protected static final String TOTAL_OPERATIONS = "total-operations";
@@ -189,9 +190,7 @@ protected void setFailRate(String repoName, int value) throws ExecutionException
         Settings.Builder settings = Settings.builder()
             .put("location", rmd.settings().get("location"))
             .put(REPOSITORIES_FAILRATE_SETTING.getKey(), value);
-        assertAcked(
-            client().admin().cluster().preparePutRepository(repoName).setType(ReloadableFsRepository.TYPE).setSettings(settings).get()
-        );
+        createRepository(repoName, ReloadableFsRepository.TYPE, settings);
     }
 
     public Settings indexSettings() {
@@ -312,7 +311,7 @@ public void assertRemoteStoreRepositoryOnAllNodes(String repositoryName) {
         }
     }
 
-    public static int getFileCount(Path path) throws Exception {
+    public static int getFileCount(Path path) throws IOException {
         final AtomicInteger filesExisting = new AtomicInteger(0);
         Files.walkFileTree(path, new SimpleFileVisitor<>() {
             @Override
@@ -350,4 +349,30 @@ protected void restore(boolean restoreAllShards, String... indices) {
                 PlainActionFuture.newFuture()
             );
     }
+
+    protected void prepareCluster(int numClusterManagerNodes, int numDataOnlyNodes, String indices, int replicaCount, int shardCount) {
+        internalCluster().startClusterManagerOnlyNodes(numClusterManagerNodes);
+        internalCluster().startDataOnlyNodes(numDataOnlyNodes);
+        for (String index : indices.split(",")) {
+            createIndex(index, remoteStoreIndexSettings(replicaCount, shardCount));
+            ensureYellowAndNoInitializingShards(index);
+            ensureGreen(index);
+        }
+    }
+
+    protected void prepareCluster(
+        int numClusterManagerNodes,
+        int numDataOnlyNodes,
+        String indices,
+        int replicaCount,
+        int shardCount,
+        Settings settings
+    ) {
+        internalCluster().startClusterManagerOnlyNodes(numClusterManagerNodes, settings);
+        internalCluster().startDataOnlyNodes(numDataOnlyNodes, settings);
+        for (String index : indices.split(",")) {
+            createIndex(index, remoteStoreIndexSettings(replicaCount, shardCount));
+            ensureGreen(index);
+        }
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreClusterStateRestoreIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreClusterStateRestoreIT.java
index 8f27c25c56667..6ec973090883b 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreClusterStateRestoreIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreClusterStateRestoreIT.java
@@ -8,20 +8,36 @@
 
 package org.opensearch.remotestore;
 
+import org.opensearch.action.admin.cluster.configuration.AddVotingConfigExclusionsAction;
+import org.opensearch.action.admin.cluster.configuration.AddVotingConfigExclusionsRequest;
 import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
+import org.opensearch.action.admin.indices.alias.Alias;
 import org.opensearch.action.admin.indices.datastream.DataStreamRolloverIT;
 import org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequest;
+import org.opensearch.action.admin.indices.template.put.PutComponentTemplateAction;
+import org.opensearch.action.admin.indices.template.put.PutComposableIndexTemplateAction;
 import org.opensearch.action.admin.indices.template.put.PutIndexTemplateRequest;
+import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.metadata.ComponentTemplate;
+import org.opensearch.cluster.metadata.ComponentTemplateMetadata;
+import org.opensearch.cluster.metadata.ComposableIndexTemplate;
+import org.opensearch.cluster.metadata.ComposableIndexTemplateMetadata;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexTemplateMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.RepositoriesMetadata;
+import org.opensearch.cluster.metadata.Template;
+import org.opensearch.common.action.ActionFuture;
+import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.gateway.remote.ClusterMetadataManifest;
 import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedIndexMetadata;
 import org.opensearch.gateway.remote.RemoteClusterStateService;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.test.InternalTestCluster;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.junit.Before;
@@ -30,23 +46,31 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ExecutionException;
+import java.util.stream.Collectors;
 
 import static org.opensearch.cluster.coordination.ClusterBootstrapService.INITIAL_CLUSTER_MANAGER_NODES_SETTING;
 import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_READ_ONLY_SETTING;
 import static org.opensearch.cluster.metadata.Metadata.CLUSTER_READ_ONLY_BLOCK;
 import static org.opensearch.cluster.metadata.Metadata.SETTING_READ_ONLY_SETTING;
 import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.encodeString;
 import static org.opensearch.indices.ShardLimitValidator.SETTING_CLUSTER_MAX_SHARDS_PER_NODE;
 import static org.opensearch.repositories.blobstore.BlobStoreRepository.SYSTEM_REPOSITORY_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class RemoteStoreClusterStateRestoreIT extends BaseRemoteStoreRestoreIT {
+    static final String TEMPLATE_NAME = "remote-store-test-template";
+    static final String COMPONENT_TEMPLATE_NAME = "remote-component-template1";
+    static final String COMPOSABLE_TEMPLATE_NAME = "remote-composable-template1";
+    static final Setting<String> MOCK_SETTING = Setting.simpleString("mock-setting");
+    static final String[] EXCLUDED_NODES = { "ex-1", "ex-2" };
 
     @Before
     public void setup() {
@@ -93,6 +117,45 @@ public void testFullClusterRestore() throws Exception {
         Map<String, Long> indexStats = initialTestSetup(shardCount, replicaCount, dataNodeCount, 1);
         String prevClusterUUID = clusterService().state().metadata().clusterUUID();
         long prevClusterStateVersion = clusterService().state().version();
+        // Step - 1.1 Add some cluster state elements
+        ActionFuture<AcknowledgedResponse> response = client().admin()
+            .indices()
+            .preparePutTemplate(TEMPLATE_NAME)
+            .addAlias(new Alias(INDEX_NAME))
+            .setPatterns(Arrays.stream(INDEX_NAMES_WILDCARD.split(",")).collect(Collectors.toList()))
+            .execute();
+        assertTrue(response.get().isAcknowledged());
+        ActionFuture<ClusterUpdateSettingsResponse> clusterUpdateSettingsResponse = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setPersistentSettings(Settings.builder().put(SETTING_READ_ONLY_SETTING.getKey(), false).build())
+            .execute();
+        assertTrue(clusterUpdateSettingsResponse.get().isAcknowledged());
+        // update coordination metadata
+        client().execute(AddVotingConfigExclusionsAction.INSTANCE, new AddVotingConfigExclusionsRequest(EXCLUDED_NODES));
+        // Add a custom metadata as component index template
+        ActionFuture<AcknowledgedResponse> componentTemplateResponse = client().execute(
+            PutComponentTemplateAction.INSTANCE,
+            new PutComponentTemplateAction.Request(COMPONENT_TEMPLATE_NAME).componentTemplate(
+                new ComponentTemplate(new Template(Settings.EMPTY, null, Collections.emptyMap()), 1L, Collections.emptyMap())
+            )
+        );
+        assertTrue(componentTemplateResponse.get().isAcknowledged());
+        ActionFuture<AcknowledgedResponse> composableTemplateResponse = client().execute(
+            PutComposableIndexTemplateAction.INSTANCE,
+            new PutComposableIndexTemplateAction.Request(COMPOSABLE_TEMPLATE_NAME).indexTemplate(
+                new ComposableIndexTemplate(
+                    Arrays.stream(INDEX_NAMES_WILDCARD.split(",")).collect(Collectors.toList()),
+                    new Template(Settings.EMPTY, null, Collections.emptyMap()),
+                    Collections.singletonList(COMPONENT_TEMPLATE_NAME),
+                    1L,
+                    1L,
+                    Collections.emptyMap(),
+                    null
+                )
+            )
+        );
+        assertTrue(composableTemplateResponse.get().isAcknowledged());
 
         // Step - 2 Replace all nodes in the cluster with new nodes. This ensures new cluster state doesn't have previous index metadata
         resetCluster(dataNodeCount, clusterManagerNodeCount);
@@ -110,7 +173,24 @@ public void testFullClusterRestore() throws Exception {
         );
         validateMetadata(List.of(INDEX_NAME));
         verifyRedIndicesAndTriggerRestore(indexStats, INDEX_NAME, true);
-
+        clusterService().state()
+            .metadata()
+            .coordinationMetadata()
+            .getVotingConfigExclusions()
+            .stream()
+            .forEach(config -> assertTrue(Arrays.stream(EXCLUDED_NODES).anyMatch(node -> node.equals(config.getNodeId()))));
+        assertFalse(clusterService().state().metadata().templates().isEmpty());
+        assertTrue(clusterService().state().metadata().templates().containsKey(TEMPLATE_NAME));
+        assertFalse(clusterService().state().metadata().settings().isEmpty());
+        assertFalse(clusterService().state().metadata().settings().getAsBoolean(SETTING_READ_ONLY_SETTING.getKey(), true));
+        assertNotNull(clusterService().state().metadata().custom("component_template"));
+        ComponentTemplateMetadata componentTemplateMetadata = clusterService().state().metadata().custom("component_template");
+        assertFalse(componentTemplateMetadata.componentTemplates().isEmpty());
+        assertTrue(componentTemplateMetadata.componentTemplates().containsKey(COMPONENT_TEMPLATE_NAME));
+        assertNotNull(clusterService().state().metadata().custom("index_template"));
+        ComposableIndexTemplateMetadata composableIndexTemplate = clusterService().state().metadata().custom("index_template");
+        assertFalse(composableIndexTemplate.indexTemplates().isEmpty());
+        assertTrue(composableIndexTemplate.indexTemplates().containsKey(COMPOSABLE_TEMPLATE_NAME));
     }
 
     /**
@@ -249,9 +329,7 @@ public void testFullClusterRestoreManifestFilePointsToInvalidIndexMetadataPathTh
         // Step - 3 Delete index metadata file in remote
         try {
             Files.move(
-                segmentRepoPath.resolve(
-                    RemoteClusterStateService.encodeString(clusterName) + "/cluster-state/" + prevClusterUUID + "/index"
-                ),
+                segmentRepoPath.resolve(encodeString(clusterName) + "/cluster-state/" + prevClusterUUID + "/index"),
                 segmentRepoPath.resolve("cluster-state/")
             );
         } catch (IOException e) {
@@ -277,10 +355,7 @@ public void testRemoteStateFullRestart() throws Exception {
         try {
             Files.move(
                 segmentRepoPath.resolve(
-                    RemoteClusterStateService.encodeString(clusterService().state().getClusterName().value())
-                        + "/cluster-state/"
-                        + prevClusterUUID
-                        + "/manifest"
+                    encodeString(clusterService().state().getClusterName().value()) + "/cluster-state/" + prevClusterUUID + "/manifest"
                 ),
                 segmentRepoPath.resolve("cluster-state/")
             );
@@ -403,14 +478,7 @@ public void testFullClusterRestoreGlobalMetadata() throws Exception {
 
     private Path registerCustomRepository() {
         Path path = randomRepoPath();
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository("custom-repo")
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", path).put("compress", false))
-                .get()
-        );
+        createRepository("custom-repo", "fs", Settings.builder().put("location", path).put("compress", false));
         return path;
     }
 
@@ -420,9 +488,15 @@ private void verifyRestoredRepositories(Path repoPath) {
         assertTrue(SYSTEM_REPOSITORY_SETTING.get(repositoriesMetadata.repository(REPOSITORY_NAME).settings()));
         assertTrue(SYSTEM_REPOSITORY_SETTING.get(repositoriesMetadata.repository(REPOSITORY_2_NAME).settings()));
         assertEquals("fs", repositoriesMetadata.repository("custom-repo").type());
+        Settings settings = repositoriesMetadata.repository("custom-repo").settings();
+        PathType pathType = BlobStoreRepository.SHARD_PATH_TYPE.get(settings);
         assertEquals(
-            Settings.builder().put("location", repoPath).put("compress", false).build(),
-            repositoriesMetadata.repository("custom-repo").settings()
+            Settings.builder()
+                .put("location", repoPath)
+                .put("compress", false)
+                .put(BlobStoreRepository.SHARD_PATH_TYPE.getKey(), pathType)
+                .build(),
+            settings
         );
 
         // repo cleanup post verification
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreIT.java
index 7721b18a4fe6b..692727357a88a 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreIT.java
@@ -47,6 +47,7 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -65,7 +66,6 @@
 import static org.opensearch.index.remote.RemoteStoreEnums.DataType.METADATA;
 import static org.opensearch.index.shard.IndexShardTestCase.getTranslog;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING;
-import static org.opensearch.test.OpenSearchTestCase.getShardLevelBlobPath;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
 import static org.hamcrest.Matchers.comparesEqualTo;
@@ -133,6 +133,21 @@ private void testPeerRecovery(int numberOfIterations, boolean invokeFlush) throw
         );
     }
 
+    public void testRemoteStoreIndexCreationAndDeletionWithReferencedStore() throws InterruptedException, ExecutionException {
+        String dataNode = internalCluster().startNodes(1).get(0);
+        createIndex(INDEX_NAME, remoteStoreIndexSettings(0));
+        ensureYellowAndNoInitializingShards(INDEX_NAME);
+        ensureGreen(INDEX_NAME);
+
+        IndexShard indexShard = getIndexShard(dataNode, INDEX_NAME);
+
+        // Simulating a condition where store is already in use by increasing ref count, this helps in testing index
+        // deletion when refresh is in-progress.
+        indexShard.store().incRef();
+        assertAcked(client().admin().indices().prepareDelete(INDEX_NAME));
+        indexShard.store().decRef();
+    }
+
     public void testPeerRecoveryWithRemoteStoreAndRemoteTranslogNoDataFlush() throws Exception {
         testPeerRecovery(1, true);
     }
@@ -190,7 +205,16 @@ public void testStaleCommitDeletionWithInvokeFlush() throws Exception {
         createIndex(INDEX_NAME, remoteStoreIndexSettings(1, 10000l, -1));
         int numberOfIterations = randomIntBetween(5, 15);
         indexData(numberOfIterations, true, INDEX_NAME);
-        String shardPath = getShardLevelBlobPath(client(), INDEX_NAME, BlobPath.cleanPath(), "0", SEGMENTS, METADATA).buildAsString();
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
+        String shardPath = getShardLevelBlobPath(
+            client(),
+            INDEX_NAME,
+            BlobPath.cleanPath(),
+            "0",
+            SEGMENTS,
+            METADATA,
+            segmentsPathFixedPrefix
+        ).buildAsString();
         Path indexPath = Path.of(segmentRepoPath + "/" + shardPath);
         ;
         IndexShard indexShard = getIndexShard(dataNode, INDEX_NAME);
@@ -203,10 +227,15 @@ public void testStaleCommitDeletionWithInvokeFlush() throws Exception {
             } else {
                 // As delete is async its possible that the file gets created before the deletion or after
                 // deletion.
-                MatcherAssert.assertThat(
-                    actualFileCount,
-                    is(oneOf(lastNMetadataFilesToKeep - 1, lastNMetadataFilesToKeep, lastNMetadataFilesToKeep + 1))
-                );
+                if (RemoteStoreSettings.isPinnedTimestampsEnabled()) {
+                    // With pinned timestamp, we also keep md files since last successful fetch
+                    assertTrue(actualFileCount >= lastNMetadataFilesToKeep);
+                } else {
+                    MatcherAssert.assertThat(
+                        actualFileCount,
+                        is(oneOf(lastNMetadataFilesToKeep - 1, lastNMetadataFilesToKeep, lastNMetadataFilesToKeep + 1))
+                    );
+                }
             }
         }, 30, TimeUnit.SECONDS);
     }
@@ -216,7 +245,16 @@ public void testStaleCommitDeletionWithoutInvokeFlush() throws Exception {
         createIndex(INDEX_NAME, remoteStoreIndexSettings(1, 10000l, -1));
         int numberOfIterations = randomIntBetween(5, 15);
         indexData(numberOfIterations, false, INDEX_NAME);
-        String shardPath = getShardLevelBlobPath(client(), INDEX_NAME, BlobPath.cleanPath(), "0", SEGMENTS, METADATA).buildAsString();
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
+        String shardPath = getShardLevelBlobPath(
+            client(),
+            INDEX_NAME,
+            BlobPath.cleanPath(),
+            "0",
+            SEGMENTS,
+            METADATA,
+            segmentsPathFixedPrefix
+        ).buildAsString();
         Path indexPath = Path.of(segmentRepoPath + "/" + shardPath);
         int actualFileCount = getFileCount(indexPath);
         // We also allow (numberOfIterations + 1) as index creation also triggers refresh.
@@ -227,15 +265,28 @@ public void testStaleCommitDeletionWithMinSegmentFiles_3() throws Exception {
         Settings.Builder settings = Settings.builder()
             .put(RemoteStoreSettings.CLUSTER_REMOTE_INDEX_SEGMENT_METADATA_RETENTION_MAX_COUNT_SETTING.getKey(), "3");
         internalCluster().startNode(settings);
-
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
         createIndex(INDEX_NAME, remoteStoreIndexSettings(1, 10000l, -1));
         int numberOfIterations = randomIntBetween(5, 15);
         indexData(numberOfIterations, true, INDEX_NAME);
-        String shardPath = getShardLevelBlobPath(client(), INDEX_NAME, BlobPath.cleanPath(), "0", SEGMENTS, METADATA).buildAsString();
+        String shardPath = getShardLevelBlobPath(
+            client(),
+            INDEX_NAME,
+            BlobPath.cleanPath(),
+            "0",
+            SEGMENTS,
+            METADATA,
+            segmentsPathFixedPrefix
+        ).buildAsString();
         Path indexPath = Path.of(segmentRepoPath + "/" + shardPath);
         int actualFileCount = getFileCount(indexPath);
         // We also allow (numberOfIterations + 1) as index creation also triggers refresh.
-        MatcherAssert.assertThat(actualFileCount, is(oneOf(4)));
+        if (RemoteStoreSettings.isPinnedTimestampsEnabled()) {
+            // With pinned timestamp, we also keep md files since last successful fetch
+            assertTrue(actualFileCount >= 4);
+        } else {
+            assertEquals(4, actualFileCount);
+        }
     }
 
     public void testStaleCommitDeletionWithMinSegmentFiles_Disabled() throws Exception {
@@ -246,7 +297,16 @@ public void testStaleCommitDeletionWithMinSegmentFiles_Disabled() throws Excepti
         createIndex(INDEX_NAME, remoteStoreIndexSettings(1, 10000l, -1));
         int numberOfIterations = randomIntBetween(12, 18);
         indexData(numberOfIterations, true, INDEX_NAME);
-        String shardPath = getShardLevelBlobPath(client(), INDEX_NAME, BlobPath.cleanPath(), "0", SEGMENTS, METADATA).buildAsString();
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
+        String shardPath = getShardLevelBlobPath(
+            client(),
+            INDEX_NAME,
+            BlobPath.cleanPath(),
+            "0",
+            SEGMENTS,
+            METADATA,
+            segmentsPathFixedPrefix
+        ).buildAsString();
         Path indexPath = Path.of(segmentRepoPath + "/" + shardPath);
         ;
         int actualFileCount = getFileCount(indexPath);
@@ -486,9 +546,7 @@ public void testRestoreSnapshotToIndexWithSameNameDifferentUUID() throws Excepti
         List<String> dataNodes = internalCluster().startDataOnlyNodes(2);
 
         Path absolutePath = randomRepoPath().toAbsolutePath();
-        assertAcked(
-            clusterAdmin().preparePutRepository("test-repo").setType("fs").setSettings(Settings.builder().put("location", absolutePath))
-        );
+        createRepository("test-repo", "fs", Settings.builder().put("location", absolutePath));
 
         logger.info("--> Create index and ingest 50 docs");
         createIndex(INDEX_NAME, remoteStoreIndexSettings(1));
@@ -581,8 +639,10 @@ public void testFallbackToNodeToNodeSegmentCopy() throws Exception {
         indexBulk(INDEX_NAME, 50);
         flushAndRefresh(INDEX_NAME);
 
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
         // 3. Delete data from remote segment store
-        String shardPath = getShardLevelBlobPath(client(), INDEX_NAME, BlobPath.cleanPath(), "0", SEGMENTS, DATA).buildAsString();
+        String shardPath = getShardLevelBlobPath(client(), INDEX_NAME, BlobPath.cleanPath(), "0", SEGMENTS, DATA, segmentsPathFixedPrefix)
+            .buildAsString();
         Path segmentDataPath = Path.of(segmentRepoPath + "/" + shardPath);
 
         try (Stream<Path> files = Files.list(segmentDataPath)) {
@@ -821,7 +881,16 @@ public void testLocalOnlyTranslogCleanupOnNodeRestart() throws Exception {
             .get()
             .getSetting(INDEX_NAME, IndexMetadata.SETTING_INDEX_UUID);
 
-        String shardPath = getShardLevelBlobPath(client(), INDEX_NAME, BlobPath.cleanPath(), "0", TRANSLOG, METADATA).buildAsString();
+        String translogPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.get(getNodeSettings());
+        String shardPath = getShardLevelBlobPath(
+            client(),
+            INDEX_NAME,
+            BlobPath.cleanPath(),
+            "0",
+            TRANSLOG,
+            METADATA,
+            translogPathFixedPrefix
+        ).buildAsString();
         Path translogMetaDataPath = Path.of(translogRepoPath + "/" + shardPath);
 
         try (Stream<Path> files = Files.list(translogMetaDataPath)) {
@@ -852,7 +921,9 @@ public void testFlushOnTooManyRemoteTranslogFiles() throws Exception {
 
         ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
         updateSettingsRequest.persistentSettings(
-            Settings.builder().put(RemoteStoreSettings.CLUSTER_REMOTE_MAX_TRANSLOG_READERS.getKey(), "100")
+            Settings.builder()
+                .put(RemoteStoreSettings.CLUSTER_REMOTE_MAX_TRANSLOG_READERS.getKey(), "100")
+                .put(CLUSTER_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING.getKey(), "0ms")
         );
         assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
 
@@ -883,5 +954,61 @@ public void testFlushOnTooManyRemoteTranslogFiles() throws Exception {
                 assertEquals(totalFiles, 1L);
             }
         }, 30, TimeUnit.SECONDS);
+
+        // Disabling max translog readers
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setPersistentSettings(Settings.builder().put(RemoteStoreSettings.CLUSTER_REMOTE_MAX_TRANSLOG_READERS.getKey(), "-1"))
+                .get()
+        );
+
+        // Indexing 500 more docs
+        for (int i = 0; i < 500; i++) {
+            indexBulk(INDEX_NAME, 1);
+        }
+
+        // No flush is triggered since max_translog_readers is set to -1
+        // Total tlog files would be incremented by 500
+        try (Stream<Path> files = Files.list(translogLocation)) {
+            long totalFiles = files.filter(f -> f.getFileName().toString().endsWith(Translog.TRANSLOG_FILE_SUFFIX)).count();
+            assertEquals(totalFiles, 501L);
+        }
+    }
+
+    public void testAsyncTranslogDurabilityRestrictionsThroughIdxTemplates() throws Exception {
+        logger.info("Starting up cluster manager with cluster.remote_store.index.restrict.async-durability set to true");
+        String cm1 = internalCluster().startClusterManagerOnlyNode(
+            Settings.builder().put(IndicesService.CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING.getKey(), true).build()
+        );
+        internalCluster().startDataOnlyNode();
+        ensureStableCluster(2);
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> internalCluster().client()
+                .admin()
+                .indices()
+                .preparePutTemplate("test")
+                .setPatterns(Arrays.asList("test*"))
+                .setSettings(Settings.builder().put(IndexSettings.INDEX_TRANSLOG_DURABILITY_SETTING.getKey(), "async"))
+                .get()
+        );
+        logger.info("Starting up another cluster manager with cluster.remote_store.index.restrict.async-durability set to false");
+        internalCluster().startClusterManagerOnlyNode(
+            Settings.builder().put(IndicesService.CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING.getKey(), false).build()
+        );
+        internalCluster().stopRandomNode(InternalTestCluster.nameFilter(cm1));
+        ensureStableCluster(2);
+        assertAcked(
+            internalCluster().client()
+                .admin()
+                .indices()
+                .preparePutTemplate("test")
+                .setPatterns(Arrays.asList("test*"))
+                .setSettings(Settings.builder().put(IndexSettings.INDEX_TRANSLOG_DURABILITY_SETTING.getKey(), "async"))
+                .get()
+        );
     }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsIT.java
new file mode 100644
index 0000000000000..2fcda8c2d2f27
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStorePinnedTimestampsIT.java
@@ -0,0 +1,183 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.remotestore;
+
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class RemoteStorePinnedTimestampsIT extends RemoteStoreBaseIntegTestCase {
+    static final String INDEX_NAME = "remote-store-test-idx-1";
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true)
+            .build();
+    }
+
+    ActionListener<Void> noOpActionListener = new ActionListener<>() {
+        @Override
+        public void onResponse(Void unused) {}
+
+        @Override
+        public void onFailure(Exception e) {}
+    };
+
+    public void testTimestampPinUnpin() throws Exception {
+        prepareCluster(1, 1, INDEX_NAME, 0, 2);
+        ensureGreen(INDEX_NAME);
+
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = internalCluster().getInstance(
+            RemoteStorePinnedTimestampService.class,
+            primaryNodeName(INDEX_NAME)
+        );
+
+        Tuple<Long, Set<Long>> pinnedTimestampWithFetchTimestamp = RemoteStorePinnedTimestampService.getPinnedTimestamps();
+        long lastFetchTimestamp = pinnedTimestampWithFetchTimestamp.v1();
+        assertEquals(-1L, lastFetchTimestamp);
+        assertEquals(Set.of(), pinnedTimestampWithFetchTimestamp.v2());
+
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> remoteStorePinnedTimestampService.pinTimestamp(1234L, "ss1", noOpActionListener)
+        );
+
+        long timestamp1 = System.currentTimeMillis() + 30000L;
+        long timestamp2 = System.currentTimeMillis() + 60000L;
+        long timestamp3 = System.currentTimeMillis() + 900000L;
+        remoteStorePinnedTimestampService.pinTimestamp(timestamp1, "ss2", noOpActionListener);
+        remoteStorePinnedTimestampService.pinTimestamp(timestamp2, "ss3", noOpActionListener);
+        remoteStorePinnedTimestampService.pinTimestamp(timestamp3, "ss4", noOpActionListener);
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+
+        assertBusy(() -> {
+            Tuple<Long, Set<Long>> pinnedTimestampWithFetchTimestamp_2 = RemoteStorePinnedTimestampService.getPinnedTimestamps();
+            long lastFetchTimestamp_2 = pinnedTimestampWithFetchTimestamp_2.v1();
+            assertTrue(lastFetchTimestamp_2 != -1);
+            assertEquals(Set.of(timestamp1, timestamp2, timestamp3), pinnedTimestampWithFetchTimestamp_2.v2());
+        });
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueMinutes(3));
+
+        // Unpinning already pinned entity
+        remoteStorePinnedTimestampService.unpinTimestamp(timestamp2, "ss3", noOpActionListener);
+
+        // This should fail as timestamp is not pinned by pinning entity
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteStorePinnedTimestampService.unpinTimestamp(timestamp1, "no-snapshot", new LatchedActionListener<>(new ActionListener<Void>() {
+            @Override
+            public void onResponse(Void unused) {
+                // onResponse should not get called.
+                fail();
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                assertTrue(e instanceof IllegalArgumentException);
+            }
+        }, latch));
+        latch.await();
+
+        // Adding different entity to already pinned timestamp
+        remoteStorePinnedTimestampService.pinTimestamp(timestamp3, "ss5", noOpActionListener);
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+
+        assertBusy(() -> {
+            Tuple<Long, Set<Long>> pinnedTimestampWithFetchTimestamp_3 = RemoteStorePinnedTimestampService.getPinnedTimestamps();
+            long lastFetchTimestamp_3 = pinnedTimestampWithFetchTimestamp_3.v1();
+            assertTrue(lastFetchTimestamp_3 != -1);
+            assertEquals(Set.of(timestamp1, timestamp3), pinnedTimestampWithFetchTimestamp_3.v2());
+        });
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueMinutes(3));
+    }
+
+    public void testPinnedTimestampClone() throws Exception {
+        prepareCluster(1, 1, INDEX_NAME, 0, 2);
+        ensureGreen(INDEX_NAME);
+
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = internalCluster().getInstance(
+            RemoteStorePinnedTimestampService.class,
+            primaryNodeName(INDEX_NAME)
+        );
+
+        long timestamp1 = System.currentTimeMillis() + 30000L;
+        long timestamp2 = System.currentTimeMillis() + 60000L;
+        long timestamp3 = System.currentTimeMillis() + 900000L;
+        remoteStorePinnedTimestampService.pinTimestamp(timestamp1, "ss2", noOpActionListener);
+        remoteStorePinnedTimestampService.pinTimestamp(timestamp2, "ss3", noOpActionListener);
+        remoteStorePinnedTimestampService.pinTimestamp(timestamp3, "ss4", noOpActionListener);
+
+        // Clone timestamp1
+        remoteStorePinnedTimestampService.cloneTimestamp(timestamp1, "ss2", "ss2-2", noOpActionListener);
+
+        // With clone, set of pinned timestamp will not change
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+        assertBusy(
+            () -> assertEquals(Set.of(timestamp1, timestamp2, timestamp3), RemoteStorePinnedTimestampService.getPinnedTimestamps().v2())
+        );
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueMinutes(3));
+
+        // Clone timestamp1 but provide invalid existing entity
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteStorePinnedTimestampService.cloneTimestamp(
+            timestamp1,
+            "ss3",
+            "ss2-3",
+            new LatchedActionListener<>(new ActionListener<Void>() {
+                @Override
+                public void onResponse(Void unused) {
+                    // onResponse should not get called.
+                    fail();
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    assertTrue(e instanceof IllegalArgumentException);
+                }
+            }, latch)
+        );
+        latch.await();
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+        assertBusy(
+            () -> assertEquals(Set.of(timestamp1, timestamp2, timestamp3), RemoteStorePinnedTimestampService.getPinnedTimestamps().v2())
+        );
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueMinutes(3));
+
+        // Now we have timestamp1 pinned by 2 entities, unpin 1, this should not change set of pinned timestamps
+        remoteStorePinnedTimestampService.unpinTimestamp(timestamp1, "ss2", noOpActionListener);
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+        assertBusy(
+            () -> assertEquals(Set.of(timestamp1, timestamp2, timestamp3), RemoteStorePinnedTimestampService.getPinnedTimestamps().v2())
+        );
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueMinutes(3));
+
+        // Now unpin second entity as well, set of pinned timestamp should be reduced by 1
+        remoteStorePinnedTimestampService.unpinTimestamp(timestamp1, "ss2-2", noOpActionListener);
+
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+        assertBusy(() -> assertEquals(Set.of(timestamp2, timestamp3), RemoteStorePinnedTimestampService.getPinnedTimestamps().v2()));
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueMinutes(3));
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRefreshListenerIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRefreshListenerIT.java
index 7ae08bf968ade..a7292482100e1 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRefreshListenerIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRefreshListenerIT.java
@@ -13,6 +13,7 @@
 import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.nio.file.Path;
@@ -50,7 +51,10 @@ public void testRemoteRefreshRetryOnFailure() throws Exception {
 
         String indexName = response.getShards()[0].getShardRouting().index().getName();
         String indexUuid = response.getShards()[0].getShardRouting().index().getUUID();
-        String shardPath = getShardLevelBlobPath(client(), indexName, new BlobPath(), "0", SEGMENTS, DATA).buildAsString();
+
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
+        String shardPath = getShardLevelBlobPath(client(), indexName, new BlobPath(), "0", SEGMENTS, DATA, segmentsPathFixedPrefix)
+            .buildAsString();
         Path segmentDataRepoPath = location.resolve(shardPath);
         String segmentDataLocalPath = String.format(Locale.ROOT, "%s/indices/%s/0/index", response.getShards()[0].getDataPath(), indexUuid);
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRepositoryRegistrationIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRepositoryRegistrationIT.java
index b0827dcfe4892..4cbafde6417af 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRepositoryRegistrationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRepositoryRegistrationIT.java
@@ -131,13 +131,15 @@ public void testMultiNodeClusterRandomNodeRecoverNetworkIsolationPostNonRestrict
             .get(0);
         Settings.Builder updatedSettings = Settings.builder().put(repositoryMetadata.settings()).put("chunk_size", new ByteSizeValue(20));
         updatedSettings.remove("system_repository");
-
-        client.admin()
-            .cluster()
-            .preparePutRepository(repositoryMetadata.name())
-            .setType(repositoryMetadata.type())
-            .setSettings(updatedSettings)
-            .get();
+        OpenSearchIntegTestCase.putRepositoryRequestBuilder(
+            client.admin().cluster(),
+            repositoryMetadata.name(),
+            repositoryMetadata.type(),
+            true,
+            updatedSettings,
+            null,
+            false
+        ).get();
 
         ensureStableCluster(3, nodesInOneSide.stream().findAny().get());
         networkDisruption.stopDisrupting();
@@ -161,12 +163,7 @@ public void testNodeRestartPostNonRestrictedSettingsUpdate() throws Exception {
         Settings.Builder updatedSettings = Settings.builder().put(repositoryMetadata.settings()).put("chunk_size", new ByteSizeValue(20));
         updatedSettings.remove("system_repository");
 
-        client.admin()
-            .cluster()
-            .preparePutRepository(repositoryMetadata.name())
-            .setType(repositoryMetadata.type())
-            .setSettings(updatedSettings)
-            .get();
+        createRepository(repositoryMetadata.name(), repositoryMetadata.type(), updatedSettings);
 
         internalCluster().restartRandomDataNode();
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRestoreIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRestoreIT.java
index 195b2d18df7cc..8c7789846935d 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRestoreIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreRestoreIT.java
@@ -478,15 +478,7 @@ public void testRateLimitedRemoteDownloads() throws Exception {
         Settings.Builder settings = Settings.builder();
         settingsMap.entrySet().forEach(entry -> settings.put(entry.getKey(), entry.getValue()));
         settings.put("location", segmentRepoPath).put("max_remote_download_bytes_per_sec", 4, ByteSizeUnit.KB);
-
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository(REPOSITORY_NAME)
-                .setType(ReloadableFsRepository.TYPE)
-                .setSettings(settings)
-                .get()
-        );
+        createRepository(REPOSITORY_NAME, ReloadableFsRepository.TYPE, settings);
 
         for (RepositoriesService repositoriesService : internalCluster().getDataNodeInstances(RepositoriesService.class)) {
             Repository segmentRepo = repositoriesService.repository(REPOSITORY_NAME);
@@ -515,14 +507,7 @@ public void testRateLimitedRemoteDownloads() throws Exception {
         // revert repo metadata to pass asserts on repo metadata vs. node attrs during teardown
         // https://github.com/opensearch-project/OpenSearch/pull/9569#discussion_r1345668700
         settings.remove("max_remote_download_bytes_per_sec");
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository(REPOSITORY_NAME)
-                .setType(ReloadableFsRepository.TYPE)
-                .setSettings(settings)
-                .get()
-        );
+        createRepository(REPOSITORY_NAME, ReloadableFsRepository.TYPE, settings);
         for (RepositoriesService repositoriesService : internalCluster().getDataNodeInstances(RepositoriesService.class)) {
             Repository segmentRepo = repositoriesService.repository(REPOSITORY_NAME);
             assertNull(segmentRepo.getMetadata().settings().get("max_remote_download_bytes_per_sec"));
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreStatsIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreStatsIT.java
index 7715e19ef349d..5a831822f695d 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreStatsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/RemoteStoreStatsIT.java
@@ -29,6 +29,7 @@
 import org.opensearch.test.InternalTestCluster;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.disruption.NetworkDisruption;
+import org.opensearch.test.junit.annotations.TestLogging;
 import org.opensearch.test.transport.MockTransportService;
 
 import java.io.IOException;
@@ -257,6 +258,7 @@ public void testStatsResponseFromLocalNode() {
         }
     }
 
+    @TestLogging(reason = "Getting trace logs from remote store package", value = "org.opensearch.index.shard:TRACE")
     public void testDownloadStatsCorrectnessSinglePrimarySingleReplica() throws Exception {
         setup();
         // Scenario:
@@ -285,6 +287,15 @@ public void testDownloadStatsCorrectnessSinglePrimarySingleReplica() throws Exce
             .collect(Collectors.toList())
             .get(0)
             .getSegmentStats();
+        logger.info(
+            "Zero state primary stats: {}ms refresh time lag, {}b bytes lag, {}b upload bytes started, {}b upload bytes failed , {} uploads succeeded, {} upload byes succeeded.",
+            zeroStatePrimaryStats.refreshTimeLagMs,
+            zeroStatePrimaryStats.bytesLag,
+            zeroStatePrimaryStats.uploadBytesStarted,
+            zeroStatePrimaryStats.uploadBytesFailed,
+            zeroStatePrimaryStats.totalUploadsSucceeded,
+            zeroStatePrimaryStats.uploadBytesSucceeded
+        );
         assertTrue(
             zeroStatePrimaryStats.totalUploadsStarted == zeroStatePrimaryStats.totalUploadsSucceeded
                 && zeroStatePrimaryStats.totalUploadsSucceeded == 1
@@ -347,6 +358,7 @@ public void testDownloadStatsCorrectnessSinglePrimarySingleReplica() throws Exce
         }
     }
 
+    @TestLogging(reason = "Getting trace logs from remote store package", value = "org.opensearch.index.shard:TRACE")
     public void testDownloadStatsCorrectnessSinglePrimaryMultipleReplicaShards() throws Exception {
         setup();
         // Scenario:
@@ -379,6 +391,15 @@ public void testDownloadStatsCorrectnessSinglePrimaryMultipleReplicaShards() thr
             .collect(Collectors.toList())
             .get(0)
             .getSegmentStats();
+        logger.info(
+            "Zero state primary stats: {}ms refresh time lag, {}b bytes lag, {}b upload bytes started, {}b upload bytes failed , {} uploads succeeded, {} upload byes succeeded.",
+            zeroStatePrimaryStats.refreshTimeLagMs,
+            zeroStatePrimaryStats.bytesLag,
+            zeroStatePrimaryStats.uploadBytesStarted,
+            zeroStatePrimaryStats.uploadBytesFailed,
+            zeroStatePrimaryStats.totalUploadsSucceeded,
+            zeroStatePrimaryStats.uploadBytesSucceeded
+        );
         assertTrue(
             zeroStatePrimaryStats.totalUploadsStarted == zeroStatePrimaryStats.totalUploadsSucceeded
                 && zeroStatePrimaryStats.totalUploadsSucceeded == 1
@@ -608,7 +629,7 @@ public void testNonZeroPrimaryStatsOnNewlyCreatedIndexWithZeroDocs() throws Exce
                 }
                 assertZeroTranslogDownloadStats(translogStats);
             });
-        }, 5, TimeUnit.SECONDS);
+        }, 10, TimeUnit.SECONDS);
     }
 
     public void testStatsCorrectnessOnFailover() {
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/WritableWarmIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/WritableWarmIT.java
new file mode 100644
index 0000000000000..73510b1aebfe2
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/WritableWarmIT.java
@@ -0,0 +1,171 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.remotestore;
+
+import com.carrotsearch.randomizedtesting.annotations.ThreadLeakFilters;
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.FilterDirectory;
+import org.opensearch.action.admin.indices.delete.DeleteIndexRequest;
+import org.opensearch.action.admin.indices.get.GetIndexRequest;
+import org.opensearch.action.admin.indices.get.GetIndexResponse;
+import org.opensearch.action.search.SearchResponse;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsException;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.index.IndexModule;
+import org.opensearch.index.query.QueryBuilders;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.store.CompositeDirectory;
+import org.opensearch.index.store.remote.file.CleanerDaemonThreadLeakFilter;
+import org.opensearch.index.store.remote.filecache.FileCache;
+import org.opensearch.index.store.remote.utils.FileTypeUtils;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.node.Node;
+import org.opensearch.test.InternalTestCluster;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
+
+@ThreadLeakFilters(filters = CleanerDaemonThreadLeakFilter.class)
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0, supportsDedicatedMasters = false)
+// Uncomment the below line to enable trace level logs for this test for better debugging
+// @TestLogging(reason = "Getting trace logs from composite directory package", value = "org.opensearch.index.store:TRACE")
+public class WritableWarmIT extends RemoteStoreBaseIntegTestCase {
+
+    protected static final String INDEX_NAME = "test-idx-1";
+    protected static final int NUM_DOCS_IN_BULK = 1000;
+
+    /*
+    Disabling MockFSIndexStore plugin as the MockFSDirectoryFactory wraps the FSDirectory over a OpenSearchMockDirectoryWrapper which extends FilterDirectory (whereas FSDirectory extends BaseDirectory)
+    As a result of this wrapping the local directory of Composite Directory does not satisfy the assertion that local directory must be of type FSDirectory
+     */
+    @Override
+    protected boolean addMockIndexStorePlugin() {
+        return false;
+    }
+
+    @Override
+    protected Settings featureFlagSettings() {
+        Settings.Builder featureSettings = Settings.builder();
+        featureSettings.put(FeatureFlags.TIERED_REMOTE_INDEX, true);
+        return featureSettings.build();
+    }
+
+    @Override
+    protected Settings nodeSettings(int nodeOrdinal) {
+        ByteSizeValue cacheSize = new ByteSizeValue(16, ByteSizeUnit.GB);
+        return Settings.builder()
+            .put(super.nodeSettings(nodeOrdinal))
+            .put(Node.NODE_SEARCH_CACHE_SIZE_SETTING.getKey(), cacheSize.toString())
+            .build();
+    }
+
+    public void testWritableWarmFeatureFlagDisabled() {
+        Settings clusterSettings = Settings.builder().put(super.nodeSettings(0)).put(FeatureFlags.TIERED_REMOTE_INDEX, false).build();
+        InternalTestCluster internalTestCluster = internalCluster();
+        internalTestCluster.startClusterManagerOnlyNode(clusterSettings);
+        internalTestCluster.startDataAndSearchNodes(1);
+
+        Settings indexSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            .put(IndexModule.INDEX_STORE_LOCALITY_SETTING.getKey(), IndexModule.DataLocalityType.PARTIAL.name())
+            .build();
+
+        try {
+            prepareCreate(INDEX_NAME).setSettings(indexSettings).get();
+            fail("Should have thrown Exception as setting should not be registered if Feature Flag is Disabled");
+        } catch (SettingsException | IllegalArgumentException ex) {
+            assertEquals(
+                "unknown setting ["
+                    + IndexModule.INDEX_STORE_LOCALITY_SETTING.getKey()
+                    + "] please check that any required plugins are installed, or check the "
+                    + "breaking changes documentation for removed settings",
+                ex.getMessage()
+            );
+        }
+    }
+
+    public void testWritableWarmBasic() throws Exception {
+        InternalTestCluster internalTestCluster = internalCluster();
+        internalTestCluster.startClusterManagerOnlyNode();
+        internalTestCluster.startDataAndSearchNodes(1);
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            .put(IndexModule.INDEX_STORE_LOCALITY_SETTING.getKey(), IndexModule.DataLocalityType.PARTIAL.name())
+            .build();
+        assertAcked(client().admin().indices().prepareCreate(INDEX_NAME).setSettings(settings).get());
+
+        // Verify from the cluster settings if the data locality is partial
+        GetIndexResponse getIndexResponse = client().admin()
+            .indices()
+            .getIndex(new GetIndexRequest().indices(INDEX_NAME).includeDefaults(true))
+            .get();
+        Settings indexSettings = getIndexResponse.settings().get(INDEX_NAME);
+        assertEquals(IndexModule.DataLocalityType.PARTIAL.name(), indexSettings.get(IndexModule.INDEX_STORE_LOCALITY_SETTING.getKey()));
+
+        // Ingesting some docs
+        indexBulk(INDEX_NAME, NUM_DOCS_IN_BULK);
+        flushAndRefresh(INDEX_NAME);
+
+        // ensuring cluster is green after performing force-merge
+        ensureGreen();
+
+        SearchResponse searchResponse = client().prepareSearch(INDEX_NAME).setQuery(QueryBuilders.matchAllQuery()).get();
+        // Asserting that search returns same number of docs as ingested
+        assertHitCount(searchResponse, NUM_DOCS_IN_BULK);
+
+        // Ingesting docs again before force merge
+        indexBulk(INDEX_NAME, NUM_DOCS_IN_BULK);
+        flushAndRefresh(INDEX_NAME);
+
+        FileCache fileCache = internalTestCluster.getDataNodeInstance(Node.class).fileCache();
+        IndexShard shard = internalTestCluster.getDataNodeInstance(IndicesService.class)
+            .indexService(resolveIndex(INDEX_NAME))
+            .getShardOrNull(0);
+        Directory directory = (((FilterDirectory) (((FilterDirectory) (shard.store().directory())).getDelegate())).getDelegate());
+
+        // Force merging the index
+        Set<String> filesBeforeMerge = new HashSet<>(Arrays.asList(directory.listAll()));
+        client().admin().indices().prepareForceMerge(INDEX_NAME).setMaxNumSegments(1).get();
+        flushAndRefresh(INDEX_NAME);
+        Set<String> filesAfterMerge = new HashSet<>(Arrays.asList(directory.listAll()));
+
+        Set<String> filesFromPreviousGenStillPresent = filesBeforeMerge.stream()
+            .filter(filesAfterMerge::contains)
+            .filter(file -> !FileTypeUtils.isLockFile(file))
+            .filter(file -> !FileTypeUtils.isSegmentsFile(file))
+            .collect(Collectors.toUnmodifiableSet());
+
+        // Asserting that after merge all the files from previous gen are no more part of the directory
+        assertTrue(filesFromPreviousGenStillPresent.isEmpty());
+
+        // Asserting that files from previous gen are not present in File Cache as well
+        filesBeforeMerge.stream()
+            .filter(file -> !FileTypeUtils.isLockFile(file))
+            .filter(file -> !FileTypeUtils.isSegmentsFile(file))
+            .forEach(file -> assertNull(fileCache.get(((CompositeDirectory) directory).getFilePath(file))));
+
+        // Deleting the index (so that ref count drops to zero for all the files) and then pruning the cache to clear it to avoid any file
+        // leaks
+        assertAcked(client().admin().indices().delete(new DeleteIndexRequest(INDEX_NAME)).get());
+        fileCache.prune();
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/RemoteStoreMultipartIT.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/RemoteStoreMultipartIT.java
index 3dfde6f472525..99cc58848a04a 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/RemoteStoreMultipartIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/multipart/RemoteStoreMultipartIT.java
@@ -31,7 +31,6 @@
 
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
-import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
 
@@ -119,19 +118,12 @@ public void testRateLimitedRemoteUploads() throws Exception {
         internalCluster().startNode(clusterSettings.build());
         Client client = client();
         logger.info("-->  updating repository");
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository(REPOSITORY_NAME)
-                .setType(MockFsRepositoryPlugin.TYPE)
-                .setSettings(
-                    Settings.builder()
-                        .put("location", repositoryLocation)
-                        .put("compress", compress)
-                        .put("max_remote_upload_bytes_per_sec", "1kb")
-                        .put("chunk_size", 100, ByteSizeUnit.BYTES)
-                )
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", repositoryLocation)
+            .put("compress", compress)
+            .put("max_remote_upload_bytes_per_sec", "1kb")
+            .put("chunk_size", 100, ByteSizeUnit.BYTES);
+        createRepository(REPOSITORY_NAME, MockFsRepositoryPlugin.TYPE, settings);
 
         createIndex(INDEX_NAME, remoteStoreIndexSettings(0));
         ensureGreen();
diff --git a/server/src/internalClusterTest/java/org/opensearch/remotestore/translogmetadata/mocks/MockFsMetadataSupportedRepository.java b/server/src/internalClusterTest/java/org/opensearch/remotestore/translogmetadata/mocks/MockFsMetadataSupportedRepository.java
index 333fba413ce4e..1abacbe5091dd 100644
--- a/server/src/internalClusterTest/java/org/opensearch/remotestore/translogmetadata/mocks/MockFsMetadataSupportedRepository.java
+++ b/server/src/internalClusterTest/java/org/opensearch/remotestore/translogmetadata/mocks/MockFsMetadataSupportedRepository.java
@@ -16,9 +16,9 @@
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.env.Environment;
 import org.opensearch.indices.recovery.RecoverySettings;
-import org.opensearch.repositories.fs.FsRepository;
+import org.opensearch.repositories.fs.ReloadableFsRepository;
 
-public class MockFsMetadataSupportedRepository extends FsRepository {
+public class MockFsMetadataSupportedRepository extends ReloadableFsRepository {
 
     public static Setting<Boolean> TRIGGER_DATA_INTEGRITY_FAILURE = Setting.boolSetting(
         "mock_fs_repository.trigger_data_integrity_failure",
diff --git a/server/src/internalClusterTest/java/org/opensearch/repositories/RepositoriesServiceIT.java b/server/src/internalClusterTest/java/org/opensearch/repositories/RepositoriesServiceIT.java
index b8415f4b41815..e4347fef744ab 100644
--- a/server/src/internalClusterTest/java/org/opensearch/repositories/RepositoriesServiceIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/repositories/RepositoriesServiceIT.java
@@ -45,7 +45,6 @@
 import java.util.Collection;
 import java.util.Collections;
 
-import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.instanceOf;
@@ -70,9 +69,12 @@ public void testUpdateRepository() {
             .next();
 
         final Settings.Builder repoSettings = Settings.builder().put("location", randomRepoPath());
-
-        assertAcked(
-            client.admin().cluster().preparePutRepository(repositoryName).setType(FsRepository.TYPE).setSettings(repoSettings).get()
+        OpenSearchIntegTestCase.putRepositoryWithNoSettingOverrides(
+            client().admin().cluster(),
+            repositoryName,
+            FsRepository.TYPE,
+            true,
+            repoSettings
         );
 
         final GetRepositoriesResponse originalGetRepositoriesResponse = client.admin()
@@ -91,8 +93,12 @@ public void testUpdateRepository() {
         final boolean updated = randomBoolean();
         final String updatedRepositoryType = updated ? "mock" : FsRepository.TYPE;
 
-        assertAcked(
-            client.admin().cluster().preparePutRepository(repositoryName).setType(updatedRepositoryType).setSettings(repoSettings).get()
+        OpenSearchIntegTestCase.putRepositoryWithNoSettingOverrides(
+            client().admin().cluster(),
+            repositoryName,
+            updatedRepositoryType,
+            true,
+            repoSettings
         );
 
         final GetRepositoriesResponse updatedGetRepositoriesResponse = client.admin()
@@ -112,12 +118,8 @@ public void testUpdateRepository() {
     public void testSystemRepositoryCantBeCreated() {
         internalCluster();
         final String repositoryName = "test-repo";
-        final Client client = client();
         final Settings.Builder repoSettings = Settings.builder().put("system_repository", true).put("location", randomRepoPath());
 
-        assertThrows(
-            RepositoryException.class,
-            () -> client.admin().cluster().preparePutRepository(repositoryName).setType(FsRepository.TYPE).setSettings(repoSettings).get()
-        );
+        assertThrows(RepositoryException.class, () -> createRepository(repositoryName, FsRepository.TYPE, repoSettings));
     }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/repositories/fs/FsBlobStoreRepositoryIT.java b/server/src/internalClusterTest/java/org/opensearch/repositories/fs/FsBlobStoreRepositoryIT.java
index 9057ef900efbd..34075b78e98af 100644
--- a/server/src/internalClusterTest/java/org/opensearch/repositories/fs/FsBlobStoreRepositoryIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/repositories/fs/FsBlobStoreRepositoryIT.java
@@ -76,19 +76,11 @@ public void testMissingDirectoriesNotCreatedInReadonlyRepository() throws IOExce
         final Path repoPath = randomRepoPath();
 
         logger.info("--> creating repository {} at {}", repoName, repoPath);
-
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository(repoName)
-                .setType("fs")
-                .setSettings(
-                    Settings.builder()
-                        .put("location", repoPath)
-                        .put("compress", randomBoolean())
-                        .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
-                )
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", repoPath)
+            .put("compress", randomBoolean())
+            .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES);
+        createRepository(repoName, "fs", settings);
 
         final String indexName = randomName();
         int docCount = iterations(10, 1000);
@@ -112,14 +104,7 @@ public void testMissingDirectoriesNotCreatedInReadonlyRepository() throws IOExce
             IOUtils.rm(deletedPath);
         }
         assertFalse(Files.exists(deletedPath));
-
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository(repoName)
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", repoPath).put("readonly", true))
-        );
+        createRepository(repoName, "fs", Settings.builder().put("location", repoPath).put("readonly", true));
 
         final OpenSearchException exception = expectThrows(
             OpenSearchException.class,
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/AggregationsIntegrationIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/AggregationsIntegrationIT.java
index 4a8b00ea45738..01f3b434bc4dc 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/AggregationsIntegrationIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/AggregationsIntegrationIT.java
@@ -57,7 +57,10 @@
 import java.util.Collection;
 import java.util.List;
 
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.global;
 import static org.opensearch.search.aggregations.AggregationBuilders.stats;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
@@ -81,8 +84,12 @@ public AggregationsIntegrationIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
@@ -187,4 +194,27 @@ public void testAggsOnEmptyShards() {
         // Validate non-global agg does not throw an exception
         assertSearchResponse(client().prepareSearch("idx").addAggregation(stats("value_stats").field("score")).get());
     }
+
+    public void testAggsWithTerminateAfter() throws InterruptedException {
+        assertAcked(
+            prepareCreate(
+                "terminate_index",
+                Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+            ).setMapping("f", "type=keyword").get()
+        );
+        List<IndexRequestBuilder> docs = new ArrayList<>();
+        for (int i = 0; i < randomIntBetween(5, 20); ++i) {
+            docs.add(client().prepareIndex("terminate_index").setSource("f", Integer.toString(i / 3)));
+        }
+        indexRandom(true, docs);
+
+        SearchResponse response = client().prepareSearch("terminate_index")
+            .setSize(2)
+            .setTerminateAfter(1)
+            .addAggregation(terms("f").field("f"))
+            .get();
+        assertSearchResponse(response);
+        assertTrue(response.isTerminatedEarly());
+        assertEquals(response.getHits().getHits().length, 1);
+    }
 }
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/CombiIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/CombiIT.java
index 1826dd69cd804..4ce74f8195da9 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/CombiIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/CombiIT.java
@@ -51,7 +51,10 @@
 import java.util.Map;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.missing;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
@@ -69,8 +72,12 @@ public CombiIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/EquivalenceIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/EquivalenceIT.java
index 302ec3116d187..2fcf09d6ebf50 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/EquivalenceIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/EquivalenceIT.java
@@ -72,7 +72,10 @@
 import java.util.function.Function;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.extendedStats;
 import static org.opensearch.search.aggregations.AggregationBuilders.filter;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
@@ -102,8 +105,12 @@ public EquivalenceIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/MetadataIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/MetadataIT.java
index b650855083eed..ca13b4de00156 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/MetadataIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/MetadataIT.java
@@ -49,7 +49,10 @@
 import java.util.Map;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
 import static org.opensearch.search.aggregations.PipelineAggregatorBuilders.maxBucket;
@@ -65,8 +68,12 @@ public MetadataIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/MissingValueIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/MissingValueIT.java
index bdd16c7e74dc0..1310792e2f2e4 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/MissingValueIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/MissingValueIT.java
@@ -51,7 +51,10 @@
 import java.util.Arrays;
 import java.util.Collection;
 
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.cardinality;
 import static org.opensearch.search.aggregations.AggregationBuilders.dateHistogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.geoCentroid;
@@ -73,8 +76,12 @@ public MissingValueIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/bucket/terms/StringTermsIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/bucket/terms/StringTermsIT.java
index edf9cd432dda2..f5d018b2ef491 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/bucket/terms/StringTermsIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/bucket/terms/StringTermsIT.java
@@ -42,10 +42,12 @@
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.script.Script;
 import org.opensearch.script.ScriptType;
+import org.opensearch.search.aggregations.AggregationBuilders;
 import org.opensearch.search.aggregations.AggregationExecutionException;
 import org.opensearch.search.aggregations.Aggregator.SubAggCollectionMode;
 import org.opensearch.search.aggregations.BucketOrder;
 import org.opensearch.search.aggregations.bucket.filter.Filter;
+import org.opensearch.search.aggregations.bucket.filter.InternalFilters;
 import org.opensearch.search.aggregations.bucket.terms.Terms.Bucket;
 import org.opensearch.search.aggregations.metrics.Avg;
 import org.opensearch.search.aggregations.metrics.ExtendedStats;
@@ -999,6 +1001,72 @@ public void testOtherDocCount() {
         testOtherDocCount(SINGLE_VALUED_FIELD_NAME, MULTI_VALUED_FIELD_NAME);
     }
 
+    public void testDeferredSubAggs() {
+        // Tests subAgg doc count is the same with different collection modes and additional top level aggs
+        SearchResponse r1 = client().prepareSearch("idx")
+            .setSize(0)
+            .addAggregation(
+                terms("terms1").collectMode(SubAggCollectionMode.BREADTH_FIRST)
+                    .field("s_value")
+                    .size(2)
+                    .subAggregation(AggregationBuilders.filters("filter", QueryBuilders.boolQuery()))
+            )
+            .addAggregation(AggregationBuilders.min("min").field("constant"))
+            .get();
+
+        SearchResponse r2 = client().prepareSearch("idx")
+            .setSize(0)
+            .addAggregation(
+                terms("terms1").collectMode(SubAggCollectionMode.DEPTH_FIRST)
+                    .field("s_value")
+                    .size(2)
+                    .subAggregation(AggregationBuilders.filters("filter", QueryBuilders.boolQuery()))
+            )
+            .addAggregation(AggregationBuilders.min("min").field("constant"))
+            .get();
+
+        SearchResponse r3 = client().prepareSearch("idx")
+            .setSize(0)
+            .addAggregation(
+                terms("terms1").collectMode(SubAggCollectionMode.BREADTH_FIRST)
+                    .field("s_value")
+                    .size(2)
+                    .subAggregation(AggregationBuilders.filters("filter", QueryBuilders.boolQuery()))
+            )
+            .get();
+
+        SearchResponse r4 = client().prepareSearch("idx")
+            .setSize(0)
+            .addAggregation(
+                terms("terms1").collectMode(SubAggCollectionMode.DEPTH_FIRST)
+                    .field("s_value")
+                    .size(2)
+                    .subAggregation(AggregationBuilders.filters("filter", QueryBuilders.boolQuery()))
+            )
+            .get();
+
+        assertNotNull(r1.getAggregations().get("terms1"));
+        assertNotNull(r2.getAggregations().get("terms1"));
+        assertNotNull(r3.getAggregations().get("terms1"));
+        assertNotNull(r4.getAggregations().get("terms1"));
+
+        Terms terms = r1.getAggregations().get("terms1");
+        Bucket b1 = terms.getBucketByKey("val0");
+        InternalFilters f1 = b1.getAggregations().get("filter");
+        long docCount1 = f1.getBuckets().get(0).getDocCount();
+        Bucket b2 = terms.getBucketByKey("val1");
+        InternalFilters f2 = b2.getAggregations().get("filter");
+        long docCount2 = f1.getBuckets().get(0).getDocCount();
+
+        for (SearchResponse response : new SearchResponse[] { r2, r3, r4 }) {
+            terms = response.getAggregations().get("terms1");
+            f1 = terms.getBucketByKey(b1.getKeyAsString()).getAggregations().get("filter");
+            f2 = terms.getBucketByKey(b2.getKeyAsString()).getAggregations().get("filter");
+            assertEquals(docCount1, f1.getBuckets().get(0).getDocCount());
+            assertEquals(docCount2, f2.getBuckets().get(0).getDocCount());
+        }
+    }
+
     /**
      * Make sure that a request using a deterministic script or not using a script get cached.
      * Ensure requests using nondeterministic scripts do not get cached.
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/metrics/CardinalityIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/metrics/CardinalityIT.java
index db4ee3571d141..b2ed689622e7d 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/metrics/CardinalityIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/metrics/CardinalityIT.java
@@ -34,6 +34,7 @@
 
 import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
 
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsResponse;
 import org.opensearch.action.index.IndexRequestBuilder;
 import org.opensearch.action.search.SearchResponse;
 import org.opensearch.common.settings.Settings;
@@ -59,6 +60,7 @@
 import static java.util.Collections.emptyMap;
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
 import static org.opensearch.index.query.QueryBuilders.matchAllQuery;
+import static org.opensearch.search.SearchService.CARDINALITY_AGGREGATION_PRUNING_THRESHOLD;
 import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
 import static org.opensearch.search.aggregations.AggregationBuilders.cardinality;
 import static org.opensearch.search.aggregations.AggregationBuilders.global;
@@ -255,6 +257,36 @@ public void testSingleValuedString() throws Exception {
         assertCount(count, numDocs);
     }
 
+    public void testDisableDynamicPruning() throws Exception {
+        SearchResponse response = client().prepareSearch("idx")
+            .addAggregation(cardinality("cardinality").precisionThreshold(precisionThreshold).field("str_value"))
+            .get();
+        assertSearchResponse(response);
+
+        Cardinality count1 = response.getAggregations().get("cardinality");
+
+        final ClusterUpdateSettingsResponse updateSettingResponse = client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(Settings.builder().put(CARDINALITY_AGGREGATION_PRUNING_THRESHOLD.getKey(), 0))
+            .get();
+        assertEquals(updateSettingResponse.getTransientSettings().get(CARDINALITY_AGGREGATION_PRUNING_THRESHOLD.getKey()), "0");
+
+        response = client().prepareSearch("idx")
+            .addAggregation(cardinality("cardinality").precisionThreshold(precisionThreshold).field("str_value"))
+            .get();
+        assertSearchResponse(response);
+        Cardinality count2 = response.getAggregations().get("cardinality");
+
+        assertEquals(count1, count2);
+
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(Settings.builder().putNull(CARDINALITY_AGGREGATION_PRUNING_THRESHOLD.getKey()))
+            .get();
+    }
+
     public void testSingleValuedNumeric() throws Exception {
         SearchResponse response = client().prepareSearch("idx")
             .addAggregation(cardinality("cardinality").precisionThreshold(precisionThreshold).field(singleNumericField()))
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/AvgBucketIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/AvgBucketIT.java
index 48fd06bac285b..7e1cae8e5b628 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/AvgBucketIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/AvgBucketIT.java
@@ -53,7 +53,10 @@
 import java.util.List;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
@@ -83,8 +86,12 @@ public AvgBucketIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketScriptIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketScriptIT.java
index 1b22cf2018d96..204aaa764849f 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketScriptIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketScriptIT.java
@@ -63,7 +63,10 @@
 import java.util.function.Function;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.dateRange;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
@@ -96,8 +99,12 @@ public BucketScriptIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketSelectorIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketSelectorIT.java
index 7dca1d0d79b1e..7677cfdac3e29 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketSelectorIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketSelectorIT.java
@@ -62,7 +62,10 @@
 import java.util.function.Function;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.PipelineAggregatorBuilders.bucketSelector;
@@ -95,8 +98,12 @@ public BucketSelectorIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketSortIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketSortIT.java
index ffb607866935b..cd489e5b982e6 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketSortIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/BucketSortIT.java
@@ -58,7 +58,10 @@
 import java.util.List;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.avg;
 import static org.opensearch.search.aggregations.AggregationBuilders.dateHistogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
@@ -91,8 +94,12 @@ public BucketSortIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/DateDerivativeIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/DateDerivativeIT.java
index 8c89c1232ebb3..fc4c76f513f1d 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/DateDerivativeIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/DateDerivativeIT.java
@@ -63,7 +63,10 @@
 import java.util.List;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.dateHistogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.PipelineAggregatorBuilders.derivative;
@@ -89,8 +92,12 @@ public DateDerivativeIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/DerivativeIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/DerivativeIT.java
index f8def40ec003a..6fabbb32a4d15 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/DerivativeIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/DerivativeIT.java
@@ -61,7 +61,10 @@
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
 import static org.opensearch.index.query.QueryBuilders.matchAllQuery;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.avg;
 import static org.opensearch.search.aggregations.AggregationBuilders.filters;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
@@ -106,8 +109,12 @@ public DerivativeIT(Settings dynamicSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/ExtendedStatsBucketIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/ExtendedStatsBucketIT.java
index 1bd04cc13268f..06d46e80f9710 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/ExtendedStatsBucketIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/ExtendedStatsBucketIT.java
@@ -56,7 +56,10 @@
 import java.util.List;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
@@ -86,8 +89,12 @@ public ExtendedStatsBucketIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MaxBucketIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MaxBucketIT.java
index f646c06aba556..7805e0bac4c0b 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MaxBucketIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MaxBucketIT.java
@@ -66,7 +66,10 @@
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
 import static org.opensearch.index.query.QueryBuilders.termQuery;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.filter;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
@@ -97,8 +100,12 @@ public MaxBucketIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MinBucketIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MinBucketIT.java
index b92e086e0f20b..e1e8d8b035ae1 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MinBucketIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MinBucketIT.java
@@ -53,7 +53,10 @@
 import java.util.List;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
@@ -83,8 +86,12 @@ public MinBucketIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MovAvgIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MovAvgIT.java
index d35b80b7918fe..e481e48cf6188 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MovAvgIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/MovAvgIT.java
@@ -61,7 +61,10 @@
 import java.util.Map;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.avg;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.max;
@@ -139,8 +142,12 @@ public MovAvgIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/PercentilesBucketIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/PercentilesBucketIT.java
index 29cb334bfcd00..592a151781048 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/PercentilesBucketIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/PercentilesBucketIT.java
@@ -56,7 +56,10 @@
 import java.util.List;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
@@ -86,8 +89,12 @@ public PercentilesBucketIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/SerialDiffIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/SerialDiffIT.java
index 507bff51f0e39..2a412bc0f7720 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/SerialDiffIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/SerialDiffIT.java
@@ -54,7 +54,10 @@
 import java.util.Map;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.avg;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.max;
@@ -104,8 +107,12 @@ public SerialDiffIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/StatsBucketIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/StatsBucketIT.java
index fbaf799871c8a..4e52e6e706324 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/StatsBucketIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/StatsBucketIT.java
@@ -53,7 +53,10 @@
 import java.util.List;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
@@ -82,8 +85,12 @@ public StatsBucketIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/SumBucketIT.java b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/SumBucketIT.java
index a5967124ff921..55652877d3f4b 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/SumBucketIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/aggregations/pipeline/SumBucketIT.java
@@ -53,7 +53,10 @@
 import java.util.List;
 
 import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
-import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.aggregations.AggregationBuilders.histogram;
 import static org.opensearch.search.aggregations.AggregationBuilders.sum;
 import static org.opensearch.search.aggregations.AggregationBuilders.terms;
@@ -83,8 +86,12 @@ public SumBucketIT(Settings staticSettings) {
     @ParametersFactory
     public static Collection<Object[]> parameters() {
         return Arrays.asList(
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), false).build() },
-            new Object[] { Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build() }
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_ALL).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build() },
+            new Object[] {
+                Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_NONE).build() }
         );
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/pit/PitMultiNodeIT.java b/server/src/internalClusterTest/java/org/opensearch/search/pit/PitMultiNodeIT.java
index e54c9577241a9..002ad61a4fe09 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/pit/PitMultiNodeIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/pit/PitMultiNodeIT.java
@@ -102,7 +102,7 @@ public void testPit() throws Exception {
         assertEquals(2, searchResponse.getSuccessfulShards());
         assertEquals(2, searchResponse.getTotalShards());
         validatePitStats("index", 2, 2);
-        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime());
+        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime(), TimeValue.timeValueDays(1));
         assertSegments(false, client(), pitResponse.getId());
     }
 
@@ -129,7 +129,12 @@ public void testCreatePitWhileNodeDropWithAllowPartialCreationTrue() throws Exce
             public Settings onNodeStopped(String nodeName) throws Exception {
                 ActionFuture<CreatePitResponse> execute = client().execute(CreatePitAction.INSTANCE, request);
                 CreatePitResponse pitResponse = execute.get();
-                PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime());
+                PitTestsUtil.assertUsingGetAllPits(
+                    client(),
+                    pitResponse.getId(),
+                    pitResponse.getCreationTime(),
+                    TimeValue.timeValueDays(1)
+                );
                 assertSegments(false, "index", 1, client(), pitResponse.getId());
                 assertEquals(1, pitResponse.getSuccessfulShards());
                 assertEquals(2, pitResponse.getTotalShards());
@@ -162,7 +167,12 @@ public Settings onNodeStopped(String nodeName) throws Exception {
                 assertEquals(0, searchResponse.getSkippedShards());
                 assertEquals(2, searchResponse.getTotalShards());
                 validatePitStats("index", 1, 1);
-                PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime());
+                PitTestsUtil.assertUsingGetAllPits(
+                    client(),
+                    pitResponse.getId(),
+                    pitResponse.getCreationTime(),
+                    TimeValue.timeValueDays(1)
+                );
                 return super.onNodeStopped(nodeName);
             }
         });
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/query/QueryStringIT.java b/server/src/internalClusterTest/java/org/opensearch/search/query/QueryStringIT.java
index c43a9c23661ea..8841638328ea4 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/query/QueryStringIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/query/QueryStringIT.java
@@ -45,7 +45,7 @@
 import org.opensearch.index.query.QueryStringQueryBuilder;
 import org.opensearch.search.SearchHit;
 import org.opensearch.search.SearchHits;
-import org.opensearch.search.SearchModule;
+import org.opensearch.search.SearchService;
 import org.opensearch.test.ParameterizedStaticSettingsOpenSearchIntegTestCase;
 import org.junit.Before;
 import org.junit.BeforeClass;
@@ -101,7 +101,7 @@ public void setup() throws Exception {
     protected Settings nodeSettings(int nodeOrdinal) {
         return Settings.builder()
             .put(super.nodeSettings(nodeOrdinal))
-            .put(SearchModule.INDICES_MAX_CLAUSE_COUNT_SETTING.getKey(), CLUSTER_MAX_CLAUSE_COUNT)
+            .put(SearchService.INDICES_MAX_CLAUSE_COUNT_SETTING.getKey(), CLUSTER_MAX_CLAUSE_COUNT)
             .build();
     }
 
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/query/SearchQueryIT.java b/server/src/internalClusterTest/java/org/opensearch/search/query/SearchQueryIT.java
index a58db51780826..1933d9ebfdc6c 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/query/SearchQueryIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/query/SearchQueryIT.java
@@ -52,6 +52,7 @@
 import org.opensearch.common.time.DateFormatter;
 import org.opensearch.common.unit.Fuzziness;
 import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.rest.RestStatus;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.XContentBuilder;
@@ -66,6 +67,7 @@
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.index.query.RangeQueryBuilder;
 import org.opensearch.index.query.TermQueryBuilder;
+import org.opensearch.index.query.TermsQueryBuilder;
 import org.opensearch.index.query.WildcardQueryBuilder;
 import org.opensearch.index.query.WrapperQueryBuilder;
 import org.opensearch.index.query.functionscore.ScoreFunctionBuilders;
@@ -84,6 +86,7 @@
 
 import java.io.IOException;
 import java.io.Reader;
+import java.nio.ByteBuffer;
 import java.time.Instant;
 import java.time.ZoneId;
 import java.time.ZoneOffset;
@@ -98,6 +101,8 @@
 import java.util.concurrent.ExecutionException;
 import java.util.regex.Pattern;
 
+import org.roaringbitmap.RoaringBitmap;
+
 import static java.util.Collections.singletonMap;
 import static org.opensearch.action.support.WriteRequest.RefreshPolicy.IMMEDIATE;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
@@ -1157,6 +1162,41 @@ public void testTermsQuery() throws Exception {
         assertHitCount(searchResponse, 0L);
     }
 
+    public void testTermsQueryWithBitmapDocValuesQuery() throws Exception {
+        assertAcked(
+            prepareCreate("products").setMapping(
+                jsonBuilder().startObject()
+                    .startObject("properties")
+                    .startObject("product")
+                    .field("type", "integer")
+                    .field("index", false)
+                    .endObject()
+                    .endObject()
+                    .endObject()
+            )
+        );
+        indexRandom(
+            true,
+            client().prepareIndex("products").setId("1").setSource("product", 1),
+            client().prepareIndex("products").setId("2").setSource("product", 2),
+            client().prepareIndex("products").setId("3").setSource("product", new int[] { 1, 3 }),
+            client().prepareIndex("products").setId("4").setSource("product", 4)
+        );
+
+        RoaringBitmap r = new RoaringBitmap();
+        r.add(1);
+        r.add(4);
+        byte[] array = new byte[r.serializedSizeInBytes()];
+        r.serialize(ByteBuffer.wrap(array));
+        BytesArray bitmap = new BytesArray(array);
+        // directly building the terms query builder, so pass in the bitmap value as BytesArray
+        SearchResponse searchResponse = client().prepareSearch("products")
+            .setQuery(constantScoreQuery(termsQuery("product", bitmap).valueType(TermsQueryBuilder.ValueType.BITMAP)))
+            .get();
+        assertHitCount(searchResponse, 3L);
+        assertSearchHits(searchResponse, "1", "3", "4");
+    }
+
     public void testTermsLookupFilter() throws Exception {
         assertAcked(prepareCreate("lookup").setMapping("terms", "type=text", "other", "type=text"));
         indexRandomForConcurrentSearch("lookup");
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/query/SimpleQueryStringIT.java b/server/src/internalClusterTest/java/org/opensearch/search/query/SimpleQueryStringIT.java
index cae543506f919..f9ccdbd62de1c 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/query/SimpleQueryStringIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/query/SimpleQueryStringIT.java
@@ -57,7 +57,7 @@
 import org.opensearch.plugins.Plugin;
 import org.opensearch.search.SearchHit;
 import org.opensearch.search.SearchHits;
-import org.opensearch.search.SearchModule;
+import org.opensearch.search.SearchService;
 import org.opensearch.search.builder.SearchSourceBuilder;
 import org.opensearch.test.ParameterizedStaticSettingsOpenSearchIntegTestCase;
 import org.junit.BeforeClass;
@@ -79,6 +79,7 @@
 import static org.opensearch.index.query.QueryBuilders.simpleQueryStringQuery;
 import static org.opensearch.index.query.QueryBuilders.termQuery;
 import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.INDICES_MAX_CLAUSE_COUNT_SETTING;
 import static org.opensearch.test.StreamsUtils.copyToStringFromClasspath;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertFailures;
@@ -122,7 +123,7 @@ public static void createRandomClusterSetting() {
     protected Settings nodeSettings(int nodeOrdinal) {
         return Settings.builder()
             .put(super.nodeSettings(nodeOrdinal))
-            .put(SearchModule.INDICES_MAX_CLAUSE_COUNT_SETTING.getKey(), CLUSTER_MAX_CLAUSE_COUNT)
+            .put(SearchService.INDICES_MAX_CLAUSE_COUNT_SETTING.getKey(), CLUSTER_MAX_CLAUSE_COUNT)
             .build();
     }
 
@@ -720,6 +721,52 @@ public void testFieldAliasOnDisallowedFieldType() throws Exception {
         assertHits(response.getHits(), "1");
     }
 
+    public void testDynamicClauseCountUpdate() throws Exception {
+        client().prepareIndex("testdynamic").setId("1").setSource("field", "foo bar baz").get();
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().put(INDICES_MAX_CLAUSE_COUNT_SETTING.getKey(), CLUSTER_MAX_CLAUSE_COUNT - 1))
+        );
+        refresh();
+        StringBuilder sb = new StringBuilder("foo");
+
+        // create clause_count + 1 clauses to hit error
+        for (int i = 0; i <= CLUSTER_MAX_CLAUSE_COUNT; i++) {
+            sb.append(" OR foo" + i);
+        }
+
+        QueryStringQueryBuilder qb = queryStringQuery(sb.toString()).field("field");
+
+        SearchPhaseExecutionException e = expectThrows(SearchPhaseExecutionException.class, () -> {
+            client().prepareSearch("testdynamic").setQuery(qb).get();
+        });
+
+        assert (e.getDetailedMessage().contains("maxClauseCount is set to " + (CLUSTER_MAX_CLAUSE_COUNT - 1)));
+
+        // increase clause count by 2
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().put(INDICES_MAX_CLAUSE_COUNT_SETTING.getKey(), CLUSTER_MAX_CLAUSE_COUNT + 2))
+        );
+
+        Thread.sleep(1);
+
+        SearchResponse response = client().prepareSearch("testdynamic").setQuery(qb).get();
+        assertHitCount(response, 1);
+        assertHits(response.getHits(), "1");
+
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().putNull(INDICES_MAX_CLAUSE_COUNT_SETTING.getKey()))
+        );
+    }
+
     private void assertHits(SearchHits hits, String... ids) {
         assertThat(hits.getTotalHits().value, equalTo((long) ids.length));
         Set<String> hitIds = new HashSet<>();
diff --git a/server/src/internalClusterTest/java/org/opensearch/search/sort/FieldSortIT.java b/server/src/internalClusterTest/java/org/opensearch/search/sort/FieldSortIT.java
index e40928f15e8a8..fdb12639c65be 100644
--- a/server/src/internalClusterTest/java/org/opensearch/search/sort/FieldSortIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/search/sort/FieldSortIT.java
@@ -42,6 +42,7 @@
 import org.opensearch.action.bulk.BulkRequestBuilder;
 import org.opensearch.action.index.IndexRequestBuilder;
 import org.opensearch.action.search.SearchPhaseExecutionException;
+import org.opensearch.action.search.SearchRequestBuilder;
 import org.opensearch.action.search.SearchResponse;
 import org.opensearch.action.search.ShardSearchFailure;
 import org.opensearch.cluster.metadata.IndexMetadata;
@@ -90,6 +91,7 @@
 import static org.opensearch.script.MockScriptPlugin.NAME;
 import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertFailures;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertFirstHit;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertHitCount;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertNoFailures;
@@ -919,7 +921,7 @@ public void testSortMissingNumbers() throws Exception {
         client().prepareIndex("test")
             .setId("3")
             .setSource(
-                jsonBuilder().startObject().field("id", "3").field("i_value", 2).field("d_value", 2.2).field("u_value", 2).endObject()
+                jsonBuilder().startObject().field("id", "3").field("i_value", 2).field("d_value", 2.2).field("u_value", 3).endObject()
             )
             .get();
 
@@ -964,6 +966,18 @@ public void testSortMissingNumbers() throws Exception {
         assertThat(searchResponse.getHits().getAt(1).getId(), equalTo("1"));
         assertThat(searchResponse.getHits().getAt(2).getId(), equalTo("3"));
 
+        logger.info("--> sort with custom missing value");
+        searchResponse = client().prepareSearch()
+            .setQuery(matchAllQuery())
+            .addSort(SortBuilders.fieldSort("i_value").order(SortOrder.ASC).missing(randomBoolean() ? 1 : "1"))
+            .get();
+        assertNoFailures(searchResponse);
+
+        assertThat(searchResponse.getHits().getTotalHits().value, equalTo(3L));
+        assertThat(searchResponse.getHits().getAt(0).getId(), equalTo("1"));
+        assertThat(searchResponse.getHits().getAt(1).getId(), equalTo("2"));
+        assertThat(searchResponse.getHits().getAt(2).getId(), equalTo("3"));
+
         // FLOAT
         logger.info("--> sort with no missing (same as missing _last)");
         searchResponse = client().prepareSearch()
@@ -1001,6 +1015,18 @@ public void testSortMissingNumbers() throws Exception {
         assertThat(searchResponse.getHits().getAt(1).getId(), equalTo("1"));
         assertThat(searchResponse.getHits().getAt(2).getId(), equalTo("3"));
 
+        logger.info("--> sort with custom missing value");
+        searchResponse = client().prepareSearch()
+            .setQuery(matchAllQuery())
+            .addSort(SortBuilders.fieldSort("d_value").order(SortOrder.ASC).missing(randomBoolean() ? 1.1 : "1.1"))
+            .get();
+        assertNoFailures(searchResponse);
+
+        assertThat(searchResponse.getHits().getTotalHits().value, equalTo(3L));
+        assertThat(searchResponse.getHits().getAt(0).getId(), equalTo("1"));
+        assertThat(searchResponse.getHits().getAt(1).getId(), equalTo("2"));
+        assertThat(searchResponse.getHits().getAt(2).getId(), equalTo("3"));
+
         // UNSIGNED_LONG
         logger.info("--> sort with no missing (same as missing _last)");
         searchResponse = client().prepareSearch()
@@ -1037,6 +1063,24 @@ public void testSortMissingNumbers() throws Exception {
         assertThat(searchResponse.getHits().getAt(0).getId(), equalTo("2"));
         assertThat(searchResponse.getHits().getAt(1).getId(), equalTo("1"));
         assertThat(searchResponse.getHits().getAt(2).getId(), equalTo("3"));
+
+        logger.info("--> sort with custom missing value");
+        searchResponse = client().prepareSearch()
+            .setQuery(matchAllQuery())
+            .addSort(SortBuilders.fieldSort("u_value").order(SortOrder.ASC).missing(randomBoolean() ? 2 : "2"))
+            .get();
+        assertNoFailures(searchResponse);
+
+        assertThat(searchResponse.getHits().getTotalHits().value, equalTo(3L));
+        assertThat(searchResponse.getHits().getAt(0).getId(), equalTo("1"));
+        assertThat(searchResponse.getHits().getAt(1).getId(), equalTo("2"));
+        assertThat(searchResponse.getHits().getAt(2).getId(), equalTo("3"));
+
+        logger.info("--> sort with negative missing value");
+        SearchRequestBuilder searchRequestBuilder = client().prepareSearch()
+            .setQuery(matchAllQuery())
+            .addSort(SortBuilders.fieldSort("u_value").order(SortOrder.ASC).missing(randomBoolean() ? -1 : "-1"));
+        assertFailures(searchRequestBuilder, RestStatus.BAD_REQUEST, containsString("Value [-1] is out of range for an unsigned long"));
     }
 
     public void testSortMissingNumbersMinMax() throws Exception {
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/CorruptedBlobStoreRepositoryIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/CorruptedBlobStoreRepositoryIT.java
index fbf2acf7b08a6..9c784e5c80fea 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/CorruptedBlobStoreRepositoryIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/CorruptedBlobStoreRepositoryIT.java
@@ -72,6 +72,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static org.opensearch.test.OpenSearchIntegTestCase.resolvePath;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertFileExists;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertRequestBuilderThrows;
@@ -140,18 +141,11 @@ public void testConcurrentlyChangeRepositoryContents() throws Exception {
         assertAcked(client.admin().cluster().prepareDeleteRepository(repoName));
 
         logger.info("--> recreate repository");
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository(repoName)
-                .setType("fs")
-                .setSettings(
-                    Settings.builder()
-                        .put("location", repo)
-                        .put("compress", false)
-                        .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
-                )
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", repo)
+            .put("compress", false)
+            .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES);
+        createRepository(repoName, "fs", settings);
 
         startDeleteSnapshot(repoName, snapshot).get();
 
@@ -168,20 +162,12 @@ public void testConcurrentlyChangeRepositoryContentsInBwCMode() throws Exception
         Path repo = randomRepoPath();
         final String repoName = "test-repo";
         logger.info("-->  creating repository at {}", repo.toAbsolutePath());
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository(repoName)
-                .setType("fs")
-                .setSettings(
-                    Settings.builder()
-                        .put("location", repo)
-                        .put("compress", false)
-                        .put(BlobStoreRepository.ALLOW_CONCURRENT_MODIFICATION.getKey(), true)
-                        .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
-                )
-        );
-
+        Settings.Builder settings = Settings.builder()
+            .put("location", repo)
+            .put("compress", false)
+            .put(BlobStoreRepository.ALLOW_CONCURRENT_MODIFICATION.getKey(), true)
+            .put("chunk_size", randomIntBetween(100, 1000), ByteSizeUnit.BYTES);
+        createRepository(repoName, "fs", settings);
         createIndex("test-idx-1", "test-idx-2");
         logger.info("--> indexing some data");
         indexRandom(
@@ -472,7 +458,7 @@ public void testHandleSnapshotErrorWithBwCFormat() throws IOException, Execution
         // not break subsequent repository operations
         logger.info("--> move shard level metadata to new generation");
         final IndexId indexId = getRepositoryData(repoName).resolveIndexId(indexName);
-        final Path shardPath = repoPath.resolve("indices").resolve(indexId.getId()).resolve("0");
+        final Path shardPath = repoPath.resolve(resolvePath(indexId, "0"));
         final Path initialShardMetaPath = shardPath.resolve(BlobStoreRepository.INDEX_FILE_PREFIX + "0");
         assertFileExists(initialShardMetaPath);
         Files.move(initialShardMetaPath, shardPath.resolve(BlobStoreRepository.INDEX_FILE_PREFIX + "1"));
@@ -501,8 +487,9 @@ public void testRepairBrokenShardGenerations() throws Exception {
 
         logger.info("--> move shard level metadata to new generation and make RepositoryData point at an older generation");
         final IndexId indexId = getRepositoryData(repoName).resolveIndexId(indexName);
-        final Path shardPath = repoPath.resolve("indices").resolve(indexId.getId()).resolve("0");
+        final Path shardPath = repoPath.resolve(resolvePath(indexId, "0"));
         final Path initialShardMetaPath = shardPath.resolve(BlobStoreRepository.INDEX_FILE_PREFIX + "0");
+
         assertFileExists(initialShardMetaPath);
         Files.move(initialShardMetaPath, shardPath.resolve(BlobStoreRepository.INDEX_FILE_PREFIX + randomIntBetween(1, 1000)));
 
@@ -564,9 +551,7 @@ public void testSnapshotWithCorruptedShardIndexFile() throws Exception {
         assertThat(indexIds.size(), equalTo(1));
 
         final IndexId corruptedIndex = indexIds.get(indexName);
-        final Path shardIndexFile = repo.resolve("indices")
-            .resolve(corruptedIndex.getId())
-            .resolve("0")
+        final Path shardIndexFile = repo.resolve(resolvePath(corruptedIndex, "0"))
             .resolve("index-" + repositoryData.shardGenerations().getShardGen(corruptedIndex, 0));
 
         logger.info("-->  truncating shard index file [{}]", shardIndexFile);
@@ -641,7 +626,7 @@ public void testDeleteSnapshotWithMissingIndexAndShardMetadata() throws Exceptio
 
         logger.info("--> delete index metadata and shard metadata");
         for (String index : indices) {
-            Path shardZero = indicesPath.resolve(indexIds.get(index).getId()).resolve("0");
+            Path shardZero = repo.resolve(resolvePath(indexIds.get(index), "0"));
             if (randomBoolean()) {
                 Files.delete(
                     shardZero.resolve("index-" + getRepositoryData("test-repo").shardGenerations().getShardGen(indexIds.get(index), 0))
@@ -834,10 +819,9 @@ public void testSnapshotWithMissingShardLevelIndexFile() throws Exception {
         clusterAdmin().prepareCreateSnapshot("test-repo", "test-snap-1").setWaitForCompletion(true).setIndices("test-idx-*").get();
 
         logger.info("--> deleting shard level index file");
-        final Path indicesPath = repo.resolve("indices");
         for (IndexId indexId : getRepositoryData("test-repo").getIndices().values()) {
             final Path shardGen;
-            try (Stream<Path> shardFiles = Files.list(indicesPath.resolve(indexId.getId()).resolve("0"))) {
+            try (Stream<Path> shardFiles = Files.list(repo.resolve(resolvePath(indexId, "0")))) {
                 shardGen = shardFiles.filter(file -> file.getFileName().toString().startsWith(BlobStoreRepository.INDEX_FILE_PREFIX))
                     .findFirst()
                     .orElseThrow(() -> new AssertionError("Failed to find shard index blob"));
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/DedicatedClusterSnapshotRestoreIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/DedicatedClusterSnapshotRestoreIT.java
index 2b88dbc64e2af..5b581eed3a944 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/DedicatedClusterSnapshotRestoreIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/DedicatedClusterSnapshotRestoreIT.java
@@ -88,6 +88,7 @@
 import org.opensearch.rest.action.admin.cluster.RestGetRepositoriesAction;
 import org.opensearch.snapshots.mockstore.MockRepository;
 import org.opensearch.test.InternalTestCluster;
+import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.OpenSearchIntegTestCase.ClusterScope;
 import org.opensearch.test.OpenSearchIntegTestCase.Scope;
 import org.opensearch.test.TestCustomMetadata;
@@ -761,18 +762,26 @@ public void testRegistrationFailure() {
         internalCluster().startNode(nonClusterManagerNode());
         // Register mock repositories
         for (int i = 0; i < 5; i++) {
-            clusterAdmin().preparePutRepository("test-repo" + i)
-                .setType("mock")
-                .setSettings(Settings.builder().put("location", randomRepoPath()))
-                .setVerify(false)
-                .get();
+            OpenSearchIntegTestCase.putRepositoryRequestBuilder(
+                clusterAdmin(),
+                "test-repo" + i,
+                "mock",
+                false,
+                Settings.builder().put("location", randomRepoPath()),
+                null,
+                false
+            ).get();
         }
         logger.info("--> make sure that properly setup repository can be registered on all nodes");
-        clusterAdmin().preparePutRepository("test-repo-0")
-            .setType("fs")
-            .setSettings(Settings.builder().put("location", randomRepoPath()))
-            .get();
-
+        OpenSearchIntegTestCase.putRepositoryRequestBuilder(
+            clusterAdmin(),
+            "test-repo-0",
+            "fs",
+            true,
+            Settings.builder().put("location", randomRepoPath()),
+            null,
+            false
+        ).get();
     }
 
     public void testThatSensitiveRepositorySettingsAreNotExposed() throws Exception {
@@ -981,11 +990,7 @@ public void testSnapshotWithDateMath() {
         final String snapshotName = "<snapshot-{now/d}>";
 
         logger.info("-->  creating repository");
-        assertAcked(
-            clusterAdmin().preparePutRepository(repo)
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", randomRepoPath()).put("compress", randomBoolean()))
-        );
+        createRepository(repo, "fs", Settings.builder().put("location", randomRepoPath()).put("compress", randomBoolean()));
 
         final String expression1 = nameExpressionResolver.resolveDateMathExpression(snapshotName);
         logger.info("-->  creating date math snapshot");
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotIT.java
index c0157c6303533..ecad956003d0b 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotIT.java
@@ -19,6 +19,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.index.store.RemoteBufferedOutputDirectory;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
@@ -285,11 +286,18 @@ public void testDeleteMultipleShallowCopySnapshotsCase3() throws Exception {
         assert (getLockFilesInRemoteStore(remoteStoreEnabledIndexName, REMOTE_REPO_NAME).length == 0);
     }
 
+    @AwaitsFix(bugUrl = "https://github.com/opensearch-project/OpenSearch/issues/9208")
     public void testRemoteStoreCleanupForDeletedIndex() throws Exception {
         disableRepoConsistencyCheck("Remote store repository is being used in the test");
         final Path remoteStoreRepoPath = randomRepoPath();
-        internalCluster().startClusterManagerOnlyNode(remoteStoreClusterSettings(REMOTE_REPO_NAME, remoteStoreRepoPath));
-        internalCluster().startDataOnlyNode(remoteStoreClusterSettings(REMOTE_REPO_NAME, remoteStoreRepoPath));
+        Settings settings = remoteStoreClusterSettings(REMOTE_REPO_NAME, remoteStoreRepoPath);
+        // Disabling pinned timestamp as this test is specifically for shallow snapshot.
+        settings = Settings.builder()
+            .put(settings)
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), false)
+            .build();
+        internalCluster().startClusterManagerOnlyNode(settings);
+        internalCluster().startDataOnlyNode(settings);
         final Client clusterManagerClient = internalCluster().clusterManagerClient();
         ensureStableCluster(2);
 
@@ -317,13 +325,15 @@ public void testRemoteStoreCleanupForDeletedIndex() throws Exception {
 
         final RepositoriesService repositoriesService = internalCluster().getCurrentClusterManagerNodeInstance(RepositoriesService.class);
         final BlobStoreRepository remoteStoreRepository = (BlobStoreRepository) repositoriesService.repository(REMOTE_REPO_NAME);
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
         BlobPath shardLevelBlobPath = getShardLevelBlobPath(
             client(),
             remoteStoreEnabledIndexName,
             remoteStoreRepository.basePath(),
             "0",
             SEGMENTS,
-            LOCK_FILES
+            LOCK_FILES,
+            segmentsPathFixedPrefix
         );
         BlobContainer blobContainer = remoteStoreRepository.blobStore().blobContainer(shardLevelBlobPath);
         String[] lockFiles;
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotITV2.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotITV2.java
new file mode 100644
index 0000000000000..02b6ea47172c7
--- /dev/null
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/DeleteSnapshotITV2.java
@@ -0,0 +1,332 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.snapshots;
+
+import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.client.Client;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
+import org.opensearch.remotestore.RemoteStoreBaseIntegTestCase;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.fs.FsRepository;
+import org.opensearch.test.OpenSearchIntegTestCase;
+
+import java.nio.file.Path;
+import java.util.concurrent.TimeUnit;
+
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.lessThan;
+
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
+public class DeleteSnapshotITV2 extends AbstractSnapshotIntegTestCase {
+
+    private static final String REMOTE_REPO_NAME = "remote-store-repo-name";
+
+    public void testDeleteShallowCopyV2() throws Exception {
+        disableRepoConsistencyCheck("Remote store repository is being used in the test");
+
+        final Path remoteStoreRepoPath = randomRepoPath();
+        internalCluster().startClusterManagerOnlyNode(snapshotV2Settings(remoteStoreRepoPath));
+
+        internalCluster().startDataOnlyNode(snapshotV2Settings(remoteStoreRepoPath));
+        internalCluster().startDataOnlyNode(snapshotV2Settings(remoteStoreRepoPath));
+
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String indexName3 = "testindex3";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot1";
+        String snapshotName2 = "test-create-snapshot2";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Client client = client();
+
+        assertAcked(
+            client.admin()
+                .cluster()
+                .preparePutRepository(snapshotRepoName)
+                .setType(FsRepository.TYPE)
+                .setSettings(
+                    Settings.builder()
+                        .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+                        .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+                        .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+                        .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+                        .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true)
+                )
+        );
+
+        createIndex(indexName1, getRemoteStoreBackedIndexSettings());
+        createIndex(indexName2, getRemoteStoreBackedIndexSettings());
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexRandomDocs(indexName1, numDocsInIndex1);
+        indexRandomDocs(indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        CreateSnapshotResponse createSnapshotResponse = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName1)
+            .setWaitForCompletion(true)
+            .get();
+        SnapshotInfo snapshotInfo = createSnapshotResponse.getSnapshotInfo();
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName1));
+
+        createIndex(indexName3, getRemoteStoreBackedIndexSettings());
+        indexRandomDocs(indexName3, 10);
+        CreateSnapshotResponse createSnapshotResponse2 = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName2)
+            .setWaitForCompletion(true)
+            .get();
+        snapshotInfo = createSnapshotResponse2.getSnapshotInfo();
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName2));
+
+        assertAcked(client().admin().indices().prepareDelete(indexName1));
+        Thread.sleep(100);
+
+        AcknowledgedResponse deleteResponse = client().admin()
+            .cluster()
+            .prepareDeleteSnapshot(snapshotRepoName, snapshotName2)
+            .setSnapshots(snapshotName2)
+            .get();
+        assertTrue(deleteResponse.isAcknowledged());
+
+        // test delete non-existent snapshot
+        assertThrows(
+            SnapshotMissingException.class,
+            () -> client().admin().cluster().prepareDeleteSnapshot(snapshotRepoName, "random-snapshot").setSnapshots(snapshotName2).get()
+        );
+
+    }
+
+    public void testDeleteShallowCopyV2MultipleSnapshots() throws Exception {
+        disableRepoConsistencyCheck("Remote store repository is being used in the test");
+        final Path remoteStoreRepoPath = randomRepoPath();
+
+        internalCluster().startClusterManagerOnlyNode(snapshotV2Settings(remoteStoreRepoPath));
+        internalCluster().startDataOnlyNode(snapshotV2Settings(remoteStoreRepoPath));
+        internalCluster().startDataOnlyNode(snapshotV2Settings(remoteStoreRepoPath));
+
+        String indexName1 = "testindex1";
+        String indexName2 = "testindex2";
+        String indexName3 = "testindex3";
+        String snapshotRepoName = "test-create-snapshot-repo";
+        String snapshotName1 = "test-create-snapshot1";
+        String snapshotName2 = "test-create-snapshot2";
+        Path absolutePath1 = randomRepoPath().toAbsolutePath();
+        logger.info("Snapshot Path [{}]", absolutePath1);
+
+        Client client = client();
+
+        assertAcked(
+            client.admin()
+                .cluster()
+                .preparePutRepository(snapshotRepoName)
+                .setType(FsRepository.TYPE)
+                .setSettings(
+                    Settings.builder()
+                        .put(FsRepository.LOCATION_SETTING.getKey(), absolutePath1)
+                        .put(FsRepository.COMPRESS_SETTING.getKey(), randomBoolean())
+                        .put(FsRepository.CHUNK_SIZE_SETTING.getKey(), randomIntBetween(100, 1000), ByteSizeUnit.BYTES)
+                        .put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), true)
+                        .put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true)
+                )
+        );
+
+        createIndex(indexName1, getRemoteStoreBackedIndexSettings());
+
+        createIndex(indexName2, getRemoteStoreBackedIndexSettings());
+
+        final int numDocsInIndex1 = 10;
+        final int numDocsInIndex2 = 20;
+        indexRandomDocs(indexName1, numDocsInIndex1);
+        indexRandomDocs(indexName2, numDocsInIndex2);
+        ensureGreen(indexName1, indexName2);
+
+        CreateSnapshotResponse createSnapshotResponse = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName1)
+            .setWaitForCompletion(true)
+            .get();
+        SnapshotInfo snapshotInfo = createSnapshotResponse.getSnapshotInfo();
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName1));
+
+        createIndex(indexName3, getRemoteStoreBackedIndexSettings());
+        indexRandomDocs(indexName3, 10);
+
+        CreateSnapshotResponse createSnapshotResponse2 = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, snapshotName2)
+            .setWaitForCompletion(true)
+            .get();
+        snapshotInfo = createSnapshotResponse2.getSnapshotInfo();
+        assertThat(snapshotInfo.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo.successfulShards(), equalTo(snapshotInfo.totalShards()));
+        assertThat(snapshotInfo.snapshotId().getName(), equalTo(snapshotName2));
+
+        AcknowledgedResponse deleteResponse = client().admin()
+            .cluster()
+            .prepareDeleteSnapshot(snapshotRepoName, snapshotName1, snapshotName2)
+            .setSnapshots(snapshotName2)
+            .get();
+        assertTrue(deleteResponse.isAcknowledged());
+
+        // test delete non-existent snapshot
+        assertThrows(
+            SnapshotMissingException.class,
+            () -> client().admin().cluster().prepareDeleteSnapshot(snapshotRepoName, "random-snapshot").setSnapshots(snapshotName2).get()
+        );
+
+    }
+
+    public void testRemoteStoreCleanupForDeletedIndexForSnapshotV2() throws Exception {
+        disableRepoConsistencyCheck("Remote store repository is being used in the test");
+        final Path remoteStoreRepoPath = randomRepoPath();
+        Settings settings = remoteStoreClusterSettings(REMOTE_REPO_NAME, remoteStoreRepoPath);
+        settings = Settings.builder()
+            .put(settings)
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true)
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING.getKey(), RemoteStoreEnums.PathType.FIXED.toString())
+            .build();
+        String clusterManagerName = internalCluster().startClusterManagerOnlyNode(settings);
+        internalCluster().startDataOnlyNode(settings);
+        final Client clusterManagerClient = internalCluster().clusterManagerClient();
+        ensureStableCluster(2);
+
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = internalCluster().getInstance(
+            RemoteStorePinnedTimestampService.class,
+            clusterManagerName
+        );
+        remoteStorePinnedTimestampService.rescheduleAsyncUpdatePinnedTimestampTask(TimeValue.timeValueSeconds(1));
+
+        final String snapshotRepoName = "snapshot-repo-name";
+        final Path snapshotRepoPath = randomRepoPath();
+        createRepository(snapshotRepoName, "mock", snapshotRepoSettingsForShallowV2(snapshotRepoPath));
+
+        final String remoteStoreEnabledIndexName = "remote-index-1";
+        final Settings remoteStoreEnabledIndexSettings = getRemoteStoreBackedIndexSettings();
+        createIndex(remoteStoreEnabledIndexName, remoteStoreEnabledIndexSettings);
+        indexRandomDocs(remoteStoreEnabledIndexName, 5);
+
+        String indexUUID = client().admin()
+            .indices()
+            .prepareGetSettings(remoteStoreEnabledIndexName)
+            .get()
+            .getSetting(remoteStoreEnabledIndexName, IndexMetadata.SETTING_INDEX_UUID);
+
+        String numShards = client().admin()
+            .indices()
+            .prepareGetSettings(remoteStoreEnabledIndexName)
+            .get()
+            .getSetting(remoteStoreEnabledIndexName, IndexMetadata.SETTING_NUMBER_OF_SHARDS);
+
+        logger.info("--> create two remote index shallow snapshots");
+        CreateSnapshotResponse createSnapshotResponse = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, "snap1")
+            .setWaitForCompletion(true)
+            .get();
+        SnapshotInfo snapshotInfo1 = createSnapshotResponse.getSnapshotInfo();
+
+        indexRandomDocs(remoteStoreEnabledIndexName, 25);
+
+        CreateSnapshotResponse createSnapshotResponse2 = client().admin()
+            .cluster()
+            .prepareCreateSnapshot(snapshotRepoName, "snap2")
+            .setWaitForCompletion(true)
+            .get();
+        SnapshotInfo snapshotInfo2 = createSnapshotResponse2.getSnapshotInfo();
+        assertThat(snapshotInfo2.state(), equalTo(SnapshotState.SUCCESS));
+        assertThat(snapshotInfo2.successfulShards(), greaterThan(0));
+        assertThat(snapshotInfo2.successfulShards(), equalTo(snapshotInfo2.totalShards()));
+        assertThat(snapshotInfo2.snapshotId().getName(), equalTo("snap2"));
+
+        // delete remote store index
+        assertAcked(client().admin().indices().prepareDelete(remoteStoreEnabledIndexName));
+
+        logger.info("--> delete snapshot 2");
+
+        Path indexPath = Path.of(String.valueOf(remoteStoreRepoPath), indexUUID);
+        Path shardPath = Path.of(String.valueOf(indexPath), "0");
+        Path segmentsPath = Path.of(String.valueOf(shardPath), "segments");
+
+        // Get total segments remote store directory file count for deleted index and shard 0
+        int segmentFilesCountBeforeDeletingSnapshot1 = RemoteStoreBaseIntegTestCase.getFileCount(segmentsPath);
+
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+
+        AcknowledgedResponse deleteSnapshotResponse = clusterManagerClient.admin()
+            .cluster()
+            .prepareDeleteSnapshot(snapshotRepoName, snapshotInfo2.snapshotId().getName())
+            .get();
+        assertAcked(deleteSnapshotResponse);
+
+        Thread.sleep(5000);
+
+        assertBusy(() -> {
+            try {
+                assertThat(RemoteStoreBaseIntegTestCase.getFileCount(segmentsPath), lessThan(segmentFilesCountBeforeDeletingSnapshot1));
+            } catch (Exception e) {}
+        }, 30, TimeUnit.SECONDS);
+        int segmentFilesCountAfterDeletingSnapshot1 = RemoteStoreBaseIntegTestCase.getFileCount(segmentsPath);
+
+        logger.info("--> delete snapshot 1");
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+        // on snapshot deletion, remote store segment files should get cleaned up for deleted index - `remote-index-1`
+        deleteSnapshotResponse = clusterManagerClient.admin()
+            .cluster()
+            .prepareDeleteSnapshot(snapshotRepoName, snapshotInfo1.snapshotId().getName())
+            .get();
+        assertAcked(deleteSnapshotResponse);
+
+        // Delete is async. Give time for it
+        assertBusy(() -> {
+            try {
+                assertThat(RemoteStoreBaseIntegTestCase.getFileCount(segmentsPath), lessThan(segmentFilesCountAfterDeletingSnapshot1));
+            } catch (Exception e) {}
+        }, 60, TimeUnit.SECONDS);
+    }
+
+    private Settings snapshotV2Settings(Path remoteStoreRepoPath) {
+        Settings settings = Settings.builder()
+            .put(remoteStoreClusterSettings(REMOTE_REPO_NAME, remoteStoreRepoPath))
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true)
+            .build();
+        return settings;
+    }
+
+    protected Settings.Builder snapshotRepoSettingsForShallowV2(Path path) {
+        final Settings.Builder settings = Settings.builder();
+        settings.put("location", path);
+        settings.put(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY.getKey(), Boolean.TRUE);
+        settings.put(BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(), true);
+        return settings;
+    }
+}
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/MultiClusterRepoAccessIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/MultiClusterRepoAccessIT.java
index 1c46e37dea93a..c96d4a2f079ee 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/MultiClusterRepoAccessIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/MultiClusterRepoAccessIT.java
@@ -115,13 +115,15 @@ public void testConcurrentDeleteFromOtherCluster() throws InterruptedException {
 
         secondCluster.startClusterManagerOnlyNode();
         secondCluster.startDataOnlyNode();
-        secondCluster.client()
-            .admin()
-            .cluster()
-            .preparePutRepository(repoNameOnSecondCluster)
-            .setType("fs")
-            .setSettings(Settings.builder().put("location", repoPath))
-            .get();
+        OpenSearchIntegTestCase.putRepositoryRequestBuilder(
+            secondCluster.client().admin().cluster(),
+            repoNameOnSecondCluster,
+            "fs",
+            true,
+            Settings.builder().put("location", repoPath),
+            null,
+            false
+        ).get();
 
         createIndexWithRandomDocs("test-idx-1", randomIntBetween(1, 100));
         createFullSnapshot(repoNameOnFirstCluster, "snap-1");
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/RemoteIndexSnapshotStatusApiIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/RemoteIndexSnapshotStatusApiIT.java
index 8e2580aba1745..e84de36df2fca 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/RemoteIndexSnapshotStatusApiIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/RemoteIndexSnapshotStatusApiIT.java
@@ -32,20 +32,28 @@
 
 package org.opensearch.snapshots;
 
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
 import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotIndexShardStage;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotIndexShardStatus;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotIndexStatus;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotStatus;
 import org.opensearch.cluster.SnapshotsInProgress;
 import org.opensearch.common.action.ActionFuture;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.threadpool.ThreadPool;
 import org.junit.Before;
 
 import java.nio.file.Path;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 import static org.opensearch.remotestore.RemoteStoreBaseIntegTestCase.remoteStoreClusterSettings;
+import static org.opensearch.snapshots.SnapshotsService.MAX_SHARDS_ALLOWED_IN_STATUS_API;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
 import static org.hamcrest.Matchers.is;
@@ -192,6 +200,110 @@ public void testStatusAPICallInProgressShallowSnapshot() throws Exception {
         createSnapshotResponseActionFuture.actionGet();
     }
 
+    public void testStatusAPICallForShallowV2Snapshot() throws Exception {
+        disableRepoConsistencyCheck("Remote store repository is being used for the test");
+        Settings pinnedTimestampSettings = Settings.builder()
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true)
+            .build();
+        internalCluster().startClusterManagerOnlyNode(pinnedTimestampSettings);
+        internalCluster().startDataOnlyNodes(2, pinnedTimestampSettings);
+
+        final String index1 = "remote-index-1";
+        final String index2 = "remote-index-2";
+        final String index3 = "remote-index-3";
+        final String snapshotRepoName = "snapshot-repo-name";
+        final String snapshot = "snapshot";
+
+        logger.info("Create repository for shallow V2 snapshots");
+        Settings.Builder snapshotV2RepoSettings = snapshotRepoSettingsForShallowCopy().put(
+            BlobStoreRepository.SHALLOW_SNAPSHOT_V2.getKey(),
+            Boolean.TRUE
+        );
+        createRepository(snapshotRepoName, "fs", snapshotV2RepoSettings);
+
+        final Settings remoteStoreEnabledIndexSettings = getRemoteStoreBackedIndexSettings();
+        createIndex(index1, remoteStoreEnabledIndexSettings);
+        createIndex(index2, remoteStoreEnabledIndexSettings);
+        createIndex(index3, remoteStoreEnabledIndexSettings);
+        ensureGreen();
+
+        logger.info("Indexing some data");
+        for (int i = 0; i < 50; i++) {
+            index(index1, "_doc", Integer.toString(i), "foo", "bar" + i);
+            index(index2, "_doc", Integer.toString(i), "foo", "bar" + i);
+            index(index3, "_doc", Integer.toString(i), "foo", "bar" + i);
+        }
+        refresh();
+
+        SnapshotInfo snapshotInfo = createFullSnapshot(snapshotRepoName, snapshot);
+        assertTrue(snapshotInfo.getPinnedTimestamp() > 0); // to assert creation of a shallow v2 snapshot
+
+        logger.info("Set MAX_SHARDS_ALLOWED_IN_STATUS_API to a low value");
+        ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
+        updateSettingsRequest.persistentSettings(Settings.builder().put(MAX_SHARDS_ALLOWED_IN_STATUS_API.getKey(), 2));
+        assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+
+        assertBusy(() -> {
+            // without index filter
+            // although no. of shards in snapshot (3) is greater than the max value allowed in a status api call, the request does not fail
+            SnapshotStatus snapshotStatusWithoutIndexFilter = client().admin()
+                .cluster()
+                .prepareSnapshotStatus(snapshotRepoName)
+                .setSnapshots(snapshot)
+                .execute()
+                .actionGet()
+                .getSnapshots()
+                .get(0);
+
+            assertShallowV2SnapshotStatus(snapshotStatusWithoutIndexFilter, false);
+
+            // with index filter
+            SnapshotStatus snapshotStatusWithIndexFilter = client().admin()
+                .cluster()
+                .prepareSnapshotStatus(snapshotRepoName)
+                .setSnapshots(snapshot)
+                .setIndices(index1, index2)
+                .execute()
+                .actionGet()
+                .getSnapshots()
+                .get(0);
+
+            assertShallowV2SnapshotStatus(snapshotStatusWithIndexFilter, true);
+
+        }, 1, TimeUnit.MINUTES);
+
+    }
+
+    private void assertShallowV2SnapshotStatus(SnapshotStatus snapshotStatus, boolean hasIndexFilter) {
+        if (hasIndexFilter) {
+            assertEquals(0, snapshotStatus.getStats().getTotalSize());
+        } else {
+            // TODO: after adding primary store size at the snapshot level, total size here should be > 0
+        }
+        // assert that total and incremental values of file count and size_in_bytes are 0 at index and shard levels
+        assertEquals(0, snapshotStatus.getStats().getTotalFileCount());
+        assertEquals(0, snapshotStatus.getStats().getIncrementalSize());
+        assertEquals(0, snapshotStatus.getStats().getIncrementalFileCount());
+
+        for (Map.Entry<String, SnapshotIndexStatus> entry : snapshotStatus.getIndices().entrySet()) {
+            // index level
+            SnapshotIndexStatus snapshotIndexStatus = entry.getValue();
+            assertEquals(0, snapshotIndexStatus.getStats().getTotalSize());
+            assertEquals(0, snapshotIndexStatus.getStats().getTotalFileCount());
+            assertEquals(0, snapshotIndexStatus.getStats().getIncrementalSize());
+            assertEquals(0, snapshotIndexStatus.getStats().getIncrementalFileCount());
+
+            for (SnapshotIndexShardStatus snapshotIndexShardStatus : snapshotStatus.getShards()) {
+                // shard level
+                assertEquals(0, snapshotIndexShardStatus.getStats().getTotalSize());
+                assertEquals(0, snapshotIndexShardStatus.getStats().getTotalFileCount());
+                assertEquals(0, snapshotIndexShardStatus.getStats().getIncrementalSize());
+                assertEquals(0, snapshotIndexShardStatus.getStats().getIncrementalFileCount());
+                assertEquals(SnapshotIndexShardStage.DONE, snapshotIndexShardStatus.getStage());
+            }
+        }
+    }
+
     private static SnapshotIndexShardStatus stateFirstShard(SnapshotStatus snapshotStatus, String indexName) {
         return snapshotStatus.getIndices().get(indexName).getShards().get(0);
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/RepositoriesIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/RepositoriesIT.java
index dd40c77ba918d..271fcf166139f 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/RepositoriesIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/RepositoriesIT.java
@@ -33,6 +33,7 @@
 package org.opensearch.snapshots;
 
 import org.opensearch.action.admin.cluster.repositories.get.GetRepositoriesResponse;
+import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequestBuilder;
 import org.opensearch.action.admin.cluster.repositories.verify.VerifyRepositoryResponse;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
 import org.opensearch.action.bulk.BulkRequest;
@@ -56,7 +57,6 @@
 import java.nio.file.Path;
 import java.util.List;
 
-import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertRequestBuilderThrows;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
@@ -110,19 +110,17 @@ public void testRepositoryCreation() throws Exception {
         assertThat(findRepository(repositoriesResponse.repositories(), "test-repo-1"), notNullValue());
         assertThat(findRepository(repositoriesResponse.repositories(), "test-repo-2"), notNullValue());
 
+        RepositoryMetadata testRepo1Md = findRepository(repositoriesResponse.repositories(), "test-repo-1");
+
         logger.info("--> check that trying to create a repository with the same settings repeatedly does not update cluster state");
         String beforeStateUuid = clusterStateResponse.getState().stateUUID();
-        assertThat(
-            client.admin()
-                .cluster()
-                .preparePutRepository("test-repo-1")
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", location))
-                .get()
-                .isAcknowledged(),
-            equalTo(true)
-        );
-        assertEquals(beforeStateUuid, client.admin().cluster().prepareState().clear().get().getState().stateUUID());
+        createRepository("test-repo-1", "fs", Settings.builder().put("location", location));
+        repositoriesResponse = client.admin().cluster().prepareGetRepositories(randomFrom("_all", "*", "test-repo-*")).get();
+        RepositoryMetadata testRepo1MdAfterUpdate = findRepository(repositoriesResponse.repositories(), "test-repo-1");
+
+        if (testRepo1Md.settings().equals(testRepo1MdAfterUpdate.settings())) {
+            assertEquals(beforeStateUuid, client.admin().cluster().prepareState().clear().get().getState().stateUUID());
+        }
 
         logger.info("--> delete repository test-repo-1");
         client.admin().cluster().prepareDeleteRepository("test-repo-1").get();
@@ -225,12 +223,7 @@ public void testMisconfiguredRepository() throws Exception {
         Path invalidRepoPath = createTempDir().toAbsolutePath();
         String location = invalidRepoPath.toString();
         try {
-            client().admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", location))
-                .get();
+            createRepository("test-repo", "fs", Settings.builder().put("location", location));
             fail("Shouldn't be here");
         } catch (RepositoryException ex) {
             assertThat(
@@ -242,33 +235,28 @@ public void testMisconfiguredRepository() throws Exception {
 
     public void testRepositoryAckTimeout() throws Exception {
         logger.info("-->  creating repository test-repo-1 with 0s timeout - shouldn't ack");
-        AcknowledgedResponse putRepositoryResponse = client().admin()
-            .cluster()
-            .preparePutRepository("test-repo-1")
-            .setType("fs")
-            .setSettings(
-                Settings.builder()
-                    .put("location", randomRepoPath())
-                    .put("compress", randomBoolean())
-                    .put("chunk_size", randomIntBetween(5, 100), ByteSizeUnit.BYTES)
-            )
-            .setTimeout("0s")
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(false));
+
+        Settings.Builder settings = Settings.builder()
+            .put("location", randomRepoPath())
+            .put("compress", randomBoolean())
+            .put("chunk_size", randomIntBetween(5, 100), ByteSizeUnit.BYTES);
+        PutRepositoryRequestBuilder requestBuilder = OpenSearchIntegTestCase.putRepositoryRequestBuilder(
+            client().admin().cluster(),
+            "test-repo-1",
+            "fs",
+            true,
+            settings,
+            "0s",
+            false
+        );
+        assertFalse(requestBuilder.get().isAcknowledged());
 
         logger.info("-->  creating repository test-repo-2 with standard timeout - should ack");
-        putRepositoryResponse = client().admin()
-            .cluster()
-            .preparePutRepository("test-repo-2")
-            .setType("fs")
-            .setSettings(
-                Settings.builder()
-                    .put("location", randomRepoPath())
-                    .put("compress", randomBoolean())
-                    .put("chunk_size", randomIntBetween(5, 100), ByteSizeUnit.BYTES)
-            )
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        settings = Settings.builder()
+            .put("location", randomRepoPath())
+            .put("compress", randomBoolean())
+            .put("chunk_size", randomIntBetween(5, 100), ByteSizeUnit.BYTES);
+        createRepository("test-repo-2", "fs", settings);
 
         logger.info("-->  deleting repository test-repo-2 with 0s timeout - shouldn't ack");
         AcknowledgedResponse deleteRepositoryResponse = client().admin()
@@ -292,25 +280,45 @@ public void testRepositoryVerification() throws Exception {
         Settings readonlySettings = Settings.builder().put(settings).put("readonly", true).build();
         logger.info("-->  creating repository that cannot write any files - should fail");
         assertRequestBuilderThrows(
-            client.admin().cluster().preparePutRepository("test-repo-1").setType("mock").setSettings(settings),
+            OpenSearchIntegTestCase.putRepositoryRequestBuilder(
+                client.admin().cluster(),
+                "test-repo-1",
+                "mock",
+                true,
+                Settings.builder().put(settings),
+                null,
+                false
+            ),
             RepositoryVerificationException.class
         );
 
         logger.info("-->  creating read-only repository that cannot read any files - should fail");
         assertRequestBuilderThrows(
-            client.admin().cluster().preparePutRepository("test-repo-2").setType("mock").setSettings(readonlySettings),
+            OpenSearchIntegTestCase.putRepositoryRequestBuilder(
+                client.admin().cluster(),
+                "test-repo-2",
+                "mock",
+                true,
+                Settings.builder().put(readonlySettings),
+                null,
+                false
+            ),
             RepositoryVerificationException.class
         );
 
         logger.info("-->  creating repository that cannot write any files, but suppress verification - should be acked");
-        assertAcked(client.admin().cluster().preparePutRepository("test-repo-1").setType("mock").setSettings(settings).setVerify(false));
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), "test-repo-1", "mock", false, Settings.builder().put(settings));
 
         logger.info("-->  verifying repository");
         assertRequestBuilderThrows(client.admin().cluster().prepareVerifyRepository("test-repo-1"), RepositoryVerificationException.class);
 
         logger.info("-->  creating read-only repository that cannot read any files, but suppress verification - should be acked");
-        assertAcked(
-            client.admin().cluster().preparePutRepository("test-repo-2").setType("mock").setSettings(readonlySettings).setVerify(false)
+        OpenSearchIntegTestCase.putRepository(
+            client.admin().cluster(),
+            "test-repo-2",
+            "mock",
+            false,
+            Settings.builder().put(readonlySettings)
         );
 
         logger.info("-->  verifying repository");
@@ -320,12 +328,8 @@ public void testRepositoryVerification() throws Exception {
 
         logger.info("-->  creating repository");
         try {
-            client.admin()
-                .cluster()
-                .preparePutRepository("test-repo-1")
-                .setType("mock")
-                .setSettings(Settings.builder().put("location", location).put("localize_location", true))
-                .get();
+            Settings.Builder settingsBuilder = Settings.builder().put("location", location).put("localize_location", true);
+            createRepository("test-repo-1", "mock", settingsBuilder);
             fail("RepositoryVerificationException wasn't generated");
         } catch (RepositoryVerificationException ex) {
             assertThat(ex.getMessage(), containsString("is not shared"));
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/RepositoryFilterUserMetadataIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/RepositoryFilterUserMetadataIT.java
index 0eb37703eb0f1..4187ecdf5f283 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/RepositoryFilterUserMetadataIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/RepositoryFilterUserMetadataIT.java
@@ -36,6 +36,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
@@ -58,7 +59,6 @@
 import java.util.Map;
 import java.util.function.Function;
 
-import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.is;
 
 public class RepositoryFilterUserMetadataIT extends OpenSearchIntegTestCase {
@@ -71,17 +71,10 @@ protected Collection<Class<? extends Plugin>> nodePlugins() {
     public void testFilteredRepoMetadataIsUsed() {
         final String clusterManagerName = internalCluster().getClusterManagerName();
         final String repoName = "test-repo";
-        assertAcked(
-            client().admin()
-                .cluster()
-                .preparePutRepository(repoName)
-                .setType(MetadataFilteringPlugin.TYPE)
-                .setSettings(
-                    Settings.builder()
-                        .put("location", randomRepoPath())
-                        .put(MetadataFilteringPlugin.CLUSTER_MANAGER_SETTING_VALUE, clusterManagerName)
-                )
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", randomRepoPath())
+            .put(MetadataFilteringPlugin.CLUSTER_MANAGER_SETTING_VALUE, clusterManagerName);
+        createRepository(repoName, MetadataFilteringPlugin.TYPE, settings);
         createIndex("test-idx");
         final SnapshotInfo snapshotInfo = client().admin()
             .cluster()
@@ -127,6 +120,7 @@ public void finalizeSnapshot(
                         SnapshotInfo snapshotInfo,
                         Version repositoryMetaVersion,
                         Function<ClusterState, ClusterState> stateTransformer,
+                        Priority repositoryUpdatePriority,
                         ActionListener<RepositoryData> listener
                     ) {
                         super.finalizeSnapshot(
@@ -136,6 +130,7 @@ public void finalizeSnapshot(
                             snapshotInfo,
                             repositoryMetaVersion,
                             stateTransformer,
+                            repositoryUpdatePriority,
                             listener
                         );
                     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/SearchableSnapshotIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/SearchableSnapshotIT.java
index 90bb2b501764e..a19bbe49ad340 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/SearchableSnapshotIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/SearchableSnapshotIT.java
@@ -17,6 +17,7 @@
 import org.opensearch.action.admin.cluster.snapshots.delete.DeleteSnapshotRequest;
 import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsResponse;
 import org.opensearch.action.admin.cluster.snapshots.restore.RestoreSnapshotRequest;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusResponse;
 import org.opensearch.action.admin.indices.settings.get.GetSettingsRequest;
 import org.opensearch.action.admin.indices.settings.get.GetSettingsResponse;
 import org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequestBuilder;
@@ -27,6 +28,7 @@
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.routing.GroupShardsIterator;
 import org.opensearch.cluster.routing.ShardIterator;
 import org.opensearch.cluster.routing.ShardRouting;
@@ -34,6 +36,7 @@
 import org.opensearch.common.Priority;
 import org.opensearch.common.io.PathUtils;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsException;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.index.Index;
@@ -47,21 +50,30 @@
 import org.opensearch.node.Node;
 import org.opensearch.repositories.fs.FsRepository;
 import org.hamcrest.MatcherAssert;
+import org.junit.After;
 
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
 import static org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest.Metric.FS;
 import static org.opensearch.core.common.util.CollectionUtils.iterableAsArrayList;
+import static org.opensearch.index.store.remote.filecache.FileCacheSettings.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING;
+import static org.opensearch.test.NodeRoles.clusterManagerOnlyNode;
+import static org.opensearch.test.NodeRoles.dataNode;
+import static org.opensearch.test.NodeRoles.onlyRole;
+import static org.opensearch.test.NodeRoles.onlyRoles;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
@@ -127,21 +139,24 @@ public void testCreateSearchableSnapshot() throws Exception {
 
     public void testSnapshottingSearchableSnapshots() throws Exception {
         final String repoName = "test-repo";
+        final String initSnapName = "initial-snapshot";
         final String indexName = "test-idx";
+        final String repeatSnapNamePrefix = "test-repeated-snap-";
+        final String repeatIndexNamePrefix = indexName + "-copy-";
         final Client client = client();
 
         // create an index, add data, snapshot it, then delete it
         internalCluster().ensureAtLeastNumDataNodes(1);
         createIndexWithDocsAndEnsureGreen(0, 100, indexName);
         createRepositoryWithSettings(null, repoName);
-        takeSnapshot(client, "initial-snapshot", repoName, indexName);
+        takeSnapshot(client, initSnapName, repoName, indexName);
         deleteIndicesAndEnsureGreen(client, indexName);
 
         // restore the index as a searchable snapshot
         internalCluster().ensureAtLeastNumSearchNodes(1);
         client.admin()
             .cluster()
-            .prepareRestoreSnapshot(repoName, "initial-snapshot")
+            .prepareRestoreSnapshot(repoName, initSnapName)
             .setRenamePattern("(.+)")
             .setRenameReplacement("$1-copy-0")
             .setStorageType(RestoreSnapshotRequest.StorageType.REMOTE_SNAPSHOT)
@@ -154,7 +169,7 @@ public void testSnapshottingSearchableSnapshots() throws Exception {
 
         // Test that the searchable snapshot index can continue to be snapshotted and restored
         for (int i = 0; i < 4; i++) {
-            final String repeatedSnapshotName = "test-repeated-snap-" + i;
+            final String repeatedSnapshotName = repeatSnapNamePrefix + i;
             takeSnapshot(client, repeatedSnapshotName, repoName);
             deleteIndicesAndEnsureGreen(client, "_all");
             client.admin()
@@ -176,21 +191,34 @@ public void testSnapshottingSearchableSnapshots() throws Exception {
         final Map<String, List<String>> snapshotInfoMap = response.getSnapshots()
             .stream()
             .collect(Collectors.toMap(s -> s.snapshotId().getName(), SnapshotInfo::indices));
-        assertEquals(
-            Map.of(
-                "initial-snapshot",
-                List.of("test-idx"),
-                "test-repeated-snap-0",
-                List.of("test-idx-copy-0"),
-                "test-repeated-snap-1",
-                List.of("test-idx-copy-1"),
-                "test-repeated-snap-2",
-                List.of("test-idx-copy-2"),
-                "test-repeated-snap-3",
-                List.of("test-idx-copy-3")
-            ),
-            snapshotInfoMap
-        );
+        final Map<String, List<String>> expect = new HashMap<>();
+        expect.put(initSnapName, List.of(indexName));
+        IntStream.range(0, 4).forEach(i -> expect.put(repeatSnapNamePrefix + i, List.of(repeatIndexNamePrefix + i)));
+        assertEquals(expect, snapshotInfoMap);
+
+        String[] snapNames = new String[5];
+        IntStream.range(0, 4).forEach(i -> snapNames[i] = repeatSnapNamePrefix + i);
+        snapNames[4] = initSnapName;
+        SnapshotsStatusResponse snapshotsStatusResponse = client.admin()
+            .cluster()
+            .prepareSnapshotStatus(repoName)
+            .addSnapshots(snapNames)
+            .execute()
+            .actionGet();
+        snapshotsStatusResponse.getSnapshots().forEach(s -> {
+            String snapName = s.getSnapshot().getSnapshotId().getName();
+            assertEquals(1, s.getIndices().size());
+            assertEquals(1, s.getShards().size());
+            if (snapName.equals("initial-snapshot")) {
+                assertNotNull(s.getIndices().get("test-idx"));
+                assertTrue(s.getShards().get(0).getStats().getTotalFileCount() > 0);
+            } else {
+                assertTrue(snapName.startsWith(repeatSnapNamePrefix));
+                assertEquals(1, s.getIndices().size());
+                assertNotNull(s.getIndices().get(repeatIndexNamePrefix + snapName.substring(repeatSnapNamePrefix.length())));
+                assertEquals(0L, s.getShards().get(0).getStats().getTotalFileCount());
+            }
+        });
     }
 
     /**
@@ -939,6 +967,73 @@ public void testRelocateSearchableSnapshotIndex() throws Exception {
         assertSearchableSnapshotIndexDirectoryExistence(searchNode2, index, false);
     }
 
+    public void testCreateSearchableSnapshotWithSpecifiedRemoteDataRatio() throws Exception {
+        final String snapshotName = "test-snap";
+        final String repoName = "test-repo";
+        final String indexName1 = "test-idx-1";
+        final String restoredIndexName1 = indexName1 + "-copy";
+        final String indexName2 = "test-idx-2";
+        final String restoredIndexName2 = indexName2 + "-copy";
+        final int numReplicasIndex1 = 1;
+        final int numReplicasIndex2 = 1;
+
+        Settings clusterManagerNodeSettings = clusterManagerOnlyNode();
+        internalCluster().startNodes(2, clusterManagerNodeSettings);
+        Settings dateNodeSettings = dataNode();
+        internalCluster().startNodes(2, dateNodeSettings);
+        createIndexWithDocsAndEnsureGreen(numReplicasIndex1, 100, indexName1);
+        createIndexWithDocsAndEnsureGreen(numReplicasIndex2, 100, indexName2);
+
+        final Client client = client();
+        assertAcked(
+            client.admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().put(DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.getKey(), 5))
+        );
+
+        createRepositoryWithSettings(null, repoName);
+        takeSnapshot(client, snapshotName, repoName, indexName1, indexName2);
+
+        internalCluster().ensureAtLeastNumSearchNodes(Math.max(numReplicasIndex1, numReplicasIndex2) + 1);
+        restoreSnapshotAndEnsureGreen(client, snapshotName, repoName);
+
+        assertDocCount(restoredIndexName1, 100L);
+        assertDocCount(restoredIndexName2, 100L);
+        assertIndexDirectoryDoesNotExist(restoredIndexName1, restoredIndexName2);
+    }
+
+    @After
+    public void cleanup() throws Exception {
+        assertAcked(
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().putNull(DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.getKey()))
+        );
+    }
+
+    public void testStartSearchNode() throws Exception {
+        // test start dedicated search node
+        internalCluster().startNode(Settings.builder().put(onlyRole(DiscoveryNodeRole.SEARCH_ROLE)));
+        // test start node without search role
+        internalCluster().startNode(Settings.builder().put(onlyRole(DiscoveryNodeRole.DATA_ROLE)));
+        // test start non-dedicated search node, if the user doesn't configure the cache size, it fails
+        assertThrows(
+            SettingsException.class,
+            () -> internalCluster().startNode(
+                Settings.builder().put(onlyRoles(Set.of(DiscoveryNodeRole.SEARCH_ROLE, DiscoveryNodeRole.DATA_ROLE)))
+            )
+        );
+        // test start non-dedicated search node
+        assertThrows(
+            SettingsException.class,
+            () -> internalCluster().startNode(
+                Settings.builder().put(onlyRoles(Set.of(DiscoveryNodeRole.SEARCH_ROLE, DiscoveryNodeRole.DATA_ROLE)))
+            )
+        );
+    }
+
     private void assertSearchableSnapshotIndexDirectoryExistence(String nodeName, Index index, boolean exists) throws Exception {
         final Node node = internalCluster().getInstance(Node.class, nodeName);
         final ShardId shardId = new ShardId(index, 0);
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/SharedClusterSnapshotRestoreIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/SharedClusterSnapshotRestoreIT.java
index 75c3a0a23de37..2d48882e43739 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/SharedClusterSnapshotRestoreIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/SharedClusterSnapshotRestoreIT.java
@@ -82,6 +82,7 @@
 import org.opensearch.repositories.RepositoryException;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.snapshots.mockstore.MockRepository;
+import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.nio.channels.SeekableByteChannel;
@@ -389,17 +390,11 @@ public void testSnapshotFileFailureDuringSnapshot() throws InterruptedException
         disableRepoConsistencyCheck("This test uses a purposely broken repository so it would fail consistency checks");
 
         logger.info("-->  creating repository");
-        assertAcked(
-            clusterAdmin().preparePutRepository("test-repo")
-                .setType("mock")
-                .setSettings(
-                    Settings.builder()
-                        .put("location", randomRepoPath())
-                        .put("random", randomAlphaOfLength(10))
-                        .put("random_control_io_exception_rate", 0.2)
-                )
-                .setVerify(false)
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", randomRepoPath())
+            .put("random", randomAlphaOfLength(10))
+            .put("random_control_io_exception_rate", 0.2);
+        OpenSearchIntegTestCase.putRepository(clusterAdmin(), "test-repo", "mock", false, settings);
 
         createIndexWithRandomDocs("test-idx", 100);
 
@@ -690,11 +685,8 @@ private void unrestorableUseCase(
         assertAcked(client().admin().indices().prepareDelete(indexName));
 
         // update the test repository
-        assertAcked(
-            clusterAdmin().preparePutRepository("test-repo")
-                .setType("mock")
-                .setSettings(Settings.builder().put("location", repositoryLocation).put(repositorySettings).build())
-        );
+        Settings.Builder settings = Settings.builder().put("location", repositoryLocation).put(repositorySettings);
+        OpenSearchIntegTestCase.putRepository(clusterAdmin(), "test-repo", "mock", settings);
 
         // attempt to restore the snapshot with the given settings
         RestoreSnapshotResponse restoreResponse = clusterAdmin().prepareRestoreSnapshot("test-repo", "test-snap")
@@ -1015,27 +1007,17 @@ public void testDeleteRepositoryWhileSnapshotting() throws Exception {
         }
 
         logger.info("--> trying to move repository to another location");
+        Settings.Builder settings = Settings.builder().put("location", repositoryLocation.resolve("test"));
         try {
-            client.admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", repositoryLocation.resolve("test")))
-                .get();
+            OpenSearchIntegTestCase.putRepository(client.admin().cluster(), "test-repo", "fs", settings);
             fail("shouldn't be able to replace in-use repository");
         } catch (Exception ex) {
             logger.info("--> in-use repository replacement failed");
         }
 
         logger.info("--> trying to create a repository with different name");
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository("test-repo-2")
-                .setVerify(false) // do not do verification itself as snapshot threads could be fully blocked
-                .setType("fs")
-                .setSettings(Settings.builder().put("location", repositoryLocation.resolve("test")))
-        );
+        Settings.Builder settingsBuilder = Settings.builder().put("location", repositoryLocation.resolve("test"));
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), "test-repo-2", "fs", false, settingsBuilder);
 
         logger.info("--> unblocking blocked node");
         unblockNode("test-repo", blockedNode);
@@ -1941,20 +1923,12 @@ public void testSnapshotSucceedsAfterSnapshotFailure() throws Exception {
         logger.info("--> creating repository");
         final Path repoPath = randomRepoPath();
         final Client client = client();
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("mock")
-                .setVerify(false)
-                .setSettings(
-                    Settings.builder()
-                        .put("location", repoPath)
-                        .put("random_control_io_exception_rate", randomIntBetween(5, 20) / 100f)
-                        // test that we can take a snapshot after a failed one, even if a partial index-N was written
-                        .put("random", randomAlphaOfLength(10))
-                )
-        );
+        Settings.Builder settings = Settings.builder()
+            .put("location", repoPath)
+            .put("random_control_io_exception_rate", randomIntBetween(5, 20) / 100f)
+            // test that we can take a snapshot after a failed one, even if a partial index-N was written
+            .put("random", randomAlphaOfLength(10));
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), "test-repo", "mock", false, settings);
 
         assertAcked(
             prepareCreate("test-idx").setSettings(
@@ -2004,14 +1978,8 @@ public void testGetSnapshotsFromIndexBlobOnly() throws Exception {
         logger.info("--> creating repository");
         final Path repoPath = randomRepoPath();
         final Client client = client();
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository("test-repo")
-                .setType("fs")
-                .setVerify(false)
-                .setSettings(Settings.builder().put("location", repoPath))
-        );
+        Settings.Builder settings = Settings.builder().put("location", repoPath);
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), "test-repo", "fs", false, settings);
 
         logger.info("--> creating random number of indices");
         final int numIndices = randomIntBetween(1, 10);
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/SnapshotStatusApisIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/SnapshotStatusApisIT.java
index fb69209f7adda..c3214022df663 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/SnapshotStatusApisIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/SnapshotStatusApisIT.java
@@ -33,11 +33,14 @@
 package org.opensearch.snapshots;
 
 import org.opensearch.Version;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
 import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
 import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsRequest;
 import org.opensearch.action.admin.cluster.snapshots.get.GetSnapshotsResponse;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotIndexShardStage;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotIndexShardStatus;
+import org.opensearch.action.admin.cluster.snapshots.status.SnapshotIndexStatus;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotStats;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotStatus;
 import org.opensearch.action.admin.cluster.snapshots.status.SnapshotsStatusResponse;
@@ -48,7 +51,11 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.breaker.CircuitBreakingException;
 import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.index.IndexNotFoundException;
+import org.opensearch.repositories.IndexId;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -59,9 +66,13 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
+import static org.opensearch.snapshots.SnapshotsService.MAX_SHARDS_ALLOWED_IN_STATUS_API;
+import static org.opensearch.test.OpenSearchIntegTestCase.resolvePath;
 import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
@@ -200,11 +211,9 @@ public void testExceptionOnMissingShardLevelSnapBlob() throws IOException {
         final SnapshotInfo snapshotInfo = createFullSnapshot("test-repo", "test-snap");
 
         logger.info("--> delete shard-level snap-${uuid}.dat file for one shard in this snapshot to simulate concurrent delete");
-        final String indexRepoId = getRepositoryData("test-repo").resolveIndexId(snapshotInfo.indices().get(0)).getId();
+        IndexId indexId = getRepositoryData("test-repo").resolveIndexId(snapshotInfo.indices().get(0));
         IOUtils.rm(
-            repoPath.resolve("indices")
-                .resolve(indexRepoId)
-                .resolve("0")
+            repoPath.resolve(resolvePath(indexId, "0"))
                 .resolve(BlobStoreRepository.SNAPSHOT_PREFIX + snapshotInfo.snapshotId().getUUID() + ".dat")
         );
 
@@ -564,6 +573,194 @@ public void testGetSnapshotsRequest() throws Exception {
         waitForCompletion(repositoryName, inProgressSnapshot, TimeValue.timeValueSeconds(60));
     }
 
+    public void testSnapshotStatusApiFailureForTooManyShardsAcrossSnapshots() throws Exception {
+        String repositoryName = "test-repo";
+        String index1 = "test-idx-1";
+        String index2 = "test-idx-2";
+        String index3 = "test-idx-3";
+        createRepository(repositoryName, "fs");
+
+        logger.info("Create indices");
+        createIndex(index1, index2, index3);
+        ensureGreen();
+
+        logger.info("Indexing some data");
+        for (int i = 0; i < 10; i++) {
+            index(index1, "_doc", Integer.toString(i), "foo", "bar" + i);
+            index(index2, "_doc", Integer.toString(i), "foo", "baz" + i);
+            index(index3, "_doc", Integer.toString(i), "foo", "baz" + i);
+        }
+        refresh();
+        String snapshot1 = "test-snap-1";
+        String snapshot2 = "test-snap-2";
+        createSnapshot(repositoryName, snapshot1, List.of(index1, index2, index3));
+        createSnapshot(repositoryName, snapshot2, List.of(index1, index2));
+
+        logger.info("Set MAX_SHARDS_ALLOWED_IN_STATUS_API to a low value");
+        ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
+        updateSettingsRequest.persistentSettings(Settings.builder().put(MAX_SHARDS_ALLOWED_IN_STATUS_API.getKey(), 2));
+        assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+
+        // across a single snapshot
+        assertBusy(() -> {
+            CircuitBreakingException exception = expectThrows(
+                CircuitBreakingException.class,
+                () -> client().admin().cluster().prepareSnapshotStatus(repositoryName).setSnapshots(snapshot1).execute().actionGet()
+            );
+            assertEquals(exception.status(), RestStatus.TOO_MANY_REQUESTS);
+            assertTrue(
+                exception.getMessage().endsWith(" is more than the maximum allowed value of shard count [2] for snapshot status request")
+            );
+        }, 1, TimeUnit.MINUTES);
+
+        // across multiple snapshots
+        assertBusy(() -> {
+            CircuitBreakingException exception = expectThrows(
+                CircuitBreakingException.class,
+                () -> client().admin()
+                    .cluster()
+                    .prepareSnapshotStatus(repositoryName)
+                    .setSnapshots(snapshot1, snapshot2)
+                    .execute()
+                    .actionGet()
+            );
+            assertEquals(exception.status(), RestStatus.TOO_MANY_REQUESTS);
+            assertTrue(
+                exception.getMessage().endsWith(" is more than the maximum allowed value of shard count [2] for snapshot status request")
+            );
+        }, 1, TimeUnit.MINUTES);
+
+        logger.info("Reset MAX_SHARDS_ALLOWED_IN_STATUS_API to default value");
+        updateSettingsRequest.persistentSettings(Settings.builder().putNull(MAX_SHARDS_ALLOWED_IN_STATUS_API.getKey()));
+        assertAcked(internalCluster().client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+    }
+
+    public void testSnapshotStatusForIndexFilter() throws Exception {
+        String repositoryName = "test-repo";
+        String index1 = "test-idx-1";
+        String index2 = "test-idx-2";
+        String index3 = "test-idx-3";
+        createRepository(repositoryName, "fs");
+
+        logger.info("Create indices");
+        createIndex(index1, index2, index3);
+        ensureGreen();
+
+        logger.info("Indexing some data");
+        for (int i = 0; i < 10; i++) {
+            index(index1, "_doc", Integer.toString(i), "foo", "bar" + i);
+            index(index2, "_doc", Integer.toString(i), "foo", "baz" + i);
+            index(index3, "_doc", Integer.toString(i), "foo", "baz" + i);
+        }
+        refresh();
+        String snapshot = "test-snap-1";
+        createSnapshot(repositoryName, snapshot, List.of(index1, index2, index3));
+
+        assertBusy(() -> {
+            SnapshotStatus snapshotsStatus = client().admin()
+                .cluster()
+                .prepareSnapshotStatus(repositoryName)
+                .setSnapshots(snapshot)
+                .setIndices(index1, index2)
+                .get()
+                .getSnapshots()
+                .get(0);
+            Map<String, SnapshotIndexStatus> snapshotIndexStatusMap = snapshotsStatus.getIndices();
+            // Although the snapshot contains 3 indices, the response of status api call only contains results for 2
+            assertEquals(snapshotIndexStatusMap.size(), 2);
+            assertEquals(snapshotIndexStatusMap.keySet(), Set.of(index1, index2));
+        }, 1, TimeUnit.MINUTES);
+    }
+
+    public void testSnapshotStatusFailuresWithIndexFilter() throws Exception {
+        String repositoryName = "test-repo";
+        String index1 = "test-idx-1";
+        String index2 = "test-idx-2";
+        String index3 = "test-idx-3";
+        createRepository(repositoryName, "fs");
+
+        logger.info("Create indices");
+        createIndex(index1, index2, index3);
+        ensureGreen();
+
+        logger.info("Indexing some data");
+        for (int i = 0; i < 10; i++) {
+            index(index1, "_doc", Integer.toString(i), "foo", "bar" + i);
+            index(index2, "_doc", Integer.toString(i), "foo", "baz" + i);
+            index(index3, "_doc", Integer.toString(i), "foo", "baz" + i);
+        }
+        refresh();
+        String snapshot1 = "test-snap-1";
+        String snapshot2 = "test-snap-2";
+        createSnapshot(repositoryName, snapshot1, List.of(index1, index2, index3));
+        createSnapshot(repositoryName, snapshot2, List.of(index1));
+
+        assertBusy(() -> {
+            // failure due to passing index filter for multiple snapshots
+            ActionRequestValidationException ex = expectThrows(
+                ActionRequestValidationException.class,
+                () -> client().admin()
+                    .cluster()
+                    .prepareSnapshotStatus(repositoryName)
+                    .setSnapshots(snapshot1, snapshot2)
+                    .setIndices(index1, index2, index3)
+                    .execute()
+                    .actionGet()
+            );
+            String cause = "index list filter is supported only for a single snapshot";
+            assertTrue(ex.getMessage().contains(cause));
+        }, 1, TimeUnit.MINUTES);
+
+        assertBusy(() -> {
+            // failure due to index not found in snapshot
+            IndexNotFoundException ex = expectThrows(
+                IndexNotFoundException.class,
+                () -> client().admin()
+                    .cluster()
+                    .prepareSnapshotStatus(repositoryName)
+                    .setSnapshots(snapshot2)
+                    .setIndices(index1, index2, index3)
+                    .execute()
+                    .actionGet()
+            );
+            assertEquals(ex.status(), RestStatus.NOT_FOUND);
+            String cause = String.format(
+                Locale.ROOT,
+                "indices [%s] missing in snapshot [%s] of repository [%s]",
+                String.join(", ", List.of(index2, index3)),
+                snapshot2,
+                repositoryName
+            );
+            assertEquals(cause, ex.getCause().getMessage());
+
+        }, 1, TimeUnit.MINUTES);
+
+        assertBusy(() -> {
+            // failure due to too many shards requested
+            logger.info("Set MAX_SHARDS_ALLOWED_IN_STATUS_API to a low value");
+            ClusterUpdateSettingsRequest updateSettingsRequest = new ClusterUpdateSettingsRequest();
+            updateSettingsRequest.persistentSettings(Settings.builder().put(MAX_SHARDS_ALLOWED_IN_STATUS_API.getKey(), 2));
+            assertAcked(client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+
+            CircuitBreakingException ex = expectThrows(
+                CircuitBreakingException.class,
+                () -> client().admin()
+                    .cluster()
+                    .prepareSnapshotStatus(repositoryName)
+                    .setSnapshots(snapshot1)
+                    .setIndices(index1, index2, index3)
+                    .execute()
+                    .actionGet()
+            );
+            assertEquals(ex.status(), RestStatus.TOO_MANY_REQUESTS);
+            assertTrue(ex.getMessage().endsWith(" is more than the maximum allowed value of shard count [2] for snapshot status request"));
+
+            logger.info("Reset MAX_SHARDS_ALLOWED_IN_STATUS_API to default value");
+            updateSettingsRequest.persistentSettings(Settings.builder().putNull(MAX_SHARDS_ALLOWED_IN_STATUS_API.getKey()));
+            assertAcked(internalCluster().client().admin().cluster().updateSettings(updateSettingsRequest).actionGet());
+        }, 2, TimeUnit.MINUTES);
+    }
+
     private static SnapshotIndexShardStatus stateFirstShard(SnapshotStatus snapshotStatus, String indexName) {
         return snapshotStatus.getIndices().get(indexName).getShards().get(0);
     }
diff --git a/server/src/internalClusterTest/java/org/opensearch/snapshots/SystemRepositoryIT.java b/server/src/internalClusterTest/java/org/opensearch/snapshots/SystemRepositoryIT.java
index 28b84655a2cc7..bb5cc89d4e1d5 100644
--- a/server/src/internalClusterTest/java/org/opensearch/snapshots/SystemRepositoryIT.java
+++ b/server/src/internalClusterTest/java/org/opensearch/snapshots/SystemRepositoryIT.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.snapshots;
 
-import org.opensearch.client.Client;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.repositories.RepositoryException;
@@ -19,7 +18,6 @@
 import java.nio.file.Path;
 
 import static org.opensearch.remotestore.RemoteStoreBaseIntegTestCase.remoteStoreClusterSettings;
-import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 
 @OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0)
 public class SystemRepositoryIT extends AbstractSnapshotIntegTestCase {
@@ -43,13 +41,8 @@ public void testRestrictedSettingsCantBeUpdated() {
         disableRepoConsistencyCheck("System repository is being used for the test");
 
         internalCluster().startNode();
-        final Client client = client();
         final Settings.Builder repoSettings = Settings.builder().put("location", randomRepoPath());
-
-        RepositoryException e = expectThrows(
-            RepositoryException.class,
-            () -> client.admin().cluster().preparePutRepository(systemRepoName).setType("mock").setSettings(repoSettings).get()
-        );
+        RepositoryException e = expectThrows(RepositoryException.class, () -> createRepository(systemRepoName, "mock", repoSettings));
         assertEquals(
             e.getMessage(),
             "[system-repo-name] trying to modify an unmodifiable attribute type of system "
@@ -59,18 +52,8 @@ public void testRestrictedSettingsCantBeUpdated() {
 
     public void testSystemRepositoryNonRestrictedSettingsCanBeUpdated() {
         disableRepoConsistencyCheck("System repository is being used for the test");
-
         internalCluster().startNode();
-        final Client client = client();
         final Settings.Builder repoSettings = Settings.builder().put("location", absolutePath).put("chunk_size", new ByteSizeValue(20));
-
-        assertAcked(
-            client.admin()
-                .cluster()
-                .preparePutRepository(systemRepoName)
-                .setType(ReloadableFsRepository.TYPE)
-                .setSettings(repoSettings)
-                .get()
-        );
+        createRepository(systemRepoName, ReloadableFsRepository.TYPE, repoSettings);
     }
 }
diff --git a/server/src/main/java/org/apache/lucene/codecs/lucene90/Lucene90DocValuesConsumerWrapper.java b/server/src/main/java/org/apache/lucene/codecs/lucene90/Lucene90DocValuesConsumerWrapper.java
new file mode 100644
index 0000000000000..67ee45f4c9306
--- /dev/null
+++ b/server/src/main/java/org/apache/lucene/codecs/lucene90/Lucene90DocValuesConsumerWrapper.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.apache.lucene.codecs.lucene90;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.index.SegmentWriteState;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+/**
+ * This class is an abstraction of the {@link DocValuesConsumer} for the Star Tree index structure.
+ * It is responsible to consume various types of document values (numeric, binary, sorted, sorted numeric,
+ * and sorted set) for fields in the Star Tree index.
+ *
+ * @opensearch.experimental
+ */
+public class Lucene90DocValuesConsumerWrapper implements Closeable {
+
+    private final Lucene90DocValuesConsumer lucene90DocValuesConsumer;
+
+    public Lucene90DocValuesConsumerWrapper(
+        SegmentWriteState state,
+        String dataCodec,
+        String dataExtension,
+        String metaCodec,
+        String metaExtension
+    ) throws IOException {
+        lucene90DocValuesConsumer = new Lucene90DocValuesConsumer(state, dataCodec, dataExtension, metaCodec, metaExtension);
+    }
+
+    public Lucene90DocValuesConsumer getLucene90DocValuesConsumer() {
+        return lucene90DocValuesConsumer;
+    }
+
+    @Override
+    public void close() throws IOException {
+        lucene90DocValuesConsumer.close();
+    }
+}
diff --git a/server/src/main/java/org/apache/lucene/codecs/lucene90/Lucene90DocValuesProducerWrapper.java b/server/src/main/java/org/apache/lucene/codecs/lucene90/Lucene90DocValuesProducerWrapper.java
new file mode 100644
index 0000000000000..a213852c59094
--- /dev/null
+++ b/server/src/main/java/org/apache/lucene/codecs/lucene90/Lucene90DocValuesProducerWrapper.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.apache.lucene.codecs.lucene90;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.SegmentReadState;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+/**
+ * This class is a custom abstraction of the {@link DocValuesProducer} for the Star Tree index structure.
+ * It is responsible for providing access to various types of document values (numeric, binary, sorted, sorted numeric,
+ * and sorted set) for fields in the Star Tree index.
+ *
+ * @opensearch.experimental
+ */
+public class Lucene90DocValuesProducerWrapper implements Closeable {
+
+    private final Lucene90DocValuesProducer lucene90DocValuesProducer;
+
+    public Lucene90DocValuesProducerWrapper(
+        SegmentReadState state,
+        String dataCodec,
+        String dataExtension,
+        String metaCodec,
+        String metaExtension
+    ) throws IOException {
+        lucene90DocValuesProducer = new Lucene90DocValuesProducer(state, dataCodec, dataExtension, metaCodec, metaExtension);
+    }
+
+    public DocValuesProducer getLucene90DocValuesProducer() {
+        return lucene90DocValuesProducer;
+    }
+
+    @Override
+    public void close() throws IOException {
+        lucene90DocValuesProducer.close();
+    }
+}
diff --git a/server/src/main/java/org/apache/lucene/index/SortedNumericDocValuesWriterWrapper.java b/server/src/main/java/org/apache/lucene/index/SortedNumericDocValuesWriterWrapper.java
new file mode 100644
index 0000000000000..f7759fcced284
--- /dev/null
+++ b/server/src/main/java/org/apache/lucene/index/SortedNumericDocValuesWriterWrapper.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.apache.lucene.index;
+
+import org.apache.lucene.util.Counter;
+
+/**
+ * A wrapper class for writing sorted numeric doc values.
+ * <p>
+ * This class provides a convenient way to add sorted numeric doc values to a field
+ * and retrieve the corresponding {@link SortedNumericDocValues} instance.
+ *
+ * @opensearch.experimental
+ */
+public class SortedNumericDocValuesWriterWrapper {
+
+    private final SortedNumericDocValuesWriter sortedNumericDocValuesWriter;
+
+    /**
+     * Sole constructor. Constructs a new {@link SortedNumericDocValuesWriterWrapper} instance.
+     *
+     * @param fieldInfo the field information for the field being written
+     * @param counter a counter for tracking memory usage
+     */
+    public SortedNumericDocValuesWriterWrapper(FieldInfo fieldInfo, Counter counter) {
+        sortedNumericDocValuesWriter = new SortedNumericDocValuesWriter(fieldInfo, counter);
+    }
+
+    /**
+     * Adds a value to the sorted numeric doc values for the specified document.
+     *
+     * @param docID the document ID
+     * @param value the value to add
+     */
+    public void addValue(int docID, long value) {
+        sortedNumericDocValuesWriter.addValue(docID, value);
+    }
+
+    /**
+     * Returns the {@link SortedNumericDocValues} instance containing the sorted numeric doc values
+     *
+     * @return the {@link SortedNumericDocValues} instance
+     */
+    public SortedNumericDocValues getDocValues() {
+        return sortedNumericDocValuesWriter.getDocValues();
+    }
+}
diff --git a/server/src/main/java/org/apache/lucene/queries/BlendedTermQuery.java b/server/src/main/java/org/apache/lucene/queries/BlendedTermQuery.java
index b47b974b96fed..34e1e210d7137 100644
--- a/server/src/main/java/org/apache/lucene/queries/BlendedTermQuery.java
+++ b/server/src/main/java/org/apache/lucene/queries/BlendedTermQuery.java
@@ -120,6 +120,7 @@ protected void blend(final TermStates[] contexts, int maxDoc, IndexReader reader
         }
         int max = 0;
         long minSumTTF = Long.MAX_VALUE;
+        int[] docCounts = new int[contexts.length];
         for (int i = 0; i < contexts.length; i++) {
             TermStates ctx = contexts[i];
             int df = ctx.docFreq();
@@ -133,6 +134,7 @@ protected void blend(final TermStates[] contexts, int maxDoc, IndexReader reader
                 // we need to find out the minimum sumTTF to adjust the statistics
                 // otherwise the statistics don't match
                 minSumTTF = Math.min(minSumTTF, reader.getSumTotalTermFreq(terms[i].field()));
+                docCounts[i] = reader.getDocCount(terms[i].field());
             }
         }
         if (maxDoc > minSumTTF) {
@@ -175,7 +177,11 @@ protected int compare(int i, int j) {
             if (prev > current) {
                 actualDf++;
             }
-            contexts[i] = ctx = adjustDF(reader.getContext(), ctx, Math.min(maxDoc, actualDf));
+            // Per field, we want to guarantee that the adjusted df does not exceed the number of docs with the field.
+            // That is, in the IDF formula (log(1 + (N - n + 0.5) / (n + 0.5))), we need to make sure that n (the
+            // adjusted df) is never bigger than N (the number of docs with the field).
+            int fieldMaxDoc = Math.min(maxDoc, docCounts[i]);
+            contexts[i] = ctx = adjustDF(reader.getContext(), ctx, Math.min(fieldMaxDoc, actualDf));
             prev = current;
             sumTTF += ctx.totalTermFreq();
         }
diff --git a/server/src/main/java/org/apache/lucene/search/uhighlight/CustomFieldHighlighter.java b/server/src/main/java/org/apache/lucene/search/uhighlight/CustomFieldHighlighter.java
index 477f1a7d2f9ba..dd28d5c28b1ca 100644
--- a/server/src/main/java/org/apache/lucene/search/uhighlight/CustomFieldHighlighter.java
+++ b/server/src/main/java/org/apache/lucene/search/uhighlight/CustomFieldHighlighter.java
@@ -51,6 +51,8 @@
 class CustomFieldHighlighter extends FieldHighlighter {
     private static final Passage[] EMPTY_PASSAGE = new Passage[0];
 
+    private static final Comparator<Passage> DEFAULT_PASSAGE_SORT_COMPARATOR = Comparator.comparingInt(Passage::getStartOffset);
+
     private final Locale breakIteratorLocale;
     private final int noMatchSize;
     private String fieldValue;
@@ -66,7 +68,16 @@ class CustomFieldHighlighter extends FieldHighlighter {
         PassageFormatter passageFormatter,
         int noMatchSize
     ) {
-        super(field, fieldOffsetStrategy, breakIterator, passageScorer, maxPassages, maxNoHighlightPassages, passageFormatter);
+        super(
+            field,
+            fieldOffsetStrategy,
+            breakIterator,
+            passageScorer,
+            maxPassages,
+            maxNoHighlightPassages,
+            passageFormatter,
+            DEFAULT_PASSAGE_SORT_COMPARATOR
+        );
         this.breakIteratorLocale = breakIteratorLocale;
         this.noMatchSize = noMatchSize;
     }
diff --git a/server/src/main/java/org/opensearch/OpenSearchServerException.java b/server/src/main/java/org/opensearch/OpenSearchServerException.java
index 10c5beb46092f..5fb064f2c9182 100644
--- a/server/src/main/java/org/opensearch/OpenSearchServerException.java
+++ b/server/src/main/java/org/opensearch/OpenSearchServerException.java
@@ -14,6 +14,7 @@
 import static org.opensearch.OpenSearchException.OpenSearchExceptionHandleRegistry.registerExceptionHandle;
 import static org.opensearch.OpenSearchException.UNKNOWN_VERSION_ADDED;
 import static org.opensearch.Version.V_2_10_0;
+import static org.opensearch.Version.V_2_17_0;
 import static org.opensearch.Version.V_2_1_0;
 import static org.opensearch.Version.V_2_3_0;
 import static org.opensearch.Version.V_2_4_0;
@@ -1179,6 +1180,22 @@ public static void registerExceptions() {
             )
         );
         registerExceptionHandle(new OpenSearchExceptionHandle(CryptoRegistryException.class, CryptoRegistryException::new, 171, V_2_10_0));
+        registerExceptionHandle(
+            new OpenSearchExceptionHandle(
+                org.opensearch.indices.InvalidIndexContextException.class,
+                org.opensearch.indices.InvalidIndexContextException::new,
+                174,
+                V_2_17_0
+            )
+        );
+        registerExceptionHandle(
+            new OpenSearchExceptionHandle(
+                org.opensearch.snapshots.TooManyShardsInSnapshotsStatusException.class,
+                org.opensearch.snapshots.TooManyShardsInSnapshotsStatusException::new,
+                175,
+                V_2_17_0
+            )
+        );
         registerExceptionHandle(
             new OpenSearchExceptionHandle(
                 org.opensearch.cluster.block.IndexCreateBlockException.class,
diff --git a/server/src/main/java/org/opensearch/action/ActionModule.java b/server/src/main/java/org/opensearch/action/ActionModule.java
index e771399607c5b..35def090c0fc5 100644
--- a/server/src/main/java/org/opensearch/action/ActionModule.java
+++ b/server/src/main/java/org/opensearch/action/ActionModule.java
@@ -85,7 +85,9 @@
 import org.opensearch.action.admin.cluster.reroute.TransportClusterRerouteAction;
 import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsAction;
 import org.opensearch.action.admin.cluster.settings.TransportClusterUpdateSettingsAction;
+import org.opensearch.action.admin.cluster.shards.CatShardsAction;
 import org.opensearch.action.admin.cluster.shards.ClusterSearchShardsAction;
+import org.opensearch.action.admin.cluster.shards.TransportCatShardsAction;
 import org.opensearch.action.admin.cluster.shards.TransportClusterSearchShardsAction;
 import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.ClusterDeleteWeightedRoutingAction;
 import org.opensearch.action.admin.cluster.shards.routing.weighted.delete.TransportDeleteWeightedRoutingAction;
@@ -216,6 +218,9 @@
 import org.opensearch.action.admin.indices.template.put.TransportPutComponentTemplateAction;
 import org.opensearch.action.admin.indices.template.put.TransportPutComposableIndexTemplateAction;
 import org.opensearch.action.admin.indices.template.put.TransportPutIndexTemplateAction;
+import org.opensearch.action.admin.indices.tiering.HotToWarmTieringAction;
+import org.opensearch.action.admin.indices.tiering.RestWarmTieringAction;
+import org.opensearch.action.admin.indices.tiering.TransportHotToWarmTieringAction;
 import org.opensearch.action.admin.indices.upgrade.get.TransportUpgradeStatusAction;
 import org.opensearch.action.admin.indices.upgrade.get.UpgradeStatusAction;
 import org.opensearch.action.admin.indices.upgrade.post.TransportUpgradeAction;
@@ -434,6 +439,7 @@
 import org.opensearch.rest.action.cat.RestTemplatesAction;
 import org.opensearch.rest.action.cat.RestThreadPoolAction;
 import org.opensearch.rest.action.document.RestBulkAction;
+import org.opensearch.rest.action.document.RestBulkStreamingAction;
 import org.opensearch.rest.action.document.RestDeleteAction;
 import org.opensearch.rest.action.document.RestGetAction;
 import org.opensearch.rest.action.document.RestGetSourceAction;
@@ -626,12 +632,16 @@ public <Request extends ActionRequest, Response extends ActionResponse> void reg
         actions.register(CreateSnapshotAction.INSTANCE, TransportCreateSnapshotAction.class);
         actions.register(CloneSnapshotAction.INSTANCE, TransportCloneSnapshotAction.class);
         actions.register(RestoreSnapshotAction.INSTANCE, TransportRestoreSnapshotAction.class);
+        if (FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX)) {
+            actions.register(HotToWarmTieringAction.INSTANCE, TransportHotToWarmTieringAction.class);
+        }
         actions.register(SnapshotsStatusAction.INSTANCE, TransportSnapshotsStatusAction.class);
 
         actions.register(ClusterAddWeightedRoutingAction.INSTANCE, TransportAddWeightedRoutingAction.class);
         actions.register(ClusterGetWeightedRoutingAction.INSTANCE, TransportGetWeightedRoutingAction.class);
         actions.register(ClusterDeleteWeightedRoutingAction.INSTANCE, TransportDeleteWeightedRoutingAction.class);
         actions.register(IndicesStatsAction.INSTANCE, TransportIndicesStatsAction.class);
+        actions.register(CatShardsAction.INSTANCE, TransportCatShardsAction.class);
         actions.register(IndicesSegmentsAction.INSTANCE, TransportIndicesSegmentsAction.class);
         actions.register(IndicesShardStoresAction.INSTANCE, TransportIndicesShardStoresAction.class);
         actions.register(CreateIndexAction.INSTANCE, TransportCreateIndexAction.class);
@@ -872,6 +882,7 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         registerHandler.accept(new RestTermVectorsAction());
         registerHandler.accept(new RestMultiTermVectorsAction());
         registerHandler.accept(new RestBulkAction(settings));
+        registerHandler.accept(new RestBulkStreamingAction(settings));
         registerHandler.accept(new RestUpdateAction());
 
         registerHandler.accept(new RestSearchAction());
@@ -941,6 +952,9 @@ public void initRestHandlers(Supplier<DiscoveryNodes> nodesInCluster) {
         registerHandler.accept(new RestNodeAttrsAction());
         registerHandler.accept(new RestRepositoriesAction());
         registerHandler.accept(new RestSnapshotAction());
+        if (FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX)) {
+            registerHandler.accept(new RestWarmTieringAction());
+        }
         registerHandler.accept(new RestTemplatesAction());
 
         // Point in time API
@@ -1166,9 +1180,12 @@ public void unregisterDynamicRoute(NamedRoute route) {
          * @param route The {@link RestHandler.Route}.
          * @return the corresponding {@link RestSendToExtensionAction} if it is registered, null otherwise.
          */
-        @SuppressWarnings("unchecked")
         public RestSendToExtensionAction get(RestHandler.Route route) {
-            return routeRegistry.get(route);
+            if (route instanceof NamedRoute) {
+                return routeRegistry.get((NamedRoute) route);
+            }
+            // Only NamedRoutes are map keys so any other route is not in the map
+            return null;
         }
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/allocation/ClusterAllocationExplanation.java b/server/src/main/java/org/opensearch/action/admin/cluster/allocation/ClusterAllocationExplanation.java
index 3c8f07613561d..70a223d60069a 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/allocation/ClusterAllocationExplanation.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/allocation/ClusterAllocationExplanation.java
@@ -95,7 +95,7 @@ public ClusterAllocationExplanation(StreamInput in) throws IOException {
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         shardRouting.writeTo(out);
-        out.writeOptionalWriteable(currentNode);
+        out.writeOptionalWriteable((stream, node) -> node.writeToWithAttribute(stream), currentNode);
         out.writeOptionalWriteable(relocationTargetNode);
         out.writeOptionalWriteable(clusterInfo);
         shardAllocationDecision.writeTo(out);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/decommission/awareness/get/TransportGetDecommissionStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/decommission/awareness/get/TransportGetDecommissionStateAction.java
index 22feb4d99297a..c8a3be78a790e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/decommission/awareness/get/TransportGetDecommissionStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/decommission/awareness/get/TransportGetDecommissionStateAction.java
@@ -48,7 +48,8 @@ public TransportGetDecommissionStateAction(
             threadPool,
             actionFilters,
             GetDecommissionStateRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
index 1cc357a4c20f4..f69f462372888 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/health/TransportClusterHealthAction.java
@@ -534,4 +534,9 @@ private ClusterHealthResponse clusterHealth(
             pendingTaskTimeInQueue
         );
     }
+
+    @Override
+    protected boolean localExecuteSupportedByAction() {
+        return false;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
index f38ebe35a52d2..870242d40c89b 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/info/TransportNodesInfoAction.java
@@ -129,7 +129,7 @@ protected NodeInfo nodeOperation(NodeInfoRequest nodeRequest) {
      */
     public static class NodeInfoRequest extends BaseNodeRequest {
 
-        NodesInfoRequest request;
+        protected NodesInfoRequest request;
 
         public NodeInfoRequest(StreamInput in) throws IOException {
             super(in);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
index 1c1ebc240ee67..5dae0bb1017e9 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/node/stats/TransportNodesStatsAction.java
@@ -140,7 +140,7 @@ protected NodeStats nodeOperation(NodeStatsRequest nodeStatsRequest) {
      */
     public static class NodeStatsRequest extends BaseNodeRequest {
 
-        NodesStatsRequest request;
+        protected NodesStatsRequest request;
 
         public NodeStatsRequest(StreamInput in) throws IOException {
             super(in);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/repositories/cleanup/TransportCleanupRepositoryAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/repositories/cleanup/TransportCleanupRepositoryAction.java
index b9a4b3f2e24f8..83a63070161e9 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/repositories/cleanup/TransportCleanupRepositoryAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/repositories/cleanup/TransportCleanupRepositoryAction.java
@@ -54,7 +54,9 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.index.store.RemoteSegmentStoreDirectoryFactory;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManagerFactory;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.RepositoryCleanupResult;
@@ -100,6 +102,8 @@ public final class TransportCleanupRepositoryAction extends TransportClusterMana
 
     private final RemoteStoreLockManagerFactory remoteStoreLockManagerFactory;
 
+    private final RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory;
+
     @Override
     protected String executor() {
         return ThreadPool.Names.SAME;
@@ -113,7 +117,8 @@ public TransportCleanupRepositoryAction(
         SnapshotsService snapshotsService,
         ThreadPool threadPool,
         ActionFilters actionFilters,
-        IndexNameExpressionResolver indexNameExpressionResolver
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        RemoteStoreSettings remoteStoreSettings
     ) {
         super(
             CleanupRepositoryAction.NAME,
@@ -126,7 +131,15 @@ public TransportCleanupRepositoryAction(
         );
         this.repositoriesService = repositoriesService;
         this.snapshotsService = snapshotsService;
-        this.remoteStoreLockManagerFactory = new RemoteStoreLockManagerFactory(() -> repositoriesService);
+        this.remoteSegmentStoreDirectoryFactory = new RemoteSegmentStoreDirectoryFactory(
+            () -> repositoriesService,
+            threadPool,
+            remoteStoreSettings.getSegmentsPathFixedPrefix()
+        );
+        this.remoteStoreLockManagerFactory = new RemoteStoreLockManagerFactory(
+            () -> repositoriesService,
+            remoteStoreSettings.getSegmentsPathFixedPrefix()
+        );
         // We add a state applier that will remove any dangling repository cleanup actions on cluster-manager failover.
         // This is safe to do since cleanups will increment the repository state id before executing any operations to prevent concurrent
         // operations from corrupting the repository. This is the same safety mechanism used by snapshot deletes.
@@ -286,6 +299,7 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
                                         repositoryStateId,
                                         snapshotsService.minCompatibleVersion(newState.nodes().getMinNodeVersion(), repositoryData, null),
                                         remoteStoreLockManagerFactory,
+                                        remoteSegmentStoreDirectoryFactory,
                                         ActionListener.wrap(result -> after(null, result), e -> after(e, null))
                                     )
                                 )
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/repositories/get/TransportGetRepositoriesAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/repositories/get/TransportGetRepositoriesAction.java
index c7d784dbc96e7..c99b52dfe34f4 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/repositories/get/TransportGetRepositoriesAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/repositories/get/TransportGetRepositoriesAction.java
@@ -79,7 +79,8 @@ public TransportGetRepositoriesAction(
             threadPool,
             actionFilters,
             GetRepositoriesRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java
index 216e1fb2ed1cc..3988d50b2ce1e 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/settings/TransportClusterUpdateSettingsAction.java
@@ -42,7 +42,6 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.block.ClusterBlockException;
 import org.opensearch.cluster.block.ClusterBlockLevel;
-import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -59,17 +58,13 @@
 import org.opensearch.common.settings.SettingsException;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdater;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
-import java.util.Collection;
-import java.util.Set;
-import java.util.stream.Collectors;
 
-import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdater.indexHasAllRemoteStoreRelatedMetadata;
+import static org.opensearch.index.remote.RemoteStoreUtils.checkAndFinalizeRemoteStoreMigration;
 
 /**
  * Transport action for updating cluster settings
@@ -262,13 +257,14 @@ public void onFailure(String source, Exception e) {
 
                 @Override
                 public ClusterState execute(final ClusterState currentState) {
-                    validateCompatibilityModeSettingRequest(request, state);
-                    final ClusterState clusterState = updater.updateSettings(
+                    boolean isCompatibilityModeChanging = validateCompatibilityModeSettingRequest(request, state);
+                    ClusterState clusterState = updater.updateSettings(
                         currentState,
                         clusterSettings.upgradeSettings(request.transientSettings()),
                         clusterSettings.upgradeSettings(request.persistentSettings()),
                         logger
                     );
+                    clusterState = checkAndFinalizeRemoteStoreMigration(isCompatibilityModeChanging, request, clusterState, logger);
                     changed = clusterState != currentState;
                     return clusterState;
                 }
@@ -278,19 +274,23 @@ public ClusterState execute(final ClusterState currentState) {
 
     /**
      * Runs various checks associated with changing cluster compatibility mode
+     *
      * @param request cluster settings update request, for settings to be updated and new values
      * @param clusterState current state of cluster, for information on nodes
+     * @return true if the incoming cluster settings update request is switching compatibility modes
      */
-    public void validateCompatibilityModeSettingRequest(ClusterUpdateSettingsRequest request, ClusterState clusterState) {
+    public boolean validateCompatibilityModeSettingRequest(ClusterUpdateSettingsRequest request, ClusterState clusterState) {
         Settings settings = Settings.builder().put(request.persistentSettings()).put(request.transientSettings()).build();
         if (RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING.exists(settings)) {
-            String value = RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING.get(settings).mode;
             validateAllNodesOfSameVersion(clusterState.nodes());
-            if (RemoteStoreNodeService.CompatibilityMode.STRICT.mode.equals(value)) {
+            if (RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING.get(
+                settings
+            ) == RemoteStoreNodeService.CompatibilityMode.STRICT) {
                 validateAllNodesOfSameType(clusterState.nodes());
-                validateIndexSettings(clusterState);
             }
+            return true;
         }
+        return false;
     }
 
     /**
@@ -310,31 +310,18 @@ private void validateAllNodesOfSameVersion(DiscoveryNodes discoveryNodes) {
      * @param discoveryNodes current discovery nodes in the cluster
      */
     private void validateAllNodesOfSameType(DiscoveryNodes discoveryNodes) {
-        Set<Boolean> nodeTypes = discoveryNodes.getNodes()
+        boolean allNodesDocrepEnabled = discoveryNodes.getNodes()
             .values()
             .stream()
-            .map(DiscoveryNode::isRemoteStoreNode)
-            .collect(Collectors.toSet());
-        if (nodeTypes.size() != 1) {
+            .allMatch(discoveryNode -> discoveryNode.isRemoteStoreNode() == false);
+        boolean allNodesRemoteStoreEnabled = discoveryNodes.getNodes()
+            .values()
+            .stream()
+            .allMatch(discoveryNode -> discoveryNode.isRemoteStoreNode());
+        if (allNodesDocrepEnabled == false && allNodesRemoteStoreEnabled == false) {
             throw new SettingsException(
                 "can not switch to STRICT compatibility mode when the cluster contains both remote and non-remote nodes"
             );
         }
     }
-
-    /**
-     * Verifies that while trying to switch to STRICT compatibility mode,
-     * all indices in the cluster have {@link RemoteMigrationIndexMetadataUpdater#indexHasAllRemoteStoreRelatedMetadata(IndexMetadata)} as <code>true</code>.
-     * If not, throws {@link SettingsException}
-     * @param clusterState current cluster state
-     */
-    private void validateIndexSettings(ClusterState clusterState) {
-        Collection<IndexMetadata> allIndicesMetadata = clusterState.metadata().indices().values();
-        if (allIndicesMetadata.isEmpty() == false
-            && allIndicesMetadata.stream().anyMatch(indexMetadata -> indexHasAllRemoteStoreRelatedMetadata(indexMetadata) == false)) {
-            throw new SettingsException(
-                "can not switch to STRICT compatibility mode since all indices in the cluster does not have remote store based index settings"
-            );
-        }
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsAction.java
new file mode 100644
index 0000000000000..381a950fe9a79
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsAction.java
@@ -0,0 +1,25 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.cluster.shards;
+
+import org.opensearch.action.ActionType;
+
+/**
+ * Transport action for cat shards
+ *
+ * @opensearch.internal
+ */
+public class CatShardsAction extends ActionType<CatShardsResponse> {
+    public static final CatShardsAction INSTANCE = new CatShardsAction();
+    public static final String NAME = "cluster:monitor/shards";
+
+    private CatShardsAction() {
+        super(NAME, CatShardsResponse::new);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsRequest.java
new file mode 100644
index 0000000000000..49299777db8ae
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsRequest.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.cluster.shards;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.support.clustermanager.ClusterManagerNodeReadRequest;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.tasks.TaskId;
+import org.opensearch.rest.action.admin.cluster.ClusterAdminTask;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * A request of _cat/shards.
+ *
+ * @opensearch.api
+ */
+public class CatShardsRequest extends ClusterManagerNodeReadRequest<CatShardsRequest> {
+
+    private String[] indices;
+    private TimeValue cancelAfterTimeInterval;
+
+    public CatShardsRequest() {}
+
+    public CatShardsRequest(StreamInput in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        return null;
+    }
+
+    public void setIndices(String[] indices) {
+        this.indices = indices;
+    }
+
+    public String[] getIndices() {
+        return this.indices;
+    }
+
+    public void setCancelAfterTimeInterval(TimeValue timeout) {
+        this.cancelAfterTimeInterval = timeout;
+    }
+
+    public TimeValue getCancelAfterTimeInterval() {
+        return this.cancelAfterTimeInterval;
+    }
+
+    @Override
+    public ClusterAdminTask createTask(long id, String type, String action, TaskId parentTaskId, Map<String, String> headers) {
+        return new ClusterAdminTask(id, type, action, parentTaskId, headers, this.cancelAfterTimeInterval);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsResponse.java
new file mode 100644
index 0000000000000..3dd88a2cda037
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/CatShardsResponse.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.cluster.shards;
+
+import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
+import org.opensearch.core.action.ActionResponse;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+
+/**
+ * A response of a cat shards request.
+ *
+ * @opensearch.api
+ */
+public class CatShardsResponse extends ActionResponse {
+
+    private ClusterStateResponse clusterStateResponse = null;
+
+    private IndicesStatsResponse indicesStatsResponse = null;
+
+    public CatShardsResponse() {}
+
+    public CatShardsResponse(StreamInput in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        clusterStateResponse.writeTo(out);
+        indicesStatsResponse.writeTo(out);
+    }
+
+    public void setClusterStateResponse(ClusterStateResponse clusterStateResponse) {
+        this.clusterStateResponse = clusterStateResponse;
+    }
+
+    public ClusterStateResponse getClusterStateResponse() {
+        return this.clusterStateResponse;
+    }
+
+    public void setIndicesStatsResponse(IndicesStatsResponse indicesStatsResponse) {
+        this.indicesStatsResponse = indicesStatsResponse;
+    }
+
+    public IndicesStatsResponse getIndicesStatsResponse() {
+        return this.indicesStatsResponse;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java
new file mode 100644
index 0000000000000..224d3cbc5f10a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportCatShardsAction.java
@@ -0,0 +1,110 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.cluster.shards;
+
+import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
+import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.indices.stats.IndicesStatsRequest;
+import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.HandledTransportAction;
+import org.opensearch.action.support.TimeoutTaskCancellationUtility;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.action.NotifyOnceListener;
+import org.opensearch.tasks.CancellableTask;
+import org.opensearch.tasks.Task;
+import org.opensearch.transport.TransportService;
+
+/**
+ * Perform cat shards action
+ *
+ * @opensearch.internal
+ */
+public class TransportCatShardsAction extends HandledTransportAction<CatShardsRequest, CatShardsResponse> {
+
+    private final NodeClient client;
+
+    @Inject
+    public TransportCatShardsAction(NodeClient client, TransportService transportService, ActionFilters actionFilters) {
+        super(CatShardsAction.NAME, transportService, actionFilters, CatShardsRequest::new);
+        this.client = client;
+    }
+
+    @Override
+    public void doExecute(Task parentTask, CatShardsRequest shardsRequest, ActionListener<CatShardsResponse> listener) {
+        final ClusterStateRequest clusterStateRequest = new ClusterStateRequest();
+        clusterStateRequest.setShouldCancelOnTimeout(true);
+        clusterStateRequest.local(shardsRequest.local());
+        clusterStateRequest.clusterManagerNodeTimeout(shardsRequest.clusterManagerNodeTimeout());
+        clusterStateRequest.clear().nodes(true).routingTable(true).indices(shardsRequest.getIndices());
+        assert parentTask instanceof CancellableTask;
+        clusterStateRequest.setParentTask(client.getLocalNodeId(), parentTask.getId());
+
+        ActionListener<CatShardsResponse> originalListener = new NotifyOnceListener<CatShardsResponse>() {
+            @Override
+            protected void innerOnResponse(CatShardsResponse catShardsResponse) {
+                listener.onResponse(catShardsResponse);
+            }
+
+            @Override
+            protected void innerOnFailure(Exception e) {
+                listener.onFailure(e);
+            }
+        };
+        ActionListener<CatShardsResponse> cancellableListener = TimeoutTaskCancellationUtility.wrapWithCancellationListener(
+            client,
+            (CancellableTask) parentTask,
+            ((CancellableTask) parentTask).getCancellationTimeout(),
+            originalListener,
+            e -> {
+                originalListener.onFailure(e);
+            }
+        );
+        CatShardsResponse catShardsResponse = new CatShardsResponse();
+        try {
+            client.admin().cluster().state(clusterStateRequest, new ActionListener<ClusterStateResponse>() {
+                @Override
+                public void onResponse(ClusterStateResponse clusterStateResponse) {
+                    catShardsResponse.setClusterStateResponse(clusterStateResponse);
+                    IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest();
+                    indicesStatsRequest.setShouldCancelOnTimeout(true);
+                    indicesStatsRequest.all();
+                    indicesStatsRequest.indices(shardsRequest.getIndices());
+                    indicesStatsRequest.setParentTask(client.getLocalNodeId(), parentTask.getId());
+                    try {
+                        client.admin().indices().stats(indicesStatsRequest, new ActionListener<IndicesStatsResponse>() {
+                            @Override
+                            public void onResponse(IndicesStatsResponse indicesStatsResponse) {
+                                catShardsResponse.setIndicesStatsResponse(indicesStatsResponse);
+                                cancellableListener.onResponse(catShardsResponse);
+                            }
+
+                            @Override
+                            public void onFailure(Exception e) {
+                                cancellableListener.onFailure(e);
+                            }
+                        });
+                    } catch (Exception e) {
+                        cancellableListener.onFailure(e);
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    cancellableListener.onFailure(e);
+                }
+            });
+        } catch (Exception e) {
+            cancellableListener.onFailure(e);
+        }
+
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportClusterSearchShardsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportClusterSearchShardsAction.java
index a2a65b6400c97..83e104236f640 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportClusterSearchShardsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/TransportClusterSearchShardsAction.java
@@ -85,7 +85,8 @@ public TransportClusterSearchShardsAction(
             threadPool,
             actionFilters,
             ClusterSearchShardsRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.indicesService = indicesService;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/shards/routing/weighted/get/TransportGetWeightedRoutingAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/shards/routing/weighted/get/TransportGetWeightedRoutingAction.java
index 50368d85e0011..6c110c0ea2a73 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/shards/routing/weighted/get/TransportGetWeightedRoutingAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/shards/routing/weighted/get/TransportGetWeightedRoutingAction.java
@@ -55,7 +55,8 @@ public TransportGetWeightedRoutingAction(
             threadPool,
             actionFilters,
             ClusterGetWeightedRoutingRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.weightedRoutingService = weightedRoutingService;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/create/TransportCreateSnapshotAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/create/TransportCreateSnapshotAction.java
index 768a6578c75fb..198e8e5d24dc6 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/create/TransportCreateSnapshotAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/create/TransportCreateSnapshotAction.java
@@ -42,12 +42,16 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.Repository;
 import org.opensearch.snapshots.SnapshotsService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
 
+import static org.opensearch.repositories.blobstore.BlobStoreRepository.SHALLOW_SNAPSHOT_V2;
+
 /**
  * Transport action for create snapshot operation
  *
@@ -56,12 +60,15 @@
 public class TransportCreateSnapshotAction extends TransportClusterManagerNodeAction<CreateSnapshotRequest, CreateSnapshotResponse> {
     private final SnapshotsService snapshotsService;
 
+    private final RepositoriesService repositoriesService;
+
     @Inject
     public TransportCreateSnapshotAction(
         TransportService transportService,
         ClusterService clusterService,
         ThreadPool threadPool,
         SnapshotsService snapshotsService,
+        RepositoriesService repositoriesService,
         ActionFilters actionFilters,
         IndexNameExpressionResolver indexNameExpressionResolver
     ) {
@@ -75,6 +82,7 @@ public TransportCreateSnapshotAction(
             indexNameExpressionResolver
         );
         this.snapshotsService = snapshotsService;
+        this.repositoriesService = repositoriesService;
     }
 
     @Override
@@ -103,15 +111,22 @@ protected void clusterManagerOperation(
         ClusterState state,
         final ActionListener<CreateSnapshotResponse> listener
     ) {
+
         if (state.nodes().getMinNodeVersion().before(SnapshotsService.NO_REPO_INITIALIZE_VERSION)) {
             if (request.waitForCompletion()) {
                 snapshotsService.executeSnapshotLegacy(request, ActionListener.map(listener, CreateSnapshotResponse::new));
             } else {
                 snapshotsService.createSnapshotLegacy(request, ActionListener.map(listener, snapshot -> new CreateSnapshotResponse()));
             }
+
         } else {
+            Repository repository = repositoriesService.repository(request.repository());
+            boolean isSnapshotV2 = SHALLOW_SNAPSHOT_V2.get(repository.getMetadata().settings());
+
             if (request.waitForCompletion()) {
                 snapshotsService.executeSnapshot(request, ActionListener.map(listener, CreateSnapshotResponse::new));
+            } else if (isSnapshotV2) {
+                snapshotsService.executeSnapshot(request, ActionListener.map(listener, snapshot -> new CreateSnapshotResponse()));
             } else {
                 snapshotsService.createSnapshot(request, ActionListener.map(listener, snapshot -> new CreateSnapshotResponse()));
             }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/SnapshotsStatusRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/SnapshotsStatusRequest.java
index 061e73f1094b5..3d7fb5b6beb56 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/SnapshotsStatusRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/SnapshotsStatusRequest.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.action.admin.cluster.snapshots.status;
 
+import org.opensearch.Version;
 import org.opensearch.action.ActionRequestValidationException;
 import org.opensearch.action.support.clustermanager.ClusterManagerNodeRequest;
 import org.opensearch.common.annotation.PublicApi;
@@ -54,6 +55,7 @@ public class SnapshotsStatusRequest extends ClusterManagerNodeRequest<SnapshotsS
     private String repository = "_all";
 
     private String[] snapshots = Strings.EMPTY_ARRAY;
+    private String[] indices = Strings.EMPTY_ARRAY;
 
     private boolean ignoreUnavailable;
 
@@ -70,11 +72,27 @@ public SnapshotsStatusRequest(String repository, String[] snapshots) {
         this.snapshots = snapshots;
     }
 
+    /**
+     * Constructs a new get snapshots request with given repository name and list of snapshots
+     *
+     * @param repository repository name
+     * @param snapshots  list of snapshots
+     * @param indices  list of indices
+     */
+    public SnapshotsStatusRequest(String repository, String[] snapshots, String[] indices) {
+        this.repository = repository;
+        this.snapshots = snapshots;
+        this.indices = indices;
+    }
+
     public SnapshotsStatusRequest(StreamInput in) throws IOException {
         super(in);
         repository = in.readString();
         snapshots = in.readStringArray();
         ignoreUnavailable = in.readBoolean();
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            indices = in.readOptionalStringArray();
+        }
     }
 
     @Override
@@ -83,6 +101,9 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(repository);
         out.writeStringArray(snapshots);
         out.writeBoolean(ignoreUnavailable);
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeOptionalStringArray(indices);
+        }
     }
 
     /**
@@ -103,6 +124,9 @@ public ActionRequestValidationException validate() {
         if (snapshots == null) {
             validationException = addValidationError("snapshots is null", validationException);
         }
+        if (indices.length != 0 && snapshots.length != 1) {
+            validationException = addValidationError("index list filter is supported only for a single snapshot", validationException);
+        }
         return validationException;
     }
 
@@ -146,10 +170,29 @@ public SnapshotsStatusRequest snapshots(String[] snapshots) {
     }
 
     /**
-     * Set to <code>true</code> to ignore unavailable snapshots, instead of throwing an exception.
-     * Defaults to <code>false</code>, which means unavailable snapshots cause an exception to be thrown.
+     * Returns the names of the indices.
+     *
+     * @return the names of indices
+     */
+    public String[] indices() {
+        return this.indices;
+    }
+
+    /**
+     * Sets the list of indices to be returned
+     *
+     * @return this request
+     */
+    public SnapshotsStatusRequest indices(String[] indices) {
+        this.indices = indices;
+        return this;
+    }
+
+    /**
+     * Set to <code>true</code> to ignore unavailable snapshots and indices, instead of throwing an exception.
+     * Defaults to <code>false</code>, which means unavailable snapshots and indices cause an exception to be thrown.
      *
-     * @param ignoreUnavailable whether to ignore unavailable snapshots
+     * @param ignoreUnavailable whether to ignore unavailable snapshots and indices
      * @return this request
      */
     public SnapshotsStatusRequest ignoreUnavailable(boolean ignoreUnavailable) {
@@ -158,9 +201,9 @@ public SnapshotsStatusRequest ignoreUnavailable(boolean ignoreUnavailable) {
     }
 
     /**
-     * Returns whether the request permits unavailable snapshots to be ignored.
+     * Returns whether the request permits unavailable snapshots and indices to be ignored.
      *
-     * @return true if the request will ignore unavailable snapshots, false if it will throw an exception on unavailable snapshots
+     * @return true if the request will ignore unavailable snapshots and indices, false if it will throw an exception on unavailable snapshots and indices
      */
     public boolean ignoreUnavailable() {
         return ignoreUnavailable;
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/SnapshotsStatusRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/SnapshotsStatusRequestBuilder.java
index 9377eca60e353..6f0ac278d01c4 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/SnapshotsStatusRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/SnapshotsStatusRequestBuilder.java
@@ -96,10 +96,32 @@ public SnapshotsStatusRequestBuilder addSnapshots(String... snapshots) {
     }
 
     /**
-     * Set to <code>true</code> to ignore unavailable snapshots, instead of throwing an exception.
-     * Defaults to <code>false</code>, which means unavailable snapshots cause an exception to be thrown.
+     * Sets list of indices to return
      *
-     * @param ignoreUnavailable whether to ignore unavailable snapshots.
+     * @param indices list of indices
+     * @return this builder
+     */
+    public SnapshotsStatusRequestBuilder setIndices(String... indices) {
+        request.indices(indices);
+        return this;
+    }
+
+    /**
+     * Adds additional indices to the list of indices to return
+     *
+     * @param indices additional indices
+     * @return this builder
+     */
+    public SnapshotsStatusRequestBuilder addIndices(String... indices) {
+        request.indices(ArrayUtils.concat(request.indices(), indices));
+        return this;
+    }
+
+    /**
+     * Set to <code>true</code> to ignore unavailable snapshots and indices, instead of throwing an exception.
+     * Defaults to <code>false</code>, which means unavailable snapshots and indices cause an exception to be thrown.
+     *
+     * @param ignoreUnavailable whether to ignore unavailable snapshots and indices.
      * @return this builder
      */
     public SnapshotsStatusRequestBuilder setIgnoreUnavailable(boolean ignoreUnavailable) {
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/TransportSnapshotsStatusAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/TransportSnapshotsStatusAction.java
index 4fc2acb2caa51..8228cb6301c8c 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/TransportSnapshotsStatusAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/snapshots/status/TransportSnapshotsStatusAction.java
@@ -49,9 +49,12 @@
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.breaker.CircuitBreaker;
+import org.opensearch.core.common.breaker.CircuitBreakingException;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.util.CollectionUtils;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.IndexNotFoundException;
 import org.opensearch.index.snapshots.IndexShardSnapshotStatus;
 import org.opensearch.repositories.IndexId;
 import org.opensearch.repositories.RepositoriesService;
@@ -81,6 +84,7 @@
 import java.util.stream.Collectors;
 
 import static java.util.Collections.unmodifiableMap;
+import static org.opensearch.snapshots.SnapshotsService.MAX_SHARDS_ALLOWED_IN_STATUS_API;
 
 /**
  * Transport action for accessing snapshot status
@@ -95,6 +99,8 @@ public class TransportSnapshotsStatusAction extends TransportClusterManagerNodeA
 
     private final TransportNodesSnapshotsStatus transportNodesSnapshotsStatus;
 
+    private long maximumAllowedShardCount;
+
     @Inject
     public TransportSnapshotsStatusAction(
         TransportService transportService,
@@ -314,38 +320,34 @@ private void loadRepositoryData(
         String repositoryName,
         ActionListener<SnapshotsStatusResponse> listener
     ) {
-        final Set<String> requestedSnapshotNames = Sets.newHashSet(request.snapshots());
+        maximumAllowedShardCount = clusterService.getClusterSettings().get(MAX_SHARDS_ALLOWED_IN_STATUS_API);
         final StepListener<RepositoryData> repositoryDataListener = new StepListener<>();
         repositoriesService.getRepositoryData(repositoryName, repositoryDataListener);
         repositoryDataListener.whenComplete(repositoryData -> {
-            final Map<String, SnapshotId> matchedSnapshotIds = repositoryData.getSnapshotIds()
-                .stream()
-                .filter(s -> requestedSnapshotNames.contains(s.getName()))
-                .collect(Collectors.toMap(SnapshotId::getName, Function.identity()));
-            for (final String snapshotName : request.snapshots()) {
-                if (currentSnapshotNames.contains(snapshotName)) {
-                    // we've already found this snapshot in the current snapshot entries, so skip over
-                    continue;
-                }
-                SnapshotId snapshotId = matchedSnapshotIds.get(snapshotName);
-                if (snapshotId == null) {
-                    // neither in the current snapshot entries nor found in the repository
-                    if (request.ignoreUnavailable()) {
-                        // ignoring unavailable snapshots, so skip over
-                        logger.debug(
-                            "snapshot status request ignoring snapshot [{}], not found in repository [{}]",
-                            snapshotName,
-                            repositoryName
-                        );
-                        continue;
-                    } else {
-                        throw new SnapshotMissingException(repositoryName, snapshotName);
-                    }
-                }
-                SnapshotInfo snapshotInfo = snapshot(snapshotsInProgress, repositoryName, snapshotId);
+            Map<SnapshotId, SnapshotInfo> snapshotsInfoMap = snapshotsInfo(
+                request,
+                repositoryName,
+                repositoryData,
+                snapshotsInProgress,
+                currentSnapshotNames
+            );
+            for (Map.Entry<SnapshotId, SnapshotInfo> entry : snapshotsInfoMap.entrySet()) {
+                SnapshotId snapshotId = entry.getKey();
+                SnapshotInfo snapshotInfo = entry.getValue();
                 List<SnapshotIndexShardStatus> shardStatusBuilder = new ArrayList<>();
                 if (snapshotInfo.state().completed()) {
-                    Map<ShardId, IndexShardSnapshotStatus> shardStatuses = snapshotShards(repositoryName, repositoryData, snapshotInfo);
+                    Map<ShardId, IndexShardSnapshotStatus> shardStatuses = snapshotShards(
+                        request,
+                        repositoryName,
+                        repositoryData,
+                        snapshotInfo
+                    );
+                    boolean isShallowV2Snapshot = snapshotInfo.getPinnedTimestamp() > 0;
+                    long initialSnapshotTotalSize = 0;
+                    if (isShallowV2Snapshot && request.indices().length == 0) {
+                        // TODO: add primary store size in bytes at the snapshot level
+                    }
+
                     for (Map.Entry<ShardId, IndexShardSnapshotStatus> shardStatus : shardStatuses.entrySet()) {
                         IndexShardSnapshotStatus.Copy lastSnapshotStatus = shardStatus.getValue().asCopy();
                         shardStatusBuilder.add(new SnapshotIndexShardStatus(shardStatus.getKey(), lastSnapshotStatus));
@@ -406,6 +408,72 @@ private SnapshotInfo snapshot(SnapshotsInProgress snapshotsInProgress, String re
         return repositoriesService.repository(repositoryName).getSnapshotInfo(snapshotId);
     }
 
+    /**
+     * Returns snapshot info for finished snapshots
+     * @param request         snapshot status request
+     * @param repositoryName  repository name
+     * @param repositoryData    repository data
+     * @param snapshotsInProgress    currently running snapshots
+     * @param currentSnapshotNames    list of names of currently running snapshots
+     * @return map of snapshot id to snapshot info
+     */
+    private Map<SnapshotId, SnapshotInfo> snapshotsInfo(
+        SnapshotsStatusRequest request,
+        String repositoryName,
+        RepositoryData repositoryData,
+        SnapshotsInProgress snapshotsInProgress,
+        Set<String> currentSnapshotNames
+    ) {
+        final Set<String> requestedSnapshotNames = Sets.newHashSet(request.snapshots());
+        final Map<SnapshotId, SnapshotInfo> snapshotsInfoMap = new HashMap<>();
+        final Map<String, SnapshotId> matchedSnapshotIds = repositoryData.getSnapshotIds()
+            .stream()
+            .filter(s -> requestedSnapshotNames.contains(s.getName()))
+            .collect(Collectors.toMap(SnapshotId::getName, Function.identity()));
+        int totalShardsAcrossSnapshots = 0;
+        for (final String snapshotName : request.snapshots()) {
+            if (currentSnapshotNames.contains(snapshotName)) {
+                // we've already found this snapshot in the current snapshot entries, so skip over
+                continue;
+            }
+            SnapshotId snapshotId = matchedSnapshotIds.get(snapshotName);
+            if (snapshotId == null) {
+                // neither in the current snapshot entries nor found in the repository
+                if (request.ignoreUnavailable()) {
+                    // ignoring unavailable snapshots, so skip over
+                    logger.debug(
+                        "snapshot status request ignoring snapshot [{}], not found in repository [{}]",
+                        snapshotName,
+                        repositoryName
+                    );
+                    continue;
+                } else {
+                    throw new SnapshotMissingException(repositoryName, snapshotName);
+                }
+            }
+            SnapshotInfo snapshotInfo = snapshot(snapshotsInProgress, repositoryName, snapshotId);
+            boolean isV2Snapshot = snapshotInfo.getPinnedTimestamp() > 0;
+            if (isV2Snapshot == false && request.indices().length == 0) {
+                totalShardsAcrossSnapshots += snapshotInfo.totalShards();
+            }
+            snapshotsInfoMap.put(snapshotId, snapshotInfo);
+        }
+        if (totalShardsAcrossSnapshots > maximumAllowedShardCount && request.indices().length == 0) {
+            String message = "["
+                + repositoryName
+                + ":"
+                + String.join(", ", request.snapshots())
+                + "]"
+                + " Total shard count ["
+                + totalShardsAcrossSnapshots
+                + "] is more than the maximum allowed value of shard count ["
+                + maximumAllowedShardCount
+                + "] for snapshot status request";
+            throw new CircuitBreakingException(message, CircuitBreaker.Durability.PERMANENT);
+        }
+        return unmodifiableMap(snapshotsInfoMap);
+    }
+
     /**
      * Returns status of shards currently finished snapshots
      * <p>
@@ -413,21 +481,69 @@ private SnapshotInfo snapshot(SnapshotsInProgress snapshotsInProgress, String re
      * {@link SnapshotShardsService#currentSnapshotShards(Snapshot)} because it
      * returns similar information but for already finished snapshots.
      * </p>
-     *
+     * @param request         snapshot status request
      * @param repositoryName  repository name
      * @param snapshotInfo    snapshot info
      * @return map of shard id to snapshot status
      */
     private Map<ShardId, IndexShardSnapshotStatus> snapshotShards(
+        final SnapshotsStatusRequest request,
         final String repositoryName,
         final RepositoryData repositoryData,
         final SnapshotInfo snapshotInfo
     ) throws IOException {
+        final Set<String> requestedIndexNames = Sets.newHashSet(request.indices());
+        String snapshotName = snapshotInfo.snapshotId().getName();
+        Set<String> indices = Sets.newHashSet(snapshotInfo.indices());
+        if (requestedIndexNames.isEmpty() == false) {
+            Set<String> finalIndices = indices;
+            List<String> indicesNotFound = requestedIndexNames.stream()
+                .filter(i -> finalIndices.contains(i) == false)
+                .collect(Collectors.toList());
+            if (indicesNotFound.isEmpty() == false) {
+                handleIndexNotFound(String.join(", ", indicesNotFound), request, snapshotName, repositoryName);
+            }
+            indices = requestedIndexNames;
+        }
+
         final Repository repository = repositoriesService.repository(repositoryName);
-        final Map<ShardId, IndexShardSnapshotStatus> shardStatus = new HashMap<>();
-        for (String index : snapshotInfo.indices()) {
+        boolean isV2Snapshot = snapshotInfo.getPinnedTimestamp() > 0;
+        int totalShardsAcrossIndices = 0;
+        final Map<IndexId, IndexMetadata> indexMetadataMap = new HashMap<>();
+
+        for (String index : indices) {
             IndexId indexId = repositoryData.resolveIndexId(index);
             IndexMetadata indexMetadata = repository.getSnapshotIndexMetaData(repositoryData, snapshotInfo.snapshotId(), indexId);
+            if (indexMetadata != null) {
+                if (requestedIndexNames.isEmpty() == false && isV2Snapshot == false) {
+                    totalShardsAcrossIndices += indexMetadata.getNumberOfShards();
+                }
+                indexMetadataMap.put(indexId, indexMetadata);
+            } else if (requestedIndexNames.isEmpty() == false) {
+                handleIndexNotFound(index, request, snapshotName, repositoryName);
+            }
+        }
+
+        if (totalShardsAcrossIndices > maximumAllowedShardCount && requestedIndexNames.isEmpty() == false && isV2Snapshot == false) {
+            String message = "["
+                + repositoryName
+                + ":"
+                + String.join(", ", request.snapshots())
+                + "]"
+                + " Total shard count ["
+                + totalShardsAcrossIndices
+                + "] across the requested indices ["
+                + requestedIndexNames.stream().collect(Collectors.joining(", "))
+                + "] is more than the maximum allowed value of shard count ["
+                + maximumAllowedShardCount
+                + "] for snapshot status request";
+            throw new CircuitBreakingException(message, CircuitBreaker.Durability.PERMANENT);
+        }
+
+        final Map<ShardId, IndexShardSnapshotStatus> shardStatus = new HashMap<>();
+        for (Map.Entry<IndexId, IndexMetadata> entry : indexMetadataMap.entrySet()) {
+            IndexId indexId = entry.getKey();
+            IndexMetadata indexMetadata = entry.getValue();
             if (indexMetadata != null) {
                 int numberOfShards = indexMetadata.getNumberOfShards();
                 for (int i = 0; i < numberOfShards; i++) {
@@ -447,7 +563,12 @@ private Map<ShardId, IndexShardSnapshotStatus> snapshotShards(
                             // could not be taken due to partial being set to false.
                             shardSnapshotStatus = IndexShardSnapshotStatus.newFailed("skipped");
                         } else {
-                            shardSnapshotStatus = repository.getShardSnapshotStatus(snapshotInfo.snapshotId(), indexId, shardId);
+                            // TODO: to be refactored later
+                            if (isV2Snapshot) {
+                                shardSnapshotStatus = IndexShardSnapshotStatus.newDone(0, 0, 0, 0, 0, 0, null);
+                            } else {
+                                shardSnapshotStatus = repository.getShardSnapshotStatus(snapshotInfo.snapshotId(), indexId, shardId);
+                            }
                         }
                         shardStatus.put(shardId, shardSnapshotStatus);
                     }
@@ -457,6 +578,21 @@ private Map<ShardId, IndexShardSnapshotStatus> snapshotShards(
         return unmodifiableMap(shardStatus);
     }
 
+    private void handleIndexNotFound(String index, SnapshotsStatusRequest request, String snapshotName, String repositoryName) {
+        if (request.ignoreUnavailable()) {
+            // ignoring unavailable index
+            logger.debug(
+                "snapshot status request ignoring indices [{}], not found in snapshot[{}] in repository [{}]",
+                index,
+                snapshotName,
+                repositoryName
+            );
+        } else {
+            String cause = "indices [" + index + "] missing in snapshot [" + snapshotName + "] of repository [" + repositoryName + "]";
+            throw new IndexNotFoundException(index, new IllegalArgumentException(cause));
+        }
+    }
+
     private static SnapshotShardFailure findShardFailure(List<SnapshotShardFailure> shardFailures, ShardId shardId) {
         for (SnapshotShardFailure shardFailure : shardFailures) {
             if (shardId.getIndexName().equals(shardFailure.index()) && shardId.getId() == shardFailure.shardId()) {
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
index 90a52f7406d57..66bb64ca5580b 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/ClusterStateRequest.java
@@ -41,8 +41,12 @@
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.tasks.TaskId;
+import org.opensearch.rest.action.admin.cluster.ClusterAdminTask;
+import org.opensearch.tasks.Task;
 
 import java.io.IOException;
+import java.util.Map;
 
 /**
  * Transport request for obtaining cluster state
@@ -211,4 +215,13 @@ public ClusterStateRequest waitForMetadataVersion(long waitForMetadataVersion) {
         this.waitForMetadataVersion = waitForMetadataVersion;
         return this;
     }
+
+    @Override
+    public Task createTask(long id, String type, String action, TaskId parentTaskId, Map<String, String> headers) {
+        if (this.getShouldCancelOnTimeout()) {
+            return new ClusterAdminTask(id, type, action, parentTaskId, headers);
+        } else {
+            return super.createTask(id, type, action, parentTaskId, headers);
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
index cae465a90446e..13ea7eaa43bf8 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/state/TransportClusterStateAction.java
@@ -92,6 +92,7 @@ public TransportClusterStateAction(
             ClusterStateRequest::new,
             indexNameExpressionResolver
         );
+        this.localExecuteSupported = true;
     }
 
     @Override
@@ -233,9 +234,4 @@ private ClusterStateResponse buildResponse(final ClusterStateRequest request, fi
 
         return new ClusterStateResponse(currentState.getClusterName(), builder.build(), false);
     }
-
-    @Override
-    protected boolean localExecuteSupportedByAction() {
-        return true;
-    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIndices.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIndices.java
index 26e554f44fca1..03a73f45ffe81 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIndices.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsIndices.java
@@ -78,26 +78,49 @@ public ClusterStatsIndices(List<ClusterStatsNodeResponse> nodeResponses, Mapping
         this.segments = new SegmentsStats();
 
         for (ClusterStatsNodeResponse r : nodeResponses) {
-            for (org.opensearch.action.admin.indices.stats.ShardStats shardStats : r.shardsStats()) {
-                ShardStats indexShardStats = countsPerIndex.get(shardStats.getShardRouting().getIndexName());
-                if (indexShardStats == null) {
-                    indexShardStats = new ShardStats();
-                    countsPerIndex.put(shardStats.getShardRouting().getIndexName(), indexShardStats);
+            // Aggregated response from the node
+            if (r.getAggregatedNodeLevelStats() != null) {
+
+                for (Map.Entry<String, ClusterStatsNodeResponse.AggregatedIndexStats> entry : r.getAggregatedNodeLevelStats().indexStatsMap
+                    .entrySet()) {
+                    ShardStats indexShardStats = countsPerIndex.get(entry.getKey());
+                    if (indexShardStats == null) {
+                        indexShardStats = new ShardStats(entry.getValue());
+                        countsPerIndex.put(entry.getKey(), indexShardStats);
+                    } else {
+                        indexShardStats.addStatsFrom(entry.getValue());
+                    }
                 }
 
-                indexShardStats.total++;
-
-                CommonStats shardCommonStats = shardStats.getStats();
-
-                if (shardStats.getShardRouting().primary()) {
-                    indexShardStats.primaries++;
-                    docs.add(shardCommonStats.docs);
+                docs.add(r.getAggregatedNodeLevelStats().commonStats.docs);
+                store.add(r.getAggregatedNodeLevelStats().commonStats.store);
+                fieldData.add(r.getAggregatedNodeLevelStats().commonStats.fieldData);
+                queryCache.add(r.getAggregatedNodeLevelStats().commonStats.queryCache);
+                completion.add(r.getAggregatedNodeLevelStats().commonStats.completion);
+                segments.add(r.getAggregatedNodeLevelStats().commonStats.segments);
+            } else {
+                // Default response from the node
+                for (org.opensearch.action.admin.indices.stats.ShardStats shardStats : r.shardsStats()) {
+                    ShardStats indexShardStats = countsPerIndex.get(shardStats.getShardRouting().getIndexName());
+                    if (indexShardStats == null) {
+                        indexShardStats = new ShardStats();
+                        countsPerIndex.put(shardStats.getShardRouting().getIndexName(), indexShardStats);
+                    }
+
+                    indexShardStats.total++;
+
+                    CommonStats shardCommonStats = shardStats.getStats();
+
+                    if (shardStats.getShardRouting().primary()) {
+                        indexShardStats.primaries++;
+                        docs.add(shardCommonStats.docs);
+                    }
+                    store.add(shardCommonStats.store);
+                    fieldData.add(shardCommonStats.fieldData);
+                    queryCache.add(shardCommonStats.queryCache);
+                    completion.add(shardCommonStats.completion);
+                    segments.add(shardCommonStats.segments);
                 }
-                store.add(shardCommonStats.store);
-                fieldData.add(shardCommonStats.fieldData);
-                queryCache.add(shardCommonStats.queryCache);
-                completion.add(shardCommonStats.completion);
-                segments.add(shardCommonStats.segments);
             }
         }
 
@@ -202,6 +225,11 @@ public static class ShardStats implements ToXContentFragment {
 
         public ShardStats() {}
 
+        public ShardStats(ClusterStatsNodeResponse.AggregatedIndexStats aggregatedIndexStats) {
+            this.total = aggregatedIndexStats.total;
+            this.primaries = aggregatedIndexStats.primaries;
+        }
+
         /**
          * number of indices in the cluster
          */
@@ -329,6 +357,11 @@ public void addIndexShardCount(ShardStats indexShardCount) {
             }
         }
 
+        public void addStatsFrom(ClusterStatsNodeResponse.AggregatedIndexStats incomingStats) {
+            this.total += incomingStats.total;
+            this.primaries += incomingStats.primaries;
+        }
+
         /**
          * Inner Fields used for creating XContent and parsing
          *
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodeResponse.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodeResponse.java
index 1b25bf84356d6..6ed3ca7c409e7 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodeResponse.java
@@ -32,17 +32,29 @@
 
 package org.opensearch.action.admin.cluster.stats;
 
+import org.opensearch.Version;
 import org.opensearch.action.admin.cluster.node.info.NodeInfo;
 import org.opensearch.action.admin.cluster.node.stats.NodeStats;
+import org.opensearch.action.admin.indices.stats.CommonStats;
 import org.opensearch.action.admin.indices.stats.ShardStats;
 import org.opensearch.action.support.nodes.BaseNodeResponse;
 import org.opensearch.cluster.health.ClusterHealthStatus;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.index.cache.query.QueryCacheStats;
+import org.opensearch.index.engine.SegmentsStats;
+import org.opensearch.index.fielddata.FieldDataStats;
+import org.opensearch.index.shard.DocsStats;
+import org.opensearch.index.store.StoreStats;
+import org.opensearch.search.suggest.completion.CompletionStats;
 
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
 /**
  * Transport action for obtaining cluster stats from node level
@@ -55,6 +67,7 @@ public class ClusterStatsNodeResponse extends BaseNodeResponse {
     private final NodeStats nodeStats;
     private final ShardStats[] shardsStats;
     private ClusterHealthStatus clusterStatus;
+    private AggregatedNodeLevelStats aggregatedNodeLevelStats;
 
     public ClusterStatsNodeResponse(StreamInput in) throws IOException {
         super(in);
@@ -64,7 +77,12 @@ public ClusterStatsNodeResponse(StreamInput in) throws IOException {
         }
         this.nodeInfo = new NodeInfo(in);
         this.nodeStats = new NodeStats(in);
-        shardsStats = in.readArray(ShardStats::new, ShardStats[]::new);
+        if (in.getVersion().onOrAfter(Version.V_2_16_0)) {
+            this.shardsStats = in.readOptionalArray(ShardStats::new, ShardStats[]::new);
+            this.aggregatedNodeLevelStats = in.readOptionalWriteable(AggregatedNodeLevelStats::new);
+        } else {
+            this.shardsStats = in.readArray(ShardStats::new, ShardStats[]::new);
+        }
     }
 
     public ClusterStatsNodeResponse(
@@ -81,6 +99,24 @@ public ClusterStatsNodeResponse(
         this.clusterStatus = clusterStatus;
     }
 
+    public ClusterStatsNodeResponse(
+        DiscoveryNode node,
+        @Nullable ClusterHealthStatus clusterStatus,
+        NodeInfo nodeInfo,
+        NodeStats nodeStats,
+        ShardStats[] shardsStats,
+        boolean useAggregatedNodeLevelResponses
+    ) {
+        super(node);
+        this.nodeInfo = nodeInfo;
+        this.nodeStats = nodeStats;
+        if (useAggregatedNodeLevelResponses) {
+            this.aggregatedNodeLevelStats = new AggregatedNodeLevelStats(node, shardsStats);
+        }
+        this.shardsStats = shardsStats;
+        this.clusterStatus = clusterStatus;
+    }
+
     public NodeInfo nodeInfo() {
         return this.nodeInfo;
     }
@@ -101,6 +137,10 @@ public ShardStats[] shardsStats() {
         return this.shardsStats;
     }
 
+    public AggregatedNodeLevelStats getAggregatedNodeLevelStats() {
+        return aggregatedNodeLevelStats;
+    }
+
     public static ClusterStatsNodeResponse readNodeResponse(StreamInput in) throws IOException {
         return new ClusterStatsNodeResponse(in);
     }
@@ -116,6 +156,95 @@ public void writeTo(StreamOutput out) throws IOException {
         }
         nodeInfo.writeTo(out);
         nodeStats.writeTo(out);
-        out.writeArray(shardsStats);
+        if (out.getVersion().onOrAfter(Version.V_2_16_0)) {
+            if (aggregatedNodeLevelStats != null) {
+                out.writeOptionalArray(null);
+                out.writeOptionalWriteable(aggregatedNodeLevelStats);
+            } else {
+                out.writeOptionalArray(shardsStats);
+                out.writeOptionalWriteable(null);
+            }
+        } else {
+            out.writeArray(shardsStats);
+        }
+    }
+
+    /**
+     * Node level statistics used for ClusterStatsIndices for _cluster/stats call.
+     */
+    public class AggregatedNodeLevelStats extends BaseNodeResponse {
+
+        CommonStats commonStats;
+        Map<String, AggregatedIndexStats> indexStatsMap;
+
+        protected AggregatedNodeLevelStats(StreamInput in) throws IOException {
+            super(in);
+            commonStats = in.readOptionalWriteable(CommonStats::new);
+            indexStatsMap = in.readMap(StreamInput::readString, AggregatedIndexStats::new);
+        }
+
+        protected AggregatedNodeLevelStats(DiscoveryNode node, ShardStats[] indexShardsStats) {
+            super(node);
+            this.commonStats = new CommonStats();
+            this.commonStats.docs = new DocsStats();
+            this.commonStats.store = new StoreStats();
+            this.commonStats.fieldData = new FieldDataStats();
+            this.commonStats.queryCache = new QueryCacheStats();
+            this.commonStats.completion = new CompletionStats();
+            this.commonStats.segments = new SegmentsStats();
+            this.indexStatsMap = new HashMap<>();
+
+            // Index Level Stats
+            for (org.opensearch.action.admin.indices.stats.ShardStats shardStats : indexShardsStats) {
+                AggregatedIndexStats indexShardStats = this.indexStatsMap.get(shardStats.getShardRouting().getIndexName());
+                if (indexShardStats == null) {
+                    indexShardStats = new AggregatedIndexStats();
+                    this.indexStatsMap.put(shardStats.getShardRouting().getIndexName(), indexShardStats);
+                }
+
+                indexShardStats.total++;
+
+                CommonStats shardCommonStats = shardStats.getStats();
+
+                if (shardStats.getShardRouting().primary()) {
+                    indexShardStats.primaries++;
+                    this.commonStats.docs.add(shardCommonStats.docs);
+                }
+                this.commonStats.store.add(shardCommonStats.store);
+                this.commonStats.fieldData.add(shardCommonStats.fieldData);
+                this.commonStats.queryCache.add(shardCommonStats.queryCache);
+                this.commonStats.completion.add(shardCommonStats.completion);
+                this.commonStats.segments.add(shardCommonStats.segments);
+            }
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            super.writeTo(out);
+            out.writeOptionalWriteable(commonStats);
+            out.writeMap(indexStatsMap, StreamOutput::writeString, (stream, stats) -> stats.writeTo(stream));
+        }
+    }
+
+    /**
+     * Node level statistics used for ClusterStatsIndices for _cluster/stats call.
+     */
+    @PublicApi(since = "2.16.0")
+    public static class AggregatedIndexStats implements Writeable {
+        public int total = 0;
+        public int primaries = 0;
+
+        public AggregatedIndexStats(StreamInput in) throws IOException {
+            total = in.readVInt();
+            primaries = in.readVInt();
+        }
+
+        public AggregatedIndexStats() {}
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeVInt(total);
+            out.writeVInt(primaries);
+        }
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequest.java
index 6a99451c596ed..bd75b2210e474 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequest.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.action.admin.cluster.stats;
 
+import org.opensearch.Version;
 import org.opensearch.action.support.nodes.BaseNodesRequest;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -49,8 +50,13 @@ public class ClusterStatsRequest extends BaseNodesRequest<ClusterStatsRequest> {
 
     public ClusterStatsRequest(StreamInput in) throws IOException {
         super(in);
+        if (in.getVersion().onOrAfter(Version.V_2_16_0)) {
+            useAggregatedNodeLevelResponses = in.readOptionalBoolean();
+        }
     }
 
+    private Boolean useAggregatedNodeLevelResponses = false;
+
     /**
      * Get stats from nodes based on the nodes ids specified. If none are passed, stats
      * based on all nodes will be returned.
@@ -59,9 +65,20 @@ public ClusterStatsRequest(String... nodesIds) {
         super(nodesIds);
     }
 
+    public boolean useAggregatedNodeLevelResponses() {
+        return useAggregatedNodeLevelResponses;
+    }
+
+    public void useAggregatedNodeLevelResponses(boolean useAggregatedNodeLevelResponses) {
+        this.useAggregatedNodeLevelResponses = useAggregatedNodeLevelResponses;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
+        if (out.getVersion().onOrAfter(Version.V_2_16_0)) {
+            out.writeOptionalBoolean(useAggregatedNodeLevelResponses);
+        }
     }
 
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequestBuilder.java
index 0dcb03dc26d0e..4d0932bd3927d 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/ClusterStatsRequestBuilder.java
@@ -50,4 +50,9 @@ public class ClusterStatsRequestBuilder extends NodesOperationRequestBuilder<
     public ClusterStatsRequestBuilder(OpenSearchClient client, ClusterStatsAction action) {
         super(client, action, new ClusterStatsRequest());
     }
+
+    public final ClusterStatsRequestBuilder useAggregatedNodeLevelResponses(boolean useAggregatedNodeLevelResponses) {
+        request.useAggregatedNodeLevelResponses(useAggregatedNodeLevelResponses);
+        return this;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
index 61adca8d89747..f79019bf0e7b6 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/stats/TransportClusterStatsAction.java
@@ -217,9 +217,9 @@ protected ClusterStatsNodeResponse nodeOperation(ClusterStatsNodeRequest nodeReq
             clusterStatus,
             nodeInfo,
             nodeStats,
-            shardsStats.toArray(new ShardStats[shardsStats.size()])
+            shardsStats.toArray(new ShardStats[0]),
+            nodeRequest.request.useAggregatedNodeLevelResponses()
         );
-
     }
 
     /**
@@ -229,7 +229,7 @@ protected ClusterStatsNodeResponse nodeOperation(ClusterStatsNodeRequest nodeReq
      */
     public static class ClusterStatsNodeRequest extends BaseNodeRequest {
 
-        ClusterStatsRequest request;
+        protected ClusterStatsRequest request;
 
         public ClusterStatsNodeRequest(StreamInput in) throws IOException {
             super(in);
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/storedscripts/TransportGetStoredScriptAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/storedscripts/TransportGetStoredScriptAction.java
index db1f1edde2812..c34ec49406802 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/storedscripts/TransportGetStoredScriptAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/storedscripts/TransportGetStoredScriptAction.java
@@ -73,7 +73,8 @@ public TransportGetStoredScriptAction(
             threadPool,
             actionFilters,
             GetStoredScriptRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.scriptService = scriptService;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/cluster/tasks/TransportPendingClusterTasksAction.java b/server/src/main/java/org/opensearch/action/admin/cluster/tasks/TransportPendingClusterTasksAction.java
index 5d5053cc80738..01846ef46c1ed 100644
--- a/server/src/main/java/org/opensearch/action/admin/cluster/tasks/TransportPendingClusterTasksAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/cluster/tasks/TransportPendingClusterTasksAction.java
@@ -110,4 +110,9 @@ protected void clusterManagerOperation(
         logger.trace("done fetching pending tasks from cluster service");
         listener.onResponse(new PendingClusterTasksResponse(pendingTasks));
     }
+
+    @Override
+    protected boolean localExecuteSupportedByAction() {
+        return false;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/alias/get/TransportGetAliasesAction.java b/server/src/main/java/org/opensearch/action/admin/indices/alias/get/TransportGetAliasesAction.java
index 3aca9c1976f16..4f4e3bd481ee7 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/alias/get/TransportGetAliasesAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/alias/get/TransportGetAliasesAction.java
@@ -86,7 +86,8 @@ public TransportGetAliasesAction(
             threadPool,
             actionFilters,
             GetAliasesRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.systemIndices = systemIndices;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexClusterStateUpdateRequest.java b/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexClusterStateUpdateRequest.java
index ad45e5346f9fa..d7e86744ad528 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexClusterStateUpdateRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexClusterStateUpdateRequest.java
@@ -37,6 +37,7 @@
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.cluster.ack.ClusterStateUpdateRequest;
 import org.opensearch.cluster.block.ClusterBlock;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.index.Index;
@@ -65,6 +66,8 @@ public class CreateIndexClusterStateUpdateRequest extends ClusterStateUpdateRequ
 
     private final Set<Alias> aliases = new HashSet<>();
 
+    private Context context;
+
     private final Set<ClusterBlock> blocks = new HashSet<>();
 
     private ActiveShardCount waitForActiveShards = ActiveShardCount.DEFAULT;
@@ -90,6 +93,11 @@ public CreateIndexClusterStateUpdateRequest aliases(Set<Alias> aliases) {
         return this;
     }
 
+    public CreateIndexClusterStateUpdateRequest context(Context context) {
+        this.context = context;
+        return this;
+    }
+
     public CreateIndexClusterStateUpdateRequest recoverFrom(Index recoverFrom) {
         this.recoverFrom = recoverFrom;
         return this;
@@ -130,6 +138,10 @@ public Set<Alias> aliases() {
         return aliases;
     }
 
+    public Context context() {
+        return context;
+    }
+
     public Set<ClusterBlock> blocks() {
         return blocks;
     }
@@ -199,6 +211,8 @@ public String toString() {
             + settings
             + ", aliases="
             + aliases
+            + ", context="
+            + context
             + ", blocks="
             + blocks
             + ", waitForActiveShards="
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequest.java b/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequest.java
index 6713d271ef5d1..4be3584fd8481 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequest.java
@@ -43,6 +43,7 @@
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.action.support.master.AcknowledgedRequest;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.LoggingDeprecationHandler;
@@ -90,6 +91,7 @@ public class CreateIndexRequest extends AcknowledgedRequest<CreateIndexRequest>
     public static final ParseField MAPPINGS = new ParseField("mappings");
     public static final ParseField SETTINGS = new ParseField("settings");
     public static final ParseField ALIASES = new ParseField("aliases");
+    public static final ParseField CONTEXT = new ParseField("context");
 
     private String cause = "";
 
@@ -101,6 +103,8 @@ public class CreateIndexRequest extends AcknowledgedRequest<CreateIndexRequest>
 
     private final Set<Alias> aliases = new HashSet<>();
 
+    private Context context;
+
     private ActiveShardCount waitForActiveShards = ActiveShardCount.DEFAULT;
 
     public CreateIndexRequest(StreamInput in) throws IOException {
@@ -132,6 +136,9 @@ public CreateIndexRequest(StreamInput in) throws IOException {
             in.readBoolean(); // updateAllTypes
         }
         waitForActiveShards = ActiveShardCount.readFrom(in);
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            context = in.readOptionalWriteable(Context::new);
+        }
     }
 
     public CreateIndexRequest() {}
@@ -528,6 +535,8 @@ public CreateIndexRequest source(Map<String, ?> source, DeprecationHandler depre
                 }
             } else if (ALIASES.match(name, deprecationHandler)) {
                 aliases((Map<String, Object>) entry.getValue());
+            } else if (CONTEXT.match(name, deprecationHandler)) {
+                context((Map<String, Object>) entry.getValue());
             } else {
                 throw new OpenSearchParseException("unknown key [{}] for create index", name);
             }
@@ -575,6 +584,36 @@ public CreateIndexRequest waitForActiveShards(final int waitForActiveShards) {
         return waitForActiveShards(ActiveShardCount.from(waitForActiveShards));
     }
 
+    public CreateIndexRequest context(Map<String, ?> source) {
+        try {
+            XContentBuilder builder = XContentFactory.jsonBuilder();
+            builder.map(source);
+            return context(BytesReference.bytes(builder));
+        } catch (IOException e) {
+            throw new OpenSearchGenerationException("Failed to generate [" + source + "]", e);
+        }
+    }
+
+    public CreateIndexRequest context(BytesReference source) {
+        // EMPTY is safe here because we never call namedObject
+        try (XContentParser parser = XContentHelper.createParser(NamedXContentRegistry.EMPTY, LoggingDeprecationHandler.INSTANCE, source)) {
+            // move to the first alias
+            context(Context.fromXContent(parser));
+            return this;
+        } catch (IOException e) {
+            throw new OpenSearchParseException("Failed to parse context", e);
+        }
+    }
+
+    public CreateIndexRequest context(Context context) {
+        this.context = context;
+        return this;
+    }
+
+    public Context context() {
+        return context;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
@@ -600,6 +639,9 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeBoolean(true); // updateAllTypes
         }
         waitForActiveShards.writeTo(out);
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeOptionalWriteable(context);
+        }
     }
 
     @Override
@@ -618,6 +660,9 @@ public String toString() {
             + '\''
             + ", aliases="
             + aliases
+            + '\''
+            + ", context="
+            + context
             + ", waitForActiveShards="
             + waitForActiveShards
             + '}';
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequestBuilder.java b/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequestBuilder.java
index b233f45422967..27a580434333a 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequestBuilder.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/create/CreateIndexRequestBuilder.java
@@ -36,6 +36,7 @@
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.action.support.master.AcknowledgedRequestBuilder;
 import org.opensearch.client.OpenSearchClient;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.LoggingDeprecationHandler;
@@ -275,4 +276,24 @@ public CreateIndexRequestBuilder setWaitForActiveShards(ActiveShardCount waitFor
     public CreateIndexRequestBuilder setWaitForActiveShards(final int waitForActiveShards) {
         return setWaitForActiveShards(ActiveShardCount.from(waitForActiveShards));
     }
+
+    /**
+     * Adds context that will be added when the index gets created.
+     *
+     * @param source The mapping source
+     */
+    public CreateIndexRequestBuilder setContext(Map<String, ?> source) {
+        request.context(source);
+        return this;
+    }
+
+    /**
+     * Adds context that will be added when the index gets created.
+     *
+     * @param source The context source
+     */
+    public CreateIndexRequestBuilder setContext(Context source) {
+        request.context(source);
+        return this;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/create/TransportCreateIndexAction.java b/server/src/main/java/org/opensearch/action/admin/indices/create/TransportCreateIndexAction.java
index b5f822bd45b7e..250693c130c85 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/create/TransportCreateIndexAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/create/TransportCreateIndexAction.java
@@ -121,6 +121,7 @@ protected void clusterManagerOperation(
             .settings(request.settings())
             .mappings(request.mappings())
             .aliases(request.aliases())
+            .context(request.context())
             .waitForActiveShards(request.waitForActiveShards());
 
         createIndexService.createIndex(
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/exists/indices/TransportIndicesExistsAction.java b/server/src/main/java/org/opensearch/action/admin/indices/exists/indices/TransportIndicesExistsAction.java
index 428a0eb35513d..a298eae1aa865 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/exists/indices/TransportIndicesExistsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/exists/indices/TransportIndicesExistsAction.java
@@ -71,7 +71,8 @@ public TransportIndicesExistsAction(
             threadPool,
             actionFilters,
             IndicesExistsRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/get/GetIndexRequest.java b/server/src/main/java/org/opensearch/action/admin/indices/get/GetIndexRequest.java
index 47c59791edf04..f8862967ddfef 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/get/GetIndexRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/get/GetIndexRequest.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.action.admin.indices.get;
 
+import org.opensearch.Version;
 import org.opensearch.action.ActionRequestValidationException;
 import org.opensearch.action.support.master.info.ClusterInfoRequest;
 import org.opensearch.common.annotation.PublicApi;
@@ -40,6 +41,7 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 
 import java.io.IOException;
+import java.util.Arrays;
 
 /**
  * A request to retrieve information about an index.
@@ -57,7 +59,8 @@ public class GetIndexRequest extends ClusterInfoRequest<GetIndexRequest> {
     public enum Feature {
         ALIASES((byte) 0),
         MAPPINGS((byte) 1),
-        SETTINGS((byte) 2);
+        SETTINGS((byte) 2),
+        CONTEXT((byte) 3);
 
         private static final Feature[] FEATURES = new Feature[Feature.values().length];
 
@@ -86,7 +89,11 @@ public static Feature fromId(byte id) {
         }
     }
 
-    private static final Feature[] DEFAULT_FEATURES = new Feature[] { Feature.ALIASES, Feature.MAPPINGS, Feature.SETTINGS };
+    private static final Feature[] DEFAULT_FEATURES = new Feature[] {
+        Feature.ALIASES,
+        Feature.MAPPINGS,
+        Feature.SETTINGS,
+        Feature.CONTEXT };
     private Feature[] features = DEFAULT_FEATURES;
     private boolean humanReadable = false;
     private transient boolean includeDefaults = false;
@@ -161,7 +168,18 @@ public boolean includeDefaults() {
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
-        out.writeArray((o, f) -> o.writeByte(f.id), features);
+        if (out.getVersion().onOrAfter(Version.V_2_17_0) || Arrays.stream(features).noneMatch(f -> f == Feature.CONTEXT)) {
+            out.writeArray((o, f) -> o.writeByte(f.id), features);
+        } else {
+            Feature[] updatedFeatures = new Feature[features.length - 1];
+            int cursor = 0;
+            for (Feature feature : features) {
+                if (feature != Feature.CONTEXT) {
+                    updatedFeatures[cursor++] = feature;
+                }
+            }
+            out.writeArray((o, f) -> o.writeByte(f.id), updatedFeatures);
+        }
         out.writeBoolean(humanReadable);
         out.writeBoolean(includeDefaults);
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/get/GetIndexResponse.java b/server/src/main/java/org/opensearch/action/admin/indices/get/GetIndexResponse.java
index 26e5aa21de2ac..6d738061dc304 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/get/GetIndexResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/get/GetIndexResponse.java
@@ -35,6 +35,7 @@
 import org.opensearch.LegacyESVersion;
 import org.opensearch.Version;
 import org.opensearch.cluster.metadata.AliasMetadata;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.MappingMetadata;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.settings.Settings;
@@ -69,6 +70,7 @@ public class GetIndexResponse extends ActionResponse implements ToXContentObject
     private Map<String, Settings> settings = Map.of();
     private Map<String, Settings> defaultSettings = Map.of();
     private Map<String, String> dataStreams = Map.of();
+    private Map<String, Context> contexts = Map.of();
     private final String[] indices;
 
     public GetIndexResponse(
@@ -78,6 +80,18 @@ public GetIndexResponse(
         final Map<String, Settings> settings,
         final Map<String, Settings> defaultSettings,
         final Map<String, String> dataStreams
+    ) {
+        this(indices, mappings, aliases, settings, defaultSettings, dataStreams, null);
+    }
+
+    public GetIndexResponse(
+        String[] indices,
+        Map<String, MappingMetadata> mappings,
+        final Map<String, List<AliasMetadata>> aliases,
+        final Map<String, Settings> settings,
+        final Map<String, Settings> defaultSettings,
+        final Map<String, String> dataStreams,
+        final Map<String, Context> contexts
     ) {
         this.indices = indices;
         // to have deterministic order
@@ -97,6 +111,9 @@ public GetIndexResponse(
         if (dataStreams != null) {
             this.dataStreams = Collections.unmodifiableMap(dataStreams);
         }
+        if (contexts != null) {
+            this.contexts = Collections.unmodifiableMap(contexts);
+        }
     }
 
     GetIndexResponse(StreamInput in) throws IOException {
@@ -163,6 +180,15 @@ public GetIndexResponse(
             }
             dataStreams = Collections.unmodifiableMap(dataStreamsMapBuilder);
         }
+
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            final Map<String, Context> contextMapBuilder = new HashMap<>();
+            int contextSize = in.readVInt();
+            for (int i = 0; i < contextSize; i++) {
+                contextMapBuilder.put(in.readString(), in.readOptionalWriteable(Context::new));
+            }
+            contexts = Collections.unmodifiableMap(contextMapBuilder);
+        }
     }
 
     public String[] indices() {
@@ -217,6 +243,10 @@ public Map<String, Settings> getSettings() {
         return settings();
     }
 
+    public Map<String, Context> contexts() {
+        return contexts;
+    }
+
     /**
      * Returns the string value for the specified index and setting.  If the includeDefaults flag was not set or set to
      * false on the {@link GetIndexRequest}, this method will only return a value where the setting was explicitly set
@@ -282,6 +312,14 @@ public void writeTo(StreamOutput out) throws IOException {
                 out.writeOptionalString(indexEntry.getValue());
             }
         }
+
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeVInt(contexts.size());
+            for (final Map.Entry<String, Context> indexEntry : contexts.entrySet()) {
+                out.writeString(indexEntry.getKey());
+                out.writeOptionalWriteable(indexEntry.getValue());
+            }
+        }
     }
 
     @Override
@@ -325,6 +363,11 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
                     if (dataStream != null) {
                         builder.field("data_stream", dataStream);
                     }
+
+                    Context context = contexts.get(index);
+                    if (context != null) {
+                        builder.field("context", context);
+                    }
                 }
                 builder.endObject();
             }
@@ -348,11 +391,12 @@ public boolean equals(Object o) {
             && Objects.equals(mappings, that.mappings)
             && Objects.equals(settings, that.settings)
             && Objects.equals(defaultSettings, that.defaultSettings)
-            && Objects.equals(dataStreams, that.dataStreams);
+            && Objects.equals(dataStreams, that.dataStreams)
+            && Objects.equals(contexts, that.contexts);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(Arrays.hashCode(indices), aliases, mappings, settings, defaultSettings, dataStreams);
+        return Objects.hash(Arrays.hashCode(indices), aliases, mappings, settings, defaultSettings, dataStreams, contexts);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/get/TransportGetIndexAction.java b/server/src/main/java/org/opensearch/action/admin/indices/get/TransportGetIndexAction.java
index 755119401c6b5..c6f4a8cd49ae9 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/get/TransportGetIndexAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/get/TransportGetIndexAction.java
@@ -36,6 +36,7 @@
 import org.opensearch.action.support.clustermanager.info.TransportClusterInfoAction;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.AliasMetadata;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.metadata.MappingMetadata;
@@ -110,6 +111,7 @@ protected void doClusterManagerOperation(
         Map<String, List<AliasMetadata>> aliasesResult = Map.of();
         Map<String, Settings> settings = Map.of();
         Map<String, Settings> defaultSettings = Map.of();
+        Map<String, Context> contexts = Map.of();
         final Map<String, String> dataStreams = new HashMap<>(
             StreamSupport.stream(Spliterators.spliterator(state.metadata().findDataStreams(concreteIndices).entrySet(), 0), false)
                 .collect(Collectors.toMap(k -> k.getKey(), v -> v.getValue().getName()))
@@ -118,6 +120,7 @@ protected void doClusterManagerOperation(
         boolean doneAliases = false;
         boolean doneMappings = false;
         boolean doneSettings = false;
+        boolean doneContext = false;
         for (GetIndexRequest.Feature feature : features) {
             switch (feature) {
                 case MAPPINGS:
@@ -159,11 +162,25 @@ protected void doClusterManagerOperation(
                         doneSettings = true;
                     }
                     break;
-
+                case CONTEXT:
+                    if (!doneContext) {
+                        final Map<String, Context> contextBuilder = new HashMap<>();
+                        for (String index : concreteIndices) {
+                            Context indexContext = state.metadata().index(index).context();
+                            if (indexContext != null) {
+                                contextBuilder.put(index, indexContext);
+                            }
+                        }
+                        contexts = contextBuilder;
+                        doneContext = true;
+                    }
+                    break;
                 default:
                     throw new IllegalStateException("feature [" + feature + "] is not valid");
             }
         }
-        listener.onResponse(new GetIndexResponse(concreteIndices, mappingsResult, aliasesResult, settings, defaultSettings, dataStreams));
+        listener.onResponse(
+            new GetIndexResponse(concreteIndices, mappingsResult, aliasesResult, settings, defaultSettings, dataStreams, contexts)
+        );
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/settings/put/TransportUpdateSettingsAction.java b/server/src/main/java/org/opensearch/action/admin/indices/settings/put/TransportUpdateSettingsAction.java
index 9265c6ae60678..09cceca52ce23 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/settings/put/TransportUpdateSettingsAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/settings/put/TransportUpdateSettingsAction.java
@@ -50,7 +50,6 @@
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.index.Index;
-import org.opensearch.index.IndexModule;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.TransportService;
 
@@ -59,8 +58,6 @@
 import java.util.Set;
 import java.util.stream.Stream;
 
-import static org.opensearch.index.IndexModule.INDEX_STORE_TYPE_SETTING;
-
 /**
  * Transport action for updating index settings
  *
@@ -133,9 +130,7 @@ protected ClusterBlockException checkBlock(UpdateSettingsRequest request, Cluste
         for (Index index : requestIndices) {
             if (state.blocks().indexBlocked(ClusterBlockLevel.METADATA_WRITE, index.getName())) {
                 allowSearchableSnapshotSettingsUpdate = allowSearchableSnapshotSettingsUpdate
-                    && IndexModule.Type.REMOTE_SNAPSHOT.match(
-                        state.getMetadata().getIndexSafe(index).getSettings().get(INDEX_STORE_TYPE_SETTING.getKey())
-                    );
+                    && state.getMetadata().getIndexSafe(index).isRemoteSnapshot();
             }
         }
         // check if all settings in the request are in the allow list
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java b/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
index 3fbf9ac1bb570..a8b97d0f344ae 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/shards/TransportIndicesShardStoresAction.java
@@ -105,7 +105,8 @@ public TransportIndicesShardStoresAction(
             threadPool,
             actionFilters,
             IndicesShardStoresRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
         this.listShardStoresInfo = listShardStoresInfo;
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
index 311511f18c218..223c3a0733c0f 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/CommonStatsFlags.java
@@ -68,6 +68,7 @@ public class CommonStatsFlags implements Writeable, Cloneable {
     // Used for metric CACHE_STATS, to determine which caches to report stats for
     private EnumSet<CacheType> includeCaches = EnumSet.noneOf(CacheType.class);
     private String[] levels = new String[0];
+    private boolean includeIndicesStatsByLevel = false;
 
     /**
      * @param flags flags to set. If no flags are supplied, default flags will be set.
@@ -106,6 +107,9 @@ public CommonStatsFlags(StreamInput in) throws IOException {
             includeCaches = in.readEnumSet(CacheType.class);
             levels = in.readStringArray();
         }
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            includeIndicesStatsByLevel = in.readBoolean();
+        }
     }
 
     @Override
@@ -135,6 +139,9 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeEnumSet(includeCaches);
             out.writeStringArrayNullable(levels);
         }
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeBoolean(includeIndicesStatsByLevel);
+        }
     }
 
     /**
@@ -149,7 +156,7 @@ public CommonStatsFlags all() {
         includeUnloadedSegments = false;
         includeAllShardIndexingPressureTrackers = false;
         includeOnlyTopIndexingPressureMetrics = false;
-        includeCaches = EnumSet.noneOf(CacheType.class);
+        includeCaches = EnumSet.allOf(CacheType.class);
         levels = new String[0];
         return this;
     }
@@ -273,6 +280,14 @@ public boolean includeSegmentFileSizes() {
         return this.includeSegmentFileSizes;
     }
 
+    public void setIncludeIndicesStatsByLevel(boolean includeIndicesStatsByLevel) {
+        this.includeIndicesStatsByLevel = includeIndicesStatsByLevel;
+    }
+
+    public boolean getIncludeIndicesStatsByLevel() {
+        return this.includeIndicesStatsByLevel;
+    }
+
     public boolean isSet(Flag flag) {
         return flags.contains(flag);
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/IndicesStatsRequest.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/IndicesStatsRequest.java
index 2b64464a76899..c36e53098d166 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/IndicesStatsRequest.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/IndicesStatsRequest.java
@@ -36,8 +36,12 @@
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.tasks.TaskId;
+import org.opensearch.rest.action.admin.cluster.ClusterAdminTask;
+import org.opensearch.tasks.Task;
 
 import java.io.IOException;
+import java.util.Map;
 
 /**
  * A request to get indices level stats. Allow to enable different stats to be returned.
@@ -103,6 +107,15 @@ public IndicesStatsRequest groups(String... groups) {
         return this;
     }
 
+    @Override
+    public Task createTask(long id, String type, String action, TaskId parentTaskId, Map<String, String> headers) {
+        if (this.getShouldCancelOnTimeout()) {
+            return new ClusterAdminTask(id, type, action, parentTaskId, headers);
+        } else {
+            return super.createTask(id, type, action, parentTaskId, headers);
+        }
+    }
+
     public String[] groups() {
         return this.flags.groups();
     }
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/stats/IndicesStatsResponse.java b/server/src/main/java/org/opensearch/action/admin/indices/stats/IndicesStatsResponse.java
index 6242081cd2371..900a886481fe6 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/stats/IndicesStatsResponse.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/stats/IndicesStatsResponse.java
@@ -69,7 +69,7 @@ public class IndicesStatsResponse extends BroadcastResponse {
         shards = in.readArray(ShardStats::new, (size) -> new ShardStats[size]);
     }
 
-    IndicesStatsResponse(
+    public IndicesStatsResponse(
         ShardStats[] shards,
         int totalShards,
         int successfulShards,
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComponentTemplateAction.java b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComponentTemplateAction.java
index e2594cd792cd3..c3217d109044d 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComponentTemplateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComponentTemplateAction.java
@@ -76,7 +76,8 @@ public TransportGetComponentTemplateAction(
             threadPool,
             actionFilters,
             GetComponentTemplateAction.Request::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComposableIndexTemplateAction.java b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComposableIndexTemplateAction.java
index b1ef32db7274f..84fbb59481c10 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComposableIndexTemplateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetComposableIndexTemplateAction.java
@@ -76,7 +76,8 @@ public TransportGetComposableIndexTemplateAction(
             threadPool,
             actionFilters,
             GetComposableIndexTemplateAction.Request::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetIndexTemplatesAction.java b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetIndexTemplatesAction.java
index 10b4975f7b9d0..522234dda509f 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetIndexTemplatesAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/template/get/TransportGetIndexTemplatesAction.java
@@ -76,7 +76,8 @@ public TransportGetIndexTemplatesAction(
             threadPool,
             actionFilters,
             GetIndexTemplatesRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/template/post/TransportSimulateIndexTemplateAction.java b/server/src/main/java/org/opensearch/action/admin/indices/template/post/TransportSimulateIndexTemplateAction.java
index c1a02d813ffb2..22f1831a54164 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/template/post/TransportSimulateIndexTemplateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/template/post/TransportSimulateIndexTemplateAction.java
@@ -140,7 +140,8 @@ protected void clusterManagerOperation(
             MetadataIndexTemplateService.validateV2TemplateRequest(
                 state.metadata(),
                 simulateTemplateToAdd,
-                request.getIndexTemplateRequest().indexTemplate()
+                request.getIndexTemplateRequest().indexTemplate(),
+                clusterService.getClusterSettings()
             );
             stateWithTemplate = indexTemplateService.addIndexTemplateV2(
                 state,
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/template/post/TransportSimulateTemplateAction.java b/server/src/main/java/org/opensearch/action/admin/indices/template/post/TransportSimulateTemplateAction.java
index 6565896fd3db2..03190445647ad 100644
--- a/server/src/main/java/org/opensearch/action/admin/indices/template/post/TransportSimulateTemplateAction.java
+++ b/server/src/main/java/org/opensearch/action/admin/indices/template/post/TransportSimulateTemplateAction.java
@@ -134,7 +134,8 @@ protected void clusterManagerOperation(
             MetadataIndexTemplateService.validateV2TemplateRequest(
                 state.metadata(),
                 simulateTemplateToAdd,
-                request.getIndexTemplateRequest().indexTemplate()
+                request.getIndexTemplateRequest().indexTemplate(),
+                clusterService.getClusterSettings()
             );
             stateWithTemplate = indexTemplateService.addIndexTemplateV2(
                 state,
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringAction.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringAction.java
new file mode 100644
index 0000000000000..ae34a9a734221
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringAction.java
@@ -0,0 +1,28 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.ActionType;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * Tiering action to move indices from hot to warm
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class HotToWarmTieringAction extends ActionType<HotToWarmTieringResponse> {
+
+    public static final HotToWarmTieringAction INSTANCE = new HotToWarmTieringAction();
+    public static final String NAME = "indices:admin/tier/hot_to_warm";
+
+    private HotToWarmTieringAction() {
+        super(NAME, HotToWarmTieringResponse::new);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponse.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponse.java
new file mode 100644
index 0000000000000..275decf7a8ea5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponse.java
@@ -0,0 +1,157 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.support.master.AcknowledgedResponse;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+/**
+ * Response object for an {@link TieringIndexRequest} which is sent to client after the initial verification of the request
+ * by the backend service. The format of the response object will be as below:
+ *
+ *  {
+ *     "acknowledged": true/false,
+ *     "failed_indices": [
+ *              {
+ *                "index": "index1",
+ *                "error": "Low disk threshold watermark breached"
+ *              },
+ *              {
+ *                "index": "index2",
+ *                "error": "Index is not a remote store backed index"
+ *              }
+ *     ]
+ *  }
+ *
+ *  @opensearch.experimental
+ */
+@ExperimentalApi
+public class HotToWarmTieringResponse extends AcknowledgedResponse {
+
+    private final List<IndexResult> failedIndices;
+
+    public HotToWarmTieringResponse(boolean acknowledged) {
+        super(acknowledged);
+        this.failedIndices = Collections.emptyList();
+    }
+
+    public HotToWarmTieringResponse(boolean acknowledged, List<IndexResult> indicesResults) {
+        super(acknowledged);
+        this.failedIndices = (indicesResults == null)
+            ? Collections.emptyList()
+            : indicesResults.stream().sorted(Comparator.comparing(IndexResult::getIndex)).collect(Collectors.toList());
+    }
+
+    public HotToWarmTieringResponse(StreamInput in) throws IOException {
+        super(in);
+        failedIndices = Collections.unmodifiableList(in.readList(IndexResult::new));
+    }
+
+    public List<IndexResult> getFailedIndices() {
+        return this.failedIndices;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeList(this.failedIndices);
+    }
+
+    @Override
+    protected void addCustomFields(XContentBuilder builder, Params params) throws IOException {
+        super.addCustomFields(builder, params);
+        builder.startArray("failed_indices");
+
+        for (IndexResult failedIndex : failedIndices) {
+            failedIndex.toXContent(builder, params);
+        }
+        builder.endArray();
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(MediaTypeRegistry.JSON, this);
+    }
+
+    /**
+     * Inner class to represent the result of a failed index for tiering.
+     * @opensearch.experimental
+     */
+    @ExperimentalApi
+    public static class IndexResult implements Writeable, ToXContentFragment {
+        private final String index;
+        private final String failureReason;
+
+        public IndexResult(String index, String failureReason) {
+            this.index = index;
+            this.failureReason = failureReason;
+        }
+
+        IndexResult(StreamInput in) throws IOException {
+            this.index = in.readString();
+            this.failureReason = in.readString();
+        }
+
+        public String getIndex() {
+            return index;
+        }
+
+        public String getFailureReason() {
+            return failureReason;
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeString(index);
+            out.writeString(failureReason);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.startObject();
+            builder.field("index", index);
+            builder.field("error", failureReason);
+            return builder.endObject();
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            IndexResult that = (IndexResult) o;
+            return Objects.equals(index, that.index) && Objects.equals(failureReason, that.failureReason);
+        }
+
+        @Override
+        public int hashCode() {
+            int result = Objects.hashCode(index);
+            result = 31 * result + Objects.hashCode(failureReason);
+            return result;
+        }
+
+        @Override
+        public String toString() {
+            return Strings.toString(MediaTypeRegistry.JSON, this);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/RestWarmTieringAction.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/RestWarmTieringAction.java
new file mode 100644
index 0000000000000..6f2eceafa9e77
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/RestWarmTieringAction.java
@@ -0,0 +1,61 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.RestHandler;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.action.RestToXContentListener;
+
+import java.util.List;
+
+import static java.util.Collections.singletonList;
+import static org.opensearch.core.common.Strings.splitStringByCommaToArray;
+import static org.opensearch.rest.RestRequest.Method.POST;
+
+/**
+ * Rest Tiering API action to move indices to warm tier
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class RestWarmTieringAction extends BaseRestHandler {
+
+    private static final String TARGET_TIER = "warm";
+
+    @Override
+    public List<RestHandler.Route> routes() {
+        return singletonList(new RestHandler.Route(POST, "/{index}/_tier/" + TARGET_TIER));
+    }
+
+    @Override
+    public String getName() {
+        return "warm_tiering_action";
+    }
+
+    @Override
+    protected BaseRestHandler.RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) {
+        final TieringIndexRequest tieringIndexRequest = new TieringIndexRequest(
+            TARGET_TIER,
+            splitStringByCommaToArray(request.param("index"))
+        );
+        tieringIndexRequest.timeout(request.paramAsTime("timeout", tieringIndexRequest.timeout()));
+        tieringIndexRequest.clusterManagerNodeTimeout(
+            request.paramAsTime("cluster_manager_timeout", tieringIndexRequest.clusterManagerNodeTimeout())
+        );
+        tieringIndexRequest.indicesOptions(IndicesOptions.fromRequest(request, tieringIndexRequest.indicesOptions()));
+        tieringIndexRequest.waitForCompletion(request.paramAsBoolean("wait_for_completion", tieringIndexRequest.waitForCompletion()));
+        return channel -> client.admin()
+            .cluster()
+            .execute(HotToWarmTieringAction.INSTANCE, tieringIndexRequest, new RestToXContentListener<>(channel));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequest.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequest.java
new file mode 100644
index 0000000000000..ed458a47ddb7d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequest.java
@@ -0,0 +1,195 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.IndicesRequest;
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.action.support.master.AcknowledgedRequest;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Objects;
+
+import static org.opensearch.action.ValidateActions.addValidationError;
+
+/**
+ * Represents the tiering request for indices to move to a different tier
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class TieringIndexRequest extends AcknowledgedRequest<TieringIndexRequest> implements IndicesRequest.Replaceable {
+
+    private String[] indices;
+    private final Tier targetTier;
+    private IndicesOptions indicesOptions;
+    private boolean waitForCompletion;
+
+    public TieringIndexRequest(String targetTier, String... indices) {
+        this.targetTier = Tier.fromString(targetTier);
+        this.indices = indices;
+        this.indicesOptions = IndicesOptions.fromOptions(false, false, true, false);
+        this.waitForCompletion = false;
+    }
+
+    public TieringIndexRequest(StreamInput in) throws IOException {
+        super(in);
+        indices = in.readStringArray();
+        targetTier = Tier.fromString(in.readString());
+        indicesOptions = IndicesOptions.readIndicesOptions(in);
+        waitForCompletion = in.readBoolean();
+    }
+
+    // pkg private for testing
+    TieringIndexRequest(Tier targetTier, IndicesOptions indicesOptions, boolean waitForCompletion, String... indices) {
+        this.indices = indices;
+        this.targetTier = targetTier;
+        this.indicesOptions = indicesOptions;
+        this.waitForCompletion = waitForCompletion;
+    }
+
+    @Override
+    public ActionRequestValidationException validate() {
+        ActionRequestValidationException validationException = null;
+        if (indices == null) {
+            validationException = addValidationError("Mandatory parameter - indices is missing from the request", validationException);
+        } else {
+            for (String index : indices) {
+                if (index == null || index.length() == 0) {
+                    validationException = addValidationError(
+                        String.format(Locale.ROOT, "Specified index in the request [%s] is null or empty", index),
+                        validationException
+                    );
+                }
+            }
+        }
+        if (!Tier.WARM.equals(targetTier)) {
+            validationException = addValidationError("The specified tier is not supported", validationException);
+        }
+        return validationException;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeStringArray(indices);
+        out.writeString(targetTier.value());
+        indicesOptions.writeIndicesOptions(out);
+        out.writeBoolean(waitForCompletion);
+    }
+
+    @Override
+    public String[] indices() {
+        return indices;
+    }
+
+    @Override
+    public IndicesOptions indicesOptions() {
+        return indicesOptions;
+    }
+
+    @Override
+    public boolean includeDataStreams() {
+        return true;
+    }
+
+    @Override
+    public TieringIndexRequest indices(String... indices) {
+        this.indices = indices;
+        return this;
+    }
+
+    public TieringIndexRequest indicesOptions(IndicesOptions indicesOptions) {
+        this.indicesOptions = indicesOptions;
+        return this;
+    }
+
+    /**
+     * If this parameter is set to true the operation will wait for completion of tiering process before returning.
+     *
+     * @param waitForCompletion if true the operation will wait for completion
+     * @return this request
+     */
+    public TieringIndexRequest waitForCompletion(boolean waitForCompletion) {
+        this.waitForCompletion = waitForCompletion;
+        return this;
+    }
+
+    /**
+     * Returns wait for completion setting
+     *
+     * @return true if the operation will wait for completion
+     */
+    public boolean waitForCompletion() {
+        return waitForCompletion;
+    }
+
+    public Tier tier() {
+        return targetTier;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        TieringIndexRequest that = (TieringIndexRequest) o;
+        return clusterManagerNodeTimeout.equals(that.clusterManagerNodeTimeout)
+            && timeout.equals(that.timeout)
+            && Objects.equals(indicesOptions, that.indicesOptions)
+            && Arrays.equals(indices, that.indices)
+            && targetTier.equals(that.targetTier)
+            && waitForCompletion == that.waitForCompletion;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(clusterManagerNodeTimeout, timeout, indicesOptions, waitForCompletion, Arrays.hashCode(indices));
+    }
+
+    /**
+     * Represents the supported tiers for an index
+     *
+     * @opensearch.experimental
+     */
+    @ExperimentalApi
+    public enum Tier {
+        HOT,
+        WARM;
+
+        public static Tier fromString(String name) {
+            if (name == null) {
+                throw new IllegalArgumentException("Tiering type cannot be null");
+            }
+            String upperCase = name.trim().toUpperCase(Locale.ROOT);
+            switch (upperCase) {
+                case "HOT":
+                    return HOT;
+                case "WARM":
+                    return WARM;
+                default:
+                    throw new IllegalArgumentException(
+                        "Tiering type [" + name + "] is not supported. Supported types are " + HOT + " and " + WARM
+                    );
+            }
+        }
+
+        public String value() {
+            return name().toLowerCase(Locale.ROOT);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringUtils.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringUtils.java
new file mode 100644
index 0000000000000..46912de17f213
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringUtils.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.allocation.RoutingAllocation;
+import org.opensearch.index.IndexModule;
+
+/**
+ * Utility class for tiering operations
+ *
+ * @opensearch.internal
+ */
+public class TieringUtils {
+
+    /**
+     *  Checks if the specified shard is a partial shard by
+     *  checking the INDEX_STORE_LOCALITY_SETTING for its index.
+     *  see {@link #isPartialIndex(IndexMetadata)}
+     * @param shard ShardRouting object representing the shard
+     * @param allocation RoutingAllocation object representing the allocation
+     * @return true if the shard is a partial shard, false otherwise
+     */
+    public static boolean isPartialShard(ShardRouting shard, RoutingAllocation allocation) {
+        IndexMetadata indexMetadata = allocation.metadata().getIndexSafe(shard.index());
+        return isPartialIndex(indexMetadata);
+    }
+
+    /**
+     * Checks if the specified index is a partial index by
+     * checking the INDEX_STORE_LOCALITY_SETTING for the index.
+     *
+     * @param indexMetadata the metadata of the index
+     * @return true if the index is a partial index, false otherwise
+     */
+    public static boolean isPartialIndex(final IndexMetadata indexMetadata) {
+        return IndexModule.DataLocalityType.PARTIAL.name()
+            .equals(indexMetadata.getSettings().get(IndexModule.INDEX_STORE_LOCALITY_SETTING.getKey()));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringValidationResult.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringValidationResult.java
new file mode 100644
index 0000000000000..ccd60daf027ce
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TieringValidationResult.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.index.Index;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Validation result for tiering
+ *
+ * @opensearch.experimental
+ */
+
+@ExperimentalApi
+public class TieringValidationResult {
+    private final Set<Index> acceptedIndices;
+    private final Map<Index, String> rejectedIndices;
+
+    public TieringValidationResult(Set<Index> concreteIndices) {
+        // by default all the indices are added to the accepted set
+        this.acceptedIndices = ConcurrentHashMap.newKeySet();
+        acceptedIndices.addAll(concreteIndices);
+        this.rejectedIndices = new HashMap<>();
+    }
+
+    public Set<Index> getAcceptedIndices() {
+        return acceptedIndices;
+    }
+
+    public Map<Index, String> getRejectedIndices() {
+        return rejectedIndices;
+    }
+
+    public void addToRejected(Index index, String reason) {
+        acceptedIndices.remove(index);
+        rejectedIndices.put(index, reason);
+    }
+
+    public HotToWarmTieringResponse constructResponse() {
+        final List<HotToWarmTieringResponse.IndexResult> indicesResult = new LinkedList<>();
+        for (Map.Entry<Index, String> rejectedIndex : rejectedIndices.entrySet()) {
+            indicesResult.add(new HotToWarmTieringResponse.IndexResult(rejectedIndex.getKey().getName(), rejectedIndex.getValue()));
+        }
+        return new HotToWarmTieringResponse(acceptedIndices.size() > 0, indicesResult);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        TieringValidationResult that = (TieringValidationResult) o;
+
+        if (!Objects.equals(acceptedIndices, that.acceptedIndices)) return false;
+        return Objects.equals(rejectedIndices, that.rejectedIndices);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = acceptedIndices != null ? acceptedIndices.hashCode() : 0;
+        result = 31 * result + (rejectedIndices != null ? rejectedIndices.hashCode() : 0);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "TieringValidationResult{" + "acceptedIndices=" + acceptedIndices + ", rejectedIndices=" + rejectedIndices + '}';
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringAction.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringAction.java
new file mode 100644
index 0000000000000..8d1ab0bb37cdd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringAction.java
@@ -0,0 +1,110 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.clustermanager.TransportClusterManagerNodeAction;
+import org.opensearch.cluster.ClusterInfoService;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.routing.allocation.DiskThresholdSettings;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.index.Index;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.Set;
+
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateHotToWarm;
+
+/**
+ * Transport Tiering action to move indices from hot to warm
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class TransportHotToWarmTieringAction extends TransportClusterManagerNodeAction<TieringIndexRequest, HotToWarmTieringResponse> {
+
+    private static final Logger logger = LogManager.getLogger(TransportHotToWarmTieringAction.class);
+    private final ClusterInfoService clusterInfoService;
+    private final DiskThresholdSettings diskThresholdSettings;
+
+    @Inject
+    public TransportHotToWarmTieringAction(
+        TransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ActionFilters actionFilters,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        ClusterInfoService clusterInfoService,
+        Settings settings
+    ) {
+        super(
+            HotToWarmTieringAction.NAME,
+            transportService,
+            clusterService,
+            threadPool,
+            actionFilters,
+            TieringIndexRequest::new,
+            indexNameExpressionResolver
+        );
+        this.clusterInfoService = clusterInfoService;
+        this.diskThresholdSettings = new DiskThresholdSettings(settings, clusterService.getClusterSettings());
+    }
+
+    @Override
+    protected String executor() {
+        return ThreadPool.Names.SAME;
+    }
+
+    @Override
+    protected HotToWarmTieringResponse read(StreamInput in) throws IOException {
+        return new HotToWarmTieringResponse(in);
+    }
+
+    @Override
+    protected ClusterBlockException checkBlock(TieringIndexRequest request, ClusterState state) {
+        return state.blocks()
+            .indicesBlockedException(ClusterBlockLevel.METADATA_WRITE, indexNameExpressionResolver.concreteIndexNames(state, request));
+    }
+
+    @Override
+    protected void clusterManagerOperation(
+        TieringIndexRequest request,
+        ClusterState state,
+        ActionListener<HotToWarmTieringResponse> listener
+    ) throws Exception {
+        Index[] concreteIndices = indexNameExpressionResolver.concreteIndices(state, request);
+        if (concreteIndices == null || concreteIndices.length == 0) {
+            listener.onResponse(new HotToWarmTieringResponse(true));
+            return;
+        }
+        final TieringValidationResult tieringValidationResult = validateHotToWarm(
+            state,
+            Set.of(concreteIndices),
+            clusterInfoService.getClusterInfo(),
+            diskThresholdSettings
+        );
+
+        if (tieringValidationResult.getAcceptedIndices().isEmpty()) {
+            listener.onResponse(tieringValidationResult.constructResponse());
+            return;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/admin/indices/tiering/package-info.java b/server/src/main/java/org/opensearch/action/admin/indices/tiering/package-info.java
new file mode 100644
index 0000000000000..878e3575a3934
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/admin/indices/tiering/package-info.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * Actions that OpenSearch can take to tier the indices
+ */
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
diff --git a/server/src/main/java/org/opensearch/action/bulk/BulkRequest.java b/server/src/main/java/org/opensearch/action/bulk/BulkRequest.java
index 7614206cd226f..e686585095962 100644
--- a/server/src/main/java/org/opensearch/action/bulk/BulkRequest.java
+++ b/server/src/main/java/org/opensearch/action/bulk/BulkRequest.java
@@ -96,7 +96,7 @@ public class BulkRequest extends ActionRequest implements CompositeIndicesReques
     private String globalRouting;
     private String globalIndex;
     private Boolean globalRequireAlias;
-    private int batchSize = 1;
+    private int batchSize = Integer.MAX_VALUE;
 
     private long sizeInBytes = 0;
 
diff --git a/server/src/main/java/org/opensearch/action/ingest/GetPipelineTransportAction.java b/server/src/main/java/org/opensearch/action/ingest/GetPipelineTransportAction.java
index 80333c7346f92..7bc0380bccbc0 100644
--- a/server/src/main/java/org/opensearch/action/ingest/GetPipelineTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/ingest/GetPipelineTransportAction.java
@@ -70,7 +70,8 @@ public GetPipelineTransportAction(
             threadPool,
             actionFilters,
             GetPipelineRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/ingest/SimulateExecutionService.java b/server/src/main/java/org/opensearch/action/ingest/SimulateExecutionService.java
index c7c0f21eb0876..459466f8c8ab6 100644
--- a/server/src/main/java/org/opensearch/action/ingest/SimulateExecutionService.java
+++ b/server/src/main/java/org/opensearch/action/ingest/SimulateExecutionService.java
@@ -36,6 +36,7 @@
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.ingest.CompoundProcessor;
 import org.opensearch.ingest.IngestDocument;
+import org.opensearch.ingest.IngestService;
 import org.opensearch.ingest.Pipeline;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -56,9 +57,11 @@ class SimulateExecutionService {
     private static final String THREAD_POOL_NAME = ThreadPool.Names.MANAGEMENT;
 
     private final ThreadPool threadPool;
+    private final IngestService ingestService;
 
-    SimulateExecutionService(ThreadPool threadPool) {
+    SimulateExecutionService(ThreadPool threadPool, IngestService ingestService) {
         this.threadPool = threadPool;
+        this.ingestService = ingestService;
     }
 
     void executeDocument(
@@ -91,6 +94,9 @@ void executeDocument(
     }
 
     public void execute(SimulatePipelineRequest.Parsed request, ActionListener<SimulatePipelineResponse> listener) {
+
+        ingestService.validateProcessorCountForIngestPipeline(request.getPipeline());
+
         threadPool.executor(THREAD_POOL_NAME).execute(ActionRunnable.wrap(listener, l -> {
             final AtomicInteger counter = new AtomicInteger();
             final List<SimulateDocumentResult> responses = new CopyOnWriteArrayList<>(
diff --git a/server/src/main/java/org/opensearch/action/ingest/SimulatePipelineTransportAction.java b/server/src/main/java/org/opensearch/action/ingest/SimulatePipelineTransportAction.java
index 4753679d370af..5eeb09c4d50c0 100644
--- a/server/src/main/java/org/opensearch/action/ingest/SimulatePipelineTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/ingest/SimulatePipelineTransportAction.java
@@ -69,7 +69,7 @@ public SimulatePipelineTransportAction(
             (Writeable.Reader<SimulatePipelineRequest>) SimulatePipelineRequest::new
         );
         this.ingestService = ingestService;
-        this.executionService = new SimulateExecutionService(threadPool);
+        this.executionService = new SimulateExecutionService(threadPool, ingestService);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/search/AbstractSearchAsyncAction.java b/server/src/main/java/org/opensearch/action/search/AbstractSearchAsyncAction.java
index 9bf4a4b1e18f1..f0fc05c595d6f 100644
--- a/server/src/main/java/org/opensearch/action/search/AbstractSearchAsyncAction.java
+++ b/server/src/main/java/org/opensearch/action/search/AbstractSearchAsyncAction.java
@@ -51,6 +51,7 @@
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.action.ShardOperationFailedException;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceInfo;
 import org.opensearch.search.SearchPhaseResult;
 import org.opensearch.search.SearchShardTarget;
 import org.opensearch.search.internal.AliasFilter;
@@ -469,6 +470,10 @@ private void onRequestEnd(SearchRequestContext searchRequestContext) {
         this.searchRequestContext.getSearchRequestOperationsListener().onRequestEnd(this, searchRequestContext);
     }
 
+    private void onRequestFailure(SearchRequestContext searchRequestContext) {
+        this.searchRequestContext.getSearchRequestOperationsListener().onRequestFailure(this, searchRequestContext);
+    }
+
     private void executePhase(SearchPhase phase) {
         Span phaseSpan = tracer.startSpan(SpanCreationContext.server().name("[phase/" + phase.getName() + "]"));
         try (final SpanScope scope = tracer.withSpanInScope(phaseSpan)) {
@@ -507,6 +512,7 @@ ShardSearchFailure[] buildShardFailures() {
     private void onShardFailure(final int shardIndex, @Nullable SearchShardTarget shard, final SearchShardIterator shardIt, Exception e) {
         // we always add the shard failure for a specific shard instance
         // we do make sure to clean it on a successful response from a shard
+        setPhaseResourceUsages();
         onShardFailure(shardIndex, shard, e);
         SearchShardTarget nextShard = FailAwareWeightedRouting.getInstance()
             .findNext(shardIt, clusterState, e, () -> totalOps.incrementAndGet());
@@ -618,9 +624,15 @@ protected void onShardResult(Result result, SearchShardIterator shardIt) {
         if (logger.isTraceEnabled()) {
             logger.trace("got first-phase result from {}", result != null ? result.getSearchShardTarget() : null);
         }
+        this.setPhaseResourceUsages();
         results.consumeResult(result, () -> onShardResultConsumed(result, shardIt));
     }
 
+    public void setPhaseResourceUsages() {
+        TaskResourceInfo taskResourceUsage = searchRequestContext.getTaskResourceUsageSupplier().get();
+        searchRequestContext.recordPhaseResourceUsage(taskResourceUsage);
+    }
+
     private void onShardResultConsumed(Result result, SearchShardIterator shardIt) {
         successfulOps.incrementAndGet();
         // clean a previous error on this shard group (note, this code will be serialized on the same shardIndex value level
@@ -751,6 +763,7 @@ public void sendSearchResponse(InternalSearchResponse internalSearchResponse, At
 
     @Override
     public final void onPhaseFailure(SearchPhase phase, String msg, Throwable cause) {
+        setPhaseResourceUsages();
         if (currentPhaseHasLifecycle) {
             this.searchRequestContext.getSearchRequestOperationsListener().onPhaseFailure(this, cause);
         }
@@ -780,6 +793,7 @@ private void raisePhaseFailure(SearchPhaseExecutionException exception) {
             });
         }
         Releasables.close(releasables);
+        onRequestFailure(searchRequestContext);
         listener.onFailure(exception);
     }
 
diff --git a/server/src/main/java/org/opensearch/action/search/FetchSearchPhase.java b/server/src/main/java/org/opensearch/action/search/FetchSearchPhase.java
index ebb2f33f8f37d..2ad7f8a29896c 100644
--- a/server/src/main/java/org/opensearch/action/search/FetchSearchPhase.java
+++ b/server/src/main/java/org/opensearch/action/search/FetchSearchPhase.java
@@ -240,6 +240,7 @@ private void executeFetch(
                     public void innerOnResponse(FetchSearchResult result) {
                         try {
                             progressListener.notifyFetchResult(shardIndex);
+                            context.setPhaseResourceUsages();
                             counter.onResult(result);
                         } catch (Exception e) {
                             context.onPhaseFailure(FetchSearchPhase.this, "", e);
@@ -254,6 +255,7 @@ public void onFailure(Exception e) {
                                 e
                             );
                             progressListener.notifyFetchFailure(shardIndex, shardTarget, e);
+                            context.setPhaseResourceUsages();
                             counter.onFailure(shardIndex, shardTarget, e);
                         } finally {
                             // the search context might not be cleared on the node where the fetch was executed for example
diff --git a/server/src/main/java/org/opensearch/action/search/GetSearchPipelineTransportAction.java b/server/src/main/java/org/opensearch/action/search/GetSearchPipelineTransportAction.java
index a7fcb8f1cfbae..215b7ae1a610c 100644
--- a/server/src/main/java/org/opensearch/action/search/GetSearchPipelineTransportAction.java
+++ b/server/src/main/java/org/opensearch/action/search/GetSearchPipelineTransportAction.java
@@ -48,7 +48,8 @@ public GetSearchPipelineTransportAction(
             threadPool,
             actionFilters,
             GetSearchPipelineRequest::new,
-            indexNameExpressionResolver
+            indexNameExpressionResolver,
+            true
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/action/search/ListPitInfo.java b/server/src/main/java/org/opensearch/action/search/ListPitInfo.java
index 7e4ed186dd665..ac321d961679a 100644
--- a/server/src/main/java/org/opensearch/action/search/ListPitInfo.java
+++ b/server/src/main/java/org/opensearch/action/search/ListPitInfo.java
@@ -53,6 +53,10 @@ public long getCreationTime() {
         return creationTime;
     }
 
+    public long getKeepAlive() {
+        return keepAlive;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeString(pitId);
diff --git a/server/src/main/java/org/opensearch/action/search/SearchPhaseContext.java b/server/src/main/java/org/opensearch/action/search/SearchPhaseContext.java
index df451e0745e3c..55f2a22749e70 100644
--- a/server/src/main/java/org/opensearch/action/search/SearchPhaseContext.java
+++ b/server/src/main/java/org/opensearch/action/search/SearchPhaseContext.java
@@ -150,4 +150,9 @@ default void sendReleaseSearchContext(
      * Registers a {@link Releasable} that will be closed when the search request finishes or fails.
      */
     void addReleasable(Releasable releasable);
+
+    /**
+     * Set the resource usage info for this phase
+     */
+    void setPhaseResourceUsages();
 }
diff --git a/server/src/main/java/org/opensearch/action/search/SearchQueryAggregationCategorizer.java b/server/src/main/java/org/opensearch/action/search/SearchQueryAggregationCategorizer.java
deleted file mode 100644
index 607ccf182851b..0000000000000
--- a/server/src/main/java/org/opensearch/action/search/SearchQueryAggregationCategorizer.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.action.search;
-
-import org.opensearch.search.aggregations.AggregationBuilder;
-import org.opensearch.search.aggregations.PipelineAggregationBuilder;
-import org.opensearch.telemetry.metrics.tags.Tags;
-
-import java.util.Collection;
-
-/**
- * Increments the counters related to Aggregation Search Queries.
- */
-public class SearchQueryAggregationCategorizer {
-
-    private static final String TYPE_TAG = "type";
-    private final SearchQueryCounters searchQueryCounters;
-
-    public SearchQueryAggregationCategorizer(SearchQueryCounters searchQueryCounters) {
-        this.searchQueryCounters = searchQueryCounters;
-    }
-
-    public void incrementSearchQueryAggregationCounters(Collection<AggregationBuilder> aggregatorFactories) {
-        for (AggregationBuilder aggregationBuilder : aggregatorFactories) {
-            incrementCountersRecursively(aggregationBuilder);
-        }
-    }
-
-    private void incrementCountersRecursively(AggregationBuilder aggregationBuilder) {
-        // Increment counters for the current aggregation
-        String aggregationType = aggregationBuilder.getType();
-        searchQueryCounters.aggCounter.add(1, Tags.create().addTag(TYPE_TAG, aggregationType));
-
-        // Recursively process sub-aggregations if any
-        Collection<AggregationBuilder> subAggregations = aggregationBuilder.getSubAggregations();
-        if (subAggregations != null && !subAggregations.isEmpty()) {
-            for (AggregationBuilder subAggregation : subAggregations) {
-                incrementCountersRecursively(subAggregation);
-            }
-        }
-
-        // Process pipeline aggregations
-        Collection<PipelineAggregationBuilder> pipelineAggregations = aggregationBuilder.getPipelineAggregations();
-        for (PipelineAggregationBuilder pipelineAggregation : pipelineAggregations) {
-            String pipelineAggregationType = pipelineAggregation.getType();
-            searchQueryCounters.aggCounter.add(1, Tags.create().addTag(TYPE_TAG, pipelineAggregationType));
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/search/SearchQueryCategorizer.java b/server/src/main/java/org/opensearch/action/search/SearchQueryCategorizer.java
deleted file mode 100644
index ffaae5b08772f..0000000000000
--- a/server/src/main/java/org/opensearch/action/search/SearchQueryCategorizer.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.action.search;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.opensearch.index.query.QueryBuilder;
-import org.opensearch.index.query.QueryBuilderVisitor;
-import org.opensearch.index.query.QueryShapeVisitor;
-import org.opensearch.search.aggregations.AggregatorFactories;
-import org.opensearch.search.builder.SearchSourceBuilder;
-import org.opensearch.search.sort.SortBuilder;
-import org.opensearch.telemetry.metrics.MetricsRegistry;
-import org.opensearch.telemetry.metrics.tags.Tags;
-
-import java.util.List;
-import java.util.ListIterator;
-
-/**
- * Class to categorize the search queries based on the type and increment the relevant counters.
- * Class also logs the query shape.
- */
-final class SearchQueryCategorizer {
-
-    private static final Logger log = LogManager.getLogger(SearchQueryCategorizer.class);
-
-    final SearchQueryCounters searchQueryCounters;
-
-    final SearchQueryAggregationCategorizer searchQueryAggregationCategorizer;
-
-    public SearchQueryCategorizer(MetricsRegistry metricsRegistry) {
-        searchQueryCounters = new SearchQueryCounters(metricsRegistry);
-        searchQueryAggregationCategorizer = new SearchQueryAggregationCategorizer(searchQueryCounters);
-    }
-
-    public void categorize(SearchSourceBuilder source) {
-        QueryBuilder topLevelQueryBuilder = source.query();
-        logQueryShape(topLevelQueryBuilder);
-        incrementQueryTypeCounters(topLevelQueryBuilder);
-        incrementQueryAggregationCounters(source.aggregations());
-        incrementQuerySortCounters(source.sorts());
-    }
-
-    private void incrementQuerySortCounters(List<SortBuilder<?>> sorts) {
-        if (sorts != null && sorts.size() > 0) {
-            for (ListIterator<SortBuilder<?>> it = sorts.listIterator(); it.hasNext();) {
-                SortBuilder sortBuilder = it.next();
-                String sortOrder = sortBuilder.order().toString();
-                searchQueryCounters.sortCounter.add(1, Tags.create().addTag("sort_order", sortOrder));
-            }
-        }
-    }
-
-    private void incrementQueryAggregationCounters(AggregatorFactories.Builder aggregations) {
-        if (aggregations == null) {
-            return;
-        }
-
-        searchQueryAggregationCategorizer.incrementSearchQueryAggregationCounters(aggregations.getAggregatorFactories());
-    }
-
-    private void incrementQueryTypeCounters(QueryBuilder topLevelQueryBuilder) {
-        if (topLevelQueryBuilder == null) {
-            return;
-        }
-        QueryBuilderVisitor searchQueryVisitor = new SearchQueryCategorizingVisitor(searchQueryCounters);
-        topLevelQueryBuilder.visit(searchQueryVisitor);
-    }
-
-    private void logQueryShape(QueryBuilder topLevelQueryBuilder) {
-        if (topLevelQueryBuilder == null) {
-            return;
-        }
-        QueryShapeVisitor shapeVisitor = new QueryShapeVisitor();
-        topLevelQueryBuilder.visit(shapeVisitor);
-        log.trace("Query shape : {}", shapeVisitor.prettyPrintTree("  "));
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/action/search/SearchQueryCategorizingVisitor.java b/server/src/main/java/org/opensearch/action/search/SearchQueryCategorizingVisitor.java
deleted file mode 100644
index 31f83dbef9dc9..0000000000000
--- a/server/src/main/java/org/opensearch/action/search/SearchQueryCategorizingVisitor.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.action.search;
-
-import org.apache.lucene.search.BooleanClause;
-import org.opensearch.index.query.QueryBuilder;
-import org.opensearch.index.query.QueryBuilderVisitor;
-
-/**
- * Class to visit the query builder tree and also track the level information.
- * Increments the counters related to Search Query type.
- */
-final class SearchQueryCategorizingVisitor implements QueryBuilderVisitor {
-    private final int level;
-    private final SearchQueryCounters searchQueryCounters;
-
-    public SearchQueryCategorizingVisitor(SearchQueryCounters searchQueryCounters) {
-        this(searchQueryCounters, 0);
-    }
-
-    private SearchQueryCategorizingVisitor(SearchQueryCounters counters, int level) {
-        this.searchQueryCounters = counters;
-        this.level = level;
-    }
-
-    public void accept(QueryBuilder qb) {
-        searchQueryCounters.incrementCounter(qb, level);
-    }
-
-    public QueryBuilderVisitor getChildVisitor(BooleanClause.Occur occur) {
-        return new SearchQueryCategorizingVisitor(searchQueryCounters, level + 1);
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/search/SearchQueryCounters.java b/server/src/main/java/org/opensearch/action/search/SearchQueryCounters.java
deleted file mode 100644
index a8a7e352b89dc..0000000000000
--- a/server/src/main/java/org/opensearch/action/search/SearchQueryCounters.java
+++ /dev/null
@@ -1,70 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.action.search;
-
-import org.opensearch.index.query.QueryBuilder;
-import org.opensearch.telemetry.metrics.Counter;
-import org.opensearch.telemetry.metrics.MetricsRegistry;
-import org.opensearch.telemetry.metrics.tags.Tags;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Class contains all the Counters related to search query types.
- */
-final class SearchQueryCounters {
-    private static final String LEVEL_TAG = "level";
-    private static final String UNIT = "1";
-    private final MetricsRegistry metricsRegistry;
-    public final Counter aggCounter;
-    public final Counter otherQueryCounter;
-    public final Counter sortCounter;
-    private final Map<Class<? extends QueryBuilder>, Counter> queryHandlers;
-    public final ConcurrentHashMap<String, Counter> nameToQueryTypeCounters;
-
-    public SearchQueryCounters(MetricsRegistry metricsRegistry) {
-        this.metricsRegistry = metricsRegistry;
-        this.nameToQueryTypeCounters = new ConcurrentHashMap<>();
-        this.aggCounter = metricsRegistry.createCounter(
-            "search.query.type.agg.count",
-            "Counter for the number of top level agg search queries",
-            UNIT
-        );
-        this.otherQueryCounter = metricsRegistry.createCounter(
-            "search.query.type.other.count",
-            "Counter for the number of top level and nested search queries that do not match any other categories",
-            UNIT
-        );
-        this.sortCounter = metricsRegistry.createCounter(
-            "search.query.type.sort.count",
-            "Counter for the number of top level sort search queries",
-            UNIT
-        );
-        this.queryHandlers = new HashMap<>();
-
-    }
-
-    public void incrementCounter(QueryBuilder queryBuilder, int level) {
-        String uniqueQueryCounterName = queryBuilder.getName();
-
-        Counter counter = nameToQueryTypeCounters.computeIfAbsent(uniqueQueryCounterName, k -> createQueryCounter(k));
-        counter.add(1, Tags.create().addTag(LEVEL_TAG, level));
-    }
-
-    private Counter createQueryCounter(String counterName) {
-        Counter counter = metricsRegistry.createCounter(
-            "search.query.type." + counterName + ".count",
-            "Counter for the number of top level and nested " + counterName + " search queries",
-            UNIT
-        );
-        return counter;
-    }
-}
diff --git a/server/src/main/java/org/opensearch/action/search/SearchRequestContext.java b/server/src/main/java/org/opensearch/action/search/SearchRequestContext.java
index b8bbde65ca6bc..111d9c64550b3 100644
--- a/server/src/main/java/org/opensearch/action/search/SearchRequestContext.java
+++ b/server/src/main/java/org/opensearch/action/search/SearchRequestContext.java
@@ -8,13 +8,20 @@
 
 package org.opensearch.action.search;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.apache.lucene.search.TotalHits;
 import org.opensearch.common.annotation.InternalApi;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceInfo;
 
+import java.util.ArrayList;
 import java.util.EnumMap;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.function.Supplier;
 
 /**
  * This class holds request-level context for search queries at the coordinator node
@@ -23,6 +30,7 @@
  */
 @InternalApi
 public class SearchRequestContext {
+    private static final Logger logger = LogManager.getLogger();
     private final SearchRequestOperationsListener searchRequestOperationsListener;
     private long absoluteStartNanos;
     private final Map<String, Long> phaseTookMap;
@@ -30,13 +38,21 @@ public class SearchRequestContext {
     private final EnumMap<ShardStatsFieldNames, Integer> shardStats;
 
     private final SearchRequest searchRequest;
-
-    SearchRequestContext(final SearchRequestOperationsListener searchRequestOperationsListener, final SearchRequest searchRequest) {
+    private final LinkedBlockingQueue<TaskResourceInfo> phaseResourceUsage;
+    private final Supplier<TaskResourceInfo> taskResourceUsageSupplier;
+
+    SearchRequestContext(
+        final SearchRequestOperationsListener searchRequestOperationsListener,
+        final SearchRequest searchRequest,
+        final Supplier<TaskResourceInfo> taskResourceUsageSupplier
+    ) {
         this.searchRequestOperationsListener = searchRequestOperationsListener;
         this.absoluteStartNanos = System.nanoTime();
         this.phaseTookMap = new HashMap<>();
         this.shardStats = new EnumMap<>(ShardStatsFieldNames.class);
         this.searchRequest = searchRequest;
+        this.phaseResourceUsage = new LinkedBlockingQueue<>();
+        this.taskResourceUsageSupplier = taskResourceUsageSupplier;
     }
 
     SearchRequestOperationsListener getSearchRequestOperationsListener() {
@@ -107,6 +123,24 @@ String formattedShardStats() {
             );
         }
     }
+
+    public Supplier<TaskResourceInfo> getTaskResourceUsageSupplier() {
+        return taskResourceUsageSupplier;
+    }
+
+    public void recordPhaseResourceUsage(TaskResourceInfo usage) {
+        if (usage != null) {
+            this.phaseResourceUsage.add(usage);
+        }
+    }
+
+    public List<TaskResourceInfo> getPhaseResourceUsage() {
+        return new ArrayList<>(phaseResourceUsage);
+    }
+
+    public SearchRequest getRequest() {
+        return searchRequest;
+    }
 }
 
 enum ShardStatsFieldNames {
diff --git a/server/src/main/java/org/opensearch/action/search/SearchRequestOperationsListener.java b/server/src/main/java/org/opensearch/action/search/SearchRequestOperationsListener.java
index 53efade174502..61f19977ae5ce 100644
--- a/server/src/main/java/org/opensearch/action/search/SearchRequestOperationsListener.java
+++ b/server/src/main/java/org/opensearch/action/search/SearchRequestOperationsListener.java
@@ -41,16 +41,18 @@ protected SearchRequestOperationsListener(final boolean enabled) {
         this.enabled = enabled;
     }
 
-    protected abstract void onPhaseStart(SearchPhaseContext context);
+    protected void onPhaseStart(SearchPhaseContext context) {};
 
-    protected abstract void onPhaseEnd(SearchPhaseContext context, SearchRequestContext searchRequestContext);
+    protected void onPhaseEnd(SearchPhaseContext context, SearchRequestContext searchRequestContext) {};
 
-    protected abstract void onPhaseFailure(SearchPhaseContext context, Throwable cause);
+    protected void onPhaseFailure(SearchPhaseContext context, Throwable cause) {};
 
     protected void onRequestStart(SearchRequestContext searchRequestContext) {}
 
     protected void onRequestEnd(SearchPhaseContext context, SearchRequestContext searchRequestContext) {}
 
+    protected void onRequestFailure(SearchPhaseContext context, SearchRequestContext searchRequestContext) {}
+
     protected boolean isEnabled(SearchRequest searchRequest) {
         return isEnabled();
     }
@@ -133,6 +135,17 @@ public void onRequestEnd(SearchPhaseContext context, SearchRequestContext search
             }
         }
 
+        @Override
+        public void onRequestFailure(SearchPhaseContext context, SearchRequestContext searchRequestContext) {
+            for (SearchRequestOperationsListener listener : listeners) {
+                try {
+                    listener.onRequestFailure(context, searchRequestContext);
+                } catch (Exception e) {
+                    logger.warn(() -> new ParameterizedMessage("onRequestFailure listener [{}] failed", listener), e);
+                }
+            }
+        }
+
         public List<SearchRequestOperationsListener> getListeners() {
             return listeners;
         }
diff --git a/server/src/main/java/org/opensearch/action/search/SearchRequestStats.java b/server/src/main/java/org/opensearch/action/search/SearchRequestStats.java
index 97ef94055faf7..d1d5f568fc09d 100644
--- a/server/src/main/java/org/opensearch/action/search/SearchRequestStats.java
+++ b/server/src/main/java/org/opensearch/action/search/SearchRequestStats.java
@@ -27,6 +27,7 @@
 @PublicApi(since = "2.11.0")
 public final class SearchRequestStats extends SearchRequestOperationsListener {
     Map<SearchPhaseName, StatsHolder> phaseStatsMap = new EnumMap<>(SearchPhaseName.class);
+    StatsHolder tookStatsHolder;
 
     public static final String SEARCH_REQUEST_STATS_ENABLED_KEY = "search.request_stats_enabled";
     public static final Setting<Boolean> SEARCH_REQUEST_STATS_ENABLED = Setting.boolSetting(
@@ -40,6 +41,7 @@ public final class SearchRequestStats extends SearchRequestOperationsListener {
     public SearchRequestStats(ClusterSettings clusterSettings) {
         this.setEnabled(clusterSettings.get(SEARCH_REQUEST_STATS_ENABLED));
         clusterSettings.addSettingsUpdateConsumer(SEARCH_REQUEST_STATS_ENABLED, this::setEnabled);
+        tookStatsHolder = new StatsHolder();
         for (SearchPhaseName searchPhaseName : SearchPhaseName.values()) {
             phaseStatsMap.put(searchPhaseName, new StatsHolder());
         }
@@ -57,6 +59,18 @@ public long getPhaseMetric(SearchPhaseName searchPhaseName) {
         return phaseStatsMap.get(searchPhaseName).timing.sum();
     }
 
+    public long getTookCurrent() {
+        return tookStatsHolder.current.count();
+    }
+
+    public long getTookTotal() {
+        return tookStatsHolder.total.count();
+    }
+
+    public long getTookMetric() {
+        return tookStatsHolder.timing.sum();
+    }
+
     @Override
     protected void onPhaseStart(SearchPhaseContext context) {
         phaseStatsMap.get(context.getCurrentPhase().getSearchPhaseName()).current.inc();
@@ -75,6 +89,23 @@ protected void onPhaseFailure(SearchPhaseContext context, Throwable cause) {
         phaseStatsMap.get(context.getCurrentPhase().getSearchPhaseName()).current.dec();
     }
 
+    @Override
+    protected void onRequestStart(SearchRequestContext searchRequestContext) {
+        tookStatsHolder.current.inc();
+    }
+
+    @Override
+    protected void onRequestEnd(SearchPhaseContext context, SearchRequestContext searchRequestContext) {
+        tookStatsHolder.current.dec();
+        tookStatsHolder.total.inc();
+        tookStatsHolder.timing.inc(TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - searchRequestContext.getAbsoluteStartNanos()));
+    }
+
+    @Override
+    protected void onRequestFailure(SearchPhaseContext context, SearchRequestContext searchRequestContext) {
+        tookStatsHolder.current.dec();
+    }
+
     /**
      * Holder of statistics values
      *
diff --git a/server/src/main/java/org/opensearch/action/search/SearchShardTask.java b/server/src/main/java/org/opensearch/action/search/SearchShardTask.java
index dfecf4f462c4d..ed2943db94420 100644
--- a/server/src/main/java/org/opensearch/action/search/SearchShardTask.java
+++ b/server/src/main/java/org/opensearch/action/search/SearchShardTask.java
@@ -37,8 +37,8 @@
 import org.opensearch.core.tasks.TaskId;
 import org.opensearch.search.fetch.ShardFetchSearchRequest;
 import org.opensearch.search.internal.ShardSearchRequest;
-import org.opensearch.tasks.CancellableTask;
 import org.opensearch.tasks.SearchBackpressureTask;
+import org.opensearch.wlm.QueryGroupTask;
 
 import java.util.Map;
 import java.util.function.Supplier;
@@ -50,7 +50,7 @@
  * @opensearch.api
  */
 @PublicApi(since = "1.0.0")
-public class SearchShardTask extends CancellableTask implements SearchBackpressureTask {
+public class SearchShardTask extends QueryGroupTask implements SearchBackpressureTask {
     // generating metadata in a lazy way since source can be quite big
     private final MemoizedSupplier<String> metadataSupplier;
 
diff --git a/server/src/main/java/org/opensearch/action/search/SearchTask.java b/server/src/main/java/org/opensearch/action/search/SearchTask.java
index d3c1043c50cce..2a1a961e7607b 100644
--- a/server/src/main/java/org/opensearch/action/search/SearchTask.java
+++ b/server/src/main/java/org/opensearch/action/search/SearchTask.java
@@ -35,8 +35,8 @@
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.tasks.TaskId;
-import org.opensearch.tasks.CancellableTask;
 import org.opensearch.tasks.SearchBackpressureTask;
+import org.opensearch.wlm.QueryGroupTask;
 
 import java.util.Map;
 import java.util.function.Supplier;
@@ -49,7 +49,7 @@
  * @opensearch.api
  */
 @PublicApi(since = "1.0.0")
-public class SearchTask extends CancellableTask implements SearchBackpressureTask {
+public class SearchTask extends QueryGroupTask implements SearchBackpressureTask {
     // generating description in a lazy way since source can be quite big
     private final Supplier<String> descriptionSupplier;
     private SearchProgressListener progressListener = SearchProgressListener.NOOP;
diff --git a/server/src/main/java/org/opensearch/action/search/SearchTaskRequestOperationsListener.java b/server/src/main/java/org/opensearch/action/search/SearchTaskRequestOperationsListener.java
new file mode 100644
index 0000000000000..4434d71793b23
--- /dev/null
+++ b/server/src/main/java/org/opensearch/action/search/SearchTaskRequestOperationsListener.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.search;
+
+import org.opensearch.tasks.TaskResourceTrackingService;
+
+/**
+ * SearchTaskRequestOperationsListener subscriber for operations on search tasks resource usages.
+ * Listener ensures to refreshResourceStats on request end capturing the search task resource usage
+ * upon request completion.
+ *
+ */
+public final class SearchTaskRequestOperationsListener extends SearchRequestOperationsListener {
+    private final TaskResourceTrackingService taskResourceTrackingService;
+
+    public SearchTaskRequestOperationsListener(TaskResourceTrackingService taskResourceTrackingService) {
+        this.taskResourceTrackingService = taskResourceTrackingService;
+    }
+
+    @Override
+    public void onRequestEnd(SearchPhaseContext context, SearchRequestContext searchRequestContext) {
+        taskResourceTrackingService.refreshResourceStats(context.getTask());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/action/search/TransportSearchAction.java b/server/src/main/java/org/opensearch/action/search/TransportSearchAction.java
index 143b01af3f62f..8c4927afa9a14 100644
--- a/server/src/main/java/org/opensearch/action/search/TransportSearchAction.java
+++ b/server/src/main/java/org/opensearch/action/search/TransportSearchAction.java
@@ -87,6 +87,7 @@
 import org.opensearch.search.profile.SearchProfileShardResults;
 import org.opensearch.tasks.CancellableTask;
 import org.opensearch.tasks.Task;
+import org.opensearch.tasks.TaskResourceTrackingService;
 import org.opensearch.telemetry.metrics.MetricsRegistry;
 import org.opensearch.telemetry.tracing.Span;
 import org.opensearch.telemetry.tracing.SpanBuilder;
@@ -100,6 +101,7 @@
 import org.opensearch.transport.RemoteTransportException;
 import org.opensearch.transport.Transport;
 import org.opensearch.transport.TransportService;
+import org.opensearch.wlm.QueryGroupTask;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -142,13 +144,6 @@ public class TransportSearchAction extends HandledTransportAction<SearchRequest,
         Property.NodeScope
     );
 
-    public static final Setting<Boolean> SEARCH_QUERY_METRICS_ENABLED_SETTING = Setting.boolSetting(
-        "search.query.metrics.enabled",
-        false,
-        Setting.Property.NodeScope,
-        Setting.Property.Dynamic
-    );
-
     // cluster level setting for timeout based search cancellation. If search request level parameter is present then that will take
     // precedence over the cluster setting value
     public static final String SEARCH_CANCEL_AFTER_TIME_INTERVAL_SETTING_KEY = "search.cancel_after_time_interval";
@@ -181,11 +176,9 @@ public class TransportSearchAction extends HandledTransportAction<SearchRequest,
     private final SearchRequestOperationsCompositeListenerFactory searchRequestOperationsCompositeListenerFactory;
     private final Tracer tracer;
 
-    private volatile boolean searchQueryMetricsEnabled;
-
     private final MetricsRegistry metricsRegistry;
 
-    private SearchQueryCategorizer searchQueryCategorizer;
+    private TaskResourceTrackingService taskResourceTrackingService;
 
     @Inject
     public TransportSearchAction(
@@ -203,7 +196,8 @@ public TransportSearchAction(
         SearchPipelineService searchPipelineService,
         MetricsRegistry metricsRegistry,
         SearchRequestOperationsCompositeListenerFactory searchRequestOperationsCompositeListenerFactory,
-        Tracer tracer
+        Tracer tracer,
+        TaskResourceTrackingService taskResourceTrackingService
     ) {
         super(SearchAction.NAME, transportService, actionFilters, (Writeable.Reader<SearchRequest>) SearchRequest::new);
         this.client = client;
@@ -219,18 +213,9 @@ public TransportSearchAction(
         this.namedWriteableRegistry = namedWriteableRegistry;
         this.searchPipelineService = searchPipelineService;
         this.metricsRegistry = metricsRegistry;
-        this.searchQueryMetricsEnabled = clusterService.getClusterSettings().get(SEARCH_QUERY_METRICS_ENABLED_SETTING);
         this.searchRequestOperationsCompositeListenerFactory = searchRequestOperationsCompositeListenerFactory;
-        clusterService.getClusterSettings()
-            .addSettingsUpdateConsumer(SEARCH_QUERY_METRICS_ENABLED_SETTING, this::setSearchQueryMetricsEnabled);
         this.tracer = tracer;
-    }
-
-    private void setSearchQueryMetricsEnabled(boolean searchQueryMetricsEnabled) {
-        this.searchQueryMetricsEnabled = searchQueryMetricsEnabled;
-        if ((this.searchQueryMetricsEnabled == true) && this.searchQueryCategorizer == null) {
-            this.searchQueryCategorizer = new SearchQueryCategorizer(metricsRegistry);
-        }
+        this.taskResourceTrackingService = taskResourceTrackingService;
     }
 
     private Map<String, AliasFilter> buildPerIndexAliasFilter(
@@ -327,8 +312,9 @@ protected void doExecute(Task task, SearchRequest searchRequest, ActionListener<
             listener = TimeoutTaskCancellationUtility.wrapWithCancellationListener(
                 client,
                 (CancellableTask) task,
-                clusterService.getClusterSettings(),
-                listener
+                clusterService.getClusterSettings().get(SEARCH_CANCEL_AFTER_TIME_INTERVAL_SETTING),
+                listener,
+                e -> {}
             );
         }
         executeRequest(task, searchRequest, this::searchAsyncAction, listener);
@@ -451,9 +437,19 @@ private void executeRequest(
                 logger,
                 TraceableSearchRequestOperationsListener.create(tracer, requestSpan)
             );
-            SearchRequestContext searchRequestContext = new SearchRequestContext(requestOperationsListeners, originalSearchRequest);
+            SearchRequestContext searchRequestContext = new SearchRequestContext(
+                requestOperationsListeners,
+                originalSearchRequest,
+                taskResourceTrackingService::getTaskResourceUsageFromThreadContext
+            );
             searchRequestContext.getSearchRequestOperationsListener().onRequestStart(searchRequestContext);
 
+            // At this point either the QUERY_GROUP_ID header will be present in ThreadContext either via ActionFilter
+            // or HTTP header (HTTP header will be deprecated once ActionFilter is implemented)
+            if (task instanceof QueryGroupTask) {
+                ((QueryGroupTask) task).setQueryGroupId(threadPool.getThreadContext());
+            }
+
             PipelinedRequest searchRequest;
             ActionListener<SearchResponse> listener;
             try {
@@ -465,13 +461,6 @@ private void executeRequest(
             }
 
             ActionListener<SearchRequest> requestTransformListener = ActionListener.wrap(sr -> {
-                if (searchQueryMetricsEnabled) {
-                    try {
-                        searchQueryCategorizer.categorize(sr.source());
-                    } catch (Exception e) {
-                        logger.error("Error while trying to categorize the query.", e);
-                    }
-                }
 
                 ActionListener<SearchSourceBuilder> rewriteListener = buildRewriteListener(
                     sr,
diff --git a/server/src/main/java/org/opensearch/action/support/TimeoutTaskCancellationUtility.java b/server/src/main/java/org/opensearch/action/support/TimeoutTaskCancellationUtility.java
index a317a45eab31f..d2e7121a592cb 100644
--- a/server/src/main/java/org/opensearch/action/support/TimeoutTaskCancellationUtility.java
+++ b/server/src/main/java/org/opensearch/action/support/TimeoutTaskCancellationUtility.java
@@ -12,11 +12,12 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksRequest;
+import org.opensearch.action.admin.cluster.node.tasks.cancel.CancelTasksResponse;
 import org.opensearch.client.OriginSettingClient;
 import org.opensearch.client.node.NodeClient;
-import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.tasks.TaskCancelledException;
 import org.opensearch.core.tasks.TaskId;
 import org.opensearch.search.SearchService;
 import org.opensearch.tasks.CancellableTask;
@@ -27,7 +28,6 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 
 import static org.opensearch.action.admin.cluster.node.tasks.get.GetTaskAction.TASKS_ORIGIN;
-import static org.opensearch.action.search.TransportSearchAction.SEARCH_CANCEL_AFTER_TIME_INTERVAL_SETTING;
 
 /**
  * Utility to cancel a timeout task
@@ -38,25 +38,25 @@ public class TimeoutTaskCancellationUtility {
 
     private static final Logger logger = LogManager.getLogger(TimeoutTaskCancellationUtility.class);
 
+    private static final AtomicBoolean executeResponseOrFailureOnce = new AtomicBoolean(true);
+
     /**
      * Wraps a listener with a timeout listener {@link TimeoutRunnableListener} to schedule the task cancellation for provided tasks on
      * generic thread pool
      * @param client - {@link NodeClient}
      * @param taskToCancel - task to schedule cancellation for
-     * @param clusterSettings - {@link ClusterSettings}
+     * @param timeout - {@link TimeValue}
      * @param listener - original listener associated with the task
      * @return wrapped listener
      */
     public static <Response> ActionListener<Response> wrapWithCancellationListener(
         NodeClient client,
         CancellableTask taskToCancel,
-        ClusterSettings clusterSettings,
-        ActionListener<Response> listener
+        TimeValue timeout,
+        ActionListener<Response> listener,
+        TimeoutHandler timeoutHandler
     ) {
-        final TimeValue globalTimeout = clusterSettings.get(SEARCH_CANCEL_AFTER_TIME_INTERVAL_SETTING);
-        final TimeValue timeoutInterval = (taskToCancel.getCancellationTimeout() == null)
-            ? globalTimeout
-            : taskToCancel.getCancellationTimeout();
+        final TimeValue timeoutInterval = (taskToCancel.getCancellationTimeout() == null) ? timeout : taskToCancel.getCancellationTimeout();
         // Note: -1 (or no timeout) will help to turn off cancellation. The combinations will be request level set at -1 or request level
         // set to null and cluster level set to -1.
         ActionListener<Response> listenerToReturn = listener;
@@ -72,24 +72,30 @@ public static <Response> ActionListener<Response> wrapWithCancellationListener(
                 // force the origin to execute the cancellation as a system user
                 new OriginSettingClient(client, TASKS_ORIGIN).admin()
                     .cluster()
-                    .cancelTasks(
-                        cancelTasksRequest,
-                        ActionListener.wrap(
-                            r -> logger.debug(
+                    .cancelTasks(cancelTasksRequest, new ActionListener<CancelTasksResponse>() {
+                        @Override
+                        public void onResponse(CancelTasksResponse cancelTasksResponse) {
+                            logger.debug(
                                 "Scheduled cancel task with timeout: {} for original task: {} is successfully completed",
                                 timeoutInterval,
                                 cancelTasksRequest.getTaskId()
-                            ),
-                            e -> logger.error(
+                            );
+                            // Notify the timeoutHandler that the task was canceled due to timeout
+                            timeoutHandler.onTimeout(new TaskCancelledException(cancelTasksRequest.getReason()));
+                        }
+
+                        @Override
+                        public void onFailure(Exception e) {
+                            logger.error(
                                 new ParameterizedMessage(
                                     "Scheduled cancel task with timeout: {} for original task: {} is failed",
                                     timeoutInterval,
                                     cancelTasksRequest.getTaskId()
                                 ),
                                 e
-                            )
-                        )
-                    );
+                            );
+                        }
+                    });
             });
             wrappedListener.cancellable = client.threadPool().schedule(wrappedListener, timeoutInterval, ThreadPool.Names.GENERIC);
             listenerToReturn = wrappedListener;
@@ -100,6 +106,22 @@ public static <Response> ActionListener<Response> wrapWithCancellationListener(
         return listenerToReturn;
     }
 
+    /**
+     * A functional interface used to handle the timeout of a cancellable task.
+     * Implementations of this interface provide a callback method that is invoked
+     * when a task is cancelled due to a timeout.
+     */
+    public interface TimeoutHandler {
+
+        /**
+         * Called when a cancellable task is cancelled due to a timeout.
+         *
+         * @param e the exception that contains details about the task cancellation,
+         *          including the reason for cancellation.
+         */
+        void onTimeout(TaskCancelledException e);
+    }
+
     /**
      * Timeout listener which executes the provided runnable after timeout is expired and if a response/failure is not yet received.
      * If either a response/failure is received before timeout then the scheduled task is cancelled and response/failure is sent back to
@@ -144,6 +166,7 @@ public void run() {
                 if (executeRunnable.compareAndSet(true, false)) {
                     timeoutRunnable.run();
                 } // else do nothing since either response/failure is already sent to client
+
             } catch (Exception ex) {
                 // ignore the exception
                 logger.error(
diff --git a/server/src/main/java/org/opensearch/action/support/broadcast/BroadcastRequest.java b/server/src/main/java/org/opensearch/action/support/broadcast/BroadcastRequest.java
index 8a27e032cec5e..784c43c938f2c 100644
--- a/server/src/main/java/org/opensearch/action/support/broadcast/BroadcastRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/broadcast/BroadcastRequest.java
@@ -52,6 +52,8 @@ public class BroadcastRequest<Request extends BroadcastRequest<Request>> extends
     protected String[] indices;
     private IndicesOptions indicesOptions = IndicesOptions.strictExpandOpenAndForbidClosed();
 
+    protected boolean shouldCancelOnTimeout = false;
+
     public BroadcastRequest(StreamInput in) throws IOException {
         super(in);
         indices = in.readStringArray();
@@ -125,4 +127,12 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeStringArrayNullable(indices);
         indicesOptions.writeIndicesOptions(out);
     }
+
+    public void setShouldCancelOnTimeout(boolean shouldCancelOnTimeout) {
+        this.shouldCancelOnTimeout = shouldCancelOnTimeout;
+    }
+
+    public boolean getShouldCancelOnTimeout() {
+        return this.shouldCancelOnTimeout;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/ClusterManagerNodeReadRequest.java b/server/src/main/java/org/opensearch/action/support/clustermanager/ClusterManagerNodeReadRequest.java
index 6dcc6ed1b098e..c373107163082 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/ClusterManagerNodeReadRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/ClusterManagerNodeReadRequest.java
@@ -47,6 +47,8 @@ public abstract class ClusterManagerNodeReadRequest<Request extends ClusterManag
 
     protected boolean local = false;
 
+    protected boolean shouldCancelOnTimeout = false;
+
     protected ClusterManagerNodeReadRequest() {}
 
     protected ClusterManagerNodeReadRequest(StreamInput in) throws IOException {
@@ -74,4 +76,12 @@ public final Request local(boolean local) {
     public final boolean local() {
         return local;
     }
+
+    public void setShouldCancelOnTimeout(boolean shouldCancelOnTimeout) {
+        this.shouldCancelOnTimeout = shouldCancelOnTimeout;
+    }
+
+    public boolean getShouldCancelOnTimeout() {
+        return this.shouldCancelOnTimeout;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
index 080b0d607e991..4e869f29878cd 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeAction.java
@@ -267,24 +267,7 @@ protected void doStart(ClusterState clusterState) {
                 final DiscoveryNodes nodes = clusterState.nodes();
                 if (nodes.isLocalNodeElectedClusterManager() || localExecute(request)) {
                     // check for block, if blocked, retry, else, execute locally
-                    final ClusterBlockException blockException = checkBlock(request, clusterState);
-                    if (blockException != null) {
-                        if (!blockException.retryable()) {
-                            listener.onFailure(blockException);
-                        } else {
-                            logger.debug("can't execute due to a cluster block, retrying", blockException);
-                            retry(clusterState, blockException, newState -> {
-                                try {
-                                    ClusterBlockException newException = checkBlock(request, newState);
-                                    return (newException == null || !newException.retryable());
-                                } catch (Exception e) {
-                                    // accept state as block will be rechecked by doStart() and listener.onFailure() then called
-                                    logger.trace("exception occurred during cluster block checking, accepting state", e);
-                                    return true;
-                                }
-                            });
-                        }
-                    } else {
+                    if (!checkForBlock(request, clusterState)) {
                         threadPool.executor(executor)
                             .execute(
                                 ActionRunnable.wrap(
@@ -422,12 +405,43 @@ public GetTermVersionResponse read(StreamInput in) throws IOException {
             };
         }
 
+        private boolean checkForBlock(Request request, ClusterState localClusterState) {
+            final ClusterBlockException blockException = checkBlock(request, localClusterState);
+            if (blockException != null) {
+                if (!blockException.retryable()) {
+                    listener.onFailure(blockException);
+                } else {
+                    logger.debug("can't execute due to a cluster block, retrying", blockException);
+                    retry(localClusterState, blockException, newState -> {
+                        try {
+                            ClusterBlockException newException = checkBlock(request, newState);
+                            return (newException == null || !newException.retryable());
+                        } catch (Exception e) {
+                            // accept state as block will be rechecked by doStart() and listener.onFailure() then called
+                            logger.trace("exception occurred during cluster block checking, accepting state", e);
+                            return true;
+                        }
+                    });
+                }
+                return true;
+            } else {
+                return false;
+            }
+        }
+
         private void executeOnLocalNode(ClusterState localClusterState) {
-            Runnable runTask = ActionRunnable.wrap(
-                getDelegateForLocalExecute(localClusterState),
-                l -> clusterManagerOperation(task, request, localClusterState, l)
-            );
-            threadPool.executor(executor).execute(runTask);
+            try {
+                // check for block, if blocked, retry, else, execute locally
+                if (!checkForBlock(request, localClusterState)) {
+                    Runnable runTask = ActionRunnable.wrap(
+                        getDelegateForLocalExecute(localClusterState),
+                        l -> clusterManagerOperation(task, request, localClusterState, l)
+                    );
+                    threadPool.executor(executor).execute(runTask);
+                }
+            } catch (Exception e) {
+                listener.onFailure(e);
+            }
         }
 
         private void executeOnClusterManager(DiscoveryNode clusterManagerNode, ClusterState clusterState) {
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeReadAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeReadAction.java
index d58487a475bcf..88cb2ed6a9bf0 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeReadAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeReadAction.java
@@ -51,6 +51,8 @@ public abstract class TransportClusterManagerNodeReadAction<
     Request extends ClusterManagerNodeReadRequest<Request>,
     Response extends ActionResponse> extends TransportClusterManagerNodeAction<Request, Response> {
 
+    protected boolean localExecuteSupported = false;
+
     protected TransportClusterManagerNodeReadAction(
         String actionName,
         TransportService transportService,
@@ -58,7 +60,8 @@ protected TransportClusterManagerNodeReadAction(
         ThreadPool threadPool,
         ActionFilters actionFilters,
         Writeable.Reader<Request> request,
-        IndexNameExpressionResolver indexNameExpressionResolver
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        boolean localExecuteSupported
     ) {
         this(
             actionName,
@@ -71,6 +74,19 @@ protected TransportClusterManagerNodeReadAction(
             request,
             indexNameExpressionResolver
         );
+        this.localExecuteSupported = localExecuteSupported;
+    }
+
+    protected TransportClusterManagerNodeReadAction(
+        String actionName,
+        TransportService transportService,
+        ClusterService clusterService,
+        ThreadPool threadPool,
+        ActionFilters actionFilters,
+        Writeable.Reader<Request> request,
+        IndexNameExpressionResolver indexNameExpressionResolver
+    ) {
+        this(actionName, transportService, clusterService, threadPool, actionFilters, request, indexNameExpressionResolver, false);
     }
 
     protected TransportClusterManagerNodeReadAction(
@@ -124,4 +140,9 @@ protected TransportClusterManagerNodeReadAction(
     protected final boolean localExecute(Request request) {
         return request.local();
     }
+
+    protected boolean localExecuteSupportedByAction() {
+        return localExecuteSupported;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/action/support/clustermanager/info/TransportClusterInfoAction.java b/server/src/main/java/org/opensearch/action/support/clustermanager/info/TransportClusterInfoAction.java
index 65f00a4731ab5..8a0082ad05f66 100644
--- a/server/src/main/java/org/opensearch/action/support/clustermanager/info/TransportClusterInfoAction.java
+++ b/server/src/main/java/org/opensearch/action/support/clustermanager/info/TransportClusterInfoAction.java
@@ -62,6 +62,7 @@ public TransportClusterInfoAction(
         IndexNameExpressionResolver indexNameExpressionResolver
     ) {
         super(actionName, transportService, clusterService, threadPool, actionFilters, request, indexNameExpressionResolver);
+        this.localExecuteSupported = true;
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
index 8a4e12567b515..7e10b583ef21a 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodeResponse.java
@@ -67,6 +67,6 @@ public DiscoveryNode getNode() {
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
-        node.writeTo(out);
+        node.writeToWithAttribute(out);
     }
 }
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodesRequest.java b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodesRequest.java
index 4d54ce51c923c..a4f6d8afeaf38 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/BaseNodesRequest.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/BaseNodesRequest.java
@@ -65,6 +65,14 @@ public abstract class BaseNodesRequest<Request extends BaseNodesRequest<Request>
      * will be ignored and this will be used.
      * */
     private DiscoveryNode[] concreteNodes;
+
+    /**
+     * Since do not use the discovery nodes coming from the request in all code paths following a request extended off from
+     * BaseNodeRequest, we do not require it to sent around across all nodes.
+     *
+     * Setting default behavior as `true` but can be explicitly changed in requests that do not require.
+     */
+    private boolean includeDiscoveryNodes = true;
     private final TimeValue DEFAULT_TIMEOUT_SECS = TimeValue.timeValueSeconds(30);
 
     private TimeValue timeout;
@@ -119,6 +127,14 @@ public void setConcreteNodes(DiscoveryNode[] concreteNodes) {
         this.concreteNodes = concreteNodes;
     }
 
+    public void setIncludeDiscoveryNodes(boolean value) {
+        includeDiscoveryNodes = value;
+    }
+
+    public boolean getIncludeDiscoveryNodes() {
+        return includeDiscoveryNodes;
+    }
+
     @Override
     public ActionRequestValidationException validate() {
         return null;
diff --git a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
index 1b44ee562a4ed..3a356a6bba69a 100644
--- a/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
+++ b/server/src/main/java/org/opensearch/action/support/nodes/TransportNodesAction.java
@@ -226,6 +226,7 @@ class AsyncAction {
         private final NodesRequest request;
         private final ActionListener<NodesResponse> listener;
         private final AtomicReferenceArray<Object> responses;
+        private final DiscoveryNode[] concreteNodes;
         private final AtomicInteger counter = new AtomicInteger();
         private final Task task;
 
@@ -238,10 +239,18 @@ class AsyncAction {
                 assert request.concreteNodes() != null;
             }
             this.responses = new AtomicReferenceArray<>(request.concreteNodes().length);
+            this.concreteNodes = request.concreteNodes();
+
+            if (request.getIncludeDiscoveryNodes() == false) {
+                // As we transfer the ownership of discovery nodes to route the request to into the AsyncAction class, we
+                // remove the list of DiscoveryNodes from the request. This reduces the payload of the request and improves
+                // the number of concrete nodes in the memory.
+                request.setConcreteNodes(null);
+            }
         }
 
         void start() {
-            final DiscoveryNode[] nodes = request.concreteNodes();
+            final DiscoveryNode[] nodes = this.concreteNodes;
             if (nodes.length == 0) {
                 // nothing to notify
                 threadPool.generic().execute(() -> listener.onResponse(newResponse(request, responses)));
@@ -260,7 +269,6 @@ void start() {
                     if (task != null) {
                         nodeRequest.setParentTask(clusterService.localNode().getId(), task.getId());
                     }
-
                     transportService.sendRequest(
                         node,
                         getTransportNodeAction(node),
diff --git a/server/src/main/java/org/opensearch/action/update/UpdateRequest.java b/server/src/main/java/org/opensearch/action/update/UpdateRequest.java
index ea18f53ad3ada..0a62148539ee4 100644
--- a/server/src/main/java/org/opensearch/action/update/UpdateRequest.java
+++ b/server/src/main/java/org/opensearch/action/update/UpdateRequest.java
@@ -740,7 +740,7 @@ public IndexRequest doc() {
 
     private IndexRequest safeDoc() {
         if (doc == null) {
-            doc = new IndexRequest();
+            doc = new IndexRequest(index);
         }
         return doc;
     }
@@ -826,7 +826,7 @@ public IndexRequest upsertRequest() {
 
     private IndexRequest safeUpsertRequest() {
         if (upsertRequest == null) {
-            upsertRequest = new IndexRequest();
+            upsertRequest = new IndexRequest(index);
         }
         return upsertRequest;
     }
diff --git a/server/src/main/java/org/opensearch/client/OriginSettingClient.java b/server/src/main/java/org/opensearch/client/OriginSettingClient.java
index 1b0e08cc489c4..27d87227df7bc 100644
--- a/server/src/main/java/org/opensearch/client/OriginSettingClient.java
+++ b/server/src/main/java/org/opensearch/client/OriginSettingClient.java
@@ -36,6 +36,7 @@
 import org.opensearch.action.ActionType;
 import org.opensearch.action.support.ContextPreservingActionListener;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.action.ActionResponse;
 
@@ -65,7 +66,11 @@ protected <Request extends ActionRequest, Response extends ActionResponse> void
         ActionListener<Response> listener
     ) {
         final Supplier<ThreadContext.StoredContext> supplier = in().threadPool().getThreadContext().newRestorableContext(false);
-        try (ThreadContext.StoredContext ignore = in().threadPool().getThreadContext().stashWithOrigin(origin)) {
+        try (
+            ThreadContext.StoredContext ignore = ThreadContextAccess.doPrivileged(
+                () -> in().threadPool().getThreadContext().stashWithOrigin(origin)
+            )
+        ) {
             super.doExecute(action, request, new ContextPreservingActionListener<>(supplier, listener));
         }
     }
diff --git a/server/src/main/java/org/opensearch/client/support/AbstractClient.java b/server/src/main/java/org/opensearch/client/support/AbstractClient.java
index 786bfa38bb19c..d3e26f846b70c 100644
--- a/server/src/main/java/org/opensearch/client/support/AbstractClient.java
+++ b/server/src/main/java/org/opensearch/client/support/AbstractClient.java
@@ -410,6 +410,7 @@
 import org.opensearch.common.action.ActionFuture;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.action.ActionResponse;
 import org.opensearch.core.common.bytes.BytesReference;
@@ -2082,7 +2083,9 @@ protected <Request extends ActionRequest, Response extends ActionResponse> void
                 ActionListener<Response> listener
             ) {
                 ThreadContext threadContext = threadPool().getThreadContext();
-                try (ThreadContext.StoredContext ctx = threadContext.stashAndMergeHeaders(headers)) {
+                try (
+                    ThreadContext.StoredContext ctx = ThreadContextAccess.doPrivileged(() -> threadContext.stashAndMergeHeaders(headers))
+                ) {
                     super.doExecute(action, request, listener);
                 }
             }
diff --git a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
index 74af3472433ba..770a0c171e084 100644
--- a/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
+++ b/server/src/main/java/org/opensearch/cluster/AbstractDiffable.java
@@ -83,6 +83,11 @@ private static class CompleteDiff<T extends Diffable<T>> implements Diff<T> {
             this.part = part;
         }
 
+        @Override
+        public String toString() {
+            return "CompleteDiff{" + "part=" + part + '}';
+        }
+
         /**
          * Creates simple diff without changes
          */
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterInfo.java b/server/src/main/java/org/opensearch/cluster/ClusterInfo.java
index 616c90cb5759c..8244726876465 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterInfo.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterInfo.java
@@ -33,6 +33,7 @@
 package org.opensearch.cluster;
 
 import org.opensearch.Version;
+import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -69,6 +70,8 @@ public class ClusterInfo implements ToXContentFragment, Writeable {
     final Map<ShardRouting, String> routingToDataPath;
     final Map<NodeAndPath, ReservedSpace> reservedSpace;
     final Map<String, FileCacheStats> nodeFileCacheStats;
+    private long avgTotalBytes;
+    private long avgFreeByte;
 
     protected ClusterInfo() {
         this(Map.of(), Map.of(), Map.of(), Map.of(), Map.of(), Map.of());
@@ -98,6 +101,7 @@ public ClusterInfo(
         this.routingToDataPath = routingToDataPath;
         this.reservedSpace = reservedSpace;
         this.nodeFileCacheStats = nodeFileCacheStats;
+        calculateAvgFreeAndTotalBytes(mostAvailableSpaceUsage);
     }
 
     public ClusterInfo(StreamInput in) throws IOException {
@@ -122,6 +126,39 @@ public ClusterInfo(StreamInput in) throws IOException {
         } else {
             this.nodeFileCacheStats = Map.of();
         }
+
+        calculateAvgFreeAndTotalBytes(mostAvailableSpaceUsage);
+    }
+
+    /**
+     * Returns a {@link DiskUsage} for the {@link RoutingNode} using the
+     * average usage of other nodes in the disk usage map.
+     * @param usages Map of nodeId to DiskUsage for all known nodes.
+     */
+    private void calculateAvgFreeAndTotalBytes(final Map<String, DiskUsage> usages) {
+        if (usages == null || usages.isEmpty()) {
+            this.avgTotalBytes = 0;
+            this.avgFreeByte = 0;
+            return;
+        }
+
+        long totalBytes = 0;
+        long freeBytes = 0;
+        for (DiskUsage du : usages.values()) {
+            totalBytes += du.getTotalBytes();
+            freeBytes += du.getFreeBytes();
+        }
+
+        this.avgTotalBytes = totalBytes / usages.size();
+        this.avgFreeByte = freeBytes / usages.size();
+    }
+
+    public long getAvgFreeByte() {
+        return avgFreeByte;
+    }
+
+    public long getAvgTotalBytes() {
+        return avgTotalBytes;
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterManagerMetrics.java b/server/src/main/java/org/opensearch/cluster/ClusterManagerMetrics.java
new file mode 100644
index 0000000000000..a98349a4af5cd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/ClusterManagerMetrics.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster;
+
+import org.opensearch.telemetry.metrics.Counter;
+import org.opensearch.telemetry.metrics.Histogram;
+import org.opensearch.telemetry.metrics.MetricsRegistry;
+import org.opensearch.telemetry.metrics.tags.Tags;
+
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Class containing metrics (counters/latency) specific to ClusterManager.
+ *
+ * @opensearch.internal
+ */
+public final class ClusterManagerMetrics {
+
+    private static final String LATENCY_METRIC_UNIT_MS = "ms";
+    private static final String COUNTER_METRICS_UNIT = "1";
+
+    public final Histogram clusterStateAppliersHistogram;
+    public final Histogram clusterStateListenersHistogram;
+    public final Histogram rerouteHistogram;
+    public final Histogram clusterStateComputeHistogram;
+    public final Histogram clusterStatePublishHistogram;
+
+    public final Counter leaderCheckFailureCounter;
+    public final Counter followerChecksFailureCounter;
+
+    public ClusterManagerMetrics(MetricsRegistry metricsRegistry) {
+        clusterStateAppliersHistogram = metricsRegistry.createHistogram(
+            "cluster.state.appliers.latency",
+            "Histogram for tracking the latency of cluster state appliers",
+            LATENCY_METRIC_UNIT_MS
+        );
+        clusterStateListenersHistogram = metricsRegistry.createHistogram(
+            "cluster.state.listeners.latency",
+            "Histogram for tracking the latency of cluster state listeners",
+            LATENCY_METRIC_UNIT_MS
+        );
+        rerouteHistogram = metricsRegistry.createHistogram(
+            "allocation.reroute.latency",
+            "Histogram for recording latency of shard re-routing",
+            LATENCY_METRIC_UNIT_MS
+        );
+        clusterStateComputeHistogram = metricsRegistry.createHistogram(
+            "cluster.state.new.compute.latency",
+            "Histogram for recording time taken to compute new cluster state",
+            LATENCY_METRIC_UNIT_MS
+        );
+        clusterStatePublishHistogram = metricsRegistry.createHistogram(
+            "cluster.state.publish.success.latency",
+            "Histogram for recording time taken to publish a new cluster state",
+            LATENCY_METRIC_UNIT_MS
+        );
+        followerChecksFailureCounter = metricsRegistry.createCounter(
+            "followers.checker.failure.count",
+            "Counter for number of failed follower checks",
+            COUNTER_METRICS_UNIT
+        );
+        leaderCheckFailureCounter = metricsRegistry.createCounter(
+            "leader.checker.failure.count",
+            "Counter for number of failed leader checks",
+            COUNTER_METRICS_UNIT
+        );
+    }
+
+    public void recordLatency(Histogram histogram, Double value) {
+        histogram.record(value);
+    }
+
+    public void recordLatency(Histogram histogram, Double value, Optional<Tags> tags) {
+        if (Objects.isNull(tags) || tags.isEmpty()) {
+            histogram.record(value);
+            return;
+        }
+        histogram.record(value, tags.get());
+    }
+
+    public void incrementCounter(Counter counter, Double value) {
+        incrementCounter(counter, value, Optional.empty());
+    }
+
+    public void incrementCounter(Counter counter, Double value, Optional<Tags> tags) {
+        if (Objects.isNull(tags) || tags.isEmpty()) {
+            counter.add(value);
+            return;
+        }
+        counter.add(value, tags.get());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterModule.java b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
index e3c4bc80eb4a7..0d15158f31e34 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterModule.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterModule.java
@@ -48,6 +48,7 @@
 import org.opensearch.cluster.metadata.MetadataIndexTemplateService;
 import org.opensearch.cluster.metadata.MetadataMappingService;
 import org.opensearch.cluster.metadata.MetadataUpdateSettingsService;
+import org.opensearch.cluster.metadata.QueryGroupMetadata;
 import org.opensearch.cluster.metadata.RepositoriesMetadata;
 import org.opensearch.cluster.metadata.WeightedRoutingMetadata;
 import org.opensearch.cluster.routing.DelayedAllocationService;
@@ -73,6 +74,7 @@
 import org.opensearch.cluster.routing.allocation.decider.ResizeAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.RestoreInProgressAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.SameShardAllocationDecider;
+import org.opensearch.cluster.routing.allocation.decider.SearchReplicaAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.ShardsLimitAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.SnapshotInProgressAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.TargetPoolAllocationDecider;
@@ -145,7 +147,8 @@ public ClusterModule(
         List<ClusterPlugin> clusterPlugins,
         ClusterInfoService clusterInfoService,
         SnapshotsInfoService snapshotsInfoService,
-        ThreadContext threadContext
+        ThreadContext threadContext,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
         this.clusterPlugins = clusterPlugins;
         this.deciderList = createAllocationDeciders(settings, clusterService.getClusterSettings(), clusterPlugins);
@@ -158,7 +161,8 @@ public ClusterModule(
             shardsAllocator,
             clusterInfoService,
             snapshotsInfoService,
-            settings
+            settings,
+            clusterManagerMetrics
         );
     }
 
@@ -211,6 +215,8 @@ public static List<Entry> getNamedWriteables() {
             DecommissionAttributeMetadata::new,
             DecommissionAttributeMetadata::readDiffFrom
         );
+
+        registerMetadataCustom(entries, QueryGroupMetadata.TYPE, QueryGroupMetadata::new, QueryGroupMetadata::readDiffFrom);
         // Task Status (not Diffable)
         entries.add(new Entry(Task.Status.class, PersistentTasksNodeService.Status.NAME, PersistentTasksNodeService.Status::new));
         return entries;
@@ -372,6 +378,9 @@ public static Collection<AllocationDecider> createAllocationDeciders(
         addAllocationDecider(deciders, new SnapshotInProgressAllocationDecider());
         addAllocationDecider(deciders, new RestoreInProgressAllocationDecider());
         addAllocationDecider(deciders, new FilterAllocationDecider(settings, clusterSettings));
+        if (FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL_SETTING.get(settings)) {
+            addAllocationDecider(deciders, new SearchReplicaAllocationDecider(settings, clusterSettings));
+        }
         addAllocationDecider(deciders, new SameShardAllocationDecider(settings, clusterSettings));
         addAllocationDecider(deciders, new DiskThresholdDecider(settings, clusterSettings));
         addAllocationDecider(deciders, new ThrottlingAllocationDecider(settings, clusterSettings));
@@ -379,9 +388,7 @@ public static Collection<AllocationDecider> createAllocationDeciders(
         addAllocationDecider(deciders, new AwarenessAllocationDecider(settings, clusterSettings));
         addAllocationDecider(deciders, new NodeLoadAwareAllocationDecider(settings, clusterSettings));
         addAllocationDecider(deciders, new TargetPoolAllocationDecider());
-        if (FeatureFlags.isEnabled(FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING)) {
-            addAllocationDecider(deciders, new RemoteStoreMigrationAllocationDecider(settings, clusterSettings));
-        }
+        addAllocationDecider(deciders, new RemoteStoreMigrationAllocationDecider(settings, clusterSettings));
 
         clusterPlugins.stream()
             .flatMap(p -> p.createAllocationDeciders(settings, clusterSettings).stream())
diff --git a/server/src/main/java/org/opensearch/cluster/ClusterState.java b/server/src/main/java/org/opensearch/cluster/ClusterState.java
index 9e63f961d241d..1e4fd2dfffe0f 100644
--- a/server/src/main/java/org/opensearch/cluster/ClusterState.java
+++ b/server/src/main/java/org/opensearch/cluster/ClusterState.java
@@ -156,7 +156,7 @@ default boolean isPrivate() {
 
     }
 
-    private static final NamedDiffableValueSerializer<Custom> CUSTOM_VALUE_SERIALIZER = new NamedDiffableValueSerializer<>(Custom.class);
+    public static final NamedDiffableValueSerializer<Custom> CUSTOM_VALUE_SERIALIZER = new NamedDiffableValueSerializer<>(Custom.class);
 
     public static final String UNKNOWN_UUID = "_na_";
 
@@ -781,7 +781,7 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(stateUUID);
         metadata.writeTo(out);
         routingTable.writeTo(out);
-        nodes.writeTo(out);
+        nodes.writeToWithAttribute(out);
         blocks.writeTo(out);
         // filter out custom states not supported by the other node
         int numberOfCustoms = 0;
@@ -839,6 +839,34 @@ private static class ClusterStateDiff implements Diff<ClusterState> {
             minimumClusterManagerNodesOnPublishingClusterManager = after.minimumClusterManagerNodesOnPublishingClusterManager;
         }
 
+        @Override
+        public String toString() {
+            return new StringBuilder().append("ClusterStateDiff{toVersion=")
+                .append(toVersion)
+                .append(", fromUuid='")
+                .append(fromUuid)
+                .append('\'')
+                .append(", toUuid='")
+                .append(toUuid)
+                .append('\'')
+                .append(", clusterName=")
+                .append(clusterName)
+                .append(", routingTable=")
+                .append(routingTable)
+                .append(", nodes=")
+                .append(nodes)
+                .append(", metadata=")
+                .append(metadata)
+                .append(", blocks=")
+                .append(blocks)
+                .append(", customs=")
+                .append(customs)
+                .append(", minimumClusterManagerNodesOnPublishingClusterManager=")
+                .append(minimumClusterManagerNodesOnPublishingClusterManager)
+                .append("}")
+                .toString();
+        }
+
         ClusterStateDiff(StreamInput in, DiscoveryNode localNode) throws IOException {
             clusterName = new ClusterName(in);
             fromUuid = in.readString();
@@ -859,13 +887,23 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeString(toUuid);
             out.writeLong(toVersion);
             routingTable.writeTo(out);
-            nodes.writeTo(out);
+            nodesWriteToWithAttributes(nodes, out);
             metadata.writeTo(out);
             blocks.writeTo(out);
             customs.writeTo(out);
             out.writeVInt(minimumClusterManagerNodesOnPublishingClusterManager);
         }
 
+        private void nodesWriteToWithAttributes(Diff<DiscoveryNodes> nodes, StreamOutput out) throws IOException {
+            DiscoveryNodes part = nodes.apply(null);
+            if (part != null) {
+                out.writeBoolean(true);
+                part.writeToWithAttribute(out);
+            } else {
+                out.writeBoolean(false);
+            }
+        }
+
         @Override
         public ClusterState apply(ClusterState state) {
             Builder builder = new Builder(clusterName);
diff --git a/server/src/main/java/org/opensearch/cluster/DiffableUtils.java b/server/src/main/java/org/opensearch/cluster/DiffableUtils.java
index a38fc81bebc08..4b5dcaa52cc50 100644
--- a/server/src/main/java/org/opensearch/cluster/DiffableUtils.java
+++ b/server/src/main/java/org/opensearch/cluster/DiffableUtils.java
@@ -271,6 +271,18 @@ public Map<K, T> getUpserts() {
             return upserts;
         }
 
+        @Override
+        public String toString() {
+            return new StringBuilder().append("MapDiff{deletes=")
+                .append(deletes)
+                .append(", diffs=")
+                .append(diffs)
+                .append(", upserts=")
+                .append(upserts)
+                .append("}")
+                .toString();
+        }
+
         @Override
         public void writeTo(StreamOutput out) throws IOException {
             out.writeCollection(deletes, (o, v) -> keySerializer.writeKey(v, o));
@@ -494,6 +506,18 @@ public void writeDiff(Diff<V> value, StreamOutput out) throws IOException {
      * @opensearch.internal
      */
     public abstract static class NonDiffableValueSerializer<K, V> implements ValueSerializer<K, V> {
+        private static final NonDiffableValueSerializer ABSTRACT_INSTANCE = new NonDiffableValueSerializer<>() {
+            @Override
+            public void write(Object value, StreamOutput out) {
+                throw new UnsupportedOperationException();
+            }
+
+            @Override
+            public Object read(StreamInput in, Object key) {
+                throw new UnsupportedOperationException();
+            }
+        };
+
         @Override
         public boolean supportsDiffableValues() {
             return false;
@@ -513,6 +537,10 @@ public void writeDiff(Diff<V> value, StreamOutput out) throws IOException {
         public Diff<V> readDiff(StreamInput in, K key) throws IOException {
             throw new UnsupportedOperationException();
         }
+
+        public static <K, V> NonDiffableValueSerializer<K, V> getAbstractInstance() {
+            return ABSTRACT_INSTANCE;
+        }
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/cluster/RepositoryCleanupInProgress.java b/server/src/main/java/org/opensearch/cluster/RepositoryCleanupInProgress.java
index debfe43f1d2b1..d21de314d3f27 100644
--- a/server/src/main/java/org/opensearch/cluster/RepositoryCleanupInProgress.java
+++ b/server/src/main/java/org/opensearch/cluster/RepositoryCleanupInProgress.java
@@ -45,6 +45,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * Information passed during repository cleanup
@@ -118,6 +119,24 @@ public Version getMinimalSupportedVersion() {
         return LegacyESVersion.V_7_4_0;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        RepositoryCleanupInProgress that = (RepositoryCleanupInProgress) o;
+        return entries.equals(that.entries);
+    }
+
+    @Override
+    public int hashCode() {
+        return 31 + entries.hashCode();
+    }
+
     /**
      * Entry in the collection.
      *
@@ -155,6 +174,23 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeLong(repositoryStateId);
         }
 
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) {
+                return true;
+            }
+            if (o == null || getClass() != o.getClass()) {
+                return false;
+            }
+            RepositoryCleanupInProgress.Entry that = (RepositoryCleanupInProgress.Entry) o;
+            return repository.equals(that.repository) && repositoryStateId == that.repositoryStateId;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(repository, repositoryStateId);
+        }
+
         @Override
         public String toString() {
             return "{" + repository + '}' + '{' + repositoryStateId + '}';
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoader.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoader.java
new file mode 100644
index 0000000000000..332960ef49064
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoader.java
@@ -0,0 +1,108 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.OpenSearchCorruptionException;
+import org.opensearch.action.admin.indices.template.put.PutComponentTemplateAction;
+import org.opensearch.client.Client;
+import org.opensearch.client.OriginSettingClient;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.ComponentTemplate;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.xcontent.DeprecationHandler;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Objects;
+import java.util.function.Supplier;
+
+/**
+ * Class responsible for loading the component templates provided by a repository into the cluster state.
+ */
+@ExperimentalApi
+public class ClusterStateSystemTemplateLoader implements SystemTemplateLoader {
+
+    private final Client client;
+
+    private final Supplier<ClusterState> clusterStateSupplier;
+
+    private static final Logger logger = LogManager.getLogger(SystemTemplateLoader.class);
+
+    public static final String TEMPLATE_LOADER_IDENTIFIER = "system_template_loader";
+    public static final String TEMPLATE_TYPE_KEY = "_type";
+
+    public ClusterStateSystemTemplateLoader(Client client, Supplier<ClusterState> clusterStateSupplier) {
+        this.client = new OriginSettingClient(client, TEMPLATE_LOADER_IDENTIFIER);
+        this.clusterStateSupplier = clusterStateSupplier;
+    }
+
+    @Override
+    public boolean loadTemplate(SystemTemplate template) throws IOException {
+        final ComponentTemplate existingTemplate = clusterStateSupplier.get()
+            .metadata()
+            .componentTemplates()
+            .get(template.templateMetadata().fullyQualifiedName());
+
+        if (existingTemplate != null
+            && !SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE.equals(
+                Objects.toString(existingTemplate.metadata().get(TEMPLATE_TYPE_KEY))
+            )) {
+            throw new OpenSearchCorruptionException(
+                "Attempting to create " + template.templateMetadata().name() + " which has already been created through some other source."
+            );
+        }
+
+        if (existingTemplate != null && existingTemplate.version() >= template.templateMetadata().version()) {
+            logger.debug(
+                "Skipping putting template {} as its existing version [{}] is >= fetched version [{}]",
+                template.templateMetadata().fullyQualifiedName(),
+                existingTemplate.version(),
+                template.templateMetadata().version()
+            );
+            return false;
+        }
+
+        ComponentTemplate newTemplate = null;
+        try (
+            XContentParser contentParser = JsonXContent.jsonXContent.createParser(
+                NamedXContentRegistry.EMPTY,
+                DeprecationHandler.IGNORE_DEPRECATIONS,
+                template.templateContent().utf8ToString()
+            )
+        ) {
+            newTemplate = ComponentTemplate.parse(contentParser);
+        }
+
+        if (!Objects.equals(newTemplate.version(), template.templateMetadata().version())) {
+            throw new OpenSearchCorruptionException(
+                "Template version mismatch for "
+                    + template.templateMetadata().name()
+                    + ". Version in metadata: "
+                    + template.templateMetadata().version()
+                    + " , Version in content: "
+                    + newTemplate.version()
+            );
+        }
+
+        final PutComponentTemplateAction.Request request = new PutComponentTemplateAction.Request(
+            template.templateMetadata().fullyQualifiedName()
+        ).componentTemplate(newTemplate);
+
+        return client.admin()
+            .indices()
+            .execute(PutComponentTemplateAction.INSTANCE, request)
+            .actionGet(TimeValue.timeValueMillis(30000))
+            .isAcknowledged();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplate.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplate.java
new file mode 100644
index 0000000000000..e11ded7ef5546
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplate.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.common.bytes.BytesReference;
+
+/**
+ * Encapsulates the information and content about a system template available within a repository.
+ */
+@ExperimentalApi
+public class SystemTemplate {
+
+    private final BytesReference templateContent;
+
+    private final SystemTemplateMetadata templateMetadata;
+
+    private final TemplateRepositoryMetadata repositoryMetadata;
+
+    public SystemTemplate(BytesReference templateContent, SystemTemplateMetadata templateInfo, TemplateRepositoryMetadata repositoryInfo) {
+        this.templateContent = templateContent;
+        this.templateMetadata = templateInfo;
+        this.repositoryMetadata = repositoryInfo;
+    }
+
+    public BytesReference templateContent() {
+        return templateContent;
+    }
+
+    public SystemTemplateMetadata templateMetadata() {
+        return templateMetadata;
+    }
+
+    public TemplateRepositoryMetadata repositoryMetadata() {
+        return repositoryMetadata;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateLoader.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateLoader.java
new file mode 100644
index 0000000000000..077580aed5a64
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateLoader.java
@@ -0,0 +1,26 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+
+/**
+ * Interface to load template into the OpenSearch runtime.
+ */
+@ExperimentalApi
+public interface SystemTemplateLoader {
+
+    /**
+     * @param template Templated to be loaded
+     * @throws IOException If an exceptional situation is encountered while parsing/loading the template
+     */
+    boolean loadTemplate(SystemTemplate template) throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateMetadata.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateMetadata.java
new file mode 100644
index 0000000000000..227b70ffa2ef5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateMetadata.java
@@ -0,0 +1,89 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.Objects;
+
+/**
+ * Metadata information about a template available in a template repository.
+ */
+@ExperimentalApi
+public class SystemTemplateMetadata {
+
+    private final long version;
+    private final String type;
+    private final String name;
+
+    private static final String DELIMITER = "@";
+
+    public static final String COMPONENT_TEMPLATE_TYPE = "@abc_template";
+
+    public SystemTemplateMetadata(long version, String type, String name) {
+        this.version = version;
+        this.type = type;
+        this.name = name;
+    }
+
+    public String type() {
+        return type;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public long version() {
+        return version;
+    }
+
+    /**
+     * Gets the metadata using fully qualified name for the template
+     * @param fullyQualifiedName (e.g. @abc_template@logs@1)
+     * @return Metadata object based on name
+     */
+    public static SystemTemplateMetadata fromComponentTemplate(String fullyQualifiedName) {
+        assert fullyQualifiedName.length() > DELIMITER.length() * 3 + 2 + COMPONENT_TEMPLATE_TYPE.length()
+            : "System template name must have all defined components";
+        assert (DELIMITER + fullyQualifiedName.substring(1, fullyQualifiedName.indexOf(DELIMITER, 1))).equals(COMPONENT_TEMPLATE_TYPE);
+
+        return new SystemTemplateMetadata(
+            Long.parseLong(fullyQualifiedName.substring(fullyQualifiedName.lastIndexOf(DELIMITER) + 1)),
+            COMPONENT_TEMPLATE_TYPE,
+            fullyQualifiedName.substring(fullyQualifiedName.indexOf(DELIMITER, 2) + 1, fullyQualifiedName.lastIndexOf(DELIMITER))
+        );
+    }
+
+    public static SystemTemplateMetadata fromComponentTemplateInfo(String name, long version) {
+        return new SystemTemplateMetadata(version, COMPONENT_TEMPLATE_TYPE, name);
+    }
+
+    public final String fullyQualifiedName() {
+        return type + DELIMITER + name + DELIMITER + version;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        SystemTemplateMetadata that = (SystemTemplateMetadata) o;
+        return version == that.version && Objects.equals(type, that.type) && Objects.equals(name, that.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(version, type, name);
+    }
+
+    @Override
+    public String toString() {
+        return "SystemTemplateMetadata{" + "version=" + version + ", type='" + type + '\'' + ", name='" + name + '\'' + '}';
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateRepository.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateRepository.java
new file mode 100644
index 0000000000000..9cf302b8874f2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplateRepository.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+
+/**
+ * Repository interface around the templates provided by a store (e.g. code repo, remote file store, etc)
+ */
+@ExperimentalApi
+public interface SystemTemplateRepository extends AutoCloseable {
+
+    /**
+     * @return Metadata about the repository
+     */
+    TemplateRepositoryMetadata metadata();
+
+    /**
+     * @return Metadata for all available templates
+     */
+    Iterable<SystemTemplateMetadata> listTemplates() throws IOException;
+
+    /**
+     *
+     * @param template metadata about template to be fetched
+     * @return The actual template content
+     */
+    SystemTemplate getTemplate(SystemTemplateMetadata template) throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesPlugin.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesPlugin.java
new file mode 100644
index 0000000000000..54871e6db7010
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesPlugin.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+
+/**
+ * Plugin interface to expose the template maintaining logic.
+ */
+@ExperimentalApi
+public interface SystemTemplatesPlugin {
+
+    /**
+     * @return repository implementation from which templates are to be fetched.
+     */
+    SystemTemplateRepository loadRepository() throws IOException;
+
+    /**
+     * @param templateInfo Metadata about the template to load
+     * @return Implementation of TemplateLoader which determines how to make the template available at runtime.
+     */
+    SystemTemplateLoader loaderFor(SystemTemplateMetadata templateInfo);
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesService.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesService.java
new file mode 100644
index 0000000000000..90652192e5c28
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesService.java
@@ -0,0 +1,183 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.cluster.LocalNodeClusterManagerListener;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Service class to orchestrate execution around available templates' management.
+ */
+@ExperimentalApi
+public class SystemTemplatesService implements LocalNodeClusterManagerListener {
+
+    public static final Setting<Boolean> SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED = Setting.boolSetting(
+        "cluster.application_templates.enabled",
+        false,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    private final List<SystemTemplatesPlugin> systemTemplatesPluginList;
+    private final ThreadPool threadPool;
+
+    private final AtomicBoolean loaded = new AtomicBoolean(false);
+
+    private volatile boolean enabledTemplates;
+
+    private volatile Stats latestStats;
+
+    private static final Logger logger = LogManager.getLogger(SystemTemplatesService.class);
+
+    public SystemTemplatesService(
+        List<SystemTemplatesPlugin> systemTemplatesPluginList,
+        ThreadPool threadPool,
+        ClusterSettings clusterSettings,
+        Settings settings
+    ) {
+        this.systemTemplatesPluginList = systemTemplatesPluginList;
+        this.threadPool = threadPool;
+        if (settings.getAsBoolean(SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED.getKey(), false)) {
+            setEnabledTemplates(settings.getAsBoolean(SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED.getKey(), false));
+        }
+        clusterSettings.addSettingsUpdateConsumer(SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED, this::setEnabledTemplates);
+    }
+
+    @Override
+    public void onClusterManager() {
+        threadPool.generic().execute(() -> refreshTemplates(false));
+    }
+
+    @Override
+    public void offClusterManager() {
+        // do nothing
+    }
+
+    public void verifyRepositories() {
+        refreshTemplates(true);
+    }
+
+    public Stats stats() {
+        return latestStats;
+    }
+
+    void refreshTemplates(boolean verification) {
+        int templatesLoaded = 0;
+        int failedLoadingTemplates = 0;
+        int failedLoadingRepositories = 0;
+        List<Exception> exceptions = new ArrayList<>();
+
+        if ((verification || loaded.compareAndSet(false, true)) && enabledTemplates) {
+            for (SystemTemplatesPlugin plugin : systemTemplatesPluginList) {
+                try (SystemTemplateRepository repository = plugin.loadRepository()) {
+
+                    final TemplateRepositoryMetadata repositoryMetadata = repository.metadata();
+                    logger.debug(
+                        "Loading templates from repository: {} at version {}",
+                        repositoryMetadata.id(),
+                        repositoryMetadata.version()
+                    );
+
+                    for (SystemTemplateMetadata templateMetadata : repository.listTemplates()) {
+                        try {
+                            final SystemTemplate template = repository.getTemplate(templateMetadata);
+
+                            // Load plugin if not in verification phase.
+                            if (!verification && plugin.loaderFor(templateMetadata).loadTemplate(template)) {
+                                templatesLoaded++;
+                            }
+
+                        } catch (Exception ex) {
+                            exceptions.add(ex);
+                            logger.error(
+                                new ParameterizedMessage(
+                                    "Failed loading template  {} from repository: {}",
+                                    templateMetadata.fullyQualifiedName(),
+                                    repositoryMetadata.id()
+                                ),
+                                ex
+                            );
+                            failedLoadingTemplates++;
+                        }
+                    }
+                } catch (Exception ex) {
+                    exceptions.add(ex);
+                    failedLoadingRepositories++;
+                    logger.error(new ParameterizedMessage("Failed loading repository from plugin: {}", plugin.getClass().getName()), ex);
+                }
+            }
+
+            logger.debug(
+                "Stats: Total Loaded Templates: [{}], Failed Loading Templates: [{}], Failed Loading Repositories: [{}]",
+                templatesLoaded,
+                failedLoadingTemplates,
+                failedLoadingRepositories
+            );
+
+            // End exceptionally if invoked in verification context
+            if (verification && (failedLoadingRepositories > 0 || failedLoadingTemplates > 0)) {
+                latestStats = new Stats(templatesLoaded, failedLoadingTemplates, failedLoadingRepositories);
+                throw new IllegalStateException("Some of the repositories could not be loaded or are corrupted: " + exceptions);
+            }
+        }
+
+        latestStats = new Stats(templatesLoaded, failedLoadingTemplates, failedLoadingRepositories);
+    }
+
+    private void setEnabledTemplates(boolean enabled) {
+        if (!FeatureFlags.isEnabled(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING)) {
+            throw new IllegalArgumentException(
+                "Application Based Configuration Templates is under an experimental feature and can be activated only by enabling "
+                    + FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING.getKey()
+                    + " feature flag."
+            );
+        }
+        enabledTemplates = enabled;
+    }
+
+    /**
+     * Class to record stats for templates loaded through the listener in a single iteration.
+     */
+    @ExperimentalApi
+    public static class Stats {
+        private final long templatesLoaded;
+        private final long failedLoadingTemplates;
+        private final long failedLoadingRepositories;
+
+        public Stats(long templatesLoaded, long failedLoadingTemplates, long failedLoadingRepositories) {
+            this.templatesLoaded = templatesLoaded;
+            this.failedLoadingTemplates = failedLoadingTemplates;
+            this.failedLoadingRepositories = failedLoadingRepositories;
+        }
+
+        public long getTemplatesLoaded() {
+            return templatesLoaded;
+        }
+
+        public long getFailedLoadingTemplates() {
+            return failedLoadingTemplates;
+        }
+
+        public long getFailedLoadingRepositories() {
+            return failedLoadingRepositories;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/TemplateRepositoryMetadata.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/TemplateRepositoryMetadata.java
new file mode 100644
index 0000000000000..1fa79d291480b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/TemplateRepositoryMetadata.java
@@ -0,0 +1,54 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.Objects;
+
+/**
+ * The information to uniquely identify a template repository.
+ */
+@ExperimentalApi
+public class TemplateRepositoryMetadata {
+
+    private final String id;
+    private final long version;
+
+    public TemplateRepositoryMetadata(String id, long version) {
+        this.id = id;
+        this.version = version;
+    }
+
+    public String id() {
+        return id;
+    }
+
+    public long version() {
+        return version;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        TemplateRepositoryMetadata that = (TemplateRepositoryMetadata) o;
+        return version == that.version && Objects.equals(id, that.id);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, version);
+    }
+
+    @Override
+    public String toString() {
+        return "TemplateRepositoryMetadata{" + "id='" + id + '\'' + ", version=" + version + '}';
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/applicationtemplates/package-info.java b/server/src/main/java/org/opensearch/cluster/applicationtemplates/package-info.java
new file mode 100644
index 0000000000000..3fef2aab07d43
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/applicationtemplates/package-info.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/** Core classes responsible for handling all application based configuration templates related operations. */
+package org.opensearch.cluster.applicationtemplates;
diff --git a/server/src/main/java/org/opensearch/cluster/block/ClusterBlock.java b/server/src/main/java/org/opensearch/cluster/block/ClusterBlock.java
index 5fa897c0b1185..7c0a7a2a6b837 100644
--- a/server/src/main/java/org/opensearch/cluster/block/ClusterBlock.java
+++ b/server/src/main/java/org/opensearch/cluster/block/ClusterBlock.java
@@ -52,7 +52,7 @@
  * @opensearch.api
  */
 @PublicApi(since = "1.0.0")
-public class ClusterBlock implements Writeable, ToXContentFragment {
+public class ClusterBlock implements Writeable, ToXContentFragment, Comparable<ClusterBlock> {
 
     private final int id;
     @Nullable
@@ -217,7 +217,13 @@ public int hashCode() {
         return Objects.hash(id, uuid);
     }
 
+    @Override
+    public int compareTo(ClusterBlock block) {
+        return Integer.compare(block.id(), this.id());
+    }
+
     public boolean isAllowReleaseResources() {
         return allowReleaseResources;
     }
+
 }
diff --git a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
index 304136166d515..c2c9e2e2bd0d2 100644
--- a/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
+++ b/server/src/main/java/org/opensearch/cluster/block/ClusterBlocks.java
@@ -42,7 +42,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.rest.RestStatus;
-import org.opensearch.index.IndexModule;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -304,6 +304,10 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeMap(indicesBlocks, StreamOutput::writeString, (o, s) -> writeBlockSet(s, o));
     }
 
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        writeTo(out);
+    }
+
     private static void writeBlockSet(Set<ClusterBlock> blocks, StreamOutput out) throws IOException {
         out.writeCollection(blocks);
     }
@@ -399,7 +403,7 @@ public Builder addBlocks(IndexMetadata indexMetadata) {
             if (IndexMetadata.INDEX_BLOCKS_READ_ONLY_ALLOW_DELETE_SETTING.get(indexMetadata.getSettings())) {
                 addIndexBlock(indexName, IndexMetadata.INDEX_READ_ONLY_ALLOW_DELETE_BLOCK);
             }
-            if (IndexModule.Type.REMOTE_SNAPSHOT.match(indexMetadata.getSettings().get(IndexModule.INDEX_STORE_TYPE_SETTING.getKey()))) {
+            if (indexMetadata.isRemoteSnapshot()) {
                 addIndexBlock(indexName, IndexMetadata.REMOTE_READ_ONLY_ALLOW_DELETE);
             }
             return this;
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/CoordinationMetadata.java b/server/src/main/java/org/opensearch/cluster/coordination/CoordinationMetadata.java
index 1447cc2fbe772..df2550de102f9 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/CoordinationMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/CoordinationMetadata.java
@@ -42,6 +42,7 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 
 import java.io.IOException;
 import java.util.Arrays;
@@ -149,6 +150,10 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeCollection(votingConfigExclusions);
     }
 
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        writeTo(out);
+    }
+
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
         return builder.field(TERM_PARSE_FIELD.getPreferredName(), term)
@@ -272,7 +277,7 @@ public CoordinationMetadata build() {
      * @opensearch.api
      */
     @PublicApi(since = "1.0.0")
-    public static class VotingConfigExclusion implements Writeable, ToXContentFragment {
+    public static class VotingConfigExclusion implements Writeable, ToXContentFragment, Comparable<VotingConfigExclusion> {
         public static final String MISSING_VALUE_MARKER = "_absent_";
         private final String nodeId;
         private final String nodeName;
@@ -361,6 +366,10 @@ public String toString() {
             return sb.toString();
         }
 
+        @Override
+        public int compareTo(VotingConfigExclusion votingConfigExclusion) {
+            return votingConfigExclusion.getNodeId().compareTo(this.getNodeId());
+        }
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/CoordinationState.java b/server/src/main/java/org/opensearch/cluster/coordination/CoordinationState.java
index 987a3e3ffa7d3..c7820c2c9a365 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/CoordinationState.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/CoordinationState.java
@@ -39,6 +39,7 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.io.IOUtils;
 
 import java.io.Closeable;
@@ -52,6 +53,7 @@
 import java.util.Set;
 
 import static org.opensearch.cluster.coordination.Coordinator.ZEN1_BWC_TERM;
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled;
 
 /**
@@ -79,6 +81,7 @@ public class CoordinationState {
     private VotingConfiguration lastPublishedConfiguration;
     private VoteCollection publishVotes;
     private final boolean isRemoteStateEnabled;
+    private final boolean isRemotePublicationEnabled;
 
     public CoordinationState(
         DiscoveryNode localNode,
@@ -102,6 +105,13 @@ public CoordinationState(
             .getLastAcceptedConfiguration();
         this.publishVotes = new VoteCollection();
         this.isRemoteStateEnabled = isRemoteStoreClusterStateEnabled(settings);
+        this.isRemotePublicationEnabled = isRemoteStateEnabled
+            && FeatureFlags.isEnabled(REMOTE_PUBLICATION_EXPERIMENTAL)
+            && localNode.isRemoteStatePublicationEnabled();
+    }
+
+    public boolean isRemotePublicationEnabled() {
+        return isRemotePublicationEnabled;
     }
 
     public long getCurrentTerm() {
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
index 5b2b2b36ea79e..84a998c12a4c2 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Coordinator.java
@@ -37,6 +37,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.LegacyESVersion;
 import org.opensearch.cluster.ClusterChangedEvent;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateTaskConfig;
@@ -85,6 +86,7 @@
 import org.opensearch.discovery.PeerFinder;
 import org.opensearch.discovery.SeedHostsProvider;
 import org.opensearch.discovery.SeedHostsResolver;
+import org.opensearch.gateway.remote.RemoteClusterStateService;
 import org.opensearch.monitor.NodeHealthService;
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
@@ -208,7 +210,9 @@ public Coordinator(
         ElectionStrategy electionStrategy,
         NodeHealthService nodeHealthService,
         PersistedStateRegistry persistedStateRegistry,
-        RemoteStoreNodeService remoteStoreNodeService
+        RemoteStoreNodeService remoteStoreNodeService,
+        ClusterManagerMetrics clusterManagerMetrics,
+        RemoteClusterStateService remoteClusterStateService
     ) {
         this.settings = settings;
         this.transportService = transportService;
@@ -260,16 +264,25 @@ public Coordinator(
             transportService,
             namedWriteableRegistry,
             this::handlePublishRequest,
-            this::handleApplyCommit
+            this::handleApplyCommit,
+            remoteClusterStateService
+        );
+        this.leaderChecker = new LeaderChecker(
+            settings,
+            clusterSettings,
+            transportService,
+            this::onLeaderFailure,
+            nodeHealthService,
+            clusterManagerMetrics
         );
-        this.leaderChecker = new LeaderChecker(settings, clusterSettings, transportService, this::onLeaderFailure, nodeHealthService);
         this.followersChecker = new FollowersChecker(
             settings,
             clusterSettings,
             transportService,
             this::onFollowerCheckRequest,
             this::removeNode,
-            nodeHealthService
+            nodeHealthService,
+            clusterManagerMetrics
         );
         this.nodeRemovalExecutor = new NodeRemovalClusterStateTaskExecutor(allocationService, logger);
         this.clusterApplier = clusterApplier;
@@ -889,6 +902,10 @@ public DiscoveryStats stats() {
                 stats.add(persistedStateRegistry.getPersistedState(stateType).getStats());
             }
         });
+        if (coordinationState.get().isRemotePublicationEnabled()) {
+            stats.add(publicationHandler.getFullDownloadStats());
+            stats.add(publicationHandler.getDiffDownloadStats());
+        }
         clusterStateStats.setPersistenceStats(stats);
         return new DiscoveryStats(new PendingClusterStateStats(0, 0, 0), publicationHandler.stats(), clusterStateStats);
     }
@@ -1321,8 +1338,11 @@ assert getLocalNode().equals(clusterState.getNodes().get(getLocalNode().getId())
                     + clusterState;
 
                 final PublicationTransportHandler.PublicationContext publicationContext = publicationHandler.newPublicationContext(
-                    clusterChangedEvent
+                    clusterChangedEvent,
+                    coordinationState.get().isRemotePublicationEnabled(),
+                    persistedStateRegistry
                 );
+                logger.debug("initialized PublicationContext using class: {}", publicationContext.getClass().toString());
 
                 final PublishRequest publishRequest = coordinationState.get().handleClientValue(clusterState);
                 final CoordinatorPublication publication = new CoordinatorPublication(
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
index 70bb0515bb022..2ec0dabd91786 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/FollowersChecker.java
@@ -35,6 +35,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.coordination.Coordinator.Mode;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
@@ -127,6 +128,7 @@ public class FollowersChecker {
     private final TransportService transportService;
     private final NodeHealthService nodeHealthService;
     private volatile FastResponseState fastResponseState;
+    private ClusterManagerMetrics clusterManagerMetrics;
 
     public FollowersChecker(
         Settings settings,
@@ -134,7 +136,8 @@ public FollowersChecker(
         TransportService transportService,
         Consumer<FollowerCheckRequest> handleRequestAndUpdateState,
         BiConsumer<DiscoveryNode, String> onNodeFailure,
-        NodeHealthService nodeHealthService
+        NodeHealthService nodeHealthService,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
         this.settings = settings;
         this.transportService = transportService;
@@ -161,6 +164,7 @@ public void onNodeDisconnected(DiscoveryNode node, Transport.Connection connecti
                 handleDisconnectedNode(node);
             }
         });
+        this.clusterManagerMetrics = clusterManagerMetrics;
     }
 
     private void setFollowerCheckTimeout(TimeValue followerCheckTimeout) {
@@ -413,6 +417,7 @@ public String executor() {
         }
 
         void failNode(String reason) {
+            clusterManagerMetrics.incrementCounter(clusterManagerMetrics.followerChecksFailureCounter, 1.0);
             transportService.getThreadPool().generic().execute(new Runnable() {
                 @Override
                 public void run() {
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/Join.java b/server/src/main/java/org/opensearch/cluster/coordination/Join.java
index 58fa85992ebc8..ce1a234998690 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/Join.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/Join.java
@@ -78,8 +78,8 @@ public Join(StreamInput in) throws IOException {
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
-        sourceNode.writeTo(out);
-        targetNode.writeTo(out);
+        sourceNode.writeToWithAttribute(out);
+        targetNode.writeToWithAttribute(out);
         out.writeLong(term);
         out.writeLong(lastAcceptedTerm);
         out.writeLong(lastAcceptedVersion);
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinRequest.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinRequest.java
index 6eb1514ae848c..c598240e2e9f0 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinRequest.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinRequest.java
@@ -89,7 +89,7 @@ public JoinRequest(StreamInput in) throws IOException {
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
-        sourceNode.writeTo(out);
+        sourceNode.writeToWithAttribute(out);
         if (out.getVersion().onOrAfter(LegacyESVersion.V_7_7_0)) {
             out.writeLong(minimumTerm);
         }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java b/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
index 0ad2b511c4417..7a1747743ad1c 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/JoinTaskExecutor.java
@@ -69,6 +69,7 @@
 
 import static org.opensearch.cluster.decommission.DecommissionHelper.nodeCommissioned;
 import static org.opensearch.gateway.GatewayService.STATE_NOT_RECOVERED_BLOCK;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_CLUSTER_PUBLICATION_REPO_NAME_ATTRIBUTES;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode.MIXED;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode.STRICT;
@@ -519,7 +520,7 @@ public static void ensureNodesCompatibility(
             );
         }
 
-        ensureRemoteStoreNodesCompatibility(joiningNode, currentNodes, metadata);
+        ensureRemoteRepositoryCompatibility(joiningNode, currentNodes, metadata);
     }
 
     /**
@@ -552,6 +553,30 @@ public static void ensureNodeCommissioned(DiscoveryNode node, Metadata metadata)
         }
     }
 
+    public static void ensureRemoteRepositoryCompatibility(DiscoveryNode joiningNode, DiscoveryNodes currentNodes, Metadata metadata) {
+        List<DiscoveryNode> existingNodes = new ArrayList<>(currentNodes.getNodes().values());
+
+        boolean isClusterRemoteStoreEnabled = existingNodes.stream().anyMatch(DiscoveryNode::isRemoteStoreNode);
+        if (isClusterRemoteStoreEnabled || joiningNode.isRemoteStoreNode()) {
+            ensureRemoteStoreNodesCompatibility(joiningNode, currentNodes, metadata);
+        } else {
+            ensureRemoteClusterStateNodesCompatibility(joiningNode, currentNodes);
+        }
+    }
+
+    private static void ensureRemoteClusterStateNodesCompatibility(DiscoveryNode joiningNode, DiscoveryNodes currentNodes) {
+        List<DiscoveryNode> existingNodes = new ArrayList<>(currentNodes.getNodes().values());
+
+        assert existingNodes.isEmpty() == false;
+        Optional<DiscoveryNode> remotePublicationNode = existingNodes.stream()
+            .filter(DiscoveryNode::isRemoteStatePublicationEnabled)
+            .findFirst();
+
+        if (remotePublicationNode.isPresent() && joiningNode.isRemoteStatePublicationEnabled()) {
+            ensureRepositoryCompatibility(joiningNode, remotePublicationNode.get(), REMOTE_CLUSTER_PUBLICATION_REPO_NAME_ATTRIBUTES);
+        }
+    }
+
     /**
      * The method ensures homogeneity -
      * 1. The joining node has to be a remote store backed if it's joining a remote store backed cluster. Validates
@@ -567,16 +592,33 @@ public static void ensureNodeCommissioned(DiscoveryNode node, Metadata metadata)
      *       needs to be modified.
      */
     private static void ensureRemoteStoreNodesCompatibility(DiscoveryNode joiningNode, DiscoveryNodes currentNodes, Metadata metadata) {
+
         List<DiscoveryNode> existingNodes = new ArrayList<>(currentNodes.getNodes().values());
 
         assert existingNodes.isEmpty() == false;
 
         CompatibilityMode remoteStoreCompatibilityMode = REMOTE_STORE_COMPATIBILITY_MODE_SETTING.get(metadata.settings());
-        if (STRICT.equals(remoteStoreCompatibilityMode)) {
 
-            DiscoveryNode existingNode = existingNodes.get(0);
+        List<String> reposToSkip = new ArrayList<>(1);
+        Optional<DiscoveryNode> remoteRoutingTableNode = existingNodes.stream()
+            .filter(
+                node -> node.getAttributes().get(RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY) != null
+            )
+            .findFirst();
+        // If none of the existing nodes have routing table repo, then we skip this repo check if present in joining node.
+        // This ensures a new node with remote routing table repo is able to join the cluster.
+        if (remoteRoutingTableNode.isEmpty()) {
+            String joiningNodeRepoName = joiningNode.getAttributes()
+                .get(RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY);
+            if (joiningNodeRepoName != null) {
+                reposToSkip.add(joiningNodeRepoName);
+            }
+        }
+
+        if (STRICT.equals(remoteStoreCompatibilityMode)) {
+            DiscoveryNode existingNode = remoteRoutingTableNode.orElseGet(() -> existingNodes.get(0));
             if (joiningNode.isRemoteStoreNode()) {
-                ensureRemoteStoreNodesCompatibility(joiningNode, existingNode);
+                ensureRemoteStoreNodesCompatibility(joiningNode, existingNode, reposToSkip);
             } else {
                 if (existingNode.isRemoteStoreNode()) {
                     throw new IllegalStateException(
@@ -598,19 +640,25 @@ private static void ensureRemoteStoreNodesCompatibility(DiscoveryNode joiningNod
                     throw new IllegalStateException(reason);
                 }
                 if (joiningNode.isRemoteStoreNode()) {
-                    Optional<DiscoveryNode> remoteDN = existingNodes.stream().filter(DiscoveryNode::isRemoteStoreNode).findFirst();
-                    remoteDN.ifPresent(discoveryNode -> ensureRemoteStoreNodesCompatibility(joiningNode, discoveryNode));
+                    Optional<DiscoveryNode> remoteDN = remoteRoutingTableNode.isPresent()
+                        ? remoteRoutingTableNode
+                        : existingNodes.stream().filter(DiscoveryNode::isRemoteStoreNode).findFirst();
+                    remoteDN.ifPresent(discoveryNode -> ensureRemoteStoreNodesCompatibility(joiningNode, discoveryNode, reposToSkip));
                 }
             }
         }
     }
 
-    private static void ensureRemoteStoreNodesCompatibility(DiscoveryNode joiningNode, DiscoveryNode existingNode) {
+    private static void ensureRemoteStoreNodesCompatibility(
+        DiscoveryNode joiningNode,
+        DiscoveryNode existingNode,
+        List<String> reposToSkip
+    ) {
         if (joiningNode.isRemoteStoreNode()) {
             if (existingNode.isRemoteStoreNode()) {
                 RemoteStoreNodeAttribute joiningRemoteStoreNodeAttribute = new RemoteStoreNodeAttribute(joiningNode);
                 RemoteStoreNodeAttribute existingRemoteStoreNodeAttribute = new RemoteStoreNodeAttribute(existingNode);
-                if (existingRemoteStoreNodeAttribute.equals(joiningRemoteStoreNodeAttribute) == false) {
+                if (existingRemoteStoreNodeAttribute.equalsWithRepoSkip(joiningRemoteStoreNodeAttribute, reposToSkip) == false) {
                     throw new IllegalStateException(
                         "a remote store node ["
                             + joiningNode
@@ -626,6 +674,23 @@ private static void ensureRemoteStoreNodesCompatibility(DiscoveryNode joiningNod
         }
     }
 
+    private static void ensureRepositoryCompatibility(DiscoveryNode joiningNode, DiscoveryNode existingNode, List<String> reposToValidate) {
+
+        RemoteStoreNodeAttribute joiningRemoteStoreNodeAttribute = new RemoteStoreNodeAttribute(joiningNode);
+        RemoteStoreNodeAttribute existingRemoteStoreNodeAttribute = new RemoteStoreNodeAttribute(existingNode);
+
+        if (existingRemoteStoreNodeAttribute.equalsForRepositories(joiningRemoteStoreNodeAttribute, reposToValidate) == false) {
+            throw new IllegalStateException(
+                "a remote store node ["
+                    + joiningNode
+                    + "] is trying to join a remote store cluster with incompatible node attributes in "
+                    + "comparison with existing node ["
+                    + existingNode
+                    + "]"
+            );
+        }
+    }
+
     public static Collection<BiConsumer<DiscoveryNode, ClusterState>> addBuiltInJoinValidators(
         Collection<BiConsumer<DiscoveryNode, ClusterState>> onJoinValidators
     ) {
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
index 8d4373b865f62..4fd2c0eb13073 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/LeaderChecker.java
@@ -36,6 +36,7 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.OpenSearchException;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.Nullable;
@@ -119,17 +120,17 @@ public class LeaderChecker {
     private final TransportService transportService;
     private final Consumer<Exception> onLeaderFailure;
     private final NodeHealthService nodeHealthService;
-
     private AtomicReference<CheckScheduler> currentChecker = new AtomicReference<>();
-
     private volatile DiscoveryNodes discoveryNodes;
+    private final ClusterManagerMetrics clusterManagerMetrics;
 
     LeaderChecker(
         final Settings settings,
         final ClusterSettings clusterSettings,
         final TransportService transportService,
         final Consumer<Exception> onLeaderFailure,
-        NodeHealthService nodeHealthService
+        NodeHealthService nodeHealthService,
+        final ClusterManagerMetrics clusterManagerMetrics
     ) {
         this.settings = settings;
         leaderCheckInterval = LEADER_CHECK_INTERVAL_SETTING.get(settings);
@@ -138,6 +139,7 @@ public class LeaderChecker {
         this.transportService = transportService;
         this.onLeaderFailure = onLeaderFailure;
         this.nodeHealthService = nodeHealthService;
+        this.clusterManagerMetrics = clusterManagerMetrics;
         clusterSettings.addSettingsUpdateConsumer(LEADER_CHECK_TIMEOUT_SETTING, this::setLeaderCheckTimeout);
 
         transportService.registerRequestHandler(
@@ -293,7 +295,6 @@ public void handleResponse(Empty response) {
                             logger.debug("closed check scheduler received a response, doing nothing");
                             return;
                         }
-
                         failureCountSinceLastSuccess.set(0);
                         scheduleNextWakeUp(); // logs trace message indicating success
                     }
@@ -304,7 +305,6 @@ public void handleException(TransportException exp) {
                             logger.debug("closed check scheduler received a response, doing nothing");
                             return;
                         }
-
                         if (exp instanceof ConnectTransportException || exp.getCause() instanceof ConnectTransportException) {
                             logger.debug(new ParameterizedMessage("leader [{}] disconnected during check", leader), exp);
                             leaderFailed(new ConnectTransportException(leader, "disconnected during check", exp));
@@ -355,6 +355,7 @@ public String executor() {
 
         void leaderFailed(Exception e) {
             if (isClosed.compareAndSet(false, true)) {
+                clusterManagerMetrics.incrementCounter(clusterManagerMetrics.leaderCheckFailureCounter, 1.0);
                 transportService.getThreadPool().generic().execute(new Runnable() {
                     @Override
                     public void run() {
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/OpenSearchNodeCommand.java b/server/src/main/java/org/opensearch/cluster/coordination/OpenSearchNodeCommand.java
index 259d8961a3e78..896fe6fc8024b 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/OpenSearchNodeCommand.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/OpenSearchNodeCommand.java
@@ -47,6 +47,7 @@
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.metadata.ComponentTemplateMetadata;
 import org.opensearch.cluster.metadata.DataStreamMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.common.collect.Tuple;
@@ -94,9 +95,10 @@ public abstract class OpenSearchNodeCommand extends EnvironmentAwareCommand {
         public <T, C> T parseNamedObject(Class<T> categoryClass, String name, XContentParser parser, C context) throws IOException {
             // Currently, two unknown top-level objects are present
             if (Metadata.Custom.class.isAssignableFrom(categoryClass)) {
-                if (DataStreamMetadata.TYPE.equals(name)) {
+                if (DataStreamMetadata.TYPE.equals(name) || ComponentTemplateMetadata.TYPE.equals(name)) {
                     // DataStreamMetadata is used inside Metadata class for validation purposes and building the indicesLookup,
-                    // therefor even es node commands need to be able to parse it.
+                    // ComponentTemplateMetadata is used inside Metadata class for building the systemTemplatesLookup,
+                    // therefor even OpenSearch node commands need to be able to parse it.
                     return super.parseNamedObject(categoryClass, name, parser, context);
                     // TODO: Try to parse other named objects (e.g. stored scripts, ingest pipelines) that are part of core es as well?
                     // Note that supporting PersistentTasksCustomMetadata is trickier, because PersistentTaskParams is a named object too.
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PersistedStateStats.java b/server/src/main/java/org/opensearch/cluster/coordination/PersistedStateStats.java
index 0b7ed4fee5775..023c2db1a574a 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PersistedStateStats.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PersistedStateStats.java
@@ -117,6 +117,10 @@ protected void addToExtendedFields(String extendedField, AtomicLong extendedFiel
         this.extendedFields.put(extendedField, extendedFieldValue);
     }
 
+    public Map<String, AtomicLong> getExtendedFields() {
+        return extendedFields;
+    }
+
     public String getStatsName() {
         return statsName;
     }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
index 1fdaeead0d28d..ca36011b3a0e9 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/PublicationTransportHandler.java
@@ -40,6 +40,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.IncompatibleClusterStateVersionException;
+import org.opensearch.cluster.coordination.PersistedStateRegistry.PersistedStateType;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.core.action.ActionListener;
@@ -47,6 +48,9 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.transport.TransportResponse;
+import org.opensearch.gateway.GatewayMetaState.RemotePersistedState;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateService;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.transport.BytesTransportRequest;
 import org.opensearch.transport.TransportChannel;
@@ -58,6 +62,7 @@
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
@@ -74,6 +79,7 @@ public class PublicationTransportHandler {
     private static final Logger logger = LogManager.getLogger(PublicationTransportHandler.class);
 
     public static final String PUBLISH_STATE_ACTION_NAME = "internal:cluster/coordination/publish_state";
+    public static final String PUBLISH_REMOTE_STATE_ACTION_NAME = "internal:cluster/coordination/publish_remote_state";
     public static final String COMMIT_STATE_ACTION_NAME = "internal:cluster/coordination/commit_state";
 
     private final TransportService transportService;
@@ -92,21 +98,25 @@ public class PublicationTransportHandler {
     private final AtomicLong fullClusterStateReceivedCount = new AtomicLong();
     private final AtomicLong incompatibleClusterStateDiffReceivedCount = new AtomicLong();
     private final AtomicLong compatibleClusterStateDiffReceivedCount = new AtomicLong();
+    private final AtomicBoolean allNodesRemotePublicationEnabled = new AtomicBoolean();
     // -> no need to put a timeout on the options here, because we want the response to eventually be received
     // and not log an error if it arrives after the timeout
     private final TransportRequestOptions stateRequestOptions = TransportRequestOptions.builder()
         .withType(TransportRequestOptions.Type.STATE)
         .build();
+    private final RemoteClusterStateService remoteClusterStateService;
 
     public PublicationTransportHandler(
         TransportService transportService,
         NamedWriteableRegistry namedWriteableRegistry,
         Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest,
-        BiConsumer<ApplyCommitRequest, ActionListener<Void>> handleApplyCommit
+        BiConsumer<ApplyCommitRequest, ActionListener<Void>> handleApplyCommit,
+        RemoteClusterStateService remoteClusterStateService
     ) {
         this.transportService = transportService;
         this.namedWriteableRegistry = namedWriteableRegistry;
         this.handlePublishRequest = handlePublishRequest;
+        this.remoteClusterStateService = remoteClusterStateService;
 
         transportService.registerRequestHandler(
             PUBLISH_STATE_ACTION_NAME,
@@ -117,6 +127,15 @@ public PublicationTransportHandler(
             (request, channel, task) -> channel.sendResponse(handleIncomingPublishRequest(request))
         );
 
+        transportService.registerRequestHandler(
+            PUBLISH_REMOTE_STATE_ACTION_NAME,
+            ThreadPool.Names.GENERIC,
+            false,
+            false,
+            RemotePublishRequest::new,
+            (request, channel, task) -> channel.sendResponse(handleIncomingRemotePublishRequest(request))
+        );
+
         transportService.registerRequestHandler(
             COMMIT_STATE_ACTION_NAME,
             ThreadPool.Names.GENERIC,
@@ -159,6 +178,14 @@ public PublishClusterStateStats stats() {
         );
     }
 
+    public PersistedStateStats getFullDownloadStats() {
+        return remoteClusterStateService.getFullDownloadStats();
+    }
+
+    public PersistedStateStats getDiffDownloadStats() {
+        return remoteClusterStateService.getDiffDownloadStats();
+    }
+
     private PublishWithJoinResponse handleIncomingPublishRequest(BytesTransportRequest request) throws IOException {
         try (StreamInput in = CompressedStreamUtils.decompressBytes(request, namedWriteableRegistry)) {
             ClusterState incomingState;
@@ -211,6 +238,82 @@ private PublishWithJoinResponse handleIncomingPublishRequest(BytesTransportReque
         }
     }
 
+    // package private for testing
+    PublishWithJoinResponse handleIncomingRemotePublishRequest(RemotePublishRequest request) throws IOException, IllegalStateException {
+        boolean applyFullState = false;
+        try {
+            if (transportService.getLocalNode().equals(request.getSourceNode())) {
+                return acceptRemoteStateOnLocalNode(request);
+            }
+            // TODO Make cluster state download non-blocking: https://github.com/opensearch-project/OpenSearch/issues/14102
+            ClusterMetadataManifest manifest = remoteClusterStateService.getClusterMetadataManifestByFileName(
+                request.getClusterUUID(),
+                request.getManifestFile()
+            );
+            if (manifest == null) {
+                throw new IllegalStateException("Publication failed as manifest was not found for " + request);
+            }
+            final ClusterState lastSeen = lastSeenClusterState.get();
+            if (lastSeen == null) {
+                logger.debug(() -> "Diff cannot be applied as there is no last cluster state");
+                applyFullState = true;
+            } else if (manifest.getDiffManifest() == null) {
+                logger.debug(() -> "There is no diff in the manifest");
+                applyFullState = true;
+            } else if (manifest.getDiffManifest().getFromStateUUID().equals(lastSeen.stateUUID()) == false) {
+                logger.debug(() -> "Last cluster state not compatible with the diff");
+                applyFullState = true;
+            }
+
+            if (applyFullState == true) {
+                logger.debug(
+                    () -> new ParameterizedMessage(
+                        "Downloading full cluster state for term {}, version {}, stateUUID {}",
+                        manifest.getClusterTerm(),
+                        manifest.getStateVersion(),
+                        manifest.getStateUUID()
+                    )
+                );
+                ClusterState clusterState = remoteClusterStateService.getClusterStateForManifest(
+                    request.getClusterName(),
+                    manifest,
+                    transportService.getLocalNode().getId(),
+                    true
+                );
+                fullClusterStateReceivedCount.incrementAndGet();
+                final PublishWithJoinResponse response = acceptState(clusterState);
+                lastSeenClusterState.set(clusterState);
+                return response;
+            } else {
+                logger.debug(
+                    () -> new ParameterizedMessage(
+                        "Downloading diff cluster state for term {}, version {}, previousUUID {}, current UUID {}",
+                        manifest.getClusterTerm(),
+                        manifest.getStateVersion(),
+                        manifest.getDiffManifest().getFromStateUUID(),
+                        manifest.getStateUUID()
+                    )
+                );
+                ClusterState clusterState = remoteClusterStateService.getClusterStateUsingDiff(
+                    manifest,
+                    lastSeen,
+                    transportService.getLocalNode().getId()
+                );
+                compatibleClusterStateDiffReceivedCount.incrementAndGet();
+                final PublishWithJoinResponse response = acceptState(clusterState);
+                lastSeenClusterState.compareAndSet(lastSeen, clusterState);
+                return response;
+            }
+        } catch (Exception e) {
+            if (applyFullState) {
+                remoteClusterStateService.fullDownloadFailed();
+            } else {
+                remoteClusterStateService.diffDownloadFailed();
+            }
+            throw e;
+        }
+    }
+
     private PublishWithJoinResponse acceptState(ClusterState incomingState) {
         // if the state is coming from the current node, use original request instead (see currentPublishRequestToSelf for explanation)
         if (transportService.getLocalNode().equals(incomingState.nodes().getClusterManagerNode())) {
@@ -224,8 +327,42 @@ private PublishWithJoinResponse acceptState(ClusterState incomingState) {
         return handlePublishRequest.apply(new PublishRequest(incomingState));
     }
 
-    public PublicationContext newPublicationContext(ClusterChangedEvent clusterChangedEvent) {
-        final PublicationContext publicationContext = new PublicationContext(clusterChangedEvent);
+    private PublishWithJoinResponse acceptRemoteStateOnLocalNode(RemotePublishRequest remotePublishRequest) {
+        final PublishRequest publishRequest = currentPublishRequestToSelf.get();
+        if (publishRequest == null
+            || publishRequest.getAcceptedState().coordinationMetadata().term() != remotePublishRequest.term
+            || publishRequest.getAcceptedState().version() != remotePublishRequest.version) {
+            logger.debug(
+                () -> new ParameterizedMessage(
+                    "Publication failure for current publish request : {} and remote publish request: {}",
+                    publishRequest,
+                    remotePublishRequest
+                )
+            );
+            throw new IllegalStateException("publication to self failed for " + remotePublishRequest);
+        }
+        PublishWithJoinResponse publishWithJoinResponse = handlePublishRequest.apply(publishRequest);
+        lastSeenClusterState.set(publishRequest.getAcceptedState());
+        return publishWithJoinResponse;
+    }
+
+    public PublicationContext newPublicationContext(
+        ClusterChangedEvent clusterChangedEvent,
+        boolean isRemotePublicationEnabled,
+        PersistedStateRegistry persistedStateRegistry
+    ) {
+        if (isRemotePublicationEnabled == true) {
+            if (allNodesRemotePublicationEnabled.get() == false) {
+                if (validateRemotePublicationOnAllNodes(clusterChangedEvent.state().nodes()) == true) {
+                    allNodesRemotePublicationEnabled.set(true);
+                }
+            }
+            if (allNodesRemotePublicationEnabled.get() == true) {
+                // if all nodes are remote then create remote publication context
+                return new RemotePublicationContext(clusterChangedEvent, persistedStateRegistry);
+            }
+        }
+        final PublicationContext publicationContext = new PublicationContext(clusterChangedEvent, persistedStateRegistry);
 
         // Build the serializations we expect to need now, early in the process, so that an error during serialization fails the publication
         // straight away. This isn't watertight since we send diffs on a best-effort basis and may fall back to sending a full state (and
@@ -234,6 +371,27 @@ public PublicationContext newPublicationContext(ClusterChangedEvent clusterChang
         return publicationContext;
     }
 
+    private boolean validateRemotePublicationOnAllNodes(DiscoveryNodes discoveryNodes) {
+        assert ClusterMetadataManifest.getCodecForVersion(discoveryNodes.getMinNodeVersion()) >= ClusterMetadataManifest.CODEC_V0;
+        for (DiscoveryNode node : discoveryNodes.getNodes().values()) {
+            // if a node is non-remote then created local publication context
+            if (node.isRemoteStatePublicationEnabled() == false) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // package private for testing
+    void setCurrentPublishRequestToSelf(PublishRequest publishRequest) {
+        this.currentPublishRequestToSelf.set(publishRequest);
+    }
+
+    // package private for testing
+    void setLastSeenClusterState(ClusterState clusterState) {
+        this.lastSeenClusterState.set(clusterState);
+    }
+
     private static BytesReference serializeFullClusterState(ClusterState clusterState, Version nodeVersion) throws IOException {
         final BytesReference serializedState = CompressedStreamUtils.createCompressedStream(nodeVersion, stream -> {
             stream.writeBoolean(true);
@@ -264,18 +422,20 @@ private static BytesReference serializeDiffClusterState(Diff<ClusterState> diff,
      */
     public class PublicationContext {
 
-        private final DiscoveryNodes discoveryNodes;
-        private final ClusterState newState;
-        private final ClusterState previousState;
-        private final boolean sendFullVersion;
+        protected final DiscoveryNodes discoveryNodes;
+        protected final ClusterState newState;
+        protected final ClusterState previousState;
+        protected final boolean sendFullVersion;
         private final Map<Version, BytesReference> serializedStates = new HashMap<>();
         private final Map<Version, BytesReference> serializedDiffs = new HashMap<>();
+        protected final PersistedStateRegistry persistedStateRegistry;
 
-        PublicationContext(ClusterChangedEvent clusterChangedEvent) {
+        PublicationContext(ClusterChangedEvent clusterChangedEvent, PersistedStateRegistry persistedStateRegistry) {
             discoveryNodes = clusterChangedEvent.state().nodes();
             newState = clusterChangedEvent.state();
             previousState = clusterChangedEvent.previousState();
             sendFullVersion = previousState.getBlocks().disableStatePersistence();
+            this.persistedStateRegistry = persistedStateRegistry;
         }
 
         void buildDiffAndSerializeStates() {
@@ -339,13 +499,7 @@ public void onFailure(Exception e) {
             } else {
                 responseActionListener = listener;
             }
-            if (sendFullVersion || previousState.nodes().nodeExists(destination) == false) {
-                logger.trace("sending full cluster state version [{}] to [{}]", newState.version(), destination);
-                sendFullClusterState(destination, responseActionListener);
-            } else {
-                logger.trace("sending cluster state diff for version [{}] to [{}]", newState.version(), destination);
-                sendClusterStateDiff(destination, responseActionListener);
-            }
+            sendClusterState(destination, responseActionListener);
         }
 
         public void sendApplyCommit(
@@ -384,6 +538,17 @@ public String executor() {
             );
         }
 
+        public void sendClusterState(DiscoveryNode destination, ActionListener<PublishWithJoinResponse> listener) {
+            logger.info("sending cluster state over transport to node: {}", destination.getName());
+            if (sendFullVersion || previousState.nodes().nodeExists(destination) == false) {
+                logger.trace("sending full cluster state version [{}] to [{}]", newState.version(), destination);
+                sendFullClusterState(destination, listener);
+            } else {
+                logger.trace("sending cluster state diff for version [{}] to [{}]", newState.version(), destination);
+                sendClusterStateDiff(destination, listener);
+            }
+        }
+
         private void sendFullClusterState(DiscoveryNode destination, ActionListener<PublishWithJoinResponse> listener) {
             BytesReference bytes = serializedStates.get(destination.getVersion());
             if (bytes == null) {
@@ -460,4 +625,69 @@ public String executor() {
         }
     }
 
+    /**
+     * An extension of {@code PublicationContext} to support remote cluster state publication
+     *
+     * @opensearch.internal
+     */
+    public class RemotePublicationContext extends PublicationContext {
+
+        RemotePublicationContext(ClusterChangedEvent clusterChangedEvent, PersistedStateRegistry persistedStateRegistry) {
+            super(clusterChangedEvent, persistedStateRegistry);
+        }
+
+        @Override
+        public void sendClusterState(final DiscoveryNode destination, final ActionListener<PublishWithJoinResponse> listener) {
+            try {
+                logger.info("sending remote cluster state to node: {}", destination.getName());
+                final String manifestFileName = ((RemotePersistedState) persistedStateRegistry.getPersistedState(PersistedStateType.REMOTE))
+                    .getLastUploadedManifestFile();
+                final RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+                    discoveryNodes.getLocalNode(),
+                    newState.term(),
+                    newState.getVersion(),
+                    newState.getClusterName().value(),
+                    newState.metadata().clusterUUID(),
+                    manifestFileName
+                );
+                final Consumer<TransportException> transportExceptionHandler = exp -> {
+                    logger.debug(() -> new ParameterizedMessage("failed to send remote cluster state to {}", destination), exp);
+                    listener.onFailure(exp);
+                };
+                final TransportResponseHandler<PublishWithJoinResponse> responseHandler = new TransportResponseHandler<>() {
+
+                    @Override
+                    public PublishWithJoinResponse read(StreamInput in) throws IOException {
+                        return new PublishWithJoinResponse(in);
+                    }
+
+                    @Override
+                    public void handleResponse(PublishWithJoinResponse response) {
+                        listener.onResponse(response);
+                    }
+
+                    @Override
+                    public void handleException(TransportException exp) {
+                        transportExceptionHandler.accept(exp);
+                    }
+
+                    @Override
+                    public String executor() {
+                        return ThreadPool.Names.GENERIC;
+                    }
+                };
+                transportService.sendRequest(
+                    destination,
+                    PUBLISH_REMOTE_STATE_ACTION_NAME,
+                    remotePublishRequest,
+                    stateRequestOptions,
+                    responseHandler
+                );
+            } catch (Exception e) {
+                logger.warn(() -> new ParameterizedMessage("error sending remote cluster state to {}", destination), e);
+                listener.onFailure(e);
+            }
+        }
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/RemotePublishRequest.java b/server/src/main/java/org/opensearch/cluster/coordination/RemotePublishRequest.java
new file mode 100644
index 0000000000000..9461c5ee63627
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/coordination/RemotePublishRequest.java
@@ -0,0 +1,85 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.coordination;
+
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+
+import java.io.IOException;
+
+/**
+ * Send the publish request with the remote cluster state details
+ * @opensearch.internal
+ */
+public class RemotePublishRequest extends TermVersionRequest {
+
+    private final String clusterName;
+    private final String clusterUUID;
+    private final String manifestFile;
+
+    public RemotePublishRequest(
+        DiscoveryNode sourceNode,
+        long term,
+        long version,
+        String clusterName,
+        String clusterUUID,
+        String manifestFile
+    ) {
+        super(sourceNode, term, version);
+        this.clusterName = clusterName;
+        this.clusterUUID = clusterUUID;
+        this.manifestFile = manifestFile;
+    }
+
+    public RemotePublishRequest(StreamInput in) throws IOException {
+        super(in);
+        this.clusterName = in.readString();
+        this.clusterUUID = in.readString();
+        this.manifestFile = in.readString();
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        super.writeTo(out);
+        out.writeString(clusterName);
+        out.writeString(clusterUUID);
+        out.writeString(manifestFile);
+    }
+
+    @Override
+    public String toString() {
+        return "RemotePublishRequest{"
+            + "term="
+            + term
+            + ", version="
+            + version
+            + ", clusterName="
+            + clusterName
+            + ", clusterUUID="
+            + clusterUUID
+            + ", sourceNode="
+            + sourceNode
+            + ", manifestFile="
+            + manifestFile
+            + '}';
+    }
+
+    public String getClusterName() {
+        return clusterName;
+    }
+
+    public String getClusterUUID() {
+        return clusterUUID;
+    }
+
+    public String getManifestFile() {
+        return manifestFile;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/coordination/StartJoinRequest.java b/server/src/main/java/org/opensearch/cluster/coordination/StartJoinRequest.java
index de58eb721b28f..287418aaf378e 100644
--- a/server/src/main/java/org/opensearch/cluster/coordination/StartJoinRequest.java
+++ b/server/src/main/java/org/opensearch/cluster/coordination/StartJoinRequest.java
@@ -64,7 +64,7 @@ public StartJoinRequest(StreamInput input) throws IOException {
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         super.writeTo(out);
-        sourceNode.writeTo(out);
+        sourceNode.writeToWithAttribute(out);
         out.writeLong(term);
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
index f16568aa4b53c..538a24a6b7871 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/ComposableIndexTemplate.java
@@ -77,6 +77,7 @@ public class ComposableIndexTemplate extends AbstractDiffable<ComposableIndexTem
     private static final ParseField VERSION = new ParseField("version");
     private static final ParseField METADATA = new ParseField("_meta");
     private static final ParseField DATA_STREAM = new ParseField("data_stream");
+    private static final ParseField CONTEXT = new ParseField("context");
 
     @SuppressWarnings("unchecked")
     public static final ConstructingObjectParser<ComposableIndexTemplate, Void> PARSER = new ConstructingObjectParser<>(
@@ -89,7 +90,8 @@ public class ComposableIndexTemplate extends AbstractDiffable<ComposableIndexTem
             (Long) a[3],
             (Long) a[4],
             (Map<String, Object>) a[5],
-            (DataStreamTemplate) a[6]
+            (DataStreamTemplate) a[6],
+            (Context) a[7]
         )
     );
 
@@ -101,6 +103,7 @@ public class ComposableIndexTemplate extends AbstractDiffable<ComposableIndexTem
         PARSER.declareLong(ConstructingObjectParser.optionalConstructorArg(), VERSION);
         PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> p.map(), METADATA);
         PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), DataStreamTemplate.PARSER, DATA_STREAM);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), Context.PARSER, CONTEXT);
     }
 
     private final List<String> indexPatterns;
@@ -116,6 +119,8 @@ public class ComposableIndexTemplate extends AbstractDiffable<ComposableIndexTem
     private final Map<String, Object> metadata;
     @Nullable
     private final DataStreamTemplate dataStreamTemplate;
+    @Nullable
+    private final Context context;
 
     static Diff<ComposableIndexTemplate> readITV2DiffFrom(StreamInput in) throws IOException {
         return AbstractDiffable.readDiffFrom(ComposableIndexTemplate::new, in);
@@ -133,7 +138,7 @@ public ComposableIndexTemplate(
         @Nullable Long version,
         @Nullable Map<String, Object> metadata
     ) {
-        this(indexPatterns, template, componentTemplates, priority, version, metadata, null);
+        this(indexPatterns, template, componentTemplates, priority, version, metadata, null, null);
     }
 
     public ComposableIndexTemplate(
@@ -144,6 +149,19 @@ public ComposableIndexTemplate(
         @Nullable Long version,
         @Nullable Map<String, Object> metadata,
         @Nullable DataStreamTemplate dataStreamTemplate
+    ) {
+        this(indexPatterns, template, componentTemplates, priority, version, metadata, dataStreamTemplate, null);
+    }
+
+    public ComposableIndexTemplate(
+        List<String> indexPatterns,
+        @Nullable Template template,
+        @Nullable List<String> componentTemplates,
+        @Nullable Long priority,
+        @Nullable Long version,
+        @Nullable Map<String, Object> metadata,
+        @Nullable DataStreamTemplate dataStreamTemplate,
+        @Nullable Context context
     ) {
         this.indexPatterns = indexPatterns;
         this.template = template;
@@ -152,6 +170,7 @@ public ComposableIndexTemplate(
         this.version = version;
         this.metadata = metadata;
         this.dataStreamTemplate = dataStreamTemplate;
+        this.context = context;
     }
 
     public ComposableIndexTemplate(StreamInput in) throws IOException {
@@ -170,6 +189,11 @@ public ComposableIndexTemplate(StreamInput in) throws IOException {
         } else {
             this.dataStreamTemplate = null;
         }
+        if (in.getVersion().onOrAfter(Version.V_2_16_0)) {
+            this.context = in.readOptionalWriteable(Context::new);
+        } else {
+            this.context = null;
+        }
     }
 
     public List<String> indexPatterns() {
@@ -211,6 +235,10 @@ public DataStreamTemplate getDataStreamTemplate() {
         return dataStreamTemplate;
     }
 
+    public Context context() {
+        return context;
+    }
+
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         out.writeStringCollection(this.indexPatterns);
@@ -227,6 +255,9 @@ public void writeTo(StreamOutput out) throws IOException {
         if (out.getVersion().onOrAfter(LegacyESVersion.V_7_9_0)) {
             out.writeOptionalWriteable(dataStreamTemplate);
         }
+        if (out.getVersion().onOrAfter(Version.V_2_16_0)) {
+            out.writeOptionalWriteable(context);
+        }
     }
 
     @Override
@@ -251,6 +282,9 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         if (this.dataStreamTemplate != null) {
             builder.field(DATA_STREAM.getPreferredName(), dataStreamTemplate);
         }
+        if (this.context != null) {
+            builder.field(CONTEXT.getPreferredName(), context);
+        }
         builder.endObject();
         return builder;
     }
@@ -264,7 +298,8 @@ public int hashCode() {
             this.priority,
             this.version,
             this.metadata,
-            this.dataStreamTemplate
+            this.dataStreamTemplate,
+            this.context
         );
     }
 
@@ -283,7 +318,8 @@ public boolean equals(Object obj) {
             && Objects.equals(this.priority, other.priority)
             && Objects.equals(this.version, other.version)
             && Objects.equals(this.metadata, other.metadata)
-            && Objects.equals(this.dataStreamTemplate, other.dataStreamTemplate);
+            && Objects.equals(this.dataStreamTemplate, other.dataStreamTemplate)
+            && Objects.equals(this.context, other.context);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Context.java b/server/src/main/java/org/opensearch/cluster/metadata/Context.java
new file mode 100644
index 0000000000000..ceaef4dbc8d14
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Context.java
@@ -0,0 +1,135 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.cluster.AbstractDiffable;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.ParseField;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.ConstructingObjectParser;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Class encapsulating the context metadata associated with an index template/index.
+ */
+@ExperimentalApi
+public class Context extends AbstractDiffable<Context> implements ToXContentObject {
+
+    private static final ParseField NAME = new ParseField("name");
+    private static final ParseField VERSION = new ParseField("version");
+    private static final ParseField PARAMS = new ParseField("params");
+
+    public static final String LATEST_VERSION = "_latest";
+
+    private String name;
+    private String version = LATEST_VERSION;
+    private Map<String, Object> params;
+
+    public static final ConstructingObjectParser<Context, Void> PARSER = new ConstructingObjectParser<>(
+        "index_template",
+        false,
+        a -> new Context((String) a[0], (String) a[1], (Map<String, Object>) a[2])
+    );
+
+    static {
+        PARSER.declareString(ConstructingObjectParser.constructorArg(), NAME);
+        PARSER.declareString(ConstructingObjectParser.optionalConstructorArg(), VERSION);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), (p, c) -> p.map(), PARAMS);
+    }
+
+    public Context(String name) {
+        this(name, LATEST_VERSION, Map.of());
+    }
+
+    public Context(String name, String version, Map<String, Object> params) {
+        this.name = name;
+        if (version != null) {
+            this.version = version;
+        }
+        this.params = params;
+    }
+
+    public Context(StreamInput in) throws IOException {
+        this.name = in.readString();
+        this.version = in.readOptionalString();
+        this.params = in.readMap();
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public void name(String name) {
+        this.name = name;
+    }
+
+    public String version() {
+        return version;
+    }
+
+    public void version(String version) {
+        this.version = version;
+    }
+
+    public Map<String, Object> params() {
+        return params;
+    }
+
+    public void params(Map<String, Object> params) {
+        this.params = params;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(name);
+        out.writeOptionalString(version);
+        out.writeMap(params);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(NAME.getPreferredName(), this.name);
+        builder.field(VERSION.getPreferredName(), this.version);
+        if (this.params != null) {
+            builder.field(PARAMS.getPreferredName(), this.params);
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    public static Context fromXContent(XContentParser parser) {
+        return PARSER.apply(parser, null);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Context context = (Context) o;
+        return Objects.equals(name, context.name) && Objects.equals(version, context.version) && Objects.equals(params, context.params);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, version, params);
+    }
+
+    @Override
+    public String toString() {
+        return "Context{" + "name='" + name + '\'' + ", version='" + version + '\'' + ", params=" + params + '}';
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/DiffableStringMap.java b/server/src/main/java/org/opensearch/cluster/metadata/DiffableStringMap.java
index a8102182576ff..5865891c8a7f9 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/DiffableStringMap.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/DiffableStringMap.java
@@ -66,7 +66,7 @@ public static DiffableStringMap readFrom(StreamInput in) throws IOException {
         return map.isEmpty() ? EMPTY : new DiffableStringMap(map);
     }
 
-    DiffableStringMap(final Map<String, String> map) {
+    public DiffableStringMap(final Map<String, String> map) {
         this.innerMap = Collections.unmodifiableMap(map);
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexMetadata.java
index fdf8c7a74df68..e0444ee670011 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/IndexMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexMetadata.java
@@ -43,6 +43,7 @@
 import org.opensearch.cluster.block.ClusterBlockLevel;
 import org.opensearch.cluster.node.DiscoveryNodeFilters;
 import org.opensearch.cluster.routing.allocation.IndexMetadataUpdater;
+import org.opensearch.cluster.routing.allocation.decider.ShardsLimitAllocationDecider;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.collect.MapBuilder;
@@ -65,8 +66,11 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.gateway.MetadataStateFormat;
+import org.opensearch.index.IndexModule;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.seqno.SequenceNumbers;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
+import org.opensearch.indices.replication.SegmentReplicationSource;
 import org.opensearch.indices.replication.common.ReplicationType;
 
 import java.io.IOException;
@@ -85,6 +89,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.function.Function;
 
 import static org.opensearch.cluster.metadata.Metadata.CONTEXT_MODE_PARAM;
@@ -241,6 +246,22 @@ static Setting<Integer> buildNumberOfShardsSetting() {
         Property.IndexScope
     );
 
+    /**
+     * Setting to control the number of search only replicas for an index.
+     * A search only replica exists solely to perform read operations for a shard and are designed to achieve
+     * isolation from writers (primary shards).  This means they are not primary eligible and do not have any direct communication
+     * with their primary.  Search replicas require the use of Segment Replication on the index and poll their {@link SegmentReplicationSource} for
+     * updates.  //TODO: Once physical isolation is introduced, reference the setting here.
+     */
+    public static final String SETTING_NUMBER_OF_SEARCH_REPLICAS = "index.number_of_search_only_replicas";
+    public static final Setting<Integer> INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING = Setting.intSetting(
+        SETTING_NUMBER_OF_SEARCH_REPLICAS,
+        0,
+        0,
+        Property.Dynamic,
+        Property.IndexScope
+    );
+
     public static final String SETTING_ROUTING_PARTITION_SIZE = "index.routing_partition_size";
     public static final Setting<Integer> INDEX_ROUTING_PARTITION_SIZE_SETTING = Setting.intSetting(
         SETTING_ROUTING_PARTITION_SIZE,
@@ -637,6 +658,7 @@ public static APIBlock readFrom(StreamInput input) throws IOException {
     public static final String KEY_PRIMARY_TERMS = "primary_terms";
     public static final String REMOTE_STORE_CUSTOM_KEY = "remote_store";
     public static final String TRANSLOG_METADATA_KEY = "translog_metadata";
+    public static final String CONTEXT_KEY = "context";
 
     public static final String INDEX_STATE_FILE_PREFIX = "state-";
 
@@ -648,6 +670,7 @@ public static APIBlock readFrom(StreamInput input) throws IOException {
 
     private final int numberOfShards;
     private final int numberOfReplicas;
+    private final int numberOfSearchOnlyReplicas;
 
     private final Index index;
     private final long version;
@@ -685,6 +708,11 @@ public static APIBlock readFrom(StreamInput input) throws IOException {
     private final ActiveShardCount waitForActiveShards;
     private final Map<String, RolloverInfo> rolloverInfos;
     private final boolean isSystem;
+    private final boolean isRemoteSnapshot;
+
+    private final int indexTotalShardsPerNodeLimit;
+
+    private final Context context;
 
     private IndexMetadata(
         final Index index,
@@ -696,6 +724,7 @@ private IndexMetadata(
         final State state,
         final int numberOfShards,
         final int numberOfReplicas,
+        final int numberOfSearchOnlyReplicas,
         final Settings settings,
         final Map<String, MappingMetadata> mappings,
         final Map<String, AliasMetadata> aliases,
@@ -711,7 +740,9 @@ private IndexMetadata(
         final int routingPartitionSize,
         final ActiveShardCount waitForActiveShards,
         final Map<String, RolloverInfo> rolloverInfos,
-        final boolean isSystem
+        final boolean isSystem,
+        final int indexTotalShardsPerNodeLimit,
+        final Context context
     ) {
 
         this.index = index;
@@ -727,7 +758,8 @@ private IndexMetadata(
         this.state = state;
         this.numberOfShards = numberOfShards;
         this.numberOfReplicas = numberOfReplicas;
-        this.totalNumberOfShards = numberOfShards * (numberOfReplicas + 1);
+        this.numberOfSearchOnlyReplicas = numberOfSearchOnlyReplicas;
+        this.totalNumberOfShards = numberOfShards * (numberOfReplicas + numberOfSearchOnlyReplicas + 1);
         this.settings = settings;
         this.mappings = Collections.unmodifiableMap(mappings);
         this.customData = Collections.unmodifiableMap(customData);
@@ -745,6 +777,9 @@ private IndexMetadata(
         this.waitForActiveShards = waitForActiveShards;
         this.rolloverInfos = Collections.unmodifiableMap(rolloverInfos);
         this.isSystem = isSystem;
+        this.isRemoteSnapshot = IndexModule.Type.REMOTE_SNAPSHOT.match(this.settings);
+        this.indexTotalShardsPerNodeLimit = indexTotalShardsPerNodeLimit;
+        this.context = context;
         assert numberOfShards * routingFactor == routingNumShards : routingNumShards + " must be a multiple of " + numberOfShards;
     }
 
@@ -827,6 +862,10 @@ public int getNumberOfReplicas() {
         return numberOfReplicas;
     }
 
+    public int getNumberOfSearchOnlyReplicas() {
+        return numberOfSearchOnlyReplicas;
+    }
+
     public int getRoutingPartitionSize() {
         return routingPartitionSize;
     }
@@ -898,6 +937,10 @@ public Set<String> inSyncAllocationIds(int shardId) {
         return inSyncAllocationIds.get(shardId);
     }
 
+    public int getIndexTotalShardsPerNodeLimit() {
+        return this.indexTotalShardsPerNodeLimit;
+    }
+
     @Nullable
     public DiscoveryNodeFilters requireFilters() {
         return requireFilters;
@@ -969,6 +1012,9 @@ public boolean equals(Object o) {
         if (isSystem != that.isSystem) {
             return false;
         }
+        if (!Objects.equals(context, that.context)) {
+            return false;
+        }
         return true;
     }
 
@@ -987,6 +1033,7 @@ public int hashCode() {
         result = 31 * result + inSyncAllocationIds.hashCode();
         result = 31 * result + rolloverInfos.hashCode();
         result = 31 * result + Boolean.hashCode(isSystem);
+        result = 31 * result + Objects.hashCode(context);
         return result;
     }
 
@@ -1031,6 +1078,7 @@ private static class IndexMetadataDiff implements Diff<IndexMetadata> {
         private final Diff<Map<Integer, Set<String>>> inSyncAllocationIds;
         private final Diff<Map<String, RolloverInfo>> rolloverInfos;
         private final boolean isSystem;
+        private final Context context;
 
         IndexMetadataDiff(IndexMetadata before, IndexMetadata after) {
             index = after.index.getName();
@@ -1053,6 +1101,7 @@ private static class IndexMetadataDiff implements Diff<IndexMetadata> {
             );
             rolloverInfos = DiffableUtils.diff(before.rolloverInfos, after.rolloverInfos, DiffableUtils.getStringKeySerializer());
             isSystem = after.isSystem;
+            context = after.context;
         }
 
         private static final DiffableUtils.DiffableValueReader<String, AliasMetadata> ALIAS_METADATA_DIFF_VALUE_READER =
@@ -1092,6 +1141,11 @@ private static class IndexMetadataDiff implements Diff<IndexMetadata> {
             } else {
                 isSystem = false;
             }
+            if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+                context = in.readOptionalWriteable(Context::new);
+            } else {
+                context = null;
+            }
         }
 
         @Override
@@ -1112,9 +1166,13 @@ public void writeTo(StreamOutput out) throws IOException {
             customData.writeTo(out);
             inSyncAllocationIds.writeTo(out);
             rolloverInfos.writeTo(out);
+
             if (out.getVersion().onOrAfter(SYSTEM_INDEX_FLAG_ADDED)) {
                 out.writeBoolean(isSystem);
             }
+            if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+                out.writeOptionalWriteable(context);
+            }
         }
 
         @Override
@@ -1134,6 +1192,7 @@ public IndexMetadata apply(IndexMetadata part) {
             builder.inSyncAllocationIds.putAll(inSyncAllocationIds.apply(part.inSyncAllocationIds));
             builder.rolloverInfos.putAll(rolloverInfos.apply(part.rolloverInfos));
             builder.system(part.isSystem);
+            builder.context(context);
             return builder.build();
         }
     }
@@ -1181,6 +1240,9 @@ public static IndexMetadata readFrom(StreamInput in) throws IOException {
         if (in.getVersion().onOrAfter(SYSTEM_INDEX_FLAG_ADDED)) {
             builder.system(in.readBoolean());
         }
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            builder.context(in.readOptionalWriteable(Context::new));
+        }
         return builder.build();
     }
 
@@ -1222,12 +1284,48 @@ public void writeTo(StreamOutput out) throws IOException {
         if (out.getVersion().onOrAfter(SYSTEM_INDEX_FLAG_ADDED)) {
             out.writeBoolean(isSystem);
         }
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeOptionalWriteable(context);
+        }
+    }
+
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        out.writeString(index.getName()); // uuid will come as part of settings
+        out.writeLong(version);
+        out.writeVLong(mappingVersion);
+        out.writeVLong(settingsVersion);
+        out.writeVLong(aliasesVersion);
+        out.writeInt(routingNumShards);
+        out.writeByte(state.id());
+        writeSettingsToStream(settings, out);
+        out.writeVLongArray(primaryTerms);
+        out.writeMapValues(mappings, (stream, val) -> val.writeTo(stream));
+        out.writeMapValues(aliases, (stream, val) -> val.writeTo(stream));
+        out.writeMap(customData, StreamOutput::writeString, (stream, val) -> val.writeTo(stream));
+        out.writeMap(
+            inSyncAllocationIds,
+            StreamOutput::writeVInt,
+            (stream, val) -> DiffableUtils.StringSetValueSerializer.getInstance().write(new TreeSet<>(val), stream)
+        );
+        out.writeMapValues(rolloverInfos, (stream, val) -> val.writeTo(stream));
+        out.writeBoolean(isSystem);
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeOptionalWriteable(context);
+        }
     }
 
     public boolean isSystem() {
         return isSystem;
     }
 
+    public Context context() {
+        return context;
+    }
+
+    public boolean isRemoteSnapshot() {
+        return isRemoteSnapshot;
+    }
+
     public static Builder builder(String index) {
         return new Builder(index);
     }
@@ -1259,6 +1357,7 @@ public static class Builder {
         private final Map<String, RolloverInfo> rolloverInfos;
         private Integer routingNumShards;
         private boolean isSystem;
+        private Context context;
 
         public Builder(String index) {
             this.index = index;
@@ -1286,6 +1385,7 @@ public Builder(IndexMetadata indexMetadata) {
             this.inSyncAllocationIds = new HashMap<>(indexMetadata.inSyncAllocationIds);
             this.rolloverInfos = new HashMap<>(indexMetadata.rolloverInfos);
             this.isSystem = indexMetadata.isSystem;
+            this.context = indexMetadata.context;
         }
 
         public Builder index(String index) {
@@ -1332,6 +1432,11 @@ public Builder numberOfReplicas(int numberOfReplicas) {
             return this;
         }
 
+        public Builder numberOfSearchReplicas(int numberOfSearchReplicas) {
+            settings = Settings.builder().put(settings).put(SETTING_NUMBER_OF_SEARCH_REPLICAS, numberOfSearchReplicas).build();
+            return this;
+        }
+
         public Builder routingPartitionSize(int routingPartitionSize) {
             settings = Settings.builder().put(settings).put(SETTING_ROUTING_PARTITION_SIZE, routingPartitionSize).build();
             return this;
@@ -1502,6 +1607,15 @@ public boolean isSystem() {
             return isSystem;
         }
 
+        public Builder context(Context context) {
+            this.context = context;
+            return this;
+        }
+
+        public Context context() {
+            return context;
+        }
+
         public IndexMetadata build() {
             final Map<String, AliasMetadata> tmpAliases = aliases;
             Settings tmpSettings = settings;
@@ -1519,6 +1633,7 @@ public IndexMetadata build() {
                 throw new IllegalArgumentException("must specify number of replicas for index [" + index + "]");
             }
             final int numberOfReplicas = INDEX_NUMBER_OF_REPLICAS_SETTING.get(settings);
+            final int numberOfSearchReplicas = INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING.get(settings);
 
             int routingPartitionSize = INDEX_ROUTING_PARTITION_SIZE_SETTING.get(settings);
             if (routingPartitionSize != 1 && routingPartitionSize >= getRoutingNumShards()) {
@@ -1600,6 +1715,8 @@ public IndexMetadata build() {
                 );
             }
 
+            final int indexTotalShardsPerNodeLimit = ShardsLimitAllocationDecider.INDEX_TOTAL_SHARDS_PER_NODE_SETTING.get(settings);
+
             final String uuid = settings.get(SETTING_INDEX_UUID, INDEX_UUID_NA_VALUE);
 
             return new IndexMetadata(
@@ -1612,6 +1729,7 @@ public IndexMetadata build() {
                 state,
                 numberOfShards,
                 numberOfReplicas,
+                numberOfSearchReplicas,
                 tmpSettings,
                 mappings,
                 tmpAliases,
@@ -1627,7 +1745,9 @@ public IndexMetadata build() {
                 routingPartitionSize,
                 waitForActiveShards,
                 rolloverInfos,
-                isSystem
+                isSystem,
+                indexTotalShardsPerNodeLimit,
+                context
             );
         }
 
@@ -1730,6 +1850,11 @@ public static void toXContent(IndexMetadata indexMetadata, XContentBuilder build
             builder.endObject();
             builder.field(KEY_SYSTEM, indexMetadata.isSystem);
 
+            if (indexMetadata.context != null) {
+                builder.field(CONTEXT_KEY);
+                indexMetadata.context.toXContent(builder, params);
+            }
+
             builder.endObject();
         }
 
@@ -1811,6 +1936,8 @@ public static IndexMetadata fromXContent(XContentParser parser) throws IOExcepti
                         // simply ignored when upgrading from 2.x
                         assert Version.CURRENT.major <= 5;
                         parser.skipChildren();
+                    } else if (CONTEXT_KEY.equals(currentFieldName)) {
+                        builder.context(Context.fromXContent(parser));
                     } else {
                         // assume it's custom index metadata
                         builder.putCustom(currentFieldName, parser.mapStrings());
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
index 3d532208bcfe2..1539abcfb2e8a 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/IndexTemplateMetadata.java
@@ -50,6 +50,7 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
@@ -257,6 +258,16 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeOptionalVInt(version);
     }
 
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        out.writeString(name);
+        out.writeInt(order);
+        out.writeStringCollection(patterns);
+        Settings.writeSettingsToStream(settings, out);
+        out.writeMap(mappings, StreamOutput::writeString, (stream, val) -> val.writeTo(stream));
+        out.writeMapValues(aliases, (stream, val) -> val.writeTo(stream));
+        out.writeOptionalVInt(version);
+    }
+
     @Override
     public String toString() {
         try {
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
index e38043c11e977..0f6165e18f678 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/Metadata.java
@@ -44,6 +44,7 @@
 import org.opensearch.cluster.DiffableUtils;
 import org.opensearch.cluster.NamedDiffable;
 import org.opensearch.cluster.NamedDiffableValueSerializer;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateMetadata;
 import org.opensearch.cluster.block.ClusterBlock;
 import org.opensearch.cluster.block.ClusterBlockLevel;
 import org.opensearch.cluster.coordination.CoordinationMetadata;
@@ -176,6 +177,11 @@ public enum XContentContext {
     public interface Custom extends NamedDiffable<Custom>, ToXContentFragment, ClusterState.FeatureAware {
 
         EnumSet<XContentContext> context();
+
+        static Custom fromXContent(XContentParser parser, String name) throws IOException {
+            // handling any Exception is caller's responsibility
+            return parser.namedObject(Custom.class, name, null);
+        }
     }
 
     public static final Setting<Integer> DEFAULT_REPLICA_COUNT_SETTING = Setting.intSetting(
@@ -248,7 +254,7 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment, Clust
 
     public static final String GLOBAL_STATE_FILE_PREFIX = "global-";
 
-    private static final NamedDiffableValueSerializer<Custom> CUSTOM_VALUE_SERIALIZER = new NamedDiffableValueSerializer<>(Custom.class);
+    public static final NamedDiffableValueSerializer<Custom> CUSTOM_VALUE_SERIALIZER = new NamedDiffableValueSerializer<>(Custom.class);
 
     private final String clusterUUID;
     private final boolean clusterUUIDCommitted;
@@ -261,7 +267,7 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment, Clust
     private final Settings settings;
     private final DiffableStringMap hashesOfConsistentSettings;
     private final Map<String, IndexMetadata> indices;
-    private final Map<String, IndexTemplateMetadata> templates;
+    private final TemplatesMetadata templates;
     private final Map<String, Custom> customs;
 
     private final transient int totalNumberOfShards; // Transient ? not serializable anyway?
@@ -276,6 +282,8 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment, Clust
 
     private final SortedMap<String, IndexAbstraction> indicesLookup;
 
+    private final Map<String, SortedMap<Long, String>> systemTemplatesLookup;
+
     Metadata(
         String clusterUUID,
         boolean clusterUUIDCommitted,
@@ -293,7 +301,8 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment, Clust
         String[] visibleOpenIndices,
         String[] allClosedIndices,
         String[] visibleClosedIndices,
-        SortedMap<String, IndexAbstraction> indicesLookup
+        SortedMap<String, IndexAbstraction> indicesLookup,
+        Map<String, SortedMap<Long, String>> systemTemplatesLookup
     ) {
         this.clusterUUID = clusterUUID;
         this.clusterUUIDCommitted = clusterUUIDCommitted;
@@ -305,7 +314,7 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment, Clust
         this.hashesOfConsistentSettings = hashesOfConsistentSettings;
         this.indices = Collections.unmodifiableMap(indices);
         this.customs = Collections.unmodifiableMap(customs);
-        this.templates = Collections.unmodifiableMap(templates);
+        this.templates = new TemplatesMetadata(templates);
         int totalNumberOfShards = 0;
         int totalOpenIndexShards = 0;
         for (IndexMetadata cursor : indices.values()) {
@@ -324,6 +333,7 @@ public interface Custom extends NamedDiffable<Custom>, ToXContentFragment, Clust
         this.allClosedIndices = allClosedIndices;
         this.visibleClosedIndices = visibleClosedIndices;
         this.indicesLookup = indicesLookup;
+        this.systemTemplatesLookup = systemTemplatesLookup;
     }
 
     public long version() {
@@ -807,19 +817,27 @@ public Map<String, IndexMetadata> getIndices() {
     }
 
     public Map<String, IndexTemplateMetadata> templates() {
-        return this.templates;
+        return this.templates.getTemplates();
     }
 
     public Map<String, IndexTemplateMetadata> getTemplates() {
         return templates();
     }
 
+    public TemplatesMetadata templatesMetadata() {
+        return this.templates;
+    }
+
     public Map<String, ComponentTemplate> componentTemplates() {
         return Optional.ofNullable((ComponentTemplateMetadata) this.custom(ComponentTemplateMetadata.TYPE))
             .map(ComponentTemplateMetadata::componentTemplates)
             .orElse(Collections.emptyMap());
     }
 
+    public Map<String, SortedMap<Long, String>> systemTemplatesLookup() {
+        return systemTemplatesLookup;
+    }
+
     public Map<String, ComposableIndexTemplate> templatesV2() {
         return Optional.ofNullable((ComposableIndexTemplateMetadata) this.custom(ComposableIndexTemplateMetadata.TYPE))
             .map(ComposableIndexTemplateMetadata::indexTemplates)
@@ -832,6 +850,12 @@ public Map<String, DataStream> dataStreams() {
             .orElse(Collections.emptyMap());
     }
 
+    public Map<String, QueryGroup> queryGroups() {
+        return Optional.ofNullable((QueryGroupMetadata) this.custom(QueryGroupMetadata.TYPE))
+            .map(QueryGroupMetadata::queryGroups)
+            .orElse(Collections.emptyMap());
+    }
+
     public DecommissionAttributeMetadata decommissionAttributeMetadata() {
         return custom(DecommissionAttributeMetadata.TYPE);
     }
@@ -924,7 +948,7 @@ public Iterator<IndexMetadata> iterator() {
     }
 
     public static boolean isGlobalStateEquals(Metadata metadata1, Metadata metadata2) {
-        if (!metadata1.coordinationMetadata.equals(metadata2.coordinationMetadata)) {
+        if (!isCoordinationMetadataEqual(metadata1, metadata2)) {
             return false;
         }
         if (!metadata1.hashesOfConsistentSettings.equals(metadata2.hashesOfConsistentSettings)) {
@@ -943,13 +967,37 @@ public static boolean isGlobalStateEquals(Metadata metadata1, Metadata metadata2
      * Compares Metadata entities persisted in Remote Store.
      */
     public static boolean isGlobalResourcesMetadataEquals(Metadata metadata1, Metadata metadata2) {
-        if (!metadata1.persistentSettings.equals(metadata2.persistentSettings)) {
+        if (!isSettingsMetadataEqual(metadata1, metadata2)) {
             return false;
         }
-        if (!metadata1.templates.equals(metadata2.templates())) {
+        if (!isTemplatesMetadataEqual(metadata1, metadata2)) {
             return false;
         }
         // Check if any persistent metadata needs to be saved
+        return isCustomMetadataEqual(metadata1, metadata2);
+    }
+
+    public static boolean isCoordinationMetadataEqual(Metadata metadata1, Metadata metadata2) {
+        return metadata1.coordinationMetadata.equals(metadata2.coordinationMetadata);
+    }
+
+    public static boolean isSettingsMetadataEqual(Metadata metadata1, Metadata metadata2) {
+        return metadata1.persistentSettings.equals(metadata2.persistentSettings);
+    }
+
+    public static boolean isTransientSettingsMetadataEqual(Metadata metadata1, Metadata metadata2) {
+        return metadata1.transientSettings.equals(metadata2.transientSettings);
+    }
+
+    public static boolean isTemplatesMetadataEqual(Metadata metadata1, Metadata metadata2) {
+        return metadata1.templates.equals(metadata2.templates);
+    }
+
+    public static boolean isHashesOfConsistentSettingsEqual(Metadata metadata1, Metadata metadata2) {
+        return metadata1.hashesOfConsistentSettings.equals(metadata2.hashesOfConsistentSettings);
+    }
+
+    public static boolean isCustomMetadataEqual(Metadata metadata1, Metadata metadata2) {
         int customCount1 = 0;
         for (Map.Entry<String, Custom> cursor : metadata1.customs.entrySet()) {
             if (cursor.getValue().context().contains(XContentContext.GATEWAY)) {
@@ -963,8 +1011,7 @@ public static boolean isGlobalResourcesMetadataEquals(Metadata metadata1, Metada
                 customCount2++;
             }
         }
-        if (customCount1 != customCount2) return false;
-        return true;
+        return customCount1 == customCount2;
     }
 
     @Override
@@ -1013,7 +1060,11 @@ private static class MetadataDiff implements Diff<Metadata> {
             persistentSettings = after.persistentSettings;
             hashesOfConsistentSettings = after.hashesOfConsistentSettings.diff(before.hashesOfConsistentSettings);
             indices = DiffableUtils.diff(before.indices, after.indices, DiffableUtils.getStringKeySerializer());
-            templates = DiffableUtils.diff(before.templates, after.templates, DiffableUtils.getStringKeySerializer());
+            templates = DiffableUtils.diff(
+                before.templates.getTemplates(),
+                after.templates.getTemplates(),
+                DiffableUtils.getStringKeySerializer()
+            );
             customs = DiffableUtils.diff(before.customs, after.customs, DiffableUtils.getStringKeySerializer(), CUSTOM_VALUE_SERIALIZER);
         }
 
@@ -1076,7 +1127,7 @@ public Metadata apply(Metadata part) {
             builder.persistentSettings(persistentSettings);
             builder.hashesOfConsistentSettings(hashesOfConsistentSettings.apply(part.hashesOfConsistentSettings));
             builder.indices(indices.apply(part.indices));
-            builder.templates(templates.apply(part.templates));
+            builder.templates(templates.apply(part.templates.getTemplates()));
             builder.customs(customs.apply(part.customs));
             return builder.build();
         }
@@ -1132,10 +1183,7 @@ public void writeTo(StreamOutput out) throws IOException {
         for (IndexMetadata indexMetadata : this) {
             indexMetadata.writeTo(out);
         }
-        out.writeVInt(templates.size());
-        for (final IndexTemplateMetadata cursor : templates.values()) {
-            cursor.writeTo(out);
-        }
+        templates.writeTo(out);
         // filter out custom states not supported by the other node
         int numberOfCustoms = 0;
         for (final Custom cursor : customs.values()) {
@@ -1181,6 +1229,8 @@ public static class Builder {
         private final Map<String, Custom> customs;
         private final Metadata previousMetadata;
 
+        private Map<String, SortedMap<Long, String>> systemTemplatesLookup;
+
         public Builder() {
             clusterUUID = UNKNOWN_CLUSTER_UUID;
             indices = new HashMap<>();
@@ -1199,7 +1249,7 @@ public Builder(Metadata metadata) {
             this.hashesOfConsistentSettings = metadata.hashesOfConsistentSettings;
             this.version = metadata.version;
             this.indices = new HashMap<>(metadata.indices);
-            this.templates = new HashMap<>(metadata.templates);
+            this.templates = new HashMap<>(metadata.templates.getTemplates());
             this.customs = new HashMap<>(metadata.customs);
             this.previousMetadata = metadata;
         }
@@ -1278,6 +1328,12 @@ public Builder templates(Map<String, IndexTemplateMetadata> templates) {
             return this;
         }
 
+        public Builder templates(TemplatesMetadata templatesMetadata) {
+            this.templates.clear();
+            this.templates.putAll(templatesMetadata.getTemplates());
+            return this;
+        }
+
         public Builder put(String name, ComponentTemplate componentTemplate) {
             Objects.requireNonNull(componentTemplate, "it is invalid to add a null component template: " + name);
             Map<String, ComponentTemplate> existingTemplates = Optional.ofNullable(
@@ -1354,6 +1410,32 @@ public Builder removeDataStream(String name) {
             return this;
         }
 
+        public Builder queryGroups(final Map<String, QueryGroup> queryGroups) {
+            this.customs.put(QueryGroupMetadata.TYPE, new QueryGroupMetadata(queryGroups));
+            return this;
+        }
+
+        public Builder put(final QueryGroup queryGroup) {
+            Objects.requireNonNull(queryGroup, "queryGroup should not be null");
+            Map<String, QueryGroup> existing = new HashMap<>(getQueryGroups());
+            existing.put(queryGroup.get_id(), queryGroup);
+            return queryGroups(existing);
+        }
+
+        public Builder remove(final QueryGroup queryGroup) {
+            Objects.requireNonNull(queryGroup, "queryGroup should not be null");
+            Map<String, QueryGroup> existing = new HashMap<>(getQueryGroups());
+            existing.remove(queryGroup.get_id());
+            return queryGroups(existing);
+        }
+
+        private Map<String, QueryGroup> getQueryGroups() {
+            return Optional.ofNullable(this.customs.get(QueryGroupMetadata.TYPE))
+                .map(o -> (QueryGroupMetadata) o)
+                .map(QueryGroupMetadata::queryGroups)
+                .orElse(Collections.emptyMap());
+        }
+
         public Custom getCustom(String type) {
             return customs.get(type);
         }
@@ -1426,6 +1508,24 @@ public Builder updateNumberOfReplicas(final int numberOfReplicas, final String[]
             return this;
         }
 
+        /**
+         * Update the number of search replicas for the specified indices.
+         *
+         * @param numberOfSearchReplicas the number of search replicas
+         * @param indices          the indices to update the number of replicas for
+         * @return the builder
+         */
+        public Builder updateNumberOfSearchReplicas(final int numberOfSearchReplicas, final String[] indices) {
+            for (String index : indices) {
+                IndexMetadata indexMetadata = this.indices.get(index);
+                if (indexMetadata == null) {
+                    throw new IndexNotFoundException(index);
+                }
+                put(IndexMetadata.builder(indexMetadata).numberOfSearchReplicas(numberOfSearchReplicas));
+            }
+            return this;
+        }
+
         public Builder coordinationMetadata(CoordinationMetadata coordinationMetadata) {
             this.coordinationMetadata = coordinationMetadata;
             return this;
@@ -1491,6 +1591,8 @@ public Metadata build() {
                 ? (DataStreamMetadata) this.previousMetadata.customs.get(DataStreamMetadata.TYPE)
                 : null;
 
+            buildSystemTemplatesLookup();
+
             boolean recomputeRequiredforIndicesLookups = (previousMetadata == null)
                 || (indices.equals(previousMetadata.indices) == false)
                 || (previousDataStreamMetadata != null && previousDataStreamMetadata.equals(dataStreamMetadata) == false)
@@ -1501,6 +1603,33 @@ public Metadata build() {
                 : buildMetadataWithRecomputedIndicesLookups();
         }
 
+        private void buildSystemTemplatesLookup() {
+            if (previousMetadata != null
+                && Objects.equals(
+                    previousMetadata.customs.get(ComponentTemplateMetadata.TYPE),
+                    this.customs.get(ComponentTemplateMetadata.TYPE)
+                )) {
+                systemTemplatesLookup = Collections.unmodifiableMap(previousMetadata.systemTemplatesLookup);
+            } else {
+                systemTemplatesLookup = new HashMap<>();
+                Optional.ofNullable((ComponentTemplateMetadata) this.customs.get(ComponentTemplateMetadata.TYPE))
+                    .map(ComponentTemplateMetadata::componentTemplates)
+                    .orElseGet(Collections::emptyMap)
+                    .forEach((k, v) -> {
+                        if (MetadataIndexTemplateService.isSystemTemplate(v)) {
+                            SystemTemplateMetadata templateMetadata = SystemTemplateMetadata.fromComponentTemplate(k);
+                            systemTemplatesLookup.compute(templateMetadata.name(), (ik, iv) -> {
+                                if (iv == null) {
+                                    iv = new TreeMap<>();
+                                }
+                                iv.put(templateMetadata.version(), k);
+                                return iv;
+                            });
+                        }
+                    });
+            }
+        }
+
         protected Metadata buildMetadataWithPreviousIndicesLookups() {
             return new Metadata(
                 clusterUUID,
@@ -1519,7 +1648,8 @@ protected Metadata buildMetadataWithPreviousIndicesLookups() {
                 Arrays.copyOf(previousMetadata.visibleOpenIndices, previousMetadata.visibleOpenIndices.length),
                 Arrays.copyOf(previousMetadata.allClosedIndices, previousMetadata.allClosedIndices.length),
                 Arrays.copyOf(previousMetadata.visibleClosedIndices, previousMetadata.visibleClosedIndices.length),
-                Collections.unmodifiableSortedMap(previousMetadata.indicesLookup)
+                Collections.unmodifiableSortedMap(previousMetadata.indicesLookup),
+                systemTemplatesLookup
             );
         }
 
@@ -1642,7 +1772,8 @@ protected Metadata buildMetadataWithRecomputedIndicesLookups() {
                 visibleOpenIndicesArray,
                 allClosedIndicesArray,
                 visibleClosedIndicesArray,
-                indicesLookup
+                indicesLookup,
+                systemTemplatesLookup
             );
         }
 
@@ -1719,9 +1850,7 @@ static void validateDataStreams(SortedMap<String, IndexAbstraction> indicesLooku
             if (dsMetadata != null) {
                 for (DataStream ds : dsMetadata.dataStreams().values()) {
                     String prefix = DataStream.BACKING_INDEX_PREFIX + ds.getName() + "-";
-                    Set<String> conflicts = indicesLookup.subMap(prefix, DataStream.BACKING_INDEX_PREFIX + ds.getName() + ".") // '.' is the
-                                                                                                                               // char after
-                                                                                                                               // '-'
+                    Set<String> conflicts = indicesLookup.subMap(prefix, DataStream.BACKING_INDEX_PREFIX + ds.getName() + ".")
                         .keySet()
                         .stream()
                         .filter(s -> NUMBER_PATTERN.matcher(s.substring(prefix.length())).matches())
@@ -1768,9 +1897,7 @@ public static void toXContent(Metadata metadata, XContentBuilder builder, ToXCon
             }
 
             builder.startObject("templates");
-            for (final IndexTemplateMetadata cursor : metadata.templates().values()) {
-                IndexTemplateMetadata.Builder.toXContentWithTypes(cursor, builder, params);
-            }
+            metadata.templatesMetadata().toXContent(builder, params);
             builder.endObject();
 
             if (context == XContentContext.API) {
@@ -1833,12 +1960,10 @@ public static Metadata fromXContent(XContentParser parser) throws IOException {
                     } else if ("hashes_of_consistent_settings".equals(currentFieldName)) {
                         builder.hashesOfConsistentSettings(parser.mapStrings());
                     } else if ("templates".equals(currentFieldName)) {
-                        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
-                            builder.put(IndexTemplateMetadata.Builder.fromXContent(parser, parser.currentName()));
-                        }
+                        builder.templates(TemplatesMetadata.fromXContent(parser));
                     } else {
                         try {
-                            Custom custom = parser.namedObject(Custom.class, currentFieldName, null);
+                            Custom custom = Custom.fromXContent(parser, currentFieldName);
                             builder.putCustom(custom.getWriteableName(), custom);
                         } catch (NamedObjectNotFoundException ex) {
                             logger.warn("Skipping unknown custom object with type {}", currentFieldName);
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java b/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
index 7829d42b803ef..0931ca8216556 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MetadataCreateIndexService.java
@@ -50,6 +50,7 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ack.ClusterStateUpdateResponse;
 import org.opensearch.cluster.ack.CreateIndexClusterStateUpdateResponse;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesService;
 import org.opensearch.cluster.block.ClusterBlock;
 import org.opensearch.cluster.block.ClusterBlockLevel;
 import org.opensearch.cluster.block.ClusterBlocks;
@@ -76,9 +77,12 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.common.util.set.Sets;
 import org.opensearch.common.xcontent.XContentHelper;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.env.Environment;
@@ -86,6 +90,9 @@
 import org.opensearch.index.IndexNotFoundException;
 import org.opensearch.index.IndexService;
 import org.opensearch.index.IndexSettings;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
+import org.opensearch.index.compositeindex.CompositeIndexValidator;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.MapperService.MergeReason;
@@ -98,6 +105,7 @@
 import org.opensearch.index.translog.Translog;
 import org.opensearch.indices.IndexCreationException;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.InvalidIndexContextException;
 import org.opensearch.indices.InvalidIndexNameException;
 import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.indices.ShardLimitValidator;
@@ -125,27 +133,31 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
-import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
+import java.util.stream.Stream;
 
 import static java.util.stream.Collectors.toList;
 import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING;
+import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING;
 import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING;
 import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_REPLICATION_TYPE_SETTING;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_AUTO_EXPAND_REPLICAS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_CREATION_DATE;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_INDEX_UUID;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REMOTE_SEGMENT_STORE_REPOSITORY;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REMOTE_STORE_ENABLED;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REMOTE_TRANSLOG_STORE_REPOSITORY;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REPLICATION_TYPE;
 import static org.opensearch.cluster.metadata.Metadata.DEFAULT_REPLICA_COUNT_SETTING;
+import static org.opensearch.cluster.metadata.MetadataIndexTemplateService.findContextTemplateName;
 import static org.opensearch.index.IndexModule.INDEX_STORE_TYPE_SETTING;
+import static org.opensearch.index.IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING;
 import static org.opensearch.indices.IndicesService.CLUSTER_REPLICATION_TYPE_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteDataAttributePresent;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
@@ -494,20 +506,30 @@ private ClusterState applyCreateIndexWithTemporaryService(
         final IndexMetadata sourceMetadata,
         final IndexMetadata temporaryIndexMeta,
         final List<Map<String, Object>> mappings,
-        final Function<IndexService, List<AliasMetadata>> aliasSupplier,
+        final BiFunction<IndexService, Map<String, AliasMetadata>, List<AliasMetadata>> aliasSupplier,
         final List<String> templatesApplied,
         final BiConsumer<Metadata.Builder, IndexMetadata> metadataTransformer
     ) throws Exception {
         // create the index here (on the master) to validate it can be created, as well as adding the mapping
         return indicesService.<ClusterState, Exception>withTempIndexService(temporaryIndexMeta, indexService -> {
+            Settings.Builder tmpSettingsBuilder = Settings.builder().put(temporaryIndexMeta.getSettings());
+
+            List<Map<String, Object>> updatedMappings = new ArrayList<>();
+            updatedMappings.addAll(mappings);
+
+            Template contextTemplate = applyContext(request, currentState, updatedMappings, tmpSettingsBuilder);
+
             try {
-                updateIndexMappingsAndBuildSortOrder(indexService, request, mappings, sourceMetadata);
+                updateIndexMappingsAndBuildSortOrder(indexService, request, updatedMappings, sourceMetadata);
             } catch (Exception e) {
                 logger.log(silent ? Level.DEBUG : Level.INFO, "failed on parsing mappings on index creation [{}]", request.index(), e);
                 throw e;
             }
 
-            final List<AliasMetadata> aliases = aliasSupplier.apply(indexService);
+            final List<AliasMetadata> aliases = aliasSupplier.apply(
+                indexService,
+                Optional.ofNullable(contextTemplate).map(Template::aliases).orElse(Map.of())
+            );
 
             final IndexMetadata indexMetadata;
             try {
@@ -515,11 +537,12 @@ private ClusterState applyCreateIndexWithTemporaryService(
                     request.index(),
                     aliases,
                     indexService.mapperService()::documentMapper,
-                    temporaryIndexMeta.getSettings(),
+                    tmpSettingsBuilder.build(),
                     temporaryIndexMeta.getRoutingNumShards(),
                     sourceMetadata,
                     temporaryIndexMeta.isSystem(),
-                    temporaryIndexMeta.getCustomData()
+                    temporaryIndexMeta.getCustomData(),
+                    temporaryIndexMeta.context()
                 );
             } catch (Exception e) {
                 logger.info("failed to build index metadata [{}]", request.index());
@@ -541,6 +564,54 @@ private ClusterState applyCreateIndexWithTemporaryService(
         });
     }
 
+    Template applyContext(
+        CreateIndexClusterStateUpdateRequest request,
+        ClusterState currentState,
+        List<Map<String, Object>> mappings,
+        Settings.Builder settingsBuilder
+    ) throws IOException {
+        if (request.context() != null) {
+            ComponentTemplate componentTemplate = MetadataIndexTemplateService.findComponentTemplate(
+                currentState.metadata(),
+                request.context()
+            );
+
+            if (componentTemplate.template().mappings() != null) {
+                // Mappings added at last (priority to mappings provided)
+                mappings.add(MapperService.parseMapping(xContentRegistry, componentTemplate.template().mappings().toString()));
+            }
+
+            if (componentTemplate.template().settings() != null) {
+                validateOverlap(settingsBuilder.keys(), componentTemplate.template().settings(), request.index()).ifPresent(message -> {
+                    ValidationException validationException = new ValidationException();
+                    validationException.addValidationError(message);
+                    throw validationException;
+                });
+                // Settings applied at last
+                settingsBuilder.put(componentTemplate.template().settings());
+            }
+
+            settingsBuilder.put(IndexSettings.INDEX_CONTEXT_CREATED_VERSION.getKey(), componentTemplate.version());
+            settingsBuilder.put(IndexSettings.INDEX_CONTEXT_CURRENT_VERSION.getKey(), componentTemplate.version());
+
+            return componentTemplate.template();
+        }
+        return null;
+    }
+
+    static Optional<String> validateOverlap(Set<String> requestSettings, Settings contextTemplateSettings, String indexName) {
+        if (requestSettings.stream().anyMatch(contextTemplateSettings::hasValue)) {
+            return Optional.of(
+                "Cannot apply context template as user provide settings have overlap with the included context template."
+                    + "Please remove the settings ["
+                    + Sets.intersection(requestSettings, contextTemplateSettings.keySet())
+                    + "] to continue using the context for index: "
+                    + indexName
+            );
+        }
+        return Optional.empty();
+    }
+
     /**
      * Given a state and index settings calculated after applying templates, validate metadata for
      * the new index, returning an {@link IndexMetadata} for the new index.
@@ -567,6 +638,10 @@ IndexMetadata buildAndValidateTemporaryIndexMetadata(
         tmpImdBuilder.system(isSystem);
         addRemoteStoreCustomMetadata(tmpImdBuilder, true);
 
+        if (request.context() != null) {
+            tmpImdBuilder.context(request.context());
+        }
+
         // Set up everything, now locally create the index to see that things are ok, and apply
         IndexMetadata tempMetadata = tmpImdBuilder.build();
         validateActiveShardCount(request.waitForActiveShards(), tempMetadata);
@@ -647,10 +722,10 @@ private ClusterState applyCreateIndexRequestWithV1Templates(
             null,
             tmpImd,
             Collections.singletonList(mappings),
-            indexService -> resolveAndValidateAliases(
+            (indexService, contextAlias) -> resolveAndValidateAliases(
                 request.index(),
                 request.aliases(),
-                MetadataIndexTemplateService.resolveAliases(templates),
+                Stream.concat(Stream.of(contextAlias), MetadataIndexTemplateService.resolveAliases(templates).stream()).collect(toList()),
                 currentState.metadata(),
                 aliasValidator,
                 // the context is only used for validation so it's fine to pass fake values for the
@@ -712,10 +787,13 @@ private ClusterState applyCreateIndexRequestWithV2Template(
             null,
             tmpImd,
             mappings,
-            indexService -> resolveAndValidateAliases(
+            (indexService, contextAlias) -> resolveAndValidateAliases(
                 request.index(),
                 request.aliases(),
-                MetadataIndexTemplateService.resolveAliases(currentState.metadata(), templateName),
+                Stream.concat(
+                    Stream.of(contextAlias),
+                    MetadataIndexTemplateService.resolveAliases(currentState.metadata(), templateName).stream()
+                ).collect(toList()),
                 currentState.metadata(),
                 aliasValidator,
                 // the context is only used for validation so it's fine to pass fake values for the
@@ -793,7 +871,7 @@ private ClusterState applyCreateIndexRequestWithExistingMetadata(
             sourceMetadata,
             tmpImd,
             Collections.singletonList(mappings),
-            indexService -> resolveAndValidateAliases(
+            (indexService, contextTemplate) -> resolveAndValidateAliases(
                 request.index(),
                 request.aliases(),
                 Collections.emptyList(),
@@ -952,7 +1030,8 @@ static Settings aggregateIndexSettings(
             }
             indexSettingsBuilder.put(SETTING_NUMBER_OF_SHARDS, numberOfShards);
         }
-        if (INDEX_NUMBER_OF_REPLICAS_SETTING.exists(indexSettingsBuilder) == false) {
+        if (INDEX_NUMBER_OF_REPLICAS_SETTING.exists(indexSettingsBuilder) == false
+            || indexSettingsBuilder.get(SETTING_NUMBER_OF_REPLICAS) == null) {
             indexSettingsBuilder.put(SETTING_NUMBER_OF_REPLICAS, DEFAULT_REPLICA_COUNT_SETTING.get(currentState.metadata().settings()));
         }
         if (settings.get(SETTING_AUTO_EXPAND_REPLICAS) != null && indexSettingsBuilder.get(SETTING_AUTO_EXPAND_REPLICAS) == null) {
@@ -967,6 +1046,9 @@ static Settings aggregateIndexSettings(
 
         updateReplicationStrategy(indexSettingsBuilder, request.settings(), settings, combinedTemplateSettings, clusterSettings);
         updateRemoteStoreSettings(indexSettingsBuilder, currentState, clusterSettings, settings, request.index());
+        if (FeatureFlags.isEnabled(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL_SETTING)) {
+            updateSearchOnlyReplicas(request.settings(), indexSettingsBuilder);
+        }
 
         if (sourceMetadata != null) {
             assert request.resizeType() != null;
@@ -1001,11 +1083,28 @@ static Settings aggregateIndexSettings(
         validateTranslogRetentionSettings(indexSettings);
         validateStoreTypeSettings(indexSettings);
         validateRefreshIntervalSettings(request.settings(), clusterSettings);
+        validateTranslogFlushIntervalSettingsForCompositeIndex(request.settings(), clusterSettings);
         validateTranslogDurabilitySettings(request.settings(), clusterSettings, settings);
-
         return indexSettings;
     }
 
+    private static void updateSearchOnlyReplicas(Settings requestSettings, Settings.Builder builder) {
+        if (INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING.exists(builder) && builder.get(SETTING_NUMBER_OF_SEARCH_REPLICAS) != null) {
+            if (INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING.get(requestSettings) > 0
+                && ReplicationType.parseString(builder.get(INDEX_REPLICATION_TYPE_SETTING.getKey())).equals(ReplicationType.DOCUMENT)) {
+                throw new IllegalArgumentException(
+                    "To set "
+                        + SETTING_NUMBER_OF_SEARCH_REPLICAS
+                        + ", "
+                        + INDEX_REPLICATION_TYPE_SETTING.getKey()
+                        + " must be set to "
+                        + ReplicationType.SEGMENT
+                );
+            }
+            builder.put(SETTING_NUMBER_OF_SEARCH_REPLICAS, INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING.get(requestSettings));
+        }
+    }
+
     /**
      * Updates index settings to set replication strategy by default based on cluster level settings or remote store
      * node attributes
@@ -1256,7 +1355,8 @@ static IndexMetadata buildIndexMetadata(
         int routingNumShards,
         @Nullable IndexMetadata sourceMetadata,
         boolean isSystem,
-        Map<String, DiffableStringMap> customData
+        Map<String, DiffableStringMap> customData,
+        Context context
     ) {
         IndexMetadata.Builder indexMetadataBuilder = createIndexMetadataBuilder(indexName, sourceMetadata, indexSettings, routingNumShards);
         indexMetadataBuilder.system(isSystem);
@@ -1281,6 +1381,8 @@ static IndexMetadata buildIndexMetadata(
             indexMetadataBuilder.putCustom(entry.getKey(), entry.getValue());
         }
 
+        indexMetadataBuilder.context(context);
+
         indexMetadataBuilder.state(IndexMetadata.State.OPEN);
         return indexMetadataBuilder.build();
     }
@@ -1340,6 +1442,10 @@ private static void updateIndexMappingsAndBuildSortOrder(
             }
         }
 
+        if (mapperService.isCompositeIndexPresent()) {
+            CompositeIndexValidator.validate(mapperService, indexService.getCompositeIndexSettings(), indexService.getIndexSettings());
+        }
+
         if (sourceMetadata == null) {
             // now that the mapping is merged we can validate the index sort.
             // we cannot validate for index shrinking since the mapping is empty
@@ -1370,6 +1476,7 @@ private static void validateActiveShardCount(ActiveShardCount waitForActiveShard
     private void validate(CreateIndexClusterStateUpdateRequest request, ClusterState state) {
         validateIndexName(request.index(), state);
         validateIndexSettings(request.index(), request.settings(), forbidPrivateIndexSettings);
+        validateContext(request);
     }
 
     public void validateIndexSettings(String indexName, final Settings settings, final boolean forbidPrivateIndexSettings)
@@ -1664,6 +1771,71 @@ public static void validateTranslogRetentionSettings(Settings indexSettings) {
         }
     }
 
+    /**
+     * Validates {@code index.translog.flush_threshold_size} is equal or below the {@code indices.composite_index.translog.max_flush_threshold_size}
+     * for composite indices based on {{@code index.composite_index}}
+     *
+     * @param requestSettings settings passed in during index create/update request
+     * @param clusterSettings cluster setting
+     */
+    public static void validateTranslogFlushIntervalSettingsForCompositeIndex(Settings requestSettings, ClusterSettings clusterSettings) {
+        if (StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.exists(requestSettings) == false
+            || requestSettings.get(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey()) == null) {
+            return;
+        }
+        ByteSizeValue translogFlushSize = INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.get(requestSettings);
+        ByteSizeValue compositeIndexMaxFlushSize = clusterSettings.get(
+            CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING
+        );
+        if (translogFlushSize.compareTo(compositeIndexMaxFlushSize) > 0) {
+            throw new IllegalArgumentException(
+                String.format(
+                    Locale.ROOT,
+                    "You can configure '%s' with upto '%s' for composite index",
+                    INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(),
+                    compositeIndexMaxFlushSize
+                )
+            );
+        }
+    }
+
+    /**
+     * Validates {@code index.translog.flush_threshold_size} is equal or below the {@code indices.composite_index.translog.max_flush_threshold_size}
+     * for composite indices based on {{@code index.composite_index}}
+     * This is used during update index settings flow
+     *
+     * @param requestSettings settings passed in during index update request
+     * @param clusterSettings cluster setting
+     * @param indexSettings index settings
+     */
+    public static Optional<String> validateTranslogFlushIntervalSettingsForCompositeIndex(
+        Settings requestSettings,
+        ClusterSettings clusterSettings,
+        Settings indexSettings
+    ) {
+        if (INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.exists(requestSettings) == false
+            || requestSettings.get(INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey()) == null
+            || StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.exists(indexSettings) == false
+            || indexSettings.get(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey()) == null) {
+            return Optional.empty();
+        }
+        ByteSizeValue translogFlushSize = INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.get(requestSettings);
+        ByteSizeValue compositeIndexMaxFlushSize = clusterSettings.get(
+            CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING
+        );
+        if (translogFlushSize.compareTo(compositeIndexMaxFlushSize) > 0) {
+            return Optional.of(
+                String.format(
+                    Locale.ROOT,
+                    "You can configure '%s' with upto '%s' for composite index",
+                    INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(),
+                    compositeIndexMaxFlushSize
+                )
+            );
+        }
+        return Optional.empty();
+    }
+
     /**
      * Validates {@code index.refresh_interval} is equal or below the {@code cluster.minimum.index.refresh_interval}.
      *
@@ -1714,4 +1886,25 @@ static void validateTranslogDurabilitySettings(Settings requestSettings, Cluster
         }
 
     }
+
+    void validateContext(CreateIndexClusterStateUpdateRequest request) {
+        final boolean isContextAllowed = FeatureFlags.isEnabled(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES);
+
+        if (request.context() != null && !isContextAllowed) {
+            throw new InvalidIndexContextException(
+                request.context().name(),
+                request.index(),
+                "index specifies a context which cannot be used without enabling: "
+                    + SystemTemplatesService.SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED.getKey()
+            );
+        }
+
+        if (request.context() != null && findContextTemplateName(clusterService.state().metadata(), request.context()) == null) {
+            throw new InvalidIndexContextException(
+                request.context().name(),
+                request.index(),
+                "index specifies a context which is not loaded on the cluster."
+            );
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MetadataIndexTemplateService.java b/server/src/main/java/org/opensearch/cluster/metadata/MetadataIndexTemplateService.java
index 5b03d3f7b19ce..e4afc798cc64d 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MetadataIndexTemplateService.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MetadataIndexTemplateService.java
@@ -42,6 +42,9 @@
 import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateUpdateTask;
+import org.opensearch.cluster.applicationtemplates.ClusterStateSystemTemplateLoader;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateMetadata;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesService;
 import org.opensearch.cluster.service.ClusterManagerTaskKeys;
 import org.opensearch.cluster.service.ClusterManagerTaskThrottler;
 import org.opensearch.cluster.service.ClusterService;
@@ -53,9 +56,11 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.logging.HeaderWarning;
 import org.opensearch.common.regex.Regex;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.action.ActionListener;
@@ -66,12 +71,15 @@
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.IndexService;
+import org.opensearch.index.IndexSettings;
 import org.opensearch.index.mapper.MapperParsingException;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.MapperService.MergeReason;
+import org.opensearch.index.translog.Translog;
 import org.opensearch.indices.IndexTemplateMissingException;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.InvalidIndexTemplateException;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
@@ -94,6 +102,8 @@
 
 import static org.opensearch.cluster.metadata.MetadataCreateDataStreamService.validateTimestampFieldMapping;
 import static org.opensearch.cluster.metadata.MetadataCreateIndexService.validateRefreshIntervalSettings;
+import static org.opensearch.cluster.metadata.MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex;
+import static org.opensearch.common.util.concurrent.ThreadContext.ACTION_ORIGIN_TRANSIENT_NAME;
 import static org.opensearch.indices.cluster.IndicesClusterStateService.AllocatedIndices.IndexRemovalReason.NO_LONGER_ASSIGNED;
 
 /**
@@ -116,6 +126,7 @@ public class MetadataIndexTemplateService {
     private final ClusterManagerTaskThrottler.ThrottlingKey removeIndexTemplateV2TaskKey;
     private final ClusterManagerTaskThrottler.ThrottlingKey createComponentTemplateTaskKey;
     private final ClusterManagerTaskThrottler.ThrottlingKey removeComponentTemplateTaskKey;
+    private final ThreadPool threadPool;
 
     @Inject
     public MetadataIndexTemplateService(
@@ -124,7 +135,8 @@ public MetadataIndexTemplateService(
         AliasValidator aliasValidator,
         IndicesService indicesService,
         IndexScopedSettings indexScopedSettings,
-        NamedXContentRegistry xContentRegistry
+        NamedXContentRegistry xContentRegistry,
+        ThreadPool threadPool
     ) {
         this.clusterService = clusterService;
         this.aliasValidator = aliasValidator;
@@ -132,6 +144,7 @@ public MetadataIndexTemplateService(
         this.metadataCreateIndexService = metadataCreateIndexService;
         this.indexScopedSettings = indexScopedSettings;
         this.xContentRegistry = xContentRegistry;
+        this.threadPool = threadPool;
 
         // Task is onboarded for throttling, it will get retried from associated TransportClusterManagerNodeAction.
         createIndexTemplateTaskKey = clusterService.registerClusterManagerTask(ClusterManagerTaskKeys.CREATE_INDEX_TEMPLATE_KEY, true);
@@ -209,6 +222,7 @@ public void putComponentTemplate(
         final ComponentTemplate template,
         final ActionListener<AcknowledgedResponse> listener
     ) {
+        validateComponentTemplateRequest(template);
         clusterService.submitStateUpdateTask(
             "create-component-template [" + name + "], cause [" + cause + "]",
             new ClusterStateUpdateTask(Priority.URGENT) {
@@ -378,6 +392,7 @@ public void removeComponentTemplate(
         final ActionListener<AcknowledgedResponse> listener
     ) {
         validateNotInUse(clusterService.state().metadata(), name);
+        validateComponentTemplateRequest(clusterService.state().metadata().componentTemplates().get(name));
         clusterService.submitStateUpdateTask("remove-component-template [" + name + "]", new ClusterStateUpdateTask(Priority.URGENT) {
 
             @Override
@@ -439,7 +454,12 @@ static void validateNotInUse(Metadata metadata, String templateNameOrWildcard) {
             .collect(Collectors.toSet());
         final Set<String> componentsBeingUsed = new HashSet<>();
         final List<String> templatesStillUsing = metadata.templatesV2().entrySet().stream().filter(e -> {
-            Set<String> intersecting = Sets.intersection(new HashSet<>(e.getValue().composedOf()), matchingComponentTemplates);
+            Set<String> referredComponentTemplates = new HashSet<>(e.getValue().composedOf());
+            String systemTemplateUsed = findContextTemplateName(metadata, e.getValue().context());
+            if (systemTemplateUsed != null) {
+                referredComponentTemplates.add(systemTemplateUsed);
+            }
+            Set<String> intersecting = Sets.intersection(referredComponentTemplates, matchingComponentTemplates);
             if (intersecting.size() > 0) {
                 componentsBeingUsed.addAll(intersecting);
                 return true;
@@ -469,7 +489,7 @@ public void putIndexTemplateV2(
         final ComposableIndexTemplate template,
         final ActionListener<AcknowledgedResponse> listener
     ) {
-        validateV2TemplateRequest(clusterService.state().metadata(), name, template);
+        validateV2TemplateRequest(clusterService.state().metadata(), name, template, clusterService.getClusterSettings());
         clusterService.submitStateUpdateTask(
             "create-index-template-v2 [" + name + "], cause [" + cause + "]",
             new ClusterStateUpdateTask(Priority.URGENT) {
@@ -502,7 +522,12 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
         );
     }
 
-    public static void validateV2TemplateRequest(Metadata metadata, String name, ComposableIndexTemplate template) {
+    public static void validateV2TemplateRequest(
+        Metadata metadata,
+        String name,
+        ComposableIndexTemplate template,
+        ClusterSettings settings
+    ) {
         if (template.indexPatterns().stream().anyMatch(Regex::isMatchAllPattern)) {
             Settings mergedSettings = resolveSettings(metadata, template);
             if (IndexMetadata.INDEX_HIDDEN_SETTING.exists(mergedSettings)) {
@@ -514,6 +539,8 @@ public static void validateV2TemplateRequest(Metadata metadata, String name, Com
         }
 
         final Map<String, ComponentTemplate> componentTemplates = metadata.componentTemplates();
+        final boolean isContextAllowed = FeatureFlags.isEnabled(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES);
+
         final List<String> missingComponentTemplates = template.composedOf()
             .stream()
             .filter(componentTemplate -> componentTemplates.containsKey(componentTemplate) == false)
@@ -525,6 +552,64 @@ public static void validateV2TemplateRequest(Metadata metadata, String name, Com
                 "index template [" + name + "] specifies component templates " + missingComponentTemplates + " that do not exist"
             );
         }
+
+        if (template.context() != null && !isContextAllowed) {
+            throw new InvalidIndexTemplateException(
+                name,
+                "index template ["
+                    + name
+                    + "] specifies a context which cannot be used without enabling: "
+                    + SystemTemplatesService.SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED.getKey()
+            );
+        }
+
+        if (isContextAllowed
+            && template.composedOf().stream().anyMatch(componentTemplate -> isSystemTemplate(componentTemplates.get(componentTemplate)))) {
+            throw new InvalidIndexTemplateException(
+                name,
+                "index template [" + name + "] specifies a component templates which can only be used in context."
+            );
+        }
+
+        if (template.context() != null && findContextTemplateName(metadata, template.context()) == null) {
+            throw new InvalidIndexTemplateException(
+                name,
+                "index template [" + name + "] specifies a context which is not loaded on the cluster."
+            );
+        }
+    }
+
+    private void validateComponentTemplateRequest(ComponentTemplate componentTemplate) {
+        if (isSystemTemplate(componentTemplate)
+            && !ClusterStateSystemTemplateLoader.TEMPLATE_LOADER_IDENTIFIER.equals(
+                threadPool.getThreadContext().getTransient(ACTION_ORIGIN_TRANSIENT_NAME)
+            )) {
+            throw new IllegalArgumentException("A system template can only be created/updated/deleted with a repository");
+        }
+    }
+
+    static ComponentTemplate findComponentTemplate(Metadata metadata, Context context) {
+        String contextTemplateName = findContextTemplateName(metadata, context);
+        return metadata.componentTemplates().getOrDefault(contextTemplateName, null);
+    }
+
+    static String findContextTemplateName(Metadata metadata, Context context) {
+        if (context == null) {
+            return null;
+        }
+        final boolean searchSpecificVersion = !Context.LATEST_VERSION.equals(context.version());
+        return Optional.ofNullable(metadata.systemTemplatesLookup())
+            .map(coll -> coll.get(context.name()))
+            .map(coll -> coll.get(searchSpecificVersion ? Long.parseLong(context.version()) : coll.lastKey()))
+            .orElse(null);
+    }
+
+    public static boolean isSystemTemplate(ComponentTemplate componentTemplate) {
+        return Optional.ofNullable(componentTemplate)
+            .map(ComponentTemplate::metadata)
+            .map(md -> md.get(ClusterStateSystemTemplateLoader.TEMPLATE_TYPE_KEY))
+            .filter(ob -> SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE.equals(ob.toString()))
+            .isPresent();
     }
 
     public ClusterState addIndexTemplateV2(
@@ -613,7 +698,8 @@ public ClusterState addIndexTemplateV2(
                 template.priority(),
                 template.version(),
                 template.metadata(),
-                template.getDataStreamTemplate()
+                template.getDataStreamTemplate(),
+                template.context()
             );
         }
 
@@ -866,7 +952,7 @@ static ClusterState innerRemoveIndexTemplateV2(ClusterState currentState, String
 
     static Set<String> dataStreamsUsingTemplate(final ClusterState state, final String templateName) {
         final ComposableIndexTemplate template = state.metadata().templatesV2().get(templateName);
-        if (template == null) {
+        if (template == null || template.getDataStreamTemplate() == null) {
             return Collections.emptySet();
         }
         final Set<String> dataStreams = state.metadata().dataStreams().keySet();
@@ -1140,7 +1226,7 @@ public static List<CompressedXContent> collectMappings(final ClusterState state,
             .map(Template::mappings)
             .filter(Objects::nonNull)
             .collect(Collectors.toCollection(LinkedList::new));
-        // Add the actual index template's mappings, since it takes the highest precedence
+        // Add the actual index template's mappings, since it takes the next precedence
         Optional.ofNullable(template.template()).map(Template::mappings).ifPresent(mappings::add);
         if (template.getDataStreamTemplate() != null && indexName.startsWith(DataStream.BACKING_INDEX_PREFIX)) {
             // add a default mapping for the timestamp field, at the lowest precedence, to make bootstrapping data streams more
@@ -1165,6 +1251,15 @@ public static List<CompressedXContent> collectMappings(final ClusterState state,
                 })
                 .ifPresent(mappings::add);
         }
+
+        // Now use context mappings which take the highest precedence
+        Optional.ofNullable(template.context())
+            .map(ctx -> findContextTemplateName(state.metadata(), ctx))
+            .map(name -> state.metadata().componentTemplates().get(name))
+            .map(ComponentTemplate::template)
+            .map(Template::mappings)
+            .ifPresent(mappings::add);
+
         return Collections.unmodifiableList(mappings);
     }
 
@@ -1226,8 +1321,13 @@ private static Settings resolveSettings(Metadata metadata, ComposableIndexTempla
 
         Settings.Builder templateSettings = Settings.builder();
         componentSettings.forEach(templateSettings::put);
-        // Add the actual index template's settings to the end, since it takes the highest precedence.
+        // Add the actual index template's settings now, since it takes the next precedence.
         Optional.ofNullable(template.template()).map(Template::settings).ifPresent(templateSettings::put);
+
+        // Add the template referred by context since it will take the highest precedence.
+        final ComponentTemplate componentTemplate = findComponentTemplate(metadata, template.context());
+        Optional.ofNullable(componentTemplate).map(ComponentTemplate::template).map(Template::settings).ifPresent(templateSettings::put);
+
         return templateSettings.build();
     }
 
@@ -1269,8 +1369,15 @@ public static List<Map<String, AliasMetadata>> resolveAliases(final Metadata met
             .filter(Objects::nonNull)
             .collect(Collectors.toList());
 
-        // Add the actual index template's aliases to the end if they exist
+        // Add the actual index template's aliases now if they exist
         Optional.ofNullable(template.template()).map(Template::aliases).ifPresent(aliases::add);
+
+        // Now use context referenced template's aliases which take the highest precedence
+        if (template.context() != null) {
+            final ComponentTemplate componentTemplate = findComponentTemplate(metadata, template.context());
+            Optional.ofNullable(componentTemplate.template()).map(Template::aliases).ifPresent(aliases::add);
+        }
+
         // Aliases are applied in order, but subsequent alias configuration from the same name is
         // ignored, so in order for the order to be correct, alias configuration should be in order
         // of precedence (with the index template first)
@@ -1531,8 +1638,10 @@ private void validate(String name, @Nullable Settings settings, List<String> ind
             );
             validationErrors.addAll(indexSettingsValidation);
 
-            // validate index refresh interval settings
+            // validate index refresh interval and translog durability settings
             validateRefreshIntervalSettings(settings, clusterService.getClusterSettings());
+            validateTranslogFlushIntervalSettingsForCompositeIndex(settings, clusterService.getClusterSettings());
+            validateTranslogDurabilitySettingsInTemplate(settings, clusterService.getClusterSettings());
         }
 
         if (indexPatterns.stream().anyMatch(Regex::isMatchAllPattern)) {
@@ -1558,6 +1667,29 @@ private void validate(String name, @Nullable Settings settings, List<String> ind
         }
     }
 
+    /**
+     * Validates {@code index.translog.durability} is not async with the incoming index template
+     * if the {@code cluster.remote_store.index.restrict.async-durability} is set to true.
+     *
+     * @param requestSettings settings passed during template creation
+     * @param clusterSettings current cluster settings
+     */
+    private void validateTranslogDurabilitySettingsInTemplate(Settings requestSettings, ClusterSettings clusterSettings) {
+        if (IndexSettings.INDEX_TRANSLOG_DURABILITY_SETTING.exists(requestSettings) == false
+            || clusterSettings.get(IndicesService.CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING) == false) {
+            return;
+        }
+        Translog.Durability durability = IndexSettings.INDEX_TRANSLOG_DURABILITY_SETTING.get(requestSettings);
+        if (durability.equals(Translog.Durability.ASYNC)) {
+            throw new IllegalArgumentException(
+                "index setting [index.translog.durability=async] is not allowed as cluster setting ["
+                    + IndicesService.CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING.getKey()
+                    + "=true]"
+            );
+        }
+
+    }
+
     /**
      * Listener for putting metadata in the template
      *
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MetadataMappingService.java b/server/src/main/java/org/opensearch/cluster/metadata/MetadataMappingService.java
index 1406287149e8d..b4d8429d98f73 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MetadataMappingService.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MetadataMappingService.java
@@ -55,6 +55,7 @@
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.index.Index;
 import org.opensearch.index.IndexService;
+import org.opensearch.index.compositeindex.CompositeIndexValidator;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.MapperService.MergeReason;
@@ -291,7 +292,7 @@ private ClusterState applyRequest(
                 // we use the exact same indexService and metadata we used to validate above here to actually apply the update
                 final Index index = indexMetadata.getIndex();
                 final MapperService mapperService = indexMapperServices.get(index);
-
+                boolean isCompositeFieldPresent = !mapperService.getCompositeFieldTypes().isEmpty();
                 CompressedXContent existingSource = null;
                 DocumentMapper existingMapper = mapperService.documentMapper();
                 if (existingMapper != null) {
@@ -302,6 +303,14 @@ private ClusterState applyRequest(
                     mappingUpdateSource,
                     MergeReason.MAPPING_UPDATE
                 );
+
+                CompositeIndexValidator.validate(
+                    mapperService,
+                    indicesService.getCompositeIndexSettings(),
+                    mapperService.getIndexSettings(),
+                    isCompositeFieldPresent
+                );
+
                 CompressedXContent updatedSource = mergedMapper.mappingSource();
 
                 if (existingSource != null) {
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/MetadataUpdateSettingsService.java b/server/src/main/java/org/opensearch/cluster/metadata/MetadataUpdateSettingsService.java
index 7d4c3512ed757..7957a808970eb 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/MetadataUpdateSettingsService.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/MetadataUpdateSettingsService.java
@@ -57,24 +57,33 @@
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.Index;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.ShardLimitValidator;
+import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 
 import static org.opensearch.action.support.ContextPreservingActionListener.wrapPreservingContext;
+import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_REPLICATION_TYPE_SETTING;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS;
+import static org.opensearch.cluster.metadata.MetadataCreateIndexService.validateOverlap;
 import static org.opensearch.cluster.metadata.MetadataCreateIndexService.validateRefreshIntervalSettings;
 import static org.opensearch.cluster.metadata.MetadataCreateIndexService.validateTranslogDurabilitySettings;
+import static org.opensearch.cluster.metadata.MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex;
+import static org.opensearch.cluster.metadata.MetadataIndexTemplateService.findComponentTemplate;
 import static org.opensearch.common.settings.AbstractScopedSettings.ARCHIVED_SETTINGS_PREFIX;
 import static org.opensearch.index.IndexSettings.same;
 
@@ -196,6 +205,7 @@ public ClusterState execute(ClusterState currentState) {
                     Set<Index> openIndices = new HashSet<>();
                     Set<Index> closeIndices = new HashSet<>();
                     final String[] actualIndices = new String[request.indices().length];
+                    final List<String> validationErrors = new ArrayList<>();
                     for (int i = 0; i < request.indices().length; i++) {
                         Index index = request.indices()[i];
                         actualIndices[i] = index.getName();
@@ -205,6 +215,25 @@ public ClusterState execute(ClusterState currentState) {
                         } else {
                             closeIndices.add(index);
                         }
+                        if (metadata.context() != null) {
+                            validateOverlap(
+                                normalizedSettings.keySet(),
+                                findComponentTemplate(currentState.metadata(), metadata.context()).template().settings(),
+                                index.getName()
+                            ).ifPresent(validationErrors::add);
+                        }
+                        validateTranslogFlushIntervalSettingsForCompositeIndex(
+                            normalizedSettings,
+                            clusterService.getClusterSettings(),
+                            metadata.getSettings()
+                        ).ifPresent(validationErrors::add);
+
+                    }
+
+                    if (validationErrors.size() > 0) {
+                        ValidationException exception = new ValidationException();
+                        exception.addValidationErrors(validationErrors);
+                        throw exception;
                     }
 
                     if (!skippedSettings.isEmpty() && !openIndices.isEmpty()) {
@@ -260,6 +289,34 @@ public ClusterState execute(ClusterState currentState) {
                         }
                     }
 
+                    if (IndexMetadata.INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING.exists(openSettings)) {
+                        if (FeatureFlags.isEnabled(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL_SETTING)) {
+                            validateSearchReplicaCountSettings(normalizedSettings, request.indices(), currentState);
+                        }
+                        final int updatedNumberOfSearchReplicas = IndexMetadata.INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING.get(openSettings);
+                        if (preserveExisting == false) {
+                            // TODO: Honor awareness validation to search replicas.
+
+                            // Verify that this won't take us over the cluster shard limit.
+                            int totalNewShards = Arrays.stream(request.indices())
+                                .mapToInt(i -> getTotalNewShards(i, currentState, updatedNumberOfSearchReplicas))
+                                .sum();
+                            Optional<String> error = shardLimitValidator.checkShardLimit(totalNewShards, currentState);
+                            if (error.isPresent()) {
+                                ValidationException ex = new ValidationException();
+                                ex.addValidationError(error.get());
+                                throw ex;
+                            }
+                            routingTableBuilder.updateNumberOfSearchReplicas(updatedNumberOfSearchReplicas, actualIndices);
+                            metadataBuilder.updateNumberOfSearchReplicas(updatedNumberOfSearchReplicas, actualIndices);
+                            logger.info(
+                                "updating number_of_Search Replicas to [{}] for indices {}",
+                                updatedNumberOfSearchReplicas,
+                                actualIndices
+                            );
+                        }
+                    }
+
                     if (!openIndices.isEmpty()) {
                         for (Index index : openIndices) {
                             IndexMetadata indexMetadata = metadataBuilder.getSafe(index);
@@ -469,4 +526,27 @@ public ClusterState execute(ClusterState currentState) {
             }
         );
     }
+
+    /**
+     * Validates that if we are trying to update search replica count the index is segrep enabled.
+     *
+     * @param requestSettings {@link Settings}
+     * @param indices indices that are changing
+     * @param currentState {@link ClusterState} current cluster state
+     */
+    private void validateSearchReplicaCountSettings(Settings requestSettings, Index[] indices, ClusterState currentState) {
+        final int updatedNumberOfSearchReplicas = IndexMetadata.INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING.get(requestSettings);
+        if (updatedNumberOfSearchReplicas > 0) {
+            if (Arrays.stream(indices).allMatch(index -> currentState.metadata().isSegmentReplicationEnabled(index.getName())) == false) {
+                throw new IllegalArgumentException(
+                    "To set "
+                        + SETTING_NUMBER_OF_SEARCH_REPLICAS
+                        + ", "
+                        + INDEX_REPLICATION_TYPE_SETTING.getKey()
+                        + " must be set to "
+                        + ReplicationType.SEGMENT
+                );
+            }
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/QueryGroup.java b/server/src/main/java/org/opensearch/cluster/metadata/QueryGroup.java
new file mode 100644
index 0000000000000..dcd96dceb4bf1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/metadata/QueryGroup.java
@@ -0,0 +1,274 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.cluster.AbstractDiffable;
+import org.opensearch.cluster.Diff;
+import org.opensearch.common.UUIDs;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.wlm.MutableQueryGroupFragment;
+import org.opensearch.wlm.MutableQueryGroupFragment.ResiliencyMode;
+import org.opensearch.wlm.ResourceType;
+import org.joda.time.Instant;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Class to define the QueryGroup schema
+ * {
+ *              "_id": "fafjafjkaf9ag8a9ga9g7ag0aagaga",
+ *              "resource_limits": {
+ *                  "memory": 0.4,
+ *                  "cpu": 0.2
+ *              },
+ *              "resiliency_mode": "enforced",
+ *              "name": "analytics",
+ *              "updated_at": 4513232415
+ * }
+ */
+@ExperimentalApi
+public class QueryGroup extends AbstractDiffable<QueryGroup> implements ToXContentObject {
+
+    public static final String _ID_STRING = "_id";
+    public static final String NAME_STRING = "name";
+    public static final String UPDATED_AT_STRING = "updated_at";
+    private static final int MAX_CHARS_ALLOWED_IN_NAME = 50;
+    private final String name;
+    private final String _id;
+    // It is an epoch in millis
+    private final long updatedAtInMillis;
+    private final MutableQueryGroupFragment mutableQueryGroupFragment;
+
+    public QueryGroup(String name, MutableQueryGroupFragment mutableQueryGroupFragment) {
+        this(name, UUIDs.randomBase64UUID(), mutableQueryGroupFragment, Instant.now().getMillis());
+    }
+
+    public QueryGroup(String name, String _id, MutableQueryGroupFragment mutableQueryGroupFragment, long updatedAt) {
+        Objects.requireNonNull(name, "QueryGroup.name can't be null");
+        Objects.requireNonNull(mutableQueryGroupFragment.getResourceLimits(), "QueryGroup.resourceLimits can't be null");
+        Objects.requireNonNull(mutableQueryGroupFragment.getResiliencyMode(), "QueryGroup.resiliencyMode can't be null");
+        Objects.requireNonNull(_id, "QueryGroup._id can't be null");
+        validateName(name);
+
+        if (mutableQueryGroupFragment.getResourceLimits().isEmpty()) {
+            throw new IllegalArgumentException("QueryGroup.resourceLimits should at least have 1 resource limit");
+        }
+        if (!isValid(updatedAt)) {
+            throw new IllegalArgumentException("QueryGroup.updatedAtInMillis is not a valid epoch");
+        }
+
+        this.name = name;
+        this._id = _id;
+        this.mutableQueryGroupFragment = mutableQueryGroupFragment;
+        this.updatedAtInMillis = updatedAt;
+    }
+
+    public static boolean isValid(long updatedAt) {
+        long minValidTimestamp = Instant.ofEpochMilli(0L).getMillis();
+
+        // Use Instant.now() to get the current time in seconds since epoch
+        long currentSeconds = Instant.now().getMillis();
+
+        // Check if the timestamp is within a reasonable range
+        return minValidTimestamp <= updatedAt && updatedAt <= currentSeconds;
+    }
+
+    public QueryGroup(StreamInput in) throws IOException {
+        this(in.readString(), in.readString(), new MutableQueryGroupFragment(in), in.readLong());
+    }
+
+    public static QueryGroup updateExistingQueryGroup(QueryGroup existingGroup, MutableQueryGroupFragment mutableQueryGroupFragment) {
+        final Map<ResourceType, Double> updatedResourceLimits = new HashMap<>(existingGroup.getResourceLimits());
+        final Map<ResourceType, Double> mutableFragmentResourceLimits = mutableQueryGroupFragment.getResourceLimits();
+        if (mutableFragmentResourceLimits != null && !mutableFragmentResourceLimits.isEmpty()) {
+            updatedResourceLimits.putAll(mutableFragmentResourceLimits);
+        }
+        final ResiliencyMode mode = Optional.ofNullable(mutableQueryGroupFragment.getResiliencyMode())
+            .orElse(existingGroup.getResiliencyMode());
+        return new QueryGroup(
+            existingGroup.getName(),
+            existingGroup.get_id(),
+            new MutableQueryGroupFragment(mode, updatedResourceLimits),
+            Instant.now().getMillis()
+        );
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(name);
+        out.writeString(_id);
+        mutableQueryGroupFragment.writeTo(out);
+        out.writeLong(updatedAtInMillis);
+    }
+
+    public static void validateName(String name) {
+        if (name == null || name.isEmpty() || name.length() > MAX_CHARS_ALLOWED_IN_NAME) {
+            throw new IllegalArgumentException("QueryGroup.name shouldn't be null, empty or more than 50 chars long");
+        }
+    }
+
+    @Override
+    public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
+        builder.startObject();
+        builder.field(_ID_STRING, _id);
+        builder.field(NAME_STRING, name);
+        for (String fieldName : MutableQueryGroupFragment.acceptedFieldNames) {
+            mutableQueryGroupFragment.writeField(builder, fieldName);
+        }
+        builder.field(UPDATED_AT_STRING, updatedAtInMillis);
+        builder.endObject();
+        return builder;
+    }
+
+    public static QueryGroup fromXContent(final XContentParser parser) throws IOException {
+        return Builder.fromXContent(parser).build();
+    }
+
+    public static Diff<QueryGroup> readDiff(final StreamInput in) throws IOException {
+        return readDiffFrom(QueryGroup::new, in);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        QueryGroup that = (QueryGroup) o;
+        return Objects.equals(name, that.name)
+            && Objects.equals(mutableQueryGroupFragment, that.mutableQueryGroupFragment)
+            && Objects.equals(_id, that._id)
+            && updatedAtInMillis == that.updatedAtInMillis;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, mutableQueryGroupFragment, updatedAtInMillis, _id);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public MutableQueryGroupFragment getMutableQueryGroupFragment() {
+        return mutableQueryGroupFragment;
+    }
+
+    public ResiliencyMode getResiliencyMode() {
+        return getMutableQueryGroupFragment().getResiliencyMode();
+    }
+
+    public Map<ResourceType, Double> getResourceLimits() {
+        return getMutableQueryGroupFragment().getResourceLimits();
+    }
+
+    public String get_id() {
+        return _id;
+    }
+
+    public long getUpdatedAtInMillis() {
+        return updatedAtInMillis;
+    }
+
+    /**
+     * builder method for the {@link QueryGroup}
+     * @return Builder object
+     */
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    /**
+     * Builder class for {@link QueryGroup}
+     */
+    @ExperimentalApi
+    public static class Builder {
+        private String name;
+        private String _id;
+        private MutableQueryGroupFragment mutableQueryGroupFragment;
+        private long updatedAt;
+
+        private Builder() {}
+
+        public static Builder fromXContent(XContentParser parser) throws IOException {
+            if (parser.currentToken() == null) { // fresh parser? move to the first token
+                parser.nextToken();
+            }
+
+            Builder builder = builder();
+
+            XContentParser.Token token = parser.currentToken();
+
+            if (token != XContentParser.Token.START_OBJECT) {
+                throw new IllegalArgumentException("Expected START_OBJECT token but found [" + parser.currentName() + "]");
+            }
+
+            String fieldName = "";
+            MutableQueryGroupFragment mutableQueryGroupFragment1 = new MutableQueryGroupFragment();
+            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                if (token == XContentParser.Token.FIELD_NAME) {
+                    fieldName = parser.currentName();
+                } else if (token.isValue()) {
+                    if (fieldName.equals(_ID_STRING)) {
+                        builder._id(parser.text());
+                    } else if (fieldName.equals(NAME_STRING)) {
+                        builder.name(parser.text());
+                    } else if (MutableQueryGroupFragment.shouldParse(fieldName)) {
+                        mutableQueryGroupFragment1.parseField(parser, fieldName);
+                    } else if (fieldName.equals(UPDATED_AT_STRING)) {
+                        builder.updatedAt(parser.longValue());
+                    } else {
+                        throw new IllegalArgumentException(fieldName + " is not a valid field in QueryGroup");
+                    }
+                } else if (token == XContentParser.Token.START_OBJECT) {
+                    if (!MutableQueryGroupFragment.shouldParse(fieldName)) {
+                        throw new IllegalArgumentException(fieldName + " is not a valid object in QueryGroup");
+                    }
+                    mutableQueryGroupFragment1.parseField(parser, fieldName);
+                }
+            }
+            return builder.mutableQueryGroupFragment(mutableQueryGroupFragment1);
+        }
+
+        public Builder name(String name) {
+            this.name = name;
+            return this;
+        }
+
+        public Builder _id(String _id) {
+            this._id = _id;
+            return this;
+        }
+
+        public Builder mutableQueryGroupFragment(MutableQueryGroupFragment mutableQueryGroupFragment) {
+            this.mutableQueryGroupFragment = mutableQueryGroupFragment;
+            return this;
+        }
+
+        public Builder updatedAt(long updatedAt) {
+            this.updatedAt = updatedAt;
+            return this;
+        }
+
+        public QueryGroup build() {
+            return new QueryGroup(name, _id, mutableQueryGroupFragment, updatedAt);
+        }
+
+        public MutableQueryGroupFragment getMutableQueryGroupFragment() {
+            return mutableQueryGroupFragment;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/QueryGroupMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/QueryGroupMetadata.java
new file mode 100644
index 0000000000000..f74b8beed7835
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/metadata/QueryGroupMetadata.java
@@ -0,0 +1,185 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.DiffableUtils;
+import org.opensearch.cluster.NamedDiff;
+import org.opensearch.core.ParseField;
+import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.opensearch.cluster.metadata.Metadata.ALL_CONTEXTS;
+
+/**
+ * This class holds the QueryGroupMetadata
+ * sample schema
+ * {
+ *     "queryGroups": {
+ *         "_id": {
+ *             {@link QueryGroup}
+ *         },
+ *        ...
+ *     }
+ * }
+ */
+public class QueryGroupMetadata implements Metadata.Custom {
+    public static final String TYPE = "queryGroups";
+    private static final ParseField QUERY_GROUP_FIELD = new ParseField("queryGroups");
+
+    private final Map<String, QueryGroup> queryGroups;
+
+    public QueryGroupMetadata(Map<String, QueryGroup> queryGroups) {
+        this.queryGroups = queryGroups;
+    }
+
+    public QueryGroupMetadata(StreamInput in) throws IOException {
+        this.queryGroups = in.readMap(StreamInput::readString, QueryGroup::new);
+    }
+
+    public Map<String, QueryGroup> queryGroups() {
+        return this.queryGroups;
+    }
+
+    /**
+     * Returns the name of the writeable object
+     */
+    @Override
+    public String getWriteableName() {
+        return TYPE;
+    }
+
+    /**
+     * The minimal version of the recipient this object can be sent to
+     */
+    @Override
+    public Version getMinimalSupportedVersion() {
+        return Version.CURRENT.minimumCompatibilityVersion();
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeMap(queryGroups, StreamOutput::writeString, (stream, val) -> val.writeTo(stream));
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        for (Map.Entry<String, QueryGroup> entry : queryGroups.entrySet()) {
+            builder.field(entry.getKey(), entry.getValue());
+        }
+        return builder;
+    }
+
+    public static QueryGroupMetadata fromXContent(XContentParser parser) throws IOException {
+        Map<String, QueryGroup> queryGroupMap = new HashMap<>();
+
+        if (parser.currentToken() == null) {
+            parser.nextToken();
+        }
+
+        if (parser.currentToken() != XContentParser.Token.START_OBJECT) {
+            throw new IllegalArgumentException(
+                "QueryGroupMetadata.fromXContent was expecting a { token but found : " + parser.currentToken()
+            );
+        }
+        XContentParser.Token token = parser.currentToken();
+        String fieldName = parser.currentName();
+        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+            if (token == XContentParser.Token.FIELD_NAME) {
+                fieldName = parser.currentName();
+            } else {
+                QueryGroup queryGroup = QueryGroup.fromXContent(parser);
+                queryGroupMap.put(fieldName, queryGroup);
+            }
+        }
+
+        return new QueryGroupMetadata(queryGroupMap);
+    }
+
+    @Override
+    public Diff<Metadata.Custom> diff(final Metadata.Custom previousState) {
+        return new QueryGroupMetadataDiff((QueryGroupMetadata) previousState, this);
+    }
+
+    public static NamedDiff<Metadata.Custom> readDiffFrom(StreamInput in) throws IOException {
+        return new QueryGroupMetadataDiff(in);
+    }
+
+    @Override
+    public EnumSet<Metadata.XContentContext> context() {
+        return ALL_CONTEXTS;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        QueryGroupMetadata that = (QueryGroupMetadata) o;
+        return Objects.equals(queryGroups, that.queryGroups);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(queryGroups);
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(MediaTypeRegistry.JSON, this);
+    }
+
+    /**
+     * QueryGroupMetadataDiff
+     */
+    static class QueryGroupMetadataDiff implements NamedDiff<Metadata.Custom> {
+        final Diff<Map<String, QueryGroup>> dataStreamDiff;
+
+        QueryGroupMetadataDiff(final QueryGroupMetadata before, final QueryGroupMetadata after) {
+            dataStreamDiff = DiffableUtils.diff(before.queryGroups, after.queryGroups, DiffableUtils.getStringKeySerializer());
+        }
+
+        QueryGroupMetadataDiff(final StreamInput in) throws IOException {
+            this.dataStreamDiff = DiffableUtils.readJdkMapDiff(
+                in,
+                DiffableUtils.getStringKeySerializer(),
+                QueryGroup::new,
+                QueryGroup::readDiff
+            );
+        }
+
+        /**
+         * Returns the name of the writeable object
+         */
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            dataStreamDiff.writeTo(out);
+        }
+
+        @Override
+        public Metadata.Custom apply(Metadata.Custom part) {
+            return new QueryGroupMetadata(new HashMap<>(dataStreamDiff.apply(((QueryGroupMetadata) part).queryGroups)));
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/RepositoriesMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/RepositoriesMetadata.java
index e3689d046193c..59452e33191d7 100644
--- a/server/src/main/java/org/opensearch/cluster/metadata/RepositoriesMetadata.java
+++ b/server/src/main/java/org/opensearch/cluster/metadata/RepositoriesMetadata.java
@@ -51,8 +51,10 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.List;
+import java.util.stream.Collectors;
 
 import static org.opensearch.repositories.blobstore.BlobStoreRepository.SYSTEM_REPOSITORY_SETTING;
 
@@ -164,6 +166,58 @@ public boolean equalsIgnoreGenerations(@Nullable RepositoriesMetadata other) {
         return true;
     }
 
+    /**
+     * Checks if this instance and the give instance share the same repositories, with option to skip checking for a list of repos.
+     * This will support
+     * @param other other repositories metadata
+     * @param reposToSkip list of repos to skip check for equality
+     * @return {@code true} iff both instances contain the same repositories apart from differences in generations, not including repos provided in reposToSkip.
+     */
+    public boolean equalsIgnoreGenerationsWithRepoSkip(@Nullable RepositoriesMetadata other, List<String> reposToSkip) {
+        if (other == null) {
+            return false;
+        }
+        List<RepositoryMetadata> currentRepositories = repositories.stream()
+            .filter(repo -> !reposToSkip.contains(repo.name()))
+            .collect(Collectors.toList());
+        List<RepositoryMetadata> otherRepositories = other.repositories.stream()
+            .filter(repo -> !reposToSkip.contains(repo.name()))
+            .collect(Collectors.toList());
+
+        return equalsRepository(currentRepositories, otherRepositories);
+    }
+
+    public boolean equalsIgnoreGenerationsForRepo(@Nullable RepositoriesMetadata other, List<String> reposToValidate) {
+        if (other == null) {
+            return false;
+        }
+        List<RepositoryMetadata> currentRepositories = repositories.stream()
+            .filter(repo -> reposToValidate.contains(repo.name()))
+            .collect(Collectors.toList());
+        List<RepositoryMetadata> otherRepositories = other.repositories.stream()
+            .filter(repo -> reposToValidate.contains(repo.name()))
+            .collect(Collectors.toList());
+
+        return equalsRepository(currentRepositories, otherRepositories);
+    }
+
+    public static boolean equalsRepository(List<RepositoryMetadata> currentRepositories, List<RepositoryMetadata> otherRepositories) {
+        if (otherRepositories.size() != currentRepositories.size()) {
+            return false;
+        }
+        // Sort repos by name for ordered comparison
+        Comparator<RepositoryMetadata> compareByName = (o1, o2) -> o1.name().compareTo(o2.name());
+        currentRepositories.sort(compareByName);
+        otherRepositories.sort(compareByName);
+
+        for (int i = 0; i < currentRepositories.size(); i++) {
+            if (currentRepositories.get(i).equalsIgnoreGenerations(otherRepositories.get(i)) == false) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     @Override
     public int hashCode() {
         return repositories.hashCode();
@@ -202,6 +256,10 @@ public static RepositoriesMetadata fromXContent(XContentParser parser) throws IO
         XContentParser.Token token;
         List<RepositoryMetadata> repository = new ArrayList<>();
         while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+            if (token == XContentParser.Token.START_OBJECT) {
+                // move to next token if parsing the whole object
+                token = parser.nextToken();
+            }
             if (token == XContentParser.Token.FIELD_NAME) {
                 String name = parser.currentName();
                 if (parser.nextToken() != XContentParser.Token.START_OBJECT) {
diff --git a/server/src/main/java/org/opensearch/cluster/metadata/TemplatesMetadata.java b/server/src/main/java/org/opensearch/cluster/metadata/TemplatesMetadata.java
new file mode 100644
index 0000000000000..c337ba72de9fa
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/metadata/TemplatesMetadata.java
@@ -0,0 +1,159 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.cluster.AbstractDiffable;
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Metadata for legacy templates
+ *
+ * @opensearch.api
+ */
+@PublicApi(since = "2.15.0")
+public class TemplatesMetadata extends AbstractDiffable<TemplatesMetadata> implements ToXContentFragment {
+    public static TemplatesMetadata EMPTY_METADATA = builder().build();
+    private final Map<String, IndexTemplateMetadata> templates;
+
+    public TemplatesMetadata() {
+        this(Collections.emptyMap());
+    }
+
+    public TemplatesMetadata(Map<String, IndexTemplateMetadata> templates) {
+        this.templates = Collections.unmodifiableMap(templates);
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public Map<String, IndexTemplateMetadata> getTemplates() {
+        return this.templates;
+    }
+
+    public static TemplatesMetadata fromXContent(XContentParser parser) throws IOException {
+        return Builder.fromXContent(parser);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        Builder.toXContent(this, builder, params);
+        return builder;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeVInt(templates.size());
+        for (final IndexTemplateMetadata cursor : templates.values()) {
+            cursor.writeTo(out);
+        }
+    }
+
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        out.writeMapValues(templates, (stream, value) -> value.writeVerifiableTo((BufferedChecksumStreamOutput) stream));
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        TemplatesMetadata that = (TemplatesMetadata) o;
+
+        return Objects.equals(templates, that.templates);
+    }
+
+    @Override
+    public int hashCode() {
+        return templates != null ? templates.hashCode() : 0;
+    }
+
+    @Override
+    public String toString() {
+        return "TemplatesMetadata{" + "templates=" + templates + '}';
+    }
+
+    /**
+     * Builder for the templates metadata
+     *
+     * @opensearch.api
+     */
+    @PublicApi(since = "2.15.0")
+    public static class Builder {
+        private final Map<String, IndexTemplateMetadata> templates;
+
+        public Builder() {
+            this.templates = new HashMap<String, IndexTemplateMetadata>();
+        }
+
+        public Builder(Map<String, IndexTemplateMetadata> templates) {
+            this.templates = templates;
+        }
+
+        public Builder put(IndexTemplateMetadata.Builder templateBuilder) {
+            return put(templateBuilder.build());
+        }
+
+        public Builder put(IndexTemplateMetadata template) {
+            templates.put(template.name(), template);
+            return this;
+        }
+
+        public Builder removeTemplate(String templateName) {
+            templates.remove(templateName);
+            return this;
+        }
+
+        public Builder templates(Map<String, IndexTemplateMetadata> templates) {
+            this.templates.putAll(templates);
+            return this;
+        }
+
+        public TemplatesMetadata build() {
+            return new TemplatesMetadata(templates);
+        }
+
+        public static void toXContent(TemplatesMetadata templatesMetadata, XContentBuilder builder, Params params) throws IOException {
+            for (IndexTemplateMetadata cursor : templatesMetadata.getTemplates().values()) {
+                IndexTemplateMetadata.Builder.toXContentWithTypes(cursor, builder, params);
+            }
+        }
+
+        public static TemplatesMetadata fromXContent(XContentParser parser) throws IOException {
+            Builder builder = new Builder();
+
+            XContentParser.Token token = parser.currentToken();
+            String currentFieldName = parser.currentName();
+            if (currentFieldName == null) {
+                token = parser.nextToken();
+            }
+            if (token == XContentParser.Token.START_OBJECT) {
+                // move to the field name
+                token = parser.nextToken();
+            }
+            if (parser.currentName() != null && token != XContentParser.Token.END_OBJECT) {
+                do {
+                    builder.put(IndexTemplateMetadata.Builder.fromXContent(parser, parser.currentName()));
+                } while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT);
+            }
+            return builder.build();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
index 93d6f6b0e4d22..9e9802b1409c2 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNode.java
@@ -44,6 +44,7 @@
 import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 import org.opensearch.node.Node;
 
 import java.io.IOException;
@@ -63,7 +64,10 @@
 import java.util.stream.Stream;
 
 import static org.opensearch.node.NodeRoleSettings.NODE_ROLES_SETTING;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_NODE_ATTRIBUTE_KEY_PREFIX;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 
 /**
  * A discovery node represents a node that is part of the cluster.
@@ -130,6 +134,10 @@ public static boolean isSearchNode(Settings settings) {
         return hasRole(settings, DiscoveryNodeRole.SEARCH_ROLE);
     }
 
+    public static boolean isDedicatedSearchNode(Settings settings) {
+        return getRolesFromSettings(settings).stream().allMatch(DiscoveryNodeRole.SEARCH_ROLE::equals);
+    }
+
     private final String nodeName;
     private final String nodeId;
     private final String ephemeralId;
@@ -379,17 +387,47 @@ public DiscoveryNode(StreamInput in) throws IOException {
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            writeToUtil(out, false);
+        } else {
+            writeToUtil(out, true);
+        }
+    }
+
+    public void writeToWithAttribute(StreamOutput out) throws IOException {
+        writeToUtil(out, true);
+    }
+
+    public void writeToUtil(StreamOutput out, boolean includeAllAttributes) throws IOException {
+        writeNodeDetails(out);
+        if (includeAllAttributes) {
+            out.writeVInt(attributes.size());
+            for (Map.Entry<String, String> entry : attributes.entrySet()) {
+                out.writeString(entry.getKey());
+                out.writeString(entry.getValue());
+            }
+        } else {
+            out.writeVInt(0);
+        }
+        writeRolesAndVersion(out);
+    }
+
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        writeNodeDetails(out);
+        out.writeMap(attributes, StreamOutput::writeString, StreamOutput::writeString);
+        writeRolesAndVersion(out);
+    }
+
+    private void writeNodeDetails(StreamOutput out) throws IOException {
         out.writeString(nodeName);
         out.writeString(nodeId);
         out.writeString(ephemeralId);
         out.writeString(hostName);
         out.writeString(hostAddress);
         address.writeTo(out);
-        out.writeVInt(attributes.size());
-        for (Map.Entry<String, String> entry : attributes.entrySet()) {
-            out.writeString(entry.getKey());
-            out.writeString(entry.getValue());
-        }
+    }
+
+    private void writeRolesAndVersion(StreamOutput out) throws IOException {
         if (out.getVersion().onOrAfter(LegacyESVersion.V_7_3_0)) {
             out.writeVInt(roles.size());
             for (final DiscoveryNodeRole role : roles) {
@@ -517,7 +555,20 @@ public boolean isSearchNode() {
      * @return true if the node contains remote store node attributes, false otherwise
      */
     public boolean isRemoteStoreNode() {
-        return this.getAttributes().keySet().stream().anyMatch(key -> key.startsWith(REMOTE_STORE_NODE_ATTRIBUTE_KEY_PREFIX));
+        return this.getAttributes().keySet().stream().anyMatch(key -> key.equals(REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY))
+            && this.getAttributes().keySet().stream().anyMatch(key -> key.equals(REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY));
+    }
+
+    /**
+     * Returns whether remote cluster state publication is enabled on this node
+     * @return true if the node contains remote cluster state node attribute and remote routing table node attribute
+     */
+    public boolean isRemoteStatePublicationEnabled() {
+        return this.getAttributes()
+            .keySet()
+            .stream()
+            .anyMatch(key -> (key.equals(REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY)))
+            && this.getAttributes().keySet().stream().anyMatch(key -> key.equals(REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY));
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
index 203d45c3318c3..099d7559e1dce 100644
--- a/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/node/DiscoveryNodes.java
@@ -45,6 +45,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.transport.TransportAddress;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -701,16 +702,66 @@ public String shortSummary() {
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
+        writeToUtil((output, value) -> value.writeTo(output), out);
+    }
+
+    public void writeToWithAttribute(StreamOutput out) throws IOException {
+        writeToUtil((output, value) -> value.writeToWithAttribute(output), out);
+    }
+
+    private void writeToUtil(final Writer<DiscoveryNode> writer, StreamOutput out) throws IOException {
+        writeClusterManager(out);
+        out.writeVInt(nodes.size());
+        for (DiscoveryNode node : this) {
+            writer.write(out, node);
+        }
+    }
+
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        writeClusterManager(out);
+        out.writeMapValues(nodes, (stream, val) -> val.writeVerifiableTo((BufferedChecksumStreamOutput) stream));
+    }
+
+    private void writeClusterManager(StreamOutput out) throws IOException {
         if (clusterManagerNodeId == null) {
             out.writeBoolean(false);
         } else {
             out.writeBoolean(true);
             out.writeString(clusterManagerNodeId);
         }
-        out.writeVInt(nodes.size());
-        for (DiscoveryNode node : this) {
-            node.writeTo(out);
-        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        DiscoveryNodes that = (DiscoveryNodes) o;
+        return Objects.equals(nodes, that.nodes)
+            && Objects.equals(dataNodes, that.dataNodes)
+            && Objects.equals(clusterManagerNodes, that.clusterManagerNodes)
+            && Objects.equals(ingestNodes, that.ingestNodes)
+            && Objects.equals(clusterManagerNodeId, that.clusterManagerNodeId)
+            && Objects.equals(localNodeId, that.localNodeId)
+            && Objects.equals(minNonClientNodeVersion, that.minNonClientNodeVersion)
+            && Objects.equals(maxNonClientNodeVersion, that.maxNonClientNodeVersion)
+            && Objects.equals(maxNodeVersion, that.maxNodeVersion)
+            && Objects.equals(minNodeVersion, that.minNodeVersion);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+            nodes,
+            dataNodes,
+            clusterManagerNodes,
+            ingestNodes,
+            clusterManagerNodeId,
+            localNodeId,
+            minNonClientNodeVersion,
+            maxNonClientNodeVersion,
+            maxNodeVersion,
+            minNodeVersion
+        );
     }
 
     public static DiscoveryNodes readFrom(StreamInput in, DiscoveryNode localNode) throws IOException {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
index 7c179f6d4d8fd..b72acc3b46bbb 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexRoutingTable.java
@@ -49,6 +49,7 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -139,7 +140,7 @@ boolean validate(Metadata metadata) {
         // check the replicas
         for (IndexShardRoutingTable indexShardRoutingTable : this) {
             int routingNumberOfReplicas = indexShardRoutingTable.size() - 1;
-            if (routingNumberOfReplicas != indexMetadata.getNumberOfReplicas()) {
+            if (routingNumberOfReplicas != indexMetadata.getNumberOfReplicas() + indexMetadata.getNumberOfSearchOnlyReplicas()) {
                 throw new IllegalStateException(
                     "Shard ["
                         + indexShardRoutingTable.shardId().id()
@@ -157,7 +158,9 @@ boolean validate(Metadata metadata) {
                     );
                 }
                 final Set<String> inSyncAllocationIds = indexMetadata.inSyncAllocationIds(shardRouting.id());
-                if (shardRouting.active() && inSyncAllocationIds.contains(shardRouting.allocationId().getId()) == false) {
+                if (shardRouting.active()
+                    && inSyncAllocationIds.contains(shardRouting.allocationId().getId()) == false
+                    && shardRouting.isSearchOnly() == false) {
                     throw new IllegalStateException(
                         "active shard routing "
                             + shardRouting
@@ -351,6 +354,11 @@ public int hashCode() {
         return result;
     }
 
+    @Override
+    public String toString() {
+        return "IndexRoutingTable{" + "shards=" + shards + ", index=" + index + '}';
+    }
+
     public static IndexRoutingTable readFrom(StreamInput in) throws IOException {
         Index index = new Index(in);
         Builder builder = new Builder(index);
@@ -376,6 +384,14 @@ public void writeTo(StreamOutput out) throws IOException {
         }
     }
 
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        index.writeTo(out);
+        out.writeMapValues(
+            shards,
+            (stream, value) -> IndexShardRoutingTable.Builder.writeVerifiableTo(value, (BufferedChecksumStreamOutput) stream)
+        );
+    }
+
     public static Builder builder(Index index) {
         return new Builder(index);
     }
@@ -594,6 +610,17 @@ private Builder initializeEmpty(IndexMetadata indexMetadata, UnassignedInfo unas
                         )
                     );
                 }
+                for (int i = 0; i < indexMetadata.getNumberOfSearchOnlyReplicas(); i++) {
+                    indexShardRoutingBuilder.addShard(
+                        ShardRouting.newUnassigned(
+                            shardId,
+                            false,
+                            true,
+                            PeerRecoverySource.INSTANCE, // TODO: Update to remote store if enabled
+                            unassignedInfo
+                        )
+                    );
+                }
                 shards.put(shardNumber, indexShardRoutingBuilder.build());
             }
             return this;
@@ -614,6 +641,26 @@ public Builder addReplica() {
             return this;
         }
 
+        /**
+         * Add a Search only replica to the IndexShardRoutingTable
+         * @return The Builder
+         */
+        public Builder addSearchReplica() {
+            for (final int shardNumber : shards.keySet()) {
+                ShardId shardId = new ShardId(index, shardNumber);
+                // version 0, will get updated when reroute will happen
+                ShardRouting shard = ShardRouting.newUnassigned(
+                    shardId,
+                    false,
+                    true,
+                    PeerRecoverySource.INSTANCE, // TODO: Change to remote store if enabled
+                    new UnassignedInfo(UnassignedInfo.Reason.REPLICA_ADDED, null)
+                );
+                shards.put(shardNumber, new IndexShardRoutingTable.Builder(shards.get(shard.id())).addShard(shard).build());
+            }
+            return this;
+        }
+
         public Builder removeReplica() {
             for (final int shardId : shards.keySet()) {
                 IndexShardRoutingTable indexShard = shards.get(shardId);
@@ -629,7 +676,7 @@ public Builder removeReplica() {
                 // first check if there is one that is not assigned to a node, and remove it
                 boolean removed = false;
                 for (ShardRouting shardRouting : indexShard) {
-                    if (!shardRouting.primary() && !shardRouting.assignedToNode()) {
+                    if (!shardRouting.primary() && !shardRouting.assignedToNode() && !shardRouting.isSearchOnly()) {
                         builder.removeShard(shardRouting);
                         removed = true;
                         break;
@@ -637,7 +684,45 @@ public Builder removeReplica() {
                 }
                 if (!removed) {
                     for (ShardRouting shardRouting : indexShard) {
-                        if (!shardRouting.primary()) {
+                        if (!shardRouting.primary() && !shardRouting.isSearchOnly()) {
+                            builder.removeShard(shardRouting);
+                            break;
+                        }
+                    }
+                }
+                shards.put(shardId, builder.build());
+            }
+            return this;
+        }
+
+        /**
+         * Remove a Search only replica from the IndexShardRoutingTable
+         * @return The Builder
+         */
+        public Builder removeSearchReplica() {
+            for (final int shardId : shards.keySet()) {
+                IndexShardRoutingTable indexShardRoutingTable = shards.get(shardId);
+                if (indexShardRoutingTable.searchOnlyReplicas().isEmpty()) {
+                    // nothing to do here!
+                    return this;
+                }
+                // re-add all the current ones
+                IndexShardRoutingTable.Builder builder = new IndexShardRoutingTable.Builder(indexShardRoutingTable.shardId());
+                for (ShardRouting shardRouting : indexShardRoutingTable) {
+                    builder.addShard(shardRouting);
+                }
+                // first check if there is one that is not assigned to a node, and remove it
+                boolean removed = false;
+                for (ShardRouting shardRouting : indexShardRoutingTable) {
+                    if (shardRouting.isSearchOnly() && !shardRouting.assignedToNode()) {
+                        builder.removeShard(shardRouting);
+                        removed = true;
+                        break;
+                    }
+                }
+                if (!removed) {
+                    for (ShardRouting shardRouting : indexShardRoutingTable) {
+                        if (shardRouting.isSearchOnly()) {
                             builder.removeShard(shardRouting);
                             break;
                         }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
index fd8cbea42c12f..e4ed65683c5eb 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/IndexShardRoutingTable.java
@@ -34,6 +34,9 @@
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.cluster.AbstractDiffable;
+import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.Nullable;
@@ -45,6 +48,7 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 import org.opensearch.node.ResponseCollectorService;
 
 import java.io.IOException;
@@ -60,6 +64,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
@@ -75,7 +80,7 @@
  * @opensearch.api
  */
 @PublicApi(since = "1.0.0")
-public class IndexShardRoutingTable implements Iterable<ShardRouting> {
+public class IndexShardRoutingTable extends AbstractDiffable<IndexShardRoutingTable> implements Iterable<ShardRouting> {
 
     final ShardShuffler shuffler;
     // Shuffler for weighted round-robin shard routing. This uses rotation to permute shards.
@@ -211,6 +216,24 @@ public List<ShardRouting> getShards() {
         return shards();
     }
 
+    /**
+     * Returns a {@link List} of the search only shards in the RoutingTable
+     *
+     * @return a {@link List} of shards
+     */
+    public List<ShardRouting> searchOnlyReplicas() {
+        return replicas.stream().filter(ShardRouting::isSearchOnly).collect(Collectors.toList());
+    }
+
+    /**
+     * Returns a {@link List} of the writer replicas (primary eligible) shards in the RoutingTable
+     *
+     * @return a {@link List} of shards
+     */
+    public List<ShardRouting> writerReplicas() {
+        return replicas.stream().filter(r -> r.isSearchOnly() == false).collect(Collectors.toList());
+    }
+
     /**
      * Returns a {@link List} of active shards
      *
@@ -527,6 +550,12 @@ private static List<ShardRouting> rankShardsAndUpdateStats(
         return sortedShards;
     }
 
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        this.shardId().getIndex().writeTo(out);
+        Builder.writeToThin(this, out);
+    }
+
     private static class NodeRankComparator implements Comparator<ShardRouting> {
         private final Map<String, Double> nodeRanks;
 
@@ -619,15 +648,11 @@ public ShardIterator replicaActiveInitializingShardIt() {
             return new PlainShardIterator(shardId, Collections.emptyList());
         }
 
-        LinkedList<ShardRouting> ordered = new LinkedList<>();
-        for (ShardRouting replica : shuffler.shuffle(replicas)) {
-            if (replica.active()) {
-                ordered.addFirst(replica);
-            } else if (replica.initializing()) {
-                ordered.addLast(replica);
-            }
-        }
-        return new PlainShardIterator(shardId, ordered);
+        return filterAndOrderShards(replica -> true);
+    }
+
+    public ShardIterator searchReplicaActiveInitializingShardIt() {
+        return filterAndOrderShards(ShardRouting::isSearchOnly);
     }
 
     /**
@@ -658,6 +683,20 @@ public ShardIterator replicaFirstActiveInitializingShardsIt() {
         return new PlainShardIterator(shardId, ordered);
     }
 
+    private ShardIterator filterAndOrderShards(Predicate<ShardRouting> filter) {
+        LinkedList<ShardRouting> ordered = new LinkedList<>();
+        for (ShardRouting replica : shuffler.shuffle(replicas)) {
+            if (filter.test(replica)) {
+                if (replica.active()) {
+                    ordered.addFirst(replica);
+                } else if (replica.initializing()) {
+                    ordered.addLast(replica);
+                }
+            }
+        }
+        return new PlainShardIterator(shardId, ordered);
+    }
+
     /**
      * Returns an iterator on active and initializing shards residing on the provided nodeId.
      */
@@ -738,9 +777,7 @@ public boolean equals(Object o) {
         IndexShardRoutingTable that = (IndexShardRoutingTable) o;
 
         if (!shardId.equals(that.shardId)) return false;
-        if (!shards.equals(that.shards)) return false;
-
-        return true;
+        return shards.size() == that.shards.size() && shards.containsAll(that.shards) && that.shards.containsAll(shards);
     }
 
     @Override
@@ -1051,6 +1088,14 @@ private void populateInitializingShardWeightsMap(WeightedRouting weightedRouting
         }
     }
 
+    public static IndexShardRoutingTable readFrom(StreamInput in) throws IOException {
+        return IndexShardRoutingTable.Builder.readFrom(in);
+    }
+
+    public static Diff<IndexShardRoutingTable> readDiffFrom(StreamInput in) throws IOException {
+        return readDiffFrom(IndexShardRoutingTable::readFrom, in);
+    }
+
     /**
      * Builder of an index shard routing table.
      *
@@ -1137,6 +1182,27 @@ public static void writeToThin(IndexShardRoutingTable indexShard, StreamOutput o
             }
         }
 
+        public static void writeVerifiableTo(IndexShardRoutingTable indexShard, BufferedChecksumStreamOutput out) throws IOException {
+            out.writeVInt(indexShard.shardId.id());
+            out.writeVInt(indexShard.shards.size());
+            // Order allocated shards by allocationId
+            AtomicInteger assignedShardCount = new AtomicInteger();
+            indexShard.shards.stream()
+                .filter(shardRouting -> shardRouting.allocationId() != null)
+                .sorted(Comparator.comparing(o -> o.allocationId().getId()))
+                .forEach(shardRouting -> {
+                    try {
+                        assignedShardCount.getAndIncrement();
+                        shardRouting.writeToThin(out);
+                    } catch (IOException e) {
+                        logger.error(() -> new ParameterizedMessage("Failed to write shard {}. Exception {}", indexShard, e));
+                        throw new RuntimeException("Failed to write IndexShardRoutingTable", e);
+                    }
+                });
+            // is primary assigned
+            out.writeBoolean(indexShard.primaryShard().allocationId() != null);
+            out.writeVInt(indexShard.shards.size() - assignedShardCount.get());
+        }
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/cluster/routing/OperationRouting.java b/server/src/main/java/org/opensearch/cluster/routing/OperationRouting.java
index 42aad8028f231..0127c50b376c1 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/OperationRouting.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/OperationRouting.java
@@ -42,6 +42,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexModule;
@@ -120,6 +121,7 @@ public class OperationRouting {
     private volatile boolean isFailOpenEnabled;
     private volatile boolean isStrictWeightedShardRouting;
     private volatile boolean ignoreWeightedRouting;
+    private final boolean isReaderWriterSplitEnabled;
 
     public OperationRouting(Settings settings, ClusterSettings clusterSettings) {
         // whether to ignore awareness attributes when routing requests
@@ -140,6 +142,7 @@ public OperationRouting(Settings settings, ClusterSettings clusterSettings) {
         clusterSettings.addSettingsUpdateConsumer(WEIGHTED_ROUTING_FAILOPEN_ENABLED, this::setFailOpenEnabled);
         clusterSettings.addSettingsUpdateConsumer(STRICT_WEIGHTED_SHARD_ROUTING_ENABLED, this::setStrictWeightedShardRouting);
         clusterSettings.addSettingsUpdateConsumer(IGNORE_WEIGHTED_SHARD_ROUTING, this::setIgnoreWeightedRouting);
+        this.isReaderWriterSplitEnabled = FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL_SETTING.get(settings);
     }
 
     void setUseAdaptiveReplicaSelection(boolean useAdaptiveReplicaSelection) {
@@ -242,12 +245,25 @@ public GroupShardsIterator<ShardIterator> searchShards(
         final Set<ShardIterator> set = new HashSet<>(shards.size());
         for (IndexShardRoutingTable shard : shards) {
             IndexMetadata indexMetadataForShard = indexMetadata(clusterState, shard.shardId.getIndex().getName());
-            if (IndexModule.Type.REMOTE_SNAPSHOT.match(
-                indexMetadataForShard.getSettings().get(IndexModule.INDEX_STORE_TYPE_SETTING.getKey())
-            ) && (preference == null || preference.isEmpty())) {
+            if (indexMetadataForShard.isRemoteSnapshot() && (preference == null || preference.isEmpty())) {
                 preference = Preference.PRIMARY.type();
             }
 
+            if (FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX)
+                && IndexModule.DataLocalityType.PARTIAL.name()
+                    .equals(indexMetadataForShard.getSettings().get(IndexModule.INDEX_STORE_LOCALITY_SETTING.getKey()))
+                && (preference == null || preference.isEmpty())) {
+                preference = Preference.PRIMARY_FIRST.type();
+            }
+
+            if (isReaderWriterSplitEnabled) {
+                if (preference == null || preference.isEmpty()) {
+                    if (indexMetadataForShard.getNumberOfSearchOnlyReplicas() > 0) {
+                        preference = Preference.SEARCH_REPLICA.type();
+                    }
+                }
+            }
+
             ShardIterator iterator = preferenceActiveShardIterator(
                 shard,
                 clusterState.nodes().getLocalNodeId(),
@@ -359,6 +375,8 @@ private ShardIterator preferenceActiveShardIterator(
                     return indexShard.primaryFirstActiveInitializingShardsIt();
                 case REPLICA_FIRST:
                     return indexShard.replicaFirstActiveInitializingShardsIt();
+                case SEARCH_REPLICA:
+                    return indexShard.searchReplicaActiveInitializingShardIt();
                 case ONLY_LOCAL:
                     return indexShard.onlyNodeActiveInitializingShardsIt(localNodeId);
                 case ONLY_NODES:
diff --git a/server/src/main/java/org/opensearch/cluster/routing/Preference.java b/server/src/main/java/org/opensearch/cluster/routing/Preference.java
index a1ea01afa118f..093e3d5fd45f8 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/Preference.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/Preference.java
@@ -73,6 +73,11 @@ public enum Preference {
      */
     REPLICA_FIRST("_replica_first"),
 
+    /**
+     * Route to search replica shards
+     */
+    SEARCH_REPLICA("_search_replica"),
+
     /**
      * Route to the local shard only
      */
@@ -127,6 +132,8 @@ public static Preference parse(String preference) {
                 return ONLY_LOCAL;
             case "_only_nodes":
                 return ONLY_NODES;
+            case "_search_replica":
+                return SEARCH_REPLICA;
             default:
                 throw new IllegalArgumentException("no Preference for [" + preferenceType + "]");
         }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
index 3926eb0be707b..884387b45e015 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingNodes.java
@@ -385,7 +385,7 @@ public ShardRouting activeReplicaWithHighestVersion(ShardId shardId) {
         // be accessible. Therefore, we need to protect against the version being null
         // (meaning the node will be going away).
         return assignedShards(shardId).stream()
-            .filter(shr -> !shr.primary() && shr.active())
+            .filter(shr -> !shr.primary() && shr.active() && !shr.isSearchOnly())
             .filter(shr -> node(shr.currentNodeId()) != null)
             .max(
                 Comparator.comparing(
@@ -409,7 +409,7 @@ public ShardRouting activeReplicaWithOldestVersion(ShardId shardId) {
         // It's possible for replicaNodeVersion to be null. Therefore, we need to protect against the version being null
         // (meaning the node will be going away).
         return assignedShards(shardId).stream()
-            .filter(shr -> !shr.primary() && shr.active())
+            .filter(shr -> !shr.primary() && shr.active() && !shr.isSearchOnly())
             .filter(shr -> node(shr.currentNodeId()) != null)
             .min(
                 Comparator.comparing(
@@ -428,7 +428,7 @@ public ShardRouting activeReplicaWithOldestVersion(ShardId shardId) {
      * are preferred for primary promotion
      */
     public ShardRouting activeReplicaOnRemoteNode(ShardId shardId) {
-        return assignedShards(shardId).stream().filter(shr -> !shr.primary() && shr.active()).filter((shr) -> {
+        return assignedShards(shardId).stream().filter(shr -> !shr.primary() && shr.active() && !shr.isSearchOnly()).filter((shr) -> {
             RoutingNode nd = node(shr.currentNodeId());
             return (nd != null && nd.node().isRemoteStoreNode());
         }).findFirst().orElse(null);
@@ -820,6 +820,7 @@ private ShardRouting cancelRelocation(ShardRouting shard) {
     private ShardRouting promoteActiveReplicaShardToPrimary(ShardRouting replicaShard) {
         assert replicaShard.active() : "non-active shard cannot be promoted to primary: " + replicaShard;
         assert replicaShard.primary() == false : "primary shard cannot be promoted to primary: " + replicaShard;
+        assert replicaShard.isSearchOnly() == false : "search only replica cannot be promoted to primary: " + replicaShard;
         ShardRouting primaryShard = replicaShard.moveActiveReplicaToPrimary();
         updateAssigned(replicaShard, primaryShard);
         return primaryShard;
@@ -1439,7 +1440,9 @@ public void remove() {
      */
     public Iterator<ShardRouting> nodeInterleavedShardIterator(ShardMovementStrategy shardMovementStrategy) {
         final Queue<Iterator<ShardRouting>> queue = new ArrayDeque<>();
-        for (Map.Entry<String, RoutingNode> entry : nodesToShards.entrySet()) {
+        List<Map.Entry<String, RoutingNode>> nodesToShardsEntrySet = new ArrayList<>(nodesToShards.entrySet());
+        Randomness.shuffle(nodesToShardsEntrySet);
+        for (Map.Entry<String, RoutingNode> entry : nodesToShardsEntrySet) {
             queue.add(entry.getValue().copyShards().iterator());
         }
         if (shardMovementStrategy == ShardMovementStrategy.PRIMARY_FIRST) {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingPool.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingPool.java
index a4ff237460e28..647e993339476 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingPool.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingPool.java
@@ -11,8 +11,9 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.index.IndexModule;
+import org.opensearch.common.util.FeatureFlags;
+
+import static org.opensearch.action.admin.indices.tiering.TieringUtils.isPartialIndex;
 
 /**
  *  {@link RoutingPool} defines the different node types based on the assigned capabilities. The methods
@@ -60,10 +61,7 @@ public static RoutingPool getShardPool(ShardRouting shard, RoutingAllocation all
      * @return {@link RoutingPool} for the given index.
      */
     public static RoutingPool getIndexPool(IndexMetadata indexMetadata) {
-        Settings indexSettings = indexMetadata.getSettings();
-        if (IndexModule.Type.REMOTE_SNAPSHOT.match(indexSettings.get(IndexModule.INDEX_STORE_TYPE_SETTING.getKey()))) {
-            return REMOTE_CAPABLE;
-        }
-        return LOCAL_ONLY;
+        return indexMetadata.isRemoteSnapshot()
+            || (FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX) && isPartialIndex(indexMetadata)) ? REMOTE_CAPABLE : LOCAL_ONLY;
     }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
index e4095a84be081..7dece5b4924ed 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTable.java
@@ -48,6 +48,7 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexNotFoundException;
 import org.opensearch.index.shard.ShardNotFoundException;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -79,7 +80,7 @@ public class RoutingTable implements Iterable<IndexRoutingTable>, Diffable<Routi
     // index to IndexRoutingTable map
     private final Map<String, IndexRoutingTable> indicesRouting;
 
-    private RoutingTable(long version, final Map<String, IndexRoutingTable> indicesRouting) {
+    public RoutingTable(long version, final Map<String, IndexRoutingTable> indicesRouting) {
         this.version = version;
         this.indicesRouting = Collections.unmodifiableMap(indicesRouting);
     }
@@ -378,6 +379,10 @@ public Diff<RoutingTable> diff(RoutingTable previousState) {
         return new RoutingTableDiff(previousState, this);
     }
 
+    public Diff<RoutingTable> incrementalDiff(RoutingTable previousState) {
+        return new RoutingTableIncrementalDiff(previousState, this);
+    }
+
     public static Diff<RoutingTable> readDiffFrom(StreamInput in) throws IOException {
         return new RoutingTableDiff(in);
     }
@@ -403,7 +408,12 @@ public void writeTo(StreamOutput out) throws IOException {
         }
     }
 
-    private static class RoutingTableDiff implements Diff<RoutingTable> {
+    public void writeVerifiableTo(BufferedChecksumStreamOutput out) throws IOException {
+        out.writeLong(version);
+        out.writeMapValues(indicesRouting, (stream, value) -> value.writeVerifiableTo((BufferedChecksumStreamOutput) stream));
+    }
+
+    private static class RoutingTableDiff implements Diff<RoutingTable>, StringKeyDiffProvider<IndexRoutingTable> {
 
         private final long version;
 
@@ -422,6 +432,11 @@ private static class RoutingTableDiff implements Diff<RoutingTable> {
             indicesRouting = DiffableUtils.readJdkMapDiff(in, DiffableUtils.getStringKeySerializer(), DIFF_VALUE_READER);
         }
 
+        @Override
+        public String toString() {
+            return "RoutingTableDiff{" + "version=" + version + ", indicesRouting=" + indicesRouting + '}';
+        }
+
         @Override
         public RoutingTable apply(RoutingTable part) {
             return new RoutingTable(version, indicesRouting.apply(part.indicesRouting));
@@ -432,6 +447,11 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeLong(version);
             indicesRouting.writeTo(out);
         }
+
+        @Override
+        public DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> provideDiff() {
+            return (DiffableUtils.MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>>) indicesRouting;
+        }
     }
 
     public static Builder builder() {
@@ -520,7 +540,7 @@ public Builder updateNumberOfReplicas(final int numberOfReplicas, final String[]
                     // ignore index missing failure, its closed...
                     continue;
                 }
-                int currentNumberOfReplicas = indexRoutingTable.shards().get(0).size() - 1; // remove the required primary
+                int currentNumberOfReplicas = indexRoutingTable.shards().get(0).writerReplicas().size();
                 IndexRoutingTable.Builder builder = new IndexRoutingTable.Builder(indexRoutingTable.getIndex());
                 // re-add all the shards
                 for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
@@ -541,6 +561,45 @@ public Builder updateNumberOfReplicas(final int numberOfReplicas, final String[]
             return this;
         }
 
+        /**
+         * Update the number of search replicas for the specified indices.
+         *
+         * @param numberOfSearchReplicas the number of replicas
+         * @param indices          the indices to update the number of replicas for
+         * @return the builder
+         */
+        public Builder updateNumberOfSearchReplicas(final int numberOfSearchReplicas, final String[] indices) {
+            if (indicesRouting == null) {
+                throw new IllegalStateException("once build is called the builder cannot be reused");
+            }
+            for (String index : indices) {
+                IndexRoutingTable indexRoutingTable = indicesRouting.get(index);
+                if (indexRoutingTable == null) {
+                    // ignore index missing failure, its closed...
+                    continue;
+                }
+                IndexShardRoutingTable shardRoutings = indexRoutingTable.shards().get(0);
+                int currentNumberOfSearchReplicas = shardRoutings.searchOnlyReplicas().size();
+                IndexRoutingTable.Builder builder = new IndexRoutingTable.Builder(indexRoutingTable.getIndex());
+                // re-add all the shards
+                for (IndexShardRoutingTable indexShardRoutingTable : indexRoutingTable) {
+                    builder.addIndexShard(indexShardRoutingTable);
+                }
+                if (currentNumberOfSearchReplicas < numberOfSearchReplicas) {
+                    // now, add "empty" ones
+                    for (int i = 0; i < (numberOfSearchReplicas - currentNumberOfSearchReplicas); i++) {
+                        builder.addSearchReplica();
+                    }
+                } else if (currentNumberOfSearchReplicas > numberOfSearchReplicas) {
+                    for (int i = 0; i < (currentNumberOfSearchReplicas - numberOfSearchReplicas); i++) {
+                        builder.removeSearchReplica();
+                    }
+                }
+                indicesRouting.put(index, builder.build());
+            }
+            return this;
+        }
+
         public Builder addAsNew(IndexMetadata indexMetadata) {
             if (indexMetadata.getState() == IndexMetadata.State.OPEN) {
                 IndexRoutingTable.Builder indexRoutingBuilder = new IndexRoutingTable.Builder(indexMetadata.getIndex()).initializeAsNew(
diff --git a/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java b/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java
new file mode 100644
index 0000000000000..13501a431d9f9
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/RoutingTableIncrementalDiff.java
@@ -0,0 +1,130 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing;
+
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.DiffableUtils;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.index.Index;
+
+import java.io.IOException;
+import java.util.Map;
+
+import static org.opensearch.cluster.DiffableUtils.MapDiff;
+
+/**
+ * Represents a difference between {@link RoutingTable} objects that can be serialized and deserialized.
+ */
+public class RoutingTableIncrementalDiff implements Diff<RoutingTable>, StringKeyDiffProvider<IndexRoutingTable> {
+
+    private final Diff<Map<String, IndexRoutingTable>> indicesRouting;
+
+    private final long version;
+
+    private static final DiffableUtils.DiffableValueSerializer<String, IndexRoutingTable> CUSTOM_ROUTING_TABLE_DIFFABLE_VALUE_SERIALIZER =
+        new DiffableUtils.DiffableValueSerializer<>() {
+
+            @Override
+            public IndexRoutingTable read(StreamInput in, String key) throws IOException {
+                return IndexRoutingTable.readFrom(in);
+            }
+
+            @Override
+            public Diff<IndexRoutingTable> readDiff(StreamInput in, String key) throws IOException {
+                return new RoutingTableIncrementalDiff.IndexRoutingTableIncrementalDiff(in);
+            }
+
+            @Override
+            public Diff<IndexRoutingTable> diff(IndexRoutingTable currentState, IndexRoutingTable previousState) {
+                return new RoutingTableIncrementalDiff.IndexRoutingTableIncrementalDiff(
+                    currentState.getIndex(),
+                    previousState,
+                    currentState
+                );
+            }
+        };
+
+    public RoutingTableIncrementalDiff(RoutingTable before, RoutingTable after) {
+        version = after.version();
+        indicesRouting = DiffableUtils.diff(
+            before.getIndicesRouting(),
+            after.getIndicesRouting(),
+            DiffableUtils.getStringKeySerializer(),
+            CUSTOM_ROUTING_TABLE_DIFFABLE_VALUE_SERIALIZER
+        );
+    }
+
+    public RoutingTableIncrementalDiff(StreamInput in) throws IOException {
+        version = in.readLong();
+        indicesRouting = DiffableUtils.readJdkMapDiff(
+            in,
+            DiffableUtils.getStringKeySerializer(),
+            CUSTOM_ROUTING_TABLE_DIFFABLE_VALUE_SERIALIZER
+        );
+    }
+
+    public static RoutingTableIncrementalDiff readFrom(StreamInput in) throws IOException {
+        return new RoutingTableIncrementalDiff(in);
+    }
+
+    @Override
+    public RoutingTable apply(RoutingTable part) {
+        return new RoutingTable(version, indicesRouting.apply(part.getIndicesRouting()));
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeLong(version);
+        indicesRouting.writeTo(out);
+    }
+
+    @Override
+    public MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>> provideDiff() {
+        return (MapDiff<String, IndexRoutingTable, Map<String, IndexRoutingTable>>) indicesRouting;
+    }
+
+    /**
+     * Represents a difference between {@link IndexShardRoutingTable} objects that can be serialized and deserialized.
+     */
+    public static class IndexRoutingTableIncrementalDiff implements Diff<IndexRoutingTable> {
+
+        private final Diff<Map<Integer, IndexShardRoutingTable>> indexShardRoutingTables;
+
+        private final Index index;
+
+        public IndexRoutingTableIncrementalDiff(Index index, IndexRoutingTable before, IndexRoutingTable after) {
+            this.index = index;
+            this.indexShardRoutingTables = DiffableUtils.diff(before.getShards(), after.getShards(), DiffableUtils.getIntKeySerializer());
+        }
+
+        private static final DiffableUtils.DiffableValueReader<Integer, IndexShardRoutingTable> DIFF_VALUE_READER =
+            new DiffableUtils.DiffableValueReader<>(IndexShardRoutingTable::readFrom, IndexShardRoutingTable::readDiffFrom);
+
+        public IndexRoutingTableIncrementalDiff(StreamInput in) throws IOException {
+            this.index = new Index(in);
+            this.indexShardRoutingTables = DiffableUtils.readJdkMapDiff(in, DiffableUtils.getIntKeySerializer(), DIFF_VALUE_READER);
+        }
+
+        @Override
+        public IndexRoutingTable apply(IndexRoutingTable part) {
+            return new IndexRoutingTable(index, indexShardRoutingTables.apply(part.getShards()));
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            index.writeTo(out);
+            indexShardRoutingTables.writeTo(out);
+        }
+
+        public static IndexRoutingTableIncrementalDiff readFrom(StreamInput in) throws IOException {
+            return new IndexRoutingTableIncrementalDiff(in);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
index 45de045a8fc69..ada35caa1e61e 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/ShardRouting.java
@@ -32,11 +32,13 @@
 
 package org.opensearch.cluster.routing;
 
+import org.opensearch.Version;
 import org.opensearch.cluster.routing.RecoverySource.ExistingStoreRecoverySource;
 import org.opensearch.cluster.routing.RecoverySource.PeerRecoverySource;
 import org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
@@ -67,6 +69,7 @@ public class ShardRouting implements Writeable, ToXContentObject {
     private final String currentNodeId;
     private final String relocatingNodeId;
     private final boolean primary;
+    private final boolean searchOnly;
     private final ShardRoutingState state;
     private final RecoverySource recoverySource;
     private final UnassignedInfo unassignedInfo;
@@ -85,6 +88,7 @@ protected ShardRouting(
         String currentNodeId,
         String relocatingNodeId,
         boolean primary,
+        boolean searchOnly,
         ShardRoutingState state,
         RecoverySource recoverySource,
         UnassignedInfo unassignedInfo,
@@ -95,6 +99,7 @@ protected ShardRouting(
         this.currentNodeId = currentNodeId;
         this.relocatingNodeId = relocatingNodeId;
         this.primary = primary;
+        this.searchOnly = searchOnly;
         this.state = state;
         this.recoverySource = recoverySource;
         this.unassignedInfo = unassignedInfo;
@@ -116,6 +121,31 @@ protected ShardRouting(
             + this;
     }
 
+    protected ShardRouting(
+        ShardId shardId,
+        String relocatingNodeId,
+        String currentNodeId,
+        boolean primary,
+        ShardRoutingState shardRoutingState,
+        RecoverySource recoverySource,
+        UnassignedInfo unassignedInfo,
+        AllocationId allocationId,
+        long expectedShardSize
+    ) {
+        this(
+            shardId,
+            relocatingNodeId,
+            currentNodeId,
+            primary,
+            false,
+            shardRoutingState,
+            recoverySource,
+            unassignedInfo,
+            allocationId,
+            expectedShardSize
+        );
+    }
+
     @Nullable
     private ShardRouting initializeTargetRelocatingShard() {
         if (state == ShardRoutingState.RELOCATING) {
@@ -124,6 +154,7 @@ private ShardRouting initializeTargetRelocatingShard() {
                 relocatingNodeId,
                 currentNodeId,
                 primary,
+                searchOnly,
                 ShardRoutingState.INITIALIZING,
                 PeerRecoverySource.INSTANCE,
                 unassignedInfo,
@@ -143,12 +174,26 @@ public static ShardRouting newUnassigned(
         boolean primary,
         RecoverySource recoverySource,
         UnassignedInfo unassignedInfo
+    ) {
+        return newUnassigned(shardId, primary, false, recoverySource, unassignedInfo);
+    }
+
+    /**
+     * Creates a new unassigned shard, overloaded for bwc for searchOnly addition.
+     */
+    public static ShardRouting newUnassigned(
+        ShardId shardId,
+        boolean primary,
+        boolean search,
+        RecoverySource recoverySource,
+        UnassignedInfo unassignedInfo
     ) {
         return new ShardRouting(
             shardId,
             null,
             null,
             primary,
+            search,
             ShardRoutingState.UNASSIGNED,
             recoverySource,
             unassignedInfo,
@@ -280,6 +325,13 @@ public boolean primary() {
         return this.primary;
     }
 
+    /**
+     * Returns <code>true</code> iff this shard is a search only replica.
+     */
+    public boolean isSearchOnly() {
+        return searchOnly;
+    }
+
     /**
      * The shard state.
      */
@@ -306,6 +358,11 @@ public ShardRouting(ShardId shardId, StreamInput in) throws IOException {
         currentNodeId = in.readOptionalString();
         relocatingNodeId = in.readOptionalString();
         primary = in.readBoolean();
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            searchOnly = in.readBoolean();
+        } else {
+            searchOnly = false;
+        }
         state = ShardRoutingState.fromValue(in.readByte());
         if (state == ShardRoutingState.UNASSIGNED || state == ShardRoutingState.INITIALIZING) {
             recoverySource = RecoverySource.readFrom(in);
@@ -339,6 +396,9 @@ public void writeToThin(StreamOutput out) throws IOException {
         out.writeOptionalString(currentNodeId);
         out.writeOptionalString(relocatingNodeId);
         out.writeBoolean(primary);
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeBoolean(searchOnly);
+        }
         out.writeByte(state.value());
         if (state == ShardRoutingState.UNASSIGNED || state == ShardRoutingState.INITIALIZING) {
             recoverySource.writeTo(out);
@@ -364,6 +424,7 @@ public ShardRouting updateUnassigned(UnassignedInfo unassignedInfo, RecoverySour
             currentNodeId,
             relocatingNodeId,
             primary,
+            searchOnly,
             state,
             recoverySource,
             unassignedInfo,
@@ -392,6 +453,7 @@ public ShardRouting moveToUnassigned(UnassignedInfo unassignedInfo) {
             null,
             null,
             primary,
+            searchOnly,
             ShardRoutingState.UNASSIGNED,
             recoverySource,
             unassignedInfo,
@@ -419,6 +481,7 @@ public ShardRouting initialize(String nodeId, @Nullable String existingAllocatio
             nodeId,
             null,
             primary,
+            searchOnly,
             ShardRoutingState.INITIALIZING,
             recoverySource,
             unassignedInfo,
@@ -439,6 +502,7 @@ public ShardRouting relocate(String relocatingNodeId, long expectedShardSize) {
             currentNodeId,
             relocatingNodeId,
             primary,
+            searchOnly,
             ShardRoutingState.RELOCATING,
             recoverySource,
             null,
@@ -460,6 +524,7 @@ public ShardRouting cancelRelocation() {
             currentNodeId,
             null,
             primary,
+            searchOnly,
             ShardRoutingState.STARTED,
             recoverySource,
             null,
@@ -483,6 +548,7 @@ public ShardRouting removeRelocationSource() {
             currentNodeId,
             null,
             primary,
+            searchOnly,
             state,
             recoverySource,
             unassignedInfo,
@@ -503,6 +569,7 @@ public ShardRouting reinitializeReplicaShard() {
             currentNodeId,
             null,
             primary,
+            searchOnly,
             ShardRoutingState.INITIALIZING,
             recoverySource,
             unassignedInfo,
@@ -528,6 +595,7 @@ public ShardRouting moveToStarted() {
             currentNodeId,
             null,
             primary,
+            searchOnly,
             ShardRoutingState.STARTED,
             null,
             null,
@@ -546,11 +614,15 @@ public ShardRouting moveActivePrimaryToReplica() {
         if (!primary) {
             throw new IllegalShardRoutingStateException(this, "Not a primary shard, can't move to replica");
         }
+        if (searchOnly) {
+            throw new IllegalShardRoutingStateException(this, "Cannot move a primary to a search only replica");
+        }
         return new ShardRouting(
             shardId,
             currentNodeId,
             relocatingNodeId,
             false,
+            false,
             state,
             recoverySource,
             unassignedInfo,
@@ -569,11 +641,15 @@ public ShardRouting moveActiveReplicaToPrimary() {
         if (primary) {
             throw new IllegalShardRoutingStateException(this, "Already primary, can't move to primary");
         }
+        if (searchOnly) {
+            throw new IllegalShardRoutingStateException(this, "Cannot move a search only replica to primary");
+        }
         return new ShardRouting(
             shardId,
             currentNodeId,
             relocatingNodeId,
             true,
+            false,
             state,
             recoverySource,
             unassignedInfo,
@@ -811,7 +887,11 @@ public String shortSummary() {
         if (primary) {
             sb.append("[P]");
         } else {
-            sb.append("[R]");
+            if (searchOnly) {
+                sb.append("[S]");
+            } else {
+                sb.append("[R]");
+            }
         }
         if (recoverySource != null) {
             sb.append(", recovery_source[").append(recoverySource).append("]");
@@ -831,10 +911,11 @@ public String shortSummary() {
 
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        builder.startObject()
-            .field("state", state())
-            .field("primary", primary())
-            .field("node", currentNodeId())
+        XContentBuilder fieldBuilder = builder.startObject().field("state", state()).field("primary", primary());
+        if (FeatureFlags.isEnabled(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL)) {
+            fieldBuilder.field("searchOnly", isSearchOnly());
+        }
+        fieldBuilder.field("node", currentNodeId())
             .field("relocating_node", relocatingNodeId())
             .field("shard", id())
             .field("index", getIndexName());
diff --git a/server/src/main/java/org/opensearch/cluster/routing/StringKeyDiffProvider.java b/server/src/main/java/org/opensearch/cluster/routing/StringKeyDiffProvider.java
new file mode 100644
index 0000000000000..5d36a238e03ff
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/StringKeyDiffProvider.java
@@ -0,0 +1,33 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing;
+
+import org.opensearch.cluster.DiffableUtils;
+
+import java.util.Map;
+
+/**
+ * Interface for providing a difference (diff) between two maps with {@code String} keys and values of type {@code V}.
+ * This interface is used to compute and obtain the difference between two versions of a map, typically used
+ * in cluster state updates or other scenarios where changes need to be tracked and propagated efficiently.
+ *
+ * @param <V> the type of the values in the map
+ */
+public interface StringKeyDiffProvider<V> {
+
+    /**
+     * Provides the difference between two versions of a map with {@code String} keys and values of type {@code V}.
+     * The difference is represented as a {@link DiffableUtils.MapDiff} object, which can be used to apply the
+     * changes to another map or to serialize the diff.
+     *
+     * @return a {@link DiffableUtils.MapDiff} object representing the difference between the maps
+     */
+    DiffableUtils.MapDiff<String, V, Map<String, V>> provideDiff();
+
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/AbstractAllocationDecision.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/AbstractAllocationDecision.java
index 59a39b358cb70..614e9f49c8726 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/AbstractAllocationDecision.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/AbstractAllocationDecision.java
@@ -107,7 +107,7 @@ public List<NodeAllocationResult> getNodeDecisions() {
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
-        out.writeOptionalWriteable(targetNode);
+        out.writeOptionalWriteable((stream, node) -> node.writeToWithAttribute(stream), targetNode);
         if (nodeDecisions != null) {
             out.writeBoolean(true);
             out.writeList(nodeDecisions);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationService.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationService.java
index ae496e27ebf35..6521fc99258ab 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationService.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/AllocationService.java
@@ -37,6 +37,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
 import org.opensearch.cluster.ClusterInfoService;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.RestoreInProgress;
 import org.opensearch.cluster.health.ClusterHealthStatus;
@@ -56,10 +57,12 @@
 import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
 import org.opensearch.cluster.routing.allocation.decider.Decision;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.gateway.GatewayAllocator;
 import org.opensearch.gateway.PriorityComparator;
 import org.opensearch.gateway.ShardsBatchGatewayAllocator;
 import org.opensearch.snapshots.SnapshotsInfoService;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -69,6 +72,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -96,6 +100,7 @@ public class AllocationService {
     private final ShardsAllocator shardsAllocator;
     private final ClusterInfoService clusterInfoService;
     private SnapshotsInfoService snapshotsInfoService;
+    private final ClusterManagerMetrics clusterManagerMetrics;
 
     // only for tests that use the GatewayAllocator as the unique ExistingShardsAllocator
     public AllocationService(
@@ -105,7 +110,13 @@ public AllocationService(
         ClusterInfoService clusterInfoService,
         SnapshotsInfoService snapshotsInfoService
     ) {
-        this(allocationDeciders, shardsAllocator, clusterInfoService, snapshotsInfoService);
+        this(
+            allocationDeciders,
+            shardsAllocator,
+            clusterInfoService,
+            snapshotsInfoService,
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
+        );
         setExistingShardsAllocators(Collections.singletonMap(GatewayAllocator.ALLOCATOR_NAME, gatewayAllocator));
     }
 
@@ -113,9 +124,10 @@ public AllocationService(
         AllocationDeciders allocationDeciders,
         ShardsAllocator shardsAllocator,
         ClusterInfoService clusterInfoService,
-        SnapshotsInfoService snapshotsInfoService
+        SnapshotsInfoService snapshotsInfoService,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
-        this(allocationDeciders, shardsAllocator, clusterInfoService, snapshotsInfoService, Settings.EMPTY);
+        this(allocationDeciders, shardsAllocator, clusterInfoService, snapshotsInfoService, Settings.EMPTY, clusterManagerMetrics);
     }
 
     public AllocationService(
@@ -123,14 +135,15 @@ public AllocationService(
         ShardsAllocator shardsAllocator,
         ClusterInfoService clusterInfoService,
         SnapshotsInfoService snapshotsInfoService,
-        Settings settings
-
+        Settings settings,
+        ClusterManagerMetrics clusterManagerMetrics
     ) {
         this.allocationDeciders = allocationDeciders;
         this.shardsAllocator = shardsAllocator;
         this.clusterInfoService = clusterInfoService;
         this.snapshotsInfoService = snapshotsInfoService;
         this.settings = settings;
+        this.clusterManagerMetrics = clusterManagerMetrics;
     }
 
     /**
@@ -550,11 +563,15 @@ private void reroute(RoutingAllocation allocation) {
         assert AutoExpandReplicas.getAutoExpandReplicaChanges(allocation.metadata(), allocation).isEmpty()
             : "auto-expand replicas out of sync with number of nodes in the cluster";
         assert assertInitialized();
-
+        long rerouteStartTimeNS = System.nanoTime();
         removeDelayMarkers(allocation);
 
         allocateExistingUnassignedShards(allocation);  // try to allocate existing shard copies first
         shardsAllocator.allocate(allocation);
+        clusterManagerMetrics.recordLatency(
+            clusterManagerMetrics.rerouteHistogram,
+            (double) Math.max(0, TimeValue.nsecToMSec(System.nanoTime() - rerouteStartTimeNS))
+        );
         assert RoutingNodes.assertShardStats(allocation.routingNodes());
     }
 
@@ -568,10 +585,7 @@ private void allocateExistingUnassignedShards(RoutingAllocation allocation) {
         /*
          Use batch mode if enabled and there is no custom allocator set for Allocation service
          */
-        Boolean batchModeEnabled = EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.get(settings);
-        if (batchModeEnabled
-            && allocation.nodes().getMinNodeVersion().onOrAfter(Version.V_2_14_0)
-            && existingShardsAllocators.size() == 2) {
+        if (isBatchModeEnabled(allocation)) {
             /*
              If we do not have any custom allocator set then we will be using ShardsBatchGatewayAllocator
              Currently AllocationService will not run any custom Allocator that implements allocateAllUnassignedShards
@@ -604,10 +618,10 @@ private void allocateExistingUnassignedShards(RoutingAllocation allocation) {
 
     private void allocateAllUnassignedShards(RoutingAllocation allocation) {
         ExistingShardsAllocator allocator = existingShardsAllocators.get(ShardsBatchGatewayAllocator.ALLOCATOR_NAME);
-        allocator.allocateAllUnassignedShards(allocation, true);
+        Optional.ofNullable(allocator.allocateAllUnassignedShards(allocation, true)).ifPresent(Runnable::run);
         allocator.afterPrimariesBeforeReplicas(allocation);
         // Replicas Assignment
-        allocator.allocateAllUnassignedShards(allocation, false);
+        Optional.ofNullable(allocator.allocateAllUnassignedShards(allocation, false)).ifPresent(Runnable::run);
     }
 
     private void disassociateDeadNodes(RoutingAllocation allocation) {
@@ -708,13 +722,24 @@ private AllocateUnassignedDecision explainUnassignedShardAllocation(ShardRouting
 
     private ExistingShardsAllocator getAllocatorForShard(ShardRouting shardRouting, RoutingAllocation routingAllocation) {
         assert assertInitialized();
-        final String allocatorName = ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_SETTING.get(
-            routingAllocation.metadata().getIndexSafe(shardRouting.index()).getSettings()
-        );
+        String allocatorName;
+        if (isBatchModeEnabled(routingAllocation)) {
+            allocatorName = ShardsBatchGatewayAllocator.ALLOCATOR_NAME;
+        } else {
+            allocatorName = ExistingShardsAllocator.EXISTING_SHARDS_ALLOCATOR_SETTING.get(
+                routingAllocation.metadata().getIndexSafe(shardRouting.index()).getSettings()
+            );
+        }
         final ExistingShardsAllocator existingShardsAllocator = existingShardsAllocators.get(allocatorName);
         return existingShardsAllocator != null ? existingShardsAllocator : new NotFoundAllocator(allocatorName);
     }
 
+    private boolean isBatchModeEnabled(RoutingAllocation routingAllocation) {
+        return EXISTING_SHARDS_ALLOCATOR_BATCH_MODE.get(settings)
+            && routingAllocation.nodes().getMinNodeVersion().onOrAfter(Version.V_2_14_0)
+            && existingShardsAllocators.size() == 2;
+    }
+
     private boolean assertInitialized() {
         assert existingShardsAllocators != null : "must have set allocators first";
         return true;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
index 08fe8f92d1f80..28ad199218884 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/ConstraintTypes.java
@@ -70,7 +70,7 @@ public static Predicate<Constraint.ConstraintParams> isPerIndexPrimaryShardsPerN
         return (params) -> {
             int perIndexPrimaryShardCount = params.getNode().numPrimaryShards(params.getIndex());
             int perIndexAllowedPrimaryShardCount = (int) Math.ceil(params.getBalancer().avgPrimaryShardsPerNode(params.getIndex()));
-            return perIndexPrimaryShardCount > perIndexAllowedPrimaryShardCount;
+            return perIndexPrimaryShardCount >= perIndexAllowedPrimaryShardCount;
         };
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/ExistingShardsAllocator.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/ExistingShardsAllocator.java
index fb2a37237f8b6..eb7a1e7209c37 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/ExistingShardsAllocator.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/ExistingShardsAllocator.java
@@ -41,6 +41,7 @@
 import org.opensearch.gateway.GatewayAllocator;
 import org.opensearch.gateway.ShardsBatchGatewayAllocator;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -108,14 +109,16 @@ void allocateUnassigned(
      *
      * Allocation service will currently run the default implementation of it implemented by {@link ShardsBatchGatewayAllocator}
      */
-    default void allocateAllUnassignedShards(RoutingAllocation allocation, boolean primary) {
+    default Runnable allocateAllUnassignedShards(RoutingAllocation allocation, boolean primary) {
         RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
+        List<Runnable> runnables = new ArrayList<>();
         while (iterator.hasNext()) {
             ShardRouting shardRouting = iterator.next();
             if (shardRouting.primary() == primary) {
-                allocateUnassigned(shardRouting, allocation, iterator);
+                runnables.add(() -> allocateUnassigned(shardRouting, allocation, iterator));
             }
         }
+        return () -> runnables.forEach(Runnable::run);
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/IndexMetadataUpdater.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/IndexMetadataUpdater.java
index 2431f57a6a1f9..113d5803c1d65 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/IndexMetadataUpdater.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/IndexMetadataUpdater.java
@@ -259,7 +259,9 @@ private IndexMetadata.Builder updateInSyncAllocations(
             // We use number_of_replicas + 1 (= possible active shard copies) to bound the inSyncAllocationIds set
             // Only trim the set of allocation ids when it grows, otherwise we might trim too eagerly when the number
             // of replicas was decreased while shards were unassigned.
-            int maxActiveShards = oldIndexMetadata.getNumberOfReplicas() + 1; // +1 for the primary
+            int maxActiveShards = oldIndexMetadata.getNumberOfReplicas() + oldIndexMetadata.getNumberOfSearchOnlyReplicas() + 1; // +1 for
+                                                                                                                                 // the
+                                                                                                                                 // primary
             IndexShardRoutingTable newShardRoutingTable = newRoutingTable.shardRoutingTable(shardId);
             assert newShardRoutingTable.assignedShards()
                 .stream()
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/NodeAllocationResult.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/NodeAllocationResult.java
index 4163a5fd4c16f..6b805ca91fa58 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/NodeAllocationResult.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/NodeAllocationResult.java
@@ -104,7 +104,7 @@ public NodeAllocationResult(StreamInput in) throws IOException {
 
     @Override
     public void writeTo(StreamOutput out) throws IOException {
-        node.writeTo(out);
+        node.writeToWithAttribute(out);
         out.writeOptionalWriteable(shardStoreInfo);
         out.writeOptionalWriteable(canAllocateDecision);
         nodeDecision.writeTo(out);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
index b2443490dd973..a5193ca602f04 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/BalancedShardsAllocator.java
@@ -54,6 +54,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
 
 import java.util.HashMap;
 import java.util.HashSet;
@@ -87,6 +88,7 @@
 public class BalancedShardsAllocator implements ShardsAllocator {
 
     private static final Logger logger = LogManager.getLogger(BalancedShardsAllocator.class);
+    public static final TimeValue MIN_ALLOCATOR_TIMEOUT = TimeValue.timeValueSeconds(20);
 
     public static final Setting<Float> INDEX_BALANCE_FACTOR_SETTING = Setting.floatSetting(
         "cluster.routing.allocation.balance.index",
@@ -154,6 +156,13 @@ public class BalancedShardsAllocator implements ShardsAllocator {
         Property.NodeScope
     );
 
+    public static final Setting<Boolean> IGNORE_THROTTLE_FOR_REMOTE_RESTORE = Setting.boolSetting(
+        "cluster.routing.allocation.remote_primary.ignore_throttle",
+        true,
+        Property.Dynamic,
+        Property.NodeScope
+    );
+
     public static final Setting<Float> PRIMARY_SHARD_REBALANCE_BUFFER = Setting.floatSetting(
         "cluster.routing.allocation.rebalance.primary.buffer",
         0.10f,
@@ -162,6 +171,23 @@ public class BalancedShardsAllocator implements ShardsAllocator {
         Property.NodeScope
     );
 
+    public static final Setting<TimeValue> ALLOCATOR_TIMEOUT_SETTING = Setting.timeSetting(
+        "cluster.routing.allocation.balanced_shards_allocator.allocator_timeout",
+        TimeValue.MINUS_ONE,
+        TimeValue.MINUS_ONE,
+        timeValue -> {
+            if (timeValue.compareTo(MIN_ALLOCATOR_TIMEOUT) < 0 && timeValue.compareTo(TimeValue.MINUS_ONE) != 0) {
+                throw new IllegalArgumentException(
+                    "Setting ["
+                        + "cluster.routing.allocation.balanced_shards_allocator.allocator_timeout"
+                        + "] should be more than 20s or -1ms to disable timeout"
+                );
+            }
+        },
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
     private volatile boolean movePrimaryFirst;
     private volatile ShardMovementStrategy shardMovementStrategy;
 
@@ -173,6 +199,10 @@ public class BalancedShardsAllocator implements ShardsAllocator {
     private volatile WeightFunction weightFunction;
     private volatile float threshold;
 
+    private volatile boolean ignoreThrottleInRestore;
+    private volatile TimeValue allocatorTimeout;
+    private long startTime;
+
     public BalancedShardsAllocator(Settings settings) {
         this(settings, new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS));
     }
@@ -182,11 +212,13 @@ public BalancedShardsAllocator(Settings settings, ClusterSettings clusterSetting
         setShardBalanceFactor(SHARD_BALANCE_FACTOR_SETTING.get(settings));
         setIndexBalanceFactor(INDEX_BALANCE_FACTOR_SETTING.get(settings));
         setPreferPrimaryShardRebalanceBuffer(PRIMARY_SHARD_REBALANCE_BUFFER.get(settings));
+        setIgnoreThrottleInRestore(IGNORE_THROTTLE_FOR_REMOTE_RESTORE.get(settings));
         updateWeightFunction();
         setThreshold(THRESHOLD_SETTING.get(settings));
         setPreferPrimaryShardBalance(PREFER_PRIMARY_SHARD_BALANCE.get(settings));
         setPreferPrimaryShardRebalance(PREFER_PRIMARY_SHARD_REBALANCE.get(settings));
         setShardMovementStrategy(SHARD_MOVEMENT_STRATEGY_SETTING.get(settings));
+        setAllocatorTimeout(ALLOCATOR_TIMEOUT_SETTING.get(settings));
         clusterSettings.addSettingsUpdateConsumer(PREFER_PRIMARY_SHARD_BALANCE, this::setPreferPrimaryShardBalance);
         clusterSettings.addSettingsUpdateConsumer(SHARD_MOVE_PRIMARY_FIRST_SETTING, this::setMovePrimaryFirst);
         clusterSettings.addSettingsUpdateConsumer(SHARD_MOVEMENT_STRATEGY_SETTING, this::setShardMovementStrategy);
@@ -195,6 +227,8 @@ public BalancedShardsAllocator(Settings settings, ClusterSettings clusterSetting
         clusterSettings.addSettingsUpdateConsumer(PRIMARY_SHARD_REBALANCE_BUFFER, this::updatePreferPrimaryShardBalanceBuffer);
         clusterSettings.addSettingsUpdateConsumer(PREFER_PRIMARY_SHARD_REBALANCE, this::setPreferPrimaryShardRebalance);
         clusterSettings.addSettingsUpdateConsumer(THRESHOLD_SETTING, this::setThreshold);
+        clusterSettings.addSettingsUpdateConsumer(IGNORE_THROTTLE_FOR_REMOTE_RESTORE, this::setIgnoreThrottleInRestore);
+        clusterSettings.addSettingsUpdateConsumer(ALLOCATOR_TIMEOUT_SETTING, this::setAllocatorTimeout);
     }
 
     /**
@@ -205,6 +239,10 @@ private void setMovePrimaryFirst(boolean movePrimaryFirst) {
         setShardMovementStrategy(this.shardMovementStrategy);
     }
 
+    private void setIgnoreThrottleInRestore(boolean ignoreThrottleInRestore) {
+        this.ignoreThrottleInRestore = ignoreThrottleInRestore;
+    }
+
     /**
      * Sets the correct Shard movement strategy to use.
      * If users are still using deprecated setting `move_primary_first`, we want behavior to remain unchanged.
@@ -269,6 +307,20 @@ private void setThreshold(float threshold) {
         this.threshold = threshold;
     }
 
+    private void setAllocatorTimeout(TimeValue allocatorTimeout) {
+        this.allocatorTimeout = allocatorTimeout;
+    }
+
+    protected boolean allocatorTimedOut() {
+        if (allocatorTimeout.equals(TimeValue.MINUS_ONE)) {
+            if (logger.isTraceEnabled()) {
+                logger.trace("Allocator timeout is disabled. Will not short circuit allocator tasks");
+            }
+            return false;
+        }
+        return System.nanoTime() - this.startTime > allocatorTimeout.nanos();
+    }
+
     @Override
     public void allocate(RoutingAllocation allocation) {
         if (allocation.routingNodes().size() == 0) {
@@ -282,8 +334,11 @@ public void allocate(RoutingAllocation allocation) {
             weightFunction,
             threshold,
             preferPrimaryShardBalance,
-            preferPrimaryShardRebalance
+            preferPrimaryShardRebalance,
+            ignoreThrottleInRestore,
+            this::allocatorTimedOut
         );
+        this.startTime = System.nanoTime();
         localShardsBalancer.allocateUnassigned();
         localShardsBalancer.moveShards();
         localShardsBalancer.balance();
@@ -304,7 +359,9 @@ public ShardAllocationDecision decideShardAllocation(final ShardRouting shard, f
             weightFunction,
             threshold,
             preferPrimaryShardBalance,
-            preferPrimaryShardRebalance
+            preferPrimaryShardRebalance,
+            ignoreThrottleInRestore,
+            () -> false // as we don't need to check if timed out or not while just understanding ShardAllocationDecision
         );
         AllocateUnassignedDecision allocateUnassignedDecision = AllocateUnassignedDecision.NOT_TAKEN;
         MoveDecision moveDecision = MoveDecision.NOT_TAKEN;
@@ -459,6 +516,7 @@ void updateRebalanceConstraint(String constraint, boolean add) {
     public static class ModelNode implements Iterable<ModelIndex> {
         private final Map<String, ModelIndex> indices = new HashMap<>();
         private int numShards = 0;
+        private int numPrimaryShards = 0;
         private final RoutingNode routingNode;
 
         ModelNode(RoutingNode routingNode) {
@@ -492,7 +550,7 @@ public int numPrimaryShards(String idx) {
         }
 
         public int numPrimaryShards() {
-            return indices.values().stream().mapToInt(index -> index.numPrimaryShards()).sum();
+            return numPrimaryShards;
         }
 
         public int highestPrimary(String index) {
@@ -510,6 +568,10 @@ public void addShard(ShardRouting shard) {
                 indices.put(index.getIndexId(), index);
             }
             index.addShard(shard);
+            if (shard.primary()) {
+                numPrimaryShards++;
+            }
+
             numShards++;
         }
 
@@ -521,6 +583,11 @@ public void removeShard(ShardRouting shard) {
                     indices.remove(shard.getIndexName());
                 }
             }
+
+            if (shard.primary()) {
+                numPrimaryShards--;
+            }
+
             numShards--;
         }
 
@@ -558,7 +625,7 @@ public Balancer(
             float threshold,
             boolean preferPrimaryBalance
         ) {
-            super(logger, allocation, shardMovementStrategy, weight, threshold, preferPrimaryBalance, false);
+            super(logger, allocation, shardMovementStrategy, weight, threshold, preferPrimaryBalance, false, false, () -> false);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
index 696a83dd624a8..4d0b654f9d52f 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/allocator/LocalShardsBalancer.java
@@ -13,6 +13,7 @@
 import org.apache.lucene.util.IntroSorter;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.routing.RoutingNodes;
 import org.opensearch.cluster.routing.RoutingPool;
@@ -29,10 +30,10 @@
 import org.opensearch.cluster.routing.allocation.decider.Decision;
 import org.opensearch.cluster.routing.allocation.decider.DiskThresholdDecider;
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.gateway.PriorityComparator;
 
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -41,10 +42,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.stream.Collectors;
+import java.util.function.Supplier;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
+import static org.opensearch.action.admin.indices.tiering.TieringUtils.isPartialShard;
 import static org.opensearch.cluster.routing.ShardRoutingState.RELOCATING;
 
 /**
@@ -62,6 +64,8 @@ public class LocalShardsBalancer extends ShardsBalancer {
 
     private final boolean preferPrimaryBalance;
     private final boolean preferPrimaryRebalance;
+
+    private final boolean ignoreThrottleInRestore;
     private final BalancedShardsAllocator.WeightFunction weight;
 
     private final float threshold;
@@ -70,6 +74,8 @@ public class LocalShardsBalancer extends ShardsBalancer {
     private final float avgPrimaryShardsPerNode;
     private final BalancedShardsAllocator.NodeSorter sorter;
     private final Set<RoutingNode> inEligibleTargetNode;
+    private final Supplier<Boolean> timedOutFunc;
+    private int totalShardCount = 0;
 
     public LocalShardsBalancer(
         Logger logger,
@@ -78,7 +84,9 @@ public LocalShardsBalancer(
         BalancedShardsAllocator.WeightFunction weight,
         float threshold,
         boolean preferPrimaryBalance,
-        boolean preferPrimaryRebalance
+        boolean preferPrimaryRebalance,
+        boolean ignoreThrottleInRestore,
+        Supplier<Boolean> timedOutFunc
     ) {
         this.logger = logger;
         this.allocation = allocation;
@@ -95,6 +103,8 @@ public LocalShardsBalancer(
         this.preferPrimaryBalance = preferPrimaryBalance;
         this.preferPrimaryRebalance = preferPrimaryRebalance;
         this.shardMovementStrategy = shardMovementStrategy;
+        this.ignoreThrottleInRestore = ignoreThrottleInRestore;
+        this.timedOutFunc = timedOutFunc;
     }
 
     /**
@@ -127,8 +137,7 @@ public float avgPrimaryShardsPerNode() {
      */
     @Override
     public float avgShardsPerNode() {
-        float totalShards = nodes.values().stream().map(BalancedShardsAllocator.ModelNode::numShards).reduce(0, Integer::sum);
-        return totalShards / nodes.size();
+        return totalShardCount / nodes.size();
     }
 
     /**
@@ -341,6 +350,14 @@ private void balanceByWeights() {
         final BalancedShardsAllocator.ModelNode[] modelNodes = sorter.modelNodes;
         final float[] weights = sorter.weights;
         for (String index : buildWeightOrderedIndices()) {
+            // Terminate if the time allocated to the balanced shards allocator has elapsed
+            if (timedOutFunc != null && timedOutFunc.get()) {
+                logger.info(
+                    "Cannot balance any shard in the cluster as time allocated to balanced shards allocator has elapsed"
+                        + ". Skipping indices iteration"
+                );
+                return;
+            }
             IndexMetadata indexMetadata = metadata.index(index);
 
             // find nodes that have a shard of this index or where shards of this index are allowed to be allocated to,
@@ -365,6 +382,14 @@ private void balanceByWeights() {
             int lowIdx = 0;
             int highIdx = relevantNodes - 1;
             while (true) {
+                // break if the time allocated to the balanced shards allocator has elapsed
+                if (timedOutFunc != null && timedOutFunc.get()) {
+                    logger.info(
+                        "Cannot balance any shard in the cluster as time allocated to balanced shards allocator has elapsed"
+                            + ". Skipping relevant nodes iteration"
+                    );
+                    return;
+                }
                 final BalancedShardsAllocator.ModelNode minNode = modelNodes[lowIdx];
                 final BalancedShardsAllocator.ModelNode maxNode = modelNodes[highIdx];
                 advance_range: if (maxNode.numShards(index) > 0) {
@@ -529,6 +554,16 @@ private void checkAndAddInEligibleTargetNode(RoutingNode targetNode) {
         }
     }
 
+    /**
+     * Checks if the shard can be skipped from the local shard balancer operations
+     * @param shardRouting the shard to be checked
+     * @return true if the shard can be skipped, false otherwise
+     */
+    private boolean canShardBeSkipped(ShardRouting shardRouting) {
+        return (RoutingPool.REMOTE_CAPABLE.equals(RoutingPool.getShardPool(shardRouting, allocation))
+            && !(FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX) && isPartialShard(shardRouting, allocation)));
+    }
+
     /**
      * Move started shards that can not be allocated to a node anymore
      * <p>
@@ -569,9 +604,18 @@ void moveShards() {
                 return;
             }
 
+            // Terminate if the time allocated to the balanced shards allocator has elapsed
+            if (timedOutFunc != null && timedOutFunc.get()) {
+                logger.info(
+                    "Cannot move any shard in the cluster as time allocated to balanced shards allocator has elapsed"
+                        + ". Skipping shard iteration"
+                );
+                return;
+            }
+
             ShardRouting shardRouting = it.next();
 
-            if (RoutingPool.REMOTE_CAPABLE.equals(RoutingPool.getShardPool(shardRouting, allocation))) {
+            if (canShardBeSkipped(shardRouting)) {
                 continue;
             }
 
@@ -600,6 +644,7 @@ void moveShards() {
                 final BalancedShardsAllocator.ModelNode sourceNode = nodes.get(shardRouting.currentNodeId());
                 final BalancedShardsAllocator.ModelNode targetNode = nodes.get(moveDecision.getTargetNode().getId());
                 sourceNode.removeShard(shardRouting);
+                --totalShardCount;
                 Tuple<ShardRouting, ShardRouting> relocatingShards = routingNodes.relocateShard(
                     shardRouting,
                     targetNode.getNodeId(),
@@ -607,6 +652,7 @@ void moveShards() {
                     allocation.changes()
                 );
                 targetNode.addShard(relocatingShards.v2());
+                ++totalShardCount;
                 if (logger.isTraceEnabled()) {
                     logger.trace("Moved shard [{}] to node [{}]", shardRouting, targetNode.getRoutingNode());
                 }
@@ -635,7 +681,7 @@ void moveShards() {
      */
     @Override
     MoveDecision decideMove(final ShardRouting shardRouting) {
-        if (RoutingPool.REMOTE_CAPABLE.equals(RoutingPool.getShardPool(shardRouting, allocation))) {
+        if (canShardBeSkipped(shardRouting)) {
             return MoveDecision.NOT_TAKEN;
         }
 
@@ -724,8 +770,11 @@ private Map<String, BalancedShardsAllocator.ModelNode> buildModelFromAssigned()
             for (ShardRouting shard : rn) {
                 assert rn.nodeId().equals(shard.currentNodeId());
                 /* we skip relocating shards here since we expect an initializing shard with the same id coming in */
-                if (RoutingPool.LOCAL_ONLY.equals(RoutingPool.getShardPool(shard, allocation)) && shard.state() != RELOCATING) {
+                if ((RoutingPool.LOCAL_ONLY.equals(RoutingPool.getShardPool(shard, allocation))
+                    || (FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX) && isPartialShard(shard, allocation)))
+                    && shard.state() != RELOCATING) {
                     node.addShard(shard);
+                    ++totalShardCount;
                     if (logger.isTraceEnabled()) {
                         logger.trace("Assigned shard [{}] to node [{}]", shard, node.getNodeId());
                     }
@@ -779,21 +828,37 @@ void allocateUnassigned() {
          * if we allocate for instance (0, R, IDX1) we move the second replica to the secondary array and proceed with
          * the next replica. If we could not find a node to allocate (0,R,IDX1) we move all it's replicas to ignoreUnassigned.
          */
-        ShardRouting[] unassignedShards = unassigned.drain();
-        List<ShardRouting> allUnassignedShards = Arrays.stream(unassignedShards).collect(Collectors.toList());
-        List<ShardRouting> localUnassignedShards = allUnassignedShards.stream()
-            .filter(shard -> RoutingPool.LOCAL_ONLY.equals(RoutingPool.getShardPool(shard, allocation)))
-            .collect(Collectors.toList());
-        allUnassignedShards.removeAll(localUnassignedShards);
-        allUnassignedShards.forEach(shard -> routingNodes.unassigned().add(shard));
-        unassignedShards = localUnassignedShards.toArray(new ShardRouting[0]);
-        ShardRouting[] primary = unassignedShards;
+        List<ShardRouting> primaryList = new ArrayList<>();
+        for (ShardRouting shard : unassigned.drain()) {
+            if (RoutingPool.LOCAL_ONLY.equals(RoutingPool.getShardPool(shard, allocation))) {
+                primaryList.add(shard);
+            } else {
+                routingNodes.unassigned().add(shard);
+            }
+        }
+
+        ShardRouting[] primary = primaryList.toArray(new ShardRouting[0]);
         ShardRouting[] secondary = new ShardRouting[primary.length];
         int secondaryLength = 0;
         int primaryLength = primary.length;
         ArrayUtil.timSort(primary, comparator);
+        if (logger.isTraceEnabled()) {
+            logger.trace("Staring allocation of [{}] unassigned shards", primaryLength);
+        }
         do {
             for (int i = 0; i < primaryLength; i++) {
+                if (timedOutFunc != null && timedOutFunc.get()) {
+                    // TODO - maybe check if we can allow wait for active shards thingy bypass this condition
+                    logger.info(
+                        "Ignoring [{}] unassigned shards for allocation as time allocated to balanced shards allocator has elapsed",
+                        (primaryLength - i)
+                    );
+                    while (i < primaryLength) {
+                        unassigned.ignoreShard(primary[i], UnassignedInfo.AllocationStatus.NO_ATTEMPT, allocation.changes());
+                        i++;
+                    }
+                    return;
+                }
                 ShardRouting shard = primary[i];
                 final AllocateUnassignedDecision allocationDecision = decideAllocateUnassigned(shard);
                 final String assignedNodeId = allocationDecision.getTargetNode() != null
@@ -816,6 +881,7 @@ void allocateUnassigned() {
                     );
                     shard = routingNodes.initializeShard(shard, minNode.getNodeId(), null, shardSize, allocation.changes());
                     minNode.addShard(shard);
+                    ++totalShardCount;
                     if (!shard.primary()) {
                         // copy over the same replica shards to the secondary array so they will get allocated
                         // in a subsequent iteration, allowing replicas of other shards to be allocated first
@@ -845,6 +911,7 @@ void allocateUnassigned() {
                             allocation.routingTable()
                         );
                         minNode.addShard(shard.initialize(minNode.getNodeId(), null, shardSize));
+                        ++totalShardCount;
                     } else {
                         if (logger.isTraceEnabled()) {
                             logger.trace("No Node found to assign shard [{}]", shard);
@@ -914,7 +981,15 @@ AllocateUnassignedDecision decideAllocateUnassigned(final ShardRouting shard) {
                 nodeExplanationMap.put(node.getNodeId(), new NodeAllocationResult(node.getRoutingNode().node(), currentDecision, 0));
                 nodeWeights.add(Tuple.tuple(node.getNodeId(), currentWeight));
             }
-            if (currentDecision.type() == Decision.Type.YES || currentDecision.type() == Decision.Type.THROTTLE) {
+
+            // For REMOTE_STORE recoveries, THROTTLE is as good as NO as we want faster recoveries
+            // The side effect of this are increased relocations post these allocations.
+            boolean considerThrottleAsNo = ignoreThrottleInRestore
+                && shard.recoverySource().getType() == RecoverySource.Type.REMOTE_STORE
+                && shard.primary();
+
+            if (currentDecision.type() == Decision.Type.YES
+                || (currentDecision.type() == Decision.Type.THROTTLE && considerThrottleAsNo == false)) {
                 final boolean updateMinNode;
                 if (currentWeight == minWeight) {
                     /*  we have an equal weight tie breaking:
@@ -1012,18 +1087,21 @@ private boolean tryRelocateShard(BalancedShardsAllocator.ModelNode minNode, Bala
                 }
                 final Decision decision = new Decision.Multi().add(allocationDecision).add(rebalanceDecision);
                 maxNode.removeShard(shard);
+                --totalShardCount;
                 long shardSize = allocation.clusterInfo().getShardSize(shard, ShardRouting.UNAVAILABLE_EXPECTED_SHARD_SIZE);
 
                 if (decision.type() == Decision.Type.YES) {
                     /* only allocate on the cluster if we are not throttled */
                     logger.debug("Relocate [{}] from [{}] to [{}]", shard, maxNode.getNodeId(), minNode.getNodeId());
                     minNode.addShard(routingNodes.relocateShard(shard, minNode.getNodeId(), shardSize, allocation.changes()).v1());
+                    ++totalShardCount;
                     return true;
                 } else {
                     /* allocate on the model even if throttled */
                     logger.debug("Simulate relocation of [{}] from [{}] to [{}]", shard, maxNode.getNodeId(), minNode.getNodeId());
                     assert decision.type() == Decision.Type.THROTTLE;
                     minNode.addShard(shard.relocate(minNode.getNodeId(), shardSize));
+                    ++totalShardCount;
                     return false;
                 }
             }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java
index 5344d95b217a7..16c94acfbb553 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/AwarenessAllocationDecider.java
@@ -111,7 +111,6 @@ public class AwarenessAllocationDecider extends AllocationDecider {
     );
 
     private volatile List<String> awarenessAttributes;
-
     private volatile Map<String, List<String>> forcedAwarenessAttributes;
 
     public AwarenessAllocationDecider(Settings settings, ClusterSettings clusterSettings) {
@@ -163,8 +162,8 @@ private Decision underCapacity(ShardRouting shardRouting, RoutingNode node, Rout
         IndexMetadata indexMetadata = allocation.metadata().getIndexSafe(shardRouting.index());
         int shardCount = indexMetadata.getNumberOfReplicas() + 1; // 1 for primary
         for (String awarenessAttribute : awarenessAttributes) {
-            // the node the shard exists on must be associated with an awareness attribute
-            if (node.node().getAttributes().containsKey(awarenessAttribute) == false) {
+            // the node the shard exists on must be associated with an awareness attribute.
+            if (isAwarenessAttributeAssociatedWithNode(node, awarenessAttribute) == false) {
                 return allocation.decision(
                     Decision.NO,
                     NAME,
@@ -175,36 +174,10 @@ private Decision underCapacity(ShardRouting shardRouting, RoutingNode node, Rout
                 );
             }
 
+            int currentNodeCount = getCurrentNodeCountForAttribute(shardRouting, node, allocation, moveToNode, awarenessAttribute);
+
             // build attr_value -> nodes map
             Set<String> nodesPerAttribute = allocation.routingNodes().nodesPerAttributesCounts(awarenessAttribute);
-
-            // build the count of shards per attribute value
-            Map<String, Integer> shardPerAttribute = new HashMap<>();
-            for (ShardRouting assignedShard : allocation.routingNodes().assignedShards(shardRouting.shardId())) {
-                if (assignedShard.started() || assignedShard.initializing()) {
-                    // Note: this also counts relocation targets as that will be the new location of the shard.
-                    // Relocation sources should not be counted as the shard is moving away
-                    RoutingNode routingNode = allocation.routingNodes().node(assignedShard.currentNodeId());
-                    shardPerAttribute.merge(routingNode.node().getAttributes().get(awarenessAttribute), 1, Integer::sum);
-                }
-            }
-
-            if (moveToNode) {
-                if (shardRouting.assignedToNode()) {
-                    String nodeId = shardRouting.relocating() ? shardRouting.relocatingNodeId() : shardRouting.currentNodeId();
-                    if (node.nodeId().equals(nodeId) == false) {
-                        // we work on different nodes, move counts around
-                        shardPerAttribute.compute(
-                            allocation.routingNodes().node(nodeId).node().getAttributes().get(awarenessAttribute),
-                            (k, v) -> (v == null) ? 0 : v - 1
-                        );
-                        shardPerAttribute.merge(node.node().getAttributes().get(awarenessAttribute), 1, Integer::sum);
-                    }
-                } else {
-                    shardPerAttribute.merge(node.node().getAttributes().get(awarenessAttribute), 1, Integer::sum);
-                }
-            }
-
             int numberOfAttributes = nodesPerAttribute.size();
             List<String> fullValues = forcedAwarenessAttributes.get(awarenessAttribute);
 
@@ -216,9 +189,8 @@ private Decision underCapacity(ShardRouting shardRouting, RoutingNode node, Rout
                 }
                 numberOfAttributes = attributesSet.size();
             }
-            // TODO should we remove ones that are not part of full list?
 
-            final int currentNodeCount = shardPerAttribute.get(node.node().getAttributes().get(awarenessAttribute));
+            // TODO should we remove ones that are not part of full list?
             final int maximumNodeCount = (shardCount + numberOfAttributes - 1) / numberOfAttributes; // ceil(shardCount/numberOfAttributes)
             if (currentNodeCount > maximumNodeCount) {
                 return allocation.decision(
@@ -238,4 +210,57 @@ private Decision underCapacity(ShardRouting shardRouting, RoutingNode node, Rout
 
         return allocation.decision(Decision.YES, NAME, "node meets all awareness attribute requirements");
     }
+
+    private int getCurrentNodeCountForAttribute(
+        ShardRouting shardRouting,
+        RoutingNode node,
+        RoutingAllocation allocation,
+        boolean moveToNode,
+        String awarenessAttribute
+    ) {
+        // build the count of shards per attribute value
+        final String shardAttributeForNode = getAttributeValueForNode(node, awarenessAttribute);
+        int currentNodeCount = 0;
+        final List<ShardRouting> assignedShards = allocation.routingNodes().assignedShards(shardRouting.shardId());
+
+        for (ShardRouting assignedShard : assignedShards) {
+            if (assignedShard.started() || assignedShard.initializing()) {
+                // Note: this also counts relocation targets as that will be the new location of the shard.
+                // Relocation sources should not be counted as the shard is moving away
+                RoutingNode routingNode = allocation.routingNodes().node(assignedShard.currentNodeId());
+                // Increase node count when
+                if (getAttributeValueForNode(routingNode, awarenessAttribute).equals(shardAttributeForNode)) {
+                    ++currentNodeCount;
+                }
+            }
+        }
+
+        if (moveToNode) {
+            if (shardRouting.assignedToNode()) {
+                String nodeId = shardRouting.relocating() ? shardRouting.relocatingNodeId() : shardRouting.currentNodeId();
+                if (node.nodeId().equals(nodeId) == false) {
+                    // we work on different nodes, move counts around
+                    if (getAttributeValueForNode(allocation.routingNodes().node(nodeId), awarenessAttribute).equals(shardAttributeForNode)
+                        && currentNodeCount > 0) {
+                        --currentNodeCount;
+                    }
+
+                    ++currentNodeCount;
+                }
+            } else {
+                ++currentNodeCount;
+            }
+        }
+
+        return currentNodeCount;
+    }
+
+    private boolean isAwarenessAttributeAssociatedWithNode(RoutingNode node, String awarenessAttribute) {
+        return node.node().getAttributes().containsKey(awarenessAttribute);
+    }
+
+    private String getAttributeValueForNode(final RoutingNode node, final String awarenessAttribute) {
+        return node.node().getAttributes().get(awarenessAttribute);
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDecider.java
index 2c7df6b81e676..5fc3f282f33f7 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDecider.java
@@ -54,6 +54,7 @@
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.store.remote.filecache.FileCacheSettings;
 import org.opensearch.index.store.remote.filecache.FileCacheStats;
 import org.opensearch.snapshots.SnapshotShardSizeInfo;
 
@@ -68,7 +69,6 @@
 import static org.opensearch.cluster.routing.RoutingPool.getShardPool;
 import static org.opensearch.cluster.routing.allocation.DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING;
 import static org.opensearch.cluster.routing.allocation.DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK_SETTING;
-import static org.opensearch.index.store.remote.filecache.FileCache.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING;
 
 /**
  * The {@link DiskThresholdDecider} checks that the node a shard is potentially
@@ -109,11 +109,13 @@ public class DiskThresholdDecider extends AllocationDecider {
 
     private final DiskThresholdSettings diskThresholdSettings;
     private final boolean enableForSingleDataNode;
+    private final FileCacheSettings fileCacheSettings;
 
     public DiskThresholdDecider(Settings settings, ClusterSettings clusterSettings) {
         this.diskThresholdSettings = new DiskThresholdSettings(settings, clusterSettings);
         assert Version.CURRENT.major < 9 : "remove enable_for_single_data_node in 9";
         this.enableForSingleDataNode = ENABLE_FOR_SINGLE_DATA_NODE.get(settings);
+        this.fileCacheSettings = new FileCacheSettings(settings, clusterSettings);
     }
 
     /**
@@ -138,9 +140,8 @@ public static long sizeOfRelocatingShards(
 
         // Where reserved space is unavailable (e.g. stats are out-of-sync) compute a conservative estimate for initialising shards
         final List<ShardRouting> initializingShards = node.shardsWithState(ShardRoutingState.INITIALIZING);
-        initializingShards.removeIf(shardRouting -> reservedSpace.containsShardId(shardRouting.shardId()));
         for (ShardRouting routing : initializingShards) {
-            if (routing.relocatingNodeId() == null) {
+            if (routing.relocatingNodeId() == null || reservedSpace.containsShardId(routing.shardId())) {
                 // in practice the only initializing-but-not-relocating shards with a nonzero expected shard size will be ones created
                 // by a resize (shrink/split/clone) operation which we expect to happen using hard links, so they shouldn't be taking
                 // any additional space and can be ignored here
@@ -179,6 +180,12 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
          The following block enables allocation for remote shards within safeguard limits of the filecache.
          */
         if (REMOTE_CAPABLE.equals(getNodePool(node)) && REMOTE_CAPABLE.equals(getShardPool(shardRouting, allocation))) {
+            final double dataToFileCacheSizeRatio = fileCacheSettings.getRemoteDataRatio();
+            // we don't need to check the ratio
+            if (dataToFileCacheSizeRatio <= 0.1f) {
+                return Decision.YES;
+            }
+
             final List<ShardRouting> remoteShardsOnNode = StreamSupport.stream(node.spliterator(), false)
                 .filter(shard -> shard.primary() && REMOTE_CAPABLE.equals(getShardPool(shard, allocation)))
                 .collect(Collectors.toList());
@@ -199,7 +206,6 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
             final FileCacheStats fileCacheStats = clusterInfo.getNodeFileCacheStats().getOrDefault(node.nodeId(), null);
             final long nodeCacheSize = fileCacheStats != null ? fileCacheStats.getTotal().getBytes() : 0;
             final long totalNodeRemoteShardSize = currentNodeRemoteShardSize + shardSize;
-            final double dataToFileCacheSizeRatio = DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.get(allocation.metadata().settings());
             if (dataToFileCacheSizeRatio > 0.0f && totalNodeRemoteShardSize > dataToFileCacheSizeRatio * nodeCacheSize) {
                 return allocation.decision(
                     Decision.NO,
@@ -208,6 +214,8 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
                 );
             }
             return Decision.YES;
+        } else if (REMOTE_CAPABLE.equals(getShardPool(shardRouting, allocation))) {
+            return Decision.NO;
         }
 
         Map<String, DiskUsage> usages = clusterInfo.getNodeMostAvailableDiskUsages();
@@ -221,7 +229,14 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
 
         // subtractLeavingShards is passed as false here, because they still use disk space, and therefore we should be extra careful
         // and take the size into account
-        final DiskUsageWithRelocations usage = getDiskUsage(node, allocation, usages, false);
+        final DiskUsageWithRelocations usage = getDiskUsage(
+            node,
+            allocation,
+            usages,
+            clusterInfo.getAvgFreeByte(),
+            clusterInfo.getAvgTotalBytes(),
+            false
+        );
         // First, check that the node currently over the low watermark
         double freeDiskPercentage = usage.getFreeDiskAsPercentage();
         // Cache the used disk percentage for displaying disk percentages consistent with documentation
@@ -483,7 +498,14 @@ public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAl
 
         // subtractLeavingShards is passed as true here, since this is only for shards remaining, we will *eventually* have enough disk
         // since shards are moving away. No new shards will be incoming since in canAllocate we pass false for this check.
-        final DiskUsageWithRelocations usage = getDiskUsage(node, allocation, usages, true);
+        final DiskUsageWithRelocations usage = getDiskUsage(
+            node,
+            allocation,
+            usages,
+            clusterInfo.getAvgFreeByte(),
+            clusterInfo.getAvgTotalBytes(),
+            true
+        );
         final String dataPath = clusterInfo.getDataPath(shardRouting);
         // If this node is already above the high threshold, the shard cannot remain (get it off!)
         final double freeDiskPercentage = usage.getFreeDiskAsPercentage();
@@ -572,13 +594,15 @@ private DiskUsageWithRelocations getDiskUsage(
         RoutingNode node,
         RoutingAllocation allocation,
         final Map<String, DiskUsage> usages,
+        final long avgFreeBytes,
+        final long avgTotalBytes,
         boolean subtractLeavingShards
     ) {
         DiskUsage usage = usages.get(node.nodeId());
         if (usage == null) {
             // If there is no usage, and we have other nodes in the cluster,
             // use the average usage for all nodes as the usage for this node
-            usage = averageUsage(node, usages);
+            usage = new DiskUsage(node.nodeId(), node.node().getName(), "_na_", avgTotalBytes, avgFreeBytes);
             if (logger.isDebugEnabled()) {
                 logger.debug(
                     "unable to determine disk usage for {}, defaulting to average across nodes [{} total] [{} free] [{}% free]",
@@ -610,26 +634,6 @@ private DiskUsageWithRelocations getDiskUsage(
         return diskUsageWithRelocations;
     }
 
-    /**
-     * Returns a {@link DiskUsage} for the {@link RoutingNode} using the
-     * average usage of other nodes in the disk usage map.
-     * @param node Node to return an averaged DiskUsage object for
-     * @param usages Map of nodeId to DiskUsage for all known nodes
-     * @return DiskUsage representing given node using the average disk usage
-     */
-    DiskUsage averageUsage(RoutingNode node, final Map<String, DiskUsage> usages) {
-        if (usages.size() == 0) {
-            return new DiskUsage(node.nodeId(), node.node().getName(), "_na_", 0, 0);
-        }
-        long totalBytes = 0;
-        long freeBytes = 0;
-        for (DiskUsage du : usages.values()) {
-            totalBytes += du.getTotalBytes();
-            freeBytes += du.getFreeBytes();
-        }
-        return new DiskUsage(node.nodeId(), node.node().getName(), "_na_", totalBytes / usages.size(), freeBytes / usages.size());
-    }
-
     /**
      * Given the DiskUsage for a node and the size of the shard, return the
      * percentage of free disk if the shard were to be allocated to the node.
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/RemoteStoreMigrationAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/RemoteStoreMigrationAllocationDecider.java
index 4fc5fff805663..67fe4ea1dcb1b 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/RemoteStoreMigrationAllocationDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/RemoteStoreMigrationAllocationDecider.java
@@ -44,8 +44,6 @@
 import org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode;
 import org.opensearch.node.remotestore.RemoteStoreNodeService.Direction;
 
-import java.util.Locale;
-
 /**
  * A new allocation decider for migration of document replication clusters to remote store backed clusters:
  * - For STRICT compatibility mode, the decision is always YES
@@ -101,7 +99,7 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
         if (migrationDirection.equals(Direction.NONE)) {
             // remote backed indices on docrep nodes and non remote backed indices on remote nodes are not allowed
             boolean isNoDecision = remoteSettingsBackedIndex ^ targetNode.isRemoteStoreNode();
-            String reason = String.format(Locale.ROOT, " for %sremote store backed index", remoteSettingsBackedIndex ? "" : "non ");
+            String reason = " for " + (remoteSettingsBackedIndex ? "" : "non ") + "remote store backed index";
             return allocation.decision(
                 isNoDecision ? Decision.NO : Decision.YES,
                 NAME,
@@ -114,11 +112,9 @@ public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, Routing
             // check for remote store backed indices
             if (remoteSettingsBackedIndex && targetNode.isRemoteStoreNode() == false) {
                 // allocations and relocations must be to a remote node
-                String reason = String.format(
-                    Locale.ROOT,
-                    " because a remote store backed index's shard copy can only be %s to a remote node",
-                    ((shardRouting.assignedToNode() == false) ? "allocated" : "relocated")
-                );
+                String reason = new StringBuilder(" because a remote store backed index's shard copy can only be ").append(
+                    (shardRouting.assignedToNode() == false) ? "allocated" : "relocated"
+                ).append(" to a remote node").toString();
                 return allocation.decision(Decision.NO, NAME, getDecisionDetails(false, shardRouting, targetNode, reason));
             }
 
@@ -168,16 +164,18 @@ private Decision replicaShardDecision(ShardRouting replicaShardRouting, Discover
 
     // get detailed reason for the decision
     private String getDecisionDetails(boolean isYes, ShardRouting shardRouting, DiscoveryNode targetNode, String reason) {
-        return String.format(
-            Locale.ROOT,
-            "[%s migration_direction]: %s shard copy %s be %s to a %s node%s",
-            migrationDirection.direction,
-            (shardRouting.primary() ? "primary" : "replica"),
-            (isYes ? "can" : "can not"),
-            ((shardRouting.assignedToNode() == false) ? "allocated" : "relocated"),
-            (targetNode.isRemoteStoreNode() ? "remote" : "non-remote"),
-            reason
-        );
+        return new StringBuilder("[").append(migrationDirection.direction)
+            .append(" migration_direction]: ")
+            .append(shardRouting.primary() ? "primary" : "replica")
+            .append(" shard copy ")
+            .append(isYes ? "can" : "can not")
+            .append(" be ")
+            .append((shardRouting.assignedToNode() == false) ? "allocated" : "relocated")
+            .append(" to a ")
+            .append(targetNode.isRemoteStoreNode() ? "remote" : "non-remote")
+            .append(" node")
+            .append(reason)
+            .toString();
     }
 
 }
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/SearchReplicaAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/SearchReplicaAllocationDecider.java
new file mode 100644
index 0000000000000..955c396bee4da
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/SearchReplicaAllocationDecider.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation.decider;
+
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeFilters;
+import org.opensearch.cluster.routing.RoutingNode;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.allocation.RoutingAllocation;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.node.remotestore.RemoteStoreNodeService;
+
+import java.util.Map;
+
+import static org.opensearch.cluster.node.DiscoveryNodeFilters.IP_VALIDATOR;
+import static org.opensearch.cluster.node.DiscoveryNodeFilters.OpType.OR;
+
+/**
+ * This allocation decider is similar to FilterAllocationDecider but provides
+ * the option to filter specifically for search replicas.
+ * The filter behaves similar to an include for any defined node attribute.
+ * A search replica can be allocated to only nodes with one of the specified attributes while
+ * other shard types will be rejected from nodes with any othe attributes.
+ * @opensearch.internal
+ */
+public class SearchReplicaAllocationDecider extends AllocationDecider {
+
+    public static final String NAME = "filter";
+    private static final String SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_PREFIX = "cluster.routing.allocation.search.replica.dedicated.include";
+    public static final Setting.AffixSetting<String> SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING = Setting.prefixKeySetting(
+        SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_PREFIX + ".",
+        key -> Setting.simpleString(key, value -> IP_VALIDATOR.accept(key, value), Property.Dynamic, Property.NodeScope)
+    );
+
+    private volatile DiscoveryNodeFilters searchReplicaIncludeFilters;
+
+    private volatile RemoteStoreNodeService.Direction migrationDirection;
+    private volatile RemoteStoreNodeService.CompatibilityMode compatibilityMode;
+
+    public SearchReplicaAllocationDecider(Settings settings, ClusterSettings clusterSettings) {
+        setSearchReplicaIncludeFilters(SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING.getAsMap(settings));
+        clusterSettings.addAffixMapUpdateConsumer(
+            SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING,
+            this::setSearchReplicaIncludeFilters,
+            (a, b) -> {}
+        );
+    }
+
+    @Override
+    public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+        return shouldFilter(shardRouting, node.node(), allocation);
+    }
+
+    @Override
+    public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+        return shouldFilter(shardRouting, node.node(), allocation);
+    }
+
+    private Decision shouldFilter(ShardRouting shardRouting, DiscoveryNode node, RoutingAllocation allocation) {
+        if (searchReplicaIncludeFilters != null) {
+            final boolean match = searchReplicaIncludeFilters.match(node);
+            if (match == false && shardRouting.isSearchOnly()) {
+                return allocation.decision(
+                    Decision.NO,
+                    NAME,
+                    "node does not match shard setting [%s] filters [%s]",
+                    SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_PREFIX,
+                    searchReplicaIncludeFilters
+                );
+            }
+            // filter will only apply to search replicas
+            if (shardRouting.isSearchOnly() == false && match) {
+                return allocation.decision(
+                    Decision.NO,
+                    NAME,
+                    "only search replicas can be allocated to node with setting [%s] filters [%s]",
+                    SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_PREFIX,
+                    searchReplicaIncludeFilters
+                );
+            }
+        }
+        return allocation.decision(Decision.YES, NAME, "node passes include/exclude/require filters");
+    }
+
+    private void setSearchReplicaIncludeFilters(Map<String, String> filters) {
+        searchReplicaIncludeFilters = DiscoveryNodeFilters.trimTier(
+            DiscoveryNodeFilters.buildOrUpdateFromKeyValue(searchReplicaIncludeFilters, OR, filters)
+        );
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ShardsLimitAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ShardsLimitAllocationDecider.java
index c008102554e8c..6f211f370de95 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ShardsLimitAllocationDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ShardsLimitAllocationDecider.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.cluster.routing.allocation.decider;
 
-import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.routing.RoutingNode;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.ShardRoutingState;
@@ -125,8 +124,7 @@ private Decision doDecide(
         RoutingAllocation allocation,
         BiPredicate<Integer, Integer> decider
     ) {
-        IndexMetadata indexMd = allocation.metadata().getIndexSafe(shardRouting.index());
-        final int indexShardLimit = INDEX_TOTAL_SHARDS_PER_NODE_SETTING.get(indexMd.getSettings(), settings);
+        final int indexShardLimit = allocation.metadata().getIndexSafe(shardRouting.index()).getIndexTotalShardsPerNodeLimit();
         // Capture the limit here in case it changes during this method's
         // execution
         final int clusterShardLimit = this.clusterShardLimit;
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/TargetPoolAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/TargetPoolAllocationDecider.java
index 76f9f44077ad8..493d23b57d271 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/TargetPoolAllocationDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/TargetPoolAllocationDecider.java
@@ -87,6 +87,36 @@ public Decision canForceAllocatePrimary(ShardRouting shardRouting, RoutingNode n
         return canAllocate(shardRouting, node, allocation);
     }
 
+    @Override
+    public Decision canRemain(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+        RoutingPool targetPool = RoutingPool.getShardPool(shardRouting, allocation);
+        RoutingPool currentNodePool = RoutingPool.getNodePool(allocation.routingNodes().node(shardRouting.currentNodeId()));
+        if (RoutingPool.REMOTE_CAPABLE.equals(targetPool) && targetPool != currentNodePool) {
+            logger.debug(
+                "Shard: [{}] has current pool: [{}], target pool: [{}]. Cannot remain on node: [{}]",
+                shardRouting.shortSummary(),
+                currentNodePool.name(),
+                RoutingPool.REMOTE_CAPABLE.name(),
+                node.node()
+            );
+            return allocation.decision(
+                Decision.NO,
+                NAME,
+                "Shard %s is allocated on a different pool %s than the target pool %s",
+                shardRouting.shortSummary(),
+                currentNodePool,
+                targetPool
+            );
+        }
+        return allocation.decision(
+            Decision.YES,
+            NAME,
+            "Routing pools are compatible. Shard pool: [%s], node pool: [%s]",
+            currentNodePool,
+            targetPool
+        );
+    }
+
     public Decision shouldAutoExpandToNode(IndexMetadata indexMetadata, DiscoveryNode node, RoutingAllocation allocation) {
         logger.debug("Evaluating node: {} for autoExpandReplica eligibility of index: {}", node, indexMetadata.getIndex());
         return canAllocateInTargetPool(indexMetadata, node, allocation);
diff --git a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ThrottlingAllocationDecider.java b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ThrottlingAllocationDecider.java
index 61e7aaed5ecff..4bde1e282fe78 100644
--- a/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ThrottlingAllocationDecider.java
+++ b/server/src/main/java/org/opensearch/cluster/routing/allocation/decider/ThrottlingAllocationDecider.java
@@ -357,7 +357,7 @@ private ShardRouting initializingShard(ShardRouting shardRouting, String current
     @Override
     public Decision canMoveAway(ShardRouting shardRouting, RoutingAllocation allocation) {
         int outgoingRecoveries = 0;
-        if (!shardRouting.primary()) {
+        if (!shardRouting.primary() && !shardRouting.isSearchOnly()) {
             ShardRouting primaryShard = allocation.routingNodes().activePrimary(shardRouting.shardId());
             outgoingRecoveries = allocation.routingNodes().getOutgoingRecoveries(primaryShard.currentNodeId());
         } else {
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/InternalRemoteRoutingTableService.java b/server/src/main/java/org/opensearch/cluster/routing/remote/InternalRemoteRoutingTableService.java
new file mode 100644
index 0000000000000..c227d964806f0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/InternalRemoteRoutingTableService.java
@@ -0,0 +1,288 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.remote;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
+import org.opensearch.common.remote.RemoteWritableEntityStore;
+import org.opensearch.common.remote.RemoteWriteableEntityBlobStore;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.gateway.remote.RemoteStateTransferException;
+import org.opensearch.gateway.remote.model.RemoteRoutingTableBlobStore;
+import org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable;
+import org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.node.Node;
+import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.Repository;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteRoutingTableEnabled;
+
+/**
+ * A Service which provides APIs to upload and download routing table from remote store.
+ *
+ * @opensearch.internal
+ */
+public class InternalRemoteRoutingTableService extends AbstractLifecycleComponent implements RemoteRoutingTableService {
+
+    private static final Logger logger = LogManager.getLogger(InternalRemoteRoutingTableService.class);
+    private final Settings settings;
+    private final Supplier<RepositoriesService> repositoriesService;
+    private Compressor compressor;
+    private RemoteWritableEntityStore<IndexRoutingTable, RemoteIndexRoutingTable> remoteIndexRoutingTableStore;
+    private RemoteWritableEntityStore<Diff<RoutingTable>, RemoteRoutingTableDiff> remoteRoutingTableDiffStore;
+    private final ClusterSettings clusterSettings;
+    private BlobStoreRepository blobStoreRepository;
+    private final ThreadPool threadPool;
+    private final String clusterName;
+
+    public InternalRemoteRoutingTableService(
+        Supplier<RepositoriesService> repositoriesService,
+        Settings settings,
+        ClusterSettings clusterSettings,
+        ThreadPool threadpool,
+        String clusterName
+    ) {
+        assert isRemoteRoutingTableEnabled(settings) : "Remote routing table is not enabled";
+        this.repositoriesService = repositoriesService;
+        this.settings = settings;
+        this.threadPool = threadpool;
+        this.clusterName = clusterName;
+        this.clusterSettings = clusterSettings;
+    }
+
+    public List<IndexRoutingTable> getIndicesRouting(RoutingTable routingTable) {
+        return new ArrayList<>(routingTable.indicesRouting().values());
+    }
+
+    /**
+     * Returns diff between the two routing tables, which includes upserts and deletes.
+     *
+     * @param before previous routing table
+     * @param after  current routing table
+     * @return incremental diff of the previous and current routing table
+     */
+    @Override
+    public StringKeyDiffProvider<IndexRoutingTable> getIndicesRoutingMapDiff(RoutingTable before, RoutingTable after) {
+        return new RoutingTableIncrementalDiff(before, after);
+    }
+
+    /**
+     * Async action for writing one {@code IndexRoutingTable} to remote store
+     * @param term current term
+     * @param version current version
+     * @param clusterUUID current cluster UUID
+     * @param indexRouting indexRoutingTable to write to remote store
+     * @param latchedActionListener listener for handling async action response
+     */
+    @Override
+    public void getAsyncIndexRoutingWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        IndexRoutingTable indexRouting,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    ) {
+
+        RemoteIndexRoutingTable remoteIndexRoutingTable = new RemoteIndexRoutingTable(indexRouting, clusterUUID, compressor, term, version);
+
+        ActionListener<Void> completionListener = ActionListener.wrap(
+            resp -> latchedActionListener.onResponse(remoteIndexRoutingTable.getUploadedMetadata()),
+            ex -> latchedActionListener.onFailure(
+                new RemoteStateTransferException("Exception in writing index to remote store: " + indexRouting.getIndex().toString(), ex)
+            )
+        );
+
+        remoteIndexRoutingTableStore.writeAsync(remoteIndexRoutingTable, completionListener);
+    }
+
+    @Override
+    public void getAsyncIndexRoutingDiffWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        StringKeyDiffProvider<IndexRoutingTable> routingTableDiff,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    ) {
+        RemoteRoutingTableDiff remoteRoutingTableDiff = new RemoteRoutingTableDiff(
+            (RoutingTableIncrementalDiff) routingTableDiff,
+            clusterUUID,
+            compressor,
+            term,
+            version
+        );
+        ActionListener<Void> completionListener = ActionListener.wrap(
+            resp -> latchedActionListener.onResponse(remoteRoutingTableDiff.getUploadedMetadata()),
+            ex -> latchedActionListener.onFailure(
+                new RemoteStateTransferException("Exception in writing index routing diff to remote store", ex)
+            )
+        );
+
+        remoteRoutingTableDiffStore.writeAsync(remoteRoutingTableDiff, completionListener);
+    }
+
+    /**
+     * Combines IndicesRoutingMetadata from previous manifest and current uploaded indices, removes deleted indices.
+     * @param previousManifest previous manifest, used to get all existing indices routing paths
+     * @param indicesRoutingUploaded current uploaded indices routings
+     * @param indicesRoutingToDelete indices to delete
+     * @return combined list of metadata
+     */
+    public List<ClusterMetadataManifest.UploadedIndexMetadata> getAllUploadedIndicesRouting(
+        ClusterMetadataManifest previousManifest,
+        List<ClusterMetadataManifest.UploadedIndexMetadata> indicesRoutingUploaded,
+        List<String> indicesRoutingToDelete
+    ) {
+        final Map<String, ClusterMetadataManifest.UploadedIndexMetadata> allUploadedIndicesRouting = previousManifest.getIndicesRouting()
+            .stream()
+            .collect(Collectors.toMap(ClusterMetadataManifest.UploadedIndexMetadata::getIndexName, Function.identity()));
+
+        indicesRoutingUploaded.forEach(
+            uploadedIndexRouting -> allUploadedIndicesRouting.put(uploadedIndexRouting.getIndexName(), uploadedIndexRouting)
+        );
+        indicesRoutingToDelete.forEach(allUploadedIndicesRouting::remove);
+
+        return new ArrayList<>(allUploadedIndicesRouting.values());
+    }
+
+    @Override
+    public void getAsyncIndexRoutingReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<IndexRoutingTable> latchedActionListener
+    ) {
+
+        ActionListener<IndexRoutingTable> actionListener = ActionListener.wrap(
+            latchedActionListener::onResponse,
+            latchedActionListener::onFailure
+        );
+
+        RemoteIndexRoutingTable remoteIndexRoutingTable = new RemoteIndexRoutingTable(uploadedFilename, clusterUUID, compressor);
+
+        remoteIndexRoutingTableStore.readAsync(remoteIndexRoutingTable, actionListener);
+    }
+
+    @Override
+    public void getAsyncIndexRoutingTableDiffReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<Diff<RoutingTable>> latchedActionListener
+    ) {
+        ActionListener<Diff<RoutingTable>> actionListener = ActionListener.wrap(
+            latchedActionListener::onResponse,
+            latchedActionListener::onFailure
+        );
+
+        RemoteRoutingTableDiff remoteRoutingTableDiff = new RemoteRoutingTableDiff(uploadedFilename, clusterUUID, compressor);
+        remoteRoutingTableDiffStore.readAsync(remoteRoutingTableDiff, actionListener);
+    }
+
+    @Override
+    public List<ClusterMetadataManifest.UploadedIndexMetadata> getUpdatedIndexRoutingTableMetadata(
+        List<String> updatedIndicesRouting,
+        List<ClusterMetadataManifest.UploadedIndexMetadata> allIndicesRouting
+    ) {
+        return updatedIndicesRouting.stream().map(idx -> {
+            Optional<ClusterMetadataManifest.UploadedIndexMetadata> uploadedIndexMetadataOptional = allIndicesRouting.stream()
+                .filter(idx2 -> idx2.getIndexName().equals(idx))
+                .findFirst();
+            assert uploadedIndexMetadataOptional.isPresent() == true;
+            return uploadedIndexMetadataOptional.get();
+        }).collect(Collectors.toList());
+    }
+
+    @Override
+    protected void doClose() throws IOException {
+        if (blobStoreRepository != null) {
+            IOUtils.close(blobStoreRepository);
+        }
+    }
+
+    @Override
+    protected void doStart() {
+        assert isRemoteRoutingTableEnabled(settings) == true : "Remote routing table is not enabled";
+        final String remoteStoreRepo = settings.get(
+            Node.NODE_ATTRIBUTES.getKey() + RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY
+        );
+        assert remoteStoreRepo != null : "Remote routing table repository is not configured";
+        final Repository repository = repositoriesService.get().repository(remoteStoreRepo);
+        assert repository instanceof BlobStoreRepository : "Repository should be instance of BlobStoreRepository";
+        blobStoreRepository = (BlobStoreRepository) repository;
+        compressor = blobStoreRepository.getCompressor();
+
+        this.remoteIndexRoutingTableStore = new RemoteRoutingTableBlobStore<>(
+            new BlobStoreTransferService(blobStoreRepository.blobStore(), threadPool),
+            blobStoreRepository,
+            clusterName,
+            threadPool,
+            ThreadPool.Names.REMOTE_STATE_READ,
+            clusterSettings
+        );
+
+        this.remoteRoutingTableDiffStore = new RemoteWriteableEntityBlobStore<>(
+            new BlobStoreTransferService(blobStoreRepository.blobStore(), threadPool),
+            blobStoreRepository,
+            clusterName,
+            threadPool,
+            ThreadPool.Names.REMOTE_STATE_READ,
+            RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+        );
+    }
+
+    @Override
+    protected void doStop() {}
+
+    @Override
+    public void deleteStaleIndexRoutingPaths(List<String> stalePaths) throws IOException {
+        try {
+            logger.debug(() -> "Deleting stale index routing files from remote - " + stalePaths);
+            blobStoreRepository.blobStore().blobContainer(BlobPath.cleanPath()).deleteBlobsIgnoringIfNotExists(stalePaths);
+        } catch (IOException e) {
+            logger.error(() -> new ParameterizedMessage("Failed to delete some stale index routing paths from {}", stalePaths), e);
+            throw e;
+        }
+    }
+
+    public void deleteStaleIndexRoutingDiffPaths(List<String> stalePaths) throws IOException {
+        try {
+            logger.debug(() -> "Deleting stale index routing diff files from remote - " + stalePaths);
+            blobStoreRepository.blobStore().blobContainer(BlobPath.cleanPath()).deleteBlobsIgnoringIfNotExists(stalePaths);
+        } catch (IOException e) {
+            logger.error(() -> new ParameterizedMessage("Failed to delete some stale index routing diff paths from {}", stalePaths), e);
+            throw e;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/NoopRemoteRoutingTableService.java b/server/src/main/java/org/opensearch/cluster/routing/remote/NoopRemoteRoutingTableService.java
new file mode 100644
index 0000000000000..17687199c39d6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/NoopRemoteRoutingTableService.java
@@ -0,0 +1,120 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.remote;
+
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Noop impl for RemoteRoutingTableService.
+ */
+public class NoopRemoteRoutingTableService extends AbstractLifecycleComponent implements RemoteRoutingTableService {
+
+    @Override
+    public List<IndexRoutingTable> getIndicesRouting(RoutingTable routingTable) {
+        return List.of();
+    }
+
+    @Override
+    public StringKeyDiffProvider<IndexRoutingTable> getIndicesRoutingMapDiff(RoutingTable before, RoutingTable after) {
+        return new RoutingTableIncrementalDiff(RoutingTable.builder().build(), RoutingTable.builder().build());
+    }
+
+    @Override
+    public void getAsyncIndexRoutingWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        IndexRoutingTable indexRouting,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    ) {
+        // noop
+    }
+
+    @Override
+    public void getAsyncIndexRoutingDiffWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        StringKeyDiffProvider<IndexRoutingTable> routingTableDiff,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    ) {
+        // noop
+    }
+
+    @Override
+    public List<ClusterMetadataManifest.UploadedIndexMetadata> getAllUploadedIndicesRouting(
+        ClusterMetadataManifest previousManifest,
+        List<ClusterMetadataManifest.UploadedIndexMetadata> indicesRoutingUploaded,
+        List<String> indicesRoutingToDelete
+    ) {
+        // noop
+        return List.of();
+    }
+
+    @Override
+    public void getAsyncIndexRoutingReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<IndexRoutingTable> latchedActionListener
+    ) {
+        // noop
+    }
+
+    @Override
+    public void getAsyncIndexRoutingTableDiffReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<Diff<RoutingTable>> latchedActionListener
+    ) {
+        // noop
+    }
+
+    @Override
+    public List<ClusterMetadataManifest.UploadedIndexMetadata> getUpdatedIndexRoutingTableMetadata(
+        List<String> updatedIndicesRouting,
+        List<ClusterMetadataManifest.UploadedIndexMetadata> allIndicesRouting
+    ) {
+        // noop
+        return List.of();
+    }
+
+    @Override
+    protected void doStart() {
+        // noop
+    }
+
+    @Override
+    protected void doStop() {
+        // noop
+    }
+
+    @Override
+    protected void doClose() throws IOException {
+        // noop
+    }
+
+    @Override
+    public void deleteStaleIndexRoutingPaths(List<String> stalePaths) throws IOException {
+        // noop
+    }
+
+    public void deleteStaleIndexRoutingDiffPaths(List<String> stalePaths) throws IOException {
+        // noop
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableService.java b/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableService.java
new file mode 100644
index 0000000000000..d7ef3a29aa21f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableService.java
@@ -0,0 +1,76 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.remote;
+
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.common.lifecycle.LifecycleComponent;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * A Service which provides APIs to upload and download routing table from remote store.
+ *
+ * @opensearch.internal
+ */
+public interface RemoteRoutingTableService extends LifecycleComponent {
+
+    List<IndexRoutingTable> getIndicesRouting(RoutingTable routingTable);
+
+    void getAsyncIndexRoutingReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<IndexRoutingTable> latchedActionListener
+    );
+
+    void getAsyncIndexRoutingTableDiffReadAction(
+        String clusterUUID,
+        String uploadedFilename,
+        LatchedActionListener<Diff<RoutingTable>> latchedActionListener
+    );
+
+    List<ClusterMetadataManifest.UploadedIndexMetadata> getUpdatedIndexRoutingTableMetadata(
+        List<String> updatedIndicesRouting,
+        List<ClusterMetadataManifest.UploadedIndexMetadata> allIndicesRouting
+    );
+
+    StringKeyDiffProvider<IndexRoutingTable> getIndicesRoutingMapDiff(RoutingTable before, RoutingTable after);
+
+    void getAsyncIndexRoutingWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        IndexRoutingTable indexRouting,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    );
+
+    void getAsyncIndexRoutingDiffWriteAction(
+        String clusterUUID,
+        long term,
+        long version,
+        StringKeyDiffProvider<IndexRoutingTable> routingTableDiff,
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> latchedActionListener
+    );
+
+    List<ClusterMetadataManifest.UploadedIndexMetadata> getAllUploadedIndicesRouting(
+        ClusterMetadataManifest previousManifest,
+        List<ClusterMetadataManifest.UploadedIndexMetadata> indicesRoutingUploaded,
+        List<String> indicesRoutingToDelete
+    );
+
+    void deleteStaleIndexRoutingPaths(List<String> stalePaths) throws IOException;
+
+    void deleteStaleIndexRoutingDiffPaths(List<String> stalePaths) throws IOException;
+
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactory.java b/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactory.java
new file mode 100644
index 0000000000000..56dfa03215a64
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactory.java
@@ -0,0 +1,45 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.remote;
+
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.util.function.Supplier;
+
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteRoutingTableEnabled;
+
+/**
+ * Factory to provide impl for RemoteRoutingTableService based on settings.
+ */
+public class RemoteRoutingTableServiceFactory {
+
+    /**
+     * Returns {@code DefaultRemoteRoutingTableService} if the feature is enabled, otherwise {@code NoopRemoteRoutingTableService}
+     * @param repositoriesService repositoriesService
+     * @param settings settings
+     * @param clusterSettings clusterSettings
+     * @param threadPool threadPool
+     * @return RemoteRoutingTableService
+     */
+    public static RemoteRoutingTableService getService(
+        Supplier<RepositoriesService> repositoriesService,
+        Settings settings,
+        ClusterSettings clusterSettings,
+        ThreadPool threadPool,
+        String clusterName
+    ) {
+        if (isRemoteRoutingTableEnabled(settings)) {
+            return new InternalRemoteRoutingTableService(repositoriesService, settings, clusterSettings, threadPool, clusterName);
+        }
+        return new NoopRemoteRoutingTableService();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/cluster/routing/remote/package-info.java b/server/src/main/java/org/opensearch/cluster/routing/remote/package-info.java
new file mode 100644
index 0000000000000..9fe016e783f20
--- /dev/null
+++ b/server/src/main/java/org/opensearch/cluster/routing/remote/package-info.java
@@ -0,0 +1,10 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/** Package containing class to perform operations on remote routing table */
+package org.opensearch.cluster.routing.remote;
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
index a55721fb13cdc..b2548a8976c73 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterApplierService.java
@@ -36,6 +36,7 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.cluster.ClusterChangedEvent;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateApplier;
 import org.opensearch.cluster.ClusterStateListener;
@@ -60,7 +61,10 @@
 import org.opensearch.common.util.concurrent.OpenSearchExecutors;
 import org.opensearch.common.util.concurrent.PrioritizedOpenSearchThreadPoolExecutor;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
+import org.opensearch.telemetry.metrics.tags.Tags;
 import org.opensearch.threadpool.Scheduler;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -68,6 +72,7 @@
 import java.util.Collection;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CountDownLatch;
@@ -120,8 +125,19 @@ public class ClusterApplierService extends AbstractLifecycleComponent implements
     private final String nodeName;
 
     private NodeConnectionsService nodeConnectionsService;
+    private final ClusterManagerMetrics clusterManagerMetrics;
 
     public ClusterApplierService(String nodeName, Settings settings, ClusterSettings clusterSettings, ThreadPool threadPool) {
+        this(nodeName, settings, clusterSettings, threadPool, new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE));
+    }
+
+    public ClusterApplierService(
+        String nodeName,
+        Settings settings,
+        ClusterSettings clusterSettings,
+        ThreadPool threadPool,
+        ClusterManagerMetrics clusterManagerMetrics
+    ) {
         this.clusterSettings = clusterSettings;
         this.threadPool = threadPool;
         this.state = new AtomicReference<>();
@@ -132,6 +148,7 @@ public ClusterApplierService(String nodeName, Settings settings, ClusterSettings
             CLUSTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING,
             this::setSlowTaskLoggingThreshold
         );
+        this.clusterManagerMetrics = clusterManagerMetrics;
     }
 
     private void setSlowTaskLoggingThreshold(TimeValue slowTaskLoggingThreshold) {
@@ -380,7 +397,7 @@ private void submitStateUpdateTask(
         final ThreadContext threadContext = threadPool.getThreadContext();
         final Supplier<ThreadContext.StoredContext> supplier = threadContext.newRestorableContext(true);
         try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             final UpdateTask updateTask = new UpdateTask(
                 config.priority(),
                 source,
@@ -597,7 +614,7 @@ private void callClusterStateAppliers(ClusterChangedEvent clusterChangedEvent, S
         callClusterStateAppliers(clusterChangedEvent, stopWatch, lowPriorityStateAppliers);
     }
 
-    private static void callClusterStateAppliers(
+    private void callClusterStateAppliers(
         ClusterChangedEvent clusterChangedEvent,
         StopWatch stopWatch,
         Collection<ClusterStateApplier> clusterStateAppliers
@@ -605,7 +622,13 @@ private static void callClusterStateAppliers(
         for (ClusterStateApplier applier : clusterStateAppliers) {
             logger.trace("calling [{}] with change to version [{}]", applier, clusterChangedEvent.state().version());
             try (TimingHandle ignored = stopWatch.timing("running applier [" + applier + "]")) {
+                long applierStartTimeNS = System.nanoTime();
                 applier.applyClusterState(clusterChangedEvent);
+                clusterManagerMetrics.recordLatency(
+                    clusterManagerMetrics.clusterStateAppliersHistogram,
+                    (double) Math.max(0, TimeValue.nsecToMSec(System.nanoTime() - applierStartTimeNS)),
+                    Optional.of(Tags.create().addTag("Operation", applier.getClass().getSimpleName()))
+                );
             }
         }
     }
@@ -624,7 +647,13 @@ private void callClusterStateListener(
             try {
                 logger.trace("calling [{}] with change to version [{}]", listener, clusterChangedEvent.state().version());
                 try (TimingHandle ignored = stopWatch.timing("notifying listener [" + listener + "]")) {
+                    long listenerStartTimeNS = System.nanoTime();
                     listener.clusterChanged(clusterChangedEvent);
+                    clusterManagerMetrics.recordLatency(
+                        clusterManagerMetrics.clusterStateListenersHistogram,
+                        (double) Math.max(0, TimeValue.nsecToMSec(System.nanoTime() - listenerStartTimeNS)),
+                        Optional.of(Tags.create().addTag("Operation", listener.getClass().getSimpleName()))
+                    );
                 }
             } catch (Exception ex) {
                 logger.warn("failed to notify ClusterStateListener", ex);
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterManagerService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterManagerService.java
index e9224596e048d..fa8c965b4d538 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterManagerService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterManagerService.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.cluster.service;
 
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
@@ -20,7 +21,17 @@
  */
 @PublicApi(since = "2.2.0")
 public class ClusterManagerService extends MasterService {
+
     public ClusterManagerService(Settings settings, ClusterSettings clusterSettings, ThreadPool threadPool) {
         super(settings, clusterSettings, threadPool);
     }
+
+    public ClusterManagerService(
+        Settings settings,
+        ClusterSettings clusterSettings,
+        ThreadPool threadPool,
+        ClusterManagerMetrics clusterManagerMetrics
+    ) {
+        super(settings, clusterSettings, threadPool, clusterManagerMetrics);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
index aa7766979e851..c3c48dd8b87ef 100644
--- a/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/ClusterService.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.cluster.service;
 
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateApplier;
@@ -53,6 +54,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.index.IndexingPressureService;
 import org.opensearch.node.Node;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.util.Collections;
@@ -92,11 +94,20 @@ public class ClusterService extends AbstractLifecycleComponent {
     private IndexingPressureService indexingPressureService;
 
     public ClusterService(Settings settings, ClusterSettings clusterSettings, ThreadPool threadPool) {
+        this(settings, clusterSettings, threadPool, new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE));
+    }
+
+    public ClusterService(
+        Settings settings,
+        ClusterSettings clusterSettings,
+        ThreadPool threadPool,
+        ClusterManagerMetrics clusterManagerMetrics
+    ) {
         this(
             settings,
             clusterSettings,
-            new ClusterManagerService(settings, clusterSettings, threadPool),
-            new ClusterApplierService(Node.NODE_NAME_SETTING.get(settings), settings, clusterSettings, threadPool)
+            new ClusterManagerService(settings, clusterSettings, threadPool, clusterManagerMetrics),
+            new ClusterApplierService(Node.NODE_NAME_SETTING.get(settings), settings, clusterSettings, threadPool, clusterManagerMetrics)
         );
     }
 
diff --git a/server/src/main/java/org/opensearch/cluster/service/MasterService.java b/server/src/main/java/org/opensearch/cluster/service/MasterService.java
index af3e4f8437c43..713de8cdd0fda 100644
--- a/server/src/main/java/org/opensearch/cluster/service/MasterService.java
+++ b/server/src/main/java/org/opensearch/cluster/service/MasterService.java
@@ -39,6 +39,7 @@
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.cluster.AckedClusterStateTaskListener;
 import org.opensearch.cluster.ClusterChangedEvent;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterState.Builder;
 import org.opensearch.cluster.ClusterStateTaskConfig;
@@ -65,11 +66,14 @@
 import org.opensearch.common.util.concurrent.OpenSearchExecutors;
 import org.opensearch.common.util.concurrent.PrioritizedOpenSearchThreadPoolExecutor;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.Assertions;
 import org.opensearch.core.common.text.Text;
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.discovery.Discovery;
 import org.opensearch.node.Node;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
+import org.opensearch.telemetry.metrics.tags.Tags;
 import org.opensearch.threadpool.Scheduler;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -79,7 +83,9 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
@@ -135,8 +141,18 @@ public class MasterService extends AbstractLifecycleComponent {
     protected final ClusterManagerTaskThrottler clusterManagerTaskThrottler;
     private final ClusterManagerThrottlingStats throttlingStats;
     private final ClusterStateStats stateStats;
+    private final ClusterManagerMetrics clusterManagerMetrics;
 
     public MasterService(Settings settings, ClusterSettings clusterSettings, ThreadPool threadPool) {
+        this(settings, clusterSettings, threadPool, new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE));
+    }
+
+    public MasterService(
+        Settings settings,
+        ClusterSettings clusterSettings,
+        ThreadPool threadPool,
+        ClusterManagerMetrics clusterManagerMetrics
+    ) {
         this.nodeName = Objects.requireNonNull(Node.NODE_NAME_SETTING.get(settings));
 
         this.slowTaskLoggingThreshold = CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(settings);
@@ -154,6 +170,7 @@ public MasterService(Settings settings, ClusterSettings clusterSettings, ThreadP
         );
         this.stateStats = new ClusterStateStats();
         this.threadPool = threadPool;
+        this.clusterManagerMetrics = clusterManagerMetrics;
     }
 
     private void setSlowTaskLoggingThreshold(TimeValue slowTaskLoggingThreshold) {
@@ -206,10 +223,10 @@ protected void onTimeout(List<? extends BatchedTask> tasks, TimeValue timeout) {
         }
 
         @Override
-        protected void run(Object batchingKey, List<? extends BatchedTask> tasks, String tasksSummary) {
+        protected void run(Object batchingKey, List<? extends BatchedTask> tasks, Function<Boolean, String> taskSummaryGenerator) {
             ClusterStateTaskExecutor<Object> taskExecutor = (ClusterStateTaskExecutor<Object>) batchingKey;
             List<UpdateTask> updateTasks = (List<UpdateTask>) tasks;
-            runTasks(new TaskInputs(taskExecutor, updateTasks, tasksSummary));
+            runTasks(new TaskInputs(taskExecutor, updateTasks, taskSummaryGenerator));
         }
 
         class UpdateTask extends BatchedTask {
@@ -282,42 +299,55 @@ public static boolean assertNotMasterUpdateThread(String reason) {
     }
 
     private void runTasks(TaskInputs taskInputs) {
-        final String summary = taskInputs.summary;
+        final String longSummary = logger.isTraceEnabled() ? taskInputs.taskSummaryGenerator.apply(true) : "";
+        final String shortSummary = taskInputs.taskSummaryGenerator.apply(false);
+
         if (!lifecycle.started()) {
-            logger.debug("processing [{}]: ignoring, cluster-manager service not started", summary);
+            logger.debug("processing [{}]: ignoring, cluster-manager service not started", shortSummary);
             return;
         }
 
-        logger.debug("executing cluster state update for [{}]", summary);
+        if (logger.isTraceEnabled()) {
+            logger.trace("executing cluster state update for [{}]", longSummary);
+        } else {
+            logger.debug("executing cluster state update for [{}]", shortSummary);
+        }
+
         final ClusterState previousClusterState = state();
 
         if (!previousClusterState.nodes().isLocalNodeElectedClusterManager() && taskInputs.runOnlyWhenClusterManager()) {
-            logger.debug("failing [{}]: local node is no longer cluster-manager", summary);
+            logger.debug("failing [{}]: local node is no longer cluster-manager", shortSummary);
             taskInputs.onNoLongerClusterManager();
             return;
         }
 
         final long computationStartTime = threadPool.preciseRelativeTimeInNanos();
-        final TaskOutputs taskOutputs = calculateTaskOutputs(taskInputs, previousClusterState);
+        final TaskOutputs taskOutputs = calculateTaskOutputs(taskInputs, previousClusterState, shortSummary);
         taskOutputs.notifyFailedTasks();
         final TimeValue computationTime = getTimeSince(computationStartTime);
-        logExecutionTime(computationTime, "compute cluster state update", summary);
+        logExecutionTime(computationTime, "compute cluster state update", shortSummary);
+
+        clusterManagerMetrics.recordLatency(
+            clusterManagerMetrics.clusterStateComputeHistogram,
+            (double) computationTime.getMillis(),
+            Optional.of(Tags.create().addTag("Operation", taskInputs.executor.getClass().getSimpleName()))
+        );
 
         if (taskOutputs.clusterStateUnchanged()) {
             final long notificationStartTime = threadPool.preciseRelativeTimeInNanos();
             taskOutputs.notifySuccessfulTasksOnUnchangedClusterState();
             final TimeValue executionTime = getTimeSince(notificationStartTime);
-            logExecutionTime(executionTime, "notify listeners on unchanged cluster state", summary);
+            logExecutionTime(executionTime, "notify listeners on unchanged cluster state", shortSummary);
         } else {
             final ClusterState newClusterState = taskOutputs.newClusterState;
             if (logger.isTraceEnabled()) {
-                logger.trace("cluster state updated, source [{}]\n{}", summary, newClusterState);
+                logger.trace("cluster state updated, source [{}]\n{}", longSummary, newClusterState);
             } else {
-                logger.debug("cluster state updated, version [{}], source [{}]", newClusterState.version(), summary);
+                logger.debug("cluster state updated, version [{}], source [{}]", newClusterState.version(), shortSummary);
             }
             final long publicationStartTime = threadPool.preciseRelativeTimeInNanos();
             try {
-                ClusterChangedEvent clusterChangedEvent = new ClusterChangedEvent(summary, newClusterState, previousClusterState);
+                ClusterChangedEvent clusterChangedEvent = new ClusterChangedEvent(shortSummary, newClusterState, previousClusterState);
                 // new cluster state, notify all listeners
                 final DiscoveryNodes.Delta nodesDelta = clusterChangedEvent.nodesDelta();
                 if (nodesDelta.hasChanges() && logger.isInfoEnabled()) {
@@ -325,7 +355,7 @@ private void runTasks(TaskInputs taskInputs) {
                     if (nodesDeltaSummary.length() > 0) {
                         logger.info(
                             "{}, term: {}, version: {}, delta: {}",
-                            summary,
+                            shortSummary,
                             newClusterState.term(),
                             newClusterState.version(),
                             nodesDeltaSummary
@@ -336,7 +366,7 @@ private void runTasks(TaskInputs taskInputs) {
                 logger.debug("publishing cluster state version [{}]", newClusterState.version());
                 publish(clusterChangedEvent, taskOutputs, publicationStartTime);
             } catch (Exception e) {
-                handleException(summary, publicationStartTime, newClusterState, e);
+                handleException(shortSummary, publicationStartTime, newClusterState, e);
             }
         }
     }
@@ -361,6 +391,7 @@ protected boolean blockingAllowed() {
             final long durationMillis = getTimeSince(startTimeNanos).millis();
             stateStats.stateUpdateTook(durationMillis);
             stateStats.stateUpdated();
+            clusterManagerMetrics.recordLatency(clusterManagerMetrics.clusterStatePublishHistogram, (double) durationMillis);
         } catch (Exception e) {
             stateStats.stateUpdateFailed();
             onPublicationFailed(clusterChangedEvent, taskOutputs, startTimeNanos, e);
@@ -430,8 +461,8 @@ private void handleException(String summary, long startTimeMillis, ClusterState
         // TODO: do we want to call updateTask.onFailure here?
     }
 
-    private TaskOutputs calculateTaskOutputs(TaskInputs taskInputs, ClusterState previousClusterState) {
-        ClusterTasksResult<Object> clusterTasksResult = executeTasks(taskInputs, previousClusterState);
+    private TaskOutputs calculateTaskOutputs(TaskInputs taskInputs, ClusterState previousClusterState, String taskSummary) {
+        ClusterTasksResult<Object> clusterTasksResult = executeTasks(taskInputs, previousClusterState, taskSummary);
         ClusterState newClusterState = patchVersions(previousClusterState, clusterTasksResult);
         return new TaskOutputs(
             taskInputs,
@@ -875,7 +906,7 @@ public void onTimeout() {
         }
     }
 
-    private ClusterTasksResult<Object> executeTasks(TaskInputs taskInputs, ClusterState previousClusterState) {
+    private ClusterTasksResult<Object> executeTasks(TaskInputs taskInputs, ClusterState previousClusterState, String taskSummary) {
         ClusterTasksResult<Object> clusterTasksResult;
         try {
             List<Object> inputs = taskInputs.updateTasks.stream().map(tUpdateTask -> tUpdateTask.task).collect(Collectors.toList());
@@ -891,7 +922,7 @@ private ClusterTasksResult<Object> executeTasks(TaskInputs taskInputs, ClusterSt
                     "failed to execute cluster state update (on version: [{}], uuid: [{}]) for [{}]\n{}{}{}",
                     previousClusterState.version(),
                     previousClusterState.stateUUID(),
-                    taskInputs.summary,
+                    taskSummary,
                     previousClusterState.nodes(),
                     previousClusterState.routingTable(),
                     previousClusterState.getRoutingNodes()
@@ -933,14 +964,19 @@ private List<Batcher.UpdateTask> getNonFailedTasks(TaskInputs taskInputs, Cluste
      * Represents a set of tasks to be processed together with their executor
      */
     private class TaskInputs {
-        final String summary;
+
         final List<Batcher.UpdateTask> updateTasks;
         final ClusterStateTaskExecutor<Object> executor;
+        final Function<Boolean, String> taskSummaryGenerator;
 
-        TaskInputs(ClusterStateTaskExecutor<Object> executor, List<Batcher.UpdateTask> updateTasks, String summary) {
-            this.summary = summary;
+        TaskInputs(
+            ClusterStateTaskExecutor<Object> executor,
+            List<Batcher.UpdateTask> updateTasks,
+            final Function<Boolean, String> taskSummaryGenerator
+        ) {
             this.executor = executor;
             this.updateTasks = updateTasks;
+            this.taskSummaryGenerator = taskSummaryGenerator;
         }
 
         boolean runOnlyWhenClusterManager() {
@@ -987,7 +1023,7 @@ public <T> void submitStateUpdateTasks(
         final ThreadContext threadContext = threadPool.getThreadContext();
         final Supplier<ThreadContext.StoredContext> supplier = threadContext.newRestorableContext(true);
         try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
 
             List<Batcher.UpdateTask> safeTasks = tasks.entrySet()
                 .stream()
diff --git a/server/src/main/java/org/opensearch/cluster/service/TaskBatcher.java b/server/src/main/java/org/opensearch/cluster/service/TaskBatcher.java
index 5e58f495a16fb..3513bfffb7157 100644
--- a/server/src/main/java/org/opensearch/cluster/service/TaskBatcher.java
+++ b/server/src/main/java/org/opensearch/cluster/service/TaskBatcher.java
@@ -177,7 +177,6 @@ void runIfNotProcessed(BatchedTask updateTask) {
         // to give other tasks with different batching key a chance to execute.
         if (updateTask.processed.get() == false) {
             final List<BatchedTask> toExecute = new ArrayList<>();
-            final Map<String, List<BatchedTask>> processTasksBySource = new HashMap<>();
             // While removing task, need to remove task first from taskMap and then remove identity from identityMap.
             // Changing this order might lead to duplicate task during submission.
             LinkedHashSet<BatchedTask> pending = tasksPerBatchingKey.remove(updateTask.batchingKey);
@@ -187,7 +186,6 @@ void runIfNotProcessed(BatchedTask updateTask) {
                     if (task.processed.getAndSet(true) == false) {
                         logger.trace("will process {}", task);
                         toExecute.add(task);
-                        processTasksBySource.computeIfAbsent(task.source, s -> new ArrayList<>()).add(task);
                     } else {
                         logger.trace("skipping {}, already processed", task);
                     }
@@ -195,22 +193,34 @@ void runIfNotProcessed(BatchedTask updateTask) {
             }
 
             if (toExecute.isEmpty() == false) {
-                final String tasksSummary = processTasksBySource.entrySet().stream().map(entry -> {
-                    String tasks = updateTask.describeTasks(entry.getValue());
-                    return tasks.isEmpty() ? entry.getKey() : entry.getKey() + "[" + tasks + "]";
-                }).reduce((s1, s2) -> s1 + ", " + s2).orElse("");
-
+                Function<Boolean, String> taskSummaryGenerator = (longSummaryRequired) -> {
+                    if (longSummaryRequired == null || !longSummaryRequired) {
+                        return buildShortSummary(updateTask.batchingKey, toExecute.size());
+                    }
+                    final Map<String, List<BatchedTask>> processTasksBySource = new HashMap<>();
+                    for (final BatchedTask task : toExecute) {
+                        processTasksBySource.computeIfAbsent(task.source, s -> new ArrayList<>()).add(task);
+                    }
+                    return processTasksBySource.entrySet().stream().map(entry -> {
+                        String tasks = updateTask.describeTasks(entry.getValue());
+                        return tasks.isEmpty() ? entry.getKey() : entry.getKey() + "[" + tasks + "]";
+                    }).reduce((s1, s2) -> s1 + ", " + s2).orElse("");
+                };
                 taskBatcherListener.onBeginProcessing(toExecute);
-                run(updateTask.batchingKey, toExecute, tasksSummary);
+                run(updateTask.batchingKey, toExecute, taskSummaryGenerator);
             }
         }
     }
 
+    private String buildShortSummary(final Object batchingKey, final int taskCount) {
+        return "Tasks batched with key: " + batchingKey.toString().split("\\$")[0] + " and count: " + taskCount;
+    }
+
     /**
      * Action to be implemented by the specific batching implementation
      * All tasks have the given batching key.
      */
-    protected abstract void run(Object batchingKey, List<? extends BatchedTask> tasks, String tasksSummary);
+    protected abstract void run(Object batchingKey, List<? extends BatchedTask> tasks, Function<Boolean, String> taskSummaryGenerator);
 
     /**
      * Represents a runnable task that supports batching.
diff --git a/server/src/main/java/org/opensearch/common/blobstore/BlobPath.java b/server/src/main/java/org/opensearch/common/blobstore/BlobPath.java
index d64f47516e094..076c49ffa6d45 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/BlobPath.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/BlobPath.java
@@ -39,6 +39,7 @@
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * The list of paths where a blob can reside.  The contents of the paths are dependent upon the implementation of {@link BlobContainer}.
@@ -110,6 +111,19 @@ public BlobPath parent() {
         }
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        BlobPath that = (BlobPath) o;
+        return Objects.equals(paths, that.paths);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(paths);
+    }
+
     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder();
diff --git a/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobContainer.java b/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobContainer.java
index d0933741339d9..f58b99daec3c5 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobContainer.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobContainer.java
@@ -9,6 +9,7 @@
 package org.opensearch.common.blobstore;
 
 import org.opensearch.common.CheckedBiConsumer;
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.crypto.CryptoHandler;
 import org.opensearch.common.crypto.DecryptedRangedStreamProvider;
 import org.opensearch.common.crypto.EncryptedHeaderContentSupplier;
@@ -50,6 +51,14 @@ public InputStream readBlob(String blobName) throws IOException {
         return cryptoHandler.createDecryptingStream(inputStream);
     }
 
+    @ExperimentalApi
+    @Override
+    public InputStreamWithMetadata readBlobWithMetadata(String blobName) throws IOException {
+        InputStreamWithMetadata inputStreamWithMetadata = blobContainer.readBlobWithMetadata(blobName);
+        InputStream decryptInputStream = cryptoHandler.createDecryptingStream(inputStreamWithMetadata.getInputStream());
+        return new InputStreamWithMetadata(decryptInputStream, inputStreamWithMetadata.getMetadata());
+    }
+
     EncryptedHeaderContentSupplier getEncryptedHeaderContentSupplier(String blobName) {
         return (start, end) -> {
             byte[] buffer;
diff --git a/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobStore.java b/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobStore.java
index c41641921c822..1214c6cdc7373 100644
--- a/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobStore.java
+++ b/server/src/main/java/org/opensearch/common/blobstore/EncryptedBlobStore.java
@@ -95,6 +95,11 @@ public Map<Metric, Map<String, Long>> extendedStats() {
         return blobStore.extendedStats();
     }
 
+    @Override
+    public boolean isBlobMetadataEnabled() {
+        return blobStore.isBlobMetadataEnabled();
+    }
+
     /**
      * Closes the EncryptedBlobStore by decrementing the reference count of the CryptoManager and closing the
      * underlying BlobStore. This ensures proper cleanup of resources.
diff --git a/server/src/main/java/org/opensearch/common/cache/Cache.java b/server/src/main/java/org/opensearch/common/cache/Cache.java
index 6d346de25cadf..caae81e4387b4 100644
--- a/server/src/main/java/org/opensearch/common/cache/Cache.java
+++ b/server/src/main/java/org/opensearch/common/cache/Cache.java
@@ -36,9 +36,11 @@
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.util.concurrent.ReleasableLock;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
@@ -396,7 +398,12 @@ private V get(K key, long now, Consumer<Entry<K, V>> onExpiration) {
         if (entry == null) {
             return null;
         } else {
-            promote(entry, now);
+            List<RemovalNotification<K, V>> removalNotifications = promote(entry, now).v2();
+            if (!removalNotifications.isEmpty()) {
+                for (RemovalNotification<K, V> removalNotification : removalNotifications) {
+                    removalListener.onRemoval(removalNotification);
+                }
+            }
             return entry.value;
         }
     }
@@ -446,8 +453,14 @@ private V compute(K key, CacheLoader<K, V> loader) throws ExecutionException {
 
         BiFunction<? super Entry<K, V>, Throwable, ? extends V> handler = (ok, ex) -> {
             if (ok != null) {
+                List<RemovalNotification<K, V>> removalNotifications = new ArrayList<>();
                 try (ReleasableLock ignored = lruLock.acquire()) {
-                    promote(ok, now);
+                    removalNotifications = promote(ok, now).v2();
+                }
+                if (!removalNotifications.isEmpty()) {
+                    for (RemovalNotification<K, V> removalNotification : removalNotifications) {
+                        removalListener.onRemoval(removalNotification);
+                    }
                 }
                 return ok.value;
             } else {
@@ -512,16 +525,22 @@ private void put(K key, V value, long now) {
         CacheSegment<K, V> segment = getCacheSegment(key);
         Tuple<Entry<K, V>, Entry<K, V>> tuple = segment.put(key, value, now);
         boolean replaced = false;
+        List<RemovalNotification<K, V>> removalNotifications = new ArrayList<>();
         try (ReleasableLock ignored = lruLock.acquire()) {
             if (tuple.v2() != null && tuple.v2().state == State.EXISTING) {
                 if (unlink(tuple.v2())) {
                     replaced = true;
                 }
             }
-            promote(tuple.v1(), now);
+            removalNotifications = promote(tuple.v1(), now).v2();
         }
         if (replaced) {
-            removalListener.onRemoval(new RemovalNotification<>(tuple.v2().key, tuple.v2().value, RemovalReason.REPLACED));
+            removalNotifications.add(new RemovalNotification<>(tuple.v2().key, tuple.v2().value, RemovalReason.REPLACED));
+        }
+        if (!removalNotifications.isEmpty()) {
+            for (RemovalNotification<K, V> removalNotification : removalNotifications) {
+                removalListener.onRemoval(removalNotification);
+            }
         }
     }
 
@@ -767,8 +786,17 @@ public long getEvictions() {
         }
     }
 
-    private boolean promote(Entry<K, V> entry, long now) {
+    /**
+     * Promotes the desired entry to the head of the lru list and tries to see if it needs to evict any entries in
+     * case the cache size is exceeding or the entry got expired.
+     * @param entry Entry to be promoted
+     * @param now the current time
+     * @return Returns a tuple. v1 signifies whether an entry got promoted, v2 signifies the list of removal
+     * notifications that the callers needs to handle.
+     */
+    private Tuple<Boolean, List<RemovalNotification<K, V>>> promote(Entry<K, V> entry, long now) {
         boolean promoted = true;
+        List<RemovalNotification<K, V>> removalNotifications = new ArrayList<>();
         try (ReleasableLock ignored = lruLock.acquire()) {
             switch (entry.state) {
                 case DELETED:
@@ -782,10 +810,21 @@ private boolean promote(Entry<K, V> entry, long now) {
                     break;
             }
             if (promoted) {
-                evict(now);
+                while (tail != null && shouldPrune(tail, now)) {
+                    Entry<K, V> entryToBeRemoved = tail;
+                    CacheSegment<K, V> segment = getCacheSegment(entryToBeRemoved.key);
+                    if (segment != null) {
+                        segment.remove(entryToBeRemoved.key, entryToBeRemoved.value, f -> {});
+                    }
+                    if (unlink(entryToBeRemoved)) {
+                        removalNotifications.add(
+                            new RemovalNotification<>(entryToBeRemoved.key, entryToBeRemoved.value, RemovalReason.EVICTED)
+                        );
+                    }
+                }
             }
         }
-        return promoted;
+        return new Tuple<>(promoted, removalNotifications);
     }
 
     private void evict(long now) {
diff --git a/server/src/main/java/org/opensearch/common/cache/RemovalListener.java b/server/src/main/java/org/opensearch/common/cache/RemovalListener.java
index 68e1cdf6139e2..eaaaec2bb07e0 100644
--- a/server/src/main/java/org/opensearch/common/cache/RemovalListener.java
+++ b/server/src/main/java/org/opensearch/common/cache/RemovalListener.java
@@ -42,5 +42,10 @@
 @ExperimentalApi
 @FunctionalInterface
 public interface RemovalListener<K, V> {
+
+    /**
+     * This may be called from multiple threads at once. So implementation needs to be thread safe.
+     * @param notification removal notification for desired entry.
+     */
     void onRemoval(RemovalNotification<K, V> notification);
 }
diff --git a/server/src/main/java/org/opensearch/common/cache/service/NodeCacheStats.java b/server/src/main/java/org/opensearch/common/cache/service/NodeCacheStats.java
index 07c75eab34194..dd94dbf61debb 100644
--- a/server/src/main/java/org/opensearch/common/cache/service/NodeCacheStats.java
+++ b/server/src/main/java/org/opensearch/common/cache/service/NodeCacheStats.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.common.cache.service;
 
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.cache.CacheType;
@@ -51,6 +52,7 @@ public void writeTo(StreamOutput out) throws IOException {
 
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject(NodesStatsRequest.Metric.CACHE_STATS.metricName());
         for (CacheType type : statsByCache.keySet()) {
             if (flags.getIncludeCaches().contains(type)) {
                 builder.startObject(type.getValue());
@@ -58,6 +60,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
                 builder.endObject();
             }
         }
+        builder.endObject();
         return builder;
     }
 
@@ -77,4 +80,10 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(statsByCache, flags);
     }
+
+    // Get the immutable cache stats for a given cache, used to avoid having to process XContent in tests.
+    // Safe to expose publicly as the ImmutableCacheStatsHolder can't be modified after its creation.
+    public ImmutableCacheStatsHolder getStatsByCache(CacheType cacheType) {
+        return statsByCache.get(cacheType);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/common/cache/stats/ImmutableCacheStats.java b/server/src/main/java/org/opensearch/common/cache/stats/ImmutableCacheStats.java
index dbd78a2584f9c..db23e7b877596 100644
--- a/server/src/main/java/org/opensearch/common/cache/stats/ImmutableCacheStats.java
+++ b/server/src/main/java/org/opensearch/common/cache/stats/ImmutableCacheStats.java
@@ -115,6 +115,29 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         return builder;
     }
 
+    @Override
+    public String toString() {
+        return Fields.HIT_COUNT
+            + "="
+            + hits
+            + ", "
+            + Fields.MISS_COUNT
+            + "="
+            + misses
+            + ", "
+            + Fields.EVICTIONS
+            + "="
+            + evictions
+            + ", "
+            + Fields.SIZE_IN_BYTES
+            + "="
+            + sizeInBytes
+            + ", "
+            + Fields.ITEM_COUNT
+            + "="
+            + items;
+    }
+
     /**
      * Field names used to write the values in this object to XContent.
      */
diff --git a/server/src/main/java/org/opensearch/common/hash/MessageDigests.java b/server/src/main/java/org/opensearch/common/hash/MessageDigests.java
index f53f60a3a97a3..123bd3489bedb 100644
--- a/server/src/main/java/org/opensearch/common/hash/MessageDigests.java
+++ b/server/src/main/java/org/opensearch/common/hash/MessageDigests.java
@@ -58,6 +58,7 @@ private static ThreadLocal<MessageDigest> createThreadLocalMessageDigest(String
     private static final ThreadLocal<MessageDigest> MD5_DIGEST = createThreadLocalMessageDigest("MD5");
     private static final ThreadLocal<MessageDigest> SHA_1_DIGEST = createThreadLocalMessageDigest("SHA-1");
     private static final ThreadLocal<MessageDigest> SHA_256_DIGEST = createThreadLocalMessageDigest("SHA-256");
+    private static final ThreadLocal<MessageDigest> SHA3_256_DIGEST = createThreadLocalMessageDigest("SHA3-256");
 
     /**
      * Returns a {@link MessageDigest} instance for MD5 digests; note
@@ -95,6 +96,18 @@ public static MessageDigest sha256() {
         return get(SHA_256_DIGEST);
     }
 
+    /**
+     * Returns a {@link MessageDigest} instance for SHA3-256 digests;
+     * note that the instance returned is thread local and must not be
+     * shared amongst threads.
+     *
+     * @return a thread local {@link MessageDigest} instance that
+     * provides SHA3-256 message digest functionality.
+     */
+    public static MessageDigest sha3256() {
+        return get(SHA3_256_DIGEST);
+    }
+
     private static MessageDigest get(ThreadLocal<MessageDigest> messageDigest) {
         MessageDigest instance = messageDigest.get();
         instance.reset();
diff --git a/server/src/main/java/org/opensearch/common/logging/JsonThrowablePatternConverter.java b/server/src/main/java/org/opensearch/common/logging/JsonThrowablePatternConverter.java
index ed324e4e62d8f..ee21c343e2ea1 100644
--- a/server/src/main/java/org/opensearch/common/logging/JsonThrowablePatternConverter.java
+++ b/server/src/main/java/org/opensearch/common/logging/JsonThrowablePatternConverter.java
@@ -38,7 +38,7 @@
 import org.apache.logging.log4j.core.pattern.ExtendedThrowablePatternConverter;
 import org.apache.logging.log4j.core.pattern.PatternConverter;
 import org.apache.logging.log4j.core.pattern.ThrowablePatternConverter;
-import org.apache.logging.log4j.util.Strings;
+import org.opensearch.core.common.Strings;
 
 import java.nio.charset.Charset;
 import java.util.StringJoiner;
@@ -84,7 +84,7 @@ public static JsonThrowablePatternConverter newInstance(final Configuration conf
     @Override
     public void format(final LogEvent event, final StringBuilder toAppendTo) {
         String consoleStacktrace = formatStacktrace(event);
-        if (Strings.isNotEmpty(consoleStacktrace)) {
+        if (!Strings.isNullOrEmpty(consoleStacktrace)) {
             String jsonStacktrace = formatJson(consoleStacktrace);
 
             toAppendTo.append(", ");
diff --git a/server/src/main/java/org/opensearch/common/remote/AbstractClusterMetadataWriteableBlobEntity.java b/server/src/main/java/org/opensearch/common/remote/AbstractClusterMetadataWriteableBlobEntity.java
new file mode 100644
index 0000000000000..b9492da04680d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/AbstractClusterMetadataWriteableBlobEntity.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+
+/**
+ * An extension of {@link RemoteWriteableEntity} class which caters to the use case of writing to and reading from a blob storage
+ *
+ * @param <T> The class type which can be uploaded to or downloaded from a blob storage.
+ */
+public abstract class AbstractClusterMetadataWriteableBlobEntity<T> extends RemoteWriteableBlobEntity<T> {
+
+    protected final NamedXContentRegistry namedXContentRegistry;
+
+    public AbstractClusterMetadataWriteableBlobEntity(
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor);
+        this.namedXContentRegistry = namedXContentRegistry;
+    }
+
+    public AbstractClusterMetadataWriteableBlobEntity(final String clusterUUID, final Compressor compressor) {
+        super(clusterUUID, compressor);
+        this.namedXContentRegistry = null;
+    }
+
+    public abstract UploadedMetadata getUploadedMetadata();
+
+    public NamedXContentRegistry getNamedXContentRegistry() {
+        return namedXContentRegistry;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManager.java b/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManager.java
new file mode 100644
index 0000000000000..8e2de1580a49f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManager.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * An abstract class that provides a base implementation for managing remote entities in the remote store.
+ */
+public abstract class AbstractRemoteWritableEntityManager implements RemoteWritableEntityManager {
+    /**
+     * A map that stores the remote writable entity stores, keyed by the entity type.
+     */
+    protected final Map<String, RemoteWritableEntityStore> remoteWritableEntityStores = new HashMap<>();
+
+    /**
+     * Retrieves the remote writable entity store for the given entity.
+     *
+     * @param entity the entity for which the store is requested
+     * @return the remote writable entity store for the given entity
+     * @throws IllegalArgumentException if the entity type is unknown
+     */
+    protected RemoteWritableEntityStore getStore(AbstractClusterMetadataWriteableBlobEntity entity) {
+        RemoteWritableEntityStore remoteStore = remoteWritableEntityStores.get(entity.getType());
+        if (remoteStore == null) {
+            throw new IllegalArgumentException("Unknown entity type [" + entity.getType() + "]");
+        }
+        return remoteStore;
+    }
+
+    /**
+     * Returns an ActionListener for handling the write operation for the specified component, remote object, and latched action listener.
+     *
+     * @param component the component for which the write operation is performed
+     * @param remoteEntity the remote object to be written
+     * @param listener the listener to be notified when the write operation completes
+     * @return an ActionListener for handling the write operation
+     */
+    protected abstract ActionListener<Void> getWrappedWriteListener(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+    );
+
+    /**
+     * Returns an ActionListener for handling the read operation for the specified component,
+     * remote object, and latched action listener.
+     *
+     * @param component the component for which the read operation is performed
+     * @param remoteEntity the remote object to be read
+     * @param listener the listener to be notified when the read operation completes
+     * @return an ActionListener for handling the read operation
+     */
+    protected abstract ActionListener<Object> getWrappedReadListener(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+        ActionListener<RemoteReadResult> listener
+    );
+
+    @Override
+    public void writeAsync(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity entity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+    ) {
+        getStore(entity).writeAsync(entity, getWrappedWriteListener(component, entity, listener));
+    }
+
+    @Override
+    public void readAsync(String component, AbstractClusterMetadataWriteableBlobEntity entity, ActionListener<RemoteReadResult> listener) {
+        getStore(entity).readAsync(entity, getWrappedReadListener(component, entity, listener));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/BlobPathParameters.java b/server/src/main/java/org/opensearch/common/remote/BlobPathParameters.java
new file mode 100644
index 0000000000000..58c73a804b66a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/BlobPathParameters.java
@@ -0,0 +1,34 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import java.util.List;
+
+/**
+ * Parameters which can be used to construct a blob path
+ *
+ */
+public class BlobPathParameters {
+
+    private final List<String> pathTokens;
+    private final String filePrefix;
+
+    public BlobPathParameters(final List<String> pathTokens, final String filePrefix) {
+        this.pathTokens = pathTokens;
+        this.filePrefix = filePrefix;
+    }
+
+    public List<String> getPathTokens() {
+        return pathTokens;
+    }
+
+    public String getFilePrefix() {
+        return filePrefix;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityManager.java b/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityManager.java
new file mode 100644
index 0000000000000..c27598e368e4d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityManager.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+
+/**
+ * The RemoteWritableEntityManager interface provides async read and write methods for managing remote entities in the remote store
+ */
+public interface RemoteWritableEntityManager {
+
+    /**
+     * Performs an asynchronous read operation for the specified component and entity.
+     *
+     * @param component the component for which the read operation is performed
+     * @param entity the entity to be read
+     * @param listener the listener to be notified when the read operation completes.
+     *                 The listener's {@link ActionListener#onResponse(Object)} method
+     *                 is called with a {@link RemoteReadResult} object containing the
+     *                 read data on successful read. The
+     *                 {@link ActionListener#onFailure(Exception)} method is called with
+     *                 an exception if the read operation fails.
+     */
+    void readAsync(String component, AbstractClusterMetadataWriteableBlobEntity entity, ActionListener<RemoteReadResult> listener);
+
+    /**
+     * Performs an asynchronous write operation for the specified component and entity.
+     *
+     * @param component the component for which the write operation is performed
+     * @param entity the entity to be written
+     * @param listener the listener to be notified when the write operation completes.
+     *                 The listener's {@link ActionListener#onResponse(Object)} method
+     *                 is called with a {@link UploadedMetadata} object containing the
+     *                 uploaded metadata on successful write. The
+     *                 {@link ActionListener#onFailure(Exception)} method is called with
+     *                 an exception if the write operation fails.
+     */
+    void writeAsync(String component, AbstractClusterMetadataWriteableBlobEntity entity, ActionListener<UploadedMetadata> listener);
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityStore.java b/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityStore.java
new file mode 100644
index 0000000000000..385c6f20ba58d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/RemoteWritableEntityStore.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.action.ActionListener;
+
+import java.io.IOException;
+
+/**
+ * An interface to read/write an object from/to a remote storage. This interface is agnostic of the remote storage type.
+ *
+ * @param <T> The object type which can be uploaded to or downloaded from remote storage.
+ * @param <U> The wrapper entity which provides methods for serializing/deserializing entity T.
+ */
+@ExperimentalApi
+public interface RemoteWritableEntityStore<T, U extends RemoteWriteableEntity<T>> {
+
+    public void writeAsync(U entity, ActionListener<Void> listener);
+
+    public T read(U entity) throws IOException;
+
+    public void readAsync(U entity, ActionListener<T> listener);
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/RemoteWriteableBlobEntity.java b/server/src/main/java/org/opensearch/common/remote/RemoteWriteableBlobEntity.java
new file mode 100644
index 0000000000000..f034ce2d1adf1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/RemoteWriteableBlobEntity.java
@@ -0,0 +1,78 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.core.compress.Compressor;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.PATH_DELIMITER;
+
+/**
+ * The abstract class which represents a {@link RemoteWriteableEntity} that can be written to a store
+ * @param <T> the entity to be written
+ */
+public abstract class RemoteWriteableBlobEntity<T> implements RemoteWriteableEntity<T> {
+
+    protected String blobFileName;
+
+    protected String blobName;
+    private final String clusterUUID;
+    private final Compressor compressor;
+    private String[] pathTokens;
+
+    public RemoteWriteableBlobEntity(final String clusterUUID, final Compressor compressor) {
+        this.clusterUUID = clusterUUID;
+        this.compressor = compressor;
+    }
+
+    public abstract BlobPathParameters getBlobPathParameters();
+
+    public abstract String getType();
+
+    public String getFullBlobName() {
+        return blobName;
+    }
+
+    public String getBlobFileName() {
+        if (blobFileName == null) {
+            String[] pathTokens = getBlobPathTokens();
+            if (pathTokens == null || pathTokens.length < 1) {
+                return null;
+            }
+            blobFileName = pathTokens[pathTokens.length - 1];
+        }
+        return blobFileName;
+    }
+
+    public String[] getBlobPathTokens() {
+        if (pathTokens != null) {
+            return pathTokens;
+        }
+        if (blobName == null) {
+            return null;
+        }
+        pathTokens = blobName.split(PATH_DELIMITER);
+        return pathTokens;
+    }
+
+    public abstract String generateBlobFileName();
+
+    public String clusterUUID() {
+        return clusterUUID;
+    }
+
+    public void setFullBlobName(BlobPath blobPath) {
+        this.blobName = blobPath.buildAsString() + blobFileName;
+    }
+
+    protected Compressor getCompressor() {
+        return compressor;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/RemoteWriteableEntity.java b/server/src/main/java/org/opensearch/common/remote/RemoteWriteableEntity.java
new file mode 100644
index 0000000000000..773ddce5b9cc8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/RemoteWriteableEntity.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * An interface to which provides defines the serialization/deserialization methods for objects to be uploaded to or downloaded from remote store.
+ * This interface is agnostic of the remote storage type.
+ *
+ * @param <T> The object type which can be uploaded to or downloaded from remote storage.
+ */
+@ExperimentalApi
+public interface RemoteWriteableEntity<T> {
+    /**
+     * @return An InputStream created by serializing the entity T
+     * @throws IOException Exception encountered while serialization
+     */
+    public InputStream serialize() throws IOException;
+
+    /**
+     * @param inputStream The InputStream which is used to read the serialized entity
+     * @return The entity T after deserialization
+     * @throws IOException Exception encountered while deserialization
+     */
+    public T deserialize(InputStream inputStream) throws IOException;
+
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/RemoteWriteableEntityBlobStore.java b/server/src/main/java/org/opensearch/common/remote/RemoteWriteableEntityBlobStore.java
new file mode 100644
index 0000000000000..baa44a7c9bde9
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/RemoteWriteableEntityBlobStore.java
@@ -0,0 +1,125 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.stream.write.WritePriority;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.concurrent.ExecutorService;
+
+/**
+ * Abstract class for a blob type storage
+ *
+ * @param <T> The entity which can be uploaded to / downloaded from blob store
+ * @param <U> The concrete class implementing {@link RemoteWriteableEntity} which is used as a wrapper for T entity.
+ */
+public class RemoteWriteableEntityBlobStore<T, U extends RemoteWriteableBlobEntity<T>> implements RemoteWritableEntityStore<T, U> {
+
+    private final BlobStoreTransferService transferService;
+    private final BlobStoreRepository blobStoreRepository;
+    private final String clusterName;
+    private final ExecutorService executorService;
+    private final String pathToken;
+
+    public RemoteWriteableEntityBlobStore(
+        final BlobStoreTransferService blobStoreTransferService,
+        final BlobStoreRepository blobStoreRepository,
+        final String clusterName,
+        final ThreadPool threadPool,
+        final String executor,
+        final String pathToken
+    ) {
+        this.transferService = blobStoreTransferService;
+        this.blobStoreRepository = blobStoreRepository;
+        this.clusterName = clusterName;
+        this.executorService = threadPool.executor(executor);
+        this.pathToken = pathToken;
+    }
+
+    @Override
+    public void writeAsync(final U entity, final ActionListener<Void> listener) {
+        try {
+            try (InputStream inputStream = entity.serialize()) {
+                BlobPath blobPath = getBlobPathForUpload(entity);
+                entity.setFullBlobName(blobPath);
+                transferService.uploadBlob(
+                    inputStream,
+                    getBlobPathForUpload(entity),
+                    entity.getBlobFileName(),
+                    WritePriority.URGENT,
+                    listener
+                );
+            }
+        } catch (Exception e) {
+            listener.onFailure(e);
+        }
+    }
+
+    @Override
+    public T read(final U entity) throws IOException {
+        // TODO Add timing logs and tracing
+        assert entity.getFullBlobName() != null;
+        try (InputStream inputStream = transferService.downloadBlob(getBlobPathForDownload(entity), entity.getBlobFileName())) {
+            return entity.deserialize(inputStream);
+        }
+    }
+
+    @Override
+    public void readAsync(final U entity, final ActionListener<T> listener) {
+        executorService.execute(() -> {
+            try {
+                listener.onResponse(read(entity));
+            } catch (Exception e) {
+                listener.onFailure(e);
+            }
+        });
+    }
+
+    public String getClusterName() {
+        return clusterName;
+    }
+
+    public BlobPath getBlobPathPrefix(String clusterUUID) {
+        return blobStoreRepository.basePath().add(encodeString(getClusterName())).add(pathToken).add(clusterUUID);
+    }
+
+    public BlobPath getBlobPathForUpload(final RemoteWriteableBlobEntity<T> obj) {
+        BlobPath blobPath = getBlobPathPrefix(obj.clusterUUID());
+        for (String token : obj.getBlobPathParameters().getPathTokens()) {
+            blobPath = blobPath.add(token);
+        }
+        return blobPath;
+    }
+
+    public BlobPath getBlobPathForDownload(final RemoteWriteableBlobEntity<T> obj) {
+        String[] pathTokens = obj.getBlobPathTokens();
+        BlobPath blobPath = new BlobPath();
+        if (pathTokens == null || pathTokens.length < 1) {
+            return blobPath;
+        }
+        // Iterate till second last path token to get the blob folder
+        for (int i = 0; i < pathTokens.length - 1; i++) {
+            blobPath = blobPath.add(pathTokens[i]);
+        }
+        return blobPath;
+    }
+
+    private static String encodeString(String content) {
+        return Base64.getUrlEncoder().withoutPadding().encodeToString(content.getBytes(StandardCharsets.UTF_8));
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/common/remote/package-info.java b/server/src/main/java/org/opensearch/common/remote/package-info.java
new file mode 100644
index 0000000000000..08ff9e910dc98
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/remote/package-info.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+/**
+ * Common remote store package
+ */
+package org.opensearch.common.remote;
diff --git a/server/src/main/java/org/opensearch/common/settings/AbstractScopedSettings.java b/server/src/main/java/org/opensearch/common/settings/AbstractScopedSettings.java
index 4b23c0e3808a7..e9b83f7a82e18 100644
--- a/server/src/main/java/org/opensearch/common/settings/AbstractScopedSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/AbstractScopedSettings.java
@@ -792,6 +792,36 @@ public <T> T get(Setting<T> setting) {
         return setting.get(this.lastSettingsApplied, settings);
     }
 
+    /**
+     * Returns the value for the given setting if it is explicitly set,
+     * otherwise will return null instead of default value
+     **/
+    public <T> T getOrNull(Setting<T> setting) {
+        if (setting.getProperties().contains(scope) == false) {
+            throw new SettingsException(
+                "settings scope doesn't match the setting scope [" + this.scope + "] not in [" + setting.getProperties() + "]"
+            );
+        }
+        if (get(setting.getKey()) == null) {
+            throw new SettingsException("setting " + setting.getKey() + " has not been registered");
+        }
+        if (setting.exists(lastSettingsApplied)) {
+            return setting.get(lastSettingsApplied);
+        }
+        if (setting.exists(settings)) {
+            return setting.get(settings);
+        }
+        if (setting.fallbackSetting != null) {
+            if (setting.fallbackSetting.exists(lastSettingsApplied)) {
+                return setting.fallbackSetting.get(lastSettingsApplied);
+            }
+            if (setting.fallbackSetting.exists(settings)) {
+                return setting.fallbackSetting.get(settings);
+            }
+        }
+        return null;
+    }
+
     /**
      * Updates a target settings builder with new, updated or deleted settings from a given settings builder.
      * <p>
diff --git a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
index 47a3371baf6c5..f0ff79f5c74f6 100644
--- a/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/ClusterSettings.java
@@ -50,6 +50,7 @@
 import org.opensearch.cluster.NodeConnectionsService;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
 import org.opensearch.cluster.action.shard.ShardStateAction;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesService;
 import org.opensearch.cluster.coordination.ClusterBootstrapService;
 import org.opensearch.cluster.coordination.ClusterFormationFailureHelper;
 import org.opensearch.cluster.coordination.Coordinator;
@@ -76,6 +77,7 @@
 import org.opensearch.cluster.routing.allocation.decider.FilterAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.NodeLoadAwareAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.SameShardAllocationDecider;
+import org.opensearch.cluster.routing.allocation.decider.SearchReplicaAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.ShardsLimitAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.ThrottlingAllocationDecider;
 import org.opensearch.cluster.service.ClusterApplierService;
@@ -105,7 +107,9 @@
 import org.opensearch.gateway.GatewayService;
 import org.opensearch.gateway.PersistedClusterStateService;
 import org.opensearch.gateway.ShardsBatchGatewayAllocator;
+import org.opensearch.gateway.remote.RemoteClusterStateCleanupManager;
 import org.opensearch.gateway.remote.RemoteClusterStateService;
+import org.opensearch.gateway.remote.model.RemoteRoutingTableBlobStore;
 import org.opensearch.http.HttpTransportSettings;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.IndexSettings;
@@ -114,9 +118,10 @@
 import org.opensearch.index.ShardIndexingPressureMemoryManager;
 import org.opensearch.index.ShardIndexingPressureSettings;
 import org.opensearch.index.ShardIndexingPressureStore;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
 import org.opensearch.index.remote.RemoteStorePressureSettings;
 import org.opensearch.index.remote.RemoteStoreStatsTrackerFactory;
-import org.opensearch.index.store.remote.filecache.FileCache;
+import org.opensearch.index.store.remote.filecache.FileCacheSettings;
 import org.opensearch.indices.IndexingMemoryController;
 import org.opensearch.indices.IndicesQueryCache;
 import org.opensearch.indices.IndicesRequestCache;
@@ -129,6 +134,7 @@
 import org.opensearch.indices.fielddata.cache.IndicesFieldDataCache;
 import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.indices.store.IndicesStore;
+import org.opensearch.ingest.IngestService;
 import org.opensearch.monitor.fs.FsHealthService;
 import org.opensearch.monitor.fs.FsService;
 import org.opensearch.monitor.jvm.JvmGcMonitorService;
@@ -149,7 +155,6 @@
 import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.rest.BaseRestHandler;
 import org.opensearch.script.ScriptService;
-import org.opensearch.search.SearchModule;
 import org.opensearch.search.SearchService;
 import org.opensearch.search.aggregations.MultiBucketConsumerService;
 import org.opensearch.search.backpressure.settings.NodeDuressSettings;
@@ -171,6 +176,7 @@
 import org.opensearch.transport.SniffConnectionStrategy;
 import org.opensearch.transport.TransportSettings;
 import org.opensearch.watcher.ResourceWatcherService;
+import org.opensearch.wlm.WorkloadManagementSettings;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -180,6 +186,10 @@
 import java.util.Set;
 import java.util.function.Predicate;
 
+import static org.opensearch.gateway.remote.RemoteGlobalMetadataManager.GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING;
+import static org.opensearch.gateway.remote.RemoteIndexMetadataManager.INDEX_METADATA_UPLOAD_TIMEOUT_SETTING;
+import static org.opensearch.gateway.remote.RemoteManifestManager.METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING;
+
 /**
  * Encapsulates all valid cluster level settings.
  *
@@ -262,6 +272,8 @@ public void apply(Settings value, Settings current, Settings previous) {
                 BalancedShardsAllocator.SHARD_MOVE_PRIMARY_FIRST_SETTING,
                 BalancedShardsAllocator.SHARD_MOVEMENT_STRATEGY_SETTING,
                 BalancedShardsAllocator.THRESHOLD_SETTING,
+                BalancedShardsAllocator.IGNORE_THROTTLE_FOR_REMOTE_RESTORE,
+                BalancedShardsAllocator.ALLOCATOR_TIMEOUT_SETTING,
                 BreakerSettings.CIRCUIT_BREAKER_LIMIT_SETTING,
                 BreakerSettings.CIRCUIT_BREAKER_OVERHEAD_SETTING,
                 BreakerSettings.CIRCUIT_BREAKER_TYPE,
@@ -302,10 +314,12 @@ public void apply(Settings value, Settings current, Settings previous) {
                 RecoverySettings.INDICES_RECOVERY_ACTIVITY_TIMEOUT_SETTING,
                 RecoverySettings.INDICES_RECOVERY_INTERNAL_ACTION_TIMEOUT_SETTING,
                 RecoverySettings.INDICES_RECOVERY_INTERNAL_LONG_ACTION_TIMEOUT_SETTING,
+                RecoverySettings.INDICES_RECOVERY_INTERNAL_ACTION_RETRY_TIMEOUT_SETTING,
                 RecoverySettings.INDICES_RECOVERY_MAX_CONCURRENT_FILE_CHUNKS_SETTING,
                 RecoverySettings.INDICES_RECOVERY_MAX_CONCURRENT_OPERATIONS_SETTING,
                 RecoverySettings.INDICES_RECOVERY_MAX_CONCURRENT_REMOTE_STORE_STREAMS_SETTING,
                 RecoverySettings.INDICES_INTERNAL_REMOTE_UPLOAD_TIMEOUT,
+                RecoverySettings.INDICES_RECOVERY_CHUNK_SIZE_SETTING,
                 ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_INITIAL_PRIMARIES_RECOVERIES_SETTING,
                 ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_INITIAL_REPLICAS_RECOVERIES_SETTING,
                 ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_INCOMING_RECOVERIES_SETTING,
@@ -335,6 +349,8 @@ public void apply(Settings value, Settings current, Settings previous) {
                 GatewayService.RECOVER_AFTER_NODES_SETTING,
                 GatewayService.RECOVER_AFTER_TIME_SETTING,
                 ShardsBatchGatewayAllocator.GATEWAY_ALLOCATOR_BATCH_SIZE,
+                ShardsBatchGatewayAllocator.PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING,
+                ShardsBatchGatewayAllocator.REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING,
                 PersistedClusterStateService.SLOW_WRITE_LOGGING_THRESHOLD,
                 NetworkModule.HTTP_DEFAULT_TYPE_SETTING,
                 NetworkModule.TRANSPORT_DEFAULT_TYPE_SETTING,
@@ -393,11 +409,11 @@ public void apply(Settings value, Settings current, Settings previous) {
                 ClusterService.USER_DEFINED_METADATA,
                 ClusterManagerService.MASTER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING,  // deprecated
                 ClusterManagerService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING,
+                IngestService.MAX_NUMBER_OF_INGEST_PROCESSORS,
                 SearchService.DEFAULT_SEARCH_TIMEOUT_SETTING,
                 SearchService.DEFAULT_ALLOW_PARTIAL_SEARCH_RESULTS,
                 TransportSearchAction.SHARD_COUNT_LIMIT_SETTING,
                 TransportSearchAction.SEARCH_CANCEL_AFTER_TIME_INTERVAL_SETTING,
-                TransportSearchAction.SEARCH_QUERY_METRICS_ENABLED_SETTING,
                 TransportSearchAction.SEARCH_PHASE_TOOK_ENABLED,
                 SearchRequestStats.SEARCH_REQUEST_STATS_ENABLED,
                 RemoteClusterService.REMOTE_CLUSTER_SKIP_UNAVAILABLE,
@@ -533,6 +549,8 @@ public void apply(Settings value, Settings current, Settings previous) {
                 SearchService.MAX_OPEN_PIT_CONTEXT,
                 SearchService.MAX_PIT_KEEPALIVE_SETTING,
                 SearchService.MAX_AGGREGATION_REWRITE_FILTERS,
+                SearchService.INDICES_MAX_CLAUSE_COUNT_SETTING,
+                SearchService.CARDINALITY_AGGREGATION_PRUNING_THRESHOLD,
                 CreatePitController.PIT_INIT_KEEP_ALIVE,
                 Node.WRITE_PORTS_FILE_SETTING,
                 Node.NODE_NAME_SETTING,
@@ -582,7 +600,6 @@ public void apply(Settings value, Settings current, Settings previous) {
                 ResourceWatcherService.RELOAD_INTERVAL_HIGH,
                 ResourceWatcherService.RELOAD_INTERVAL_MEDIUM,
                 ResourceWatcherService.RELOAD_INTERVAL_LOW,
-                SearchModule.INDICES_MAX_CLAUSE_COUNT_SETTING,
                 ThreadPool.ESTIMATED_TIME_INTERVAL_SETTING,
                 FastVectorHighlighter.SETTING_TV_HIGHLIGHT_MULTI_VALUE,
                 Node.BREAKER_TYPE_KEY,
@@ -621,6 +638,7 @@ public void apply(Settings value, Settings current, Settings previous) {
                 HandshakingTransportAddressConnector.PROBE_CONNECT_TIMEOUT_SETTING,
                 HandshakingTransportAddressConnector.PROBE_HANDSHAKE_TIMEOUT_SETTING,
                 SnapshotsService.MAX_CONCURRENT_SNAPSHOT_OPERATIONS_SETTING,
+                SnapshotsService.MAX_SHARDS_ALLOWED_IN_STATUS_API,
                 FsHealthService.ENABLED_SETTING,
                 FsHealthService.REFRESH_INTERVAL_SETTING,
                 FsHealthService.SLOW_PATH_LOGGING_THRESHOLD_SETTING,
@@ -690,7 +708,7 @@ public void apply(Settings value, Settings current, Settings previous) {
 
                 // Settings related to Searchable Snapshots
                 Node.NODE_SEARCH_CACHE_SIZE_SETTING,
-                FileCache.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING,
+                FileCacheSettings.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING,
 
                 // Settings related to Remote Refresh Segment Pressure
                 RemoteStorePressureSettings.REMOTE_REFRESH_SEGMENT_PRESSURE_ENABLED,
@@ -713,15 +731,20 @@ public void apply(Settings value, Settings current, Settings previous) {
                 SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_LEVEL,
 
                 // Remote cluster state settings
+                RemoteClusterStateCleanupManager.REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING,
                 RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING,
-                RemoteClusterStateService.INDEX_METADATA_UPLOAD_TIMEOUT_SETTING,
-                RemoteClusterStateService.GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING,
-                RemoteClusterStateService.METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING,
+                INDEX_METADATA_UPLOAD_TIMEOUT_SETTING,
+                GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING,
+                METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING,
+                RemoteClusterStateService.REMOTE_STATE_READ_TIMEOUT_SETTING,
                 RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING,
                 RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING,
 
                 IndicesService.CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING,
                 IndicesService.CLUSTER_INDEX_RESTRICT_REPLICATION_TYPE_SETTING,
+                RemoteRoutingTableBlobStore.REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING,
+                RemoteRoutingTableBlobStore.REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING,
+                RemoteClusterStateService.REMOTE_CLUSTER_STATE_CHECKSUM_VALIDATION_MODE_SETTING,
 
                 AdmissionControlSettings.ADMISSION_CONTROL_TRANSPORT_LAYER_MODE,
                 CpuBasedAdmissionControllerSettings.CPU_BASED_ADMISSION_CONTROLLER_TRANSPORT_LAYER_MODE,
@@ -733,8 +756,9 @@ public void apply(Settings value, Settings current, Settings previous) {
                 IoBasedAdmissionControllerSettings.INDEXING_IO_USAGE_LIMIT,
 
                 // Concurrent segment search settings
-                SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING,
+                SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING, // deprecated
                 SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING,
+                SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE,
 
                 RemoteStoreSettings.CLUSTER_REMOTE_INDEX_SEGMENT_METADATA_RETENTION_MAX_COUNT_SETTING,
                 RemoteStoreSettings.CLUSTER_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING,
@@ -743,7 +767,29 @@ public void apply(Settings value, Settings current, Settings previous) {
                 RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING,
                 RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_HASH_ALGORITHM_SETTING,
                 RemoteStoreSettings.CLUSTER_REMOTE_MAX_TRANSLOG_READERS,
-                RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_METADATA
+                RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_METADATA,
+                RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_SCHEDULER_INTERVAL,
+                RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_LOOKBACK_INTERVAL,
+                RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED,
+                RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX,
+                RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX,
+
+                // Composite index settings
+                CompositeIndexSettings.STAR_TREE_INDEX_ENABLED_SETTING,
+                CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING,
+
+                SystemTemplatesService.SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED,
+
+                // WorkloadManagement settings
+                WorkloadManagementSettings.NODE_LEVEL_CPU_REJECTION_THRESHOLD,
+                WorkloadManagementSettings.NODE_LEVEL_CPU_CANCELLATION_THRESHOLD,
+                WorkloadManagementSettings.NODE_LEVEL_MEMORY_REJECTION_THRESHOLD,
+                WorkloadManagementSettings.NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD,
+
+                SearchService.CLUSTER_ALLOW_DERIVED_FIELD_SETTING,
+
+                // Composite index settings
+                CompositeIndexSettings.STAR_TREE_INDEX_ENABLED_SETTING
             )
         )
     );
@@ -773,6 +819,8 @@ public void apply(Settings value, Settings current, Settings previous) {
             OpenSearchOnHeapCacheSettings.EXPIRE_AFTER_ACCESS_SETTING.getConcreteSettingForNamespace(
                 CacheType.INDICES_REQUEST_CACHE.getSettingPrefix()
             )
-        )
+        ),
+        List.of(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL),
+        List.of(SearchReplicaAllocationDecider.SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING)
     );
 }
diff --git a/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java b/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
index 7a364de1c5dc6..fec19e9d286b8 100644
--- a/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/FeatureFlagSettings.java
@@ -36,6 +36,10 @@ protected FeatureFlagSettings(
         FeatureFlags.DATETIME_FORMATTER_CACHING_SETTING,
         FeatureFlags.TIERED_REMOTE_INDEX_SETTING,
         FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING,
-        FeatureFlags.PLUGGABLE_CACHE_SETTING
+        FeatureFlags.PLUGGABLE_CACHE_SETTING,
+        FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL_SETTING,
+        FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING,
+        FeatureFlags.STAR_TREE_INDEX_SETTING,
+        FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL_SETTING
     );
 }
diff --git a/server/src/main/java/org/opensearch/common/settings/IndexScopedSettings.java b/server/src/main/java/org/opensearch/common/settings/IndexScopedSettings.java
index 980c432774f6e..bddbe963e8013 100644
--- a/server/src/main/java/org/opensearch/common/settings/IndexScopedSettings.java
+++ b/server/src/main/java/org/opensearch/common/settings/IndexScopedSettings.java
@@ -41,6 +41,7 @@
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.logging.Loggers;
 import org.opensearch.common.settings.Setting.Property;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.IndexSortConfig;
@@ -51,6 +52,7 @@
 import org.opensearch.index.SearchSlowLog;
 import org.opensearch.index.TieredMergePolicyProvider;
 import org.opensearch.index.cache.bitset.BitsetFilterCache;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
 import org.opensearch.index.engine.EngineConfig;
 import org.opensearch.index.fielddata.IndexFieldDataService;
 import org.opensearch.index.mapper.FieldMapper;
@@ -222,6 +224,7 @@ public final class IndexScopedSettings extends AbstractScopedSettings {
                 IndexSettings.SEARCHABLE_SNAPSHOT_INDEX_ID,
                 IndexSettings.SEARCHABLE_SNAPSHOT_ID_NAME,
                 IndexSettings.SEARCHABLE_SNAPSHOT_ID_UUID,
+                IndexSettings.SEARCHABLE_SNAPSHOT_SHARD_PATH_TYPE,
 
                 // Settings for remote translog
                 IndexSettings.INDEX_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING,
@@ -236,7 +239,23 @@ public final class IndexScopedSettings extends AbstractScopedSettings {
                 IndexSettings.INDEX_DOC_ID_FUZZY_SET_FALSE_POSITIVE_PROBABILITY_SETTING,
 
                 // Settings for concurrent segment search
-                IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING,
+                IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING, // deprecated
+                IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MODE,
+                IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MAX_SLICE_COUNT,
+                IndexSettings.ALLOW_DERIVED_FIELDS,
+
+                // Settings for star tree index
+                StarTreeIndexSettings.STAR_TREE_DEFAULT_MAX_LEAF_DOCS,
+                StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_SETTING,
+                StarTreeIndexSettings.STAR_TREE_MAX_FIELDS_SETTING,
+                StarTreeIndexSettings.DEFAULT_METRICS_LIST,
+                StarTreeIndexSettings.DEFAULT_DATE_INTERVALS,
+                StarTreeIndexSettings.STAR_TREE_MAX_DATE_INTERVALS_SETTING,
+                StarTreeIndexSettings.STAR_TREE_MAX_BASE_METRICS_SETTING,
+                StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING,
+
+                IndexSettings.INDEX_CONTEXT_CREATED_VERSION,
+                IndexSettings.INDEX_CONTEXT_CURRENT_VERSION,
 
                 // validate that built-in similarities don't get redefined
                 Setting.groupSetting("index.similarity.", (s) -> {
@@ -260,7 +279,12 @@ public final class IndexScopedSettings extends AbstractScopedSettings {
      * is ready for production release, the feature flag can be removed, and the
      * setting should be moved to {@link #BUILT_IN_INDEX_SETTINGS}.
      */
-    public static final Map<String, List<Setting>> FEATURE_FLAGGED_INDEX_SETTINGS = Map.of();
+    public static final Map<String, List<Setting>> FEATURE_FLAGGED_INDEX_SETTINGS = Map.of(
+        FeatureFlags.TIERED_REMOTE_INDEX,
+        List.of(IndexModule.INDEX_STORE_LOCALITY_SETTING, IndexModule.INDEX_TIERING_STATE),
+        FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL,
+        List.of(IndexMetadata.INDEX_NUMBER_OF_SEARCH_REPLICAS_SETTING)
+    );
 
     public static final IndexScopedSettings DEFAULT_SCOPED_SETTINGS = new IndexScopedSettings(Settings.EMPTY, BUILT_IN_INDEX_SETTINGS);
 
diff --git a/server/src/main/java/org/opensearch/common/util/BatchRunnableExecutor.java b/server/src/main/java/org/opensearch/common/util/BatchRunnableExecutor.java
new file mode 100644
index 0000000000000..cfe2bbb85bda4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/util/BatchRunnableExecutor.java
@@ -0,0 +1,73 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.util;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.Randomness;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.TimeoutAwareRunnable;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+/**
+ * A {@link Runnable} that iteratively executes a batch of {@link TimeoutAwareRunnable}s. If the elapsed time exceeds the timeout defined by {@link TimeValue} timeout, then all subsequent {@link TimeoutAwareRunnable}s will have their {@link TimeoutAwareRunnable#onTimeout} method invoked and will not be run.
+ *
+ * @opensearch.internal
+ */
+public class BatchRunnableExecutor implements Runnable {
+
+    private final Supplier<TimeValue> timeoutSupplier;
+
+    private final List<TimeoutAwareRunnable> timeoutAwareRunnables;
+
+    private static final Logger logger = LogManager.getLogger(BatchRunnableExecutor.class);
+
+    public BatchRunnableExecutor(List<TimeoutAwareRunnable> timeoutAwareRunnables, Supplier<TimeValue> timeoutSupplier) {
+        this.timeoutSupplier = timeoutSupplier;
+        this.timeoutAwareRunnables = timeoutAwareRunnables;
+    }
+
+    // for tests
+    public List<TimeoutAwareRunnable> getTimeoutAwareRunnables() {
+        return this.timeoutAwareRunnables;
+    }
+
+    @Override
+    public void run() {
+        logger.debug("Starting execution of runnable of size [{}]", timeoutAwareRunnables.size());
+        long startTime = System.nanoTime();
+        if (timeoutAwareRunnables.isEmpty()) {
+            return;
+        }
+        Randomness.shuffle(timeoutAwareRunnables);
+        for (TimeoutAwareRunnable runnable : timeoutAwareRunnables) {
+            if (timeoutSupplier.get().nanos() < 0 || System.nanoTime() - startTime < timeoutSupplier.get().nanos()) {
+                runnable.run();
+            } else {
+                logger.debug("Executing timeout for runnable of size [{}]", timeoutAwareRunnables.size());
+                runnable.onTimeout();
+            }
+        }
+        logger.debug(
+            "Time taken to execute timed runnables in this cycle:[{}ms]",
+            TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)
+        );
+        onComplete();
+    }
+
+    /**
+     * Callback method that is invoked after all {@link TimeoutAwareRunnable} instances in the batch have been processed.
+     * By default, this method does nothing, but it can be overridden by subclasses or modified in the implementation if
+     * there is a need to perform additional actions once the batch execution is completed.
+     */
+    public void onComplete() {}
+}
diff --git a/server/src/main/java/org/opensearch/common/util/ByteArrayBackedBitset.java b/server/src/main/java/org/opensearch/common/util/ByteArrayBackedBitset.java
new file mode 100644
index 0000000000000..2d7948d414937
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/util/ByteArrayBackedBitset.java
@@ -0,0 +1,86 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.util;
+
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.RandomAccessInput;
+
+import java.io.IOException;
+
+/**
+ * A bitset backed by a byte array. This will initialize and set bits in the byte array based on the index.
+ */
+public class ByteArrayBackedBitset {
+    private final byte[] byteArray;
+
+    /**
+     * Constructor which uses an on heap list. This should be using during construction of the bitset.
+     */
+    public ByteArrayBackedBitset(int capacity) {
+        byteArray = new byte[capacity];
+    }
+
+    /**
+     * Constructor which set the Lucene's RandomAccessInput to read the bitset into a read-only buffer.
+     */
+    public ByteArrayBackedBitset(RandomAccessInput in, long offset, int length) throws IOException {
+        byteArray = new byte[length];
+        int i = 0;
+        while (i < length) {
+            byteArray[i] = in.readByte(offset + i);
+            i++;
+        }
+    }
+
+    /**
+     * Constructor which set the Lucene's IndexInput to read the bitset into a read-only buffer.
+     */
+    public ByteArrayBackedBitset(IndexInput in, int length) throws IOException {
+        byteArray = new byte[length];
+        int i = 0;
+        while (i < length) {
+            byteArray[i] = in.readByte();
+            i++;
+        }
+    }
+
+    /**
+     * Sets the bit at the given index to 1.
+     * Each byte can indicate 8 bits, so the index is divided by 8 to get the byte array index.
+     * @param index the index to set the bit
+     */
+    public void set(int index) {
+        int byteArrIndex = index >> 3;
+        byteArray[byteArrIndex] |= (byte) (1 << (index & 7));
+    }
+
+    public int write(IndexOutput output) throws IOException {
+        int numBytes = 0;
+        for (Byte bitSet : byteArray) {
+            output.writeByte(bitSet);
+            numBytes += Byte.BYTES;
+        }
+        return numBytes;
+    }
+
+    /**
+     * Retrieves whether the bit is set or not at the given index.
+     * @param index the index to look up for the bit
+     * @return true if bit is set, false otherwise
+     */
+    public boolean get(int index) throws IOException {
+        int byteArrIndex = index >> 3;
+        return (byteArray[byteArrIndex] & (1 << (index & 7))) != 0;
+    }
+
+    public int getCurrBytesRead() {
+        return byteArray.length;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/util/FeatureFlags.java b/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
index 62cfbd861d4d9..0ef2e773a690b 100644
--- a/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
+++ b/server/src/main/java/org/opensearch/common/util/FeatureFlags.java
@@ -23,7 +23,7 @@
  */
 public class FeatureFlags {
     /**
-     * Gates the visibility of the remote store migration support from docrep .
+     * Gates the visibility of the remote store to docrep migration.
      */
     public static final String REMOTE_STORE_MIGRATION_EXPERIMENTAL = "opensearch.experimental.feature.remote_store.migration.enabled";
 
@@ -67,6 +67,13 @@ public class FeatureFlags {
      */
     public static final String PLUGGABLE_CACHE = "opensearch.experimental.feature.pluggable.caching.enabled";
 
+    /**
+     * Gates the functionality of remote routing table.
+     */
+    public static final String REMOTE_PUBLICATION_EXPERIMENTAL = "opensearch.experimental.feature.remote_store.publication.enabled";
+
+    public static final String READER_WRITER_SPLIT_EXPERIMENTAL = "opensearch.experimental.feature.read.write.split.enabled";
+
     public static final Setting<Boolean> REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING = Setting.boolSetting(
         REMOTE_STORE_MIGRATION_EXPERIMENTAL,
         false,
@@ -89,6 +96,45 @@ public class FeatureFlags {
 
     public static final Setting<Boolean> PLUGGABLE_CACHE_SETTING = Setting.boolSetting(PLUGGABLE_CACHE, false, Property.NodeScope);
 
+    public static final Setting<Boolean> REMOTE_PUBLICATION_EXPERIMENTAL_SETTING = Setting.boolSetting(
+        REMOTE_PUBLICATION_EXPERIMENTAL,
+        false,
+        Property.NodeScope
+    );
+
+    public static final Setting<Boolean> READER_WRITER_SPLIT_EXPERIMENTAL_SETTING = Setting.boolSetting(
+        READER_WRITER_SPLIT_EXPERIMENTAL,
+        false,
+        Property.NodeScope
+    );
+
+    /**
+     * Gates the functionality of application based configuration templates.
+     */
+    public static final String APPLICATION_BASED_CONFIGURATION_TEMPLATES = "opensearch.experimental.feature.application_templates.enabled";
+    public static final Setting<Boolean> APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING = Setting.boolSetting(
+        APPLICATION_BASED_CONFIGURATION_TEMPLATES,
+        false,
+        Property.NodeScope
+    );
+
+    /**
+     * Gates the functionality of star tree index, which improves the performance of search
+     * aggregations.
+     */
+    public static final String STAR_TREE_INDEX = "opensearch.experimental.feature.composite_index.star_tree.enabled";
+    public static final Setting<Boolean> STAR_TREE_INDEX_SETTING = Setting.boolSetting(STAR_TREE_INDEX, false, Property.NodeScope);
+
+    /**
+     * Gates the functionality of ApproximatePointRangeQuery where we approximate query results.
+     */
+    public static final String APPROXIMATE_POINT_RANGE_QUERY = "opensearch.experimental.feature.approximate_point_range_query.enabled";
+    public static final Setting<Boolean> APPROXIMATE_POINT_RANGE_QUERY_SETTING = Setting.boolSetting(
+        APPROXIMATE_POINT_RANGE_QUERY,
+        false,
+        Property.NodeScope
+    );
+
     private static final List<Setting<Boolean>> ALL_FEATURE_FLAG_SETTINGS = List.of(
         REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING,
         EXTENSIONS_SETTING,
@@ -96,8 +142,13 @@ public class FeatureFlags {
         TELEMETRY_SETTING,
         DATETIME_FORMATTER_CACHING_SETTING,
         TIERED_REMOTE_INDEX_SETTING,
-        PLUGGABLE_CACHE_SETTING
+        PLUGGABLE_CACHE_SETTING,
+        REMOTE_PUBLICATION_EXPERIMENTAL_SETTING,
+        APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING,
+        STAR_TREE_INDEX_SETTING,
+        READER_WRITER_SPLIT_EXPERIMENTAL_SETTING
     );
+
     /**
      * Should store the settings from opensearch.yml.
      */
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
index 6580b0e0085ef..fadc53a332e64 100644
--- a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContext.java
@@ -38,6 +38,7 @@
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
@@ -45,11 +46,13 @@
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.http.HttpTransportSettings;
+import org.opensearch.secure_sm.ThreadContextPermission;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskThreadContextStatePropagator;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
+import java.security.Permission;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -102,6 +105,7 @@
  */
 @PublicApi(since = "1.0.0")
 public final class ThreadContext implements Writeable {
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(ThreadContext.class);
 
     public static final String PREFIX = "request.headers";
     public static final Setting<Settings> DEFAULT_HEADERS_SETTING = Setting.groupSetting(PREFIX + ".", Property.NodeScope);
@@ -111,6 +115,12 @@ public final class ThreadContext implements Writeable {
      */
     public static final String ACTION_ORIGIN_TRANSIENT_NAME = "action.origin";
 
+    // thread context permissions
+
+    private static final Permission ACCESS_SYSTEM_THREAD_CONTEXT_PERMISSION = new ThreadContextPermission("markAsSystemContext");
+    private static final Permission STASH_AND_MERGE_THREAD_CONTEXT_PERMISSION = new ThreadContextPermission("stashAndMergeHeaders");
+    private static final Permission STASH_WITH_ORIGIN_THREAD_CONTEXT_PERMISSION = new ThreadContextPermission("stashWithOrigin");
+
     private static final Logger logger = LogManager.getLogger(ThreadContext.class);
     private static final ThreadContextStruct DEFAULT_CONTEXT = new ThreadContextStruct();
     private final Map<String, String> defaultHeader;
@@ -205,8 +215,26 @@ public Writeable captureAsWriteable() {
      * For example, a user might not have permission to GET from the tasks index
      * but the tasks API will perform a get on their behalf using this method
      * if it can't find the task in memory.
+     *
+     * Usage of stashWithOrigin is guarded by a ThreadContextPermission. In order to use
+     * stashWithOrigin, the codebase needs to explicitly be granted permission in the JSM policy file.
+     *
+     * Add an entry in the grant portion of the policy file like this:
+     *
+     * permission org.opensearch.secure_sm.ThreadContextPermission "stashWithOrigin";
      */
     public StoredContext stashWithOrigin(String origin) {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            try {
+                sm.checkPermission(STASH_WITH_ORIGIN_THREAD_CONTEXT_PERMISSION);
+            } catch (SecurityException ex) {
+                deprecationLogger.deprecate(
+                    "stashWithOrigin",
+                    "Default access to stashWithOrigin will be removed in a future release. Permission to use stashWithOrigin must be explicitly granted."
+                );
+            }
+        }
         final ThreadContext.StoredContext storedContext = stashContext();
         putTransient(ACTION_ORIGIN_TRANSIENT_NAME, origin);
         return storedContext;
@@ -216,8 +244,26 @@ public StoredContext stashWithOrigin(String origin) {
      * Removes the current context and resets a new context that contains a merge of the current headers and the given headers.
      * The removed context can be restored when closing the returned {@link StoredContext}. The merge strategy is that headers
      * that are already existing are preserved unless they are defaults.
+     *
+     * Usage of stashAndMergeHeaders is guarded by a ThreadContextPermission. In order to use
+     * stashAndMergeHeaders, the codebase needs to explicitly be granted permission in the JSM policy file.
+     *
+     * Add an entry in the grant portion of the policy file like this:
+     *
+     * permission org.opensearch.secure_sm.ThreadContextPermission "stashAndMergeHeaders";
      */
     public StoredContext stashAndMergeHeaders(Map<String, String> headers) {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            try {
+                sm.checkPermission(STASH_AND_MERGE_THREAD_CONTEXT_PERMISSION);
+            } catch (SecurityException ex) {
+                deprecationLogger.deprecate(
+                    "stashAndMergeHeaders",
+                    "Default access to stashAndMergeHeaders will be removed in a future release. Permission to use stashAndMergeHeaders must be explicitly granted."
+                );
+            }
+        }
         final ThreadContextStruct context = threadLocal.get();
         Map<String, String> newHeader = new HashMap<>(headers);
         newHeader.putAll(context.requestHeaders);
@@ -483,6 +529,16 @@ public void addResponseHeader(final String key, final String value) {
         addResponseHeader(key, value, v -> v);
     }
 
+    /**
+     * Update the {@code value} for the specified {@code key}
+     *
+     * @param key         the header name
+     * @param value       the header value
+     */
+    public void updateResponseHeader(final String key, final String value) {
+        updateResponseHeader(key, value, v -> v);
+    }
+
     /**
      * Add the {@code value} for the specified {@code key} with the specified {@code uniqueValue} used for de-duplication. Any duplicate
      * {@code value} after applying {@code uniqueValue} is ignored.
@@ -492,7 +548,19 @@ public void addResponseHeader(final String key, final String value) {
      * @param uniqueValue the function that produces de-duplication values
      */
     public void addResponseHeader(final String key, final String value, final Function<String, String> uniqueValue) {
-        threadLocal.set(threadLocal.get().putResponse(key, value, uniqueValue, maxWarningHeaderCount, maxWarningHeaderSize));
+        threadLocal.set(threadLocal.get().putResponse(key, value, uniqueValue, maxWarningHeaderCount, maxWarningHeaderSize, false));
+    }
+
+    /**
+     * Update the {@code value} for the specified {@code key} with the specified {@code uniqueValue} used for de-duplication. Any duplicate
+     * {@code value} after applying {@code uniqueValue} is ignored.
+     *
+     * @param key         the header name
+     * @param value       the header value
+     * @param uniqueValue the function that produces de-duplication values
+     */
+    public void updateResponseHeader(final String key, final String value, final Function<String, String> uniqueValue) {
+        threadLocal.set(threadLocal.get().putResponse(key, value, uniqueValue, maxWarningHeaderCount, maxWarningHeaderSize, true));
     }
 
     /**
@@ -532,8 +600,26 @@ boolean isDefaultContext() {
     /**
      * Marks this thread context as an internal system context. This signals that actions in this context are issued
      * by the system itself rather than by a user action.
+     *
+     * Usage of markAsSystemContext is guarded by a ThreadContextPermission. In order to use
+     * markAsSystemContext, the codebase needs to explicitly be granted permission in the JSM policy file.
+     *
+     * Add an entry in the grant portion of the policy file like this:
+     *
+     * permission org.opensearch.secure_sm.ThreadContextPermission "markAsSystemContext";
      */
     public void markAsSystemContext() {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            try {
+                sm.checkPermission(ACCESS_SYSTEM_THREAD_CONTEXT_PERMISSION);
+            } catch (SecurityException ex) {
+                deprecationLogger.deprecate(
+                    "markAsSystemContext",
+                    "Default access to markAsSystemContext will be removed in a future release. Permission to use markAsSystemContext must be explicitly granted."
+                );
+            }
+        }
         threadLocal.set(threadLocal.get().setSystemContext(propagators));
     }
 
@@ -717,7 +803,8 @@ private ThreadContextStruct putResponse(
             final String value,
             final Function<String, String> uniqueValue,
             final int maxWarningHeaderCount,
-            final long maxWarningHeaderSize
+            final long maxWarningHeaderSize,
+            final boolean replaceExistingKey
         ) {
             assert value != null;
             long newWarningHeaderSize = warningHeadersSize;
@@ -759,8 +846,13 @@ private ThreadContextStruct putResponse(
                 if (existingValues.contains(uniqueValue.apply(value))) {
                     return this;
                 }
-                // preserve insertion order
-                final Set<String> newValues = Stream.concat(existingValues.stream(), Stream.of(value)).collect(LINKED_HASH_SET_COLLECTOR);
+                Set<String> newValues;
+                if (replaceExistingKey) {
+                    newValues = Stream.of(value).collect(LINKED_HASH_SET_COLLECTOR);
+                } else {
+                    // preserve insertion order
+                    newValues = Stream.concat(existingValues.stream(), Stream.of(value)).collect(LINKED_HASH_SET_COLLECTOR);
+                }
                 newResponseHeaders = new HashMap<>(responseHeaders);
                 newResponseHeaders.put(key, Collections.unmodifiableSet(newValues));
             } else {
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContextAccess.java b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContextAccess.java
new file mode 100644
index 0000000000000..14f8b8d79bf4d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/ThreadContextAccess.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.util.concurrent;
+
+import org.opensearch.SpecialPermission;
+import org.opensearch.common.annotation.InternalApi;
+
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+
+/**
+ * This class wraps the {@link ThreadContext} operations requiring access in
+ * {@link AccessController#doPrivileged(PrivilegedAction)} blocks.
+ *
+ * @opensearch.internal
+ */
+@SuppressWarnings("removal")
+@InternalApi
+public final class ThreadContextAccess {
+
+    private ThreadContextAccess() {}
+
+    public static <T> T doPrivileged(PrivilegedAction<T> operation) {
+        SpecialPermission.check();
+        return AccessController.doPrivileged(operation);
+    }
+
+    public static void doPrivilegedVoid(Runnable action) {
+        SpecialPermission.check();
+        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
+            action.run();
+            return null;
+        });
+    }
+}
diff --git a/server/src/main/java/org/opensearch/common/util/concurrent/TimeoutAwareRunnable.java b/server/src/main/java/org/opensearch/common/util/concurrent/TimeoutAwareRunnable.java
new file mode 100644
index 0000000000000..8d3357ad93095
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/util/concurrent/TimeoutAwareRunnable.java
@@ -0,0 +1,19 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.util.concurrent;
+
+/**
+ * Runnable that is aware of a timeout
+ *
+ * @opensearch.internal
+ */
+public interface TimeoutAwareRunnable extends Runnable {
+
+    void onTimeout();
+}
diff --git a/server/src/main/java/org/opensearch/common/xcontent/JsonToStringXContentParser.java b/server/src/main/java/org/opensearch/common/xcontent/JsonToStringXContentParser.java
index 998122d9e5c43..2f60fc8f69f87 100644
--- a/server/src/main/java/org/opensearch/common/xcontent/JsonToStringXContentParser.java
+++ b/server/src/main/java/org/opensearch/common/xcontent/JsonToStringXContentParser.java
@@ -9,6 +9,7 @@
 package org.opensearch.common.xcontent;
 
 import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.Strings;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.xcontent.AbstractXContentParser;
 import org.opensearch.core.xcontent.DeprecationHandler;
@@ -23,6 +24,10 @@
 import java.math.BigInteger;
 import java.nio.CharBuffer;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.LinkedList;
 
 /**
  * JsonToStringParser is the main parser class to transform JSON into stringFields in a XContentParser
@@ -32,21 +37,20 @@
  */
 public class JsonToStringXContentParser extends AbstractXContentParser {
     private final String fieldTypeName;
-    private XContentParser parser;
+    private final XContentParser parser;
 
-    private ArrayList<String> valueList = new ArrayList<>();
-    private ArrayList<String> valueAndPathList = new ArrayList<>();
-    private ArrayList<String> keyList = new ArrayList<>();
+    private final ArrayList<String> valueList = new ArrayList<>();
+    private final ArrayList<String> valueAndPathList = new ArrayList<>();
+    private final ArrayList<String> keyList = new ArrayList<>();
 
-    private XContentBuilder builder = XContentBuilder.builder(JsonXContent.jsonXContent);
+    private final XContentBuilder builder = XContentBuilder.builder(JsonXContent.jsonXContent);
 
-    private NamedXContentRegistry xContentRegistry;
+    private final NamedXContentRegistry xContentRegistry;
 
-    private DeprecationHandler deprecationHandler;
+    private final DeprecationHandler deprecationHandler;
 
     private static final String VALUE_AND_PATH_SUFFIX = "._valueAndPath";
     private static final String VALUE_SUFFIX = "._value";
-    private static final String DOT_SYMBOL = ".";
     private static final String EQUAL_SYMBOL = "=";
 
     public JsonToStringXContentParser(
@@ -63,86 +67,112 @@ public JsonToStringXContentParser(
     }
 
     public XContentParser parseObject() throws IOException {
+        assert currentToken() == Token.START_OBJECT;
+        parser.nextToken(); // Skip the outer START_OBJECT. Need to return on END_OBJECT.
+
         builder.startObject();
-        StringBuilder path = new StringBuilder(fieldTypeName);
-        parseToken(path, null);
-        builder.field(this.fieldTypeName, keyList);
-        builder.field(this.fieldTypeName + VALUE_SUFFIX, valueList);
-        builder.field(this.fieldTypeName + VALUE_AND_PATH_SUFFIX, valueAndPathList);
+        LinkedList<String> path = new LinkedList<>(Collections.singleton(fieldTypeName));
+        while (currentToken() != Token.END_OBJECT) {
+            parseToken(path, null);
+        }
+        // deduplication the fieldName,valueList,valueAndPathList
+        builder.field(this.fieldTypeName, new HashSet<>(keyList));
+        builder.field(this.fieldTypeName + VALUE_SUFFIX, new HashSet<>(valueList));
+        builder.field(this.fieldTypeName + VALUE_AND_PATH_SUFFIX, new HashSet<>(valueAndPathList));
         builder.endObject();
         String jString = XContentHelper.convertToJson(BytesReference.bytes(builder), false, MediaTypeRegistry.JSON);
         return JsonXContent.jsonXContent.createParser(this.xContentRegistry, this.deprecationHandler, String.valueOf(jString));
     }
 
-    private void parseToken(StringBuilder path, String currentFieldName) throws IOException {
-
-        while (this.parser.nextToken() != Token.END_OBJECT) {
-            if (this.parser.currentName() != null) {
-                currentFieldName = this.parser.currentName();
+    /**
+     * @return true if the child object contains no_null value, false otherwise
+     */
+    private boolean parseToken(Deque<String> path, String currentFieldName) throws IOException {
+        if (path.size() == 1 && processNoNestedValue()) {
+            return true;
+        }
+        boolean isChildrenValueValid = false;
+        boolean visitFieldName = false;
+        if (this.parser.currentToken() == Token.FIELD_NAME) {
+            currentFieldName = this.parser.currentName();
+            path.addLast(currentFieldName); // Pushing onto the stack *must* be matched by pop
+            visitFieldName = true;
+            String parts = currentFieldName;
+            while (parts.contains(".")) { // Extract the intermediate keys maybe present in fieldName
+                int dotPos = parts.indexOf('.');
+                String part = parts.substring(0, dotPos);
+                this.keyList.add(part);
+                parts = parts.substring(dotPos + 1);
             }
-            StringBuilder parsedFields = new StringBuilder();
-
-            if (this.parser.currentToken() == Token.FIELD_NAME) {
-                path.append(DOT_SYMBOL).append(currentFieldName);
-                int dotIndex = currentFieldName.indexOf(DOT_SYMBOL);
-                String fieldNameSuffix = currentFieldName;
-                // The field name may be of the form foo.bar.baz
-                // If that's the case, each "part" is a key.
-                while (dotIndex >= 0) {
-                    String fieldNamePrefix = fieldNameSuffix.substring(0, dotIndex);
-                    if (!fieldNamePrefix.isEmpty()) {
-                        this.keyList.add(fieldNamePrefix);
-                    }
-                    fieldNameSuffix = fieldNameSuffix.substring(dotIndex + 1);
-                    dotIndex = fieldNameSuffix.indexOf(DOT_SYMBOL);
-                }
-                if (!fieldNameSuffix.isEmpty()) {
-                    this.keyList.add(fieldNameSuffix);
-                }
-            } else if (this.parser.currentToken() == Token.START_ARRAY) {
-                parseToken(path, currentFieldName);
-                break;
-            } else if (this.parser.currentToken() == Token.END_ARRAY) {
-                // skip
-            } else if (this.parser.currentToken() == Token.START_OBJECT) {
-                parseToken(path, currentFieldName);
-                int dotIndex = path.lastIndexOf(DOT_SYMBOL, path.length());
-
-                if (dotIndex != -1 && path.length() > currentFieldName.length()) {
-                    path.setLength(path.length() - currentFieldName.length() - 1);
-                }
-            } else {
-                if (!path.toString().contains(currentFieldName)) {
-                    path.append(DOT_SYMBOL).append(currentFieldName);
-                }
-                parseValue(parsedFields);
-                this.valueList.add(parsedFields.toString());
-                this.valueAndPathList.add(path + EQUAL_SYMBOL + parsedFields);
-                int dotIndex = path.lastIndexOf(DOT_SYMBOL, path.length());
-                if (dotIndex != -1 && path.length() > currentFieldName.length()) {
-                    path.setLength(path.length() - currentFieldName.length() - 1);
-                }
+            this.keyList.add(parts); // parts has no dot, so either it's the original fieldName or it's the last part
+            this.parser.nextToken(); // advance to the value of fieldName
+            isChildrenValueValid = parseToken(path, currentFieldName); // parse the value for fieldName (which will be an array, an object,
+                                                                       // or a primitive value)
+            path.removeLast(); // Here is where we pop fieldName from the stack (since we're done with the value of fieldName)
+            // Note that whichever other branch we just passed through has already ended with nextToken(), so we
+            // don't need to call it.
+        } else if (this.parser.currentToken() == Token.START_ARRAY) {
+            parser.nextToken();
+            while (this.parser.currentToken() != Token.END_ARRAY) {
+                isChildrenValueValid |= parseToken(path, currentFieldName);
             }
+            this.parser.nextToken();
+        } else if (this.parser.currentToken() == Token.END_ARRAY) {
+            // skip
+        } else if (this.parser.currentToken() == Token.START_OBJECT) {
+            parser.nextToken();
+            while (this.parser.currentToken() != Token.END_OBJECT) {
+                isChildrenValueValid |= parseToken(path, currentFieldName);
+            }
+            this.parser.nextToken();
+        } else {
+            String parsedValue = parseValue();
+            if (parsedValue != null) {
+                this.valueList.add(parsedValue);
+                this.valueAndPathList.add(Strings.collectionToDelimitedString(path, ".") + EQUAL_SYMBOL + parsedValue);
+                isChildrenValueValid = true;
+            }
+            this.parser.nextToken();
+        }
 
+        if (visitFieldName && isChildrenValueValid == false) {
+            removeKeyOfNullValue();
         }
+        return isChildrenValueValid;
+    }
+
+    public void removeKeyOfNullValue() {
+        // it means that the value of the sub child (or the last brother) is invalid,
+        // we should delete the key from keyList.
+        assert keyList.size() > 0;
+        this.keyList.remove(keyList.size() - 1);
+    }
+
+    private boolean processNoNestedValue() throws IOException {
+        if (parser.currentToken() == Token.VALUE_NULL) {
+            return true;
+        } else if (this.parser.currentToken() == Token.VALUE_STRING
+            || this.parser.currentToken() == Token.VALUE_NUMBER
+            || this.parser.currentToken() == Token.VALUE_BOOLEAN) {
+                String value = this.parser.textOrNull();
+                if (value != null) {
+                    this.valueList.add(value);
+                }
+                return true;
+            }
+        return false;
     }
 
-    private void parseValue(StringBuilder parsedFields) throws IOException {
+    private String parseValue() throws IOException {
         switch (this.parser.currentToken()) {
             case VALUE_BOOLEAN:
             case VALUE_NUMBER:
             case VALUE_STRING:
             case VALUE_NULL:
-                parsedFields.append(this.parser.textOrNull());
-                break;
+                return this.parser.textOrNull();
             // Handle other token types as needed
-            case FIELD_NAME:
-            case VALUE_EMBEDDED_OBJECT:
-            case END_ARRAY:
-            case START_ARRAY:
-                break;
             default:
-                throw new IOException("Unsupported token type [" + parser.currentToken() + "]");
+                throw new IOException("Unsupported value token type [" + parser.currentToken() + "]");
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/common/xcontent/support/XContentHttpChunk.java b/server/src/main/java/org/opensearch/common/xcontent/support/XContentHttpChunk.java
new file mode 100644
index 0000000000000..a7f1d30cd05dd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/common/xcontent/support/XContentHttpChunk.java
@@ -0,0 +1,68 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.xcontent.support;
+
+import org.opensearch.common.Nullable;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.common.bytes.CompositeBytesReference;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.http.HttpChunk;
+
+/**
+ * Wraps the instance of the {@link XContentBuilder} into {@link HttpChunk}
+ */
+public final class XContentHttpChunk implements HttpChunk {
+    private static final byte[] CHUNK_SEPARATOR = new byte[] { '\r', '\n' };
+    private final BytesReference content;
+
+    /**
+     * Creates a new {@link HttpChunk} from {@link XContentBuilder}
+     * @param builder {@link XContentBuilder} instance
+     * @return new {@link HttpChunk} instance, if passed {@link XContentBuilder} us {@code null}, a last empty {@link HttpChunk} will be returned
+     */
+    public static HttpChunk from(@Nullable final XContentBuilder builder) {
+        return new XContentHttpChunk(builder);
+    }
+
+    /**
+     * Creates a new last empty {@link HttpChunk}
+     * @return last empty {@link HttpChunk} instance
+     */
+    public static HttpChunk last() {
+        return new XContentHttpChunk(null);
+    }
+
+    private XContentHttpChunk(@Nullable final XContentBuilder builder) {
+        if (builder == null /* no content */) {
+            content = BytesArray.EMPTY;
+        } else {
+            // Always finalize the output chunk with '\r\n' sequence
+            content = CompositeBytesReference.of(BytesReference.bytes(builder), new BytesArray(CHUNK_SEPARATOR));
+        }
+    }
+
+    @Override
+    public boolean isLast() {
+        return content == BytesArray.EMPTY;
+    }
+
+    @Override
+    public BytesReference content() {
+        return content;
+    }
+
+    @Override
+    public void close() {
+        if (content instanceof Releasable) {
+            ((Releasable) content).close();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java b/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
index 288371aa240a0..922e23b849d49 100644
--- a/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
+++ b/server/src/main/java/org/opensearch/discovery/DiscoveryModule.java
@@ -34,6 +34,7 @@
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.coordination.Coordinator;
 import org.opensearch.cluster.coordination.ElectionStrategy;
@@ -52,6 +53,7 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.gateway.GatewayMetaState;
+import org.opensearch.gateway.remote.RemoteClusterStateService;
 import org.opensearch.monitor.NodeHealthService;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.plugins.DiscoveryPlugin;
@@ -133,7 +135,9 @@ public DiscoveryModule(
         RerouteService rerouteService,
         NodeHealthService nodeHealthService,
         PersistedStateRegistry persistedStateRegistry,
-        RemoteStoreNodeService remoteStoreNodeService
+        RemoteStoreNodeService remoteStoreNodeService,
+        ClusterManagerMetrics clusterManagerMetrics,
+        RemoteClusterStateService remoteClusterStateService
     ) {
         final Collection<BiConsumer<DiscoveryNode, ClusterState>> joinValidators = new ArrayList<>();
         final Map<String, Supplier<SeedHostsProvider>> hostProviders = new HashMap<>();
@@ -211,7 +215,9 @@ public DiscoveryModule(
                 electionStrategy,
                 nodeHealthService,
                 persistedStateRegistry,
-                remoteStoreNodeService
+                remoteStoreNodeService,
+                clusterManagerMetrics,
+                remoteClusterStateService
             );
         } else {
             throw new IllegalArgumentException("Unknown discovery type [" + discoveryType + "]");
diff --git a/server/src/main/java/org/opensearch/env/NodeEnvironment.java b/server/src/main/java/org/opensearch/env/NodeEnvironment.java
index df7066a9af1ff..0899fb1123bc4 100644
--- a/server/src/main/java/org/opensearch/env/NodeEnvironment.java
+++ b/server/src/main/java/org/opensearch/env/NodeEnvironment.java
@@ -35,7 +35,6 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.apache.logging.log4j.util.Strings;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.SegmentInfos;
 import org.apache.lucene.store.Directory;
@@ -61,6 +60,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.common.Strings;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
@@ -1300,7 +1300,7 @@ public static List<Path> collectFileCacheDataPath(NodePath fileCacheNodePath) th
      * Resolve the custom path for a index's shard.
      */
     public static Path resolveBaseCustomLocation(String customDataPath, Path sharedDataPath, int nodeLockId) {
-        if (Strings.isNotEmpty(customDataPath)) {
+        if (!Strings.isNullOrEmpty(customDataPath)) {
             // This assert is because this should be caught by MetadataCreateIndexService
             assert sharedDataPath != null;
             return sharedDataPath.resolve(customDataPath).resolve(Integer.toString(nodeLockId));
diff --git a/server/src/main/java/org/opensearch/extensions/NoopExtensionsManager.java b/server/src/main/java/org/opensearch/extensions/NoopExtensionsManager.java
index 81b1b91b11481..5bc655af4df7b 100644
--- a/server/src/main/java/org/opensearch/extensions/NoopExtensionsManager.java
+++ b/server/src/main/java/org/opensearch/extensions/NoopExtensionsManager.java
@@ -20,7 +20,6 @@
 import org.opensearch.transport.TransportService;
 
 import java.io.IOException;
-import java.util.List;
 import java.util.Optional;
 import java.util.Set;
 
@@ -31,8 +30,8 @@
  */
 public class NoopExtensionsManager extends ExtensionsManager {
 
-    public NoopExtensionsManager() throws IOException {
-        super(Set.of(), new IdentityService(Settings.EMPTY, List.of()));
+    public NoopExtensionsManager(IdentityService identityService) throws IOException {
+        super(Set.of(), identityService);
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
index f4503ce55e6bc..dc508e30b1895 100644
--- a/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
+++ b/server/src/main/java/org/opensearch/extensions/rest/RestSendToExtensionAction.java
@@ -249,7 +249,7 @@ public String executor() {
             Map<String, List<String>> filteredHeaders = filterHeaders(headers, allowList, denyList);
 
             TokenManager tokenManager = identityService.getTokenManager();
-            Subject subject = this.identityService.getSubject();
+            Subject subject = this.identityService.getCurrentSubject();
             OnBehalfOfClaims claims = new OnBehalfOfClaims(discoveryExtensionNode.getId(), subject.getPrincipal().getName());
 
             transportService.sendRequest(
diff --git a/server/src/main/java/org/opensearch/gateway/AsyncShardBatchFetch.java b/server/src/main/java/org/opensearch/gateway/AsyncShardBatchFetch.java
index 4f39a39cea678..df642a9f5a743 100644
--- a/server/src/main/java/org/opensearch/gateway/AsyncShardBatchFetch.java
+++ b/server/src/main/java/org/opensearch/gateway/AsyncShardBatchFetch.java
@@ -80,6 +80,14 @@ public synchronized void clearShard(ShardId shardId) {
         this.cache.deleteShard(shardId);
     }
 
+    public boolean hasEmptyCache() {
+        return this.cache.getCache().isEmpty();
+    }
+
+    public AsyncShardFetchCache<T> getCache() {
+        return this.cache;
+    }
+
     /**
      * Cache implementation of transport actions returning batch of shards related data in the response.
      * Store node level responses of transport actions like {@link TransportNodesListGatewayStartedShardsBatch} or
diff --git a/server/src/main/java/org/opensearch/gateway/BaseGatewayShardAllocator.java b/server/src/main/java/org/opensearch/gateway/BaseGatewayShardAllocator.java
index eed5de65258fc..2b6c5e3f5ae53 100644
--- a/server/src/main/java/org/opensearch/gateway/BaseGatewayShardAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/BaseGatewayShardAllocator.java
@@ -44,11 +44,11 @@
 import org.opensearch.cluster.routing.allocation.NodeAllocationResult;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
 import org.opensearch.cluster.routing.allocation.decider.Decision;
+import org.opensearch.core.index.shard.ShardId;
 
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.stream.Collectors;
+import java.util.Set;
 
 /**
  * An abstract class that implements basic functionality for allocating
@@ -81,38 +81,30 @@ public void allocateUnassigned(
         executeDecision(shardRouting, allocateUnassignedDecision, allocation, unassignedAllocationHandler);
     }
 
-    /**
-     * Allocate Batch of unassigned shard  to nodes where valid copies of the shard already exists
-     * @param shardRoutings the shards to allocate
-     * @param allocation the allocation state container object
-     */
-    public void allocateUnassignedBatch(List<ShardRouting> shardRoutings, RoutingAllocation allocation) {
-        // make Allocation Decisions for all shards
-        HashMap<ShardRouting, AllocateUnassignedDecision> decisionMap = makeAllocationDecision(shardRoutings, allocation, logger);
-        assert shardRoutings.size() == decisionMap.size() : "make allocation decision didn't return allocation decision for "
-            + "some shards";
-        // get all unassigned shards iterator
+    protected void allocateUnassignedBatchOnTimeout(Set<ShardId> shardIds, RoutingAllocation allocation, boolean primary) {
+        if (shardIds.isEmpty()) {
+            return;
+        }
         RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
-
         while (iterator.hasNext()) {
-            ShardRouting shard = iterator.next();
-            try {
-                if (decisionMap.isEmpty() == false) {
-                    if (decisionMap.containsKey(shard)) {
-                        executeDecision(shard, decisionMap.remove(shard), allocation, iterator);
-                    }
-                } else {
-                    // no need to keep iterating the unassigned shards, if we don't have anything in decision map
-                    break;
+            ShardRouting unassignedShard = iterator.next();
+            AllocateUnassignedDecision allocationDecision;
+            if (unassignedShard.primary() == primary && shardIds.contains(unassignedShard.shardId())) {
+                if (isResponsibleFor(unassignedShard) == false) {
+                    continue;
                 }
-            } catch (Exception e) {
-                logger.error("Failed to execute decision for shard {} while initializing {}", shard, e);
-                throw e;
+                allocationDecision = AllocateUnassignedDecision.throttle(null);
+                executeDecision(unassignedShard, allocationDecision, allocation, iterator);
             }
         }
     }
 
-    private void executeDecision(
+    /**
+     * Is the allocator responsible for allocating the given {@link ShardRouting}?
+     */
+    protected abstract boolean isResponsibleFor(ShardRouting shardRouting);
+
+    protected void executeDecision(
         ShardRouting shardRouting,
         AllocateUnassignedDecision allocateUnassignedDecision,
         RoutingAllocation allocation,
@@ -135,8 +127,6 @@ private void executeDecision(
         }
     }
 
-    public void allocateUnassignedBatch(String batchId, RoutingAllocation allocation) {}
-
     protected long getExpectedShardSize(ShardRouting shardRouting, RoutingAllocation allocation) {
         if (shardRouting.primary()) {
             if (shardRouting.recoverySource().getType() == RecoverySource.Type.SNAPSHOT) {
@@ -165,21 +155,6 @@ public abstract AllocateUnassignedDecision makeAllocationDecision(
         Logger logger
     );
 
-    public HashMap<ShardRouting, AllocateUnassignedDecision> makeAllocationDecision(
-        List<ShardRouting> unassignedShardBatch,
-        RoutingAllocation allocation,
-        Logger logger
-    ) {
-
-        return (HashMap<ShardRouting, AllocateUnassignedDecision>) unassignedShardBatch.stream()
-            .collect(
-                Collectors.toMap(
-                    unassignedShard -> unassignedShard,
-                    unassignedShard -> makeAllocationDecision(unassignedShard, allocation, logger)
-                )
-            );
-    }
-
     /**
      * Builds decisions for all nodes in the cluster, so that the explain API can provide information on
      * allocation decisions for each node, while still waiting to allocate the shard (e.g. due to fetching shard data).
diff --git a/server/src/main/java/org/opensearch/gateway/GatewayMetaState.java b/server/src/main/java/org/opensearch/gateway/GatewayMetaState.java
index 24183f2d2675f..06026964590e1 100644
--- a/server/src/main/java/org/opensearch/gateway/GatewayMetaState.java
+++ b/server/src/main/java/org/opensearch/gateway/GatewayMetaState.java
@@ -65,6 +65,7 @@
 import org.opensearch.env.NodeMetadata;
 import org.opensearch.gateway.remote.ClusterMetadataManifest;
 import org.opensearch.gateway.remote.RemoteClusterStateService;
+import org.opensearch.gateway.remote.model.RemoteClusterStateManifestInfo;
 import org.opensearch.index.recovery.RemoteStoreRestoreService;
 import org.opensearch.index.recovery.RemoteStoreRestoreService.RemoteRestoreResult;
 import org.opensearch.node.Node;
@@ -666,6 +667,8 @@ public static class RemotePersistedState implements PersistedState {
 
         private ClusterState lastAcceptedState;
         private ClusterMetadataManifest lastAcceptedManifest;
+
+        private String lastUploadedManifestFile;
         private final RemoteClusterStateService remoteClusterStateService;
         private String previousClusterUUID;
 
@@ -691,11 +694,20 @@ public void setCurrentTerm(long currentTerm) {
             // But for RemotePersistedState, the state is only pushed by the active cluster. So this method is not required.
         }
 
+        public String getLastUploadedManifestFile() {
+            return lastUploadedManifestFile;
+        }
+
         @Override
         public void setLastAcceptedState(ClusterState clusterState) {
             try {
-                final ClusterMetadataManifest manifest;
-                if (shouldWriteFullClusterState(clusterState)) {
+                final RemoteClusterStateManifestInfo manifestDetails;
+                // Decide the codec version
+                int codecVersion = ClusterMetadataManifest.getCodecForVersion(clusterState.nodes().getMinNodeVersion());
+                assert codecVersion >= 0 : codecVersion;
+                logger.info("codec version is {}", codecVersion);
+
+                if (shouldWriteFullClusterState(clusterState, codecVersion)) {
                     final Optional<ClusterMetadataManifest> latestManifest = remoteClusterStateService.getLatestClusterMetadataManifest(
                         clusterState.getClusterName().value(),
                         clusterState.metadata().clusterUUID()
@@ -712,15 +724,21 @@ public void setLastAcceptedState(ClusterState clusterState) {
                             clusterState.metadata().clusterUUID()
                         );
                     }
-                    manifest = remoteClusterStateService.writeFullMetadata(clusterState, previousClusterUUID);
+                    manifestDetails = remoteClusterStateService.writeFullMetadata(clusterState, previousClusterUUID, codecVersion);
                 } else {
                     assert verifyManifestAndClusterState(lastAcceptedManifest, lastAcceptedState) == true
                         : "Previous manifest and previous ClusterState are not in sync";
-                    manifest = remoteClusterStateService.writeIncrementalMetadata(lastAcceptedState, clusterState, lastAcceptedManifest);
+                    manifestDetails = remoteClusterStateService.writeIncrementalMetadata(
+                        lastAcceptedState,
+                        clusterState,
+                        lastAcceptedManifest
+                    );
                 }
-                assert verifyManifestAndClusterState(manifest, clusterState) == true : "Manifest and ClusterState are not in sync";
-                lastAcceptedManifest = manifest;
+                assert verifyManifestAndClusterState(manifestDetails.getClusterMetadataManifest(), clusterState) == true
+                    : "Manifest and ClusterState are not in sync";
+                lastAcceptedManifest = manifestDetails.getClusterMetadataManifest();
                 lastAcceptedState = clusterState;
+                lastUploadedManifestFile = manifestDetails.getManifestFileName();
             } catch (Exception e) {
                 remoteClusterStateService.writeMetadataFailed();
                 handleExceptionOnWrite(e);
@@ -729,7 +747,7 @@ assert verifyManifestAndClusterState(lastAcceptedManifest, lastAcceptedState) ==
 
         @Override
         public PersistedStateStats getStats() {
-            return remoteClusterStateService.getStats();
+            return remoteClusterStateService.getUploadStats();
         }
 
         private boolean verifyManifestAndClusterState(ClusterMetadataManifest manifest, ClusterState clusterState) {
@@ -746,11 +764,13 @@ private boolean verifyManifestAndClusterState(ClusterMetadataManifest manifest,
             return true;
         }
 
-        private boolean shouldWriteFullClusterState(ClusterState clusterState) {
+        private boolean shouldWriteFullClusterState(ClusterState clusterState, int codecVersion) {
+            assert lastAcceptedManifest == null || lastAcceptedManifest.getCodecVersion() <= codecVersion;
             if (lastAcceptedState == null
                 || lastAcceptedManifest == null
                 || lastAcceptedState.term() != clusterState.term()
-                || lastAcceptedManifest.getOpensearchVersion() != Version.CURRENT) {
+                || lastAcceptedManifest.getOpensearchVersion() != Version.CURRENT
+                || lastAcceptedManifest.getCodecVersion() != codecVersion) {
                 return true;
             }
             return false;
@@ -768,12 +788,13 @@ public void markLastAcceptedStateAsCommitted() {
                     metadataBuilder.clusterUUIDCommitted(true);
                     clusterState = ClusterState.builder(lastAcceptedState).metadata(metadataBuilder).build();
                 }
-                final ClusterMetadataManifest committedManifest = remoteClusterStateService.markLastStateAsCommitted(
+                final RemoteClusterStateManifestInfo committedManifestDetails = remoteClusterStateService.markLastStateAsCommitted(
                     clusterState,
                     lastAcceptedManifest
                 );
-                lastAcceptedManifest = committedManifest;
+                lastAcceptedManifest = committedManifestDetails.getClusterMetadataManifest();
                 lastAcceptedState = clusterState;
+                lastUploadedManifestFile = committedManifestDetails.getManifestFileName();
             } catch (Exception e) {
                 handleExceptionOnWrite(e);
             }
diff --git a/server/src/main/java/org/opensearch/gateway/PrimaryShardAllocator.java b/server/src/main/java/org/opensearch/gateway/PrimaryShardAllocator.java
index f41545cbdf9bf..dea7ca9a08edd 100644
--- a/server/src/main/java/org/opensearch/gateway/PrimaryShardAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/PrimaryShardAllocator.java
@@ -82,7 +82,7 @@ public abstract class PrimaryShardAllocator extends BaseGatewayShardAllocator {
     /**
      * Is the allocator responsible for allocating the given {@link ShardRouting}?
      */
-    protected static boolean isResponsibleFor(final ShardRouting shard) {
+    protected boolean isResponsibleFor(final ShardRouting shard) {
         return shard.primary() // must be primary
             && shard.unassigned() // must be unassigned
             // only handle either an existing store or a snapshot recovery
diff --git a/server/src/main/java/org/opensearch/gateway/PrimaryShardBatchAllocator.java b/server/src/main/java/org/opensearch/gateway/PrimaryShardBatchAllocator.java
index 1979f33484d49..c493bf717c97f 100644
--- a/server/src/main/java/org/opensearch/gateway/PrimaryShardBatchAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/PrimaryShardBatchAllocator.java
@@ -14,6 +14,7 @@
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.allocation.AllocateUnassignedDecision;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
+import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.gateway.AsyncShardFetch.FetchResult;
 import org.opensearch.gateway.TransportNodesGatewayStartedShardHelper.GatewayStartedShard;
 import org.opensearch.gateway.TransportNodesGatewayStartedShardHelper.NodeGatewayStartedShard;
@@ -22,8 +23,10 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
  * PrimaryShardBatchAllocator is similar to {@link org.opensearch.gateway.PrimaryShardAllocator} only difference is
@@ -61,50 +64,61 @@ protected FetchResult<TransportNodesListGatewayStartedShards.NodeGatewayStartedS
 
     @Override
     public AllocateUnassignedDecision makeAllocationDecision(ShardRouting unassignedShard, RoutingAllocation allocation, Logger logger) {
-        return makeAllocationDecision(Collections.singletonList(unassignedShard), allocation, logger).get(unassignedShard);
+        AllocateUnassignedDecision decision = getInEligibleShardDecision(unassignedShard, allocation);
+        if (decision != null) {
+            return decision;
+        }
+        final FetchResult<NodeGatewayStartedShardsBatch> shardsState = fetchData(
+            List.of(unassignedShard),
+            Collections.emptyList(),
+            allocation
+        );
+        List<NodeGatewayStartedShard> nodeGatewayStartedShards = adaptToNodeShardStates(unassignedShard, shardsState);
+        return getAllocationDecision(unassignedShard, allocation, nodeGatewayStartedShards, logger);
     }
 
     /**
-     * Build allocation decisions for all the shards present in the batch identified by batchId.
+     * Allocate Batch of unassigned shard  to nodes where valid copies of the shard already exists
      *
-     * @param shards     set of shards given for allocation
-     * @param allocation current allocation of all the shards
-     * @param logger     logger used for logging
-     * @return shard to allocation decision map
+     * @param shardRoutings the shards to allocate
+     * @param allocation    the allocation state container object
      */
-    @Override
-    public HashMap<ShardRouting, AllocateUnassignedDecision> makeAllocationDecision(
-        List<ShardRouting> shards,
-        RoutingAllocation allocation,
-        Logger logger
-    ) {
-        HashMap<ShardRouting, AllocateUnassignedDecision> shardAllocationDecisions = new HashMap<>();
+    public void allocateUnassignedBatch(List<ShardRouting> shardRoutings, RoutingAllocation allocation) {
+        logger.trace("Starting shard allocation execution for unassigned primary shards: {}", shardRoutings.size());
+        HashMap<ShardId, AllocateUnassignedDecision> ineligibleShardAllocationDecisions = new HashMap<>();
         List<ShardRouting> eligibleShards = new ArrayList<>();
         List<ShardRouting> inEligibleShards = new ArrayList<>();
         // identify ineligible shards
-        for (ShardRouting shard : shards) {
+        for (ShardRouting shard : shardRoutings) {
             AllocateUnassignedDecision decision = getInEligibleShardDecision(shard, allocation);
             if (decision != null) {
+                ineligibleShardAllocationDecisions.put(shard.shardId(), decision);
                 inEligibleShards.add(shard);
-                shardAllocationDecisions.put(shard, decision);
             } else {
                 eligibleShards.add(shard);
             }
         }
-        // Do not call fetchData if there are no eligible shards
-        if (eligibleShards.isEmpty()) {
-            return shardAllocationDecisions;
-        }
+
         // only fetch data for eligible shards
         final FetchResult<NodeGatewayStartedShardsBatch> shardsState = fetchData(eligibleShards, inEligibleShards, allocation);
 
-        // process the received data
-        for (ShardRouting unassignedShard : eligibleShards) {
-            List<NodeGatewayStartedShard> nodeShardStates = adaptToNodeShardStates(unassignedShard, shardsState);
-            // get allocation decision for this shard
-            shardAllocationDecisions.put(unassignedShard, getAllocationDecision(unassignedShard, allocation, nodeShardStates, logger));
+        Set<ShardRouting> batchShardRoutingSet = new HashSet<>(shardRoutings);
+        RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
+        while (iterator.hasNext()) {
+            ShardRouting unassignedShard = iterator.next();
+            AllocateUnassignedDecision allocationDecision;
+
+            if (unassignedShard.primary() && batchShardRoutingSet.contains(unassignedShard)) {
+                if (ineligibleShardAllocationDecisions.containsKey(unassignedShard.shardId())) {
+                    allocationDecision = ineligibleShardAllocationDecisions.get(unassignedShard.shardId());
+                } else {
+                    List<NodeGatewayStartedShard> nodeShardStates = adaptToNodeShardStates(unassignedShard, shardsState);
+                    allocationDecision = getAllocationDecision(unassignedShard, allocation, nodeShardStates, logger);
+                }
+                executeDecision(unassignedShard, allocationDecision, allocation, iterator);
+            }
         }
-        return shardAllocationDecisions;
+        logger.trace("Finished shard allocation execution for unassigned primary shards: {}", shardRoutings.size());
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/gateway/ReplicaShardAllocator.java b/server/src/main/java/org/opensearch/gateway/ReplicaShardAllocator.java
index d9474b32bdbf6..c30ee8479ac97 100644
--- a/server/src/main/java/org/opensearch/gateway/ReplicaShardAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/ReplicaShardAllocator.java
@@ -100,7 +100,10 @@ protected Runnable cancelExistingRecoveryForBetterMatch(
         Metadata metadata = allocation.metadata();
         RoutingNodes routingNodes = allocation.routingNodes();
         ShardRouting primaryShard = allocation.routingNodes().activePrimary(shard.shardId());
-        assert primaryShard != null : "the replica shard can be allocated on at least one node, so there must be an active primary";
+        if (primaryShard == null) {
+            logger.trace("{}: no active primary shard found or allocated, letting actual allocation figure it out", shard);
+            return null;
+        }
         assert primaryShard.currentNodeId() != null;
         final DiscoveryNode primaryNode = allocation.nodes().get(primaryShard.currentNodeId());
 
@@ -188,7 +191,7 @@ public void processExistingRecoveries(RoutingAllocation allocation) {
     /**
      * Is the allocator responsible for allocating the given {@link ShardRouting}?
      */
-    protected static boolean isResponsibleFor(final ShardRouting shard) {
+    protected boolean isResponsibleFor(final ShardRouting shard) {
         return shard.primary() == false // must be a replica
             && shard.unassigned() // must be unassigned
             // if we are allocating a replica because of index creation, no need to go and find a copy, there isn't one...
diff --git a/server/src/main/java/org/opensearch/gateway/ReplicaShardBatchAllocator.java b/server/src/main/java/org/opensearch/gateway/ReplicaShardBatchAllocator.java
index be7867b7823f6..020a543ac5fc5 100644
--- a/server/src/main/java/org/opensearch/gateway/ReplicaShardBatchAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/ReplicaShardBatchAllocator.java
@@ -10,6 +10,7 @@
 
 import org.apache.logging.log4j.Logger;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.RoutingNodes;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.UnassignedInfo;
 import org.opensearch.cluster.routing.allocation.AllocateUnassignedDecision;
@@ -27,8 +28,11 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.function.Supplier;
 
 /**
  * Allocates replica shards in a batch mode
@@ -42,7 +46,7 @@ public abstract class ReplicaShardBatchAllocator extends ReplicaShardAllocator {
      * match. Today, a better match is one that can perform a no-op recovery while the previous recovery
      * has to copy segment files.
      *
-     * @param allocation the overall routing allocation
+     * @param allocation   the overall routing allocation
      * @param shardBatches a list of shard batches to check for existing recoveries
      */
     public void processExistingRecoveries(RoutingAllocation allocation, List<List<ShardRouting>> shardBatches) {
@@ -98,71 +102,98 @@ protected FetchResult<TransportNodesListShardStoreMetadata.NodeStoreFilesMetadat
 
     @Override
     public AllocateUnassignedDecision makeAllocationDecision(ShardRouting unassignedShard, RoutingAllocation allocation, Logger logger) {
-        return makeAllocationDecision(Collections.singletonList(unassignedShard), allocation, logger).get(unassignedShard);
+        Supplier<Map<DiscoveryNode, StoreFilesMetadata>> fetchDataResultSupplier = () -> {
+            return convertToNodeStoreFilesMetadataMap(
+                unassignedShard,
+                fetchData(List.of(unassignedShard), Collections.emptyList(), allocation)
+            );
+        };
+        return getUnassignedShardAllocationDecision(unassignedShard, allocation, fetchDataResultSupplier);
     }
 
-    @Override
-    public HashMap<ShardRouting, AllocateUnassignedDecision> makeAllocationDecision(
-        List<ShardRouting> shards,
-        RoutingAllocation allocation,
-        Logger logger
-    ) {
-        HashMap<ShardRouting, AllocateUnassignedDecision> shardAllocationDecisions = new HashMap<>();
-        final boolean explain = allocation.debugDecision();
+    /**
+     * Allocate Batch of unassigned shard  to nodes where valid copies of the shard already exists
+     *
+     * @param shardRoutings the shards to allocate
+     * @param allocation    the allocation state container object
+     */
+    public void allocateUnassignedBatch(List<ShardRouting> shardRoutings, RoutingAllocation allocation) {
+        logger.trace("Starting shard allocation execution for unassigned replica shards: {}", shardRoutings.size());
         List<ShardRouting> eligibleShards = new ArrayList<>();
         List<ShardRouting> ineligibleShards = new ArrayList<>();
-        HashMap<ShardRouting, Tuple<Decision, Map<String, NodeAllocationResult>>> nodeAllocationDecisions = new HashMap<>();
-        for (ShardRouting shard : shards) {
-            if (!isResponsibleFor(shard)) {
-                // this allocator n is not responsible for allocating this shard
+        Map<ShardRouting, AllocateUnassignedDecision> ineligibleShardAllocationDecisions = new HashMap<>();
+
+        for (ShardRouting shard : shardRoutings) {
+            AllocateUnassignedDecision shardDecisionWithoutFetch = getUnassignedShardAllocationDecision(shard, allocation, null);
+            // Without fetchData, decision for in-eligible shards is non-null from our preliminary checks and null for eligible shards.
+            if (shardDecisionWithoutFetch != null) {
                 ineligibleShards.add(shard);
-                shardAllocationDecisions.put(shard, AllocateUnassignedDecision.NOT_TAKEN);
-                continue;
+                ineligibleShardAllocationDecisions.put(shard, shardDecisionWithoutFetch);
+            } else {
+                eligibleShards.add(shard);
             }
+        }
 
-            Tuple<Decision, Map<String, NodeAllocationResult>> result = canBeAllocatedToAtLeastOneNode(shard, allocation);
-            Decision allocationDecision = result.v1();
-            if (allocationDecision.type() != Decision.Type.YES && (!explain || !hasInitiatedFetching(shard))) {
-                // only return early if we are not in explain mode, or we are in explain mode but we have not
-                // yet attempted to fetch any shard data
-                logger.trace("{}: ignoring allocation, can't be allocated on any node", shard);
-                shardAllocationDecisions.put(
-                    shard,
-                    AllocateUnassignedDecision.no(
-                        UnassignedInfo.AllocationStatus.fromDecision(allocationDecision.type()),
-                        result.v2() != null ? new ArrayList<>(result.v2().values()) : null
-                    )
-                );
-                continue;
-            }
-            // storing the nodeDecisions in nodeAllocationDecisions if the decision is not YES
-            // so that we don't have to compute the decisions again
-            nodeAllocationDecisions.put(shard, result);
+        // only fetch data for eligible shards
+        final FetchResult<NodeStoreFilesMetadataBatch> shardsState = fetchData(eligibleShards, ineligibleShards, allocation);
 
-            eligibleShards.add(shard);
+        Set<ShardId> shardIdsFromBatch = new HashSet<>();
+        for (ShardRouting shardRouting : shardRoutings) {
+            ShardId shardId = shardRouting.shardId();
+            shardIdsFromBatch.add(shardId);
+        }
+        RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
+        while (iterator.hasNext()) {
+            ShardRouting unassignedShard = iterator.next();
+            // There will be only one entry for the shard in the unassigned shards batch
+            // for a shard with multiple unassigned replicas, hence we are comparing the shard ids
+            // instead of ShardRouting in-order to evaluate shard assignment for all unassigned replicas of a shard.
+            if (!unassignedShard.primary() && shardIdsFromBatch.contains(unassignedShard.shardId())) {
+                AllocateUnassignedDecision allocateUnassignedDecision;
+                if (ineligibleShardAllocationDecisions.containsKey(unassignedShard)) {
+                    allocateUnassignedDecision = ineligibleShardAllocationDecisions.get(unassignedShard);
+                } else {
+                    // The shard's eligibility is being recomputed again as
+                    // the routing allocation state is updated during shard allocation decision execution
+                    // because of which allocation eligibility of other unassigned shards can change.
+                    allocateUnassignedDecision = getUnassignedShardAllocationDecision(
+                        unassignedShard,
+                        allocation,
+                        () -> convertToNodeStoreFilesMetadataMap(unassignedShard, shardsState)
+                    );
+                }
+                executeDecision(unassignedShard, allocateUnassignedDecision, allocation, iterator);
+            }
         }
+        logger.trace("Finished shard allocation execution for unassigned replica shards: {}", shardRoutings.size());
+    }
 
-        // Do not call fetchData if there are no eligible shards
-        if (eligibleShards.isEmpty()) {
-            return shardAllocationDecisions;
+    private AllocateUnassignedDecision getUnassignedShardAllocationDecision(
+        ShardRouting shardRouting,
+        RoutingAllocation allocation,
+        Supplier<Map<DiscoveryNode, StoreFilesMetadata>> nodeStoreFileMetaDataMapSupplier
+    ) {
+        if (isResponsibleFor(shardRouting) == false) {
+            return AllocateUnassignedDecision.NOT_TAKEN;
         }
-        // only fetch data for eligible shards
-        final FetchResult<NodeStoreFilesMetadataBatch> shardsState = fetchData(eligibleShards, ineligibleShards, allocation);
+        Tuple<Decision, Map<String, NodeAllocationResult>> result = canBeAllocatedToAtLeastOneNode(shardRouting, allocation);
 
-        for (ShardRouting unassignedShard : eligibleShards) {
-            Tuple<Decision, Map<String, NodeAllocationResult>> result = nodeAllocationDecisions.get(unassignedShard);
-            shardAllocationDecisions.put(
-                unassignedShard,
-                getAllocationDecision(
-                    unassignedShard,
-                    allocation,
-                    convertToNodeStoreFilesMetadataMap(unassignedShard, shardsState),
-                    result,
-                    logger
-                )
+        final boolean explain = allocation.debugDecision();
+        Decision allocationDecision = result.v1();
+        if (allocationDecision.type() != Decision.Type.YES && (!explain || !hasInitiatedFetching(shardRouting))) {
+            // only return early if we are not in explain mode, or we are in explain mode but we have not
+            // yet attempted to fetch any shard data
+            logger.trace("{}: ignoring allocation, can't be allocated on any node. Decision: {}", shardRouting, allocationDecision.type());
+            return AllocateUnassignedDecision.no(
+                UnassignedInfo.AllocationStatus.fromDecision(allocationDecision.type()),
+                result.v2() != null ? new ArrayList<>(result.v2().values()) : null
             );
         }
-        return shardAllocationDecisions;
+        if (nodeStoreFileMetaDataMapSupplier != null) {
+            Map<DiscoveryNode, StoreFilesMetadata> discoveryNodeStoreFilesMetadataMap = nodeStoreFileMetaDataMapSupplier.get();
+            return getAllocationDecision(shardRouting, allocation, discoveryNodeStoreFilesMetadataMap, result, logger);
+        }
+        return null;
     }
 
     private Map<DiscoveryNode, StoreFilesMetadata> convertToNodeStoreFilesMetadataMap(
diff --git a/server/src/main/java/org/opensearch/gateway/ShardsBatchGatewayAllocator.java b/server/src/main/java/org/opensearch/gateway/ShardsBatchGatewayAllocator.java
index d2de78ffac965..d18304ea73ed0 100644
--- a/server/src/main/java/org/opensearch/gateway/ShardsBatchGatewayAllocator.java
+++ b/server/src/main/java/org/opensearch/gateway/ShardsBatchGatewayAllocator.java
@@ -27,9 +27,13 @@
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.BatchRunnableExecutor;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
+import org.opensearch.common.util.concurrent.TimeoutAwareRunnable;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.shard.ShardId;
@@ -41,6 +45,7 @@
 import org.opensearch.indices.store.TransportNodesListShardStoreMetadataHelper;
 import org.opensearch.indices.store.TransportNodesListShardStoreMetadataHelper.StoreFilesMetadata;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -68,6 +73,15 @@ public class ShardsBatchGatewayAllocator implements ExistingShardsAllocator {
     private final long maxBatchSize;
     private static final short DEFAULT_SHARD_BATCH_SIZE = 2000;
 
+    public static final String PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY =
+        "cluster.routing.allocation.shards_batch_gateway_allocator.primary_allocator_timeout";
+    public static final String REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY =
+        "cluster.routing.allocation.shards_batch_gateway_allocator.replica_allocator_timeout";
+
+    private TimeValue primaryShardsBatchGatewayAllocatorTimeout;
+    private TimeValue replicaShardsBatchGatewayAllocatorTimeout;
+    public static final TimeValue MIN_ALLOCATOR_TIMEOUT = TimeValue.timeValueSeconds(20);
+
     /**
      * Number of shards we send in one batch to data nodes for fetching metadata
      */
@@ -79,6 +93,54 @@ public class ShardsBatchGatewayAllocator implements ExistingShardsAllocator {
         Setting.Property.NodeScope
     );
 
+    /**
+     * Timeout for existing primary shards batch allocator.
+     * Timeout value must be greater than or equal to 20s or -1ms to effectively disable timeout
+     */
+    public static final Setting<TimeValue> PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING = Setting.timeSetting(
+        PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY,
+        TimeValue.MINUS_ONE,
+        TimeValue.MINUS_ONE,
+        new Setting.Validator<>() {
+            @Override
+            public void validate(TimeValue timeValue) {
+                if (timeValue.compareTo(MIN_ALLOCATOR_TIMEOUT) < 0 && timeValue.compareTo(TimeValue.MINUS_ONE) != 0) {
+                    throw new IllegalArgumentException(
+                        "Setting ["
+                            + PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.getKey()
+                            + "] should be more than 20s or -1ms to disable timeout"
+                    );
+                }
+            }
+        },
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    /**
+     * Timeout for existing replica shards batch allocator.
+     * Timeout value must be greater than or equal to 20s or -1ms to effectively disable timeout
+     */
+    public static final Setting<TimeValue> REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING = Setting.timeSetting(
+        REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY,
+        TimeValue.MINUS_ONE,
+        TimeValue.MINUS_ONE,
+        new Setting.Validator<>() {
+            @Override
+            public void validate(TimeValue timeValue) {
+                if (timeValue.compareTo(MIN_ALLOCATOR_TIMEOUT) < 0 && timeValue.compareTo(TimeValue.MINUS_ONE) != 0) {
+                    throw new IllegalArgumentException(
+                        "Setting ["
+                            + REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.getKey()
+                            + "] should be more than 20s or -1ms to disable timeout"
+                    );
+                }
+            }
+        },
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
     private final RerouteService rerouteService;
     private final PrimaryShardBatchAllocator primaryShardBatchAllocator;
     private final ReplicaShardBatchAllocator replicaShardBatchAllocator;
@@ -97,7 +159,8 @@ public ShardsBatchGatewayAllocator(
         RerouteService rerouteService,
         TransportNodesListGatewayStartedShardsBatch batchStartedAction,
         TransportNodesListShardStoreMetadataBatch batchStoreAction,
-        Settings settings
+        Settings settings,
+        ClusterSettings clusterSettings
     ) {
         this.rerouteService = rerouteService;
         this.primaryShardBatchAllocator = new InternalPrimaryBatchShardAllocator();
@@ -105,6 +168,10 @@ public ShardsBatchGatewayAllocator(
         this.batchStartedAction = batchStartedAction;
         this.batchStoreAction = batchStoreAction;
         this.maxBatchSize = GATEWAY_ALLOCATOR_BATCH_SIZE.get(settings);
+        this.primaryShardsBatchGatewayAllocatorTimeout = PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(settings);
+        clusterSettings.addSettingsUpdateConsumer(PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING, this::setPrimaryBatchAllocatorTimeout);
+        this.replicaShardsBatchGatewayAllocatorTimeout = REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(settings);
+        clusterSettings.addSettingsUpdateConsumer(REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING, this::setReplicaBatchAllocatorTimeout);
     }
 
     @Override
@@ -117,12 +184,18 @@ public void cleanCaches() {
 
     // for tests
     protected ShardsBatchGatewayAllocator() {
+        this(DEFAULT_SHARD_BATCH_SIZE);
+    }
+
+    protected ShardsBatchGatewayAllocator(long batchSize) {
         this.rerouteService = null;
         this.batchStartedAction = null;
         this.primaryShardBatchAllocator = null;
         this.batchStoreAction = null;
         this.replicaShardBatchAllocator = null;
-        this.maxBatchSize = DEFAULT_SHARD_BATCH_SIZE;
+        this.maxBatchSize = batchSize;
+        this.primaryShardsBatchGatewayAllocatorTimeout = null;
+        this.replicaShardsBatchGatewayAllocatorTimeout = null;
     }
 
     // for tests
@@ -184,14 +257,14 @@ public void allocateUnassigned(
     }
 
     @Override
-    public void allocateAllUnassignedShards(final RoutingAllocation allocation, boolean primary) {
+    public BatchRunnableExecutor allocateAllUnassignedShards(final RoutingAllocation allocation, boolean primary) {
 
         assert primaryShardBatchAllocator != null;
         assert replicaShardBatchAllocator != null;
-        innerAllocateUnassignedBatch(allocation, primaryShardBatchAllocator, replicaShardBatchAllocator, primary);
+        return innerAllocateUnassignedBatch(allocation, primaryShardBatchAllocator, replicaShardBatchAllocator, primary);
     }
 
-    protected void innerAllocateUnassignedBatch(
+    protected BatchRunnableExecutor innerAllocateUnassignedBatch(
         RoutingAllocation allocation,
         PrimaryShardBatchAllocator primaryBatchShardAllocator,
         ReplicaShardBatchAllocator replicaBatchShardAllocator,
@@ -200,20 +273,55 @@ protected void innerAllocateUnassignedBatch(
         // create batches for unassigned shards
         Set<String> batchesToAssign = createAndUpdateBatches(allocation, primary);
         if (batchesToAssign.isEmpty()) {
-            return;
+            return null;
         }
+        List<TimeoutAwareRunnable> runnables = new ArrayList<>();
         if (primary) {
+            Set<ShardId> timedOutPrimaryShardIds = new HashSet<>();
             batchIdToStartedShardBatch.values()
                 .stream()
                 .filter(batch -> batchesToAssign.contains(batch.batchId))
-                .forEach(
-                    shardsBatch -> primaryBatchShardAllocator.allocateUnassignedBatch(shardsBatch.getBatchedShardRoutings(), allocation)
-                );
+                .forEach(shardsBatch -> runnables.add(new TimeoutAwareRunnable() {
+                    @Override
+                    public void onTimeout() {
+                        timedOutPrimaryShardIds.addAll(shardsBatch.getBatchedShards());
+                    }
+
+                    @Override
+                    public void run() {
+                        primaryBatchShardAllocator.allocateUnassignedBatch(shardsBatch.getBatchedShardRoutings(), allocation);
+                    }
+                }));
+            return new BatchRunnableExecutor(runnables, () -> primaryShardsBatchGatewayAllocatorTimeout) {
+                @Override
+                public void onComplete() {
+                    logger.trace("Triggering oncomplete after timeout for [{}] primary shards", timedOutPrimaryShardIds.size());
+                    primaryBatchShardAllocator.allocateUnassignedBatchOnTimeout(timedOutPrimaryShardIds, allocation, true);
+                }
+            };
         } else {
+            Set<ShardId> timedOutReplicaShardIds = new HashSet<>();
             batchIdToStoreShardBatch.values()
                 .stream()
                 .filter(batch -> batchesToAssign.contains(batch.batchId))
-                .forEach(batch -> replicaBatchShardAllocator.allocateUnassignedBatch(batch.getBatchedShardRoutings(), allocation));
+                .forEach(batch -> runnables.add(new TimeoutAwareRunnable() {
+                    @Override
+                    public void onTimeout() {
+                        timedOutReplicaShardIds.addAll(batch.getBatchedShards());
+                    }
+
+                    @Override
+                    public void run() {
+                        replicaBatchShardAllocator.allocateUnassignedBatch(batch.getBatchedShardRoutings(), allocation);
+                    }
+                }));
+            return new BatchRunnableExecutor(runnables, () -> replicaShardsBatchGatewayAllocatorTimeout) {
+                @Override
+                public void onComplete() {
+                    logger.trace("Triggering oncomplete after timeout for [{}] replica shards", timedOutReplicaShardIds.size());
+                    replicaBatchShardAllocator.allocateUnassignedBatchOnTimeout(timedOutReplicaShardIds, allocation, false);
+                }
+            };
         }
     }
 
@@ -228,13 +336,13 @@ protected Set<String> createAndUpdateBatches(RoutingAllocation allocation, boole
             batchEntry.getValue().getBatchedShards().forEach(shardId -> currentBatchedShards.put(shardId, batchEntry.getKey()));
         }
 
-        Set<ShardRouting> newShardsToBatch = Sets.newHashSet();
+        Map<ShardId, ShardRouting> newShardsToBatch = new HashMap<>();
         Set<ShardId> batchedShardsToAssign = Sets.newHashSet();
         // add all unassigned shards to the batch if they are not already in a batch
         unassigned.forEach(shardRouting -> {
             if ((currentBatchedShards.containsKey(shardRouting.shardId()) == false) && (shardRouting.primary() == primary)) {
                 assert shardRouting.unassigned();
-                newShardsToBatch.add(shardRouting);
+                newShardsToBatch.put(shardRouting.shardId(), shardRouting);
             }
             // if shard is already batched update to latest shardRouting information in the batches
             // Replica shard assignment can be cancelled if we get a better match. These ShardRouting objects also
@@ -262,7 +370,7 @@ else if (shardRouting.primary() == primary) {
 
         refreshShardBatches(currentBatches, batchedShardsToAssign, primary);
 
-        Iterator<ShardRouting> iterator = newShardsToBatch.iterator();
+        Iterator<ShardRouting> iterator = newShardsToBatch.values().iterator();
         assert maxBatchSize > 0 : "Shards batch size must be greater than 0";
 
         long batchSize = maxBatchSize;
@@ -513,8 +621,37 @@ protected AsyncShardFetch.FetchResult<TransportNodesListShardStoreMetadataBatch.
 
         @Override
         protected boolean hasInitiatedFetching(ShardRouting shard) {
+            /**
+             * This function is to check if asyncFetch has happened before for this shard batch, or is ongoing.
+             * It should return false if there has never been a fetch for this batch.
+             * This function is currently only used in the case of replica shards when all deciders returned NO/THROTTLE, and explain mode is ON.
+             * Allocation explain and manual reroute APIs try to append shard store information (matching bytes) to the allocation decision.
+             * However, these APIs do not want to trigger a new asyncFetch for these ineligible shards, unless the data from nodes is already there.
+             * This function is used to see if a fetch has happened to decide if it is possible to append shard store info without a new async fetch.
+             * In the case when shard has a batch but no fetch has happened before, it would be because it is a new batch.
+             * In the case when shard has a batch, and a fetch has happened before, and no fetch is ongoing, it would be because we have already completed fetch for all nodes.
+             *
+             * In order to check if a fetch has ever happened, we check 2 things:
+             * 1. If the shard batch cache is empty, we know that fetch has never happened so we return false.
+             * 2. If we see that the list of nodes to fetch from is empty, we know that all nodes have data or are ongoing a fetch. So we return true.
+             * 3. Otherwise we return false.
+             *
+             * see {@link AsyncShardFetchCache#findNodesToFetch()}
+             */
             String batchId = getBatchId(shard, shard.primary());
-            return batchId != null;
+            if (batchId == null) {
+                return false;
+            }
+            logger.trace("Checking if fetching done for batch id {}", batchId);
+            ShardsBatch shardsBatch = shard.primary() ? batchIdToStartedShardBatch.get(batchId) : batchIdToStoreShardBatch.get(batchId);
+            // if fetchData has never been called, the per node cache will be empty and have no nodes
+            // this is because cache.fillShardCacheWithDataNodes(nodes) initialises this map and is called in AsyncShardFetch.fetchData
+            if (shardsBatch == null || shardsBatch.getAsyncFetcher().hasEmptyCache()) {
+                logger.trace("Batch cache is empty for batch {} ", batchId);
+                return false;
+            }
+            // this check below is to make sure we already have all the data and that we wouldn't create a new async fetchData call
+            return shardsBatch.getAsyncFetcher().getCache().findNodesToFetch().isEmpty();
         }
     }
 
@@ -718,4 +855,12 @@ public int getNumberOfStartedShardBatches() {
     public int getNumberOfStoreShardBatches() {
         return batchIdToStoreShardBatch.size();
     }
+
+    protected void setPrimaryBatchAllocatorTimeout(TimeValue primaryShardsBatchGatewayAllocatorTimeout) {
+        this.primaryShardsBatchGatewayAllocatorTimeout = primaryShardsBatchGatewayAllocatorTimeout;
+    }
+
+    protected void setReplicaBatchAllocatorTimeout(TimeValue replicaShardsBatchGatewayAllocatorTimeout) {
+        this.replicaShardsBatchGatewayAllocatorTimeout = replicaShardsBatchGatewayAllocatorTimeout;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/ClusterMetadataManifest.java b/server/src/main/java/org/opensearch/gateway/remote/ClusterMetadataManifest.java
index 4725f40076ce2..405e5cd784196 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/ClusterMetadataManifest.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/ClusterMetadataManifest.java
@@ -16,15 +16,21 @@
 import org.opensearch.core.common.io.stream.Writeable;
 import org.opensearch.core.xcontent.ConstructingObjectParser;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.ObjectParser;
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 /**
  * Manifest file which contains the details of the uploaded entity metadata
@@ -35,7 +41,14 @@ public class ClusterMetadataManifest implements Writeable, ToXContentFragment {
 
     public static final int CODEC_V0 = 0; // Older codec version, where we haven't introduced codec versions for manifest.
     public static final int CODEC_V1 = 1; // In Codec V1 we have introduced global-metadata and codec version in Manifest file.
-
+    public static final int CODEC_V2 = 2; // In Codec V2, there are separate metadata files rather than a single global metadata file,
+    // also we introduce index routing-metadata, diff and other attributes as part of manifest
+    // required for state publication
+    public static final int CODEC_V3 = 3; // In Codec V3, we have introduced new diff field in diff-manifest's routing_table_diff
+    public static final int CODEC_V4 = 4; // In Codec V4, we have removed upserts and delete field for routing table in diff manifest and
+                                          // added checksum of cluster state.
+
+    public static final int[] CODEC_VERSIONS = { CODEC_V0, CODEC_V1, CODEC_V2, CODEC_V3, CODEC_V4 };
     private static final ParseField CLUSTER_TERM_FIELD = new ParseField("cluster_term");
     private static final ParseField STATE_VERSION_FIELD = new ParseField("state_version");
     private static final ParseField CLUSTER_UUID_FIELD = new ParseField("cluster_uuid");
@@ -48,6 +61,66 @@ public class ClusterMetadataManifest implements Writeable, ToXContentFragment {
     private static final ParseField INDICES_FIELD = new ParseField("indices");
     private static final ParseField PREVIOUS_CLUSTER_UUID = new ParseField("previous_cluster_uuid");
     private static final ParseField CLUSTER_UUID_COMMITTED = new ParseField("cluster_uuid_committed");
+    private static final ParseField UPLOADED_COORDINATOR_METADATA = new ParseField("uploaded_coordinator_metadata");
+    private static final ParseField UPLOADED_SETTINGS_METADATA = new ParseField("uploaded_settings_metadata");
+    private static final ParseField UPLOADED_TEMPLATES_METADATA = new ParseField("uploaded_templates_metadata");
+    private static final ParseField UPLOADED_CUSTOM_METADATA = new ParseField("uploaded_custom_metadata");
+    private static final ParseField ROUTING_TABLE_VERSION_FIELD = new ParseField("routing_table_version");
+    private static final ParseField INDICES_ROUTING_FIELD = new ParseField("indices_routing");
+    private static final ParseField METADATA_VERSION = new ParseField("metadata_version");
+    private static final ParseField UPLOADED_TRANSIENT_SETTINGS_METADATA = new ParseField("uploaded_transient_settings_metadata");
+    private static final ParseField UPLOADED_DISCOVERY_NODES_METADATA = new ParseField("uploaded_discovery_nodes_metadata");
+    private static final ParseField UPLOADED_CLUSTER_BLOCKS_METADATA = new ParseField("uploaded_cluster_blocks_metadata");
+    private static final ParseField UPLOADED_HASHES_OF_CONSISTENT_SETTINGS_METADATA = new ParseField(
+        "uploaded_hashes_of_consistent_settings_metadata"
+    );
+    private static final ParseField UPLOADED_CLUSTER_STATE_CUSTOM_METADATA = new ParseField("uploaded_cluster_state_custom_metadata");
+    private static final ParseField DIFF_MANIFEST = new ParseField("diff_manifest");
+    private static final ParseField CHECKSUM = new ParseField("checksum");
+
+    private static ClusterMetadataManifest.Builder manifestV0Builder(Object[] fields) {
+        return ClusterMetadataManifest.builder()
+            .clusterTerm(term(fields))
+            .stateVersion(version(fields))
+            .clusterUUID(clusterUUID(fields))
+            .stateUUID(stateUUID(fields))
+            .opensearchVersion(opensearchVersion(fields))
+            .nodeId(nodeId(fields))
+            .committed(committed(fields))
+            .codecVersion(CODEC_V0)
+            .indices(indices(fields))
+            .previousClusterUUID(previousClusterUUID(fields))
+            .clusterUUIDCommitted(clusterUUIDCommitted(fields));
+    }
+
+    private static ClusterMetadataManifest.Builder manifestV1Builder(Object[] fields) {
+        return manifestV0Builder(fields).codecVersion(codecVersion(fields)).globalMetadataFileName(globalMetadataFileName(fields));
+    }
+
+    private static ClusterMetadataManifest.Builder manifestV2Builder(Object[] fields) {
+        return manifestV0Builder(fields).codecVersion(codecVersion(fields))
+            .coordinationMetadata(coordinationMetadata(fields))
+            .settingMetadata(settingsMetadata(fields))
+            .templatesMetadata(templatesMetadata(fields))
+            .customMetadataMap(customMetadata(fields))
+            .routingTableVersion(routingTableVersion(fields))
+            .indicesRouting(indicesRouting(fields))
+            .discoveryNodesMetadata(discoveryNodesMetadata(fields))
+            .clusterBlocksMetadata(clusterBlocksMetadata(fields))
+            .diffManifest(diffManifest(fields))
+            .metadataVersion(metadataVersion(fields))
+            .transientSettingsMetadata(transientSettingsMetadata(fields))
+            .hashesOfConsistentSettings(hashesOfConsistentSettings(fields))
+            .clusterStateCustomMetadataMap(clusterStateCustomMetadata(fields));
+    }
+
+    private static ClusterMetadataManifest.Builder manifestV3Builder(Object[] fields) {
+        return manifestV2Builder(fields);
+    }
+
+    private static ClusterMetadataManifest.Builder manifestV4Builder(Object[] fields) {
+        return manifestV3Builder(fields).checksum(checksum(fields));
+    }
 
     private static long term(Object[] fields) {
         return (long) fields[0];
@@ -97,47 +170,122 @@ private static String globalMetadataFileName(Object[] fields) {
         return (String) fields[11];
     }
 
+    private static UploadedMetadataAttribute coordinationMetadata(Object[] fields) {
+        return (UploadedMetadataAttribute) fields[11];
+    }
+
+    private static UploadedMetadataAttribute settingsMetadata(Object[] fields) {
+        return (UploadedMetadataAttribute) fields[12];
+    }
+
+    private static UploadedMetadataAttribute templatesMetadata(Object[] fields) {
+        return (UploadedMetadataAttribute) fields[13];
+    }
+
+    private static Map<String, UploadedMetadataAttribute> customMetadata(Object[] fields) {
+        List<UploadedMetadataAttribute> customs = (List<UploadedMetadataAttribute>) fields[14];
+        return customs.stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()));
+    }
+
+    private static long routingTableVersion(Object[] fields) {
+        return (long) fields[15];
+    }
+
+    private static List<UploadedIndexMetadata> indicesRouting(Object[] fields) {
+        return (List<UploadedIndexMetadata>) fields[16];
+    }
+
+    private static UploadedMetadataAttribute discoveryNodesMetadata(Object[] fields) {
+        return (UploadedMetadataAttribute) fields[17];
+    }
+
+    private static UploadedMetadataAttribute clusterBlocksMetadata(Object[] fields) {
+        return (UploadedMetadataAttribute) fields[18];
+    }
+
+    private static long metadataVersion(Object[] fields) {
+        return (long) fields[19];
+    }
+
+    private static UploadedMetadataAttribute transientSettingsMetadata(Object[] fields) {
+        return (UploadedMetadataAttribute) fields[20];
+    }
+
+    private static UploadedMetadataAttribute hashesOfConsistentSettings(Object[] fields) {
+        return (UploadedMetadataAttribute) fields[21];
+    }
+
+    private static Map<String, UploadedMetadataAttribute> clusterStateCustomMetadata(Object[] fields) {
+        List<UploadedMetadataAttribute> customs = (List<UploadedMetadataAttribute>) fields[22];
+        return customs.stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()));
+    }
+
+    private static ClusterStateDiffManifest diffManifest(Object[] fields) {
+        return (ClusterStateDiffManifest) fields[23];
+    }
+
+    private static ClusterStateChecksum checksum(Object[] fields) {
+        return (ClusterStateChecksum) fields[24];
+    }
+
     private static final ConstructingObjectParser<ClusterMetadataManifest, Void> PARSER_V0 = new ConstructingObjectParser<>(
         "cluster_metadata_manifest",
-        fields -> new ClusterMetadataManifest(
-            term(fields),
-            version(fields),
-            clusterUUID(fields),
-            stateUUID(fields),
-            opensearchVersion(fields),
-            nodeId(fields),
-            committed(fields),
-            CODEC_V0,
-            null,
-            indices(fields),
-            previousClusterUUID(fields),
-            clusterUUIDCommitted(fields)
-        )
+        fields -> manifestV0Builder(fields).build()
     );
 
     private static final ConstructingObjectParser<ClusterMetadataManifest, Void> PARSER_V1 = new ConstructingObjectParser<>(
         "cluster_metadata_manifest",
-        fields -> new ClusterMetadataManifest(
-            term(fields),
-            version(fields),
-            clusterUUID(fields),
-            stateUUID(fields),
-            opensearchVersion(fields),
-            nodeId(fields),
-            committed(fields),
-            codecVersion(fields),
-            globalMetadataFileName(fields),
-            indices(fields),
-            previousClusterUUID(fields),
-            clusterUUIDCommitted(fields)
-        )
+        fields -> manifestV1Builder(fields).build()
     );
 
-    private static final ConstructingObjectParser<ClusterMetadataManifest, Void> CURRENT_PARSER = PARSER_V1;
+    private static final ConstructingObjectParser<ClusterMetadataManifest, Void> PARSER_V2 = new ConstructingObjectParser<>(
+        "cluster_metadata_manifest",
+        fields -> manifestV2Builder(fields).build()
+    );
+
+    private static final ConstructingObjectParser<ClusterMetadataManifest, Void> PARSER_V3 = new ConstructingObjectParser<>(
+        "cluster_metadata_manifest",
+        fields -> manifestV3Builder(fields).build()
+    );
+
+    private static final ConstructingObjectParser<ClusterMetadataManifest, Void> PARSER_V4 = new ConstructingObjectParser<>(
+        "cluster_metadata_manifest",
+        fields -> manifestV4Builder(fields).build()
+    );
+
+    private static final ConstructingObjectParser<ClusterMetadataManifest, Void> CURRENT_PARSER = PARSER_V4;
+
+    public static final int MANIFEST_CURRENT_CODEC_VERSION = CODEC_V4;
+
+    private static final Map<Version, Integer> VERSION_TO_CODEC_MAPPING;
 
     static {
         declareParser(PARSER_V0, CODEC_V0);
         declareParser(PARSER_V1, CODEC_V1);
+        declareParser(PARSER_V2, CODEC_V2);
+        declareParser(PARSER_V3, CODEC_V3);
+        declareParser(PARSER_V4, CODEC_V4);
+
+        assert Arrays.stream(CODEC_VERSIONS).max().getAsInt() == MANIFEST_CURRENT_CODEC_VERSION;
+        Map<Version, Integer> versionToCodecMapping = new HashMap<>();
+        for (Version version : Version.getDeclaredVersions(Version.class)) {
+            if (version.onOrAfter(Version.V_2_10_0) && version.before(Version.V_2_12_0)) {
+                versionToCodecMapping.put(version, ClusterMetadataManifest.CODEC_V0);
+            } else if (version.onOrAfter(Version.V_2_12_0) && version.before(Version.V_2_15_0)) {
+                versionToCodecMapping.put(version, ClusterMetadataManifest.CODEC_V1);
+            } else if (version.onOrAfter(Version.V_2_15_0) && version.before(Version.V_2_16_0)) {
+                versionToCodecMapping.put(version, ClusterMetadataManifest.CODEC_V2);
+            } else if (version.onOrAfter(Version.V_2_16_0) && version.before(Version.V_2_17_0)) {
+                versionToCodecMapping.put(version, ClusterMetadataManifest.CODEC_V3);
+            } else if (version.onOrAfter(Version.V_2_17_0)) {
+                versionToCodecMapping.put(version, ClusterMetadataManifest.CODEC_V4);
+            }
+        }
+        VERSION_TO_CODEC_MAPPING = Collections.unmodifiableMap(versionToCodecMapping);
+    }
+
+    public static int getCodecForVersion(Version version) {
+        return VERSION_TO_CODEC_MAPPING.getOrDefault(version, -1);
     }
 
     private static void declareParser(ConstructingObjectParser<ClusterMetadataManifest, Void> parser, long codec_version) {
@@ -150,20 +298,90 @@ private static void declareParser(ConstructingObjectParser<ClusterMetadataManife
         parser.declareBoolean(ConstructingObjectParser.constructorArg(), COMMITTED_FIELD);
         parser.declareObjectArray(
             ConstructingObjectParser.constructorArg(),
-            (p, c) -> UploadedIndexMetadata.fromXContent(p),
+            (p, c) -> UploadedIndexMetadata.fromXContent(p, codec_version),
             INDICES_FIELD
         );
         parser.declareString(ConstructingObjectParser.constructorArg(), PREVIOUS_CLUSTER_UUID);
         parser.declareBoolean(ConstructingObjectParser.constructorArg(), CLUSTER_UUID_COMMITTED);
 
-        if (codec_version >= CODEC_V1) {
+        if (codec_version == CODEC_V1) {
             parser.declareInt(ConstructingObjectParser.constructorArg(), CODEC_VERSION_FIELD);
             parser.declareString(ConstructingObjectParser.constructorArg(), GLOBAL_METADATA_FIELD);
+        } else if (codec_version >= CODEC_V2) {
+            parser.declareInt(ConstructingObjectParser.constructorArg(), CODEC_VERSION_FIELD);
+            parser.declareNamedObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_COORDINATOR_METADATA
+            );
+            parser.declareNamedObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_SETTINGS_METADATA
+            );
+            parser.declareNamedObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_TEMPLATES_METADATA
+            );
+            parser.declareNamedObjects(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_CUSTOM_METADATA
+            );
+            parser.declareLong(ConstructingObjectParser.constructorArg(), ROUTING_TABLE_VERSION_FIELD);
+            parser.declareObjectArray(
+                ConstructingObjectParser.constructorArg(),
+                (p, c) -> UploadedIndexMetadata.fromXContent(p, codec_version),
+                INDICES_ROUTING_FIELD
+            );
+            parser.declareNamedObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_DISCOVERY_NODES_METADATA
+            );
+            parser.declareNamedObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_CLUSTER_BLOCKS_METADATA
+            );
+            parser.declareLong(ConstructingObjectParser.constructorArg(), METADATA_VERSION);
+            parser.declareNamedObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_TRANSIENT_SETTINGS_METADATA
+            );
+            parser.declareNamedObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_HASHES_OF_CONSISTENT_SETTINGS_METADATA
+            );
+            parser.declareNamedObjects(
+                ConstructingObjectParser.optionalConstructorArg(),
+                UploadedMetadataAttribute.PARSER,
+                UPLOADED_CLUSTER_STATE_CUSTOM_METADATA
+            );
+            parser.declareObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                (p, c) -> ClusterStateDiffManifest.fromXContent(p, codec_version),
+                DIFF_MANIFEST
+            );
+        }
+        if (codec_version >= CODEC_V4) {
+            parser.declareObject(
+                ConstructingObjectParser.optionalConstructorArg(),
+                (p, c) -> ClusterStateChecksum.fromXContent(p),
+                CHECKSUM
+            );
         }
     }
 
     private final int codecVersion;
     private final String globalMetadataFileName;
+    private final UploadedMetadataAttribute uploadedCoordinationMetadata;
+    private final UploadedMetadataAttribute uploadedSettingsMetadata;
+    private final UploadedMetadataAttribute uploadedTemplatesMetadata;
+    private final Map<String, UploadedMetadataAttribute> uploadedCustomMetadataMap;
     private final List<UploadedIndexMetadata> indices;
     private final long clusterTerm;
     private final long stateVersion;
@@ -174,6 +392,16 @@ private static void declareParser(ConstructingObjectParser<ClusterMetadataManife
     private final boolean committed;
     private final String previousClusterUUID;
     private final boolean clusterUUIDCommitted;
+    private final long routingTableVersion;
+    private final List<UploadedIndexMetadata> indicesRouting;
+    private final long metadataVersion;
+    private final UploadedMetadataAttribute uploadedTransientSettingsMetadata;
+    private final UploadedMetadataAttribute uploadedDiscoveryNodesMetadata;
+    private final UploadedMetadataAttribute uploadedClusterBlocksMetadata;
+    private final UploadedMetadataAttribute uploadedHashesOfConsistentSettings;
+    private final Map<String, UploadedMetadataAttribute> uploadedClusterStateCustomMap;
+    private final ClusterStateDiffManifest diffManifest;
+    private ClusterStateChecksum clusterStateChecksum;
 
     public List<UploadedIndexMetadata> getIndices() {
         return indices;
@@ -223,6 +451,69 @@ public String getGlobalMetadataFileName() {
         return globalMetadataFileName;
     }
 
+    public UploadedMetadataAttribute getCoordinationMetadata() {
+        return uploadedCoordinationMetadata;
+    }
+
+    public UploadedMetadataAttribute getSettingsMetadata() {
+        return uploadedSettingsMetadata;
+    }
+
+    public UploadedMetadataAttribute getTemplatesMetadata() {
+        return uploadedTemplatesMetadata;
+    }
+
+    public Map<String, UploadedMetadataAttribute> getCustomMetadataMap() {
+        return uploadedCustomMetadataMap;
+    }
+
+    public long getMetadataVersion() {
+        return metadataVersion;
+    }
+
+    public UploadedMetadataAttribute getTransientSettingsMetadata() {
+        return uploadedTransientSettingsMetadata;
+    }
+
+    public UploadedMetadataAttribute getDiscoveryNodesMetadata() {
+        return uploadedDiscoveryNodesMetadata;
+    }
+
+    public UploadedMetadataAttribute getClusterBlocksMetadata() {
+        return uploadedClusterBlocksMetadata;
+    }
+
+    public ClusterStateDiffManifest getDiffManifest() {
+        return diffManifest;
+    }
+
+    public Map<String, UploadedMetadataAttribute> getClusterStateCustomMap() {
+        return uploadedClusterStateCustomMap;
+    }
+
+    public UploadedMetadataAttribute getHashesOfConsistentSettings() {
+        return uploadedHashesOfConsistentSettings;
+    }
+
+    public boolean hasMetadataAttributesFiles() {
+        return uploadedCoordinationMetadata != null
+            || uploadedSettingsMetadata != null
+            || uploadedTemplatesMetadata != null
+            || !uploadedCustomMetadataMap.isEmpty();
+    }
+
+    public long getRoutingTableVersion() {
+        return routingTableVersion;
+    }
+
+    public List<UploadedIndexMetadata> getIndicesRouting() {
+        return indicesRouting;
+    }
+
+    public ClusterStateChecksum getClusterStateChecksum() {
+        return clusterStateChecksum;
+    }
+
     public ClusterMetadataManifest(
         long clusterTerm,
         long version,
@@ -235,7 +526,21 @@ public ClusterMetadataManifest(
         String globalMetadataFileName,
         List<UploadedIndexMetadata> indices,
         String previousClusterUUID,
-        boolean clusterUUIDCommitted
+        boolean clusterUUIDCommitted,
+        UploadedMetadataAttribute uploadedCoordinationMetadata,
+        UploadedMetadataAttribute uploadedSettingsMetadata,
+        UploadedMetadataAttribute uploadedTemplatesMetadata,
+        Map<String, UploadedMetadataAttribute> uploadedCustomMetadataMap,
+        long routingTableVersion,
+        List<UploadedIndexMetadata> indicesRouting,
+        long metadataVersion,
+        UploadedMetadataAttribute discoveryNodesMetadata,
+        UploadedMetadataAttribute clusterBlocksMetadata,
+        UploadedMetadataAttribute uploadedTransientSettingsMetadata,
+        UploadedMetadataAttribute uploadedHashesOfConsistentSettings,
+        Map<String, UploadedMetadataAttribute> uploadedClusterStateCustomMap,
+        ClusterStateDiffManifest diffManifest,
+        ClusterStateChecksum clusterStateChecksum
     ) {
         this.clusterTerm = clusterTerm;
         this.stateVersion = version;
@@ -249,6 +554,24 @@ public ClusterMetadataManifest(
         this.indices = Collections.unmodifiableList(indices);
         this.previousClusterUUID = previousClusterUUID;
         this.clusterUUIDCommitted = clusterUUIDCommitted;
+        this.routingTableVersion = routingTableVersion;
+        this.indicesRouting = Collections.unmodifiableList(indicesRouting);
+        this.uploadedCoordinationMetadata = uploadedCoordinationMetadata;
+        this.uploadedSettingsMetadata = uploadedSettingsMetadata;
+        this.uploadedTemplatesMetadata = uploadedTemplatesMetadata;
+        this.uploadedCustomMetadataMap = Collections.unmodifiableMap(
+            uploadedCustomMetadataMap != null ? uploadedCustomMetadataMap : new HashMap<>()
+        );
+        this.uploadedDiscoveryNodesMetadata = discoveryNodesMetadata;
+        this.uploadedClusterBlocksMetadata = clusterBlocksMetadata;
+        this.diffManifest = diffManifest;
+        this.metadataVersion = metadataVersion;
+        this.uploadedTransientSettingsMetadata = uploadedTransientSettingsMetadata;
+        this.uploadedHashesOfConsistentSettings = uploadedHashesOfConsistentSettings;
+        this.uploadedClusterStateCustomMap = Collections.unmodifiableMap(
+            uploadedClusterStateCustomMap != null ? uploadedClusterStateCustomMap : new HashMap<>()
+        );
+        this.clusterStateChecksum = clusterStateChecksum;
     }
 
     public ClusterMetadataManifest(StreamInput in) throws IOException {
@@ -262,12 +585,71 @@ public ClusterMetadataManifest(StreamInput in) throws IOException {
         this.indices = Collections.unmodifiableList(in.readList(UploadedIndexMetadata::new));
         this.previousClusterUUID = in.readString();
         this.clusterUUIDCommitted = in.readBoolean();
-        if (in.getVersion().onOrAfter(Version.V_2_12_0)) {
+        clusterStateChecksum = null;
+        if (in.getVersion().onOrAfter(Version.V_2_15_0)) {
             this.codecVersion = in.readInt();
-            this.globalMetadataFileName = in.readString();
-        } else {
-            this.codecVersion = CODEC_V0; // Default codec
+            this.uploadedCoordinationMetadata = new UploadedMetadataAttribute(in);
+            this.uploadedSettingsMetadata = new UploadedMetadataAttribute(in);
+            this.uploadedTemplatesMetadata = new UploadedMetadataAttribute(in);
+            this.uploadedCustomMetadataMap = Collections.unmodifiableMap(
+                in.readMap(StreamInput::readString, UploadedMetadataAttribute::new)
+            );
             this.globalMetadataFileName = null;
+            this.routingTableVersion = in.readLong();
+            this.indicesRouting = Collections.unmodifiableList(in.readList(UploadedIndexMetadata::new));
+            this.metadataVersion = in.readLong();
+            if (in.readBoolean()) {
+                this.uploadedDiscoveryNodesMetadata = new UploadedMetadataAttribute(in);
+            } else {
+                this.uploadedDiscoveryNodesMetadata = null;
+            }
+            if (in.readBoolean()) {
+                this.uploadedClusterBlocksMetadata = new UploadedMetadataAttribute(in);
+            } else {
+                this.uploadedClusterBlocksMetadata = null;
+            }
+            if (in.readBoolean()) {
+                this.uploadedTransientSettingsMetadata = new UploadedMetadataAttribute(in);
+            } else {
+                this.uploadedTransientSettingsMetadata = null;
+            }
+            if (in.readBoolean()) {
+                this.uploadedHashesOfConsistentSettings = new UploadedMetadataAttribute(in);
+            } else {
+                this.uploadedHashesOfConsistentSettings = null;
+            }
+            this.uploadedClusterStateCustomMap = Collections.unmodifiableMap(
+                in.readMap(StreamInput::readString, UploadedMetadataAttribute::new)
+            );
+            if (in.readBoolean()) {
+                this.diffManifest = new ClusterStateDiffManifest(in);
+            } else {
+                this.diffManifest = null;
+            }
+        } else {
+            if (in.getVersion().onOrAfter(Version.V_2_12_0)) {
+                this.codecVersion = in.readInt();
+                this.globalMetadataFileName = in.readString();
+            } else {
+                this.codecVersion = CODEC_V0; // Default codec
+                this.globalMetadataFileName = null;
+            }
+            this.uploadedCoordinationMetadata = null;
+            this.uploadedSettingsMetadata = null;
+            this.uploadedTemplatesMetadata = null;
+            this.uploadedCustomMetadataMap = null;
+            this.routingTableVersion = -1;
+            this.indicesRouting = null;
+            this.uploadedDiscoveryNodesMetadata = null;
+            this.uploadedClusterBlocksMetadata = null;
+            this.diffManifest = null;
+            this.metadataVersion = -1;
+            this.uploadedTransientSettingsMetadata = null;
+            this.uploadedHashesOfConsistentSettings = null;
+            this.uploadedClusterStateCustomMap = null;
+        }
+        if (in.getVersion().onOrAfter(Version.V_2_17_0) && in.readBoolean()) {
+            clusterStateChecksum = new ClusterStateChecksum(in);
         }
     }
 
@@ -291,16 +673,88 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         builder.startArray(INDICES_FIELD.getPreferredName());
         {
             for (UploadedIndexMetadata uploadedIndexMetadata : indices) {
+                builder.startObject();
                 uploadedIndexMetadata.toXContent(builder, params);
+                builder.endObject();
             }
         }
         builder.endArray();
         builder.field(PREVIOUS_CLUSTER_UUID.getPreferredName(), getPreviousClusterUUID());
         builder.field(CLUSTER_UUID_COMMITTED.getPreferredName(), isClusterUUIDCommitted());
-        if (onOrAfterCodecVersion(CODEC_V1)) {
+        if (onOrAfterCodecVersion(CODEC_V2)) {
+            builder.field(CODEC_VERSION_FIELD.getPreferredName(), getCodecVersion());
+            if (getCoordinationMetadata() != null) {
+                builder.startObject(UPLOADED_COORDINATOR_METADATA.getPreferredName());
+                getCoordinationMetadata().toXContent(builder, params);
+                builder.endObject();
+            }
+            if (getSettingsMetadata() != null) {
+                builder.startObject(UPLOADED_SETTINGS_METADATA.getPreferredName());
+                getSettingsMetadata().toXContent(builder, params);
+                builder.endObject();
+            }
+            if (getTemplatesMetadata() != null) {
+                builder.startObject(UPLOADED_TEMPLATES_METADATA.getPreferredName());
+                getTemplatesMetadata().toXContent(builder, params);
+                builder.endObject();
+            }
+            builder.startObject(UPLOADED_CUSTOM_METADATA.getPreferredName());
+            for (UploadedMetadataAttribute attribute : getCustomMetadataMap().values()) {
+                attribute.toXContent(builder, params);
+            }
+            builder.endObject();
+            builder.field(ROUTING_TABLE_VERSION_FIELD.getPreferredName(), getRoutingTableVersion());
+            builder.startArray(INDICES_ROUTING_FIELD.getPreferredName());
+            {
+                for (UploadedIndexMetadata uploadedIndexMetadata : indicesRouting) {
+                    builder.startObject();
+                    uploadedIndexMetadata.toXContent(builder, params);
+                    builder.endObject();
+                }
+            }
+            builder.endArray();
+            if (getDiscoveryNodesMetadata() != null) {
+                builder.startObject(UPLOADED_DISCOVERY_NODES_METADATA.getPreferredName());
+                getDiscoveryNodesMetadata().toXContent(builder, params);
+                builder.endObject();
+            }
+            if (getClusterBlocksMetadata() != null) {
+                builder.startObject(UPLOADED_CLUSTER_BLOCKS_METADATA.getPreferredName());
+                getClusterBlocksMetadata().toXContent(builder, params);
+                builder.endObject();
+            }
+            if (getTransientSettingsMetadata() != null) {
+                builder.startObject(UPLOADED_TRANSIENT_SETTINGS_METADATA.getPreferredName());
+                getTransientSettingsMetadata().toXContent(builder, params);
+                builder.endObject();
+            }
+            if (getDiffManifest() != null) {
+                builder.startObject(DIFF_MANIFEST.getPreferredName());
+                getDiffManifest().toXContent(builder, params);
+                builder.endObject();
+            }
+            builder.field(METADATA_VERSION.getPreferredName(), getMetadataVersion());
+            if (getHashesOfConsistentSettings() != null) {
+                builder.startObject(UPLOADED_HASHES_OF_CONSISTENT_SETTINGS_METADATA.getPreferredName());
+                getHashesOfConsistentSettings().toXContent(builder, params);
+                builder.endObject();
+            }
+            builder.startObject(UPLOADED_CLUSTER_STATE_CUSTOM_METADATA.getPreferredName());
+            for (UploadedMetadataAttribute attribute : getClusterStateCustomMap().values()) {
+                attribute.toXContent(builder, params);
+            }
+            builder.endObject();
+        } else if (onOrAfterCodecVersion(CODEC_V1)) {
             builder.field(CODEC_VERSION_FIELD.getPreferredName(), getCodecVersion());
             builder.field(GLOBAL_METADATA_FIELD.getPreferredName(), getGlobalMetadataFileName());
         }
+        if (onOrAfterCodecVersion(CODEC_V4)) {
+            if (getClusterStateChecksum() != null) {
+                builder.startObject(CHECKSUM.getPreferredName());
+                getClusterStateChecksum().toXContent(builder, params);
+                builder.endObject();
+            }
+        }
         return builder;
     }
 
@@ -316,10 +770,58 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeCollection(indices);
         out.writeString(previousClusterUUID);
         out.writeBoolean(clusterUUIDCommitted);
-        if (out.getVersion().onOrAfter(Version.V_2_12_0)) {
+        if (out.getVersion().onOrAfter(Version.V_2_15_0)) {
+            out.writeInt(codecVersion);
+            uploadedCoordinationMetadata.writeTo(out);
+            uploadedSettingsMetadata.writeTo(out);
+            uploadedTemplatesMetadata.writeTo(out);
+            out.writeMap(uploadedCustomMetadataMap, StreamOutput::writeString, (o, v) -> v.writeTo(o));
+            out.writeLong(routingTableVersion);
+            out.writeCollection(indicesRouting);
+            out.writeLong(metadataVersion);
+            if (uploadedDiscoveryNodesMetadata != null) {
+                out.writeBoolean(true);
+                uploadedDiscoveryNodesMetadata.writeTo(out);
+            } else {
+                out.writeBoolean(false);
+            }
+            if (uploadedClusterBlocksMetadata != null) {
+                out.writeBoolean(true);
+                uploadedClusterBlocksMetadata.writeTo(out);
+            } else {
+                out.writeBoolean(false);
+            }
+            if (uploadedTransientSettingsMetadata != null) {
+                out.writeBoolean(true);
+                uploadedTransientSettingsMetadata.writeTo(out);
+            } else {
+                out.writeBoolean(false);
+            }
+            if (uploadedHashesOfConsistentSettings != null) {
+                out.writeBoolean(true);
+                uploadedHashesOfConsistentSettings.writeTo(out);
+            } else {
+                out.writeBoolean(false);
+            }
+            out.writeMap(uploadedClusterStateCustomMap, StreamOutput::writeString, (o, v) -> v.writeTo(o));
+            if (diffManifest != null) {
+                out.writeBoolean(true);
+                diffManifest.writeTo(out);
+            } else {
+                out.writeBoolean(false);
+            }
+        } else if (out.getVersion().onOrAfter(Version.V_2_12_0)) {
             out.writeInt(codecVersion);
             out.writeString(globalMetadataFileName);
         }
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            if (clusterStateChecksum != null) {
+                out.writeBoolean(true);
+                clusterStateChecksum.writeTo(out);
+            } else {
+                out.writeBoolean(false);
+            }
+        }
     }
 
     @Override
@@ -342,7 +844,21 @@ public boolean equals(Object o) {
             && Objects.equals(previousClusterUUID, that.previousClusterUUID)
             && Objects.equals(clusterUUIDCommitted, that.clusterUUIDCommitted)
             && Objects.equals(globalMetadataFileName, that.globalMetadataFileName)
-            && Objects.equals(codecVersion, that.codecVersion);
+            && Objects.equals(codecVersion, that.codecVersion)
+            && Objects.equals(routingTableVersion, that.routingTableVersion)
+            && Objects.equals(indicesRouting, that.indicesRouting)
+            && Objects.equals(uploadedCoordinationMetadata, that.uploadedCoordinationMetadata)
+            && Objects.equals(uploadedSettingsMetadata, that.uploadedSettingsMetadata)
+            && Objects.equals(uploadedTemplatesMetadata, that.uploadedTemplatesMetadata)
+            && Objects.equals(uploadedCustomMetadataMap, that.uploadedCustomMetadataMap)
+            && Objects.equals(metadataVersion, that.metadataVersion)
+            && Objects.equals(uploadedDiscoveryNodesMetadata, that.uploadedDiscoveryNodesMetadata)
+            && Objects.equals(uploadedClusterBlocksMetadata, that.uploadedClusterBlocksMetadata)
+            && Objects.equals(uploadedTransientSettingsMetadata, that.uploadedTransientSettingsMetadata)
+            && Objects.equals(uploadedHashesOfConsistentSettings, that.uploadedHashesOfConsistentSettings)
+            && Objects.equals(uploadedClusterStateCustomMap, that.uploadedClusterStateCustomMap)
+            && Objects.equals(diffManifest, that.diffManifest)
+            && Objects.equals(clusterStateChecksum, that.clusterStateChecksum);
     }
 
     @Override
@@ -359,7 +875,21 @@ public int hashCode() {
             nodeId,
             committed,
             previousClusterUUID,
-            clusterUUIDCommitted
+            clusterUUIDCommitted,
+            routingTableVersion,
+            indicesRouting,
+            uploadedCoordinationMetadata,
+            uploadedSettingsMetadata,
+            uploadedTemplatesMetadata,
+            uploadedCustomMetadataMap,
+            metadataVersion,
+            uploadedDiscoveryNodesMetadata,
+            uploadedClusterBlocksMetadata,
+            uploadedTransientSettingsMetadata,
+            uploadedHashesOfConsistentSettings,
+            uploadedClusterStateCustomMap,
+            diffManifest,
+            clusterStateChecksum
         );
     }
 
@@ -376,6 +906,18 @@ public static ClusterMetadataManifest fromXContentV0(XContentParser parser) thro
         return PARSER_V0.parse(parser, null);
     }
 
+    public static ClusterMetadataManifest fromXContentV1(XContentParser parser) throws IOException {
+        return PARSER_V1.parse(parser, null);
+    }
+
+    public static ClusterMetadataManifest fromXContentV2(XContentParser parser) throws IOException {
+        return PARSER_V2.parse(parser, null);
+    }
+
+    public static ClusterMetadataManifest fromXContentV3(XContentParser parser) throws IOException {
+        return PARSER_V3.parse(parser, null);
+    }
+
     public static ClusterMetadataManifest fromXContent(XContentParser parser) throws IOException {
         return CURRENT_PARSER.parse(parser, null);
     }
@@ -388,6 +930,10 @@ public static ClusterMetadataManifest fromXContent(XContentParser parser) throws
     public static class Builder {
 
         private String globalMetadataFileName;
+        private UploadedMetadataAttribute coordinationMetadata;
+        private UploadedMetadataAttribute settingsMetadata;
+        private UploadedMetadataAttribute templatesMetadata;
+        private Map<String, UploadedMetadataAttribute> customMetadataMap;
         private int codecVersion;
         private List<UploadedIndexMetadata> indices;
         private long clusterTerm;
@@ -399,12 +945,32 @@ public static class Builder {
         private String previousClusterUUID;
         private boolean committed;
         private boolean clusterUUIDCommitted;
+        private long routingTableVersion;
+        private List<UploadedIndexMetadata> indicesRouting;
+        private long metadataVersion;
+        private UploadedMetadataAttribute discoveryNodesMetadata;
+        private UploadedMetadataAttribute clusterBlocksMetadata;
+        private UploadedMetadataAttribute transientSettingsMetadata;
+        private UploadedMetadataAttribute hashesOfConsistentSettings;
+        private Map<String, UploadedMetadataAttribute> clusterStateCustomMetadataMap;
+        private ClusterStateDiffManifest diffManifest;
+        private ClusterStateChecksum checksum;
 
         public Builder indices(List<UploadedIndexMetadata> indices) {
             this.indices = indices;
             return this;
         }
 
+        public Builder routingTableVersion(long routingTableVersion) {
+            this.routingTableVersion = routingTableVersion;
+            return this;
+        }
+
+        public Builder indicesRouting(List<UploadedIndexMetadata> indicesRouting) {
+            this.indicesRouting = indicesRouting;
+            return this;
+        }
+
         public Builder codecVersion(int codecVersion) {
             this.codecVersion = codecVersion;
             return this;
@@ -415,6 +981,31 @@ public Builder globalMetadataFileName(String globalMetadataFileName) {
             return this;
         }
 
+        public Builder coordinationMetadata(UploadedMetadataAttribute coordinationMetadata) {
+            this.coordinationMetadata = coordinationMetadata;
+            return this;
+        }
+
+        public Builder settingMetadata(UploadedMetadataAttribute settingsMetadata) {
+            this.settingsMetadata = settingsMetadata;
+            return this;
+        }
+
+        public Builder templatesMetadata(UploadedMetadataAttribute templatesMetadata) {
+            this.templatesMetadata = templatesMetadata;
+            return this;
+        }
+
+        public Builder customMetadataMap(Map<String, UploadedMetadataAttribute> customMetadataMap) {
+            this.customMetadataMap = customMetadataMap;
+            return this;
+        }
+
+        public Builder put(String custom, UploadedMetadataAttribute customMetadata) {
+            this.customMetadataMap.put(custom, customMetadata);
+            return this;
+        }
+
         public Builder clusterTerm(long clusterTerm) {
             this.clusterTerm = clusterTerm;
             return this;
@@ -454,6 +1045,10 @@ public List<UploadedIndexMetadata> getIndices() {
             return indices;
         }
 
+        public List<UploadedIndexMetadata> getIndicesRouting() {
+            return indicesRouting;
+        }
+
         public Builder previousClusterUUID(String previousClusterUUID) {
             this.previousClusterUUID = previousClusterUUID;
             return this;
@@ -464,8 +1059,51 @@ public Builder clusterUUIDCommitted(boolean clusterUUIDCommitted) {
             return this;
         }
 
+        public Builder metadataVersion(long metadataVersion) {
+            this.metadataVersion = metadataVersion;
+            return this;
+        }
+
+        public Builder discoveryNodesMetadata(UploadedMetadataAttribute discoveryNodesMetadata) {
+            this.discoveryNodesMetadata = discoveryNodesMetadata;
+            return this;
+        }
+
+        public Builder clusterBlocksMetadata(UploadedMetadataAttribute clusterBlocksMetadata) {
+            this.clusterBlocksMetadata = clusterBlocksMetadata;
+            return this;
+        }
+
+        public Builder transientSettingsMetadata(UploadedMetadataAttribute settingsMetadata) {
+            this.transientSettingsMetadata = settingsMetadata;
+            return this;
+        }
+
+        public Builder hashesOfConsistentSettings(UploadedMetadataAttribute hashesOfConsistentSettings) {
+            this.hashesOfConsistentSettings = hashesOfConsistentSettings;
+            return this;
+        }
+
+        public Builder clusterStateCustomMetadataMap(Map<String, UploadedMetadataAttribute> clusterStateCustomMetadataMap) {
+            this.clusterStateCustomMetadataMap = clusterStateCustomMetadataMap;
+            return this;
+        }
+
+        public Builder diffManifest(ClusterStateDiffManifest diffManifest) {
+            this.diffManifest = diffManifest;
+            return this;
+        }
+
+        public Builder checksum(ClusterStateChecksum checksum) {
+            this.checksum = checksum;
+            return this;
+        }
+
         public Builder() {
             indices = new ArrayList<>();
+            customMetadataMap = new HashMap<>();
+            indicesRouting = new ArrayList<>();
+            clusterStateCustomMetadataMap = new HashMap<>();
         }
 
         public Builder(ClusterMetadataManifest manifest) {
@@ -477,10 +1115,23 @@ public Builder(ClusterMetadataManifest manifest) {
             this.nodeId = manifest.nodeId;
             this.committed = manifest.committed;
             this.globalMetadataFileName = manifest.globalMetadataFileName;
+            this.coordinationMetadata = manifest.uploadedCoordinationMetadata;
+            this.settingsMetadata = manifest.uploadedSettingsMetadata;
+            this.templatesMetadata = manifest.uploadedTemplatesMetadata;
+            this.customMetadataMap = manifest.uploadedCustomMetadataMap;
             this.codecVersion = manifest.codecVersion;
             this.indices = new ArrayList<>(manifest.indices);
             this.previousClusterUUID = manifest.previousClusterUUID;
             this.clusterUUIDCommitted = manifest.clusterUUIDCommitted;
+            this.routingTableVersion = manifest.routingTableVersion;
+            this.indicesRouting = new ArrayList<>(manifest.indicesRouting);
+            this.discoveryNodesMetadata = manifest.uploadedDiscoveryNodesMetadata;
+            this.clusterBlocksMetadata = manifest.uploadedClusterBlocksMetadata;
+            this.transientSettingsMetadata = manifest.uploadedTransientSettingsMetadata;
+            this.diffManifest = manifest.diffManifest;
+            this.hashesOfConsistentSettings = manifest.uploadedHashesOfConsistentSettings;
+            this.clusterStateCustomMetadataMap = manifest.uploadedClusterStateCustomMap;
+            this.checksum = manifest.clusterStateChecksum;
         }
 
         public ClusterMetadataManifest build() {
@@ -496,22 +1147,56 @@ public ClusterMetadataManifest build() {
                 globalMetadataFileName,
                 indices,
                 previousClusterUUID,
-                clusterUUIDCommitted
+                clusterUUIDCommitted,
+                coordinationMetadata,
+                settingsMetadata,
+                templatesMetadata,
+                customMetadataMap,
+                routingTableVersion,
+                indicesRouting,
+                metadataVersion,
+                discoveryNodesMetadata,
+                clusterBlocksMetadata,
+                transientSettingsMetadata,
+                hashesOfConsistentSettings,
+                clusterStateCustomMetadataMap,
+                diffManifest,
+                checksum
             );
         }
 
     }
 
+    /**
+     * Interface representing uploaded metadata
+     */
+    public interface UploadedMetadata {
+        /**
+         * Gets the component or part of the system this upload belongs to.
+         *
+         * @return A string identifying the component
+         */
+        String getComponent();
+
+        /**
+         * Gets the name of the file that was uploaded
+         *
+         * @return The name of the uploaded file as a string
+         */
+        String getUploadedFilename();
+    }
+
     /**
      * Metadata for uploaded index metadata
      *
      * @opensearch.internal
      */
-    public static class UploadedIndexMetadata implements Writeable, ToXContentFragment {
+    public static class UploadedIndexMetadata implements UploadedMetadata, Writeable, ToXContentFragment {
 
         private static final ParseField INDEX_NAME_FIELD = new ParseField("index_name");
         private static final ParseField INDEX_UUID_FIELD = new ParseField("index_uuid");
         private static final ParseField UPLOADED_FILENAME_FIELD = new ParseField("uploaded_filename");
+        private static final ParseField COMPONENT_PREFIX_FIELD = new ParseField("component_prefix");
 
         private static String indexName(Object[] fields) {
             return (String) fields[0];
@@ -525,40 +1210,88 @@ private static String uploadedFilename(Object[] fields) {
             return (String) fields[2];
         }
 
-        private static final ConstructingObjectParser<UploadedIndexMetadata, Void> PARSER = new ConstructingObjectParser<>(
+        private static String componentPrefix(Object[] fields) {
+            return (String) fields[3];
+        }
+
+        private static final ConstructingObjectParser<UploadedIndexMetadata, Void> PARSER_V0 = new ConstructingObjectParser<>(
             "uploaded_index_metadata",
             fields -> new UploadedIndexMetadata(indexName(fields), indexUUID(fields), uploadedFilename(fields))
         );
 
+        private static final ConstructingObjectParser<UploadedIndexMetadata, Void> PARSER_V2 = new ConstructingObjectParser<>(
+            "uploaded_index_metadata",
+            fields -> new UploadedIndexMetadata(indexName(fields), indexUUID(fields), uploadedFilename(fields), componentPrefix(fields))
+        );
+
+        private static final ConstructingObjectParser<UploadedIndexMetadata, Void> CURRENT_PARSER = PARSER_V2;
+
         static {
-            PARSER.declareString(ConstructingObjectParser.constructorArg(), INDEX_NAME_FIELD);
-            PARSER.declareString(ConstructingObjectParser.constructorArg(), INDEX_UUID_FIELD);
-            PARSER.declareString(ConstructingObjectParser.constructorArg(), UPLOADED_FILENAME_FIELD);
+            declareParser(PARSER_V0, CODEC_V0);
+            declareParser(PARSER_V2, CODEC_V2);
+        }
+
+        private static void declareParser(ConstructingObjectParser<UploadedIndexMetadata, Void> parser, long codec_version) {
+            parser.declareString(ConstructingObjectParser.constructorArg(), INDEX_NAME_FIELD);
+            parser.declareString(ConstructingObjectParser.constructorArg(), INDEX_UUID_FIELD);
+            parser.declareString(ConstructingObjectParser.constructorArg(), UPLOADED_FILENAME_FIELD);
+            if (codec_version >= CODEC_V2) {
+                parser.declareString(ConstructingObjectParser.constructorArg(), COMPONENT_PREFIX_FIELD);
+            }
         }
 
+        static final String COMPONENT_PREFIX = "index--";
+        private final String componentPrefix;
         private final String indexName;
         private final String indexUUID;
         private final String uploadedFilename;
 
+        private long codecVersion = CODEC_V2;
+
         public UploadedIndexMetadata(String indexName, String indexUUID, String uploadedFileName) {
+            this(indexName, indexUUID, uploadedFileName, CODEC_V2);
+        }
+
+        public UploadedIndexMetadata(String indexName, String indexUUID, String uploadedFileName, long codecVersion) {
+            this(indexName, indexUUID, uploadedFileName, COMPONENT_PREFIX, codecVersion);
+        }
+
+        public UploadedIndexMetadata(String indexName, String indexUUID, String uploadedFileName, String componentPrefix) {
+            this(indexName, indexUUID, uploadedFileName, componentPrefix, CODEC_V2);
+        }
+
+        public UploadedIndexMetadata(
+            String indexName,
+            String indexUUID,
+            String uploadedFileName,
+            String componentPrefix,
+            long codecVersion
+        ) {
+            this.componentPrefix = componentPrefix;
             this.indexName = indexName;
             this.indexUUID = indexUUID;
             this.uploadedFilename = uploadedFileName;
+            this.codecVersion = codecVersion;
         }
 
         public UploadedIndexMetadata(StreamInput in) throws IOException {
             this.indexName = in.readString();
             this.indexUUID = in.readString();
             this.uploadedFilename = in.readString();
+            this.componentPrefix = in.readString();
         }
 
         public String getUploadedFilePath() {
             return uploadedFilename;
         }
 
+        @Override
+        public String getComponent() {
+            return componentPrefix + getIndexName();
+        }
+
         public String getUploadedFilename() {
-            String[] splitPath = uploadedFilename.split("/");
-            return splitPath[splitPath.length - 1];
+            return uploadedFilename;
         }
 
         public String getIndexName() {
@@ -569,13 +1302,19 @@ public String getIndexUUID() {
             return indexUUID;
         }
 
+        public String getComponentPrefix() {
+            return componentPrefix;
+        }
+
         @Override
         public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-            return builder.startObject()
-                .field(INDEX_NAME_FIELD.getPreferredName(), getIndexName())
+            builder.field(INDEX_NAME_FIELD.getPreferredName(), getIndexName())
                 .field(INDEX_UUID_FIELD.getPreferredName(), getIndexUUID())
-                .field(UPLOADED_FILENAME_FIELD.getPreferredName(), getUploadedFilePath())
-                .endObject();
+                .field(UPLOADED_FILENAME_FIELD.getPreferredName(), getUploadedFilePath());
+            if (codecVersion >= CODEC_V2) {
+                builder.field(COMPONENT_PREFIX_FIELD.getPreferredName(), getComponentPrefix());
+            }
+            return builder;
         }
 
         @Override
@@ -583,6 +1322,7 @@ public void writeTo(StreamOutput out) throws IOException {
             out.writeString(indexName);
             out.writeString(indexUUID);
             out.writeString(uploadedFilename);
+            out.writeString(componentPrefix);
         }
 
         @Override
@@ -596,12 +1336,13 @@ public boolean equals(Object o) {
             final UploadedIndexMetadata that = (UploadedIndexMetadata) o;
             return Objects.equals(indexName, that.indexName)
                 && Objects.equals(indexUUID, that.indexUUID)
-                && Objects.equals(uploadedFilename, that.uploadedFilename);
+                && Objects.equals(uploadedFilename, that.uploadedFilename)
+                && Objects.equals(componentPrefix, that.componentPrefix);
         }
 
         @Override
         public int hashCode() {
-            return Objects.hash(indexName, indexUUID, uploadedFilename);
+            return Objects.hash(indexName, indexUUID, uploadedFilename, componentPrefix);
         }
 
         @Override
@@ -609,8 +1350,104 @@ public String toString() {
             return Strings.toString(MediaTypeRegistry.JSON, this);
         }
 
-        public static UploadedIndexMetadata fromXContent(XContentParser parser) throws IOException {
-            return PARSER.parse(parser, null);
+        public static UploadedIndexMetadata fromXContent(XContentParser parser, long codecVersion) throws IOException {
+            if (codecVersion >= CODEC_V2) {
+                return CURRENT_PARSER.parse(parser, null);
+            }
+            return PARSER_V0.parse(parser, null);
+        }
+
+    }
+
+    /**
+     * Metadata for uploaded metadata attribute
+     *
+     * @opensearch.internal
+     */
+    public static class UploadedMetadataAttribute implements UploadedMetadata, Writeable, ToXContentFragment {
+        private static final ParseField UPLOADED_FILENAME_FIELD = new ParseField("uploaded_filename");
+
+        private static final ObjectParser.NamedObjectParser<UploadedMetadataAttribute, Void> PARSER;
+
+        static {
+            ConstructingObjectParser<UploadedMetadataAttribute, String> innerParser = new ConstructingObjectParser<>(
+                "uploaded_metadata_attribute",
+                true,
+                (Object[] parsedObject, String name) -> {
+                    String uploadedFilename = (String) parsedObject[0];
+                    return new UploadedMetadataAttribute(name, uploadedFilename);
+                }
+            );
+            innerParser.declareString(ConstructingObjectParser.constructorArg(), UPLOADED_FILENAME_FIELD);
+            PARSER = ((p, c, name) -> innerParser.parse(p, name));
+        }
+
+        private final String attributeName;
+        private final String uploadedFilename;
+
+        public UploadedMetadataAttribute(String attributeName, String uploadedFilename) {
+            this.attributeName = attributeName;
+            this.uploadedFilename = uploadedFilename;
+        }
+
+        public UploadedMetadataAttribute(StreamInput in) throws IOException {
+            this.attributeName = in.readString();
+            this.uploadedFilename = in.readString();
+        }
+
+        public String getAttributeName() {
+            return attributeName;
+        }
+
+        @Override
+        public String getComponent() {
+            return getAttributeName();
+        }
+
+        public String getUploadedFilename() {
+            return uploadedFilename;
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeString(attributeName);
+            out.writeString(uploadedFilename);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            return builder.startObject(getAttributeName())
+                .field(UPLOADED_FILENAME_FIELD.getPreferredName(), getUploadedFilename())
+                .endObject();
+        }
+
+        public static UploadedMetadataAttribute fromXContent(XContentParser parser) throws IOException {
+            return PARSER.parse(parser, null, parser.currentName());
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            UploadedMetadataAttribute that = (UploadedMetadataAttribute) o;
+            return Objects.equals(attributeName, that.attributeName) && Objects.equals(uploadedFilename, that.uploadedFilename);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(attributeName, uploadedFilename);
+        }
+
+        @Override
+        public String toString() {
+            return "UploadedMetadataAttribute{"
+                + "attributeName='"
+                + attributeName
+                + '\''
+                + ", uploadedFilename='"
+                + uploadedFilename
+                + '\''
+                + '}';
         }
     }
 }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/ClusterStateChecksum.java b/server/src/main/java/org/opensearch/gateway/remote/ClusterStateChecksum.java
new file mode 100644
index 0000000000000..fb0eb35f4066b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/ClusterStateChecksum.java
@@ -0,0 +1,485 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.DiffableStringMap;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParseException;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import com.jcraft.jzlib.JZlib;
+
+import static org.opensearch.core.xcontent.XContentParserUtils.ensureExpectedToken;
+
+/**
+ * Stores checksum for all components in cluster state. This will be used to ensure cluster state is same across all nodes in the cluster.
+ */
+public class ClusterStateChecksum implements ToXContentFragment, Writeable {
+
+    static final String ROUTING_TABLE_CS = "routing_table";
+    static final String NODES_CS = "discovery_nodes";
+    static final String BLOCKS_CS = "blocks";
+    static final String CUSTOMS_CS = "customs";
+    static final String COORDINATION_MD_CS = "coordination_md";
+    static final String SETTINGS_MD_CS = "settings_md";
+    static final String TRANSIENT_SETTINGS_MD_CS = "transient_settings_md";
+    static final String TEMPLATES_MD_CS = "templates_md";
+    static final String CUSTOM_MD_CS = "customs_md";
+    static final String HASHES_MD_CS = "hashes_md";
+    static final String INDICES_CS = "indices_md";
+    private static final String CLUSTER_STATE_CS = "cluster_state";
+    private static final int CHECKSUM_SIZE = 8;
+    private static final Logger logger = LogManager.getLogger(ClusterStateChecksum.class);
+
+    long routingTableChecksum;
+    long nodesChecksum;
+    long blocksChecksum;
+    long clusterStateCustomsChecksum;
+    long coordinationMetadataChecksum;
+    long settingMetadataChecksum;
+    long transientSettingsMetadataChecksum;
+    long templatesMetadataChecksum;
+    long customMetadataMapChecksum;
+    long hashesOfConsistentSettingsChecksum;
+    long indicesChecksum;
+    long clusterStateChecksum;
+
+    public ClusterStateChecksum(ClusterState clusterState) {
+        try (
+            BytesStreamOutput out = new BytesStreamOutput();
+            BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out)
+        ) {
+            clusterState.routingTable().writeVerifiableTo(checksumOut);
+            routingTableChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            clusterState.nodes().writeVerifiableTo(checksumOut);
+            nodesChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            clusterState.coordinationMetadata().writeVerifiableTo(checksumOut);
+            coordinationMetadataChecksum = checksumOut.getChecksum();
+
+            // Settings create sortedMap by default, so no explicit sorting required here.
+            checksumOut.reset();
+            Settings.writeSettingsToStream(clusterState.metadata().persistentSettings(), checksumOut);
+            settingMetadataChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            Settings.writeSettingsToStream(clusterState.metadata().transientSettings(), checksumOut);
+            transientSettingsMetadataChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            clusterState.metadata().templatesMetadata().writeVerifiableTo(checksumOut);
+            templatesMetadataChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            checksumOut.writeStringCollection(clusterState.metadata().customs().keySet());
+            customMetadataMapChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            ((DiffableStringMap) clusterState.metadata().hashesOfConsistentSettings()).writeTo(checksumOut);
+            hashesOfConsistentSettingsChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            checksumOut.writeMapValues(
+                clusterState.metadata().indices(),
+                (stream, value) -> value.writeVerifiableTo((BufferedChecksumStreamOutput) stream)
+            );
+            indicesChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            clusterState.blocks().writeVerifiableTo(checksumOut);
+            blocksChecksum = checksumOut.getChecksum();
+
+            checksumOut.reset();
+            checksumOut.writeStringCollection(clusterState.customs().keySet());
+            clusterStateCustomsChecksum = checksumOut.getChecksum();
+        } catch (IOException e) {
+            logger.error("Failed to create checksum for cluster state.", e);
+            throw new RemoteStateTransferException("Failed to create checksum for cluster state.", e);
+        }
+        createClusterStateChecksum();
+    }
+
+    private void createClusterStateChecksum() {
+        clusterStateChecksum = JZlib.crc32_combine(routingTableChecksum, nodesChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, blocksChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, clusterStateCustomsChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, coordinationMetadataChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, settingMetadataChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, transientSettingsMetadataChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, templatesMetadataChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, customMetadataMapChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, hashesOfConsistentSettingsChecksum, CHECKSUM_SIZE);
+        clusterStateChecksum = JZlib.crc32_combine(clusterStateChecksum, indicesChecksum, CHECKSUM_SIZE);
+    }
+
+    public static ClusterStateChecksum.Builder builder() {
+        return new ClusterStateChecksum.Builder();
+    }
+
+    public ClusterStateChecksum(
+        long routingTableChecksum,
+        long nodesChecksum,
+        long blocksChecksum,
+        long clusterStateCustomsChecksum,
+        long coordinationMetadataChecksum,
+        long settingMetadataChecksum,
+        long transientSettingsMetadataChecksum,
+        long templatesMetadataChecksum,
+        long customMetadataMapChecksum,
+        long hashesOfConsistentSettingsChecksum,
+        long indicesChecksum,
+        long clusterStateChecksum
+    ) {
+        this.routingTableChecksum = routingTableChecksum;
+        this.nodesChecksum = nodesChecksum;
+        this.blocksChecksum = blocksChecksum;
+        this.clusterStateCustomsChecksum = clusterStateCustomsChecksum;
+        this.coordinationMetadataChecksum = coordinationMetadataChecksum;
+        this.settingMetadataChecksum = settingMetadataChecksum;
+        this.transientSettingsMetadataChecksum = transientSettingsMetadataChecksum;
+        this.templatesMetadataChecksum = templatesMetadataChecksum;
+        this.customMetadataMapChecksum = customMetadataMapChecksum;
+        this.hashesOfConsistentSettingsChecksum = hashesOfConsistentSettingsChecksum;
+        this.indicesChecksum = indicesChecksum;
+        this.clusterStateChecksum = clusterStateChecksum;
+    }
+
+    public ClusterStateChecksum(StreamInput in) throws IOException {
+        routingTableChecksum = in.readLong();
+        nodesChecksum = in.readLong();
+        blocksChecksum = in.readLong();
+        clusterStateCustomsChecksum = in.readLong();
+        coordinationMetadataChecksum = in.readLong();
+        settingMetadataChecksum = in.readLong();
+        transientSettingsMetadataChecksum = in.readLong();
+        templatesMetadataChecksum = in.readLong();
+        customMetadataMapChecksum = in.readLong();
+        hashesOfConsistentSettingsChecksum = in.readLong();
+        indicesChecksum = in.readLong();
+        clusterStateChecksum = in.readLong();
+    }
+
+    public static ClusterStateChecksum fromXContent(XContentParser parser) throws IOException {
+        ClusterStateChecksum.Builder builder = new ClusterStateChecksum.Builder();
+        if (parser.currentToken() == null) { // fresh parser? move to next token
+            parser.nextToken();
+        }
+        if (parser.currentToken() == XContentParser.Token.START_OBJECT) {
+            parser.nextToken();
+        }
+        ensureExpectedToken(XContentParser.Token.FIELD_NAME, parser.currentToken(), parser);
+        XContentParser.Token token;
+        String currentFieldName = parser.currentName();
+        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+            if (parser.currentToken() == XContentParser.Token.FIELD_NAME) {
+                currentFieldName = parser.currentName();
+            } else if (token.isValue()) {
+                switch (currentFieldName) {
+                    case ROUTING_TABLE_CS:
+                        builder.routingTableChecksum(parser.longValue());
+                        break;
+                    case NODES_CS:
+                        builder.nodesChecksum(parser.longValue());
+                        break;
+                    case BLOCKS_CS:
+                        builder.blocksChecksum(parser.longValue());
+                        break;
+                    case CUSTOMS_CS:
+                        builder.clusterStateCustomsChecksum(parser.longValue());
+                        break;
+                    case COORDINATION_MD_CS:
+                        builder.coordinationMetadataChecksum(parser.longValue());
+                        break;
+                    case SETTINGS_MD_CS:
+                        builder.settingMetadataChecksum(parser.longValue());
+                        break;
+                    case TRANSIENT_SETTINGS_MD_CS:
+                        builder.transientSettingsMetadataChecksum(parser.longValue());
+                        break;
+                    case TEMPLATES_MD_CS:
+                        builder.templatesMetadataChecksum(parser.longValue());
+                        break;
+                    case CUSTOM_MD_CS:
+                        builder.customMetadataMapChecksum(parser.longValue());
+                        break;
+                    case HASHES_MD_CS:
+                        builder.hashesOfConsistentSettingsChecksum(parser.longValue());
+                        break;
+                    case INDICES_CS:
+                        builder.indicesChecksum(parser.longValue());
+                        break;
+                    case CLUSTER_STATE_CS:
+                        builder.clusterStateChecksum(parser.longValue());
+                        break;
+                    default:
+                        throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                }
+            } else {
+                throw new XContentParseException("Unexpected token [" + token + "]");
+            }
+        }
+        return builder.build();
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeLong(routingTableChecksum);
+        out.writeLong(nodesChecksum);
+        out.writeLong(blocksChecksum);
+        out.writeLong(clusterStateCustomsChecksum);
+        out.writeLong(coordinationMetadataChecksum);
+        out.writeLong(settingMetadataChecksum);
+        out.writeLong(transientSettingsMetadataChecksum);
+        out.writeLong(templatesMetadataChecksum);
+        out.writeLong(customMetadataMapChecksum);
+        out.writeLong(hashesOfConsistentSettingsChecksum);
+        out.writeLong(indicesChecksum);
+        out.writeLong(clusterStateChecksum);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.field(ROUTING_TABLE_CS, routingTableChecksum);
+        builder.field(NODES_CS, nodesChecksum);
+        builder.field(BLOCKS_CS, blocksChecksum);
+        builder.field(CUSTOMS_CS, clusterStateCustomsChecksum);
+        builder.field(COORDINATION_MD_CS, coordinationMetadataChecksum);
+        builder.field(SETTINGS_MD_CS, settingMetadataChecksum);
+        builder.field(TRANSIENT_SETTINGS_MD_CS, transientSettingsMetadataChecksum);
+        builder.field(TEMPLATES_MD_CS, templatesMetadataChecksum);
+        builder.field(CUSTOM_MD_CS, customMetadataMapChecksum);
+        builder.field(HASHES_MD_CS, hashesOfConsistentSettingsChecksum);
+        builder.field(INDICES_CS, indicesChecksum);
+        builder.field(CLUSTER_STATE_CS, clusterStateChecksum);
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ClusterStateChecksum that = (ClusterStateChecksum) o;
+        return routingTableChecksum == that.routingTableChecksum
+            && nodesChecksum == that.nodesChecksum
+            && blocksChecksum == that.blocksChecksum
+            && clusterStateCustomsChecksum == that.clusterStateCustomsChecksum
+            && coordinationMetadataChecksum == that.coordinationMetadataChecksum
+            && settingMetadataChecksum == that.settingMetadataChecksum
+            && transientSettingsMetadataChecksum == that.transientSettingsMetadataChecksum
+            && templatesMetadataChecksum == that.templatesMetadataChecksum
+            && customMetadataMapChecksum == that.customMetadataMapChecksum
+            && hashesOfConsistentSettingsChecksum == that.hashesOfConsistentSettingsChecksum
+            && indicesChecksum == that.indicesChecksum
+            && clusterStateChecksum == that.clusterStateChecksum;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+            routingTableChecksum,
+            nodesChecksum,
+            blocksChecksum,
+            clusterStateCustomsChecksum,
+            coordinationMetadataChecksum,
+            settingMetadataChecksum,
+            transientSettingsMetadataChecksum,
+            templatesMetadataChecksum,
+            customMetadataMapChecksum,
+            hashesOfConsistentSettingsChecksum,
+            indicesChecksum,
+            clusterStateChecksum
+        );
+    }
+
+    @Override
+    public String toString() {
+        return "ClusterStateChecksum{"
+            + "routingTableChecksum="
+            + routingTableChecksum
+            + ", nodesChecksum="
+            + nodesChecksum
+            + ", blocksChecksum="
+            + blocksChecksum
+            + ", clusterStateCustomsChecksum="
+            + clusterStateCustomsChecksum
+            + ", coordinationMetadataChecksum="
+            + coordinationMetadataChecksum
+            + ", settingMetadataChecksum="
+            + settingMetadataChecksum
+            + ", transientSettingsMetadataChecksum="
+            + transientSettingsMetadataChecksum
+            + ", templatesMetadataChecksum="
+            + templatesMetadataChecksum
+            + ", customMetadataMapChecksum="
+            + customMetadataMapChecksum
+            + ", hashesOfConsistentSettingsChecksum="
+            + hashesOfConsistentSettingsChecksum
+            + ", indicesChecksum="
+            + indicesChecksum
+            + ", clusterStateChecksum="
+            + clusterStateChecksum
+            + '}';
+    }
+
+    public List<String> getMismatchEntities(ClusterStateChecksum otherClusterStateChecksum) {
+        if (this.clusterStateChecksum == otherClusterStateChecksum.clusterStateChecksum) {
+            logger.debug("No mismatch in checksums.");
+            return List.of();
+        }
+        List<String> mismatches = new ArrayList<>();
+        addIfMismatch(this.routingTableChecksum, otherClusterStateChecksum.routingTableChecksum, ROUTING_TABLE_CS, mismatches);
+        addIfMismatch(this.nodesChecksum, otherClusterStateChecksum.nodesChecksum, NODES_CS, mismatches);
+        addIfMismatch(this.blocksChecksum, otherClusterStateChecksum.blocksChecksum, BLOCKS_CS, mismatches);
+        addIfMismatch(this.clusterStateCustomsChecksum, otherClusterStateChecksum.clusterStateCustomsChecksum, CUSTOMS_CS, mismatches);
+        addIfMismatch(
+            this.coordinationMetadataChecksum,
+            otherClusterStateChecksum.coordinationMetadataChecksum,
+            COORDINATION_MD_CS,
+            mismatches
+        );
+        addIfMismatch(this.settingMetadataChecksum, otherClusterStateChecksum.settingMetadataChecksum, SETTINGS_MD_CS, mismatches);
+        addIfMismatch(
+            this.transientSettingsMetadataChecksum,
+            otherClusterStateChecksum.transientSettingsMetadataChecksum,
+            TRANSIENT_SETTINGS_MD_CS,
+            mismatches
+        );
+        addIfMismatch(this.templatesMetadataChecksum, otherClusterStateChecksum.templatesMetadataChecksum, TEMPLATES_MD_CS, mismatches);
+        addIfMismatch(this.customMetadataMapChecksum, otherClusterStateChecksum.customMetadataMapChecksum, CUSTOM_MD_CS, mismatches);
+        addIfMismatch(
+            this.hashesOfConsistentSettingsChecksum,
+            otherClusterStateChecksum.hashesOfConsistentSettingsChecksum,
+            HASHES_MD_CS,
+            mismatches
+        );
+        addIfMismatch(this.indicesChecksum, otherClusterStateChecksum.indicesChecksum, INDICES_CS, mismatches);
+
+        return mismatches;
+    }
+
+    private void addIfMismatch(long checksum, long otherChecksum, String entityName, List<String> mismatches) {
+        if (checksum != otherChecksum) {
+            mismatches.add(entityName);
+        }
+    }
+
+    /**
+     * Builder for ClusterStateChecksum
+     */
+    public static class Builder {
+        long routingTableChecksum;
+        long nodesChecksum;
+        long blocksChecksum;
+        long clusterStateCustomsChecksum;
+        long coordinationMetadataChecksum;
+        long settingMetadataChecksum;
+        long transientSettingsMetadataChecksum;
+        long templatesMetadataChecksum;
+        long customMetadataMapChecksum;
+        long hashesOfConsistentSettingsChecksum;
+        long indicesChecksum;
+        long clusterStateChecksum;
+
+        public Builder routingTableChecksum(long routingTableChecksum) {
+            this.routingTableChecksum = routingTableChecksum;
+            return this;
+        }
+
+        public Builder nodesChecksum(long nodesChecksum) {
+            this.nodesChecksum = nodesChecksum;
+            return this;
+        }
+
+        public Builder blocksChecksum(long blocksChecksum) {
+            this.blocksChecksum = blocksChecksum;
+            return this;
+        }
+
+        public Builder clusterStateCustomsChecksum(long clusterStateCustomsChecksum) {
+            this.clusterStateCustomsChecksum = clusterStateCustomsChecksum;
+            return this;
+        }
+
+        public Builder coordinationMetadataChecksum(long coordinationMetadataChecksum) {
+            this.coordinationMetadataChecksum = coordinationMetadataChecksum;
+            return this;
+        }
+
+        public Builder settingMetadataChecksum(long settingMetadataChecksum) {
+            this.settingMetadataChecksum = settingMetadataChecksum;
+            return this;
+        }
+
+        public Builder transientSettingsMetadataChecksum(long transientSettingsMetadataChecksum) {
+            this.transientSettingsMetadataChecksum = transientSettingsMetadataChecksum;
+            return this;
+        }
+
+        public Builder templatesMetadataChecksum(long templatesMetadataChecksum) {
+            this.templatesMetadataChecksum = templatesMetadataChecksum;
+            return this;
+        }
+
+        public Builder customMetadataMapChecksum(long customMetadataMapChecksum) {
+            this.customMetadataMapChecksum = customMetadataMapChecksum;
+            return this;
+        }
+
+        public Builder hashesOfConsistentSettingsChecksum(long hashesOfConsistentSettingsChecksum) {
+            this.hashesOfConsistentSettingsChecksum = hashesOfConsistentSettingsChecksum;
+            return this;
+        }
+
+        public Builder indicesChecksum(long indicesChecksum) {
+            this.indicesChecksum = indicesChecksum;
+            return this;
+        }
+
+        public Builder clusterStateChecksum(long clusterStateChecksum) {
+            this.clusterStateChecksum = clusterStateChecksum;
+            return this;
+        }
+
+        public ClusterStateChecksum build() {
+            return new ClusterStateChecksum(
+                routingTableChecksum,
+                nodesChecksum,
+                blocksChecksum,
+                clusterStateCustomsChecksum,
+                coordinationMetadataChecksum,
+                settingMetadataChecksum,
+                transientSettingsMetadataChecksum,
+                templatesMetadataChecksum,
+                customMetadataMapChecksum,
+                hashesOfConsistentSettingsChecksum,
+                indicesChecksum,
+                clusterStateChecksum
+            );
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/ClusterStateDiffManifest.java b/server/src/main/java/org/opensearch/gateway/remote/ClusterStateDiffManifest.java
new file mode 100644
index 0000000000000..a97b3e1bc6c4b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/ClusterStateDiffManifest.java
@@ -0,0 +1,728 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiffableUtils;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.ToXContentFragment;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParseException;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.opensearch.cluster.DiffableUtils.NonDiffableValueSerializer.getAbstractInstance;
+import static org.opensearch.cluster.DiffableUtils.getStringKeySerializer;
+import static org.opensearch.core.xcontent.XContentParserUtils.ensureExpectedToken;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V2;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V3;
+
+/**
+ * Manifest of diff between two cluster states
+ *
+ * @opensearch.internal
+ */
+public class ClusterStateDiffManifest implements ToXContentFragment, Writeable {
+    private static final String FROM_STATE_UUID_FIELD = "from_state_uuid";
+    private static final String TO_STATE_UUID_FIELD = "to_state_uuid";
+    private static final String METADATA_DIFF_FIELD = "metadata_diff";
+    private static final String COORDINATION_METADATA_UPDATED_FIELD = "coordination_metadata_diff";
+    private static final String SETTINGS_METADATA_UPDATED_FIELD = "settings_metadata_diff";
+    private static final String TRANSIENT_SETTINGS_METADATA_UPDATED_FIELD = "transient_settings_metadata_diff";
+    private static final String TEMPLATES_METADATA_UPDATED_FIELD = "templates_metadata_diff";
+    private static final String HASHES_OF_CONSISTENT_SETTINGS_UPDATED_FIELD = "hashes_of_consistent_settings_diff";
+    private static final String INDICES_DIFF_FIELD = "indices_diff";
+    private static final String METADATA_CUSTOM_DIFF_FIELD = "metadata_custom_diff";
+    private static final String UPSERTS_FIELD = "upserts";
+    private static final String DELETES_FIELD = "deletes";
+    private static final String DIFF_FIELD = "diff";
+    private static final String CLUSTER_BLOCKS_UPDATED_FIELD = "cluster_blocks_diff";
+    private static final String DISCOVERY_NODES_UPDATED_FIELD = "discovery_nodes_diff";
+    private static final String ROUTING_TABLE_DIFF = "routing_table_diff";
+    private static final String CLUSTER_STATE_CUSTOM_DIFF_FIELD = "cluster_state_custom_diff";
+
+    private final String fromStateUUID;
+    private final String toStateUUID;
+    private final boolean coordinationMetadataUpdated;
+    private final boolean settingsMetadataUpdated;
+    private final boolean transientSettingsMetadataUpdated;
+    private final boolean templatesMetadataUpdated;
+    private final List<String> indicesUpdated;
+    private final List<String> indicesDeleted;
+    private final List<String> customMetadataUpdated;
+    private final List<String> customMetadataDeleted;
+    private final boolean clusterBlocksUpdated;
+    private final boolean discoveryNodesUpdated;
+    private final List<String> indicesRoutingUpdated;
+    private final List<String> indicesRoutingDeleted;
+    private String indicesRoutingDiffPath;
+    private final boolean hashesOfConsistentSettingsUpdated;
+    private final List<String> clusterStateCustomUpdated;
+    private final List<String> clusterStateCustomDeleted;
+
+    public ClusterStateDiffManifest(
+        ClusterState state,
+        ClusterState previousState,
+        int codecVersion,
+        StringKeyDiffProvider<IndexRoutingTable> routingTableDiff,
+        String indicesRoutingDiffPath
+    ) {
+        fromStateUUID = previousState.stateUUID();
+        toStateUUID = state.stateUUID();
+        coordinationMetadataUpdated = !Metadata.isCoordinationMetadataEqual(state.metadata(), previousState.metadata());
+        settingsMetadataUpdated = !Metadata.isSettingsMetadataEqual(state.metadata(), previousState.metadata());
+        transientSettingsMetadataUpdated = !Metadata.isTransientSettingsMetadataEqual(state.metadata(), previousState.metadata());
+        templatesMetadataUpdated = !Metadata.isTemplatesMetadataEqual(state.metadata(), previousState.metadata());
+        DiffableUtils.MapDiff<String, IndexMetadata, Map<String, IndexMetadata>> indicesDiff = DiffableUtils.diff(
+            previousState.metadata().indices(),
+            state.metadata().indices(),
+            getStringKeySerializer()
+        );
+        indicesDeleted = indicesDiff.getDeletes();
+        indicesUpdated = new ArrayList<>(indicesDiff.getDiffs().keySet());
+        indicesUpdated.addAll(indicesDiff.getUpserts().keySet());
+        clusterBlocksUpdated = !state.blocks().equals(previousState.blocks());
+        discoveryNodesUpdated = state.nodes().delta(previousState.nodes()).hasChanges();
+        DiffableUtils.MapDiff<String, Metadata.Custom, Map<String, Metadata.Custom>> customDiff = DiffableUtils.diff(
+            previousState.metadata().customs(),
+            state.metadata().customs(),
+            getStringKeySerializer(),
+            getAbstractInstance()
+        );
+        customMetadataUpdated = new ArrayList<>(customDiff.getDiffs().keySet());
+        customMetadataUpdated.addAll(customDiff.getUpserts().keySet());
+        customMetadataDeleted = customDiff.getDeletes();
+        indicesRoutingUpdated = new ArrayList<>();
+        indicesRoutingDeleted = new ArrayList<>();
+        this.indicesRoutingDiffPath = indicesRoutingDiffPath;
+        if (codecVersion == CODEC_V2 || codecVersion == CODEC_V3) {
+            if (routingTableDiff != null && routingTableDiff.provideDiff() != null) {
+                routingTableDiff.provideDiff().getUpserts().forEach((k, v) -> indicesRoutingUpdated.add(k));
+                indicesRoutingDeleted.addAll(routingTableDiff.provideDiff().getDeletes());
+            }
+        }
+        hashesOfConsistentSettingsUpdated = !state.metadata()
+            .hashesOfConsistentSettings()
+            .equals(previousState.metadata().hashesOfConsistentSettings());
+        DiffableUtils.MapDiff<String, ClusterState.Custom, Map<String, ClusterState.Custom>> clusterStateCustomDiff = DiffableUtils.diff(
+            previousState.customs(),
+            state.customs(),
+            getStringKeySerializer(),
+            getAbstractInstance()
+        );
+        clusterStateCustomUpdated = new ArrayList<>(clusterStateCustomDiff.getDiffs().keySet());
+        clusterStateCustomUpdated.addAll(clusterStateCustomDiff.getUpserts().keySet());
+        clusterStateCustomDeleted = clusterStateCustomDiff.getDeletes();
+    }
+
+    public ClusterStateDiffManifest(
+        String fromStateUUID,
+        String toStateUUID,
+        boolean coordinationMetadataUpdated,
+        boolean settingsMetadataUpdated,
+        boolean transientSettingsMetadataUpdate,
+        boolean templatesMetadataUpdated,
+        List<String> customMetadataUpdated,
+        List<String> customMetadataDeleted,
+        List<String> indicesUpdated,
+        List<String> indicesDeleted,
+        boolean clusterBlocksUpdated,
+        boolean discoveryNodesUpdated,
+        List<String> indicesRoutingUpdated,
+        List<String> indicesRoutingDeleted,
+        String indicesRoutingDiffPath,
+        boolean hashesOfConsistentSettingsUpdated,
+        List<String> clusterStateCustomUpdated,
+        List<String> clusterStateCustomDeleted
+    ) {
+        this.fromStateUUID = fromStateUUID;
+        this.toStateUUID = toStateUUID;
+        this.coordinationMetadataUpdated = coordinationMetadataUpdated;
+        this.settingsMetadataUpdated = settingsMetadataUpdated;
+        this.transientSettingsMetadataUpdated = transientSettingsMetadataUpdate;
+        this.templatesMetadataUpdated = templatesMetadataUpdated;
+        this.customMetadataUpdated = Collections.unmodifiableList(customMetadataUpdated);
+        this.customMetadataDeleted = Collections.unmodifiableList(customMetadataDeleted);
+        this.indicesUpdated = Collections.unmodifiableList(indicesUpdated);
+        this.indicesDeleted = Collections.unmodifiableList(indicesDeleted);
+        this.clusterBlocksUpdated = clusterBlocksUpdated;
+        this.discoveryNodesUpdated = discoveryNodesUpdated;
+        this.indicesRoutingUpdated = Collections.unmodifiableList(indicesRoutingUpdated);
+        this.indicesRoutingDeleted = Collections.unmodifiableList(indicesRoutingDeleted);
+        this.hashesOfConsistentSettingsUpdated = hashesOfConsistentSettingsUpdated;
+        this.clusterStateCustomUpdated = Collections.unmodifiableList(clusterStateCustomUpdated);
+        this.clusterStateCustomDeleted = Collections.unmodifiableList(clusterStateCustomDeleted);
+        this.indicesRoutingDiffPath = indicesRoutingDiffPath;
+    }
+
+    public ClusterStateDiffManifest(StreamInput in) throws IOException {
+        this.fromStateUUID = in.readString();
+        this.toStateUUID = in.readString();
+        this.coordinationMetadataUpdated = in.readBoolean();
+        this.settingsMetadataUpdated = in.readBoolean();
+        this.transientSettingsMetadataUpdated = in.readBoolean();
+        this.templatesMetadataUpdated = in.readBoolean();
+        this.indicesUpdated = in.readStringList();
+        this.indicesDeleted = in.readStringList();
+        this.customMetadataUpdated = in.readStringList();
+        this.customMetadataDeleted = in.readStringList();
+        this.clusterBlocksUpdated = in.readBoolean();
+        this.discoveryNodesUpdated = in.readBoolean();
+        this.indicesRoutingUpdated = in.readStringList();
+        this.indicesRoutingDeleted = in.readStringList();
+        this.hashesOfConsistentSettingsUpdated = in.readBoolean();
+        this.clusterStateCustomUpdated = in.readStringList();
+        this.clusterStateCustomDeleted = in.readStringList();
+        this.indicesRoutingDiffPath = in.readOptionalString();
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.field(FROM_STATE_UUID_FIELD, fromStateUUID);
+        builder.field(TO_STATE_UUID_FIELD, toStateUUID);
+        builder.startObject(METADATA_DIFF_FIELD);
+        {
+            builder.field(COORDINATION_METADATA_UPDATED_FIELD, coordinationMetadataUpdated);
+            builder.field(SETTINGS_METADATA_UPDATED_FIELD, settingsMetadataUpdated);
+            builder.field(TRANSIENT_SETTINGS_METADATA_UPDATED_FIELD, transientSettingsMetadataUpdated);
+            builder.field(TEMPLATES_METADATA_UPDATED_FIELD, templatesMetadataUpdated);
+            builder.startObject(INDICES_DIFF_FIELD);
+            builder.startArray(UPSERTS_FIELD);
+            for (String index : indicesUpdated) {
+                builder.value(index);
+            }
+            builder.endArray();
+            builder.startArray(DELETES_FIELD);
+            for (String index : indicesDeleted) {
+                builder.value(index);
+            }
+            builder.endArray();
+            builder.endObject();
+            builder.startObject(METADATA_CUSTOM_DIFF_FIELD);
+            builder.startArray(UPSERTS_FIELD);
+            for (String custom : customMetadataUpdated) {
+                builder.value(custom);
+            }
+            builder.endArray();
+            builder.startArray(DELETES_FIELD);
+            for (String custom : customMetadataDeleted) {
+                builder.value(custom);
+            }
+            builder.endArray();
+            builder.endObject();
+            builder.field(HASHES_OF_CONSISTENT_SETTINGS_UPDATED_FIELD, hashesOfConsistentSettingsUpdated);
+        }
+        builder.endObject();
+        builder.field(CLUSTER_BLOCKS_UPDATED_FIELD, clusterBlocksUpdated);
+        builder.field(DISCOVERY_NODES_UPDATED_FIELD, discoveryNodesUpdated);
+        builder.startObject(ROUTING_TABLE_DIFF);
+        if (!indicesRoutingUpdated.isEmpty()) {
+            builder.startArray(UPSERTS_FIELD);
+            for (String index : indicesRoutingUpdated) {
+                builder.value(index);
+            }
+            builder.endArray();
+        }
+        if (!indicesRoutingDeleted.isEmpty()) {
+            builder.startArray(DELETES_FIELD);
+            for (String index : indicesRoutingDeleted) {
+                builder.value(index);
+            }
+            builder.endArray();
+        }
+        if (indicesRoutingDiffPath != null) {
+            builder.field(DIFF_FIELD, indicesRoutingDiffPath);
+        }
+        builder.endObject();
+        builder.startObject(CLUSTER_STATE_CUSTOM_DIFF_FIELD);
+        builder.startArray(UPSERTS_FIELD);
+        for (String custom : clusterStateCustomUpdated) {
+            builder.value(custom);
+        }
+        builder.endArray();
+        builder.startArray(DELETES_FIELD);
+        for (String custom : clusterStateCustomDeleted) {
+            builder.value(custom);
+        }
+        builder.endArray();
+        builder.endObject();
+        return builder;
+    }
+
+    public static ClusterStateDiffManifest fromXContent(XContentParser parser, long codec_version) throws IOException {
+        Builder builder = new Builder();
+        if (parser.currentToken() == null) { // fresh parser? move to next token
+            parser.nextToken();
+        }
+        if (parser.currentToken() == XContentParser.Token.START_OBJECT) {
+            parser.nextToken();
+        }
+        ensureExpectedToken(XContentParser.Token.FIELD_NAME, parser.currentToken(), parser);
+        String currentFieldName = parser.currentName();
+        XContentParser.Token token;
+        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+            if (token == XContentParser.Token.FIELD_NAME) {
+                currentFieldName = parser.currentName();
+            } else if (token == XContentParser.Token.START_OBJECT) {
+                if (currentFieldName.equals(METADATA_DIFF_FIELD)) {
+                    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                        currentFieldName = parser.currentName();
+                        token = parser.nextToken();
+                        if (token.isValue()) {
+                            switch (currentFieldName) {
+                                case COORDINATION_METADATA_UPDATED_FIELD:
+                                    builder.coordinationMetadataUpdated(parser.booleanValue());
+                                    break;
+                                case SETTINGS_METADATA_UPDATED_FIELD:
+                                    builder.settingsMetadataUpdated(parser.booleanValue());
+                                    break;
+                                case TRANSIENT_SETTINGS_METADATA_UPDATED_FIELD:
+                                    builder.transientSettingsMetadataUpdate(parser.booleanValue());
+                                    break;
+                                case TEMPLATES_METADATA_UPDATED_FIELD:
+                                    builder.templatesMetadataUpdated(parser.booleanValue());
+                                    break;
+                                case HASHES_OF_CONSISTENT_SETTINGS_UPDATED_FIELD:
+                                    builder.hashesOfConsistentSettingsUpdated(parser.booleanValue());
+                                    break;
+                                default:
+                                    throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                            }
+                        } else if (token == XContentParser.Token.START_OBJECT) {
+                            if (currentFieldName.equals(INDICES_DIFF_FIELD)) {
+                                while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                                    currentFieldName = parser.currentName();
+                                    token = parser.nextToken();
+                                    switch (currentFieldName) {
+                                        case UPSERTS_FIELD:
+                                            builder.indicesUpdated(convertListToString(parser.listOrderedMap()));
+                                            break;
+                                        case DELETES_FIELD:
+                                            builder.indicesDeleted(convertListToString(parser.listOrderedMap()));
+                                            break;
+                                        default:
+                                            throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                                    }
+                                }
+                            } else if (currentFieldName.equals(METADATA_CUSTOM_DIFF_FIELD)) {
+                                while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                                    currentFieldName = parser.currentName();
+                                    token = parser.nextToken();
+                                    switch (currentFieldName) {
+                                        case UPSERTS_FIELD:
+                                            builder.customMetadataUpdated(convertListToString(parser.listOrderedMap()));
+                                            break;
+                                        case DELETES_FIELD:
+                                            builder.customMetadataDeleted(convertListToString(parser.listOrderedMap()));
+                                            break;
+                                        default:
+                                            throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                                    }
+                                }
+                            } else {
+                                throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                            }
+                        } else {
+                            throw new XContentParseException("Unexpected token [" + token + "]");
+                        }
+                    }
+                } else if (currentFieldName.equals(ROUTING_TABLE_DIFF)) {
+                    while ((parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                        currentFieldName = parser.currentName();
+                        parser.nextToken();
+                        switch (currentFieldName) {
+                            case UPSERTS_FIELD:
+                                if (codec_version == CODEC_V2 || codec_version == CODEC_V3) {
+                                    builder.indicesRoutingUpdated(convertListToString(parser.listOrderedMap()));
+                                }
+                                break;
+                            case DELETES_FIELD:
+                                if (codec_version == CODEC_V2 || codec_version == CODEC_V3) {
+                                    builder.indicesRoutingDeleted(convertListToString(parser.listOrderedMap()));
+                                }
+                                break;
+                            case DIFF_FIELD:
+                                if (codec_version >= CODEC_V3) {
+                                    builder.indicesRoutingDiffPath(parser.textOrNull());
+                                }
+                                break;
+                            default:
+                                throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                        }
+                    }
+                } else if (currentFieldName.equals(CLUSTER_STATE_CUSTOM_DIFF_FIELD)) {
+                    while ((parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                        currentFieldName = parser.currentName();
+                        parser.nextToken();
+                        switch (currentFieldName) {
+                            case UPSERTS_FIELD:
+                                builder.clusterStateCustomUpdated(convertListToString(parser.listOrderedMap()));
+                                break;
+                            case DELETES_FIELD:
+                                builder.clusterStateCustomDeleted(convertListToString(parser.listOrderedMap()));
+                                break;
+                            default:
+                                throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                        }
+                    }
+                } else {
+                    throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                }
+            } else if (token.isValue()) {
+                switch (currentFieldName) {
+                    case FROM_STATE_UUID_FIELD:
+                        builder.fromStateUUID(parser.text());
+                        break;
+                    case TO_STATE_UUID_FIELD:
+                        builder.toStateUUID(parser.text());
+                        break;
+                    case CLUSTER_BLOCKS_UPDATED_FIELD:
+                        builder.clusterBlocksUpdated(parser.booleanValue());
+                        break;
+                    case DISCOVERY_NODES_UPDATED_FIELD:
+                        builder.discoveryNodesUpdated(parser.booleanValue());
+                        break;
+                    default:
+                        throw new XContentParseException("Unexpected field [" + currentFieldName + "]");
+                }
+            } else {
+                throw new XContentParseException("Unexpected token [" + token + "]");
+            }
+        }
+        return builder.build();
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(MediaTypeRegistry.JSON, this);
+    }
+
+    private static List<String> convertListToString(List<Object> list) {
+        List<String> convertedList = new ArrayList<>();
+        for (Object o : list) {
+            convertedList.add(o.toString());
+        }
+        return convertedList;
+    }
+
+    public String getFromStateUUID() {
+        return fromStateUUID;
+    }
+
+    public String getToStateUUID() {
+        return toStateUUID;
+    }
+
+    public boolean isCoordinationMetadataUpdated() {
+        return coordinationMetadataUpdated;
+    }
+
+    public boolean isSettingsMetadataUpdated() {
+        return settingsMetadataUpdated;
+    }
+
+    public boolean isTransientSettingsMetadataUpdated() {
+        return transientSettingsMetadataUpdated;
+    }
+
+    public boolean isTemplatesMetadataUpdated() {
+        return templatesMetadataUpdated;
+    }
+
+    public List<String> getCustomMetadataUpdated() {
+        return customMetadataUpdated;
+    }
+
+    public List<String> getCustomMetadataDeleted() {
+        return customMetadataDeleted;
+    }
+
+    public List<String> getIndicesUpdated() {
+        return indicesUpdated;
+    }
+
+    public List<String> getIndicesDeleted() {
+        return indicesDeleted;
+    }
+
+    public boolean isClusterBlocksUpdated() {
+        return clusterBlocksUpdated;
+    }
+
+    public boolean isDiscoveryNodesUpdated() {
+        return discoveryNodesUpdated;
+    }
+
+    public boolean isHashesOfConsistentSettingsUpdated() {
+        return hashesOfConsistentSettingsUpdated;
+    }
+
+    public String getIndicesRoutingDiffPath() {
+        return indicesRoutingDiffPath;
+    }
+
+    public List<String> getIndicesRoutingUpdated() {
+        return indicesRoutingUpdated;
+    }
+
+    public List<String> getIndicesRoutingDeleted() {
+        return indicesRoutingDeleted;
+    }
+
+    public List<String> getClusterStateCustomUpdated() {
+        return clusterStateCustomUpdated;
+    }
+
+    public List<String> getClusterStateCustomDeleted() {
+        return clusterStateCustomDeleted;
+    }
+
+    public void setIndicesRoutingDiffPath(String indicesRoutingDiffPath) {
+        this.indicesRoutingDiffPath = indicesRoutingDiffPath;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ClusterStateDiffManifest that = (ClusterStateDiffManifest) o;
+        return coordinationMetadataUpdated == that.coordinationMetadataUpdated
+            && settingsMetadataUpdated == that.settingsMetadataUpdated
+            && transientSettingsMetadataUpdated == that.transientSettingsMetadataUpdated
+            && templatesMetadataUpdated == that.templatesMetadataUpdated
+            && clusterBlocksUpdated == that.clusterBlocksUpdated
+            && discoveryNodesUpdated == that.discoveryNodesUpdated
+            && hashesOfConsistentSettingsUpdated == that.hashesOfConsistentSettingsUpdated
+            && Objects.equals(fromStateUUID, that.fromStateUUID)
+            && Objects.equals(toStateUUID, that.toStateUUID)
+            && Objects.equals(customMetadataUpdated, that.customMetadataUpdated)
+            && Objects.equals(customMetadataDeleted, that.customMetadataDeleted)
+            && Objects.equals(indicesUpdated, that.indicesUpdated)
+            && Objects.equals(indicesDeleted, that.indicesDeleted)
+            && Objects.equals(indicesRoutingUpdated, that.indicesRoutingUpdated)
+            && Objects.equals(indicesRoutingDeleted, that.indicesRoutingDeleted)
+            && Objects.equals(clusterStateCustomUpdated, that.clusterStateCustomUpdated)
+            && Objects.equals(clusterStateCustomDeleted, that.clusterStateCustomDeleted)
+            && Objects.equals(indicesRoutingDiffPath, that.indicesRoutingDiffPath);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+            fromStateUUID,
+            toStateUUID,
+            coordinationMetadataUpdated,
+            settingsMetadataUpdated,
+            transientSettingsMetadataUpdated,
+            templatesMetadataUpdated,
+            customMetadataUpdated,
+            customMetadataDeleted,
+            indicesUpdated,
+            indicesDeleted,
+            clusterBlocksUpdated,
+            discoveryNodesUpdated,
+            indicesRoutingUpdated,
+            indicesRoutingDeleted,
+            hashesOfConsistentSettingsUpdated,
+            clusterStateCustomUpdated,
+            clusterStateCustomDeleted,
+            indicesRoutingDiffPath
+        );
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(fromStateUUID);
+        out.writeString(toStateUUID);
+        out.writeBoolean(coordinationMetadataUpdated);
+        out.writeBoolean(settingsMetadataUpdated);
+        out.writeBoolean(transientSettingsMetadataUpdated);
+        out.writeBoolean(templatesMetadataUpdated);
+        out.writeStringCollection(indicesUpdated);
+        out.writeStringCollection(indicesDeleted);
+        out.writeStringCollection(customMetadataUpdated);
+        out.writeStringCollection(customMetadataDeleted);
+        out.writeBoolean(clusterBlocksUpdated);
+        out.writeBoolean(discoveryNodesUpdated);
+        out.writeStringCollection(indicesRoutingUpdated);
+        out.writeStringCollection(indicesRoutingDeleted);
+        out.writeBoolean(hashesOfConsistentSettingsUpdated);
+        out.writeStringCollection(clusterStateCustomUpdated);
+        out.writeStringCollection(clusterStateCustomDeleted);
+        out.writeOptionalString(indicesRoutingDiffPath);
+    }
+
+    /**
+     * Builder for ClusterStateDiffManifest
+     *
+     * @opensearch.internal
+     */
+    public static class Builder {
+        private String fromStateUUID;
+        private String toStateUUID;
+        private boolean coordinationMetadataUpdated;
+        private boolean settingsMetadataUpdated;
+        private boolean transientSettingsMetadataUpdated;
+        private boolean templatesMetadataUpdated;
+        private List<String> customMetadataUpdated;
+        private List<String> customMetadataDeleted;
+        private List<String> indicesUpdated;
+        private List<String> indicesDeleted;
+        private boolean clusterBlocksUpdated;
+        private boolean discoveryNodesUpdated;
+        private List<String> indicesRoutingUpdated;
+        private List<String> indicesRoutingDeleted;
+        private String indicesRoutingDiff;
+        private boolean hashesOfConsistentSettingsUpdated;
+        private List<String> clusterStateCustomUpdated;
+        private List<String> clusterStateCustomDeleted;
+
+        public Builder() {
+            customMetadataUpdated = Collections.emptyList();
+            customMetadataDeleted = Collections.emptyList();
+            indicesUpdated = Collections.emptyList();
+            indicesDeleted = Collections.emptyList();
+            indicesRoutingUpdated = Collections.emptyList();
+            indicesRoutingDeleted = Collections.emptyList();
+            clusterStateCustomUpdated = Collections.emptyList();
+            clusterStateCustomDeleted = Collections.emptyList();
+        }
+
+        public Builder fromStateUUID(String fromStateUUID) {
+            this.fromStateUUID = fromStateUUID;
+            return this;
+        }
+
+        public Builder toStateUUID(String toStateUUID) {
+            this.toStateUUID = toStateUUID;
+            return this;
+        }
+
+        public Builder coordinationMetadataUpdated(boolean coordinationMetadataUpdated) {
+            this.coordinationMetadataUpdated = coordinationMetadataUpdated;
+            return this;
+        }
+
+        public Builder settingsMetadataUpdated(boolean settingsMetadataUpdated) {
+            this.settingsMetadataUpdated = settingsMetadataUpdated;
+            return this;
+        }
+
+        public Builder transientSettingsMetadataUpdate(boolean settingsMetadataUpdated) {
+            this.transientSettingsMetadataUpdated = settingsMetadataUpdated;
+            return this;
+        }
+
+        public Builder templatesMetadataUpdated(boolean templatesMetadataUpdated) {
+            this.templatesMetadataUpdated = templatesMetadataUpdated;
+            return this;
+        }
+
+        public Builder hashesOfConsistentSettingsUpdated(boolean hashesOfConsistentSettingsUpdated) {
+            this.hashesOfConsistentSettingsUpdated = hashesOfConsistentSettingsUpdated;
+            return this;
+        }
+
+        public Builder customMetadataUpdated(List<String> customMetadataUpdated) {
+            this.customMetadataUpdated = customMetadataUpdated;
+            return this;
+        }
+
+        public Builder customMetadataDeleted(List<String> customMetadataDeleted) {
+            this.customMetadataDeleted = customMetadataDeleted;
+            return this;
+        }
+
+        public Builder indicesUpdated(List<String> indicesUpdated) {
+            this.indicesUpdated = indicesUpdated;
+            return this;
+        }
+
+        public Builder indicesDeleted(List<String> indicesDeleted) {
+            this.indicesDeleted = indicesDeleted;
+            return this;
+        }
+
+        public Builder clusterBlocksUpdated(boolean clusterBlocksUpdated) {
+            this.clusterBlocksUpdated = clusterBlocksUpdated;
+            return this;
+        }
+
+        public Builder discoveryNodesUpdated(boolean discoveryNodesUpdated) {
+            this.discoveryNodesUpdated = discoveryNodesUpdated;
+            return this;
+        }
+
+        public Builder indicesRoutingDiffPath(String indicesRoutingDiffPath) {
+            this.indicesRoutingDiff = indicesRoutingDiffPath;
+            return this;
+        }
+
+        public Builder indicesRoutingUpdated(List<String> indicesRoutingUpdated) {
+            this.indicesRoutingUpdated = indicesRoutingUpdated;
+            return this;
+        }
+
+        public Builder indicesRoutingDeleted(List<String> indicesRoutingDeleted) {
+            this.indicesRoutingDeleted = indicesRoutingDeleted;
+            return this;
+        }
+
+        public Builder clusterStateCustomUpdated(List<String> clusterStateCustomUpdated) {
+            this.clusterStateCustomUpdated = clusterStateCustomUpdated;
+            return this;
+        }
+
+        public Builder clusterStateCustomDeleted(List<String> clusterStateCustomDeleted) {
+            this.clusterStateCustomDeleted = clusterStateCustomDeleted;
+            return this;
+        }
+
+        public ClusterStateDiffManifest build() {
+            return new ClusterStateDiffManifest(
+                fromStateUUID,
+                toStateUUID,
+                coordinationMetadataUpdated,
+                settingsMetadataUpdated,
+                transientSettingsMetadataUpdated,
+                templatesMetadataUpdated,
+                customMetadataUpdated,
+                customMetadataDeleted,
+                indicesUpdated,
+                indicesDeleted,
+                clusterBlocksUpdated,
+                discoveryNodesUpdated,
+                indicesRoutingUpdated,
+                indicesRoutingDeleted,
+                indicesRoutingDiff,
+                hashesOfConsistentSettingsUpdated,
+                clusterStateCustomUpdated,
+                clusterStateCustomDeleted
+            );
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManager.java
new file mode 100644
index 0000000000000..877e2585cb1eb
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManager.java
@@ -0,0 +1,139 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiffableUtils;
+import org.opensearch.cluster.DiffableUtils.NonDiffableValueSerializer;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.AbstractRemoteWritableEntityManager;
+import org.opensearch.common.remote.RemoteWriteableEntityBlobStore;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.gateway.remote.model.RemoteClusterBlocks;
+import org.opensearch.gateway.remote.model.RemoteClusterStateCustoms;
+import org.opensearch.gateway.remote.model.RemoteDiscoveryNodes;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.util.Collections;
+import java.util.Map;
+
+/**
+ * A Manager which provides APIs to upload and download attributes of ClusterState to the {@link RemoteWriteableEntityBlobStore}
+ *
+ * @opensearch.internal
+ */
+public class RemoteClusterStateAttributesManager extends AbstractRemoteWritableEntityManager {
+    public static final String CLUSTER_STATE_ATTRIBUTE = "cluster_state_attribute";
+    public static final String DISCOVERY_NODES = "nodes";
+    public static final String CLUSTER_BLOCKS = "blocks";
+    public static final int CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION = 1;
+
+    RemoteClusterStateAttributesManager(
+        String clusterName,
+        BlobStoreRepository blobStoreRepository,
+        BlobStoreTransferService blobStoreTransferService,
+        NamedWriteableRegistry namedWriteableRegistry,
+        ThreadPool threadpool
+    ) {
+        this.remoteWritableEntityStores.put(
+            RemoteDiscoveryNodes.DISCOVERY_NODES,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.remoteWritableEntityStores.put(
+            RemoteClusterBlocks.CLUSTER_BLOCKS,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.remoteWritableEntityStores.put(
+            RemoteClusterStateCustoms.CLUSTER_STATE_CUSTOM,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+    }
+
+    @Override
+    protected ActionListener<Void> getWrappedWriteListener(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+    ) {
+        return ActionListener.wrap(
+            resp -> listener.onResponse(remoteEntity.getUploadedMetadata()),
+            ex -> listener.onFailure(new RemoteStateTransferException("Upload failed for " + component, remoteEntity, ex))
+        );
+    }
+
+    @Override
+    protected ActionListener<Object> getWrappedReadListener(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+        ActionListener<RemoteReadResult> listener
+    ) {
+        return ActionListener.wrap(
+            response -> listener.onResponse(new RemoteReadResult(response, CLUSTER_STATE_ATTRIBUTE, component)),
+            ex -> listener.onFailure(new RemoteStateTransferException("Download failed for " + component, remoteEntity, ex))
+        );
+    }
+
+    public DiffableUtils.MapDiff<String, ClusterState.Custom, Map<String, ClusterState.Custom>> getUpdatedCustoms(
+        ClusterState clusterState,
+        ClusterState previousClusterState,
+        boolean isRemotePublicationEnabled,
+        boolean isFirstUpload
+    ) {
+        if (!isRemotePublicationEnabled) {
+            // When isRemotePublicationEnabled is false, we do not want store any custom objects
+            return DiffableUtils.diff(
+                Collections.emptyMap(),
+                Collections.emptyMap(),
+                DiffableUtils.getStringKeySerializer(),
+                NonDiffableValueSerializer.getAbstractInstance()
+            );
+        }
+        if (isFirstUpload) {
+            // For first upload of ephemeral metadata, we want to upload all customs
+            return DiffableUtils.diff(
+                Collections.emptyMap(),
+                clusterState.customs(),
+                DiffableUtils.getStringKeySerializer(),
+                NonDiffableValueSerializer.getAbstractInstance()
+            );
+        }
+        return DiffableUtils.diff(
+            previousClusterState.customs(),
+            clusterState.customs(),
+            DiffableUtils.getStringKeySerializer(),
+            NonDiffableValueSerializer.getAbstractInstance()
+        );
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManager.java
new file mode 100644
index 0000000000000..d9bd9669f138c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManager.java
@@ -0,0 +1,516 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.routing.remote.RemoteRoutingTableService;
+import org.opensearch.cluster.service.ClusterApplierService;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.blobstore.BlobMetadata;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.AbstractAsyncTask;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.Strings;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN;
+import static org.opensearch.gateway.remote.model.RemoteClusterMetadataManifest.MANIFEST;
+import static org.opensearch.gateway.remote.model.RemoteGlobalMetadata.GLOBAL_METADATA_FORMAT;
+
+/**
+ * A Manager which provides APIs to clean up stale cluster state files and runs an async stale cleanup task
+ *
+ * @opensearch.internal
+ */
+public class RemoteClusterStateCleanupManager implements Closeable {
+
+    public static final int RETAINED_MANIFESTS = 10;
+    public static final int SKIP_CLEANUP_STATE_CHANGES = 10;
+    public static final TimeValue CLUSTER_STATE_CLEANUP_INTERVAL_DEFAULT = TimeValue.timeValueMinutes(5);
+    public static final TimeValue CLUSTER_STATE_CLEANUP_INTERVAL_MINIMUM = TimeValue.MINUS_ONE;
+
+    /**
+     * Setting to specify the interval to do run stale file cleanup job
+     * Min value -1 indicates that the stale file cleanup job should be disabled
+     */
+    public static final Setting<TimeValue> REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING = Setting.timeSetting(
+        "cluster.remote_store.state.cleanup_interval",
+        CLUSTER_STATE_CLEANUP_INTERVAL_DEFAULT,
+        CLUSTER_STATE_CLEANUP_INTERVAL_MINIMUM,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+    private static final Logger logger = LogManager.getLogger(RemoteClusterStateCleanupManager.class);
+    private final RemoteClusterStateService remoteClusterStateService;
+    private final RemotePersistenceStats remoteStateStats;
+    private BlobStoreTransferService blobStoreTransferService;
+    private TimeValue staleFileCleanupInterval;
+    private final AtomicBoolean deleteStaleMetadataRunning = new AtomicBoolean(false);
+    private volatile AsyncStaleFileDeletion staleFileDeletionTask;
+    private long lastCleanupAttemptStateVersion;
+    private final ThreadPool threadpool;
+    private final ClusterApplierService clusterApplierService;
+    private RemoteManifestManager remoteManifestManager;
+    private final RemoteRoutingTableService remoteRoutingTableService;
+
+    public RemoteClusterStateCleanupManager(
+        RemoteClusterStateService remoteClusterStateService,
+        ClusterService clusterService,
+        RemoteRoutingTableService remoteRoutingTableService
+    ) {
+        this.remoteClusterStateService = remoteClusterStateService;
+        this.remoteStateStats = remoteClusterStateService.getRemoteStateStats();
+        ClusterSettings clusterSettings = clusterService.getClusterSettings();
+        this.clusterApplierService = clusterService.getClusterApplierService();
+        this.staleFileCleanupInterval = clusterSettings.get(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING);
+        this.threadpool = remoteClusterStateService.getThreadpool();
+        // initialize with 0, a cleanup will be done when this node is elected master node and version is incremented more than threshold
+        this.lastCleanupAttemptStateVersion = 0;
+        clusterSettings.addSettingsUpdateConsumer(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING, this::updateCleanupInterval);
+        this.remoteRoutingTableService = remoteRoutingTableService;
+    }
+
+    void start() {
+        staleFileDeletionTask = new AsyncStaleFileDeletion(this);
+        remoteManifestManager = remoteClusterStateService.getRemoteManifestManager();
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (staleFileDeletionTask != null) {
+            staleFileDeletionTask.close();
+        }
+    }
+
+    private BlobStoreTransferService getBlobStoreTransferService() {
+        if (blobStoreTransferService == null) {
+            blobStoreTransferService = new BlobStoreTransferService(remoteClusterStateService.getBlobStore(), threadpool);
+        }
+        return blobStoreTransferService;
+    }
+
+    private void updateCleanupInterval(TimeValue updatedInterval) {
+        this.staleFileCleanupInterval = updatedInterval;
+        logger.info("updated remote state cleanup interval to {}", updatedInterval);
+        // After updating the interval, we need to close the current task and create a new one which will run with updated interval
+        if (staleFileDeletionTask != null && !staleFileDeletionTask.getInterval().equals(updatedInterval)) {
+            staleFileDeletionTask.setInterval(updatedInterval);
+        }
+    }
+
+    // visible for testing
+    void cleanUpStaleFiles() {
+        ClusterState currentAppliedState = clusterApplierService.state();
+        if (currentAppliedState.nodes().isLocalNodeElectedClusterManager()) {
+            long cleanUpAttemptStateVersion = currentAppliedState.version();
+            assert !Strings.isNullOrEmpty(currentAppliedState.getClusterName().value()) : "cluster name is not set";
+            assert !Strings.isNullOrEmpty(currentAppliedState.metadata().clusterUUID()) : "cluster uuid is not set";
+            if (cleanUpAttemptStateVersion - lastCleanupAttemptStateVersion > SKIP_CLEANUP_STATE_CHANGES) {
+                logger.info(
+                    "Cleaning up stale remote state files for cluster [{}] with uuid [{}]. Last clean was done before {} updates",
+                    currentAppliedState.getClusterName().value(),
+                    currentAppliedState.metadata().clusterUUID(),
+                    cleanUpAttemptStateVersion - lastCleanupAttemptStateVersion
+                );
+                this.deleteStaleClusterMetadata(
+                    currentAppliedState.getClusterName().value(),
+                    currentAppliedState.metadata().clusterUUID(),
+                    RETAINED_MANIFESTS
+                );
+                lastCleanupAttemptStateVersion = cleanUpAttemptStateVersion;
+            } else {
+                logger.debug(
+                    "Skipping cleanup of stale remote state files for cluster [{}] with uuid [{}]. Last clean was done before {} updates, which is less than threshold {}",
+                    currentAppliedState.getClusterName().value(),
+                    currentAppliedState.metadata().clusterUUID(),
+                    cleanUpAttemptStateVersion - lastCleanupAttemptStateVersion,
+                    SKIP_CLEANUP_STATE_CHANGES
+                );
+            }
+        } else {
+            logger.debug("Skipping cleanup task as local node is not elected Cluster Manager");
+        }
+    }
+
+    private void addStaleGlobalMetadataPath(String fileName, Set<String> filesToKeep, Set<String> staleGlobalMetadataPaths) {
+        if (!filesToKeep.contains(fileName)) {
+            String[] splitPath = fileName.split("/");
+            staleGlobalMetadataPaths.add(
+                new BlobPath().add(GLOBAL_METADATA_PATH_TOKEN).buildAsString() + GLOBAL_METADATA_FORMAT.blobName(
+                    splitPath[splitPath.length - 1]
+                )
+            );
+        }
+    }
+
+    // visible for testing
+    void deleteClusterMetadata(
+        String clusterName,
+        String clusterUUID,
+        List<BlobMetadata> activeManifestBlobMetadata,
+        List<BlobMetadata> staleManifestBlobMetadata
+    ) {
+        try {
+            Set<String> filesToKeep = new HashSet<>();
+            Set<String> staleManifestPaths = new HashSet<>();
+            Set<String> staleIndexMetadataPaths = new HashSet<>();
+            Set<String> staleGlobalMetadataPaths = new HashSet<>();
+            Set<String> staleEphemeralAttributePaths = new HashSet<>();
+            Set<String> staleIndexRoutingPaths = new HashSet<>();
+            Set<String> staleIndexRoutingDiffPaths = new HashSet<>();
+            activeManifestBlobMetadata.forEach(blobMetadata -> {
+                ClusterMetadataManifest clusterMetadataManifest = remoteManifestManager.fetchRemoteClusterMetadataManifest(
+                    clusterName,
+                    clusterUUID,
+                    blobMetadata.name()
+                );
+                clusterMetadataManifest.getIndices()
+                    .forEach(
+                        uploadedIndexMetadata -> filesToKeep.add(
+                            RemoteClusterStateUtils.getFormattedIndexFileName(uploadedIndexMetadata.getUploadedFilename())
+                        )
+                    );
+                if (clusterMetadataManifest.getCodecVersion() == ClusterMetadataManifest.CODEC_V1) {
+                    filesToKeep.add(clusterMetadataManifest.getGlobalMetadataFileName());
+                } else if (clusterMetadataManifest.getCodecVersion() >= ClusterMetadataManifest.CODEC_V2) {
+                    filesToKeep.add(clusterMetadataManifest.getCoordinationMetadata().getUploadedFilename());
+                    filesToKeep.add(clusterMetadataManifest.getSettingsMetadata().getUploadedFilename());
+                    filesToKeep.add(clusterMetadataManifest.getTemplatesMetadata().getUploadedFilename());
+                    clusterMetadataManifest.getCustomMetadataMap()
+                        .values()
+                        .forEach(attribute -> filesToKeep.add(attribute.getUploadedFilename()));
+                }
+                if (clusterMetadataManifest.getTransientSettingsMetadata() != null) {
+                    filesToKeep.add(clusterMetadataManifest.getTransientSettingsMetadata().getUploadedFilename());
+                }
+                if (clusterMetadataManifest.getHashesOfConsistentSettings() != null) {
+                    filesToKeep.add(clusterMetadataManifest.getHashesOfConsistentSettings().getUploadedFilename());
+                }
+                if (clusterMetadataManifest.getDiscoveryNodesMetadata() != null) {
+                    filesToKeep.add(clusterMetadataManifest.getDiscoveryNodesMetadata().getUploadedFilename());
+                }
+                if (clusterMetadataManifest.getClusterBlocksMetadata() != null) {
+                    filesToKeep.add(clusterMetadataManifest.getClusterBlocksMetadata().getUploadedFilename());
+                }
+                if (clusterMetadataManifest.getClusterStateCustomMap() != null) {
+                    clusterMetadataManifest.getClusterStateCustomMap()
+                        .values()
+                        .forEach(attribute -> filesToKeep.add(attribute.getUploadedFilename()));
+                }
+                if (clusterMetadataManifest.getIndicesRouting() != null) {
+                    clusterMetadataManifest.getIndicesRouting()
+                        .forEach(uploadedIndicesRouting -> filesToKeep.add(uploadedIndicesRouting.getUploadedFilename()));
+                }
+                if (clusterMetadataManifest.getDiffManifest() != null
+                    && clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath() != null) {
+                    filesToKeep.add(clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath());
+                }
+            });
+            staleManifestBlobMetadata.forEach(blobMetadata -> {
+                ClusterMetadataManifest clusterMetadataManifest = remoteManifestManager.fetchRemoteClusterMetadataManifest(
+                    clusterName,
+                    clusterUUID,
+                    blobMetadata.name()
+                );
+                staleManifestPaths.add(
+                    remoteManifestManager.getManifestFolderPath(clusterName, clusterUUID).buildAsString() + blobMetadata.name()
+                );
+                if (clusterMetadataManifest.getCodecVersion() == ClusterMetadataManifest.CODEC_V1) {
+                    addStaleGlobalMetadataPath(clusterMetadataManifest.getGlobalMetadataFileName(), filesToKeep, staleGlobalMetadataPaths);
+                } else if (clusterMetadataManifest.getCodecVersion() >= ClusterMetadataManifest.CODEC_V2) {
+                    if (filesToKeep.contains(clusterMetadataManifest.getCoordinationMetadata().getUploadedFilename()) == false) {
+                        staleGlobalMetadataPaths.add(clusterMetadataManifest.getCoordinationMetadata().getUploadedFilename());
+                    }
+                    if (filesToKeep.contains(clusterMetadataManifest.getSettingsMetadata().getUploadedFilename()) == false) {
+                        staleGlobalMetadataPaths.add(clusterMetadataManifest.getSettingsMetadata().getUploadedFilename());
+                    }
+                    if (filesToKeep.contains(clusterMetadataManifest.getTemplatesMetadata().getUploadedFilename()) == false) {
+                        staleGlobalMetadataPaths.add(clusterMetadataManifest.getTemplatesMetadata().getUploadedFilename());
+                    }
+                    clusterMetadataManifest.getCustomMetadataMap()
+                        .values()
+                        .stream()
+                        .map(ClusterMetadataManifest.UploadedMetadataAttribute::getUploadedFilename)
+                        .filter(file -> filesToKeep.contains(file) == false)
+                        .forEach(staleGlobalMetadataPaths::add);
+                }
+                if (clusterMetadataManifest.getIndicesRouting() != null) {
+                    clusterMetadataManifest.getIndicesRouting().forEach(uploadedIndicesRouting -> {
+                        if (!filesToKeep.contains(uploadedIndicesRouting.getUploadedFilename())) {
+                            staleIndexRoutingPaths.add(uploadedIndicesRouting.getUploadedFilename());
+                            logger.debug(
+                                () -> new ParameterizedMessage(
+                                    "Indices routing paths in stale manifest: {}",
+                                    uploadedIndicesRouting.getUploadedFilename()
+                                )
+                            );
+                        }
+                    });
+                }
+                if (clusterMetadataManifest.getDiffManifest() != null
+                    && clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath() != null) {
+                    if (!filesToKeep.contains(clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath())) {
+                        staleIndexRoutingDiffPaths.add(clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath());
+                        logger.debug(
+                            () -> new ParameterizedMessage(
+                                "Indices routing diff paths in stale manifest: {}",
+                                clusterMetadataManifest.getDiffManifest().getIndicesRoutingDiffPath()
+                            )
+                        );
+                    }
+                }
+
+                clusterMetadataManifest.getIndices().forEach(uploadedIndexMetadata -> {
+                    String fileName = RemoteClusterStateUtils.getFormattedIndexFileName(uploadedIndexMetadata.getUploadedFilename());
+                    if (filesToKeep.contains(fileName) == false) {
+                        staleIndexMetadataPaths.add(fileName);
+                    }
+                });
+
+                if (clusterMetadataManifest.getClusterBlocksMetadata() != null
+                    && !filesToKeep.contains(clusterMetadataManifest.getClusterBlocksMetadata().getUploadedFilename())) {
+                    staleEphemeralAttributePaths.add(clusterMetadataManifest.getClusterBlocksMetadata().getUploadedFilename());
+                }
+                if (clusterMetadataManifest.getDiscoveryNodesMetadata() != null
+                    && !filesToKeep.contains(clusterMetadataManifest.getDiscoveryNodesMetadata().getUploadedFilename())) {
+                    staleEphemeralAttributePaths.add(clusterMetadataManifest.getDiscoveryNodesMetadata().getUploadedFilename());
+                }
+                if (clusterMetadataManifest.getTransientSettingsMetadata() != null
+                    && !filesToKeep.contains(clusterMetadataManifest.getTransientSettingsMetadata().getUploadedFilename())) {
+                    staleEphemeralAttributePaths.add(clusterMetadataManifest.getTransientSettingsMetadata().getUploadedFilename());
+                }
+                if (clusterMetadataManifest.getHashesOfConsistentSettings() != null
+                    && !filesToKeep.contains(clusterMetadataManifest.getHashesOfConsistentSettings().getUploadedFilename())) {
+                    staleEphemeralAttributePaths.add(clusterMetadataManifest.getHashesOfConsistentSettings().getUploadedFilename());
+                }
+                if (clusterMetadataManifest.getClusterStateCustomMap() != null) {
+                    clusterMetadataManifest.getCustomMetadataMap()
+                        .values()
+                        .stream()
+                        .filter(u -> !filesToKeep.contains(u.getUploadedFilename()))
+                        .forEach(attribute -> staleEphemeralAttributePaths.add(attribute.getUploadedFilename()));
+                }
+
+            });
+
+            if (staleManifestPaths.isEmpty()) {
+                logger.debug("No stale Remote Cluster Metadata files found");
+                return;
+            }
+
+            deleteStalePaths(new ArrayList<>(staleGlobalMetadataPaths));
+            deleteStalePaths(new ArrayList<>(staleIndexMetadataPaths));
+            deleteStalePaths(new ArrayList<>(staleEphemeralAttributePaths));
+            deleteStalePaths(new ArrayList<>(staleManifestPaths));
+            try {
+                remoteRoutingTableService.deleteStaleIndexRoutingPaths(new ArrayList<>(staleIndexRoutingPaths));
+            } catch (IOException e) {
+                logger.error(
+                    () -> new ParameterizedMessage("Error while deleting stale index routing files {}", staleIndexRoutingPaths),
+                    e
+                );
+                remoteStateStats.indexRoutingFilesCleanupAttemptFailed();
+            }
+            try {
+                remoteRoutingTableService.deleteStaleIndexRoutingDiffPaths(new ArrayList<>(staleIndexRoutingDiffPaths));
+            } catch (IOException e) {
+                logger.error(
+                    () -> new ParameterizedMessage("Error while deleting stale index routing diff files {}", staleIndexRoutingDiffPaths),
+                    e
+                );
+                remoteStateStats.indicesRoutingDiffFileCleanupAttemptFailed();
+            }
+        } catch (IllegalStateException e) {
+            logger.error("Error while fetching Remote Cluster Metadata manifests", e);
+        } catch (IOException e) {
+            logger.error("Error while deleting stale Remote Cluster Metadata files", e);
+            remoteStateStats.cleanUpAttemptFailed();
+        } catch (Exception e) {
+            logger.error("Unexpected error while deleting stale Remote Cluster Metadata files", e);
+            remoteStateStats.cleanUpAttemptFailed();
+        }
+    }
+
+    /**
+     * Deletes older than last {@code versionsToRetain} manifests. Also cleans up unreferenced IndexMetadata associated with older manifests
+     *
+     * @param clusterName name of the cluster
+     * @param clusterUUID uuid of cluster state to refer to in remote
+     * @param manifestsToRetain no of latest manifest files to keep in remote
+     */
+    // package private for testing
+    void deleteStaleClusterMetadata(String clusterName, String clusterUUID, int manifestsToRetain) {
+        if (deleteStaleMetadataRunning.compareAndSet(false, true) == false) {
+            logger.info("Delete stale cluster metadata task is already in progress.");
+            return;
+        }
+        try {
+            getBlobStoreTransferService().listAllInSortedOrderAsync(
+                ThreadPool.Names.REMOTE_PURGE,
+                remoteManifestManager.getManifestFolderPath(clusterName, clusterUUID),
+                MANIFEST,
+                Integer.MAX_VALUE,
+                new ActionListener<>() {
+                    @Override
+                    public void onResponse(List<BlobMetadata> blobMetadata) {
+                        if (blobMetadata.size() > manifestsToRetain) {
+                            deleteClusterMetadata(
+                                clusterName,
+                                clusterUUID,
+                                blobMetadata.subList(0, manifestsToRetain),
+                                blobMetadata.subList(manifestsToRetain, blobMetadata.size())
+                            );
+                        }
+                        deleteStaleMetadataRunning.set(false);
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        logger.error(
+                            new ParameterizedMessage(
+                                "Exception occurred while deleting Remote Cluster Metadata for clusterUUIDs {}",
+                                clusterUUID
+                            )
+                        );
+                        deleteStaleMetadataRunning.set(false);
+                    }
+                }
+            );
+        } catch (Exception e) {
+            deleteStaleMetadataRunning.set(false);
+            throw e;
+        }
+    }
+
+    /**
+     * Purges all remote cluster state against provided cluster UUIDs
+     *
+     * @param clusterName name of the cluster
+     * @param clusterUUIDs clusteUUIDs for which the remote state needs to be purged
+     */
+    void deleteStaleUUIDsClusterMetadata(String clusterName, List<String> clusterUUIDs) {
+        clusterUUIDs.forEach(
+            clusterUUID -> getBlobStoreTransferService().deleteAsync(
+                ThreadPool.Names.REMOTE_PURGE,
+                RemoteClusterStateUtils.getClusterMetadataBasePath(
+                    remoteClusterStateService.getBlobStoreRepository(),
+                    clusterName,
+                    clusterUUID
+                ),
+                new ActionListener<>() {
+                    @Override
+                    public void onResponse(Void unused) {
+                        logger.info("Deleted all remote cluster metadata for cluster UUID - {}", clusterUUID);
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        logger.error(
+                            new ParameterizedMessage(
+                                "Exception occurred while deleting all remote cluster metadata for cluster UUID {}",
+                                clusterUUID
+                            ),
+                            e
+                        );
+                        remoteStateStats.cleanUpAttemptFailed();
+                    }
+                }
+            )
+        );
+    }
+
+    // package private for testing
+    void deleteStalePaths(List<String> stalePaths) throws IOException {
+        logger.debug(String.format(Locale.ROOT, "Deleting stale files from remote - %s", stalePaths));
+        getBlobStoreTransferService().deleteBlobs(BlobPath.cleanPath(), stalePaths);
+    }
+
+    /**
+     * Purges all remote cluster state against provided cluster UUIDs
+     * @param clusterState current state of the cluster
+     * @param committedManifest last committed ClusterMetadataManifest
+     */
+    public void deleteStaleClusterUUIDs(ClusterState clusterState, ClusterMetadataManifest committedManifest) {
+        threadpool.executor(ThreadPool.Names.REMOTE_PURGE).execute(() -> {
+            String clusterName = clusterState.getClusterName().value();
+            logger.debug("Deleting stale cluster UUIDs data from remote [{}]", clusterName);
+            Set<String> allClustersUUIDsInRemote;
+            try {
+                allClustersUUIDsInRemote = new HashSet<>(
+                    remoteClusterStateService.getAllClusterUUIDs(clusterState.getClusterName().value())
+                );
+            } catch (IOException e) {
+                logger.info(String.format(Locale.ROOT, "Error while fetching all cluster UUIDs for [%s]", clusterName));
+                return;
+            }
+            // Retain last 2 cluster uuids data
+            allClustersUUIDsInRemote.remove(committedManifest.getClusterUUID());
+            allClustersUUIDsInRemote.remove(committedManifest.getPreviousClusterUUID());
+            deleteStaleUUIDsClusterMetadata(clusterName, new ArrayList<>(allClustersUUIDsInRemote));
+        });
+    }
+
+    public TimeValue getStaleFileCleanupInterval() {
+        return this.staleFileCleanupInterval;
+    }
+
+    AsyncStaleFileDeletion getStaleFileDeletionTask() { // for testing
+        return this.staleFileDeletionTask;
+    }
+
+    RemotePersistenceStats getStats() {
+        return this.remoteStateStats;
+    }
+
+    static final class AsyncStaleFileDeletion extends AbstractAsyncTask {
+        private final RemoteClusterStateCleanupManager remoteClusterStateCleanupManager;
+
+        AsyncStaleFileDeletion(RemoteClusterStateCleanupManager remoteClusterStateCleanupManager) {
+            super(
+                logger,
+                remoteClusterStateCleanupManager.threadpool,
+                remoteClusterStateCleanupManager.getStaleFileCleanupInterval(),
+                true
+            );
+            this.remoteClusterStateCleanupManager = remoteClusterStateCleanupManager;
+            rescheduleIfNecessary();
+        }
+
+        @Override
+        protected boolean mustReschedule() {
+            return true;
+        }
+
+        @Override
+        protected void runInternal() {
+            remoteClusterStateCleanupManager.cleanUpStaleFiles();
+        }
+
+        @Override
+        protected String getThreadPool() {
+            return ThreadPool.Names.REMOTE_PURGE;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
index eaf607564185c..a223bfbe736c3 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateService.java
@@ -11,59 +11,107 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.opensearch.Version;
 import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.DiffableUtils;
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.coordination.PersistedStateStats;
+import org.opensearch.cluster.metadata.DiffableStringMap;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.Metadata.XContentContext;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.node.DiscoveryNodes.Builder;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.cluster.routing.remote.RemoteRoutingTableService;
+import org.opensearch.cluster.routing.remote.RemoteRoutingTableServiceFactory;
+import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.blobstore.BlobContainer;
-import org.opensearch.common.blobstore.BlobMetadata;
-import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.BlobStore;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.action.ActionListener;
-import org.opensearch.core.index.Index;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedIndexMetadata;
-import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.gateway.remote.model.RemoteClusterBlocks;
+import org.opensearch.gateway.remote.model.RemoteClusterStateCustoms;
+import org.opensearch.gateway.remote.model.RemoteClusterStateManifestInfo;
+import org.opensearch.gateway.remote.model.RemoteCoordinationMetadata;
+import org.opensearch.gateway.remote.model.RemoteCustomMetadata;
+import org.opensearch.gateway.remote.model.RemoteDiscoveryNodes;
+import org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings;
+import org.opensearch.gateway.remote.model.RemoteIndexMetadata;
+import org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.gateway.remote.model.RemoteTemplatesMetadata;
+import org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata;
+import org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff;
 import org.opensearch.index.translog.transfer.BlobStoreTransferService;
 import org.opensearch.node.Node;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
-import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.Closeable;
 import java.io.IOException;
-import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
-import java.util.Base64;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+import static org.opensearch.cluster.ClusterState.CUSTOM_VALUE_SERIALIZER;
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
 import static org.opensearch.gateway.PersistedClusterStateService.SLOW_WRITE_LOGGING_THRESHOLD;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V2;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V3;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.MANIFEST_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_BLOCKS;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTE;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.DISCOVERY_NODES;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.UploadedMetadataResults;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.clusterUUIDContainer;
+import static org.opensearch.gateway.remote.model.RemoteClusterStateCustoms.CLUSTER_STATE_CUSTOM;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_DELIMITER;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled;
 
 /**
@@ -73,88 +121,71 @@
  */
 public class RemoteClusterStateService implements Closeable {
 
-    public static final String METADATA_NAME_FORMAT = "%s.dat";
-
-    public static final String METADATA_MANIFEST_NAME_FORMAT = "%s";
-
-    public static final int RETAINED_MANIFESTS = 10;
-
-    public static final String DELIMITER = "__";
-
     private static final Logger logger = LogManager.getLogger(RemoteClusterStateService.class);
 
-    public static final TimeValue INDEX_METADATA_UPLOAD_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
-
-    public static final TimeValue GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
-
-    public static final TimeValue METADATA_MANIFEST_UPLOAD_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
-
-    public static final Setting<TimeValue> INDEX_METADATA_UPLOAD_TIMEOUT_SETTING = Setting.timeSetting(
-        "cluster.remote_store.state.index_metadata.upload_timeout",
-        INDEX_METADATA_UPLOAD_TIMEOUT_DEFAULT,
-        Setting.Property.Dynamic,
-        Setting.Property.NodeScope
+    /**
+     * Used to specify if cluster state metadata should be published to remote store
+     */
+    public static final Setting<Boolean> REMOTE_CLUSTER_STATE_ENABLED_SETTING = Setting.boolSetting(
+        "cluster.remote_store.state.enabled",
+        false,
+        Property.NodeScope,
+        Property.Final
     );
 
-    public static final Setting<TimeValue> GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING = Setting.timeSetting(
-        "cluster.remote_store.state.global_metadata.upload_timeout",
-        GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT,
+    public static final TimeValue REMOTE_STATE_READ_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
+
+    public static final Setting<TimeValue> REMOTE_STATE_READ_TIMEOUT_SETTING = Setting.timeSetting(
+        "cluster.remote_store.state.read_timeout",
+        REMOTE_STATE_READ_TIMEOUT_DEFAULT,
         Setting.Property.Dynamic,
         Setting.Property.NodeScope
     );
 
-    public static final Setting<TimeValue> METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING = Setting.timeSetting(
-        "cluster.remote_store.state.metadata_manifest.upload_timeout",
-        METADATA_MANIFEST_UPLOAD_TIMEOUT_DEFAULT,
+    public static final Setting<RemoteClusterStateValidationMode> REMOTE_CLUSTER_STATE_CHECKSUM_VALIDATION_MODE_SETTING = new Setting<>(
+        "cluster.remote_store.state.checksum_validation.mode",
+        RemoteClusterStateValidationMode.NONE.name(),
+        RemoteClusterStateValidationMode::parseString,
         Setting.Property.Dynamic,
         Setting.Property.NodeScope
     );
 
-    public static final ChecksumBlobStoreFormat<IndexMetadata> INDEX_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
-        "index-metadata",
-        METADATA_NAME_FORMAT,
-        IndexMetadata::fromXContent
-    );
-
-    public static final ChecksumBlobStoreFormat<Metadata> GLOBAL_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
-        "metadata",
-        METADATA_NAME_FORMAT,
-        Metadata::fromXContent
-    );
-
     /**
-     * Manifest format compatible with older codec v0, where codec version was missing.
+     * Validation mode for cluster state checksum.
+     *  None: Validation will be disabled.
+     *  Debug: Validation enabled but only matches checksum and logs failing entities.
+     *  Trace: Matches checksum and downloads full cluster state to find diff in failing entities. Only logs failures.
+     *  Failure: Throws exception on failing validation.
      */
-    public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT_V0 =
-        new ChecksumBlobStoreFormat<>("cluster-metadata-manifest", METADATA_MANIFEST_NAME_FORMAT, ClusterMetadataManifest::fromXContentV0);
+    public enum RemoteClusterStateValidationMode {
+        DEBUG("debug"),
+        TRACE("trace"),
+        FAILURE("failure"),
+        NONE("none");
 
-    /**
-     * Manifest format compatible with codec v1, where we introduced codec versions/global metadata.
-     */
-    public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT = new ChecksumBlobStoreFormat<>(
-        "cluster-metadata-manifest",
-        METADATA_MANIFEST_NAME_FORMAT,
-        ClusterMetadataManifest::fromXContent
-    );
+        public final String mode;
 
-    /**
-     * Used to specify if cluster state metadata should be published to remote store
-     */
-    public static final Setting<Boolean> REMOTE_CLUSTER_STATE_ENABLED_SETTING = Setting.boolSetting(
-        "cluster.remote_store.state.enabled",
-        false,
-        Property.NodeScope,
-        Property.Final
-    );
+        RemoteClusterStateValidationMode(String mode) {
+            this.mode = mode;
+        }
 
-    public static final String CLUSTER_STATE_PATH_TOKEN = "cluster-state";
-    public static final String INDEX_PATH_TOKEN = "index";
-    public static final String GLOBAL_METADATA_PATH_TOKEN = "global-metadata";
-    public static final String MANIFEST_PATH_TOKEN = "manifest";
-    public static final String MANIFEST_FILE_PREFIX = "manifest";
-    public static final String METADATA_FILE_PREFIX = "metadata";
-    public static final int SPLITED_MANIFEST_FILE_LENGTH = 6; // file name manifest__term__version__C/P__timestamp__codecversion
+        public static RemoteClusterStateValidationMode parseString(String mode) {
+            try {
+                return RemoteClusterStateValidationMode.valueOf(mode.toUpperCase(Locale.ROOT));
+            } catch (IllegalArgumentException e) {
+                throw new IllegalArgumentException(
+                    "["
+                        + mode
+                        + "] mode is not supported. "
+                        + "supported modes are ["
+                        + Arrays.toString(RemoteClusterStateValidationMode.values())
+                        + "]"
+                );
+            }
+        }
+    }
 
+    private TimeValue remoteStateReadTimeout;
     private final String nodeId;
     private final Supplier<RepositoriesService> repositoriesService;
     private final Settings settings;
@@ -163,17 +194,23 @@ public class RemoteClusterStateService implements Closeable {
     private final List<IndexMetadataUploadListener> indexMetadataUploadListeners;
     private BlobStoreRepository blobStoreRepository;
     private BlobStoreTransferService blobStoreTransferService;
+    private RemoteRoutingTableService remoteRoutingTableService;
     private volatile TimeValue slowWriteLoggingThreshold;
+    private RemoteClusterStateValidationMode remoteClusterStateValidationMode;
 
-    private volatile TimeValue indexMetadataUploadTimeout;
-    private volatile TimeValue globalMetadataUploadTimeout;
-    private volatile TimeValue metadataManifestUploadTimeout;
-
-    private final AtomicBoolean deleteStaleMetadataRunning = new AtomicBoolean(false);
     private final RemotePersistenceStats remoteStateStats;
-    public static final int INDEX_METADATA_CURRENT_CODEC_VERSION = 1;
-    public static final int MANIFEST_CURRENT_CODEC_VERSION = ClusterMetadataManifest.CODEC_V1;
-    public static final int GLOBAL_METADATA_CURRENT_CODEC_VERSION = 1;
+    private RemoteClusterStateCleanupManager remoteClusterStateCleanupManager;
+    private RemoteIndexMetadataManager remoteIndexMetadataManager;
+    private RemoteGlobalMetadataManager remoteGlobalMetadataManager;
+    private RemoteClusterStateAttributesManager remoteClusterStateAttributesManager;
+    private RemoteManifestManager remoteManifestManager;
+    private ClusterSettings clusterSettings;
+    private final NamedWriteableRegistry namedWriteableRegistry;
+    private final String CLUSTER_STATE_UPLOAD_TIME_LOG_STRING = "writing cluster state for version [{}] took [{}ms]";
+    private final String METADATA_UPDATE_LOG_STRING = "wrote metadata for [{}] indices and skipped [{}] unchanged "
+        + "indices, coordination metadata updated : [{}], settings metadata updated : [{}], templates metadata "
+        + "updated : [{}], custom metadata updated : [{}], indices routing updated : [{}]";
+    private final boolean isPublicationEnabled;
 
     // ToXContent Params with gateway mode.
     // We are using gateway context mode to persist all custom metadata.
@@ -189,10 +226,11 @@ public RemoteClusterStateService(
         String nodeId,
         Supplier<RepositoriesService> repositoriesService,
         Settings settings,
-        ClusterSettings clusterSettings,
+        ClusterService clusterService,
         LongSupplier relativeTimeNanosSupplier,
         ThreadPool threadPool,
-        List<IndexMetadataUploadListener> indexMetadataUploadListeners
+        List<IndexMetadataUploadListener> indexMetadataUploadListeners,
+        NamedWriteableRegistry namedWriteableRegistry
     ) {
         assert isRemoteStoreClusterStateEnabled(settings) : "Remote cluster state is not enabled";
         this.nodeId = nodeId;
@@ -200,23 +238,28 @@ public RemoteClusterStateService(
         this.settings = settings;
         this.relativeTimeNanosSupplier = relativeTimeNanosSupplier;
         this.threadpool = threadPool;
+        clusterSettings = clusterService.getClusterSettings();
         this.slowWriteLoggingThreshold = clusterSettings.get(SLOW_WRITE_LOGGING_THRESHOLD);
-        this.indexMetadataUploadTimeout = clusterSettings.get(INDEX_METADATA_UPLOAD_TIMEOUT_SETTING);
-        this.globalMetadataUploadTimeout = clusterSettings.get(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING);
-        this.metadataManifestUploadTimeout = clusterSettings.get(METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING);
         clusterSettings.addSettingsUpdateConsumer(SLOW_WRITE_LOGGING_THRESHOLD, this::setSlowWriteLoggingThreshold);
-        clusterSettings.addSettingsUpdateConsumer(INDEX_METADATA_UPLOAD_TIMEOUT_SETTING, this::setIndexMetadataUploadTimeout);
-        clusterSettings.addSettingsUpdateConsumer(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING, this::setGlobalMetadataUploadTimeout);
-        clusterSettings.addSettingsUpdateConsumer(METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING, this::setMetadataManifestUploadTimeout);
+        this.remoteStateReadTimeout = clusterSettings.get(REMOTE_STATE_READ_TIMEOUT_SETTING);
+        clusterSettings.addSettingsUpdateConsumer(REMOTE_STATE_READ_TIMEOUT_SETTING, this::setRemoteStateReadTimeout);
+        this.remoteClusterStateValidationMode = REMOTE_CLUSTER_STATE_CHECKSUM_VALIDATION_MODE_SETTING.get(settings);
+        clusterSettings.addSettingsUpdateConsumer(REMOTE_CLUSTER_STATE_CHECKSUM_VALIDATION_MODE_SETTING, this::setChecksumValidationMode);
+
         this.remoteStateStats = new RemotePersistenceStats();
+        this.namedWriteableRegistry = namedWriteableRegistry;
         this.indexMetadataUploadListeners = indexMetadataUploadListeners;
-    }
-
-    private BlobStoreTransferService getBlobStoreTransferService() {
-        if (blobStoreTransferService == null) {
-            blobStoreTransferService = new BlobStoreTransferService(blobStoreRepository.blobStore(), threadpool);
-        }
-        return blobStoreTransferService;
+        this.isPublicationEnabled = FeatureFlags.isEnabled(REMOTE_PUBLICATION_EXPERIMENTAL)
+            && RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled(settings)
+            && RemoteStoreNodeAttribute.isRemoteRoutingTableEnabled(settings);
+        this.remoteRoutingTableService = RemoteRoutingTableServiceFactory.getService(
+            repositoriesService,
+            settings,
+            clusterSettings,
+            threadpool,
+            ClusterName.CLUSTER_NAME_SETTING.get(settings).value()
+        );
+        remoteClusterStateCleanupManager = new RemoteClusterStateCleanupManager(this, clusterService, remoteRoutingTableService);
     }
 
     /**
@@ -226,49 +269,69 @@ private BlobStoreTransferService getBlobStoreTransferService() {
      * @return A manifest object which contains the details of uploaded entity metadata.
      */
     @Nullable
-    public ClusterMetadataManifest writeFullMetadata(ClusterState clusterState, String previousClusterUUID) throws IOException {
+    public RemoteClusterStateManifestInfo writeFullMetadata(ClusterState clusterState, String previousClusterUUID, int codecVersion)
+        throws IOException {
         final long startTimeNanos = relativeTimeNanosSupplier.getAsLong();
         if (clusterState.nodes().isLocalNodeElectedClusterManager() == false) {
             logger.error("Local node is not elected cluster manager. Exiting");
             return null;
         }
 
-        // TODO: we can upload global metadata and index metadata in parallel. [issue: #10645]
-        // Write globalMetadata
-        String globalMetadataFile = writeGlobalMetadata(clusterState);
+        UploadedMetadataResults uploadedMetadataResults = writeMetadataInParallel(
+            clusterState,
+            new ArrayList<>(clusterState.metadata().indices().values()),
+            emptyMap(),
+            RemoteGlobalMetadataManager.filterCustoms(clusterState.metadata().customs(), isPublicationEnabled),
+            true,
+            true,
+            true,
+            isPublicationEnabled,
+            isPublicationEnabled,
+            isPublicationEnabled,
+            isPublicationEnabled ? clusterState.customs() : Collections.emptyMap(),
+            isPublicationEnabled,
+            remoteRoutingTableService.getIndicesRouting(clusterState.getRoutingTable()),
+            null
+        );
 
-        List<IndexMetadata> toUpload = new ArrayList<>(clusterState.metadata().indices().values());
-        // any validations before/after upload ?
-        final List<UploadedIndexMetadata> allUploadedIndexMetadata = writeIndexMetadataParallel(
+        ClusterStateDiffManifest clusterStateDiffManifest = new ClusterStateDiffManifest(
             clusterState,
-            toUpload,
-            Collections.emptyMap()
+            ClusterState.EMPTY_STATE,
+            MANIFEST_CURRENT_CODEC_VERSION,
+            null,
+            null
         );
-        final ClusterMetadataManifest manifest = uploadManifest(
+        final RemoteClusterStateManifestInfo manifestDetails = remoteManifestManager.uploadManifest(
             clusterState,
-            allUploadedIndexMetadata,
+            uploadedMetadataResults,
             previousClusterUUID,
-            globalMetadataFile,
-            false
+            clusterStateDiffManifest,
+            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE) ? new ClusterStateChecksum(clusterState) : null,
+            false,
+            codecVersion
         );
+
         final long durationMillis = TimeValue.nsecToMSec(relativeTimeNanosSupplier.getAsLong() - startTimeNanos);
-        remoteStateStats.stateSucceeded();
-        remoteStateStats.stateTook(durationMillis);
+        remoteStateStats.stateUploadSucceeded();
+        remoteStateStats.stateUploadTook(durationMillis);
         if (durationMillis >= slowWriteLoggingThreshold.getMillis()) {
             logger.warn(
-                "writing cluster state took [{}ms] which is above the warn threshold of [{}]; " + "wrote full state with [{}] indices",
+                "writing cluster state took [{}ms] which is above the warn threshold of [{}]; "
+                    + "wrote full state with [{}] indices and [{}] indicesRouting",
                 durationMillis,
                 slowWriteLoggingThreshold,
-                allUploadedIndexMetadata.size()
+                uploadedMetadataResults.uploadedIndexMetadata.size(),
+                uploadedMetadataResults.uploadedIndicesRoutingMetadata.size()
             );
         } else {
-            logger.info(
-                "writing cluster state took [{}ms]; " + "wrote full state with [{}] indices and global metadata",
+            logger.debug(
+                "writing cluster state took [{}ms]; " + "wrote full state with [{}] indices, [{}] indicesRouting and global metadata",
                 durationMillis,
-                allUploadedIndexMetadata.size()
+                uploadedMetadataResults.uploadedIndexMetadata.size(),
+                uploadedMetadataResults.uploadedIndicesRoutingMetadata.size()
             );
         }
-        return manifest;
+        return manifestDetails;
     }
 
     /**
@@ -276,14 +339,16 @@ public ClusterMetadataManifest writeFullMetadata(ClusterState clusterState, Stri
      * manifest. The new manifest file is created by using the unchanged metadata from the previous manifest and the new metadata changes from the current
      * cluster state.
      *
-     * @return The uploaded ClusterMetadataManifest file
+     * @return {@link RemoteClusterStateManifestInfo} object containing uploaded manifest detail
      */
     @Nullable
-    public ClusterMetadataManifest writeIncrementalMetadata(
+    public RemoteClusterStateManifestInfo writeIncrementalMetadata(
         ClusterState previousClusterState,
         ClusterState clusterState,
         ClusterMetadataManifest previousManifest
     ) throws IOException {
+        logger.trace("WRITING INCREMENTAL STATE");
+
         final long startTimeNanos = relativeTimeNanosSupplier.getAsLong();
         if (clusterState.nodes().isLocalNodeElectedClusterManager() == false) {
             logger.error("Local node is not elected cluster manager. Exiting");
@@ -291,27 +356,17 @@ public ClusterMetadataManifest writeIncrementalMetadata(
         }
         assert previousClusterState.metadata().coordinationMetadata().term() == clusterState.metadata().coordinationMetadata().term();
 
-        // Write Global Metadata
-        final boolean updateGlobalMetadata = Metadata.isGlobalStateEquals(
-            previousClusterState.metadata(),
-            clusterState.metadata()
-        ) == false;
-        String globalMetadataFile;
-        // For migration case from codec V0 to V1, we have added null check on global metadata file,
-        // If file is empty and codec is 1 then write global metadata.
-        if (updateGlobalMetadata || previousManifest.getGlobalMetadataFileName() == null) {
-            globalMetadataFile = writeGlobalMetadata(clusterState);
-        } else {
-            logger.debug("Global metadata has not updated in cluster state, skipping upload of it");
-            globalMetadataFile = previousManifest.getGlobalMetadataFileName();
-        }
-
-        // Write Index Metadata
-        final Map<String, IndexMetadata> previousStateIndexMetadataByName = new HashMap<>();
-        for (final IndexMetadata indexMetadata : previousClusterState.metadata().indices().values()) {
-            previousStateIndexMetadataByName.put(indexMetadata.getIndex().getName(), indexMetadata);
-        }
+        boolean firstUploadForSplitGlobalMetadata = !previousManifest.hasMetadataAttributesFiles();
 
+        final DiffableUtils.MapDiff<String, Metadata.Custom, Map<String, Metadata.Custom>> customsDiff = remoteGlobalMetadataManager
+            .getCustomsDiff(clusterState, previousClusterState, firstUploadForSplitGlobalMetadata, isPublicationEnabled);
+        final DiffableUtils.MapDiff<String, ClusterState.Custom, Map<String, ClusterState.Custom>> clusterStateCustomsDiff =
+            remoteClusterStateAttributesManager.getUpdatedCustoms(clusterState, previousClusterState, isPublicationEnabled, false);
+        final Map<String, UploadedMetadataAttribute> allUploadedCustomMap = new HashMap<>(previousManifest.getCustomMetadataMap());
+        final Map<String, UploadedMetadataAttribute> allUploadedClusterStateCustomsMap = new HashMap<>(
+            previousManifest.getClusterStateCustomMap()
+        );
+        final Map<String, IndexMetadata> indicesToBeDeletedFromRemote = new HashMap<>(previousClusterState.metadata().indices());
         int numIndicesUpdated = 0;
         int numIndicesUnchanged = 0;
         final Map<String, ClusterMetadataManifest.UploadedIndexMetadata> allUploadedIndexMetadata = previousManifest.getIndices()
@@ -323,7 +378,7 @@ public ClusterMetadataManifest writeIncrementalMetadata(
         Map<String, IndexMetadata> prevIndexMetadataByName = new HashMap<>();
         for (final IndexMetadata indexMetadata : clusterState.metadata().indices().values()) {
             String indexName = indexMetadata.getIndex().getName();
-            final IndexMetadata prevIndexMetadata = previousStateIndexMetadataByName.get(indexName);
+            final IndexMetadata prevIndexMetadata = indicesToBeDeletedFromRemote.get(indexName);
             Long previousVersion = prevIndexMetadata != null ? prevIndexMetadata.getVersion() : null;
             if (previousVersion == null || indexMetadata.getVersion() != previousVersion) {
                 logger.debug(
@@ -338,138 +393,215 @@ public ClusterMetadataManifest writeIncrementalMetadata(
             } else {
                 numIndicesUnchanged++;
             }
-            previousStateIndexMetadataByName.remove(indexMetadata.getIndex().getName());
+            // index present in current cluster state
+            indicesToBeDeletedFromRemote.remove(indexMetadata.getIndex().getName());
         }
 
-        List<UploadedIndexMetadata> uploadedIndexMetadataList = writeIndexMetadataParallel(clusterState, toUpload, prevIndexMetadataByName);
-        uploadedIndexMetadataList.forEach(
-            uploadedIndexMetadata -> allUploadedIndexMetadata.put(uploadedIndexMetadata.getIndexName(), uploadedIndexMetadata)
+        final List<IndexRoutingTable> indicesRoutingToUpload = new ArrayList<>();
+        final List<String> deletedIndicesRouting = new ArrayList<>();
+        final StringKeyDiffProvider<IndexRoutingTable> routingTableDiff = remoteRoutingTableService.getIndicesRoutingMapDiff(
+            previousClusterState.getRoutingTable(),
+            clusterState.getRoutingTable()
+        );
+        if (routingTableDiff != null && routingTableDiff.provideDiff() != null) {
+            routingTableDiff.provideDiff()
+                .getDiffs()
+                .forEach((k, v) -> indicesRoutingToUpload.add(clusterState.getRoutingTable().index(k)));
+            routingTableDiff.provideDiff().getUpserts().forEach((k, v) -> indicesRoutingToUpload.add(v));
+            deletedIndicesRouting.addAll(routingTableDiff.provideDiff().getDeletes());
+        }
+
+        UploadedMetadataResults uploadedMetadataResults;
+        // For migration case from codec V0 or V1 to V2, we have added null check on metadata attribute files,
+        // If file is empty and codec is 1 then write global metadata.
+        boolean updateCoordinationMetadata = firstUploadForSplitGlobalMetadata
+            || Metadata.isCoordinationMetadataEqual(previousClusterState.metadata(), clusterState.metadata()) == false;
+        ;
+        boolean updateSettingsMetadata = firstUploadForSplitGlobalMetadata
+            || Metadata.isSettingsMetadataEqual(previousClusterState.metadata(), clusterState.metadata()) == false;
+        boolean updateTransientSettingsMetadata = Metadata.isTransientSettingsMetadataEqual(
+            previousClusterState.metadata(),
+            clusterState.metadata()
+        ) == false;
+        boolean updateTemplatesMetadata = firstUploadForSplitGlobalMetadata
+            || Metadata.isTemplatesMetadataEqual(previousClusterState.metadata(), clusterState.metadata()) == false;
+
+        final boolean updateDiscoveryNodes = isPublicationEnabled
+            && clusterState.getNodes().delta(previousClusterState.getNodes()).hasChanges();
+        final boolean updateClusterBlocks = isPublicationEnabled && !clusterState.blocks().equals(previousClusterState.blocks());
+        final boolean updateHashesOfConsistentSettings = isPublicationEnabled
+            && Metadata.isHashesOfConsistentSettingsEqual(previousClusterState.metadata(), clusterState.metadata()) == false;
+
+        uploadedMetadataResults = writeMetadataInParallel(
+            clusterState,
+            toUpload,
+            prevIndexMetadataByName,
+            customsDiff.getUpserts(),
+            updateCoordinationMetadata,
+            updateSettingsMetadata,
+            updateTemplatesMetadata,
+            updateDiscoveryNodes,
+            updateClusterBlocks,
+            updateTransientSettingsMetadata,
+            clusterStateCustomsDiff.getUpserts(),
+            updateHashesOfConsistentSettings,
+            indicesRoutingToUpload,
+            routingTableDiff
         );
 
-        for (String removedIndexName : previousStateIndexMetadataByName.keySet()) {
-            allUploadedIndexMetadata.remove(removedIndexName);
+        // update the map if the metadata was uploaded
+        uploadedMetadataResults.uploadedIndexMetadata.forEach(
+            uploadedIndexMetadata -> allUploadedIndexMetadata.put(uploadedIndexMetadata.getIndexName(), uploadedIndexMetadata)
+        );
+        allUploadedCustomMap.putAll(uploadedMetadataResults.uploadedCustomMetadataMap);
+        allUploadedClusterStateCustomsMap.putAll(uploadedMetadataResults.uploadedClusterStateCustomMetadataMap);
+        // remove the data for removed custom/indices
+        customsDiff.getDeletes().forEach(allUploadedCustomMap::remove);
+        indicesToBeDeletedFromRemote.keySet().forEach(allUploadedIndexMetadata::remove);
+        clusterStateCustomsDiff.getDeletes().forEach(allUploadedClusterStateCustomsMap::remove);
+
+        if (!updateCoordinationMetadata) {
+            uploadedMetadataResults.uploadedCoordinationMetadata = previousManifest.getCoordinationMetadata();
+        }
+        if (!updateSettingsMetadata) {
+            uploadedMetadataResults.uploadedSettingsMetadata = previousManifest.getSettingsMetadata();
         }
-        final ClusterMetadataManifest manifest = uploadManifest(
+        if (!updateTransientSettingsMetadata) {
+            uploadedMetadataResults.uploadedTransientSettingsMetadata = previousManifest.getTransientSettingsMetadata();
+        }
+        if (!updateTemplatesMetadata) {
+            uploadedMetadataResults.uploadedTemplatesMetadata = previousManifest.getTemplatesMetadata();
+        }
+        if (!updateDiscoveryNodes) {
+            uploadedMetadataResults.uploadedDiscoveryNodes = previousManifest.getDiscoveryNodesMetadata();
+        }
+        if (!updateClusterBlocks) {
+            uploadedMetadataResults.uploadedClusterBlocks = previousManifest.getClusterBlocksMetadata();
+        }
+        if (!updateHashesOfConsistentSettings) {
+            uploadedMetadataResults.uploadedHashesOfConsistentSettings = previousManifest.getHashesOfConsistentSettings();
+        }
+        uploadedMetadataResults.uploadedCustomMetadataMap = allUploadedCustomMap;
+        uploadedMetadataResults.uploadedClusterStateCustomMetadataMap = allUploadedClusterStateCustomsMap;
+        uploadedMetadataResults.uploadedIndexMetadata = new ArrayList<>(allUploadedIndexMetadata.values());
+
+        uploadedMetadataResults.uploadedIndicesRoutingMetadata = remoteRoutingTableService.getAllUploadedIndicesRouting(
+            previousManifest,
+            uploadedMetadataResults.uploadedIndicesRoutingMetadata,
+            deletedIndicesRouting
+        );
+
+        ClusterStateDiffManifest clusterStateDiffManifest = new ClusterStateDiffManifest(
+            clusterState,
+            previousClusterState,
+            MANIFEST_CURRENT_CODEC_VERSION,
+            routingTableDiff,
+            uploadedMetadataResults.uploadedIndicesRoutingDiffMetadata != null
+                ? uploadedMetadataResults.uploadedIndicesRoutingDiffMetadata.getUploadedFilename()
+                : null
+        );
+
+        final RemoteClusterStateManifestInfo manifestDetails = remoteManifestManager.uploadManifest(
             clusterState,
-            new ArrayList<>(allUploadedIndexMetadata.values()),
+            uploadedMetadataResults,
             previousManifest.getPreviousClusterUUID(),
-            globalMetadataFile,
-            false
+            clusterStateDiffManifest,
+            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE) ? new ClusterStateChecksum(clusterState) : null,
+            false,
+            previousManifest.getCodecVersion()
         );
-        deleteStaleClusterMetadata(clusterState.getClusterName().value(), clusterState.metadata().clusterUUID(), RETAINED_MANIFESTS);
 
         final long durationMillis = TimeValue.nsecToMSec(relativeTimeNanosSupplier.getAsLong() - startTimeNanos);
-        remoteStateStats.stateSucceeded();
-        remoteStateStats.stateTook(durationMillis);
+        remoteStateStats.stateUploadSucceeded();
+        remoteStateStats.stateUploadTook(durationMillis);
+        ParameterizedMessage clusterStateUploadTimeMessage = new ParameterizedMessage(
+            CLUSTER_STATE_UPLOAD_TIME_LOG_STRING,
+            manifestDetails.getClusterMetadataManifest().getStateVersion(),
+            durationMillis
+        );
+        ParameterizedMessage metadataUpdateMessage = new ParameterizedMessage(
+            METADATA_UPDATE_LOG_STRING,
+            numIndicesUpdated,
+            numIndicesUnchanged,
+            updateCoordinationMetadata,
+            updateSettingsMetadata,
+            updateTemplatesMetadata,
+            customsDiff.getUpserts().size(),
+            indicesRoutingToUpload.size()
+        );
         if (durationMillis >= slowWriteLoggingThreshold.getMillis()) {
+            // TODO update logs to add more details about objects uploaded
             logger.warn(
                 "writing cluster state took [{}ms] which is above the warn threshold of [{}]; "
-                    + "wrote  metadata for [{}] indices and skipped [{}] unchanged indices, global metadata updated : [{}]",
+                    + "wrote  metadata for [{}] indices and skipped [{}] unchanged indices, coordination metadata updated : [{}], "
+                    + "settings metadata updated : [{}], templates metadata updated : [{}], custom metadata updated : [{}]",
                 durationMillis,
                 slowWriteLoggingThreshold,
                 numIndicesUpdated,
                 numIndicesUnchanged,
-                updateGlobalMetadata
+                updateCoordinationMetadata,
+                updateSettingsMetadata,
+                updateTemplatesMetadata,
+                customsDiff.getUpserts().size()
             );
         } else {
-            logger.info(
+            logger.debug("{}; {}", clusterStateUploadTimeMessage, metadataUpdateMessage);
+            logger.debug(
                 "writing cluster state for version [{}] took [{}ms]; "
-                    + "wrote metadata for [{}] indices and skipped [{}] unchanged indices, global metadata updated : [{}]",
-                manifest.getStateVersion(),
+                    + "wrote metadata for [{}] indices and skipped [{}] unchanged indices, coordination metadata updated : [{}], "
+                    + "settings metadata updated : [{}], templates metadata updated : [{}], custom metadata updated : [{}]",
+                manifestDetails.getClusterMetadataManifest().getStateVersion(),
                 durationMillis,
                 numIndicesUpdated,
                 numIndicesUnchanged,
-                updateGlobalMetadata
-            );
-        }
-        return manifest;
-    }
-
-    /**
-     * Uploads provided ClusterState's global Metadata to remote store in parallel.
-     * The call is blocking so the method waits for upload to finish and then return.
-     *
-     * @param clusterState current ClusterState
-     * @return String file name where globalMetadata file is stored.
-     */
-    private String writeGlobalMetadata(ClusterState clusterState) throws IOException {
-
-        AtomicReference<String> result = new AtomicReference<String>();
-        AtomicReference<Exception> exceptionReference = new AtomicReference<Exception>();
-
-        final BlobContainer globalMetadataContainer = globalMetadataContainer(
-            clusterState.getClusterName().value(),
-            clusterState.metadata().clusterUUID()
-        );
-        final String globalMetadataFilename = globalMetadataFileName(clusterState.metadata());
-
-        // latch to wait until upload is not finished
-        CountDownLatch latch = new CountDownLatch(1);
-
-        LatchedActionListener completionListener = new LatchedActionListener<>(ActionListener.wrap(resp -> {
-            logger.trace(String.format(Locale.ROOT, "GlobalMetadata uploaded successfully."));
-            result.set(globalMetadataContainer.path().buildAsString() + globalMetadataFilename);
-        }, ex -> { exceptionReference.set(ex); }), latch);
-
-        GLOBAL_METADATA_FORMAT.writeAsyncWithUrgentPriority(
-            clusterState.metadata(),
-            globalMetadataContainer,
-            globalMetadataFilename,
-            blobStoreRepository.getCompressor(),
-            completionListener,
-            FORMAT_PARAMS
-        );
-
-        try {
-            if (latch.await(getGlobalMetadataUploadTimeout().millis(), TimeUnit.MILLISECONDS) == false) {
-                // TODO: We should add metrics where transfer is timing out. [Issue: #10687]
-                RemoteStateTransferException ex = new RemoteStateTransferException(
-                    String.format(Locale.ROOT, "Timed out waiting for transfer of global metadata to complete")
-                );
-                throw ex;
-            }
-        } catch (InterruptedException ex) {
-            RemoteStateTransferException exception = new RemoteStateTransferException(
-                String.format(Locale.ROOT, "Timed out waiting for transfer of global metadata to complete - %s"),
-                ex
+                updateCoordinationMetadata,
+                updateSettingsMetadata,
+                updateTemplatesMetadata,
+                customsDiff.getUpserts().size()
             );
-            Thread.currentThread().interrupt();
-            throw exception;
-        }
-        if (exceptionReference.get() != null) {
-            throw new RemoteStateTransferException(exceptionReference.get().getMessage(), exceptionReference.get());
         }
-        return result.get();
+        return manifestDetails;
     }
 
-    /**
-     * Uploads provided IndexMetadata's to remote store in parallel. The call is blocking so the method waits for upload to finish and then return.
-     *
-     * @param clusterState current ClusterState
-     * @param toUpload     list of IndexMetadata to upload
-     * @return {@code List<UploadedIndexMetadata>} list of IndexMetadata uploaded to remote
-     */
-    private List<UploadedIndexMetadata> writeIndexMetadataParallel(
+    // package private for testing
+    UploadedMetadataResults writeMetadataInParallel(
         ClusterState clusterState,
-        List<IndexMetadata> toUpload,
-        Map<String, IndexMetadata> prevIndexMetadataByName
+        List<IndexMetadata> indexToUpload,
+        Map<String, IndexMetadata> prevIndexMetadataByName,
+        Map<String, Metadata.Custom> customToUpload,
+        boolean uploadCoordinationMetadata,
+        boolean uploadSettingsMetadata,
+        boolean uploadTemplateMetadata,
+        boolean uploadDiscoveryNodes,
+        boolean uploadClusterBlock,
+        boolean uploadTransientSettingMetadata,
+        Map<String, ClusterState.Custom> clusterStateCustomToUpload,
+        boolean uploadHashesOfConsistentSettings,
+        List<IndexRoutingTable> indicesRoutingToUpload,
+        StringKeyDiffProvider<IndexRoutingTable> routingTableDiff
     ) throws IOException {
         assert Objects.nonNull(indexMetadataUploadListeners) : "indexMetadataUploadListeners can not be null";
-        int latchCount = toUpload.size() + indexMetadataUploadListeners.size();
-        List<Exception> exceptionList = Collections.synchronizedList(new ArrayList<>(latchCount));
-        final CountDownLatch latch = new CountDownLatch(latchCount);
-        List<UploadedIndexMetadata> result = new ArrayList<>(toUpload.size());
-
-        LatchedActionListener<UploadedIndexMetadata> latchedActionListener = new LatchedActionListener<>(
-            ActionListener.wrap((UploadedIndexMetadata uploadedIndexMetadata) -> {
-                logger.trace(
-                    String.format(Locale.ROOT, "IndexMetadata uploaded successfully for %s", uploadedIndexMetadata.getIndexName())
-                );
-                result.add(uploadedIndexMetadata);
+        int totalUploadTasks = indexToUpload.size() + indexMetadataUploadListeners.size() + customToUpload.size()
+            + (uploadCoordinationMetadata ? 1 : 0) + (uploadSettingsMetadata ? 1 : 0) + (uploadTemplateMetadata ? 1 : 0)
+            + (uploadDiscoveryNodes ? 1 : 0) + (uploadClusterBlock ? 1 : 0) + (uploadTransientSettingMetadata ? 1 : 0)
+            + clusterStateCustomToUpload.size() + (uploadHashesOfConsistentSettings ? 1 : 0) + indicesRoutingToUpload.size()
+            + ((routingTableDiff != null
+                && routingTableDiff.provideDiff() != null
+                && (!routingTableDiff.provideDiff().getDiffs().isEmpty()
+                    || !routingTableDiff.provideDiff().getDeletes().isEmpty()
+                    || !routingTableDiff.provideDiff().getUpserts().isEmpty())) ? 1 : 0);
+        CountDownLatch latch = new CountDownLatch(totalUploadTasks);
+        List<String> uploadTasks = Collections.synchronizedList(new ArrayList<>(totalUploadTasks));
+        Map<String, ClusterMetadataManifest.UploadedMetadata> results = new ConcurrentHashMap<>(totalUploadTasks);
+        List<Exception> exceptionList = Collections.synchronizedList(new ArrayList<>(totalUploadTasks));
+
+        LatchedActionListener<ClusterMetadataManifest.UploadedMetadata> listener = new LatchedActionListener<>(
+            ActionListener.wrap((ClusterMetadataManifest.UploadedMetadata uploadedMetadata) -> {
+                logger.trace(String.format(Locale.ROOT, "Metadata component %s uploaded successfully.", uploadedMetadata.getComponent()));
+                results.put(uploadedMetadata.getComponent(), uploadedMetadata);
             }, ex -> {
-                assert ex instanceof RemoteStateTransferException;
                 logger.error(
-                    () -> new ParameterizedMessage("Exception during transfer of IndexMetadata to Remote {}", ex.getMessage()),
+                    () -> new ParameterizedMessage("Exception during transfer of Metadata Fragment to Remote {}", ex.getMessage()),
                     ex
                 );
                 exceptionList.add(ex);
@@ -477,20 +609,180 @@ private List<UploadedIndexMetadata> writeIndexMetadataParallel(
             latch
         );
 
-        for (IndexMetadata indexMetadata : toUpload) {
-            // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/index/ftqsCnn9TgOX/metadata_4_1690947200
-            writeIndexMetadataAsync(clusterState, indexMetadata, latchedActionListener);
+        if (uploadSettingsMetadata) {
+            uploadTasks.add(SETTING_METADATA);
+            remoteGlobalMetadataManager.writeAsync(
+                SETTING_METADATA,
+                new RemotePersistentSettingsMetadata(
+                    clusterState.metadata().persistentSettings(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+        if (uploadTransientSettingMetadata) {
+            uploadTasks.add(TRANSIENT_SETTING_METADATA);
+            remoteGlobalMetadataManager.writeAsync(
+                TRANSIENT_SETTING_METADATA,
+                new RemoteTransientSettingsMetadata(
+                    clusterState.metadata().transientSettings(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+        if (uploadCoordinationMetadata) {
+            uploadTasks.add(COORDINATION_METADATA);
+            remoteGlobalMetadataManager.writeAsync(
+                COORDINATION_METADATA,
+                new RemoteCoordinationMetadata(
+                    clusterState.metadata().coordinationMetadata(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+        if (uploadTemplateMetadata) {
+            uploadTasks.add(TEMPLATES_METADATA);
+            remoteGlobalMetadataManager.writeAsync(
+                TEMPLATES_METADATA,
+                new RemoteTemplatesMetadata(
+                    clusterState.metadata().templatesMetadata(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+        if (uploadDiscoveryNodes) {
+            uploadTasks.add(DISCOVERY_NODES);
+            remoteClusterStateAttributesManager.writeAsync(
+                RemoteDiscoveryNodes.DISCOVERY_NODES,
+                new RemoteDiscoveryNodes(
+                    clusterState.nodes(),
+                    clusterState.version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
+            );
+        }
+        if (uploadClusterBlock) {
+            uploadTasks.add(CLUSTER_BLOCKS);
+            remoteClusterStateAttributesManager.writeAsync(
+                RemoteClusterBlocks.CLUSTER_BLOCKS,
+                new RemoteClusterBlocks(
+                    clusterState.blocks(),
+                    clusterState.version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
+            );
+        }
+        if (uploadHashesOfConsistentSettings) {
+            uploadTasks.add(HASHES_OF_CONSISTENT_SETTINGS);
+            remoteGlobalMetadataManager.writeAsync(
+                HASHES_OF_CONSISTENT_SETTINGS,
+                new RemoteHashesOfConsistentSettings(
+                    (DiffableStringMap) clusterState.metadata().hashesOfConsistentSettings(),
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
+            );
         }
+        customToUpload.forEach((key, value) -> {
+            String customComponent = String.join(CUSTOM_DELIMITER, CUSTOM_METADATA, key);
+            uploadTasks.add(customComponent);
+            remoteGlobalMetadataManager.writeAsync(
+                customComponent,
+                new RemoteCustomMetadata(
+                    value,
+                    key,
+                    clusterState.metadata().version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    namedWriteableRegistry
+                ),
+                listener
+            );
+        });
+        indexToUpload.forEach(indexMetadata -> {
+            uploadTasks.add(indexMetadata.getIndex().getName());
+            remoteIndexMetadataManager.writeAsync(
+                indexMetadata.getIndex().getName(),
+                new RemoteIndexMetadata(
+                    indexMetadata,
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        });
 
-        invokeIndexMetadataUploadListeners(toUpload, prevIndexMetadataByName, latch, exceptionList);
+        clusterStateCustomToUpload.forEach((key, value) -> {
+            uploadTasks.add(key);
+            remoteClusterStateAttributesManager.writeAsync(
+                CLUSTER_STATE_CUSTOM,
+                new RemoteClusterStateCustoms(
+                    value,
+                    key,
+                    clusterState.version(),
+                    clusterState.metadata().clusterUUID(),
+                    blobStoreRepository.getCompressor(),
+                    namedWriteableRegistry
+                ),
+                listener
+            );
+        });
+        indicesRoutingToUpload.forEach(indexRoutingTable -> {
+            uploadTasks.add(INDEX_ROUTING_METADATA_PREFIX + indexRoutingTable.getIndex().getName());
+            remoteRoutingTableService.getAsyncIndexRoutingWriteAction(
+                clusterState.metadata().clusterUUID(),
+                clusterState.term(),
+                clusterState.version(),
+                indexRoutingTable,
+                listener
+            );
+        });
+        if (routingTableDiff != null
+            && routingTableDiff.provideDiff() != null
+            && (!routingTableDiff.provideDiff().getDiffs().isEmpty()
+                || !routingTableDiff.provideDiff().getDeletes().isEmpty()
+                || !routingTableDiff.provideDiff().getUpserts().isEmpty())) {
+            uploadTasks.add(RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_FILE);
+            remoteRoutingTableService.getAsyncIndexRoutingDiffWriteAction(
+                clusterState.metadata().clusterUUID(),
+                clusterState.term(),
+                clusterState.version(),
+                routingTableDiff,
+                listener
+            );
+        }
+        invokeIndexMetadataUploadListeners(indexToUpload, prevIndexMetadataByName, latch, exceptionList);
 
         try {
-            if (latch.await(getIndexMetadataUploadTimeout().millis(), TimeUnit.MILLISECONDS) == false) {
+            if (latch.await(remoteGlobalMetadataManager.getGlobalMetadataUploadTimeout().millis(), TimeUnit.MILLISECONDS) == false) {
+                // TODO: We should add metrics where transfer is timing out. [Issue: #10687]
                 RemoteStateTransferException ex = new RemoteStateTransferException(
                     String.format(
                         Locale.ROOT,
-                        "Timed out waiting for transfer of index metadata to complete - %s",
-                        toUpload.stream().map(IndexMetadata::getIndex).map(Index::toString).collect(Collectors.joining(""))
+                        "Timed out waiting for transfer of following metadata to complete - %s",
+                        String.join(", ", uploadTasks)
                     )
                 );
                 exceptionList.forEach(ex::addSuppressed);
@@ -499,28 +791,71 @@ private List<UploadedIndexMetadata> writeIndexMetadataParallel(
         } catch (InterruptedException ex) {
             exceptionList.forEach(ex::addSuppressed);
             RemoteStateTransferException exception = new RemoteStateTransferException(
-                String.format(
-                    Locale.ROOT,
-                    "Timed out waiting for transfer of index metadata to complete - %s",
-                    toUpload.stream().map(IndexMetadata::getIndex).map(Index::toString).collect(Collectors.joining(""))
-                ),
+                String.format(Locale.ROOT, "Timed out waiting for transfer of metadata to complete - %s", String.join(", ", uploadTasks)),
                 ex
             );
             Thread.currentThread().interrupt();
             throw exception;
         }
-        if (exceptionList.size() > 0) {
+        if (!exceptionList.isEmpty()) {
             RemoteStateTransferException exception = new RemoteStateTransferException(
+                String.format(Locale.ROOT, "Exception during transfer of following metadata to Remote - %s", String.join(", ", uploadTasks))
+            );
+            exceptionList.forEach(exception::addSuppressed);
+            throw exception;
+        }
+        if (results.size() != uploadTasks.size()) {
+            throw new RemoteStateTransferException(
                 String.format(
                     Locale.ROOT,
-                    "Exception during transfer of IndexMetadata to Remote %s",
-                    toUpload.stream().map(IndexMetadata::getIndex).map(Index::toString).collect(Collectors.joining(""))
+                    "Some metadata components were not uploaded successfully. Objects to be uploaded: %s, uploaded objects: %s",
+                    String.join(", ", uploadTasks),
+                    String.join(", ", results.keySet())
                 )
             );
-            exceptionList.forEach(exception::addSuppressed);
-            throw exception;
         }
-        return result;
+        UploadedMetadataResults response = new UploadedMetadataResults();
+        results.forEach((name, uploadedMetadata) -> {
+            if (uploadedMetadata.getClass().equals(UploadedIndexMetadata.class)
+                && uploadedMetadata.getComponent().contains(INDEX_ROUTING_METADATA_PREFIX)) {
+                response.uploadedIndicesRoutingMetadata.add((UploadedIndexMetadata) uploadedMetadata);
+            } else if (RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_FILE.equals(name)) {
+                response.uploadedIndicesRoutingDiffMetadata = (UploadedMetadataAttribute) uploadedMetadata;
+            } else if (name.startsWith(CUSTOM_METADATA)) {
+                // component name for custom metadata will look like custom--<metadata-attribute>
+                String custom = name.split(DELIMITER)[0].split(CUSTOM_DELIMITER)[1];
+                response.uploadedCustomMetadataMap.put(
+                    custom,
+                    new UploadedMetadataAttribute(custom, uploadedMetadata.getUploadedFilename())
+                );
+            } else if (name.startsWith(CLUSTER_STATE_CUSTOM)) {
+                String custom = name.split(DELIMITER)[0].split(CUSTOM_DELIMITER)[1];
+                response.uploadedClusterStateCustomMetadataMap.put(
+                    custom,
+                    new UploadedMetadataAttribute(custom, uploadedMetadata.getUploadedFilename())
+                );
+            } else if (COORDINATION_METADATA.equals(name)) {
+                response.uploadedCoordinationMetadata = (UploadedMetadataAttribute) uploadedMetadata;
+            } else if (RemotePersistentSettingsMetadata.SETTING_METADATA.equals(name)) {
+                response.uploadedSettingsMetadata = (UploadedMetadataAttribute) uploadedMetadata;
+            } else if (TEMPLATES_METADATA.equals(name)) {
+                response.uploadedTemplatesMetadata = (UploadedMetadataAttribute) uploadedMetadata;
+            } else if (name.contains(UploadedIndexMetadata.COMPONENT_PREFIX)) {
+                response.uploadedIndexMetadata.add((UploadedIndexMetadata) uploadedMetadata);
+            } else if (RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA.equals(name)) {
+                response.uploadedTransientSettingsMetadata = (UploadedMetadataAttribute) uploadedMetadata;
+            } else if (RemoteDiscoveryNodes.DISCOVERY_NODES.equals(uploadedMetadata.getComponent())) {
+                response.uploadedDiscoveryNodes = (UploadedMetadataAttribute) uploadedMetadata;
+            } else if (RemoteClusterBlocks.CLUSTER_BLOCKS.equals(uploadedMetadata.getComponent())) {
+                response.uploadedClusterBlocks = (UploadedMetadataAttribute) uploadedMetadata;
+            } else if (RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS.equals(uploadedMetadata.getComponent())) {
+                response.uploadedHashesOfConsistentSettings = (UploadedMetadataAttribute) uploadedMetadata;
+            } else {
+                throw new IllegalStateException("Unknown metadata component name " + name);
+            }
+        });
+        logger.trace("response {}", response.uploadedIndicesRoutingMetadata.toString());
+        return response;
     }
 
     /**
@@ -580,47 +915,16 @@ private ActionListener<Void> getIndexMetadataUploadActionListener(
         );
     }
 
-    /**
-     * Allows async Upload of IndexMetadata to remote
-     *
-     * @param clusterState          current ClusterState
-     * @param indexMetadata         {@link IndexMetadata} to upload
-     * @param latchedActionListener listener to respond back on after upload finishes
-     */
-    private void writeIndexMetadataAsync(
-        ClusterState clusterState,
-        IndexMetadata indexMetadata,
-        LatchedActionListener<UploadedIndexMetadata> latchedActionListener
-    ) throws IOException {
-        final BlobContainer indexMetadataContainer = indexMetadataContainer(
-            clusterState.getClusterName().value(),
-            clusterState.metadata().clusterUUID(),
-            indexMetadata.getIndexUUID()
-        );
-        final String indexMetadataFilename = indexMetadataFileName(indexMetadata);
-        ActionListener<Void> completionListener = ActionListener.wrap(
-            resp -> latchedActionListener.onResponse(
-                new UploadedIndexMetadata(
-                    indexMetadata.getIndex().getName(),
-                    indexMetadata.getIndexUUID(),
-                    indexMetadataContainer.path().buildAsString() + indexMetadataFilename
-                )
-            ),
-            ex -> latchedActionListener.onFailure(new RemoteStateTransferException(indexMetadata.getIndex().toString(), ex))
-        );
+    public RemoteManifestManager getRemoteManifestManager() {
+        return remoteManifestManager;
+    }
 
-        INDEX_METADATA_FORMAT.writeAsyncWithUrgentPriority(
-            indexMetadata,
-            indexMetadataContainer,
-            indexMetadataFilename,
-            blobStoreRepository.getCompressor(),
-            completionListener,
-            FORMAT_PARAMS
-        );
+    public RemoteClusterStateCleanupManager getCleanupManager() {
+        return remoteClusterStateCleanupManager;
     }
 
     @Nullable
-    public ClusterMetadataManifest markLastStateAsCommitted(ClusterState clusterState, ClusterMetadataManifest previousManifest)
+    public RemoteClusterStateManifestInfo markLastStateAsCommitted(ClusterState clusterState, ClusterMetadataManifest previousManifest)
         throws IOException {
         assert clusterState != null : "Last accepted cluster state is not set";
         if (clusterState.nodes().isLocalNodeElectedClusterManager() == false) {
@@ -628,22 +932,58 @@ public ClusterMetadataManifest markLastStateAsCommitted(ClusterState clusterStat
             return null;
         }
         assert previousManifest != null : "Last cluster metadata manifest is not set";
-        ClusterMetadataManifest committedManifest = uploadManifest(
-            clusterState,
+        UploadedMetadataResults uploadedMetadataResults = new UploadedMetadataResults(
             previousManifest.getIndices(),
+            previousManifest.getCustomMetadataMap(),
+            previousManifest.getCoordinationMetadata(),
+            previousManifest.getSettingsMetadata(),
+            previousManifest.getTemplatesMetadata(),
+            previousManifest.getTransientSettingsMetadata(),
+            previousManifest.getDiscoveryNodesMetadata(),
+            previousManifest.getClusterBlocksMetadata(),
+            previousManifest.getIndicesRouting(),
+            previousManifest.getHashesOfConsistentSettings(),
+            previousManifest.getClusterStateCustomMap()
+        );
+
+        RemoteClusterStateManifestInfo committedManifestDetails = remoteManifestManager.uploadManifest(
+            clusterState,
+            uploadedMetadataResults,
             previousManifest.getPreviousClusterUUID(),
-            previousManifest.getGlobalMetadataFileName(),
-            true
+            previousManifest.getDiffManifest(),
+            !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE) ? new ClusterStateChecksum(clusterState) : null,
+            true,
+            previousManifest.getCodecVersion()
         );
-        deleteStaleClusterUUIDs(clusterState, committedManifest);
-        return committedManifest;
+        if (!previousManifest.isClusterUUIDCommitted() && committedManifestDetails.getClusterMetadataManifest().isClusterUUIDCommitted()) {
+            remoteClusterStateCleanupManager.deleteStaleClusterUUIDs(clusterState, committedManifestDetails.getClusterMetadataManifest());
+        }
+
+        return committedManifestDetails;
+    }
+
+    /**
+     * Fetch latest ClusterMetadataManifest from remote state store
+     *
+     * @param clusterUUID uuid of cluster state to refer to in remote
+     * @param clusterName name of the cluster
+     * @return ClusterMetadataManifest
+     */
+    public Optional<ClusterMetadataManifest> getLatestClusterMetadataManifest(String clusterName, String clusterUUID) {
+        return remoteManifestManager.getLatestClusterMetadataManifest(clusterName, clusterUUID);
+    }
+
+    public ClusterMetadataManifest getClusterMetadataManifestByFileName(String clusterUUID, String fileName) {
+        return remoteManifestManager.getRemoteClusterMetadataManifestByFileName(clusterUUID, fileName);
     }
 
     @Override
     public void close() throws IOException {
+        remoteClusterStateCleanupManager.close();
         if (blobStoreRepository != null) {
             IOUtils.close(blobStoreRepository);
         }
+        this.remoteRoutingTableService.close();
     }
 
     public void start() {
@@ -655,293 +995,720 @@ public void start() {
         final Repository repository = repositoriesService.get().repository(remoteStoreRepo);
         assert repository instanceof BlobStoreRepository : "Repository should be instance of BlobStoreRepository";
         blobStoreRepository = (BlobStoreRepository) repository;
-    }
-
-    private ClusterMetadataManifest uploadManifest(
-        ClusterState clusterState,
-        List<UploadedIndexMetadata> uploadedIndexMetadata,
-        String previousClusterUUID,
-        String globalClusterMetadataFileName,
-        boolean committed
-    ) throws IOException {
-        synchronized (this) {
-            final String manifestFileName = getManifestFileName(clusterState.term(), clusterState.version(), committed);
-            final ClusterMetadataManifest manifest = new ClusterMetadataManifest(
-                clusterState.term(),
-                clusterState.getVersion(),
-                clusterState.metadata().clusterUUID(),
-                clusterState.stateUUID(),
-                Version.CURRENT,
-                nodeId,
-                committed,
-                MANIFEST_CURRENT_CODEC_VERSION,
-                globalClusterMetadataFileName,
-                uploadedIndexMetadata,
-                previousClusterUUID,
-                clusterState.metadata().clusterUUIDCommitted()
-            );
-            writeMetadataManifest(clusterState.getClusterName().value(), clusterState.metadata().clusterUUID(), manifest, manifestFileName);
-            return manifest;
-        }
-    }
-
-    private void writeMetadataManifest(String clusterName, String clusterUUID, ClusterMetadataManifest uploadManifest, String fileName)
-        throws IOException {
-        AtomicReference<String> result = new AtomicReference<String>();
-        AtomicReference<Exception> exceptionReference = new AtomicReference<Exception>();
-
-        final BlobContainer metadataManifestContainer = manifestContainer(clusterName, clusterUUID);
-
-        // latch to wait until upload is not finished
-        CountDownLatch latch = new CountDownLatch(1);
-
-        LatchedActionListener completionListener = new LatchedActionListener<>(ActionListener.wrap(resp -> {
-            logger.trace(String.format(Locale.ROOT, "Manifest file uploaded successfully."));
-        }, ex -> { exceptionReference.set(ex); }), latch);
-
-        CLUSTER_METADATA_MANIFEST_FORMAT.writeAsyncWithUrgentPriority(
-            uploadManifest,
-            metadataManifestContainer,
-            fileName,
-            blobStoreRepository.getCompressor(),
-            completionListener,
-            FORMAT_PARAMS
+        String clusterName = ClusterName.CLUSTER_NAME_SETTING.get(settings).value();
+        blobStoreTransferService = new BlobStoreTransferService(getBlobStore(), threadpool);
+
+        remoteGlobalMetadataManager = new RemoteGlobalMetadataManager(
+            clusterSettings,
+            clusterName,
+            blobStoreRepository,
+            blobStoreTransferService,
+            namedWriteableRegistry,
+            threadpool
         );
-
-        try {
-            if (latch.await(getMetadataManifestUploadTimeout().millis(), TimeUnit.MILLISECONDS) == false) {
-                RemoteStateTransferException ex = new RemoteStateTransferException(
-                    String.format(Locale.ROOT, "Timed out waiting for transfer of manifest file to complete")
-                );
-                throw ex;
-            }
-        } catch (InterruptedException ex) {
-            RemoteStateTransferException exception = new RemoteStateTransferException(
-                String.format(Locale.ROOT, "Timed out waiting for transfer of manifest file to complete - %s"),
-                ex
-            );
-            Thread.currentThread().interrupt();
-            throw exception;
-        }
-        if (exceptionReference.get() != null) {
-            throw new RemoteStateTransferException(exceptionReference.get().getMessage(), exceptionReference.get());
-        }
-        logger.debug(
-            "Metadata manifest file [{}] written during [{}] phase. ",
-            fileName,
-            uploadManifest.isCommitted() ? "commit" : "publish"
+        remoteIndexMetadataManager = new RemoteIndexMetadataManager(
+            clusterSettings,
+            clusterName,
+            blobStoreRepository,
+            blobStoreTransferService,
+            threadpool
+        );
+        remoteManifestManager = new RemoteManifestManager(
+            clusterSettings,
+            clusterName,
+            nodeId,
+            blobStoreRepository,
+            blobStoreTransferService,
+            threadpool
+        );
+        remoteClusterStateAttributesManager = new RemoteClusterStateAttributesManager(
+            clusterName,
+            blobStoreRepository,
+            blobStoreTransferService,
+            namedWriteableRegistry,
+            threadpool
         );
-    }
-
-    private BlobContainer indexMetadataContainer(String clusterName, String clusterUUID, String indexUUID) {
-        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/index/ftqsCnn9TgOX
-        return blobStoreRepository.blobStore()
-            .blobContainer(getCusterMetadataBasePath(clusterName, clusterUUID).add(INDEX_PATH_TOKEN).add(indexUUID));
-    }
-
-    private BlobContainer globalMetadataContainer(String clusterName, String clusterUUID) {
-        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/global-metadata/
-        return blobStoreRepository.blobStore()
-            .blobContainer(getCusterMetadataBasePath(clusterName, clusterUUID).add(GLOBAL_METADATA_PATH_TOKEN));
-    }
-
-    private BlobContainer manifestContainer(String clusterName, String clusterUUID) {
-        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/manifest
-        return blobStoreRepository.blobStore().blobContainer(getManifestFolderPath(clusterName, clusterUUID));
-    }
-
-    private BlobPath getCusterMetadataBasePath(String clusterName, String clusterUUID) {
-        return blobStoreRepository.basePath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID);
-    }
 
-    private BlobContainer clusterUUIDContainer(String clusterName) {
-        return blobStoreRepository.blobStore()
-            .blobContainer(
-                blobStoreRepository.basePath()
-                    .add(Base64.getUrlEncoder().withoutPadding().encodeToString(clusterName.getBytes(StandardCharsets.UTF_8)))
-                    .add(CLUSTER_STATE_PATH_TOKEN)
-            );
+        remoteRoutingTableService.start();
+        remoteClusterStateCleanupManager.start();
     }
 
     private void setSlowWriteLoggingThreshold(TimeValue slowWriteLoggingThreshold) {
         this.slowWriteLoggingThreshold = slowWriteLoggingThreshold;
     }
 
-    private void setIndexMetadataUploadTimeout(TimeValue newIndexMetadataUploadTimeout) {
-        this.indexMetadataUploadTimeout = newIndexMetadataUploadTimeout;
-    }
-
-    private void setGlobalMetadataUploadTimeout(TimeValue newGlobalMetadataUploadTimeout) {
-        this.globalMetadataUploadTimeout = newGlobalMetadataUploadTimeout;
-    }
-
-    private void setMetadataManifestUploadTimeout(TimeValue newMetadataManifestUploadTimeout) {
-        this.metadataManifestUploadTimeout = newMetadataManifestUploadTimeout;
+    private void setChecksumValidationMode(RemoteClusterStateValidationMode remoteClusterStateValidationMode) {
+        this.remoteClusterStateValidationMode = remoteClusterStateValidationMode;
     }
 
-    public TimeValue getIndexMetadataUploadTimeout() {
-        return this.indexMetadataUploadTimeout;
+    // Package private for unit test
+    RemoteRoutingTableService getRemoteRoutingTableService() {
+        return this.remoteRoutingTableService;
     }
 
-    public TimeValue getGlobalMetadataUploadTimeout() {
-        return this.globalMetadataUploadTimeout;
+    ThreadPool getThreadpool() {
+        return threadpool;
     }
 
-    public TimeValue getMetadataManifestUploadTimeout() {
-        return this.metadataManifestUploadTimeout;
+    BlobStoreRepository getBlobStoreRepository() {
+        return blobStoreRepository;
     }
 
-    static String getManifestFileName(long term, long version, boolean committed) {
-        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/manifest/manifest__<inverted_term>__<inverted_version>__C/P__<inverted__timestamp>__<codec_version>
-        return String.join(
-            DELIMITER,
-            MANIFEST_PATH_TOKEN,
-            RemoteStoreUtils.invertLong(term),
-            RemoteStoreUtils.invertLong(version),
-            (committed ? "C" : "P"), // C for committed and P for published
-            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
-            String.valueOf(MANIFEST_CURRENT_CODEC_VERSION) // Keep the codec version at last place only, during read we reads last place to
-            // determine codec version.
-        );
+    BlobStore getBlobStore() {
+        return blobStoreRepository.blobStore();
     }
 
-    static String indexMetadataFileName(IndexMetadata indexMetadata) {
-        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/index/<index_UUID>/metadata__<inverted_index_metadata_version>__<inverted__timestamp>__<codec
-        // version>
-        return String.join(
-            DELIMITER,
-            METADATA_FILE_PREFIX,
-            RemoteStoreUtils.invertLong(indexMetadata.getVersion()),
-            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
-            String.valueOf(INDEX_METADATA_CURRENT_CODEC_VERSION) // Keep the codec version at last place only, during read we reads last
-            // place to determine codec version.
-        );
-    }
-
-    private static String globalMetadataFileName(Metadata metadata) {
-        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/global-metadata/metadata__<inverted_metadata_version>__<inverted__timestamp>__<codec_version>
-        return String.join(
-            DELIMITER,
-            METADATA_FILE_PREFIX,
-            RemoteStoreUtils.invertLong(metadata.version()),
-            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
-            String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)
+    /**
+     * Fetch latest ClusterState from remote, including global metadata, index metadata and cluster state version
+     *
+     * @param clusterUUID uuid of cluster state to refer to in remote
+     * @param clusterName name of the cluster
+     * @return {@link IndexMetadata}
+     */
+    public ClusterState getLatestClusterState(String clusterName, String clusterUUID, boolean includeEphemeral) throws IOException {
+        Optional<ClusterMetadataManifest> clusterMetadataManifest = remoteManifestManager.getLatestClusterMetadataManifest(
+            clusterName,
+            clusterUUID
         );
-    }
+        if (clusterMetadataManifest.isEmpty()) {
+            throw new IllegalStateException(
+                String.format(Locale.ROOT, "Latest cluster metadata manifest is not present for the provided clusterUUID: %s", clusterUUID)
+            );
+        }
 
-    private BlobPath getManifestFolderPath(String clusterName, String clusterUUID) {
-        return getCusterMetadataBasePath(clusterName, clusterUUID).add(MANIFEST_PATH_TOKEN);
+        return getClusterStateForManifest(clusterName, clusterMetadataManifest.get(), nodeId, includeEphemeral);
     }
 
-    /**
-     * Fetch latest index metadata from remote cluster state
-     *
-     * @param clusterUUID             uuid of cluster state to refer to in remote
-     * @param clusterName             name of the cluster
-     * @param clusterMetadataManifest manifest file of cluster
-     * @return {@code Map<String, IndexMetadata>} latest IndexUUID to IndexMetadata map
-     */
-    private Map<String, IndexMetadata> getIndexMetadataMap(
-        String clusterName,
+    // package private for testing
+    ClusterState readClusterStateInParallel(
+        ClusterState previousState,
+        ClusterMetadataManifest manifest,
         String clusterUUID,
-        ClusterMetadataManifest clusterMetadataManifest
+        String localNodeId,
+        List<UploadedIndexMetadata> indicesToRead,
+        Map<String, UploadedMetadataAttribute> customToRead,
+        boolean readCoordinationMetadata,
+        boolean readSettingsMetadata,
+        boolean readTransientSettingsMetadata,
+        boolean readTemplatesMetadata,
+        boolean readDiscoveryNodes,
+        boolean readClusterBlocks,
+        List<UploadedIndexMetadata> indicesRoutingToRead,
+        boolean readHashesOfConsistentSettings,
+        Map<String, UploadedMetadataAttribute> clusterStateCustomToRead,
+        boolean readIndexRoutingTableDiff,
+        boolean includeEphemeral
     ) {
-        assert Objects.equals(clusterUUID, clusterMetadataManifest.getClusterUUID())
-            : "Corrupt ClusterMetadataManifest found. Cluster UUID mismatch.";
-        Map<String, IndexMetadata> remoteIndexMetadata = new HashMap<>();
-        for (UploadedIndexMetadata uploadedIndexMetadata : clusterMetadataManifest.getIndices()) {
-            IndexMetadata indexMetadata = getIndexMetadata(clusterName, clusterUUID, uploadedIndexMetadata);
-            remoteIndexMetadata.put(uploadedIndexMetadata.getIndexUUID(), indexMetadata);
-        }
-        return remoteIndexMetadata;
-    }
+        int totalReadTasks = indicesToRead.size() + customToRead.size() + (readCoordinationMetadata ? 1 : 0) + (readSettingsMetadata
+            ? 1
+            : 0) + (readTemplatesMetadata ? 1 : 0) + (readDiscoveryNodes ? 1 : 0) + (readClusterBlocks ? 1 : 0)
+            + (readTransientSettingsMetadata ? 1 : 0) + (readHashesOfConsistentSettings ? 1 : 0) + clusterStateCustomToRead.size()
+            + indicesRoutingToRead.size() + (readIndexRoutingTableDiff ? 1 : 0);
+        CountDownLatch latch = new CountDownLatch(totalReadTasks);
+        List<RemoteReadResult> readResults = Collections.synchronizedList(new ArrayList<>());
+        List<IndexRoutingTable> readIndexRoutingTableResults = Collections.synchronizedList(new ArrayList<>());
+        AtomicReference<Diff<RoutingTable>> readIndexRoutingTableDiffResults = new AtomicReference<>();
+        List<Exception> exceptionList = Collections.synchronizedList(new ArrayList<>(totalReadTasks));
+
+        LatchedActionListener<RemoteReadResult> listener = new LatchedActionListener<>(ActionListener.wrap(response -> {
+            logger.debug("Successfully read cluster state component from remote");
+            readResults.add(response);
+        }, ex -> {
+            logger.error("Failed to read cluster state from remote", ex);
+            exceptionList.add(ex);
+        }), latch);
+
+        for (UploadedIndexMetadata indexMetadata : indicesToRead) {
+            remoteIndexMetadataManager.readAsync(
+                indexMetadata.getIndexName(),
+                new RemoteIndexMetadata(
+                    RemoteClusterStateUtils.getFormattedIndexFileName(indexMetadata.getUploadedFilename()),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+
+        LatchedActionListener<IndexRoutingTable> routingTableLatchedActionListener = new LatchedActionListener<>(
+            ActionListener.wrap(response -> {
+                logger.debug(() -> new ParameterizedMessage("Successfully read index-routing for index {}", response.getIndex().getName()));
+                readIndexRoutingTableResults.add(response);
+            }, ex -> {
+                logger.error(() -> new ParameterizedMessage("Failed to read index-routing from remote"), ex);
+                exceptionList.add(ex);
+            }),
+            latch
+        );
+
+        for (UploadedIndexMetadata indexRouting : indicesRoutingToRead) {
+            remoteRoutingTableService.getAsyncIndexRoutingReadAction(
+                clusterUUID,
+                indexRouting.getUploadedFilename(),
+                routingTableLatchedActionListener
+            );
+        }
+
+        LatchedActionListener<Diff<RoutingTable>> routingTableDiffLatchedActionListener = new LatchedActionListener<>(
+            ActionListener.wrap(response -> {
+                logger.debug("Successfully read routing table diff component from remote");
+                readIndexRoutingTableDiffResults.set(response);
+            }, ex -> {
+                logger.error("Failed to read routing table diff from remote", ex);
+                exceptionList.add(ex);
+            }),
+            latch
+        );
+
+        if (readIndexRoutingTableDiff) {
+            remoteRoutingTableService.getAsyncIndexRoutingTableDiffReadAction(
+                clusterUUID,
+                manifest.getDiffManifest().getIndicesRoutingDiffPath(),
+                routingTableDiffLatchedActionListener
+            );
+        }
+
+        for (Map.Entry<String, UploadedMetadataAttribute> entry : customToRead.entrySet()) {
+            remoteGlobalMetadataManager.readAsync(
+                entry.getValue().getAttributeName(),
+                new RemoteCustomMetadata(
+                    entry.getValue().getUploadedFilename(),
+                    entry.getKey(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    namedWriteableRegistry
+                ),
+                listener
+            );
+        }
+
+        if (readCoordinationMetadata) {
+            remoteGlobalMetadataManager.readAsync(
+                COORDINATION_METADATA,
+                new RemoteCoordinationMetadata(
+                    manifest.getCoordinationMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+
+        if (readSettingsMetadata) {
+            remoteGlobalMetadataManager.readAsync(
+                SETTING_METADATA,
+                new RemotePersistentSettingsMetadata(
+                    manifest.getSettingsMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+
+        if (readTransientSettingsMetadata) {
+            remoteGlobalMetadataManager.readAsync(
+                TRANSIENT_SETTING_METADATA,
+                new RemoteTransientSettingsMetadata(
+                    manifest.getTransientSettingsMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+
+        if (readTemplatesMetadata) {
+            remoteGlobalMetadataManager.readAsync(
+                TEMPLATES_METADATA,
+                new RemoteTemplatesMetadata(
+                    manifest.getTemplatesMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    blobStoreRepository.getNamedXContentRegistry()
+                ),
+                listener
+            );
+        }
+
+        if (readDiscoveryNodes) {
+            remoteClusterStateAttributesManager.readAsync(
+                DISCOVERY_NODES,
+                new RemoteDiscoveryNodes(
+                    manifest.getDiscoveryNodesMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
+            );
+        }
+
+        if (readClusterBlocks) {
+            remoteClusterStateAttributesManager.readAsync(
+                CLUSTER_BLOCKS,
+                new RemoteClusterBlocks(
+                    manifest.getClusterBlocksMetadata().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
+            );
+        }
+
+        if (readHashesOfConsistentSettings) {
+            remoteGlobalMetadataManager.readAsync(
+                HASHES_OF_CONSISTENT_SETTINGS,
+                new RemoteHashesOfConsistentSettings(
+                    manifest.getHashesOfConsistentSettings().getUploadedFilename(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor()
+                ),
+                listener
+            );
+        }
+
+        for (Map.Entry<String, UploadedMetadataAttribute> entry : clusterStateCustomToRead.entrySet()) {
+            remoteClusterStateAttributesManager.readAsync(
+                // pass component name as cluster-state-custom--<custom_name>, so that we can interpret it later
+                String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, entry.getKey()),
+                new RemoteClusterStateCustoms(
+                    entry.getValue().getUploadedFilename(),
+                    entry.getValue().getAttributeName(),
+                    clusterUUID,
+                    blobStoreRepository.getCompressor(),
+                    namedWriteableRegistry
+                ),
+                listener
+            );
+        }
 
-    /**
-     * Fetch index metadata from remote cluster state
-     *
-     * @param clusterUUID           uuid of cluster state to refer to in remote
-     * @param clusterName           name of the cluster
-     * @param uploadedIndexMetadata {@link UploadedIndexMetadata} contains details about remote location of index metadata
-     * @return {@link IndexMetadata}
-     */
-    private IndexMetadata getIndexMetadata(String clusterName, String clusterUUID, UploadedIndexMetadata uploadedIndexMetadata) {
-        BlobContainer blobContainer = indexMetadataContainer(clusterName, clusterUUID, uploadedIndexMetadata.getIndexUUID());
         try {
-            String[] splitPath = uploadedIndexMetadata.getUploadedFilename().split("/");
-            return INDEX_METADATA_FORMAT.read(
-                blobContainer,
-                splitPath[splitPath.length - 1],
-                blobStoreRepository.getNamedXContentRegistry()
+            if (latch.await(this.remoteStateReadTimeout.getMillis(), TimeUnit.MILLISECONDS) == false) {
+                RemoteStateTransferException exception = new RemoteStateTransferException(
+                    "Timed out waiting to read cluster state from remote within timeout " + this.remoteStateReadTimeout
+                );
+                exceptionList.forEach(exception::addSuppressed);
+                throw exception;
+            }
+        } catch (InterruptedException e) {
+            exceptionList.forEach(e::addSuppressed);
+            RemoteStateTransferException ex = new RemoteStateTransferException(
+                "Interrupted while waiting to read cluster state from metadata"
             );
-        } catch (IOException e) {
-            throw new IllegalStateException(
-                String.format(Locale.ROOT, "Error while downloading IndexMetadata - %s", uploadedIndexMetadata.getUploadedFilename()),
-                e
+            Thread.currentThread().interrupt();
+            throw ex;
+        }
+
+        if (!exceptionList.isEmpty()) {
+            RemoteStateTransferException exception = new RemoteStateTransferException("Exception during reading cluster state from remote");
+            exceptionList.forEach(exception::addSuppressed);
+            throw exception;
+        }
+
+        final ClusterState.Builder clusterStateBuilder = ClusterState.builder(previousState);
+        AtomicReference<Builder> discoveryNodesBuilder = new AtomicReference<>(DiscoveryNodes.builder());
+        Metadata.Builder metadataBuilder = Metadata.builder(previousState.metadata());
+        metadataBuilder.version(manifest.getMetadataVersion());
+        metadataBuilder.clusterUUID(manifest.getClusterUUID());
+        metadataBuilder.clusterUUIDCommitted(manifest.isClusterUUIDCommitted());
+        Map<String, IndexMetadata> indexMetadataMap = new HashMap<>();
+        Map<String, IndexRoutingTable> indicesRouting = new HashMap<>(previousState.routingTable().getIndicesRouting());
+
+        readResults.forEach(remoteReadResult -> {
+            switch (remoteReadResult.getComponent()) {
+                case RemoteIndexMetadata.INDEX:
+                    IndexMetadata indexMetadata = (IndexMetadata) remoteReadResult.getObj();
+                    indexMetadataMap.put(indexMetadata.getIndex().getName(), indexMetadata);
+                    break;
+                case CUSTOM_METADATA:
+                    Metadata.Custom metadataCustom = (Metadata.Custom) remoteReadResult.getObj();
+                    if (includeEphemeral || (!includeEphemeral && metadataCustom.context().contains(XContentContext.GATEWAY))) {
+                        metadataBuilder.putCustom(remoteReadResult.getComponentName(), (Metadata.Custom) remoteReadResult.getObj());
+                    }
+                    break;
+                case COORDINATION_METADATA:
+                    metadataBuilder.coordinationMetadata((CoordinationMetadata) remoteReadResult.getObj());
+                    break;
+                case SETTING_METADATA:
+                    metadataBuilder.persistentSettings((Settings) remoteReadResult.getObj());
+                    break;
+                case TRANSIENT_SETTING_METADATA:
+                    metadataBuilder.transientSettings((Settings) remoteReadResult.getObj());
+                    break;
+                case TEMPLATES_METADATA:
+                    metadataBuilder.templates((TemplatesMetadata) remoteReadResult.getObj());
+                    break;
+                case HASHES_OF_CONSISTENT_SETTINGS:
+                    metadataBuilder.hashesOfConsistentSettings((DiffableStringMap) remoteReadResult.getObj());
+                    break;
+                case CLUSTER_STATE_ATTRIBUTE:
+                    if (remoteReadResult.getComponentName().equals(DISCOVERY_NODES)) {
+                        discoveryNodesBuilder.set(DiscoveryNodes.builder((DiscoveryNodes) remoteReadResult.getObj()));
+                    } else if (remoteReadResult.getComponentName().equals(CLUSTER_BLOCKS)) {
+                        clusterStateBuilder.blocks((ClusterBlocks) remoteReadResult.getObj());
+                    } else if (remoteReadResult.getComponentName().startsWith(CLUSTER_STATE_CUSTOM)) {
+                        // component name for mat is "cluster-state-custom--custom_name"
+                        String custom = remoteReadResult.getComponentName().split(CUSTOM_DELIMITER)[1];
+                        clusterStateBuilder.putCustom(custom, (ClusterState.Custom) remoteReadResult.getObj());
+                    }
+                    break;
+                default:
+                    throw new IllegalStateException("Unknown component: " + remoteReadResult.getComponent());
+            }
+        });
+
+        metadataBuilder.indices(indexMetadataMap);
+        if (readDiscoveryNodes) {
+            clusterStateBuilder.nodes(discoveryNodesBuilder.get().localNodeId(localNodeId));
+        }
+
+        clusterStateBuilder.metadata(metadataBuilder).version(manifest.getStateVersion()).stateUUID(manifest.getStateUUID());
+
+        readIndexRoutingTableResults.forEach(
+            indexRoutingTable -> indicesRouting.put(indexRoutingTable.getIndex().getName(), indexRoutingTable)
+        );
+        Diff<RoutingTable> routingTableDiff = readIndexRoutingTableDiffResults.get();
+        RoutingTable newRoutingTable = new RoutingTable(manifest.getRoutingTableVersion(), indicesRouting);
+        if (routingTableDiff != null) {
+            newRoutingTable = routingTableDiff.apply(previousState.getRoutingTable());
+        }
+        clusterStateBuilder.routingTable(newRoutingTable);
+
+        return clusterStateBuilder.build();
+    }
+
+    public ClusterState getClusterStateForManifest(
+        String clusterName,
+        ClusterMetadataManifest manifest,
+        String localNodeId,
+        boolean includeEphemeral
+    ) throws IOException {
+        final ClusterState clusterState;
+        final long startTimeNanos = relativeTimeNanosSupplier.getAsLong();
+        if (manifest.onOrAfterCodecVersion(CODEC_V2)) {
+            clusterState = readClusterStateInParallel(
+                ClusterState.builder(new ClusterName(clusterName)).build(),
+                manifest,
+                manifest.getClusterUUID(),
+                localNodeId,
+                manifest.getIndices(),
+                manifest.getCustomMetadataMap(),
+                manifest.getCoordinationMetadata() != null,
+                manifest.getSettingsMetadata() != null,
+                includeEphemeral && manifest.getTransientSettingsMetadata() != null,
+                manifest.getTemplatesMetadata() != null,
+                includeEphemeral && manifest.getDiscoveryNodesMetadata() != null,
+                includeEphemeral && manifest.getClusterBlocksMetadata() != null,
+                includeEphemeral ? manifest.getIndicesRouting() : emptyList(),
+                includeEphemeral && manifest.getHashesOfConsistentSettings() != null,
+                includeEphemeral ? manifest.getClusterStateCustomMap() : emptyMap(),
+                false,
+                includeEphemeral
+            );
+
+            if (includeEphemeral
+                && !remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE)
+                && manifest.getClusterStateChecksum() != null) {
+                validateClusterStateFromChecksum(manifest, clusterState, clusterName, localNodeId, true);
+            }
+        } else {
+            ClusterState state = readClusterStateInParallel(
+                ClusterState.builder(new ClusterName(clusterName)).build(),
+                manifest,
+                manifest.getClusterUUID(),
+                localNodeId,
+                manifest.getIndices(),
+                // for manifest codec V1, we don't have the following objects to read, so not passing anything
+                emptyMap(),
+                false,
+                false,
+                false,
+                false,
+                false,
+                false,
+                emptyList(),
+                false,
+                emptyMap(),
+                false,
+                false
             );
+            Metadata.Builder mb = Metadata.builder(remoteGlobalMetadataManager.getGlobalMetadata(manifest.getClusterUUID(), manifest));
+            mb.indices(state.metadata().indices());
+            clusterState = ClusterState.builder(state).metadata(mb).build();
         }
+        final long durationMillis = TimeValue.nsecToMSec(relativeTimeNanosSupplier.getAsLong() - startTimeNanos);
+        remoteStateStats.stateFullDownloadSucceeded();
+        remoteStateStats.stateFullDownloadTook(durationMillis);
+
+        return clusterState;
     }
 
-    /**
-     * Fetch latest ClusterState from remote, including global metadata, index metadata and cluster state version
-     *
-     * @param clusterUUID uuid of cluster state to refer to in remote
-     * @param clusterName name of the cluster
-     * @return {@link IndexMetadata}
-     */
-    public ClusterState getLatestClusterState(String clusterName, String clusterUUID) {
-        Optional<ClusterMetadataManifest> clusterMetadataManifest = getLatestClusterMetadataManifest(clusterName, clusterUUID);
-        if (clusterMetadataManifest.isEmpty()) {
-            throw new IllegalStateException(
-                String.format(Locale.ROOT, "Latest cluster metadata manifest is not present for the provided clusterUUID: %s", clusterUUID)
+    public ClusterState getClusterStateUsingDiff(ClusterMetadataManifest manifest, ClusterState previousState, String localNodeId) {
+        assert manifest.getDiffManifest() != null : "Diff manifest null which is required for downloading cluster state";
+        final long startTimeNanos = relativeTimeNanosSupplier.getAsLong();
+        ClusterStateDiffManifest diff = manifest.getDiffManifest();
+        List<UploadedIndexMetadata> updatedIndices = diff.getIndicesUpdated().stream().map(idx -> {
+            Optional<UploadedIndexMetadata> uploadedIndexMetadataOptional = manifest.getIndices()
+                .stream()
+                .filter(idx2 -> idx2.getIndexName().equals(idx))
+                .findFirst();
+            assert uploadedIndexMetadataOptional.isPresent() == true;
+            return uploadedIndexMetadataOptional.get();
+        }).collect(Collectors.toList());
+
+        Map<String, UploadedMetadataAttribute> updatedCustomMetadata = new HashMap<>();
+        if (diff.getCustomMetadataUpdated() != null) {
+            for (String customType : diff.getCustomMetadataUpdated()) {
+                updatedCustomMetadata.put(customType, manifest.getCustomMetadataMap().get(customType));
+            }
+        }
+        Map<String, UploadedMetadataAttribute> updatedClusterStateCustom = new HashMap<>();
+        if (diff.getClusterStateCustomUpdated() != null) {
+            for (String customType : diff.getClusterStateCustomUpdated()) {
+                updatedClusterStateCustom.put(customType, manifest.getClusterStateCustomMap().get(customType));
+            }
+        }
+
+        List<UploadedIndexMetadata> updatedIndexRouting = new ArrayList<>();
+        if (manifest.getCodecVersion() == CODEC_V2 || manifest.getCodecVersion() == CODEC_V3) {
+            updatedIndexRouting.addAll(
+                remoteRoutingTableService.getUpdatedIndexRoutingTableMetadata(diff.getIndicesRoutingUpdated(), manifest.getIndicesRouting())
             );
         }
-        // Fetch Global Metadata
-        Metadata globalMetadata = getGlobalMetadata(clusterName, clusterUUID, clusterMetadataManifest.get());
 
-        // Fetch Index Metadata
-        Map<String, IndexMetadata> indices = getIndexMetadataMap(clusterName, clusterUUID, clusterMetadataManifest.get());
+        ClusterState updatedClusterState = readClusterStateInParallel(
+            previousState,
+            manifest,
+            manifest.getClusterUUID(),
+            localNodeId,
+            updatedIndices,
+            updatedCustomMetadata,
+            diff.isCoordinationMetadataUpdated(),
+            diff.isSettingsMetadataUpdated(),
+            diff.isTransientSettingsMetadataUpdated(),
+            diff.isTemplatesMetadataUpdated(),
+            diff.isDiscoveryNodesUpdated(),
+            diff.isClusterBlocksUpdated(),
+            updatedIndexRouting,
+            diff.isHashesOfConsistentSettingsUpdated(),
+            updatedClusterStateCustom,
+            manifest.getDiffManifest() != null
+                && manifest.getDiffManifest().getIndicesRoutingDiffPath() != null
+                && !manifest.getDiffManifest().getIndicesRoutingDiffPath().isEmpty(),
+            true
+        );
+        ClusterState.Builder clusterStateBuilder = ClusterState.builder(updatedClusterState);
+        Metadata.Builder metadataBuilder = Metadata.builder(updatedClusterState.metadata());
+        // remove the deleted indices from the metadata
+        for (String index : diff.getIndicesDeleted()) {
+            metadataBuilder.remove(index);
+        }
+        // remove the deleted metadata customs from the metadata
+        if (diff.getCustomMetadataDeleted() != null) {
+            for (String customType : diff.getCustomMetadataDeleted()) {
+                metadataBuilder.removeCustom(customType);
+            }
+        }
 
-        Map<String, IndexMetadata> indexMetadataMap = new HashMap<>();
-        indices.values().forEach(indexMetadata -> { indexMetadataMap.put(indexMetadata.getIndex().getName(), indexMetadata); });
+        // remove the deleted cluster state customs from the metadata
+        if (diff.getClusterStateCustomDeleted() != null) {
+            for (String customType : diff.getClusterStateCustomDeleted()) {
+                clusterStateBuilder.removeCustom(customType);
+            }
+        }
 
-        return ClusterState.builder(ClusterState.EMPTY_STATE)
-            .version(clusterMetadataManifest.get().getStateVersion())
-            .metadata(Metadata.builder(globalMetadata).indices(indexMetadataMap).build())
+        HashMap<String, IndexRoutingTable> indexRoutingTables = new HashMap<>(updatedClusterState.getRoutingTable().getIndicesRouting());
+        if (manifest.getCodecVersion() == CODEC_V2 || manifest.getCodecVersion() == CODEC_V3) {
+            for (String indexName : diff.getIndicesRoutingDeleted()) {
+                indexRoutingTables.remove(indexName);
+            }
+        }
+
+        ClusterState clusterState = clusterStateBuilder.stateUUID(manifest.getStateUUID())
+            .version(manifest.getStateVersion())
+            .metadata(metadataBuilder)
+            .routingTable(new RoutingTable(manifest.getRoutingTableVersion(), indexRoutingTables))
             .build();
+
+        if (!remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.NONE) && manifest.getClusterStateChecksum() != null) {
+            validateClusterStateFromChecksum(manifest, clusterState, previousState.getClusterName().value(), localNodeId, false);
+        }
+        final long durationMillis = TimeValue.nsecToMSec(relativeTimeNanosSupplier.getAsLong() - startTimeNanos);
+        remoteStateStats.stateDiffDownloadSucceeded();
+        remoteStateStats.stateDiffDownloadTook(durationMillis);
+
+        return clusterState;
     }
 
-    private Metadata getGlobalMetadata(String clusterName, String clusterUUID, ClusterMetadataManifest clusterMetadataManifest) {
-        String globalMetadataFileName = clusterMetadataManifest.getGlobalMetadataFileName();
-        try {
-            // Fetch Global metadata
-            if (globalMetadataFileName != null) {
-                String[] splitPath = globalMetadataFileName.split("/");
-                return GLOBAL_METADATA_FORMAT.read(
-                    globalMetadataContainer(clusterName, clusterUUID),
-                    splitPath[splitPath.length - 1],
-                    blobStoreRepository.getNamedXContentRegistry()
-                );
-            } else {
-                return Metadata.EMPTY_METADATA;
-            }
-        } catch (IOException e) {
+    void validateClusterStateFromChecksum(
+        ClusterMetadataManifest manifest,
+        ClusterState clusterState,
+        String clusterName,
+        String localNodeId,
+        boolean isFullStateDownload
+    ) {
+        ClusterStateChecksum newClusterStateChecksum = new ClusterStateChecksum(clusterState);
+        List<String> failedValidation = newClusterStateChecksum.getMismatchEntities(manifest.getClusterStateChecksum());
+        if (failedValidation.isEmpty()) {
+            return;
+        }
+        logger.error(
+            () -> new ParameterizedMessage(
+                "Cluster state checksums do not match. Checksum from manifest {}, checksum from created cluster state {}. Entities failing validation {}",
+                manifest.getClusterStateChecksum(),
+                newClusterStateChecksum,
+                failedValidation
+            )
+        );
+        if (isFullStateDownload && remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.FAILURE)) {
             throw new IllegalStateException(
-                String.format(Locale.ROOT, "Error while downloading Global Metadata - %s", globalMetadataFileName),
-                e
+                "Cluster state checksums do not match during full state read. Validation failed for " + failedValidation
             );
         }
-    }
+        if (remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.FAILURE)
+            || remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.TRACE)) {
+            // download full cluster state and match against state created for the failing entities
+            ClusterState fullClusterState = readClusterStateInParallel(
+                ClusterState.builder(new ClusterName(clusterName)).build(),
+                manifest,
+                manifest.getClusterUUID(),
+                localNodeId,
+                manifest.getIndices(),
+                manifest.getCustomMetadataMap(),
+                manifest.getCoordinationMetadata() != null,
+                manifest.getSettingsMetadata() != null,
+                manifest.getTransientSettingsMetadata() != null,
+                manifest.getTemplatesMetadata() != null,
+                manifest.getDiscoveryNodesMetadata() != null,
+                manifest.getClusterBlocksMetadata() != null,
+                manifest.getIndicesRouting(),
+                manifest.getHashesOfConsistentSettings() != null,
+                manifest.getClusterStateCustomMap(),
+                false,
+                true
+            );
+            for (String failedEntity : failedValidation) {
+                switch (failedEntity) {
+                    case ClusterStateChecksum.ROUTING_TABLE_CS:
+                        Diff<RoutingTable> routingTableDiff = fullClusterState.routingTable().diff(clusterState.routingTable());
+                        logger.error(() -> new ParameterizedMessage("Failing Diff in routing table {}", routingTableDiff));
+                        break;
+                    case ClusterStateChecksum.NODES_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in discovery nodes {}",
+                                fullClusterState.nodes().diff(clusterState.nodes())
+                            )
+                        );
+                        break;
+                    case ClusterStateChecksum.BLOCKS_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in cluster blocks {}",
+                                fullClusterState.blocks().diff(clusterState.blocks())
+                            )
+                        );
+                        break;
+                    case ClusterStateChecksum.CUSTOMS_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in cluster state customs {}",
+                                DiffableUtils.diff(
+                                    clusterState.customs(),
+                                    fullClusterState.customs(),
+                                    DiffableUtils.getStringKeySerializer(),
+                                    CUSTOM_VALUE_SERIALIZER
+                                )
+                            )
+                        );
+                        break;
+                    case ClusterStateChecksum.COORDINATION_MD_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in coordination md. current md {}, full state md {}",
+                                clusterState.metadata().coordinationMetadata(),
+                                fullClusterState.metadata().coordinationMetadata()
+                            )
+                        );
+                        break;
+                    case ClusterStateChecksum.TRANSIENT_SETTINGS_MD_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in transient settings md. current md {}, full state md {}",
+                                clusterState.metadata().transientSettings(),
+                                fullClusterState.metadata().transientSettings()
+                            )
+                        );
 
-    /**
-     * Fetch latest ClusterMetadataManifest from remote state store
-     *
-     * @param clusterUUID uuid of cluster state to refer to in remote
-     * @param clusterName name of the cluster
-     * @return ClusterMetadataManifest
-     */
-    public Optional<ClusterMetadataManifest> getLatestClusterMetadataManifest(String clusterName, String clusterUUID) {
-        Optional<String> latestManifestFileName = getLatestManifestFileName(clusterName, clusterUUID);
-        return latestManifestFileName.map(s -> fetchRemoteClusterMetadataManifest(clusterName, clusterUUID, s));
+                        break;
+                    case ClusterStateChecksum.SETTINGS_MD_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in settings md. current md {}, full state md {}",
+                                clusterState.metadata().settings(),
+                                fullClusterState.metadata().settings()
+                            )
+                        );
+
+                        break;
+                    case ClusterStateChecksum.HASHES_MD_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in hashes md {}",
+                                ((DiffableStringMap) fullClusterState.metadata().hashesOfConsistentSettings()).diff(
+                                    (DiffableStringMap) clusterState.metadata().hashesOfConsistentSettings()
+                                )
+                            )
+                        );
+                        break;
+                    case ClusterStateChecksum.TEMPLATES_MD_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in templates md{}",
+                                fullClusterState.metadata().templatesMetadata().diff(clusterState.metadata().templatesMetadata())
+                            )
+                        );
+                        break;
+                    case ClusterStateChecksum.CUSTOM_MD_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in customs md {}",
+                                DiffableUtils.diff(
+                                    clusterState.metadata().customs(),
+                                    fullClusterState.metadata().customs(),
+                                    DiffableUtils.getStringKeySerializer(),
+                                    Metadata.CUSTOM_VALUE_SERIALIZER
+                                )
+                            )
+                        );
+                        break;
+                    case ClusterStateChecksum.INDICES_CS:
+                        logger.error(
+                            () -> new ParameterizedMessage(
+                                "Failing Diff in index md {}",
+                                DiffableUtils.diff(
+                                    clusterState.metadata().indices(),
+                                    fullClusterState.metadata().indices(),
+                                    DiffableUtils.getStringKeySerializer()
+                                )
+                            )
+                        );
+                        break;
+                    default:
+                        logger.error(() -> new ParameterizedMessage("Unknown failed entity {}", failedEntity));
+                        break;
+                }
+            }
+        }
+        if (remoteClusterStateValidationMode.equals(RemoteClusterStateValidationMode.FAILURE)) {
+            throw new IllegalStateException(
+                "Cluster state checksums do not match during diff read. Validation failed for " + failedValidation
+            );
+        }
     }
 
     /**
@@ -953,7 +1720,10 @@ public Optional<ClusterMetadataManifest> getLatestClusterMetadataManifest(String
     public String getLastKnownUUIDFromRemote(String clusterName) {
         try {
             Set<String> clusterUUIDs = getAllClusterUUIDs(clusterName);
-            Map<String, ClusterMetadataManifest> latestManifests = getLatestManifestForAllClusterUUIDs(clusterName, clusterUUIDs);
+            Map<String, ClusterMetadataManifest> latestManifests = remoteManifestManager.getLatestManifestForAllClusterUUIDs(
+                clusterName,
+                clusterUUIDs
+            );
             List<String> validChain = createClusterChain(latestManifests, clusterName);
             if (validChain.isEmpty()) {
                 return ClusterState.UNKNOWN_UUID;
@@ -967,8 +1737,19 @@ public String getLastKnownUUIDFromRemote(String clusterName) {
         }
     }
 
-    private Set<String> getAllClusterUUIDs(String clusterName) throws IOException {
-        Map<String, BlobContainer> clusterUUIDMetadata = clusterUUIDContainer(clusterName).children();
+    public void setRemoteStateReadTimeout(TimeValue remoteStateReadTimeout) {
+        this.remoteStateReadTimeout = remoteStateReadTimeout;
+    }
+
+    private BlobStoreTransferService getBlobStoreTransferService() {
+        if (blobStoreTransferService == null) {
+            blobStoreTransferService = new BlobStoreTransferService(getBlobStore(), threadpool);
+        }
+        return blobStoreTransferService;
+    }
+
+    Set<String> getAllClusterUUIDs(String clusterName) throws IOException {
+        Map<String, BlobContainer> clusterUUIDMetadata = clusterUUIDContainer(blobStoreRepository, clusterName).children();
         if (clusterUUIDMetadata == null) {
             return Collections.emptySet();
         }
@@ -1013,7 +1794,7 @@ private List<String> createClusterChain(final Map<String, ClusterMetadataManifes
             // This can occur only when there are no valid cluster UUIDs
             assert validClusterManifests.isEmpty() : "There are no top level cluster UUIDs even when there are valid cluster UUIDs";
             logger.info("There is no valid previous cluster UUID. All cluster UUIDs evaluated are: {}", manifestsByClusterUUID.keySet());
-            return Collections.emptyList();
+            return emptyList();
         }
         if (topLevelClusterUUIDs.size() > 1) {
             logger.info("Top level cluster UUIDs: {}", topLevelClusterUUIDs);
@@ -1069,7 +1850,7 @@ private Map<String, ClusterMetadataManifest> trimClusterUUIDs(
             if (!ClusterState.UNKNOWN_UUID.equals(currentManifest.getPreviousClusterUUID())) {
                 ClusterMetadataManifest previousManifest = trimmedUUIDs.get(currentManifest.getPreviousClusterUUID());
                 if (isMetadataEqual(currentManifest, previousManifest, clusterName)
-                    && isGlobalMetadataEqual(currentManifest, previousManifest, clusterName)) {
+                    && remoteGlobalMetadataManager.isGlobalMetadataEqual(currentManifest, previousManifest, clusterName)) {
                     trimmedUUIDs.remove(clusterUUID);
                 }
             }
@@ -1084,14 +1865,20 @@ private boolean isMetadataEqual(ClusterMetadataManifest first, ClusterMetadataMa
         }
         final Map<String, UploadedIndexMetadata> secondIndices = second.getIndices()
             .stream()
-            .collect(Collectors.toMap(md -> md.getIndexName(), Function.identity()));
+            .collect(Collectors.toMap(UploadedIndexMetadata::getIndexName, Function.identity()));
         for (UploadedIndexMetadata uploadedIndexMetadata : first.getIndices()) {
-            final IndexMetadata firstIndexMetadata = getIndexMetadata(clusterName, first.getClusterUUID(), uploadedIndexMetadata);
+            final IndexMetadata firstIndexMetadata = remoteIndexMetadataManager.getIndexMetadata(
+                uploadedIndexMetadata,
+                first.getClusterUUID()
+            );
             final UploadedIndexMetadata secondUploadedIndexMetadata = secondIndices.get(uploadedIndexMetadata.getIndexName());
             if (secondUploadedIndexMetadata == null) {
                 return false;
             }
-            final IndexMetadata secondIndexMetadata = getIndexMetadata(clusterName, second.getClusterUUID(), secondUploadedIndexMetadata);
+            final IndexMetadata secondIndexMetadata = remoteIndexMetadataManager.getIndexMetadata(
+                secondUploadedIndexMetadata,
+                second.getClusterUUID()
+            );
             if (firstIndexMetadata.equals(secondIndexMetadata) == false) {
                 return false;
             }
@@ -1099,302 +1886,48 @@ private boolean isMetadataEqual(ClusterMetadataManifest first, ClusterMetadataMa
         return true;
     }
 
-    private boolean isGlobalMetadataEqual(ClusterMetadataManifest first, ClusterMetadataManifest second, String clusterName) {
-        Metadata secondGlobalMetadata = getGlobalMetadata(clusterName, second.getClusterUUID(), second);
-        Metadata firstGlobalMetadata = getGlobalMetadata(clusterName, first.getClusterUUID(), first);
-        return Metadata.isGlobalResourcesMetadataEquals(firstGlobalMetadata, secondGlobalMetadata);
-    }
-
     private boolean isValidClusterUUID(ClusterMetadataManifest manifest) {
         return manifest.isClusterUUIDCommitted();
     }
 
-    /**
-     * Fetch ClusterMetadataManifest files from remote state store in order
-     *
-     * @param clusterUUID uuid of cluster state to refer to in remote
-     * @param clusterName name of the cluster
-     * @param limit       max no of files to fetch
-     * @return all manifest file names
-     */
-    private List<BlobMetadata> getManifestFileNames(String clusterName, String clusterUUID, int limit) throws IllegalStateException {
-        try {
-
-            /*
-              {@link BlobContainer#listBlobsByPrefixInSortedOrder} will list the latest manifest file first
-              as the manifest file name generated via {@link RemoteClusterStateService#getManifestFileName} ensures
-              when sorted in LEXICOGRAPHIC order the latest uploaded manifest file comes on top.
-             */
-            return manifestContainer(clusterName, clusterUUID).listBlobsByPrefixInSortedOrder(
-                MANIFEST_FILE_PREFIX + DELIMITER,
-                limit,
-                BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
-            );
-        } catch (IOException e) {
-            throw new IllegalStateException("Error while fetching latest manifest file for remote cluster state", e);
-        }
+    // package private setter which are required for injecting mock managers, these setters are not supposed to be used elsewhere
+    void setRemoteIndexMetadataManager(RemoteIndexMetadataManager remoteIndexMetadataManager) {
+        this.remoteIndexMetadataManager = remoteIndexMetadataManager;
     }
 
-    /**
-     * Fetch latest ClusterMetadataManifest file from remote state store
-     *
-     * @param clusterUUID uuid of cluster state to refer to in remote
-     * @param clusterName name of the cluster
-     * @return latest ClusterMetadataManifest filename
-     */
-    private Optional<String> getLatestManifestFileName(String clusterName, String clusterUUID) throws IllegalStateException {
-        List<BlobMetadata> manifestFilesMetadata = getManifestFileNames(clusterName, clusterUUID, 1);
-        if (manifestFilesMetadata != null && !manifestFilesMetadata.isEmpty()) {
-            return Optional.of(manifestFilesMetadata.get(0).name());
-        }
-        logger.info("No manifest file present in remote store for cluster name: {}, cluster UUID: {}", clusterName, clusterUUID);
-        return Optional.empty();
-    }
-
-    /**
-     * Fetch ClusterMetadataManifest from remote state store
-     *
-     * @param clusterUUID uuid of cluster state to refer to in remote
-     * @param clusterName name of the cluster
-     * @return ClusterMetadataManifest
-     */
-    private ClusterMetadataManifest fetchRemoteClusterMetadataManifest(String clusterName, String clusterUUID, String filename)
-        throws IllegalStateException {
-        try {
-            return getClusterMetadataManifestBlobStoreFormat(filename).read(
-                manifestContainer(clusterName, clusterUUID),
-                filename,
-                blobStoreRepository.getNamedXContentRegistry()
-            );
-        } catch (IOException e) {
-            throw new IllegalStateException(String.format(Locale.ROOT, "Error while downloading cluster metadata - %s", filename), e);
-        }
-    }
-
-    private ChecksumBlobStoreFormat<ClusterMetadataManifest> getClusterMetadataManifestBlobStoreFormat(String fileName) {
-        long codecVersion = getManifestCodecVersion(fileName);
-        if (codecVersion == MANIFEST_CURRENT_CODEC_VERSION) {
-            return CLUSTER_METADATA_MANIFEST_FORMAT;
-        } else if (codecVersion == ClusterMetadataManifest.CODEC_V0) {
-            return CLUSTER_METADATA_MANIFEST_FORMAT_V0;
-        }
-
-        throw new IllegalArgumentException("Cluster metadata manifest file is corrupted, don't have valid codec version");
-    }
-
-    private int getManifestCodecVersion(String fileName) {
-        String[] splitName = fileName.split(DELIMITER);
-        if (splitName.length == SPLITED_MANIFEST_FILE_LENGTH) {
-            return Integer.parseInt(splitName[splitName.length - 1]); // Last value would be codec version.
-        } else if (splitName.length < SPLITED_MANIFEST_FILE_LENGTH) { // Where codec is not part of file name, i.e. default codec version 0
-            // is used.
-            return ClusterMetadataManifest.CODEC_V0;
-        } else {
-            throw new IllegalArgumentException("Manifest file name is corrupted");
-        }
+    void setRemoteGlobalMetadataManager(RemoteGlobalMetadataManager remoteGlobalMetadataManager) {
+        this.remoteGlobalMetadataManager = remoteGlobalMetadataManager;
     }
 
-    public static String encodeString(String content) {
-        return Base64.getUrlEncoder().withoutPadding().encodeToString(content.getBytes(StandardCharsets.UTF_8));
+    void setRemoteClusterStateAttributesManager(RemoteClusterStateAttributesManager remoteClusterStateAttributeManager) {
+        this.remoteClusterStateAttributesManager = remoteClusterStateAttributeManager;
     }
 
     public void writeMetadataFailed() {
-        getStats().stateFailed();
+        remoteStateStats.stateUploadFailed();
     }
 
-    /**
-     * Exception for Remote state transfer.
-     */
-    public static class RemoteStateTransferException extends RuntimeException {
-
-        public RemoteStateTransferException(String errorDesc) {
-            super(errorDesc);
-        }
-
-        public RemoteStateTransferException(String errorDesc, Throwable cause) {
-            super(errorDesc, cause);
-        }
-    }
-
-    /**
-     * Purges all remote cluster state against provided cluster UUIDs
-     *
-     * @param clusterName  name of the cluster
-     * @param clusterUUIDs clusteUUIDs for which the remote state needs to be purged
-     */
-    void deleteStaleUUIDsClusterMetadata(String clusterName, List<String> clusterUUIDs) {
-        clusterUUIDs.forEach(clusterUUID -> {
-            getBlobStoreTransferService().deleteAsync(
-                ThreadPool.Names.REMOTE_PURGE,
-                getCusterMetadataBasePath(clusterName, clusterUUID),
-                new ActionListener<>() {
-                    @Override
-                    public void onResponse(Void unused) {
-                        logger.info("Deleted all remote cluster metadata for cluster UUID - {}", clusterUUID);
-                    }
-
-                    @Override
-                    public void onFailure(Exception e) {
-                        logger.error(
-                            new ParameterizedMessage(
-                                "Exception occurred while deleting all remote cluster metadata for cluster UUID {}",
-                                clusterUUID
-                            ),
-                            e
-                        );
-                        remoteStateStats.cleanUpAttemptFailed();
-                    }
-                }
-            );
-        });
+    public RemotePersistenceStats getRemoteStateStats() {
+        return remoteStateStats;
     }
 
-    /**
-     * Deletes older than last {@code versionsToRetain} manifests. Also cleans up unreferenced IndexMetadata associated with older manifests
-     *
-     * @param clusterName       name of the cluster
-     * @param clusterUUID       uuid of cluster state to refer to in remote
-     * @param manifestsToRetain no of latest manifest files to keep in remote
-     */
-    // package private for testing
-    void deleteStaleClusterMetadata(String clusterName, String clusterUUID, int manifestsToRetain) {
-        if (deleteStaleMetadataRunning.compareAndSet(false, true) == false) {
-            logger.info("Delete stale cluster metadata task is already in progress.");
-            return;
-        }
-        try {
-            getBlobStoreTransferService().listAllInSortedOrderAsync(
-                ThreadPool.Names.REMOTE_PURGE,
-                getManifestFolderPath(clusterName, clusterUUID),
-                "manifest",
-                Integer.MAX_VALUE,
-                new ActionListener<>() {
-                    @Override
-                    public void onResponse(List<BlobMetadata> blobMetadata) {
-                        if (blobMetadata.size() > manifestsToRetain) {
-                            deleteClusterMetadata(
-                                clusterName,
-                                clusterUUID,
-                                blobMetadata.subList(0, manifestsToRetain - 1),
-                                blobMetadata.subList(manifestsToRetain - 1, blobMetadata.size())
-                            );
-                        }
-                        deleteStaleMetadataRunning.set(false);
-                    }
-
-                    @Override
-                    public void onFailure(Exception e) {
-                        logger.error(
-                            new ParameterizedMessage(
-                                "Exception occurred while deleting Remote Cluster Metadata for clusterUUIDs {}",
-                                clusterUUID
-                            )
-                        );
-                        deleteStaleMetadataRunning.set(false);
-                    }
-                }
-            );
-        } catch (Exception e) {
-            deleteStaleMetadataRunning.set(false);
-            throw e;
-        }
+    public PersistedStateStats getUploadStats() {
+        return remoteStateStats.getUploadStats();
     }
 
-    private void deleteClusterMetadata(
-        String clusterName,
-        String clusterUUID,
-        List<BlobMetadata> activeManifestBlobMetadata,
-        List<BlobMetadata> staleManifestBlobMetadata
-    ) {
-        try {
-            Set<String> filesToKeep = new HashSet<>();
-            Set<String> staleManifestPaths = new HashSet<>();
-            Set<String> staleIndexMetadataPaths = new HashSet<>();
-            Set<String> staleGlobalMetadataPaths = new HashSet<>();
-            activeManifestBlobMetadata.forEach(blobMetadata -> {
-                ClusterMetadataManifest clusterMetadataManifest = fetchRemoteClusterMetadataManifest(
-                    clusterName,
-                    clusterUUID,
-                    blobMetadata.name()
-                );
-                clusterMetadataManifest.getIndices()
-                    .forEach(uploadedIndexMetadata -> filesToKeep.add(uploadedIndexMetadata.getUploadedFilename()));
-                filesToKeep.add(clusterMetadataManifest.getGlobalMetadataFileName());
-            });
-            staleManifestBlobMetadata.forEach(blobMetadata -> {
-                ClusterMetadataManifest clusterMetadataManifest = fetchRemoteClusterMetadataManifest(
-                    clusterName,
-                    clusterUUID,
-                    blobMetadata.name()
-                );
-                staleManifestPaths.add(new BlobPath().add(MANIFEST_PATH_TOKEN).buildAsString() + blobMetadata.name());
-                if (filesToKeep.contains(clusterMetadataManifest.getGlobalMetadataFileName()) == false) {
-                    String[] globalMetadataSplitPath = clusterMetadataManifest.getGlobalMetadataFileName().split("/");
-                    staleGlobalMetadataPaths.add(
-                        new BlobPath().add(GLOBAL_METADATA_PATH_TOKEN).buildAsString() + GLOBAL_METADATA_FORMAT.blobName(
-                            globalMetadataSplitPath[globalMetadataSplitPath.length - 1]
-                        )
-                    );
-                }
-                clusterMetadataManifest.getIndices().forEach(uploadedIndexMetadata -> {
-                    if (filesToKeep.contains(uploadedIndexMetadata.getUploadedFilename()) == false) {
-                        staleIndexMetadataPaths.add(
-                            new BlobPath().add(INDEX_PATH_TOKEN).add(uploadedIndexMetadata.getIndexUUID()).buildAsString()
-                                + INDEX_METADATA_FORMAT.blobName(uploadedIndexMetadata.getUploadedFilename())
-                        );
-                    }
-                });
-            });
-
-            if (staleManifestPaths.isEmpty()) {
-                logger.debug("No stale Remote Cluster Metadata files found");
-                return;
-            }
-
-            deleteStalePaths(clusterName, clusterUUID, new ArrayList<>(staleGlobalMetadataPaths));
-            deleteStalePaths(clusterName, clusterUUID, new ArrayList<>(staleIndexMetadataPaths));
-            deleteStalePaths(clusterName, clusterUUID, new ArrayList<>(staleManifestPaths));
-        } catch (IllegalStateException e) {
-            logger.error("Error while fetching Remote Cluster Metadata manifests", e);
-        } catch (IOException e) {
-            logger.error("Error while deleting stale Remote Cluster Metadata files", e);
-            remoteStateStats.cleanUpAttemptFailed();
-        } catch (Exception e) {
-            logger.error("Unexpected error while deleting stale Remote Cluster Metadata files", e);
-            remoteStateStats.cleanUpAttemptFailed();
-        }
+    public PersistedStateStats getFullDownloadStats() {
+        return remoteStateStats.getRemoteFullDownloadStats();
     }
 
-    private void deleteStalePaths(String clusterName, String clusterUUID, List<String> stalePaths) throws IOException {
-        logger.debug(String.format(Locale.ROOT, "Deleting stale files from remote - %s", stalePaths));
-        getBlobStoreTransferService().deleteBlobs(getCusterMetadataBasePath(clusterName, clusterUUID), stalePaths);
+    public PersistedStateStats getDiffDownloadStats() {
+        return remoteStateStats.getRemoteDiffDownloadStats();
     }
 
-    /**
-     * Purges all remote cluster state against provided cluster UUIDs
-     *
-     * @param clusterState      current state of the cluster
-     * @param committedManifest last committed ClusterMetadataManifest
-     */
-    public void deleteStaleClusterUUIDs(ClusterState clusterState, ClusterMetadataManifest committedManifest) {
-        threadpool.executor(ThreadPool.Names.REMOTE_PURGE).execute(() -> {
-            String clusterName = clusterState.getClusterName().value();
-            logger.debug("Deleting stale cluster UUIDs data from remote [{}]", clusterName);
-            Set<String> allClustersUUIDsInRemote;
-            try {
-                allClustersUUIDsInRemote = new HashSet<>(getAllClusterUUIDs(clusterState.getClusterName().value()));
-            } catch (IOException e) {
-                logger.info(String.format(Locale.ROOT, "Error while fetching all cluster UUIDs for [%s]", clusterName));
-                return;
-            }
-            // Retain last 2 cluster uuids data
-            allClustersUUIDsInRemote.remove(committedManifest.getClusterUUID());
-            allClustersUUIDsInRemote.remove(committedManifest.getPreviousClusterUUID());
-            deleteStaleUUIDsClusterMetadata(clusterName, new ArrayList<>(allClustersUUIDsInRemote));
-        });
+    public void fullDownloadFailed() {
+        remoteStateStats.stateFullDownloadFailed();
     }
 
-    public RemotePersistenceStats getStats() {
-        return remoteStateStats;
+    public void diffDownloadFailed() {
+        remoteStateStats.stateDiffDownloadFailed();
     }
 }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateUtils.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateUtils.java
new file mode 100644
index 0000000000000..74cb838286961
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteClusterStateUtils.java
@@ -0,0 +1,133 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V1;
+
+/**
+ * Utility class for Remote Cluster State
+ */
+public class RemoteClusterStateUtils {
+
+    public static final String DELIMITER = "__";
+    public static final String METADATA_NAME_FORMAT = "%s.dat";
+    public static final String CLUSTER_STATE_PATH_TOKEN = "cluster-state";
+    public static final String GLOBAL_METADATA_PATH_TOKEN = "global-metadata";
+    public static final String CLUSTER_STATE_EPHEMERAL_PATH_TOKEN = "ephemeral";
+    public static final int GLOBAL_METADATA_CURRENT_CODEC_VERSION = 1;
+    public static final String METADATA_FILE_PREFIX = "metadata";
+    public static final String CUSTOM_DELIMITER = "--";
+    public static final String PATH_DELIMITER = "/";
+    public static final String METADATA_NAME_PLAIN_FORMAT = "%s";
+
+    // ToXContent Params with gateway mode.
+    // We are using gateway context mode to persist all custom metadata.
+    public static final ToXContent.Params FORMAT_PARAMS = new ToXContent.MapParams(
+        Map.of(Metadata.CONTEXT_MODE_PARAM, Metadata.CONTEXT_MODE_GATEWAY)
+    );
+
+    public static BlobPath getClusterMetadataBasePath(BlobStoreRepository blobStoreRepository, String clusterName, String clusterUUID) {
+        return blobStoreRepository.basePath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID);
+    }
+
+    public static String encodeString(String content) {
+        return Base64.getUrlEncoder().withoutPadding().encodeToString(content.getBytes(StandardCharsets.UTF_8));
+    }
+
+    public static String getFormattedIndexFileName(String fileName) {
+        String[] pathTokens = fileName.split(DELIMITER);
+        // last value added is the codec version in IndexMetadata file
+        int codecVersion = Integer.parseInt(pathTokens[pathTokens.length - 1]);
+        if (codecVersion == CODEC_V1) {
+            return String.format(Locale.ROOT, METADATA_NAME_FORMAT, fileName);
+        }
+        return fileName;
+    }
+
+    static BlobContainer clusterUUIDContainer(BlobStoreRepository blobStoreRepository, String clusterName) {
+        return blobStoreRepository.blobStore()
+            .blobContainer(
+                blobStoreRepository.basePath()
+                    .add(Base64.getUrlEncoder().withoutPadding().encodeToString(clusterName.getBytes(StandardCharsets.UTF_8)))
+                    .add(CLUSTER_STATE_PATH_TOKEN)
+            );
+    }
+
+    /**
+     * Container class to keep metadata of all uploaded attributes
+     */
+    public static class UploadedMetadataResults {
+        List<ClusterMetadataManifest.UploadedIndexMetadata> uploadedIndexMetadata;
+        Map<String, ClusterMetadataManifest.UploadedMetadataAttribute> uploadedCustomMetadataMap;
+        Map<String, ClusterMetadataManifest.UploadedMetadataAttribute> uploadedClusterStateCustomMetadataMap;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedCoordinationMetadata;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedSettingsMetadata;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedTransientSettingsMetadata;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedTemplatesMetadata;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedDiscoveryNodes;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedClusterBlocks;
+        List<ClusterMetadataManifest.UploadedIndexMetadata> uploadedIndicesRoutingMetadata;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedHashesOfConsistentSettings;
+        ClusterMetadataManifest.UploadedMetadataAttribute uploadedIndicesRoutingDiffMetadata;
+
+        public UploadedMetadataResults(
+            List<ClusterMetadataManifest.UploadedIndexMetadata> uploadedIndexMetadata,
+            Map<String, ClusterMetadataManifest.UploadedMetadataAttribute> uploadedCustomMetadataMap,
+            ClusterMetadataManifest.UploadedMetadataAttribute uploadedCoordinationMetadata,
+            ClusterMetadataManifest.UploadedMetadataAttribute uploadedSettingsMetadata,
+            ClusterMetadataManifest.UploadedMetadataAttribute uploadedTemplatesMetadata,
+            ClusterMetadataManifest.UploadedMetadataAttribute uploadedTransientSettingsMetadata,
+            ClusterMetadataManifest.UploadedMetadataAttribute uploadedDiscoveryNodes,
+            ClusterMetadataManifest.UploadedMetadataAttribute uploadedClusterBlocks,
+            List<ClusterMetadataManifest.UploadedIndexMetadata> uploadedIndicesRoutingMetadata,
+            ClusterMetadataManifest.UploadedMetadataAttribute uploadedHashesOfConsistentSettings,
+            Map<String, ClusterMetadataManifest.UploadedMetadataAttribute> uploadedClusterStateCustomMap
+        ) {
+            this.uploadedIndexMetadata = uploadedIndexMetadata;
+            this.uploadedCustomMetadataMap = uploadedCustomMetadataMap;
+            this.uploadedCoordinationMetadata = uploadedCoordinationMetadata;
+            this.uploadedSettingsMetadata = uploadedSettingsMetadata;
+            this.uploadedTransientSettingsMetadata = uploadedTransientSettingsMetadata;
+            this.uploadedTemplatesMetadata = uploadedTemplatesMetadata;
+            this.uploadedDiscoveryNodes = uploadedDiscoveryNodes;
+            this.uploadedClusterBlocks = uploadedClusterBlocks;
+            this.uploadedIndicesRoutingMetadata = uploadedIndicesRoutingMetadata;
+            this.uploadedHashesOfConsistentSettings = uploadedHashesOfConsistentSettings;
+            this.uploadedClusterStateCustomMetadataMap = uploadedClusterStateCustomMap;
+        }
+
+        public UploadedMetadataResults() {
+            this.uploadedIndexMetadata = new ArrayList<>();
+            this.uploadedCustomMetadataMap = new HashMap<>();
+            this.uploadedCoordinationMetadata = null;
+            this.uploadedSettingsMetadata = null;
+            this.uploadedTransientSettingsMetadata = null;
+            this.uploadedTemplatesMetadata = null;
+            this.uploadedDiscoveryNodes = null;
+            this.uploadedClusterBlocks = null;
+            this.uploadedIndicesRoutingMetadata = new ArrayList<>();
+            this.uploadedHashesOfConsistentSettings = null;
+            this.uploadedClusterStateCustomMetadataMap = new HashMap<>();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManager.java
new file mode 100644
index 0000000000000..763a8e3ff4951
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManager.java
@@ -0,0 +1,313 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiffableUtils;
+import org.opensearch.cluster.DiffableUtils.NonDiffableValueSerializer;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.Metadata.Custom;
+import org.opensearch.cluster.metadata.Metadata.XContentContext;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.AbstractRemoteWritableEntityManager;
+import org.opensearch.common.remote.RemoteWriteableEntityBlobStore;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.model.RemoteCoordinationMetadata;
+import org.opensearch.gateway.remote.model.RemoteCustomMetadata;
+import org.opensearch.gateway.remote.model.RemoteGlobalMetadata;
+import org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings;
+import org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.gateway.remote.model.RemoteTemplatesMetadata;
+import org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.METADATA_NAME_FORMAT;
+
+/**
+ * A Manager which provides APIs to write and read Global Metadata attributes to remote store
+ *
+ * @opensearch.internal
+ */
+public class RemoteGlobalMetadataManager extends AbstractRemoteWritableEntityManager {
+
+    public static final TimeValue GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
+
+    public static final Setting<TimeValue> GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING = Setting.timeSetting(
+        "cluster.remote_store.state.global_metadata.upload_timeout",
+        GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    public static final int GLOBAL_METADATA_CURRENT_CODEC_VERSION = 1;
+
+    private volatile TimeValue globalMetadataUploadTimeout;
+    private final Compressor compressor;
+    private final NamedXContentRegistry namedXContentRegistry;
+    private final NamedWriteableRegistry namedWriteableRegistry;
+
+    RemoteGlobalMetadataManager(
+        ClusterSettings clusterSettings,
+        String clusterName,
+        BlobStoreRepository blobStoreRepository,
+        BlobStoreTransferService blobStoreTransferService,
+        NamedWriteableRegistry namedWriteableRegistry,
+        ThreadPool threadpool
+    ) {
+        this.globalMetadataUploadTimeout = clusterSettings.get(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING);
+        this.compressor = blobStoreRepository.getCompressor();
+        this.namedXContentRegistry = blobStoreRepository.getNamedXContentRegistry();
+        this.namedWriteableRegistry = namedWriteableRegistry;
+        this.remoteWritableEntityStores.put(
+            RemoteGlobalMetadata.GLOBAL_METADATA,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.remoteWritableEntityStores.put(
+            RemoteCoordinationMetadata.COORDINATION_METADATA,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.remoteWritableEntityStores.put(
+            RemotePersistentSettingsMetadata.SETTING_METADATA,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.remoteWritableEntityStores.put(
+            RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.remoteWritableEntityStores.put(
+            RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.remoteWritableEntityStores.put(
+            RemoteTemplatesMetadata.TEMPLATES_METADATA,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.remoteWritableEntityStores.put(
+            RemoteCustomMetadata.CUSTOM_METADATA,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        clusterSettings.addSettingsUpdateConsumer(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING, this::setGlobalMetadataUploadTimeout);
+    }
+
+    @Override
+    protected ActionListener<Void> getWrappedWriteListener(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+    ) {
+        return ActionListener.wrap(
+            resp -> listener.onResponse(remoteEntity.getUploadedMetadata()),
+            ex -> listener.onFailure(new RemoteStateTransferException("Upload failed for " + component, remoteEntity, ex))
+        );
+    }
+
+    @Override
+    protected ActionListener<Object> getWrappedReadListener(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+        ActionListener<RemoteReadResult> listener
+    ) {
+        return ActionListener.wrap(
+            response -> listener.onResponse(new RemoteReadResult(response, remoteEntity.getType(), component)),
+            ex -> listener.onFailure(new RemoteStateTransferException("Download failed for " + component, remoteEntity, ex))
+        );
+    }
+
+    Metadata getGlobalMetadata(String clusterUUID, ClusterMetadataManifest clusterMetadataManifest) {
+        String globalMetadataFileName = clusterMetadataManifest.getGlobalMetadataFileName();
+        try {
+            // Fetch Global metadata
+            if (globalMetadataFileName != null) {
+                RemoteGlobalMetadata remoteGlobalMetadata = new RemoteGlobalMetadata(
+                    String.format(Locale.ROOT, METADATA_NAME_FORMAT, globalMetadataFileName),
+                    clusterUUID,
+                    compressor,
+                    namedXContentRegistry
+                );
+                return (Metadata) getStore(remoteGlobalMetadata).read(remoteGlobalMetadata);
+            } else if (clusterMetadataManifest.hasMetadataAttributesFiles()) {
+                // from CODEC_V2, we have started uploading all the metadata in granular files instead of a single entity
+                Metadata.Builder builder = new Metadata.Builder();
+                if (clusterMetadataManifest.getCoordinationMetadata().getUploadedFilename() != null) {
+                    RemoteCoordinationMetadata remoteCoordinationMetadata = new RemoteCoordinationMetadata(
+                        clusterMetadataManifest.getCoordinationMetadata().getUploadedFilename(),
+                        clusterUUID,
+                        compressor,
+                        namedXContentRegistry
+                    );
+                    builder.coordinationMetadata(
+                        (CoordinationMetadata) getStore(remoteCoordinationMetadata).read(remoteCoordinationMetadata)
+                    );
+                }
+                if (clusterMetadataManifest.getTemplatesMetadata().getUploadedFilename() != null) {
+                    RemoteTemplatesMetadata remoteTemplatesMetadata = new RemoteTemplatesMetadata(
+                        clusterMetadataManifest.getTemplatesMetadata().getUploadedFilename(),
+                        clusterUUID,
+                        compressor,
+                        namedXContentRegistry
+                    );
+                    builder.templates((TemplatesMetadata) getStore(remoteTemplatesMetadata).read(remoteTemplatesMetadata));
+                }
+                if (clusterMetadataManifest.getSettingsMetadata().getUploadedFilename() != null) {
+                    RemotePersistentSettingsMetadata remotePersistentSettingsMetadata = new RemotePersistentSettingsMetadata(
+                        clusterMetadataManifest.getSettingsMetadata().getUploadedFilename(),
+                        clusterUUID,
+                        compressor,
+                        namedXContentRegistry
+                    );
+                    builder.persistentSettings(
+                        (Settings) getStore(remotePersistentSettingsMetadata).read(remotePersistentSettingsMetadata)
+                    );
+                }
+                builder.clusterUUID(clusterMetadataManifest.getClusterUUID());
+                builder.clusterUUIDCommitted(clusterMetadataManifest.isClusterUUIDCommitted());
+                clusterMetadataManifest.getCustomMetadataMap().forEach((key, value) -> {
+                    try {
+                        RemoteCustomMetadata remoteCustomMetadata = new RemoteCustomMetadata(
+                            value.getUploadedFilename(),
+                            key,
+                            clusterUUID,
+                            compressor,
+                            namedWriteableRegistry
+                        );
+                        builder.putCustom(key, (Custom) getStore(remoteCustomMetadata).read(remoteCustomMetadata));
+                    } catch (IOException e) {
+                        throw new IllegalStateException(
+                            String.format(Locale.ROOT, "Error while downloading Custom Metadata - %s", value.getUploadedFilename()),
+                            e
+                        );
+                    }
+                });
+                return builder.build();
+            } else {
+                return Metadata.EMPTY_METADATA;
+            }
+        } catch (IOException e) {
+            throw new IllegalStateException(
+                String.format(Locale.ROOT, "Error while downloading Global Metadata - %s", globalMetadataFileName),
+                e
+            );
+        }
+    }
+
+    DiffableUtils.MapDiff<String, Metadata.Custom, Map<String, Metadata.Custom>> getCustomsDiff(
+        ClusterState currentState,
+        ClusterState previousState,
+        boolean firstUploadForSplitGlobalMetadata,
+        boolean isRemotePublicationEnabled
+    ) {
+        if (firstUploadForSplitGlobalMetadata) {
+            // For first split global metadata upload, we want to upload all customs
+            return DiffableUtils.diff(
+                Collections.emptyMap(),
+                filterCustoms(currentState.metadata().customs(), isRemotePublicationEnabled),
+                DiffableUtils.getStringKeySerializer(),
+                NonDiffableValueSerializer.getAbstractInstance()
+            );
+        }
+        return DiffableUtils.diff(
+            filterCustoms(previousState.metadata().customs(), isRemotePublicationEnabled),
+            filterCustoms(currentState.metadata().customs(), isRemotePublicationEnabled),
+            DiffableUtils.getStringKeySerializer(),
+            NonDiffableValueSerializer.getAbstractInstance()
+        );
+    }
+
+    public static Map<String, Metadata.Custom> filterCustoms(Map<String, Metadata.Custom> customs, boolean isRemotePublicationEnabled) {
+        if (isRemotePublicationEnabled) {
+            return customs;
+        }
+        return customs.entrySet()
+            .stream()
+            .filter(e -> e.getValue().context().contains(XContentContext.GATEWAY))
+            .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
+    }
+
+    boolean isGlobalMetadataEqual(ClusterMetadataManifest first, ClusterMetadataManifest second, String clusterName) {
+        Metadata secondGlobalMetadata = getGlobalMetadata(second.getClusterUUID(), second);
+        Metadata firstGlobalMetadata = getGlobalMetadata(first.getClusterUUID(), first);
+        return Metadata.isGlobalResourcesMetadataEquals(firstGlobalMetadata, secondGlobalMetadata);
+    }
+
+    private void setGlobalMetadataUploadTimeout(TimeValue newGlobalMetadataUploadTimeout) {
+        this.globalMetadataUploadTimeout = newGlobalMetadataUploadTimeout;
+    }
+
+    public TimeValue getGlobalMetadataUploadTimeout() {
+        return this.globalMetadataUploadTimeout;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteIndexMetadataManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteIndexMetadataManager.java
new file mode 100644
index 0000000000000..d1f08a7c2a33d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteIndexMetadataManager.java
@@ -0,0 +1,130 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.AbstractRemoteWritableEntityManager;
+import org.opensearch.common.remote.RemoteWriteableEntityBlobStore;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.model.RemoteIndexMetadata;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.Locale;
+
+/**
+ * A Manager which provides APIs to write and read Index Metadata to remote store
+ *
+ * @opensearch.internal
+ */
+public class RemoteIndexMetadataManager extends AbstractRemoteWritableEntityManager {
+
+    public static final TimeValue INDEX_METADATA_UPLOAD_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
+
+    public static final Setting<TimeValue> INDEX_METADATA_UPLOAD_TIMEOUT_SETTING = Setting.timeSetting(
+        "cluster.remote_store.state.index_metadata.upload_timeout",
+        INDEX_METADATA_UPLOAD_TIMEOUT_DEFAULT,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope,
+        Setting.Property.Deprecated
+    );
+
+    private final Compressor compressor;
+    private final NamedXContentRegistry namedXContentRegistry;
+
+    private volatile TimeValue indexMetadataUploadTimeout;
+
+    public RemoteIndexMetadataManager(
+        ClusterSettings clusterSettings,
+        String clusterName,
+        BlobStoreRepository blobStoreRepository,
+        BlobStoreTransferService blobStoreTransferService,
+        ThreadPool threadpool
+    ) {
+        this.remoteWritableEntityStores.put(
+            RemoteIndexMetadata.INDEX,
+            new RemoteWriteableEntityBlobStore<>(
+                blobStoreTransferService,
+                blobStoreRepository,
+                clusterName,
+                threadpool,
+                ThreadPool.Names.REMOTE_STATE_READ,
+                RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+            )
+        );
+        this.namedXContentRegistry = blobStoreRepository.getNamedXContentRegistry();
+        this.compressor = blobStoreRepository.getCompressor();
+        this.indexMetadataUploadTimeout = clusterSettings.get(INDEX_METADATA_UPLOAD_TIMEOUT_SETTING);
+        clusterSettings.addSettingsUpdateConsumer(INDEX_METADATA_UPLOAD_TIMEOUT_SETTING, this::setIndexMetadataUploadTimeout);
+    }
+
+    /**
+     * Fetch index metadata from remote cluster state
+     *
+     * @param uploadedIndexMetadata {@link ClusterMetadataManifest.UploadedIndexMetadata} contains details about remote location of index metadata
+     * @return {@link IndexMetadata}
+     */
+    IndexMetadata getIndexMetadata(ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata, String clusterUUID) {
+        RemoteIndexMetadata remoteIndexMetadata = new RemoteIndexMetadata(
+            RemoteClusterStateUtils.getFormattedIndexFileName(uploadedIndexMetadata.getUploadedFilename()),
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        try {
+            return (IndexMetadata) getStore(remoteIndexMetadata).read(remoteIndexMetadata);
+        } catch (IOException e) {
+            throw new IllegalStateException(
+                String.format(Locale.ROOT, "Error while downloading IndexMetadata - %s", uploadedIndexMetadata.getUploadedFilename()),
+                e
+            );
+        }
+    }
+
+    public TimeValue getIndexMetadataUploadTimeout() {
+        return this.indexMetadataUploadTimeout;
+    }
+
+    private void setIndexMetadataUploadTimeout(TimeValue newIndexMetadataUploadTimeout) {
+        this.indexMetadataUploadTimeout = newIndexMetadataUploadTimeout;
+    }
+
+    @Override
+    protected ActionListener<Void> getWrappedWriteListener(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+        ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+    ) {
+        return ActionListener.wrap(
+            resp -> listener.onResponse(remoteEntity.getUploadedMetadata()),
+            ex -> listener.onFailure(new RemoteStateTransferException("Upload failed for " + component, remoteEntity, ex))
+        );
+    }
+
+    @Override
+    protected ActionListener<Object> getWrappedReadListener(
+        String component,
+        AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+        ActionListener<RemoteReadResult> listener
+    ) {
+        return ActionListener.wrap(
+            response -> listener.onResponse(new RemoteReadResult(response, RemoteIndexMetadata.INDEX, component)),
+            ex -> listener.onFailure(new RemoteStateTransferException("Download failed for " + component, remoteEntity, ex))
+        );
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteManifestManager.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteManifestManager.java
new file mode 100644
index 0000000000000..47c847b5dc32a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteManifestManager.java
@@ -0,0 +1,325 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.Version;
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobMetadata;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.remote.RemoteWriteableEntityBlobStore;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.model.RemoteClusterMetadataManifest;
+import org.opensearch.gateway.remote.model.RemoteClusterStateManifestInfo;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+
+/**
+ * A Manager which provides APIs to write and read {@link ClusterMetadataManifest} to remote store
+ *
+ * @opensearch.internal
+ */
+public class RemoteManifestManager {
+
+    public static final TimeValue METADATA_MANIFEST_UPLOAD_TIMEOUT_DEFAULT = TimeValue.timeValueMillis(20000);
+
+    public static final Setting<TimeValue> METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING = Setting.timeSetting(
+        "cluster.remote_store.state.metadata_manifest.upload_timeout",
+        METADATA_MANIFEST_UPLOAD_TIMEOUT_DEFAULT,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+    private static final Logger logger = LogManager.getLogger(RemoteManifestManager.class);
+
+    private volatile TimeValue metadataManifestUploadTimeout;
+    private final String nodeId;
+    private final RemoteWriteableEntityBlobStore<ClusterMetadataManifest, RemoteClusterMetadataManifest> manifestBlobStore;
+    private final Compressor compressor;
+    private final NamedXContentRegistry namedXContentRegistry;
+    // todo remove blobStorerepo from here
+    private final BlobStoreRepository blobStoreRepository;
+
+    RemoteManifestManager(
+        ClusterSettings clusterSettings,
+        String clusterName,
+        String nodeId,
+        BlobStoreRepository blobStoreRepository,
+        BlobStoreTransferService blobStoreTransferService,
+        ThreadPool threadpool
+    ) {
+        this.metadataManifestUploadTimeout = clusterSettings.get(METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING);
+        this.nodeId = nodeId;
+        this.manifestBlobStore = new RemoteWriteableEntityBlobStore<>(
+            blobStoreTransferService,
+            blobStoreRepository,
+            clusterName,
+            threadpool,
+            ThreadPool.Names.REMOTE_STATE_READ,
+            RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+        );
+        ;
+        clusterSettings.addSettingsUpdateConsumer(METADATA_MANIFEST_UPLOAD_TIMEOUT_SETTING, this::setMetadataManifestUploadTimeout);
+        this.compressor = blobStoreRepository.getCompressor();
+        this.namedXContentRegistry = blobStoreRepository.getNamedXContentRegistry();
+        this.blobStoreRepository = blobStoreRepository;
+    }
+
+    RemoteClusterStateManifestInfo uploadManifest(
+        ClusterState clusterState,
+        RemoteClusterStateUtils.UploadedMetadataResults uploadedMetadataResult,
+        String previousClusterUUID,
+        ClusterStateDiffManifest clusterDiffManifest,
+        ClusterStateChecksum clusterStateChecksum,
+        boolean committed,
+        int codecVersion
+    ) {
+        synchronized (this) {
+            ClusterMetadataManifest.Builder manifestBuilder = ClusterMetadataManifest.builder();
+            manifestBuilder.clusterTerm(clusterState.term())
+                .stateVersion(clusterState.getVersion())
+                .clusterUUID(clusterState.metadata().clusterUUID())
+                .stateUUID(clusterState.stateUUID())
+                .opensearchVersion(Version.CURRENT)
+                .nodeId(nodeId)
+                .committed(committed)
+                .codecVersion(codecVersion)
+                .indices(uploadedMetadataResult.uploadedIndexMetadata)
+                .previousClusterUUID(previousClusterUUID)
+                .clusterUUIDCommitted(clusterState.metadata().clusterUUIDCommitted())
+                .coordinationMetadata(uploadedMetadataResult.uploadedCoordinationMetadata)
+                .settingMetadata(uploadedMetadataResult.uploadedSettingsMetadata)
+                .templatesMetadata(uploadedMetadataResult.uploadedTemplatesMetadata)
+                .customMetadataMap(uploadedMetadataResult.uploadedCustomMetadataMap)
+                .routingTableVersion(clusterState.getRoutingTable().version())
+                .indicesRouting(uploadedMetadataResult.uploadedIndicesRoutingMetadata)
+                .discoveryNodesMetadata(uploadedMetadataResult.uploadedDiscoveryNodes)
+                .clusterBlocksMetadata(uploadedMetadataResult.uploadedClusterBlocks)
+                .diffManifest(clusterDiffManifest)
+                .metadataVersion(clusterState.metadata().version())
+                .transientSettingsMetadata(uploadedMetadataResult.uploadedTransientSettingsMetadata)
+                .clusterStateCustomMetadataMap(uploadedMetadataResult.uploadedClusterStateCustomMetadataMap)
+                .hashesOfConsistentSettings(uploadedMetadataResult.uploadedHashesOfConsistentSettings)
+                .checksum(clusterStateChecksum);
+            final ClusterMetadataManifest manifest = manifestBuilder.build();
+            logger.trace(() -> new ParameterizedMessage("[{}] uploading manifest", manifest));
+            String manifestFileName = writeMetadataManifest(clusterState.metadata().clusterUUID(), manifest);
+            return new RemoteClusterStateManifestInfo(manifest, manifestFileName);
+        }
+    }
+
+    private String writeMetadataManifest(String clusterUUID, ClusterMetadataManifest uploadManifest) {
+        AtomicReference<String> result = new AtomicReference<String>();
+        AtomicReference<Exception> exceptionReference = new AtomicReference<Exception>();
+
+        // latch to wait until upload is not finished
+        CountDownLatch latch = new CountDownLatch(1);
+
+        LatchedActionListener completionListener = new LatchedActionListener<>(ActionListener.wrap(resp -> {
+            logger.trace(String.format(Locale.ROOT, "Manifest file uploaded successfully."));
+        }, ex -> { exceptionReference.set(ex); }), latch);
+
+        RemoteClusterMetadataManifest remoteClusterMetadataManifest = new RemoteClusterMetadataManifest(
+            uploadManifest,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        manifestBlobStore.writeAsync(remoteClusterMetadataManifest, completionListener);
+
+        try {
+            if (latch.await(getMetadataManifestUploadTimeout().millis(), TimeUnit.MILLISECONDS) == false) {
+                RemoteStateTransferException ex = new RemoteStateTransferException(
+                    String.format(Locale.ROOT, "Timed out waiting for transfer of manifest file to complete")
+                );
+                throw ex;
+            }
+        } catch (InterruptedException ex) {
+            RemoteStateTransferException exception = new RemoteStateTransferException(
+                String.format(Locale.ROOT, "Timed out waiting for transfer of manifest file to complete - %s"),
+                ex
+            );
+            Thread.currentThread().interrupt();
+            throw exception;
+        }
+        if (exceptionReference.get() != null) {
+            throw new RemoteStateTransferException(exceptionReference.get().getMessage(), exceptionReference.get());
+        }
+        logger.debug(
+            "Metadata manifest file [{}] written during [{}] phase. ",
+            remoteClusterMetadataManifest.getBlobFileName(),
+            uploadManifest.isCommitted() ? "commit" : "publish"
+        );
+        return remoteClusterMetadataManifest.getUploadedMetadata().getUploadedFilename();
+    }
+
+    /**
+     * Fetch latest ClusterMetadataManifest from remote state store
+     *
+     * @param clusterUUID uuid of cluster state to refer to in remote
+     * @param clusterName name of the cluster
+     * @return ClusterMetadataManifest
+     */
+    public Optional<ClusterMetadataManifest> getLatestClusterMetadataManifest(String clusterName, String clusterUUID) {
+        Optional<String> latestManifestFileName = getLatestManifestFileName(clusterName, clusterUUID);
+        return latestManifestFileName.map(s -> fetchRemoteClusterMetadataManifest(clusterName, clusterUUID, s));
+    }
+
+    public ClusterMetadataManifest getRemoteClusterMetadataManifestByFileName(String clusterUUID, String filename)
+        throws IllegalStateException {
+        try {
+            RemoteClusterMetadataManifest remoteClusterMetadataManifest = new RemoteClusterMetadataManifest(
+                filename,
+                clusterUUID,
+                compressor,
+                namedXContentRegistry
+            );
+            return manifestBlobStore.read(remoteClusterMetadataManifest);
+        } catch (IOException e) {
+            throw new IllegalStateException(String.format(Locale.ROOT, "Error while downloading cluster metadata - %s", filename), e);
+        }
+    }
+
+    /**
+     * Fetch ClusterMetadataManifest from remote state store
+     *
+     * @param clusterUUID uuid of cluster state to refer to in remote
+     * @param clusterName name of the cluster
+     * @return ClusterMetadataManifest
+     */
+    ClusterMetadataManifest fetchRemoteClusterMetadataManifest(String clusterName, String clusterUUID, String filename)
+        throws IllegalStateException {
+        try {
+            String fullBlobName = getManifestFolderPath(clusterName, clusterUUID).buildAsString() + filename;
+            RemoteClusterMetadataManifest remoteClusterMetadataManifest = new RemoteClusterMetadataManifest(
+                fullBlobName,
+                clusterUUID,
+                compressor,
+                namedXContentRegistry
+            );
+            return manifestBlobStore.read(remoteClusterMetadataManifest);
+        } catch (IOException e) {
+            throw new IllegalStateException(String.format(Locale.ROOT, "Error while downloading cluster metadata - %s", filename), e);
+        }
+    }
+
+    Map<String, ClusterMetadataManifest> getLatestManifestForAllClusterUUIDs(String clusterName, Set<String> clusterUUIDs) {
+        Map<String, ClusterMetadataManifest> manifestsByClusterUUID = new HashMap<>();
+        for (String clusterUUID : clusterUUIDs) {
+            try {
+                Optional<ClusterMetadataManifest> manifest = getLatestClusterMetadataManifest(clusterName, clusterUUID);
+                manifest.ifPresent(clusterMetadataManifest -> manifestsByClusterUUID.put(clusterUUID, clusterMetadataManifest));
+            } catch (Exception e) {
+                throw new IllegalStateException(
+                    String.format(Locale.ROOT, "Exception in fetching manifest for clusterUUID: %s", clusterUUID),
+                    e
+                );
+            }
+        }
+        return manifestsByClusterUUID;
+    }
+
+    private BlobContainer manifestContainer(String clusterName, String clusterUUID) {
+        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/manifest
+        return blobStoreRepository.blobStore().blobContainer(getManifestFolderPath(clusterName, clusterUUID));
+    }
+
+    BlobPath getManifestFolderPath(String clusterName, String clusterUUID) {
+        return RemoteClusterStateUtils.getClusterMetadataBasePath(blobStoreRepository, clusterName, clusterUUID)
+            .add(RemoteClusterMetadataManifest.MANIFEST);
+    }
+
+    public TimeValue getMetadataManifestUploadTimeout() {
+        return this.metadataManifestUploadTimeout;
+    }
+
+    private void setMetadataManifestUploadTimeout(TimeValue newMetadataManifestUploadTimeout) {
+        this.metadataManifestUploadTimeout = newMetadataManifestUploadTimeout;
+    }
+
+    /**
+     * Fetch ClusterMetadataManifest files from remote state store in order
+     *
+     * @param clusterUUID uuid of cluster state to refer to in remote
+     * @param clusterName name of the cluster
+     * @param limit max no of files to fetch
+     * @return all manifest file names
+     */
+    private List<BlobMetadata> getManifestFileNames(String clusterName, String clusterUUID, String filePrefix, int limit)
+        throws IllegalStateException {
+        try {
+
+            /*
+              {@link BlobContainer#listBlobsByPrefixInSortedOrder} will list the latest manifest file first
+              as the manifest file name generated via {@link RemoteClusterStateService#getManifestFileName} ensures
+              when sorted in LEXICOGRAPHIC order the latest uploaded manifest file comes on top.
+             */
+            return manifestContainer(clusterName, clusterUUID).listBlobsByPrefixInSortedOrder(
+                filePrefix,
+                limit,
+                BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
+            );
+        } catch (IOException e) {
+            throw new IllegalStateException("Error while fetching latest manifest file for remote cluster state", e);
+        }
+    }
+
+    static String getManifestFilePrefixForTermVersion(long term, long version) {
+        return String.join(
+            DELIMITER,
+            RemoteClusterMetadataManifest.MANIFEST,
+            RemoteStoreUtils.invertLong(term),
+            RemoteStoreUtils.invertLong(version)
+        ) + DELIMITER;
+    }
+
+    /**
+     * Fetch latest ClusterMetadataManifest file from remote state store
+     *
+     * @param clusterUUID uuid of cluster state to refer to in remote
+     * @param clusterName name of the cluster
+     * @return latest ClusterMetadataManifest filename
+     */
+    private Optional<String> getLatestManifestFileName(String clusterName, String clusterUUID) throws IllegalStateException {
+        List<BlobMetadata> manifestFilesMetadata = getManifestFileNames(
+            clusterName,
+            clusterUUID,
+            RemoteClusterMetadataManifest.MANIFEST + DELIMITER,
+            1
+        );
+        if (manifestFilesMetadata != null && !manifestFilesMetadata.isEmpty()) {
+            return Optional.of(manifestFilesMetadata.get(0).name());
+        }
+        logger.info("No manifest file present in remote store for cluster name: {}, cluster UUID: {}", clusterName, clusterUUID);
+        return Optional.empty();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemotePersistenceStats.java b/server/src/main/java/org/opensearch/gateway/remote/RemotePersistenceStats.java
index f2330846fa23e..417ebdafd3ba7 100644
--- a/server/src/main/java/org/opensearch/gateway/remote/RemotePersistenceStats.java
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemotePersistenceStats.java
@@ -10,28 +10,96 @@
 
 import org.opensearch.cluster.coordination.PersistedStateStats;
 
-import java.util.concurrent.atomic.AtomicLong;
-
 /**
  * Remote state related extended stats.
  *
  * @opensearch.internal
  */
-public class RemotePersistenceStats extends PersistedStateStats {
-    static final String CLEANUP_ATTEMPT_FAILED_COUNT = "cleanup_attempt_failed_count";
-    static final String REMOTE_UPLOAD = "remote_upload";
-    private AtomicLong cleanupAttemptFailedCount = new AtomicLong(0);
+public class RemotePersistenceStats {
+
+    RemoteUploadStats remoteUploadStats;
+    PersistedStateStats remoteDiffDownloadStats;
+    PersistedStateStats remoteFullDownloadStats;
+
+    final String FULL_DOWNLOAD_STATS = "remote_full_download";
+    final String DIFF_DOWNLOAD_STATS = "remote_diff_download";
 
     public RemotePersistenceStats() {
-        super(REMOTE_UPLOAD);
-        addToExtendedFields(CLEANUP_ATTEMPT_FAILED_COUNT, cleanupAttemptFailedCount);
+        remoteUploadStats = new RemoteUploadStats();
+        remoteDiffDownloadStats = new PersistedStateStats(DIFF_DOWNLOAD_STATS);
+        remoteFullDownloadStats = new PersistedStateStats(FULL_DOWNLOAD_STATS);
     }
 
     public void cleanUpAttemptFailed() {
-        cleanupAttemptFailedCount.incrementAndGet();
+        remoteUploadStats.cleanUpAttemptFailed();
     }
 
     public long getCleanupAttemptFailedCount() {
-        return cleanupAttemptFailedCount.get();
+        return remoteUploadStats.getCleanupAttemptFailedCount();
+    }
+
+    public void indexRoutingFilesCleanupAttemptFailed() {
+        remoteUploadStats.indexRoutingFilesCleanupAttemptFailed();
+    }
+
+    public long getIndexRoutingFilesCleanupAttemptFailedCount() {
+        return remoteUploadStats.getIndexRoutingFilesCleanupAttemptFailedCount();
+    }
+
+    public void indicesRoutingDiffFileCleanupAttemptFailed() {
+        remoteUploadStats.indicesRoutingDiffFileCleanupAttemptFailed();
+    }
+
+    public long getIndicesRoutingDiffFileCleanupAttemptFailedCount() {
+        return remoteUploadStats.getIndicesRoutingDiffFileCleanupAttemptFailedCount();
+    }
+
+    public void stateUploadSucceeded() {
+        remoteUploadStats.stateSucceeded();
+    }
+
+    public void stateUploadTook(long durationMillis) {
+        remoteUploadStats.stateTook(durationMillis);
+    }
+
+    public void stateUploadFailed() {
+        remoteUploadStats.stateFailed();
+    }
+
+    public void stateFullDownloadSucceeded() {
+        remoteFullDownloadStats.stateSucceeded();
+    }
+
+    public void stateDiffDownloadSucceeded() {
+        remoteDiffDownloadStats.stateSucceeded();
+    }
+
+    public void stateFullDownloadTook(long durationMillis) {
+        remoteFullDownloadStats.stateTook(durationMillis);
+    }
+
+    public void stateDiffDownloadTook(long durationMillis) {
+        remoteDiffDownloadStats.stateTook(durationMillis);
+    }
+
+    public void stateFullDownloadFailed() {
+        remoteFullDownloadStats.stateFailed();
     }
+
+    public void stateDiffDownloadFailed() {
+        remoteDiffDownloadStats.stateFailed();
+    }
+
+    public PersistedStateStats getUploadStats() {
+        return remoteUploadStats;
+    }
+
+    public PersistedStateStats getRemoteDiffDownloadStats() {
+        return remoteDiffDownloadStats;
+    }
+
+    public PersistedStateStats getRemoteFullDownloadStats() {
+        return remoteFullDownloadStats;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteStateTransferException.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteStateTransferException.java
new file mode 100644
index 0000000000000..5b75b6c18ee5b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteStateTransferException.java
@@ -0,0 +1,45 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.common.remote.RemoteWriteableEntity;
+
+/**
+ * Exception for Remote state transfer.
+ */
+public class RemoteStateTransferException extends RuntimeException {
+    private RemoteWriteableEntity<?> entity;
+
+    public RemoteStateTransferException(String errorDesc) {
+        super(errorDesc);
+    }
+
+    public RemoteStateTransferException(String errorDesc, Throwable cause) {
+        super(errorDesc, cause);
+    }
+
+    public RemoteStateTransferException(String errorDesc, RemoteWriteableEntity<?> entity) {
+        super(errorDesc);
+        this.entity = entity;
+    }
+
+    public RemoteStateTransferException(String errorDesc, RemoteWriteableEntity<?> entity, Throwable cause) {
+        super(errorDesc, cause);
+        this.entity = entity;
+    }
+
+    @Override
+    public String toString() {
+        String message = super.toString();
+        if (entity != null) {
+            message += ", failed entity:" + entity;
+        }
+        return message;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/RemoteUploadStats.java b/server/src/main/java/org/opensearch/gateway/remote/RemoteUploadStats.java
new file mode 100644
index 0000000000000..9ffef65ae1eba
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/RemoteUploadStats.java
@@ -0,0 +1,59 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.cluster.coordination.PersistedStateStats;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * Upload stats for remote state
+ *
+ * @opensearch.internal
+ */
+public class RemoteUploadStats extends PersistedStateStats {
+    static final String CLEANUP_ATTEMPT_FAILED_COUNT = "cleanup_attempt_failed_count";
+    static final String INDEX_ROUTING_FILES_CLEANUP_ATTEMPT_FAILED_COUNT = "index_routing_files_cleanup_attempt_failed_count";
+    static final String INDICES_ROUTING_DIFF_FILES_CLEANUP_ATTEMPT_FAILED_COUNT = "indices_routing_diff_files_cleanup_attempt_failed_count";
+    static final String REMOTE_UPLOAD = "remote_upload";
+    private AtomicLong cleanupAttemptFailedCount = new AtomicLong(0);
+    private AtomicLong indexRoutingFilesCleanupAttemptFailedCount = new AtomicLong(0);
+    private AtomicLong indicesRoutingDiffFilesCleanupAttemptFailedCount = new AtomicLong(0);
+
+    public RemoteUploadStats() {
+        super(REMOTE_UPLOAD);
+        addToExtendedFields(CLEANUP_ATTEMPT_FAILED_COUNT, cleanupAttemptFailedCount);
+        addToExtendedFields(INDEX_ROUTING_FILES_CLEANUP_ATTEMPT_FAILED_COUNT, indexRoutingFilesCleanupAttemptFailedCount);
+        addToExtendedFields(INDICES_ROUTING_DIFF_FILES_CLEANUP_ATTEMPT_FAILED_COUNT, indicesRoutingDiffFilesCleanupAttemptFailedCount);
+    }
+
+    public void cleanUpAttemptFailed() {
+        cleanupAttemptFailedCount.incrementAndGet();
+    }
+
+    public long getCleanupAttemptFailedCount() {
+        return cleanupAttemptFailedCount.get();
+    }
+
+    public void indexRoutingFilesCleanupAttemptFailed() {
+        indexRoutingFilesCleanupAttemptFailedCount.incrementAndGet();
+    }
+
+    public long getIndexRoutingFilesCleanupAttemptFailedCount() {
+        return indexRoutingFilesCleanupAttemptFailedCount.get();
+    }
+
+    public void indicesRoutingDiffFileCleanupAttemptFailed() {
+        indicesRoutingDiffFilesCleanupAttemptFailedCount.incrementAndGet();
+    }
+
+    public long getIndicesRoutingDiffFileCleanupAttemptFailedCount() {
+        return indicesRoutingDiffFilesCleanupAttemptFailedCount.get();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterBlocks.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterBlocks.java
new file mode 100644
index 0000000000000..101daaa143a66
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterBlocks.java
@@ -0,0 +1,93 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_EPHEMERAL_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+
+/**
+ * Wrapper class for uploading/downloading {@link ClusterBlocks} to/from remote blob store
+ */
+public class RemoteClusterBlocks extends AbstractClusterMetadataWriteableBlobEntity<ClusterBlocks> {
+
+    public static final String CLUSTER_BLOCKS = "blocks";
+    public static final ChecksumWritableBlobStoreFormat<ClusterBlocks> CLUSTER_BLOCKS_FORMAT = new ChecksumWritableBlobStoreFormat<>(
+        "blocks",
+        ClusterBlocks::readFrom
+    );
+
+    private ClusterBlocks clusterBlocks;
+    private long stateVersion;
+
+    public RemoteClusterBlocks(final ClusterBlocks clusterBlocks, long stateVersion, String clusterUUID, final Compressor compressor) {
+        super(clusterUUID, compressor, null);
+        this.clusterBlocks = clusterBlocks;
+        this.stateVersion = stateVersion;
+    }
+
+    public RemoteClusterBlocks(final String blobName, final String clusterUUID, final Compressor compressor) {
+        super(clusterUUID, compressor, null);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of(CLUSTER_STATE_EPHEMERAL_PATH_TOKEN), CLUSTER_BLOCKS);
+    }
+
+    @Override
+    public String getType() {
+        return CLUSTER_BLOCKS;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/transient/<componentPrefix>__<inverted_state_version>__<inverted__timestamp>__<codec_version>
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(stateVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedMetadataAttribute(CLUSTER_BLOCKS, blobName);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return CLUSTER_BLOCKS_FORMAT.serialize(clusterBlocks, generateBlobFileName(), getCompressor()).streamInput();
+    }
+
+    @Override
+    public ClusterBlocks deserialize(final InputStream inputStream) throws IOException {
+        return CLUSTER_BLOCKS_FORMAT.deserialize(blobName, Streams.readFully(inputStream));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifest.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifest.java
new file mode 100644
index 0000000000000..999beaa4e865d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifest.java
@@ -0,0 +1,170 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+
+/**
+ * Wrapper class for uploading/downloading {@link ClusterMetadataManifest} to/from remote blob store
+ */
+public class RemoteClusterMetadataManifest extends AbstractClusterMetadataWriteableBlobEntity<ClusterMetadataManifest> {
+
+    public static final String MANIFEST = "manifest";
+    public static final int SPLITTED_MANIFEST_FILE_LENGTH = 6;
+
+    public static final String METADATA_MANIFEST_NAME_FORMAT = "%s";
+
+    public static final String COMMITTED = "C";
+    public static final String PUBLISHED = "P";
+
+    /**
+     * Manifest format compatible with older codec v0, where codec version was missing.
+     */
+    public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT_V0 =
+        new ChecksumBlobStoreFormat<>("cluster-metadata-manifest", METADATA_MANIFEST_NAME_FORMAT, ClusterMetadataManifest::fromXContentV0);
+    /**
+     * Manifest format compatible with older codec v1, where global metadata was missing.
+     */
+    public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT_V1 =
+        new ChecksumBlobStoreFormat<>("cluster-metadata-manifest", METADATA_MANIFEST_NAME_FORMAT, ClusterMetadataManifest::fromXContentV1);
+
+    public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT_V2 =
+        new ChecksumBlobStoreFormat<>("cluster-metadata-manifest", METADATA_MANIFEST_NAME_FORMAT, ClusterMetadataManifest::fromXContentV2);
+
+    public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT_V3 =
+        new ChecksumBlobStoreFormat<>("cluster-metadata-manifest", METADATA_MANIFEST_NAME_FORMAT, ClusterMetadataManifest::fromXContentV3);
+
+    /**
+     * Manifest format compatible with codec v2, where we introduced codec versions/global metadata.
+     */
+    public static final ChecksumBlobStoreFormat<ClusterMetadataManifest> CLUSTER_METADATA_MANIFEST_FORMAT = new ChecksumBlobStoreFormat<>(
+        "cluster-metadata-manifest",
+        METADATA_MANIFEST_NAME_FORMAT,
+        ClusterMetadataManifest::fromXContent
+    );
+
+    private ClusterMetadataManifest clusterMetadataManifest;
+
+    public RemoteClusterMetadataManifest(
+        final ClusterMetadataManifest clusterMetadataManifest,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.clusterMetadataManifest = clusterMetadataManifest;
+    }
+
+    public RemoteClusterMetadataManifest(
+        final String blobName,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of(MANIFEST), MANIFEST);
+    }
+
+    @Override
+    public String getType() {
+        return MANIFEST;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/manifest/manifest__<inverted_term>__<inverted_version>__C/P__<inverted__timestamp>__
+        // <codec_version>
+        String blobFileName = String.join(
+            DELIMITER,
+            MANIFEST,
+            RemoteStoreUtils.invertLong(clusterMetadataManifest.getClusterTerm()),
+            RemoteStoreUtils.invertLong(clusterMetadataManifest.getStateVersion()),
+            (clusterMetadataManifest.isCommitted() ? COMMITTED : PUBLISHED),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(clusterMetadataManifest.getCodecVersion())
+            // Keep the codec version at last place only, during we read last place to determine codec version.
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedMetadataAttribute(MANIFEST, blobName);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return CLUSTER_METADATA_MANIFEST_FORMAT.serialize(
+            clusterMetadataManifest,
+            generateBlobFileName(),
+            getCompressor(),
+            RemoteClusterStateUtils.FORMAT_PARAMS
+        ).streamInput();
+    }
+
+    @Override
+    public ClusterMetadataManifest deserialize(final InputStream inputStream) throws IOException {
+        ChecksumBlobStoreFormat<ClusterMetadataManifest> blobStoreFormat = getClusterMetadataManifestBlobStoreFormat();
+        return blobStoreFormat.deserialize(blobName, getNamedXContentRegistry(), Streams.readFully(inputStream));
+    }
+
+    // package private for testing
+    int getManifestCodecVersion() {
+        assert blobName != null;
+        String[] splitName = getBlobFileName().split(DELIMITER);
+        if (splitName.length == SPLITTED_MANIFEST_FILE_LENGTH) {
+            return Integer.parseInt(splitName[splitName.length - 1]); // Last value would be codec version.
+        } else if (splitName.length < SPLITTED_MANIFEST_FILE_LENGTH) { // Where codec is not part of file name, i.e. default codec version 0
+            // is used.
+            return ClusterMetadataManifest.CODEC_V0;
+        } else {
+            throw new IllegalArgumentException("Manifest file name is corrupted : " + blobName);
+        }
+    }
+
+    private ChecksumBlobStoreFormat<ClusterMetadataManifest> getClusterMetadataManifestBlobStoreFormat() {
+        long codecVersion = getManifestCodecVersion();
+        if (codecVersion == ClusterMetadataManifest.MANIFEST_CURRENT_CODEC_VERSION) {
+            return CLUSTER_METADATA_MANIFEST_FORMAT;
+        } else if (codecVersion == ClusterMetadataManifest.CODEC_V3) {
+            return CLUSTER_METADATA_MANIFEST_FORMAT_V3;
+        } else if (codecVersion == ClusterMetadataManifest.CODEC_V2) {
+            return CLUSTER_METADATA_MANIFEST_FORMAT_V2;
+        } else if (codecVersion == ClusterMetadataManifest.CODEC_V1) {
+            return CLUSTER_METADATA_MANIFEST_FORMAT_V1;
+        } else if (codecVersion == ClusterMetadataManifest.CODEC_V0) {
+            return CLUSTER_METADATA_MANIFEST_FORMAT_V0;
+        }
+        throw new IllegalArgumentException("Cluster metadata manifest file is corrupted, don't have valid codec version");
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateCustoms.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateCustoms.java
new file mode 100644
index 0000000000000..e5e44525520f4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateCustoms.java
@@ -0,0 +1,128 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ClusterState.Custom;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_EPHEMERAL_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CUSTOM_DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+
+/**
+ * Wrapper class for uploading/downloading {@link Custom} to/from remote blob store
+ */
+public class RemoteClusterStateCustoms extends AbstractClusterMetadataWriteableBlobEntity<Custom> {
+    public static final String CLUSTER_STATE_CUSTOM = "cluster-state-custom";
+    public final ChecksumWritableBlobStoreFormat<ClusterState.Custom> clusterStateCustomsFormat;
+
+    private long stateVersion;
+    private final String customType;
+    private ClusterState.Custom custom;
+    private final NamedWriteableRegistry namedWriteableRegistry;
+
+    public RemoteClusterStateCustoms(
+        final ClusterState.Custom custom,
+        final String customType,
+        final long stateVersion,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedWriteableRegistry namedWriteableRegistry
+    ) {
+        super(clusterUUID, compressor, null);
+        this.stateVersion = stateVersion;
+        this.customType = customType;
+        this.custom = custom;
+        this.namedWriteableRegistry = namedWriteableRegistry;
+        this.clusterStateCustomsFormat = new ChecksumWritableBlobStoreFormat<>(
+            "cluster-state-custom",
+            is -> readFrom(is, namedWriteableRegistry, customType)
+        );
+    }
+
+    public RemoteClusterStateCustoms(
+        final String blobName,
+        final String customType,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedWriteableRegistry namedWriteableRegistry
+    ) {
+        super(clusterUUID, compressor, null);
+        this.blobName = blobName;
+        this.customType = customType;
+        this.namedWriteableRegistry = namedWriteableRegistry;
+        this.clusterStateCustomsFormat = new ChecksumWritableBlobStoreFormat<>(
+            "cluster-state-custom",
+            is -> readFrom(is, namedWriteableRegistry, customType)
+        );
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        String prefix = String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, customType);
+        return new BlobPathParameters(List.of(CLUSTER_STATE_EPHEMERAL_PATH_TOKEN), prefix);
+    }
+
+    @Override
+    public String getType() {
+        return CLUSTER_STATE_CUSTOM;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/ephemeral/<componentPrefix>__<inverted_state_version>__<inverted__timestamp>__<codec_version>
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(stateVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public ClusterMetadataManifest.UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new ClusterMetadataManifest.UploadedMetadataAttribute(
+            String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, customType),
+            blobName
+        );
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return clusterStateCustomsFormat.serialize(custom, generateBlobFileName(), getCompressor()).streamInput();
+    }
+
+    @Override
+    public ClusterState.Custom deserialize(final InputStream inputStream) throws IOException {
+        return clusterStateCustomsFormat.deserialize(blobName, Streams.readFully(inputStream));
+    }
+
+    public static ClusterState.Custom readFrom(StreamInput streamInput, NamedWriteableRegistry namedWriteableRegistry, String customType)
+        throws IOException {
+        return namedWriteableRegistry.getReader(ClusterState.Custom.class, customType).read(streamInput);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateManifestInfo.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateManifestInfo.java
new file mode 100644
index 0000000000000..5d987e5e21e1a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteClusterStateManifestInfo.java
@@ -0,0 +1,33 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+
+/**
+ * A class encapsulating the cluster state manifest and its remote uploaded path
+ */
+public class RemoteClusterStateManifestInfo {
+
+    private final ClusterMetadataManifest clusterMetadataManifest;
+    private final String manifestFileName;
+
+    public RemoteClusterStateManifestInfo(final ClusterMetadataManifest manifest, final String manifestFileName) {
+        this.clusterMetadataManifest = manifest;
+        this.manifestFileName = manifestFileName;
+    }
+
+    public ClusterMetadataManifest getClusterMetadataManifest() {
+        return clusterMetadataManifest;
+    }
+
+    public String getManifestFileName() {
+        return manifestFileName;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteCoordinationMetadata.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteCoordinationMetadata.java
new file mode 100644
index 0000000000000..63cc96e3e02c4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteCoordinationMetadata.java
@@ -0,0 +1,112 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.METADATA_NAME_PLAIN_FORMAT;
+
+/**
+ * Wrapper class for uploading/downloading {@link CoordinationMetadata} to/from remote blob store
+ */
+public class RemoteCoordinationMetadata extends AbstractClusterMetadataWriteableBlobEntity<CoordinationMetadata> {
+
+    public static final String COORDINATION_METADATA = "coordination";
+    public static final ChecksumBlobStoreFormat<CoordinationMetadata> COORDINATION_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
+        "coordination",
+        METADATA_NAME_PLAIN_FORMAT,
+        CoordinationMetadata::fromXContent
+    );
+
+    private CoordinationMetadata coordinationMetadata;
+    private long metadataVersion;
+
+    public RemoteCoordinationMetadata(
+        final CoordinationMetadata coordinationMetadata,
+        final long metadataVersion,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.coordinationMetadata = coordinationMetadata;
+        this.metadataVersion = metadataVersion;
+    }
+
+    public RemoteCoordinationMetadata(
+        final String blobName,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of("global-metadata"), COORDINATION_METADATA);
+    }
+
+    @Override
+    public String getType() {
+        return COORDINATION_METADATA;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/global-metadata/<componentPrefix>__<inverted_metadata_version>__<inverted__timestamp>__<codec_version>
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(metadataVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return COORDINATION_METADATA_FORMAT.serialize(
+            coordinationMetadata,
+            generateBlobFileName(),
+            getCompressor(),
+            RemoteClusterStateUtils.FORMAT_PARAMS
+        ).streamInput();
+    }
+
+    @Override
+    public CoordinationMetadata deserialize(final InputStream inputStream) throws IOException {
+        return COORDINATION_METADATA_FORMAT.deserialize(blobName, getNamedXContentRegistry(), Streams.readFully(inputStream));
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedMetadataAttribute(COORDINATION_METADATA, blobName);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteCustomMetadata.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteCustomMetadata.java
new file mode 100644
index 0000000000000..8e850e903954a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteCustomMetadata.java
@@ -0,0 +1,130 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.metadata.Metadata.Custom;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.common.io.stream.NamedWriteableAwareStreamInput;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN;
+
+/**
+ * Wrapper class for uploading/downloading {@link Custom} to/from remote blob store
+ */
+public class RemoteCustomMetadata extends AbstractClusterMetadataWriteableBlobEntity<Custom> {
+
+    public static final String CUSTOM_METADATA = "custom";
+    public static final String CUSTOM_DELIMITER = "--";
+    public final ChecksumWritableBlobStoreFormat<Custom> customBlobStoreFormat;
+
+    private Custom custom;
+    private final String customType;
+    private long metadataVersion;
+    private final NamedWriteableRegistry namedWriteableRegistry;
+
+    public RemoteCustomMetadata(
+        final Custom custom,
+        final String customType,
+        final long metadataVersion,
+        final String clusterUUID,
+        Compressor compressor,
+        NamedWriteableRegistry namedWriteableRegistry
+    ) {
+        super(clusterUUID, compressor, null);
+        this.custom = custom;
+        this.customType = customType;
+        this.metadataVersion = metadataVersion;
+        this.namedWriteableRegistry = namedWriteableRegistry;
+        this.customBlobStoreFormat = new ChecksumWritableBlobStoreFormat<>(
+            "custom",
+            is -> readFrom(is, namedWriteableRegistry, customType)
+        );
+    }
+
+    public RemoteCustomMetadata(
+        final String blobName,
+        final String customType,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedWriteableRegistry namedWriteableRegistry
+    ) {
+        super(clusterUUID, compressor, null);
+        this.blobName = blobName;
+        this.customType = customType;
+        this.namedWriteableRegistry = namedWriteableRegistry;
+        this.customBlobStoreFormat = new ChecksumWritableBlobStoreFormat<>(
+            "custom",
+            is -> readFrom(is, namedWriteableRegistry, customType)
+        );
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        String prefix = String.join(CUSTOM_DELIMITER, CUSTOM_METADATA, customType);
+        return new BlobPathParameters(List.of(GLOBAL_METADATA_PATH_TOKEN), prefix);
+    }
+
+    @Override
+    public String getType() {
+        return CUSTOM_METADATA;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/global-metadata/<componentPrefix>__<inverted_metadata_version>__<inverted__timestamp>__
+        // <codec_version>
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(metadataVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return customBlobStoreFormat.serialize(custom, generateBlobFileName(), getCompressor()).streamInput();
+    }
+
+    @Override
+    public Custom deserialize(final InputStream inputStream) throws IOException {
+        return customBlobStoreFormat.deserialize(blobName, Streams.readFully(inputStream));
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedMetadataAttribute(String.join(CUSTOM_DELIMITER, CUSTOM_METADATA, customType), blobName);
+    }
+
+    public static Custom readFrom(StreamInput streamInput, NamedWriteableRegistry namedWriteableRegistry, String customType)
+        throws IOException {
+        try (StreamInput in = new NamedWriteableAwareStreamInput(streamInput, namedWriteableRegistry)) {
+            return namedWriteableRegistry.getReader(Custom.class, customType).read(in);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteDiscoveryNodes.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteDiscoveryNodes.java
new file mode 100644
index 0000000000000..829036c6d122b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteDiscoveryNodes.java
@@ -0,0 +1,103 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_EPHEMERAL_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+
+/**
+ * Wrapper class for uploading/downloading {@link DiscoveryNodes} to/from remote blob store
+ */
+public class RemoteDiscoveryNodes extends AbstractClusterMetadataWriteableBlobEntity<DiscoveryNodes> {
+
+    public static final String DISCOVERY_NODES = "nodes";
+    public static final ChecksumWritableBlobStoreFormat<DiscoveryNodes> DISCOVERY_NODES_FORMAT = new ChecksumWritableBlobStoreFormat<>(
+        "nodes",
+        is -> DiscoveryNodes.readFrom(is, null)
+    );
+
+    private DiscoveryNodes discoveryNodes;
+    private long stateVersion;
+
+    public RemoteDiscoveryNodes(
+        final DiscoveryNodes discoveryNodes,
+        final long stateVersion,
+        final String clusterUUID,
+        final Compressor compressor
+    ) {
+        super(clusterUUID, compressor, null);
+        this.discoveryNodes = discoveryNodes;
+        this.stateVersion = stateVersion;
+    }
+
+    public RemoteDiscoveryNodes(final String blobName, final String clusterUUID, final Compressor compressor) {
+        super(clusterUUID, compressor, null);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of(CLUSTER_STATE_EPHEMERAL_PATH_TOKEN), DISCOVERY_NODES);
+    }
+
+    @Override
+    public String getType() {
+        return DISCOVERY_NODES;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/ephemeral/<componentPrefix>__<inverted_state_version>__<inverted__timestamp>__<codec_version>
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(stateVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedMetadataAttribute(DISCOVERY_NODES, blobName);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return DISCOVERY_NODES_FORMAT.serialize(
+            (out, discoveryNode) -> discoveryNode.writeToWithAttribute(out),
+            discoveryNodes,
+            generateBlobFileName(),
+            getCompressor()
+        ).streamInput();
+    }
+
+    @Override
+    public DiscoveryNodes deserialize(final InputStream inputStream) throws IOException {
+        return DISCOVERY_NODES_FORMAT.deserialize(blobName, Streams.readFully(inputStream));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteGlobalMetadata.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteGlobalMetadata.java
new file mode 100644
index 0000000000000..0082f873f8dba
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteGlobalMetadata.java
@@ -0,0 +1,76 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.METADATA_NAME_FORMAT;
+
+/**
+ * Wrapper class for uploading/downloading global metadata ({@link Metadata}) to/from remote blob store
+ */
+public class RemoteGlobalMetadata extends AbstractClusterMetadataWriteableBlobEntity<Metadata> {
+    public static final String GLOBAL_METADATA = "global_metadata";
+
+    public static final ChecksumBlobStoreFormat<Metadata> GLOBAL_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
+        "metadata",
+        METADATA_NAME_FORMAT,
+        Metadata::fromXContent
+    );
+
+    public RemoteGlobalMetadata(
+        final String blobName,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public String getType() {
+        return GLOBAL_METADATA;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Metadata deserialize(final InputStream inputStream) throws IOException {
+        return GLOBAL_METADATA_FORMAT.deserialize(blobName, getNamedXContentRegistry(), Streams.readFully(inputStream));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteHashesOfConsistentSettings.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteHashesOfConsistentSettings.java
new file mode 100644
index 0000000000000..dee48237e5c4c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteHashesOfConsistentSettings.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.metadata.DiffableStringMap;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN;
+
+/**
+ * Wrapper class for uploading/downloading {@link DiffableStringMap} to/from remote blob store
+ */
+public class RemoteHashesOfConsistentSettings extends AbstractClusterMetadataWriteableBlobEntity<DiffableStringMap> {
+    public static final String HASHES_OF_CONSISTENT_SETTINGS = "hashes-of-consistent-settings";
+    public static final ChecksumWritableBlobStoreFormat<DiffableStringMap> HASHES_OF_CONSISTENT_SETTINGS_FORMAT =
+        new ChecksumWritableBlobStoreFormat<>("hashes-of-consistent-settings", DiffableStringMap::readFrom);
+
+    private DiffableStringMap hashesOfConsistentSettings;
+    private long metadataVersion;
+
+    public RemoteHashesOfConsistentSettings(
+        final DiffableStringMap hashesOfConsistentSettings,
+        final long metadataVersion,
+        final String clusterUUID,
+        final Compressor compressor
+    ) {
+        super(clusterUUID, compressor, null);
+        this.metadataVersion = metadataVersion;
+        this.hashesOfConsistentSettings = hashesOfConsistentSettings;
+    }
+
+    public RemoteHashesOfConsistentSettings(final String blobName, final String clusterUUID, final Compressor compressor) {
+        super(clusterUUID, compressor, null);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of(GLOBAL_METADATA_PATH_TOKEN), HASHES_OF_CONSISTENT_SETTINGS);
+    }
+
+    @Override
+    public String getType() {
+        return HASHES_OF_CONSISTENT_SETTINGS;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(metadataVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public ClusterMetadataManifest.UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new ClusterMetadataManifest.UploadedMetadataAttribute(HASHES_OF_CONSISTENT_SETTINGS, blobName);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return HASHES_OF_CONSISTENT_SETTINGS_FORMAT.serialize(hashesOfConsistentSettings, generateBlobFileName(), getCompressor())
+            .streamInput();
+    }
+
+    @Override
+    public DiffableStringMap deserialize(final InputStream inputStream) throws IOException {
+        return HASHES_OF_CONSISTENT_SETTINGS_FORMAT.deserialize(blobName, Streams.readFully(inputStream));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteIndexMetadata.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteIndexMetadata.java
new file mode 100644
index 0000000000000..5308f92c633b1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteIndexMetadata.java
@@ -0,0 +1,111 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedIndexMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.METADATA_NAME_PLAIN_FORMAT;
+
+/**
+ * Wrapper class for uploading/downloading {@link IndexMetadata} to/from remote blob store
+ */
+public class RemoteIndexMetadata extends AbstractClusterMetadataWriteableBlobEntity<IndexMetadata> {
+
+    public static final int INDEX_METADATA_CURRENT_CODEC_VERSION = 2;
+
+    public static final ChecksumBlobStoreFormat<IndexMetadata> INDEX_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
+        "index-metadata",
+        METADATA_NAME_PLAIN_FORMAT,
+        IndexMetadata::fromXContent
+    );
+    public static final String INDEX = "index";
+
+    private IndexMetadata indexMetadata;
+
+    public RemoteIndexMetadata(
+        final IndexMetadata indexMetadata,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.indexMetadata = indexMetadata;
+    }
+
+    public RemoteIndexMetadata(
+        final String blobName,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of(INDEX, indexMetadata.getIndexUUID()), "metadata");
+    }
+
+    @Override
+    public String getType() {
+        return INDEX;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        String blobFileName = String.join(
+            RemoteClusterStateUtils.DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(indexMetadata.getVersion()),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(INDEX_METADATA_CURRENT_CODEC_VERSION) // Keep the codec version at last place only, during reads we read last
+            // place to determine codec version.
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedIndexMetadata(indexMetadata.getIndex().getName(), indexMetadata.getIndexUUID(), blobName);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return INDEX_METADATA_FORMAT.serialize(
+            indexMetadata,
+            generateBlobFileName(),
+            getCompressor(),
+            RemoteClusterStateUtils.FORMAT_PARAMS
+        ).streamInput();
+    }
+
+    @Override
+    public IndexMetadata deserialize(final InputStream inputStream) throws IOException {
+        // Blob name parameter is redundant
+        return INDEX_METADATA_FORMAT.deserialize(blobName, getNamedXContentRegistry(), Streams.readFully(inputStream));
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemotePersistentSettingsMetadata.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemotePersistentSettingsMetadata.java
new file mode 100644
index 0000000000000..81042f289254c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemotePersistentSettingsMetadata.java
@@ -0,0 +1,112 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.METADATA_NAME_PLAIN_FORMAT;
+
+/**
+ * Wrapper class for uploading/downloading persistent {@link Settings} to/from remote blob store
+ */
+public class RemotePersistentSettingsMetadata extends AbstractClusterMetadataWriteableBlobEntity<Settings> {
+
+    public static final String SETTING_METADATA = "settings";
+
+    public static final ChecksumBlobStoreFormat<Settings> SETTINGS_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
+        "settings",
+        METADATA_NAME_PLAIN_FORMAT,
+        Settings::fromXContent
+    );
+
+    private Settings persistentSettings;
+    private long metadataVersion;
+
+    public RemotePersistentSettingsMetadata(
+        final Settings settings,
+        final long metadataVersion,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.persistentSettings = settings;
+        this.metadataVersion = metadataVersion;
+    }
+
+    public RemotePersistentSettingsMetadata(
+        final String blobName,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of("global-metadata"), SETTING_METADATA);
+    }
+
+    @Override
+    public String getType() {
+        return SETTING_METADATA;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(metadataVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return SETTINGS_METADATA_FORMAT.serialize(
+            persistentSettings,
+            generateBlobFileName(),
+            getCompressor(),
+            RemoteClusterStateUtils.FORMAT_PARAMS
+        ).streamInput();
+    }
+
+    @Override
+    public Settings deserialize(final InputStream inputStream) throws IOException {
+        return SETTINGS_METADATA_FORMAT.deserialize(blobName, getNamedXContentRegistry(), Streams.readFully(inputStream));
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedMetadataAttribute(SETTING_METADATA, blobName);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteReadResult.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteReadResult.java
new file mode 100644
index 0000000000000..06d3b88ae1ecf
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteReadResult.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+/**
+ * Container class for entity read from remote store
+ */
+public class RemoteReadResult {
+
+    Object obj;
+    String component;
+    String componentName;
+
+    public RemoteReadResult(Object obj, String component, String componentName) {
+        this.obj = obj;
+        this.component = component;
+        this.componentName = componentName;
+    }
+
+    public Object getObj() {
+        return obj;
+    }
+
+    public String getComponent() {
+        return component;
+    }
+
+    public String getComponentName() {
+        return componentName;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStore.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStore.java
new file mode 100644
index 0000000000000..912861ffd8370
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStore.java
@@ -0,0 +1,118 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.RemoteWriteableBlobEntity;
+import org.opensearch.common.remote.RemoteWriteableEntity;
+import org.opensearch.common.remote.RemoteWriteableEntityBlobStore;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+
+/**
+ * Extends the RemoteClusterStateBlobStore to support {@link RemoteIndexRoutingTable}
+ *
+ * @param <IndexRoutingTable> which can be uploaded to / downloaded from blob store
+ * @param <U> The concrete class implementing {@link RemoteWriteableEntity} which is used as a wrapper for IndexRoutingTable entity.
+ */
+public class RemoteRoutingTableBlobStore<IndexRoutingTable, U extends AbstractClusterMetadataWriteableBlobEntity<IndexRoutingTable>> extends
+    RemoteWriteableEntityBlobStore<IndexRoutingTable, U> {
+
+    /**
+     * This setting is used to set the remote routing table store blob store path type strategy.
+     */
+    public static final Setting<RemoteStoreEnums.PathType> REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING = new Setting<>(
+        "cluster.remote_store.routing_table.path_type",
+        RemoteStoreEnums.PathType.HASHED_PREFIX.toString(),
+        RemoteStoreEnums.PathType::parseString,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    /**
+     * This setting is used to set the remote routing table store blob store path hash algorithm strategy.
+     * This setting will come to effect if the {@link #REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING}
+     * is either {@code HASHED_PREFIX} or {@code HASHED_INFIX}.
+     */
+    public static final Setting<RemoteStoreEnums.PathHashAlgorithm> REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING = new Setting<>(
+        "cluster.remote_store.routing_table.path_hash_algo",
+        RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64.toString(),
+        RemoteStoreEnums.PathHashAlgorithm::parseString,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    private RemoteStoreEnums.PathType pathType;
+    private RemoteStoreEnums.PathHashAlgorithm pathHashAlgo;
+
+    public RemoteRoutingTableBlobStore(
+        BlobStoreTransferService blobStoreTransferService,
+        BlobStoreRepository blobStoreRepository,
+        String clusterName,
+        ThreadPool threadPool,
+        String executor,
+        ClusterSettings clusterSettings
+    ) {
+        super(
+            blobStoreTransferService,
+            blobStoreRepository,
+            clusterName,
+            threadPool,
+            executor,
+            RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN
+        );
+        this.pathType = clusterSettings.get(REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING);
+        this.pathHashAlgo = clusterSettings.get(REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING);
+        clusterSettings.addSettingsUpdateConsumer(REMOTE_ROUTING_TABLE_PATH_TYPE_SETTING, this::setPathTypeSetting);
+        clusterSettings.addSettingsUpdateConsumer(REMOTE_ROUTING_TABLE_PATH_HASH_ALGO_SETTING, this::setPathHashAlgoSetting);
+    }
+
+    @Override
+    public BlobPath getBlobPathForUpload(final RemoteWriteableBlobEntity<IndexRoutingTable> obj) {
+        assert obj.getBlobPathParameters().getPathTokens().size() == 1 : "Unexpected tokens in RemoteRoutingTableObject";
+        BlobPath indexRoutingPath = getBlobPathPrefix(obj.clusterUUID()).add(INDEX_ROUTING_TABLE);
+
+        BlobPath path = pathType.path(
+            RemoteStorePathStrategy.BasePathInput.builder()
+                .basePath(indexRoutingPath)
+                .indexUUID(String.join("", obj.getBlobPathParameters().getPathTokens()))
+                .build(),
+            pathHashAlgo
+        );
+        return path;
+    }
+
+    private void setPathTypeSetting(RemoteStoreEnums.PathType pathType) {
+        this.pathType = pathType;
+    }
+
+    private void setPathHashAlgoSetting(RemoteStoreEnums.PathHashAlgorithm pathHashAlgo) {
+        this.pathHashAlgo = pathHashAlgo;
+    }
+
+    // For testing only
+    protected RemoteStoreEnums.PathType getPathTypeSetting() {
+        return pathType;
+    }
+
+    // For testing only
+    protected RemoteStoreEnums.PathHashAlgorithm getPathHashAlgoSetting() {
+        return pathHashAlgo;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteTemplatesMetadata.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteTemplatesMetadata.java
new file mode 100644
index 0000000000000..6ae8a533f9a21
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteTemplatesMetadata.java
@@ -0,0 +1,113 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.METADATA_NAME_PLAIN_FORMAT;
+
+/**
+ * Wrapper class for uploading/downloading {@link TemplatesMetadata} to/from remote blob store
+ */
+public class RemoteTemplatesMetadata extends AbstractClusterMetadataWriteableBlobEntity<TemplatesMetadata> {
+
+    public static final String TEMPLATES_METADATA = "templates";
+
+    public static final ChecksumBlobStoreFormat<TemplatesMetadata> TEMPLATES_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
+        "templates",
+        METADATA_NAME_PLAIN_FORMAT,
+        TemplatesMetadata::fromXContent
+    );
+    private TemplatesMetadata templatesMetadata;
+    private long metadataVersion;
+
+    public RemoteTemplatesMetadata(
+        final TemplatesMetadata templatesMetadata,
+        final long metadataVersion,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.templatesMetadata = templatesMetadata;
+        this.metadataVersion = metadataVersion;
+    }
+
+    public RemoteTemplatesMetadata(
+        final String blobName,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of("global-metadata"), TEMPLATES_METADATA);
+    }
+
+    @Override
+    public String getType() {
+        return TEMPLATES_METADATA;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        // 123456789012_test-cluster/cluster-state/dsgYj10Nkso7/global-metadata/<componentPrefix>__<inverted_metadata_version>__<inverted__timestamp>__
+        // <codec_version>
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(metadataVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return TEMPLATES_METADATA_FORMAT.serialize(
+            templatesMetadata,
+            generateBlobFileName(),
+            getCompressor(),
+            RemoteClusterStateUtils.FORMAT_PARAMS
+        ).streamInput();
+    }
+
+    @Override
+    public TemplatesMetadata deserialize(final InputStream inputStream) throws IOException {
+        return TEMPLATES_METADATA_FORMAT.deserialize(blobName, getNamedXContentRegistry(), Streams.readFully(inputStream));
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedMetadataAttribute(TEMPLATES_METADATA, blobName);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/RemoteTransientSettingsMetadata.java b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteTransientSettingsMetadata.java
new file mode 100644
index 0000000000000..d4f3837f80084
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/RemoteTransientSettingsMetadata.java
@@ -0,0 +1,113 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.METADATA_NAME_FORMAT;
+
+/**
+ * Wrapper class for uploading/downloading transient {@link Settings} to/from remote blob store
+ */
+public class RemoteTransientSettingsMetadata extends AbstractClusterMetadataWriteableBlobEntity<Settings> {
+
+    public static final String TRANSIENT_SETTING_METADATA = "transient-settings";
+
+    public static final ChecksumBlobStoreFormat<Settings> SETTINGS_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
+        "transient-settings",
+        METADATA_NAME_FORMAT,
+        Settings::fromXContent
+    );
+
+    private Settings transientSettings;
+    private long metadataVersion;
+
+    public RemoteTransientSettingsMetadata(
+        final Settings transientSettings,
+        final long metadataVersion,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.transientSettings = transientSettings;
+        this.metadataVersion = metadataVersion;
+    }
+
+    public RemoteTransientSettingsMetadata(
+        final String blobName,
+        final String clusterUUID,
+        final Compressor compressor,
+        final NamedXContentRegistry namedXContentRegistry
+    ) {
+        super(clusterUUID, compressor, namedXContentRegistry);
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of(GLOBAL_METADATA_PATH_TOKEN), TRANSIENT_SETTING_METADATA);
+    }
+
+    @Override
+    public String getType() {
+        return TRANSIENT_SETTING_METADATA;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        String blobFileName = String.join(
+            DELIMITER,
+            getBlobPathParameters().getFilePrefix(),
+            RemoteStoreUtils.invertLong(metadataVersion),
+            RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+            String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)
+        );
+        this.blobFileName = blobFileName;
+        return blobFileName;
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return SETTINGS_METADATA_FORMAT.serialize(
+            transientSettings,
+            generateBlobFileName(),
+            getCompressor(),
+            RemoteClusterStateUtils.FORMAT_PARAMS
+        ).streamInput();
+    }
+
+    @Override
+    public Settings deserialize(final InputStream inputStream) throws IOException {
+        return SETTINGS_METADATA_FORMAT.deserialize(blobName, getNamedXContentRegistry(), Streams.readFully(inputStream));
+    }
+
+    @Override
+    public UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new UploadedMetadataAttribute(TRANSIENT_SETTING_METADATA, blobName);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/model/package-info.java b/server/src/main/java/org/opensearch/gateway/remote/model/package-info.java
new file mode 100644
index 0000000000000..c0d13d15cc885
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/model/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Package containing models for remote cluster state
+ */
+package org.opensearch.gateway.remote.model;
diff --git a/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTable.java b/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTable.java
new file mode 100644
index 0000000000000..46c5074c48eb8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTable.java
@@ -0,0 +1,114 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.routingtable;
+
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.index.Index;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+
+/**
+ * Remote store object for IndexRoutingTable
+ */
+public class RemoteIndexRoutingTable extends AbstractClusterMetadataWriteableBlobEntity<IndexRoutingTable> {
+
+    public static final String INDEX_ROUTING_TABLE = "index-routing";
+    public static final String INDEX_ROUTING_METADATA_PREFIX = "indexRouting--";
+    public static final String INDEX_ROUTING_FILE = "index_routing";
+    private IndexRoutingTable indexRoutingTable;
+    private final Index index;
+    private long term;
+    private long version;
+    private BlobPathParameters blobPathParameters;
+    public static final ChecksumWritableBlobStoreFormat<IndexRoutingTable> INDEX_ROUTING_TABLE_FORMAT =
+        new ChecksumWritableBlobStoreFormat<>("index-routing-table", IndexRoutingTable::readFrom);
+
+    public RemoteIndexRoutingTable(
+        IndexRoutingTable indexRoutingTable,
+        String clusterUUID,
+        Compressor compressor,
+        long term,
+        long version
+    ) {
+        super(clusterUUID, compressor);
+        this.index = indexRoutingTable.getIndex();
+        this.indexRoutingTable = indexRoutingTable;
+        this.term = term;
+        this.version = version;
+    }
+
+    /**
+     * Reads data from inputStream and creates RemoteIndexRoutingTable object with the {@link IndexRoutingTable}
+     * @param blobName name of the blob, which contains the index routing data
+     * @param clusterUUID UUID of the cluster
+     * @param compressor Compressor object
+     */
+    public RemoteIndexRoutingTable(String blobName, String clusterUUID, Compressor compressor) {
+        super(clusterUUID, compressor);
+        this.index = null;
+        this.term = -1;
+        this.version = -1;
+        this.blobName = blobName;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        if (blobPathParameters == null) {
+            blobPathParameters = new BlobPathParameters(List.of(indexRoutingTable.getIndex().getUUID()), INDEX_ROUTING_FILE);
+        }
+        return blobPathParameters;
+    }
+
+    @Override
+    public String getType() {
+        return INDEX_ROUTING_TABLE;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        if (blobFileName == null) {
+            blobFileName = String.join(
+                DELIMITER,
+                getBlobPathParameters().getFilePrefix(),
+                RemoteStoreUtils.invertLong(term),
+                RemoteStoreUtils.invertLong(version),
+                RemoteStoreUtils.invertLong(System.currentTimeMillis())
+            );
+        }
+        return blobFileName;
+    }
+
+    @Override
+    public ClusterMetadataManifest.UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        assert index != null;
+        return new ClusterMetadataManifest.UploadedIndexMetadata(index.getName(), index.getUUID(), blobName, INDEX_ROUTING_METADATA_PREFIX);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        return INDEX_ROUTING_TABLE_FORMAT.serialize(indexRoutingTable, generateBlobFileName(), getCompressor()).streamInput();
+    }
+
+    @Override
+    public IndexRoutingTable deserialize(InputStream in) throws IOException {
+        return INDEX_ROUTING_TABLE_FORMAT.deserialize(blobName, Streams.readFully(in));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteRoutingTableDiff.java b/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteRoutingTableDiff.java
new file mode 100644
index 0000000000000..b3e0e9e5763b7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/routingtable/RemoteRoutingTableDiff.java
@@ -0,0 +1,138 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.routingtable;
+
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
+import org.opensearch.common.io.Streams;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+
+/**
+ * Represents a incremental difference between {@link org.opensearch.cluster.routing.RoutingTable} objects that can be serialized and deserialized.
+ * This class is responsible for writing and reading the differences between RoutingTables to and from an input/output stream.
+ */
+public class RemoteRoutingTableDiff extends AbstractClusterMetadataWriteableBlobEntity<Diff<RoutingTable>> {
+
+    private final RoutingTableIncrementalDiff routingTableIncrementalDiff;
+
+    private long term;
+    private long version;
+
+    public static final String ROUTING_TABLE_DIFF = "routing-table-diff";
+
+    public static final String ROUTING_TABLE_DIFF_METADATA_PREFIX = "routingTableDiff--";
+
+    public static final String ROUTING_TABLE_DIFF_FILE = "routing_table_diff";
+    private static final String codec = "RemoteRoutingTableDiff";
+    public static final String ROUTING_TABLE_DIFF_PATH_TOKEN = "routing-table-diff";
+
+    public static final int VERSION = 1;
+
+    public static final ChecksumWritableBlobStoreFormat<RoutingTableIncrementalDiff> REMOTE_ROUTING_TABLE_DIFF_FORMAT =
+        new ChecksumWritableBlobStoreFormat<>(codec, RoutingTableIncrementalDiff::readFrom);
+
+    /**
+     * Constructs a new RemoteRoutingTableDiff with the given differences.
+     *
+     * @param routingTableIncrementalDiff a RoutingTableIncrementalDiff object containing the differences of {@link IndexRoutingTable}.
+     * @param clusterUUID the cluster UUID.
+     * @param compressor the compressor to be used.
+     * @param term the term of the routing table.
+     * @param version the version of the routing table.
+     */
+    public RemoteRoutingTableDiff(
+        RoutingTableIncrementalDiff routingTableIncrementalDiff,
+        String clusterUUID,
+        Compressor compressor,
+        long term,
+        long version
+    ) {
+        super(clusterUUID, compressor);
+        this.routingTableIncrementalDiff = routingTableIncrementalDiff;
+        this.term = term;
+        this.version = version;
+    }
+
+    /**
+     * Constructs a new RemoteIndexRoutingTableDiff with the given blob name, cluster UUID, and compressor.
+     *
+     * @param blobName the name of the blob.
+     * @param clusterUUID the cluster UUID.
+     * @param compressor the compressor to be used.
+     */
+    public RemoteRoutingTableDiff(String blobName, String clusterUUID, Compressor compressor) {
+        super(clusterUUID, compressor);
+        this.routingTableIncrementalDiff = null;
+        this.blobName = blobName;
+    }
+
+    /**
+     * Gets the map of differences of {@link IndexRoutingTable}.
+     *
+     * @return a map containing the differences.
+     */
+    public Diff<RoutingTable> getDiffs() {
+        return routingTableIncrementalDiff;
+    }
+
+    @Override
+    public BlobPathParameters getBlobPathParameters() {
+        return new BlobPathParameters(List.of(ROUTING_TABLE_DIFF_PATH_TOKEN), ROUTING_TABLE_DIFF_METADATA_PREFIX);
+    }
+
+    @Override
+    public String getType() {
+        return ROUTING_TABLE_DIFF;
+    }
+
+    @Override
+    public String generateBlobFileName() {
+        if (blobFileName == null) {
+            blobFileName = String.join(
+                DELIMITER,
+                getBlobPathParameters().getFilePrefix(),
+                RemoteStoreUtils.invertLong(term),
+                RemoteStoreUtils.invertLong(version),
+                RemoteStoreUtils.invertLong(System.currentTimeMillis())
+            );
+        }
+        return blobFileName;
+    }
+
+    @Override
+    public ClusterMetadataManifest.UploadedMetadata getUploadedMetadata() {
+        assert blobName != null;
+        return new ClusterMetadataManifest.UploadedMetadataAttribute(ROUTING_TABLE_DIFF_FILE, blobName);
+    }
+
+    @Override
+    public InputStream serialize() throws IOException {
+        assert routingTableIncrementalDiff != null;
+        return REMOTE_ROUTING_TABLE_DIFF_FORMAT.serialize(routingTableIncrementalDiff, generateBlobFileName(), getCompressor())
+            .streamInput();
+    }
+
+    @Override
+    public Diff<RoutingTable> deserialize(InputStream in) throws IOException {
+        return REMOTE_ROUTING_TABLE_DIFF_FORMAT.deserialize(blobName, Streams.readFully(in));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/gateway/remote/routingtable/package-info.java b/server/src/main/java/org/opensearch/gateway/remote/routingtable/package-info.java
new file mode 100644
index 0000000000000..a6cb2251a5dd7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/gateway/remote/routingtable/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Package containing class to perform operations on remote routing table.
+ */
+package org.opensearch.gateway.remote.routingtable;
diff --git a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
index 257aca2b67990..991fbf12072be 100644
--- a/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/AbstractHttpServerTransport.java
@@ -357,6 +357,16 @@ protected void serverAcceptedChannel(HttpChannel httpChannel) {
         logger.trace(() -> new ParameterizedMessage("Http channel accepted: {}", httpChannel));
     }
 
+    /**
+     * This method handles an incoming http request as a stream.
+     *
+     * @param httpRequest that is incoming
+     * @param httpChannel that received the http request
+     */
+    public void incomingStream(HttpRequest httpRequest, final StreamingHttpChannel httpChannel) {
+        handleIncomingRequest(httpRequest, httpChannel, httpRequest.getInboundException());
+    }
+
     /**
      * This method handles an incoming http request.
      *
@@ -438,29 +448,56 @@ private void handleIncomingRequest(final HttpRequest httpRequest, final HttpChan
             RestChannel innerChannel;
             ThreadContext threadContext = threadPool.getThreadContext();
             try {
-                innerChannel = new DefaultRestChannel(
-                    httpChannel,
-                    httpRequest,
-                    restRequest,
-                    bigArrays,
-                    handlingSettings,
-                    threadContext,
-                    corsHandler,
-                    trace
-                );
+                if (httpChannel instanceof StreamingHttpChannel) {
+                    innerChannel = new DefaultStreamingRestChannel(
+                        (StreamingHttpChannel) httpChannel,
+                        httpRequest,
+                        restRequest,
+                        bigArrays,
+                        handlingSettings,
+                        threadContext,
+                        corsHandler,
+                        trace
+                    );
+                } else {
+                    innerChannel = new DefaultRestChannel(
+                        httpChannel,
+                        httpRequest,
+                        restRequest,
+                        bigArrays,
+                        handlingSettings,
+                        threadContext,
+                        corsHandler,
+                        trace
+                    );
+                }
             } catch (final IllegalArgumentException e) {
                 badRequestCause = ExceptionsHelper.useOrSuppress(badRequestCause, e);
                 final RestRequest innerRequest = RestRequest.requestWithoutParameters(xContentRegistry, httpRequest, httpChannel);
-                innerChannel = new DefaultRestChannel(
-                    httpChannel,
-                    httpRequest,
-                    innerRequest,
-                    bigArrays,
-                    handlingSettings,
-                    threadContext,
-                    corsHandler,
-                    trace
-                );
+
+                if (httpChannel instanceof StreamingHttpChannel) {
+                    innerChannel = new DefaultStreamingRestChannel(
+                        (StreamingHttpChannel) httpChannel,
+                        httpRequest,
+                        innerRequest,
+                        bigArrays,
+                        handlingSettings,
+                        threadContext,
+                        corsHandler,
+                        trace
+                    );
+                } else {
+                    innerChannel = new DefaultRestChannel(
+                        httpChannel,
+                        httpRequest,
+                        innerRequest,
+                        bigArrays,
+                        handlingSettings,
+                        threadContext,
+                        corsHandler,
+                        trace
+                    );
+                }
             }
             channel = innerChannel;
         }
diff --git a/server/src/main/java/org/opensearch/http/DefaultRestChannel.java b/server/src/main/java/org/opensearch/http/DefaultRestChannel.java
index ef93914b6677c..7e85525bc4d1f 100644
--- a/server/src/main/java/org/opensearch/http/DefaultRestChannel.java
+++ b/server/src/main/java/org/opensearch/http/DefaultRestChannel.java
@@ -57,11 +57,11 @@
 
 /**
  * The default rest channel for incoming requests. This class implements the basic logic for sending a rest
- * response. It will set necessary headers nad ensure that bytes are released after the response is sent.
+ * response. It will set necessary headers and ensure that bytes are released after the response is sent.
  *
  * @opensearch.internal
  */
-public class DefaultRestChannel extends AbstractRestChannel implements RestChannel {
+class DefaultRestChannel extends AbstractRestChannel implements RestChannel {
 
     static final String CLOSE = "close";
     static final String CONNECTION = "connection";
diff --git a/server/src/main/java/org/opensearch/http/DefaultStreamingRestChannel.java b/server/src/main/java/org/opensearch/http/DefaultStreamingRestChannel.java
new file mode 100644
index 0000000000000..7d8445294a4f3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/http/DefaultStreamingRestChannel.java
@@ -0,0 +1,107 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http;
+
+import org.opensearch.common.Nullable;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.io.stream.ReleasableBytesStreamOutput;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.util.BigArrays;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.StreamingRestChannel;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.reactivestreams.Subscriber;
+
+import static org.opensearch.tasks.Task.X_OPAQUE_ID;
+
+/**
+ * The streaming rest channel for incoming requests. This class implements the logic for sending a streaming
+ * rest in chunks response. It will set necessary headers and ensure that bytes are released after the full
+ * response is sent.
+ *
+ * @opensearch.internal
+ */
+class DefaultStreamingRestChannel extends DefaultRestChannel implements StreamingRestChannel {
+    private final StreamingHttpChannel streamingHttpChannel;
+    @Nullable
+    private final HttpTracer tracerLog;
+
+    DefaultStreamingRestChannel(
+        StreamingHttpChannel streamingHttpChannel,
+        HttpRequest httpRequest,
+        RestRequest request,
+        BigArrays bigArrays,
+        HttpHandlingSettings settings,
+        ThreadContext threadContext,
+        CorsHandler corsHandler,
+        @Nullable HttpTracer tracerLog
+    ) {
+        super(streamingHttpChannel, httpRequest, request, bigArrays, settings, threadContext, corsHandler, tracerLog);
+        this.streamingHttpChannel = streamingHttpChannel;
+        this.tracerLog = tracerLog;
+    }
+
+    @Override
+    public void subscribe(Subscriber<? super HttpChunk> subscriber) {
+        streamingHttpChannel.subscribe(subscriber);
+    }
+
+    @Override
+    public void sendChunk(HttpChunk chunk) {
+        String opaque = null;
+        boolean success = false;
+        final List<Releasable> toClose = new ArrayList<>(3);
+        String contentLength = null;
+
+        try {
+            opaque = request.header(X_OPAQUE_ID);
+            contentLength = String.valueOf(chunk.content().length());
+            toClose.add(chunk);
+
+            BytesStreamOutput bytesStreamOutput = newBytesOutput();
+            if (bytesStreamOutput instanceof ReleasableBytesStreamOutput) {
+                toClose.add((Releasable) bytesStreamOutput);
+            }
+
+            ActionListener<Void> listener = ActionListener.wrap(() -> Releasables.close(toClose));
+            streamingHttpChannel.sendChunk(chunk, listener);
+            success = true;
+        } finally {
+            if (success == false) {
+                Releasables.close(toClose);
+            }
+            if (tracerLog != null) {
+                tracerLog.traceChunk(chunk, streamingHttpChannel, contentLength, opaque, request.getRequestId(), success);
+            }
+        }
+    }
+
+    @Override
+    public void prepareResponse(RestStatus status, Map<String, List<String>> headers) {
+        streamingHttpChannel.prepareResponse(status.getStatus(), headers);
+    }
+
+    @Override
+    public boolean isReadable() {
+        return streamingHttpChannel.isReadable();
+    }
+
+    @Override
+    public boolean isWritable() {
+        return streamingHttpChannel.isWritable();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/http/HttpChannel.java b/server/src/main/java/org/opensearch/http/HttpChannel.java
index ed20ec89a9099..7048f08faff9f 100644
--- a/server/src/main/java/org/opensearch/http/HttpChannel.java
+++ b/server/src/main/java/org/opensearch/http/HttpChannel.java
@@ -77,7 +77,7 @@ default void handleException(Exception ex) {}
 
     /**
      * Returns the contextual property associated with this specific HTTP channel (the
-     * implementation of how such properties are managed depends on the the particular
+     * implementation of how such properties are managed depends on the particular
      * transport engine).
      *
      * @param name the name of the property
diff --git a/server/src/main/java/org/opensearch/http/HttpChunk.java b/server/src/main/java/org/opensearch/http/HttpChunk.java
new file mode 100644
index 0000000000000..7bcb526fe17bb
--- /dev/null
+++ b/server/src/main/java/org/opensearch/http/HttpChunk.java
@@ -0,0 +1,33 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.core.common.bytes.BytesReference;
+
+/**
+ * Represents a chunk of the HTTP request / response stream
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface HttpChunk extends Releasable {
+    /**
+     * Signals this is the last chunk of the stream.
+     * @return "true" if this is the last chunk of the stream, "false" otherwise
+     */
+    boolean isLast();
+
+    /**
+    * Returns the content of this chunk
+    * @return the content of this chunk
+    */
+    BytesReference content();
+}
diff --git a/server/src/main/java/org/opensearch/http/HttpServerTransport.java b/server/src/main/java/org/opensearch/http/HttpServerTransport.java
index 012b69c29c1d4..f58d604151fd0 100644
--- a/server/src/main/java/org/opensearch/http/HttpServerTransport.java
+++ b/server/src/main/java/org/opensearch/http/HttpServerTransport.java
@@ -38,8 +38,12 @@
 import org.opensearch.core.common.transport.BoundTransportAddress;
 import org.opensearch.core.service.ReportingService;
 import org.opensearch.rest.RestChannel;
+import org.opensearch.rest.RestHandler;
 import org.opensearch.rest.RestRequest;
 
+import java.util.Map;
+import java.util.Optional;
+
 /**
  * HTTP Transport server
  *
@@ -61,6 +65,17 @@ public interface HttpServerTransport extends LifecycleComponent, ReportingServic
      * Dispatches HTTP requests.
      */
     interface Dispatcher {
+        /**
+         * Finds the matching {@link RestHandler} that the request is going to be dispatched to, if any.
+         * @param uri request URI
+         * @param rawPath request raw path
+         * @param method request HTTP method
+         * @param params request parameters
+         * @return matching {@link RestHandler} that the request is going to be dispatched to, {@code Optional.empty()} if none match
+         */
+        default Optional<RestHandler> dispatchHandler(String uri, String rawPath, RestRequest.Method method, Map<String, String> params) {
+            return Optional.empty();
+        }
 
         /**
          * Dispatches the {@link RestRequest} to the relevant request handler or responds to the given rest channel directly if
diff --git a/server/src/main/java/org/opensearch/http/HttpTracer.java b/server/src/main/java/org/opensearch/http/HttpTracer.java
index 7a763b9ffb790..de1da4a20e294 100644
--- a/server/src/main/java/org/opensearch/http/HttpTracer.java
+++ b/server/src/main/java/org/opensearch/http/HttpTracer.java
@@ -128,6 +128,36 @@ void traceResponse(
         );
     }
 
+    /**
+     * Logs the response chunk to a request that was logged by {@link #maybeTraceRequest(RestRequest, Exception)}.
+     *
+     * @param chunk         response chunk
+     * @param httpChannel   HttpChannel the response was sent on
+     * @param contentLength Value of the response content length header
+     * @param opaqueHeader  Value of HTTP header {@link Task#X_OPAQUE_ID}
+     * @param requestId     Request id as returned by {@link RestRequest#getRequestId()}
+     * @param success       Whether the response was successfully sent
+     */
+    void traceChunk(
+        HttpChunk chunk,
+        StreamingHttpChannel httpChannel,
+        String contentLength,
+        String opaqueHeader,
+        long requestId,
+        boolean success
+    ) {
+        logger.trace(
+            new ParameterizedMessage(
+                "[{}][{}][{}] sent next chunk to [{}] success [{}]",
+                requestId,
+                opaqueHeader,
+                contentLength,
+                httpChannel,
+                success
+            )
+        );
+    }
+
     private void setTracerLogInclude(List<String> tracerLogInclude) {
         this.tracerLogInclude = tracerLogInclude.toArray(Strings.EMPTY_ARRAY);
     }
diff --git a/server/src/main/java/org/opensearch/http/StreamingHttpChannel.java b/server/src/main/java/org/opensearch/http/StreamingHttpChannel.java
new file mode 100644
index 0000000000000..9bab25cb537ed
--- /dev/null
+++ b/server/src/main/java/org/opensearch/http/StreamingHttpChannel.java
@@ -0,0 +1,56 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.http;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.action.ActionListener;
+
+import java.util.List;
+import java.util.Map;
+
+import org.reactivestreams.Publisher;
+
+/**
+ * Represents an HTTP communication channel with streaming capabilities.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface StreamingHttpChannel extends HttpChannel, Publisher<HttpChunk> {
+    /**
+     * Sends the next {@link HttpChunk} to the response stream
+     * @param chunk response chunk to send to channel
+     */
+    void sendChunk(HttpChunk chunk, ActionListener<Void> listener);
+
+    /**
+     * Receives the next {@link HttpChunk} from the request stream
+     * @param chunk next {@link HttpChunk}
+     */
+    void receiveChunk(HttpChunk chunk);
+
+    /**
+     * Prepares response before kicking of content streaming
+     * @param status response status
+     * @param headers response headers
+     */
+    void prepareResponse(int status, Map<String, List<String>> headers);
+
+    /**
+     * Returns {@code true} is this channel is ready for streaming request data, {@code false} otherwise
+     * @return {@code true} is this channel is ready for streaming request data, {@code false} otherwise
+     */
+    boolean isReadable();
+
+    /**
+     * Returns {@code true} is this channel is ready for streaming response data, {@code false} otherwise
+     * @return {@code true} is this channel is ready for streaming response data, {@code false} otherwise
+     */
+    boolean isWritable();
+}
diff --git a/server/src/main/java/org/opensearch/identity/IdentityService.java b/server/src/main/java/org/opensearch/identity/IdentityService.java
index c85ad451549de..83704ba371f05 100644
--- a/server/src/main/java/org/opensearch/identity/IdentityService.java
+++ b/server/src/main/java/org/opensearch/identity/IdentityService.java
@@ -11,7 +11,10 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.identity.noop.NoopIdentityPlugin;
 import org.opensearch.identity.tokens.TokenManager;
+import org.opensearch.plugins.IdentityAwarePlugin;
 import org.opensearch.plugins.IdentityPlugin;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.util.List;
 import java.util.stream.Collectors;
@@ -27,12 +30,12 @@ public class IdentityService {
     private final Settings settings;
     private final IdentityPlugin identityPlugin;
 
-    public IdentityService(final Settings settings, final List<IdentityPlugin> identityPlugins) {
+    public IdentityService(final Settings settings, final ThreadPool threadPool, final List<IdentityPlugin> identityPlugins) {
         this.settings = settings;
 
         if (identityPlugins.size() == 0) {
             log.debug("Identity plugins size is 0");
-            identityPlugin = new NoopIdentityPlugin();
+            identityPlugin = new NoopIdentityPlugin(threadPool);
         } else if (identityPlugins.size() == 1) {
             log.debug("Identity plugins size is 1");
             identityPlugin = identityPlugins.get(0);
@@ -47,8 +50,8 @@ public IdentityService(final Settings settings, final List<IdentityPlugin> ident
     /**
      * Gets the current subject
      */
-    public Subject getSubject() {
-        return identityPlugin.getSubject();
+    public Subject getCurrentSubject() {
+        return identityPlugin.getCurrentSubject();
     }
 
     /**
@@ -57,4 +60,13 @@ public Subject getSubject() {
     public TokenManager getTokenManager() {
         return identityPlugin.getTokenManager();
     }
+
+    public void initializeIdentityAwarePlugins(final List<IdentityAwarePlugin> identityAwarePlugins) {
+        if (identityAwarePlugins != null) {
+            for (IdentityAwarePlugin plugin : identityAwarePlugins) {
+                PluginSubject pluginSubject = identityPlugin.getPluginSubject((Plugin) plugin);
+                plugin.assignSubject(pluginSubject);
+            }
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/identity/PluginSubject.java b/server/src/main/java/org/opensearch/identity/PluginSubject.java
new file mode 100644
index 0000000000000..3ea42182d3fc3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/PluginSubject.java
@@ -0,0 +1,19 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.identity;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * Similar to {@link Subject}, but represents a plugin executing actions
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface PluginSubject extends Subject {}
diff --git a/server/src/main/java/org/opensearch/identity/Subject.java b/server/src/main/java/org/opensearch/identity/Subject.java
index cbfdadb5cf6a7..0fb0e53848d80 100644
--- a/server/src/main/java/org/opensearch/identity/Subject.java
+++ b/server/src/main/java/org/opensearch/identity/Subject.java
@@ -5,15 +5,17 @@
 
 package org.opensearch.identity;
 
-import org.opensearch.identity.tokens.AuthToken;
+import org.opensearch.common.annotation.ExperimentalApi;
 
 import java.security.Principal;
+import java.util.concurrent.Callable;
 
 /**
  * An individual, process, or device that causes information to flow among objects or change to the system state.
  *
  * @opensearch.experimental
  */
+@ExperimentalApi
 public interface Subject {
 
     /**
@@ -22,11 +24,9 @@ public interface Subject {
     Principal getPrincipal();
 
     /**
-     * Authenticate via an auth token
-     * throws UnsupportedAuthenticationMethod
-     * throws InvalidAuthenticationToken
-     * throws SubjectNotFound
-     * throws SubjectDisabled
+     * runAs allows the caller to run a callable function as this subject
      */
-    void authenticate(final AuthToken token);
+    default <T> T runAs(Callable<T> callable) throws Exception {
+        return callable.call();
+    };
 }
diff --git a/server/src/main/java/org/opensearch/identity/UserSubject.java b/server/src/main/java/org/opensearch/identity/UserSubject.java
new file mode 100644
index 0000000000000..50f8ac6b37be3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/UserSubject.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.identity;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.identity.tokens.AuthToken;
+
+/**
+ * An instance of a subject representing a User. UserSubjects must pass credentials for authentication.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface UserSubject extends Subject {
+    /**
+     * Authenticate via an auth token
+     * throws UnsupportedAuthenticationMethod
+     * throws InvalidAuthenticationToken
+     * throws SubjectNotFound
+     * throws SubjectDisabled
+     */
+    void authenticate(final AuthToken token);
+}
diff --git a/server/src/main/java/org/opensearch/identity/noop/NoopIdentityPlugin.java b/server/src/main/java/org/opensearch/identity/noop/NoopIdentityPlugin.java
index 090b1f1d025e0..6279388c76f96 100644
--- a/server/src/main/java/org/opensearch/identity/noop/NoopIdentityPlugin.java
+++ b/server/src/main/java/org/opensearch/identity/noop/NoopIdentityPlugin.java
@@ -8,9 +8,12 @@
 
 package org.opensearch.identity.noop;
 
+import org.opensearch.identity.PluginSubject;
 import org.opensearch.identity.Subject;
 import org.opensearch.identity.tokens.TokenManager;
 import org.opensearch.plugins.IdentityPlugin;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.threadpool.ThreadPool;
 
 /**
  * Implementation of identity plugin that does not enforce authentication or authorization
@@ -21,12 +24,18 @@
  */
 public class NoopIdentityPlugin implements IdentityPlugin {
 
+    private final ThreadPool threadPool;
+
+    public NoopIdentityPlugin(ThreadPool threadPool) {
+        this.threadPool = threadPool;
+    }
+
     /**
      * Get the current subject
      * @return Must never return null
      */
     @Override
-    public Subject getSubject() {
+    public Subject getCurrentSubject() {
         return new NoopSubject();
     }
 
@@ -38,4 +47,9 @@ public Subject getSubject() {
     public TokenManager getTokenManager() {
         return new NoopTokenManager();
     }
+
+    @Override
+    public PluginSubject getPluginSubject(Plugin plugin) {
+        return new NoopPluginSubject(threadPool);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/identity/noop/NoopPluginSubject.java b/server/src/main/java/org/opensearch/identity/noop/NoopPluginSubject.java
new file mode 100644
index 0000000000000..20e075276f317
--- /dev/null
+++ b/server/src/main/java/org/opensearch/identity/noop/NoopPluginSubject.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.identity.noop;
+
+import org.opensearch.common.annotation.InternalApi;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.identity.NamedPrincipal;
+import org.opensearch.identity.PluginSubject;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.security.Principal;
+import java.util.concurrent.Callable;
+
+/**
+ * Implementation of subject that is always authenticated
+ * <p>
+ * This class and related classes in this package will not return nulls or fail permissions checks
+ *
+ * This class is used by the NoopIdentityPlugin to initialize IdentityAwarePlugins
+ *
+ * @opensearch.internal
+ */
+@InternalApi
+public class NoopPluginSubject implements PluginSubject {
+    private final ThreadPool threadPool;
+
+    NoopPluginSubject(ThreadPool threadPool) {
+        super();
+        this.threadPool = threadPool;
+    }
+
+    @Override
+    public Principal getPrincipal() {
+        return NamedPrincipal.UNAUTHENTICATED;
+    }
+
+    @Override
+    public <T> T runAs(Callable<T> callable) throws Exception {
+        try (ThreadContext.StoredContext ctx = threadPool.getThreadContext().stashContext()) {
+            return callable.call();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/identity/noop/NoopSubject.java b/server/src/main/java/org/opensearch/identity/noop/NoopSubject.java
index 964a218db3cf5..fda88a8b7e8af 100644
--- a/server/src/main/java/org/opensearch/identity/noop/NoopSubject.java
+++ b/server/src/main/java/org/opensearch/identity/noop/NoopSubject.java
@@ -10,6 +10,7 @@
 
 import org.opensearch.identity.NamedPrincipal;
 import org.opensearch.identity.Subject;
+import org.opensearch.identity.UserSubject;
 import org.opensearch.identity.tokens.AuthToken;
 
 import java.security.Principal;
@@ -22,7 +23,7 @@
  *
  * @opensearch.internal
  */
-public class NoopSubject implements Subject {
+public class NoopSubject implements UserSubject {
 
     @Override
     public Principal getPrincipal() {
diff --git a/server/src/main/java/org/opensearch/identity/tokens/AuthToken.java b/server/src/main/java/org/opensearch/identity/tokens/AuthToken.java
index 88bb855a6e70d..57e4ac4a82ae3 100644
--- a/server/src/main/java/org/opensearch/identity/tokens/AuthToken.java
+++ b/server/src/main/java/org/opensearch/identity/tokens/AuthToken.java
@@ -8,11 +8,14 @@
 
 package org.opensearch.identity.tokens;
 
+import org.opensearch.common.annotation.ExperimentalApi;
+
 /**
  * Interface for all token formats to support to authenticate user such as UserName/Password tokens, Access tokens, and more.
  *
  * @opensearch.experimental
  */
+@ExperimentalApi
 public interface AuthToken {
 
     String asAuthHeaderValue();
diff --git a/server/src/main/java/org/opensearch/identity/tokens/OnBehalfOfClaims.java b/server/src/main/java/org/opensearch/identity/tokens/OnBehalfOfClaims.java
index 00e50a59e9486..2b37ed954e7d4 100644
--- a/server/src/main/java/org/opensearch/identity/tokens/OnBehalfOfClaims.java
+++ b/server/src/main/java/org/opensearch/identity/tokens/OnBehalfOfClaims.java
@@ -8,9 +8,14 @@
 
 package org.opensearch.identity.tokens;
 
+import org.opensearch.common.annotation.ExperimentalApi;
+
 /**
  * This class represents the claims of an OnBehalfOf token.
+ *
+ * @opensearch.experimental
  */
+@ExperimentalApi
 public class OnBehalfOfClaims {
 
     private final String audience;
diff --git a/server/src/main/java/org/opensearch/identity/tokens/TokenManager.java b/server/src/main/java/org/opensearch/identity/tokens/TokenManager.java
index 972a9a1080955..b9340e618245a 100644
--- a/server/src/main/java/org/opensearch/identity/tokens/TokenManager.java
+++ b/server/src/main/java/org/opensearch/identity/tokens/TokenManager.java
@@ -8,11 +8,15 @@
 
 package org.opensearch.identity.tokens;
 
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.identity.Subject;
 
 /**
  * This interface defines the expected methods of a token manager
+ *
+ * @opensearch.experimental
  */
+@ExperimentalApi
 public interface TokenManager {
 
     /**
diff --git a/server/src/main/java/org/opensearch/index/IndexModule.java b/server/src/main/java/org/opensearch/index/IndexModule.java
index 3c4cb4fd596c1..1725afcad72cf 100644
--- a/server/src/main/java/org/opensearch/index/IndexModule.java
+++ b/server/src/main/java/org/opensearch/index/IndexModule.java
@@ -48,6 +48,7 @@
 import org.opensearch.common.CheckedFunction;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.TriFunction;
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.settings.Setting;
@@ -66,11 +67,13 @@
 import org.opensearch.index.cache.query.DisabledQueryCache;
 import org.opensearch.index.cache.query.IndexQueryCache;
 import org.opensearch.index.cache.query.QueryCache;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
 import org.opensearch.index.engine.Engine;
 import org.opensearch.index.engine.EngineConfigFactory;
 import org.opensearch.index.engine.EngineFactory;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.shard.IndexEventListener;
+import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexingOperationListener;
 import org.opensearch.index.shard.SearchOperationListener;
 import org.opensearch.index.similarity.SimilarityService;
@@ -97,6 +100,7 @@
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
@@ -141,6 +145,17 @@ public final class IndexModule {
         Property.NodeScope
     );
 
+    /**
+     * Index setting which used to determine how the data is cached locally fully or partially
+     */
+    public static final Setting<DataLocalityType> INDEX_STORE_LOCALITY_SETTING = new Setting<>(
+        "index.store.data_locality",
+        DataLocalityType.FULL.name(),
+        DataLocalityType::getValueOf,
+        Property.IndexScope,
+        Property.NodeScope
+    );
+
     public static final Setting<String> INDEX_RECOVERY_TYPE_SETTING = new Setting<>(
         "index.recovery.type",
         "",
@@ -160,6 +175,14 @@ public final class IndexModule {
         Property.NodeScope
     );
 
+    public static final Setting<String> INDEX_TIERING_STATE = new Setting<>(
+        "index.tiering.state",
+        TieringState.HOT.name(),
+        Function.identity(),
+        Property.IndexScope,
+        Property.PrivateIndex
+    );
+
     /** Which lucene file extensions to load with the mmap directory when using hybridfs store. This settings is ignored if {@link #INDEX_STORE_HYBRID_NIO_EXTENSIONS} is set.
      *  This is an expert setting.
      *  @see <a href="https://lucene.apache.org/core/9_9_0/core/org/apache/lucene/codecs/lucene99/package-summary.html#file-names">Lucene File Extensions</a>.
@@ -297,6 +320,8 @@ public Iterator<Setting<?>> settings() {
     private final AtomicBoolean frozen = new AtomicBoolean(false);
     private final BooleanSupplier allowExpensiveQueries;
     private final Map<String, IndexStorePlugin.RecoveryStateFactory> recoveryStateFactories;
+    private final FileCache fileCache;
+    private final CompositeIndexSettings compositeIndexSettings;
 
     /**
      * Construct the index module for the index with the specified index settings. The index module contains extension points for plugins
@@ -315,7 +340,9 @@ public IndexModule(
         final Map<String, IndexStorePlugin.DirectoryFactory> directoryFactories,
         final BooleanSupplier allowExpensiveQueries,
         final IndexNameExpressionResolver expressionResolver,
-        final Map<String, IndexStorePlugin.RecoveryStateFactory> recoveryStateFactories
+        final Map<String, IndexStorePlugin.RecoveryStateFactory> recoveryStateFactories,
+        final FileCache fileCache,
+        final CompositeIndexSettings compositeIndexSettings
     ) {
         this.indexSettings = indexSettings;
         this.analysisRegistry = analysisRegistry;
@@ -327,6 +354,57 @@ public IndexModule(
         this.allowExpensiveQueries = allowExpensiveQueries;
         this.expressionResolver = expressionResolver;
         this.recoveryStateFactories = recoveryStateFactories;
+        this.fileCache = fileCache;
+        this.compositeIndexSettings = compositeIndexSettings;
+    }
+
+    public IndexModule(
+        final IndexSettings indexSettings,
+        final AnalysisRegistry analysisRegistry,
+        final EngineFactory engineFactory,
+        final EngineConfigFactory engineConfigFactory,
+        final Map<String, IndexStorePlugin.DirectoryFactory> directoryFactories,
+        final BooleanSupplier allowExpensiveQueries,
+        final IndexNameExpressionResolver expressionResolver,
+        final Map<String, IndexStorePlugin.RecoveryStateFactory> recoveryStateFactories,
+        final FileCache fileCache
+    ) {
+        this(
+            indexSettings,
+            analysisRegistry,
+            engineFactory,
+            engineConfigFactory,
+            directoryFactories,
+            allowExpensiveQueries,
+            expressionResolver,
+            recoveryStateFactories,
+            fileCache,
+            null
+        );
+    }
+
+    public IndexModule(
+        final IndexSettings indexSettings,
+        final AnalysisRegistry analysisRegistry,
+        final EngineFactory engineFactory,
+        final EngineConfigFactory engineConfigFactory,
+        final Map<String, IndexStorePlugin.DirectoryFactory> directoryFactories,
+        final BooleanSupplier allowExpensiveQueries,
+        final IndexNameExpressionResolver expressionResolver,
+        final Map<String, IndexStorePlugin.RecoveryStateFactory> recoveryStateFactories
+    ) {
+        this(
+            indexSettings,
+            analysisRegistry,
+            engineFactory,
+            engineConfigFactory,
+            directoryFactories,
+            allowExpensiveQueries,
+            expressionResolver,
+            recoveryStateFactories,
+            null,
+            null
+        );
     }
 
     /**
@@ -577,6 +655,40 @@ public boolean match(Settings settings) {
         }
     }
 
+    /**
+     * Indicates the locality of the data - whether it will be cached fully or partially
+     */
+    public enum DataLocalityType {
+        /**
+         * Indicates that all the data will be cached locally
+         */
+        FULL,
+        /**
+         * Indicates that only a subset of the data will be cached locally
+         */
+        PARTIAL;
+
+        private static final Map<String, DataLocalityType> LOCALITY_TYPES;
+
+        static {
+            final Map<String, DataLocalityType> localityTypes = new HashMap<>(values().length);
+            for (final DataLocalityType dataLocalityType : values()) {
+                localityTypes.put(dataLocalityType.name(), dataLocalityType);
+            }
+            LOCALITY_TYPES = Collections.unmodifiableMap(localityTypes);
+        }
+
+        public static DataLocalityType getValueOf(final String localityType) {
+            Objects.requireNonNull(localityType, "No locality type given.");
+            final String localityTypeName = localityType.trim().toUpperCase(Locale.ROOT);
+            final DataLocalityType type = LOCALITY_TYPES.get(localityTypeName);
+            if (type != null) {
+                return type;
+            }
+            throw new IllegalArgumentException("Unknown locality type constant [" + localityType + "].");
+        }
+    }
+
     public static Type defaultStoreType(final boolean allowMmap) {
         if (allowMmap && Constants.JRE_IS_64BIT && MMapDirectory.UNMAP_SUPPORTED) {
             return Type.HYBRIDFS;
@@ -585,6 +697,17 @@ public static Type defaultStoreType(final boolean allowMmap) {
         }
     }
 
+    /**
+     * Represents the tiering state of the index.
+     */
+    @ExperimentalApi
+    public enum TieringState {
+        HOT,
+        HOT_TO_WARM,
+        WARM,
+        WARM_TO_HOT;
+    }
+
     public IndexService newIndexService(
         IndexService.IndexCreationContext indexCreationContext,
         NodeEnvironment environment,
@@ -607,6 +730,56 @@ public IndexService newIndexService(
         Supplier<TimeValue> clusterDefaultRefreshIntervalSupplier,
         RecoverySettings recoverySettings,
         RemoteStoreSettings remoteStoreSettings
+    ) throws IOException {
+        return newIndexService(
+            indexCreationContext,
+            environment,
+            xContentRegistry,
+            shardStoreDeleter,
+            circuitBreakerService,
+            bigArrays,
+            threadPool,
+            scriptService,
+            clusterService,
+            client,
+            indicesQueryCache,
+            mapperRegistry,
+            indicesFieldDataCache,
+            namedWriteableRegistry,
+            idFieldDataEnabled,
+            valuesSourceRegistry,
+            remoteDirectoryFactory,
+            translogFactorySupplier,
+            clusterDefaultRefreshIntervalSupplier,
+            recoverySettings,
+            remoteStoreSettings,
+            (s) -> {}
+        );
+    }
+
+    public IndexService newIndexService(
+        IndexService.IndexCreationContext indexCreationContext,
+        NodeEnvironment environment,
+        NamedXContentRegistry xContentRegistry,
+        IndexService.ShardStoreDeleter shardStoreDeleter,
+        CircuitBreakerService circuitBreakerService,
+        BigArrays bigArrays,
+        ThreadPool threadPool,
+        ScriptService scriptService,
+        ClusterService clusterService,
+        Client client,
+        IndicesQueryCache indicesQueryCache,
+        MapperRegistry mapperRegistry,
+        IndicesFieldDataCache indicesFieldDataCache,
+        NamedWriteableRegistry namedWriteableRegistry,
+        BooleanSupplier idFieldDataEnabled,
+        ValuesSourceRegistry valuesSourceRegistry,
+        IndexStorePlugin.DirectoryFactory remoteDirectoryFactory,
+        BiFunction<IndexSettings, ShardRouting, TranslogFactory> translogFactorySupplier,
+        Supplier<TimeValue> clusterDefaultRefreshIntervalSupplier,
+        RecoverySettings recoverySettings,
+        RemoteStoreSettings remoteStoreSettings,
+        Consumer<IndexShard> replicator
     ) throws IOException {
         final IndexEventListener eventListener = freeze();
         Function<IndexService, CheckedFunction<DirectoryReader, DirectoryReader, IOException>> readerWrapperFactory = indexReaderWrapper
@@ -665,7 +838,10 @@ public IndexService newIndexService(
                 translogFactorySupplier,
                 clusterDefaultRefreshIntervalSupplier,
                 recoverySettings,
-                remoteStoreSettings
+                remoteStoreSettings,
+                fileCache,
+                compositeIndexSettings,
+                replicator
             );
             success = true;
             return indexService;
diff --git a/server/src/main/java/org/opensearch/index/IndexService.java b/server/src/main/java/org/opensearch/index/IndexService.java
index e501d7eff3f81..6e67c8f83ee4c 100644
--- a/server/src/main/java/org/opensearch/index/IndexService.java
+++ b/server/src/main/java/org/opensearch/index/IndexService.java
@@ -55,6 +55,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.concurrent.AbstractAsyncTask;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.io.IOUtils;
@@ -72,6 +73,7 @@
 import org.opensearch.index.cache.IndexCache;
 import org.opensearch.index.cache.bitset.BitsetFilterCache;
 import org.opensearch.index.cache.query.QueryCache;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
 import org.opensearch.index.engine.Engine;
 import org.opensearch.index.engine.EngineConfigFactory;
 import org.opensearch.index.engine.EngineFactory;
@@ -91,8 +93,10 @@
 import org.opensearch.index.shard.ShardNotInPrimaryModeException;
 import org.opensearch.index.shard.ShardPath;
 import org.opensearch.index.similarity.SimilarityService;
+import org.opensearch.index.store.CompositeDirectory;
 import org.opensearch.index.store.RemoteSegmentStoreDirectoryFactory;
 import org.opensearch.index.store.Store;
+import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.index.translog.TranslogFactory;
 import org.opensearch.indices.RemoteStoreSettings;
@@ -132,6 +136,7 @@
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.unmodifiableMap;
 import static org.opensearch.common.collect.MapBuilder.newMapBuilder;
+import static org.opensearch.common.util.FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL_SETTING;
 import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdater.indexHasRemoteStoreSettings;
 
 /**
@@ -170,6 +175,7 @@ public class IndexService extends AbstractIndexComponent implements IndicesClust
     private volatile AsyncTranslogFSync fsyncTask;
     private volatile AsyncGlobalCheckpointTask globalCheckpointTask;
     private volatile AsyncRetentionLeaseSyncTask retentionLeaseSyncTask;
+    private volatile AsyncReplicationTask asyncReplicationTask;
 
     // don't convert to Setting<> and register... we only set this in tests and register via a plugin
     private final String INDEX_TRANSLOG_RETENTION_CHECK_INTERVAL_SETTING = "index.translog.retention.check_interval";
@@ -188,6 +194,9 @@ public class IndexService extends AbstractIndexComponent implements IndicesClust
     private final Supplier<TimeValue> clusterDefaultRefreshIntervalSupplier;
     private final RecoverySettings recoverySettings;
     private final RemoteStoreSettings remoteStoreSettings;
+    private final FileCache fileCache;
+    private final CompositeIndexSettings compositeIndexSettings;
+    private final Consumer<IndexShard> replicator;
 
     public IndexService(
         IndexSettings indexSettings,
@@ -223,7 +232,10 @@ public IndexService(
         BiFunction<IndexSettings, ShardRouting, TranslogFactory> translogFactorySupplier,
         Supplier<TimeValue> clusterDefaultRefreshIntervalSupplier,
         RecoverySettings recoverySettings,
-        RemoteStoreSettings remoteStoreSettings
+        RemoteStoreSettings remoteStoreSettings,
+        FileCache fileCache,
+        CompositeIndexSettings compositeIndexSettings,
+        Consumer<IndexShard> replicator
     ) {
         super(indexSettings);
         this.allowExpensiveQueries = allowExpensiveQueries;
@@ -298,17 +310,183 @@ public IndexService(
         this.trimTranslogTask = new AsyncTrimTranslogTask(this);
         this.globalCheckpointTask = new AsyncGlobalCheckpointTask(this);
         this.retentionLeaseSyncTask = new AsyncRetentionLeaseSyncTask(this);
+        if (READER_WRITER_SPLIT_EXPERIMENTAL_SETTING.get(indexSettings.getNodeSettings())) {
+            this.asyncReplicationTask = new AsyncReplicationTask(this);
+        }
         this.translogFactorySupplier = translogFactorySupplier;
         this.recoverySettings = recoverySettings;
         this.remoteStoreSettings = remoteStoreSettings;
+        this.compositeIndexSettings = compositeIndexSettings;
+        this.fileCache = fileCache;
+        this.replicator = replicator;
         updateFsyncTaskIfNecessary();
     }
 
+    public IndexService(
+        IndexSettings indexSettings,
+        IndexCreationContext indexCreationContext,
+        NodeEnvironment nodeEnv,
+        NamedXContentRegistry xContentRegistry,
+        SimilarityService similarityService,
+        ShardStoreDeleter shardStoreDeleter,
+        IndexAnalyzers indexAnalyzers,
+        EngineFactory engineFactory,
+        EngineConfigFactory engineConfigFactory,
+        CircuitBreakerService circuitBreakerService,
+        BigArrays bigArrays,
+        ThreadPool threadPool,
+        ScriptService scriptService,
+        ClusterService clusterService,
+        Client client,
+        QueryCache queryCache,
+        IndexStorePlugin.DirectoryFactory directoryFactory,
+        IndexStorePlugin.DirectoryFactory remoteDirectoryFactory,
+        IndexEventListener eventListener,
+        Function<IndexService, CheckedFunction<DirectoryReader, DirectoryReader, IOException>> wrapperFactory,
+        MapperRegistry mapperRegistry,
+        IndicesFieldDataCache indicesFieldDataCache,
+        List<SearchOperationListener> searchOperationListeners,
+        List<IndexingOperationListener> indexingOperationListeners,
+        NamedWriteableRegistry namedWriteableRegistry,
+        BooleanSupplier idFieldDataEnabled,
+        BooleanSupplier allowExpensiveQueries,
+        IndexNameExpressionResolver expressionResolver,
+        ValuesSourceRegistry valuesSourceRegistry,
+        IndexStorePlugin.RecoveryStateFactory recoveryStateFactory,
+        BiFunction<IndexSettings, ShardRouting, TranslogFactory> translogFactorySupplier,
+        Supplier<TimeValue> clusterDefaultRefreshIntervalSupplier,
+        RecoverySettings recoverySettings,
+        RemoteStoreSettings remoteStoreSettings,
+        FileCache fileCache
+    ) {
+        this(
+            indexSettings,
+            indexCreationContext,
+            nodeEnv,
+            xContentRegistry,
+            similarityService,
+            shardStoreDeleter,
+            indexAnalyzers,
+            engineFactory,
+            engineConfigFactory,
+            circuitBreakerService,
+            bigArrays,
+            threadPool,
+            scriptService,
+            clusterService,
+            client,
+            queryCache,
+            directoryFactory,
+            remoteDirectoryFactory,
+            eventListener,
+            wrapperFactory,
+            mapperRegistry,
+            indicesFieldDataCache,
+            searchOperationListeners,
+            indexingOperationListeners,
+            namedWriteableRegistry,
+            idFieldDataEnabled,
+            allowExpensiveQueries,
+            expressionResolver,
+            valuesSourceRegistry,
+            recoveryStateFactory,
+            translogFactorySupplier,
+            clusterDefaultRefreshIntervalSupplier,
+            recoverySettings,
+            remoteStoreSettings,
+            fileCache,
+            null,
+            (s) -> {}
+        );
+    }
+
+    public IndexService(
+        IndexSettings indexSettings,
+        IndexCreationContext indexCreationContext,
+        NodeEnvironment nodeEnv,
+        NamedXContentRegistry xContentRegistry,
+        SimilarityService similarityService,
+        ShardStoreDeleter shardStoreDeleter,
+        IndexAnalyzers indexAnalyzers,
+        EngineFactory engineFactory,
+        EngineConfigFactory engineConfigFactory,
+        CircuitBreakerService circuitBreakerService,
+        BigArrays bigArrays,
+        ThreadPool threadPool,
+        ScriptService scriptService,
+        ClusterService clusterService,
+        Client client,
+        QueryCache queryCache,
+        IndexStorePlugin.DirectoryFactory directoryFactory,
+        IndexStorePlugin.DirectoryFactory remoteDirectoryFactory,
+        IndexEventListener eventListener,
+        Function<IndexService, CheckedFunction<DirectoryReader, DirectoryReader, IOException>> wrapperFactory,
+        MapperRegistry mapperRegistry,
+        IndicesFieldDataCache indicesFieldDataCache,
+        List<SearchOperationListener> searchOperationListeners,
+        List<IndexingOperationListener> indexingOperationListeners,
+        NamedWriteableRegistry namedWriteableRegistry,
+        BooleanSupplier idFieldDataEnabled,
+        BooleanSupplier allowExpensiveQueries,
+        IndexNameExpressionResolver expressionResolver,
+        ValuesSourceRegistry valuesSourceRegistry,
+        IndexStorePlugin.RecoveryStateFactory recoveryStateFactory,
+        BiFunction<IndexSettings, ShardRouting, TranslogFactory> translogFactorySupplier,
+        Supplier<TimeValue> clusterDefaultRefreshIntervalSupplier,
+        RecoverySettings recoverySettings,
+        RemoteStoreSettings remoteStoreSettings
+    ) {
+        this(
+            indexSettings,
+            indexCreationContext,
+            nodeEnv,
+            xContentRegistry,
+            similarityService,
+            shardStoreDeleter,
+            indexAnalyzers,
+            engineFactory,
+            engineConfigFactory,
+            circuitBreakerService,
+            bigArrays,
+            threadPool,
+            scriptService,
+            clusterService,
+            client,
+            queryCache,
+            directoryFactory,
+            remoteDirectoryFactory,
+            eventListener,
+            wrapperFactory,
+            mapperRegistry,
+            indicesFieldDataCache,
+            searchOperationListeners,
+            indexingOperationListeners,
+            namedWriteableRegistry,
+            idFieldDataEnabled,
+            allowExpensiveQueries,
+            expressionResolver,
+            valuesSourceRegistry,
+            recoveryStateFactory,
+            translogFactorySupplier,
+            clusterDefaultRefreshIntervalSupplier,
+            recoverySettings,
+            remoteStoreSettings,
+            null,
+            null,
+            s -> {}
+        );
+    }
+
     static boolean needsMapperService(IndexSettings indexSettings, IndexCreationContext indexCreationContext) {
         return false == (indexSettings.getIndexMetadata().getState() == IndexMetadata.State.CLOSE
             && indexCreationContext == IndexCreationContext.CREATE_INDEX); // metadata verification needs a mapper service
     }
 
+    // visible for tests
+    AsyncReplicationTask getReplicationTask() {
+        return asyncReplicationTask;
+    }
+
     /**
      * Context for index creation
      *
@@ -495,9 +673,9 @@ public synchronized IndexShard createShard(
                 }
             };
             Store remoteStore = null;
+            Directory remoteDirectory = null;
             boolean seedRemote = false;
             if (targetNode.isRemoteStoreNode()) {
-                final Directory remoteDirectory;
                 if (this.indexSettings.isRemoteStoreEnabled()) {
                     remoteDirectory = remoteDirectoryFactory.newDirectory(this.indexSettings, path);
                 } else {
@@ -516,7 +694,21 @@ public synchronized IndexShard createShard(
                         this.indexSettings.getRemoteStorePathStrategy()
                     );
                 }
-                remoteStore = new Store(shardId, this.indexSettings, remoteDirectory, lock, Store.OnClose.EMPTY, path);
+                // When an instance of Store is created, a shardlock is created which is released on closing the instance of store.
+                // Currently, we create 2 instances of store for remote store backed indices: store and remoteStore.
+                // As there can be only one shardlock acquired for a given shard, the lock is shared between store and remoteStore.
+                // This creates an issue when we are deleting the index as it results in closing both store and remoteStore.
+                // Sample test failure: https://github.com/opensearch-project/OpenSearch/issues/13871
+                // The following method provides ShardLock that is not maintained by NodeEnvironment.
+                // As part of https://github.com/opensearch-project/OpenSearch/issues/13075, we want to move away from keeping 2
+                // store instances.
+                ShardLock remoteStoreLock = new ShardLock(shardId) {
+                    @Override
+                    protected void closeInternal() {
+                        // Do nothing for shard lock on remote store
+                    }
+                };
+                remoteStore = new Store(shardId, this.indexSettings, remoteDirectory, remoteStoreLock, Store.OnClose.EMPTY, path);
             } else {
                 // Disallow shards with remote store based settings to be created on non-remote store enabled nodes
                 // Even though we have `RemoteStoreMigrationAllocationDecider` in place to prevent something like this from happening at the
@@ -530,7 +722,15 @@ public synchronized IndexShard createShard(
                 }
             }
 
-            Directory directory = directoryFactory.newDirectory(this.indexSettings, path);
+            Directory directory = null;
+            if (FeatureFlags.isEnabled(FeatureFlags.TIERED_REMOTE_INDEX_SETTING) &&
+            // TODO : Need to remove this check after support for hot indices is added in Composite Directory
+                this.indexSettings.isStoreLocalityPartial()) {
+                Directory localDirectory = directoryFactory.newDirectory(this.indexSettings, path);
+                directory = new CompositeDirectory(localDirectory, remoteDirectory, fileCache);
+            } else {
+                directory = directoryFactory.newDirectory(this.indexSettings, path);
+            }
             store = new Store(
                 shardId,
                 this.indexSettings,
@@ -957,11 +1157,22 @@ public synchronized void updateMetadata(final IndexMetadata currentIndexMetadata
             }
             onRefreshIntervalChange();
             updateFsyncTaskIfNecessary();
+            if (READER_WRITER_SPLIT_EXPERIMENTAL_SETTING.get(indexSettings.getNodeSettings())) {
+                updateReplicationTask();
+            }
         }
 
         metadataListeners.forEach(c -> c.accept(newIndexMetadata));
     }
 
+    private void updateReplicationTask() {
+        try {
+            asyncReplicationTask.close();
+        } finally {
+            asyncReplicationTask = new AsyncReplicationTask(this);
+        }
+    }
+
     /**
      * Called whenever the refresh interval changes. This can happen in 2 cases -
      * 1. {@code cluster.default.index.refresh_interval} cluster setting changes. The change would only happen for
@@ -1020,6 +1231,10 @@ private void rescheduleRefreshTasks() {
         }
     }
 
+    public CompositeIndexSettings getCompositeIndexSettings() {
+        return compositeIndexSettings;
+    }
+
     /**
      * Shard Store Deleter Interface
      *
@@ -1222,6 +1437,47 @@ public String toString() {
         }
     }
 
+    final class AsyncReplicationTask extends BaseAsyncTask {
+
+        AsyncReplicationTask(IndexService indexService) {
+            super(indexService, indexService.getRefreshInterval());
+        }
+
+        @Override
+        protected void runInternal() {
+            indexService.maybeSyncSegments(false);
+        }
+
+        @Override
+        protected String getThreadPool() {
+            return ThreadPool.Names.GENERIC;
+        }
+
+        @Override
+        public String toString() {
+            return "replication";
+        }
+
+        @Override
+        protected boolean mustReschedule() {
+            return indexSettings.isSegRepEnabledOrRemoteNode() && super.mustReschedule();
+        }
+    }
+
+    private void maybeSyncSegments(boolean force) {
+        if (getRefreshInterval().millis() > 0 || force) {
+            for (IndexShard shard : this.shards.values()) {
+                try {
+                    if (shard.routingEntry().isSearchOnly() && shard.routingEntry().active()) {
+                        replicator.accept(shard);
+                    }
+                } catch (IndexShardClosedException | AlreadyClosedException ex) {
+                    // do nothing
+                }
+            }
+        }
+    }
+
     final class AsyncTrimTranslogTask extends BaseAsyncTask {
 
         AsyncTrimTranslogTask(IndexService indexService) {
diff --git a/server/src/main/java/org/opensearch/index/IndexSettings.java b/server/src/main/java/org/opensearch/index/IndexSettings.java
index a7be456e3996f..8d8bf88bb82e4 100644
--- a/server/src/main/java/org/opensearch/index/IndexSettings.java
+++ b/server/src/main/java/org/opensearch/index/IndexSettings.java
@@ -49,6 +49,8 @@
 import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.index.Index;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.remote.RemoteStoreUtils;
 import org.opensearch.index.translog.Translog;
@@ -77,6 +79,10 @@
 import static org.opensearch.index.mapper.MapperService.INDEX_MAPPING_NESTED_FIELDS_LIMIT_SETTING;
 import static org.opensearch.index.mapper.MapperService.INDEX_MAPPING_TOTAL_FIELDS_LIMIT_SETTING;
 import static org.opensearch.index.store.remote.directory.RemoteSnapshotDirectory.SEARCHABLE_SNAPSHOT_EXTENDED_COMPATIBILITY_MINIMUM_VERSION;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_DEFAULT_VALUE;
 
 /**
  * This class encapsulates all index level settings and handles settings updates.
@@ -152,6 +158,14 @@ public static IndexMergePolicy fromString(String text) {
         true,
         Property.IndexScope
     );
+
+    public static final Setting<Boolean> ALLOW_DERIVED_FIELDS = Setting.boolSetting(
+        "index.query.derived_field.enabled",
+        true,
+        Property.Dynamic,
+        Property.IndexScope
+    );
+
     public static final Setting<TimeValue> INDEX_TRANSLOG_SYNC_INTERVAL_SETTING = Setting.timeSetting(
         "index.translog.sync_interval",
         TimeValue.timeValueSeconds(5),
@@ -669,6 +683,14 @@ public static IndexMergePolicy fromString(String text) {
         Property.InternalIndex
     );
 
+    public static final Setting<PathType> SEARCHABLE_SNAPSHOT_SHARD_PATH_TYPE = new Setting<>(
+        "index.searchable_snapshot.shard_path_type",
+        PathType.FIXED.toString(),
+        PathType::parseString,
+        Property.IndexScope,
+        Property.InternalIndex
+    );
+
     public static final Setting<String> DEFAULT_SEARCH_PIPELINE = new Setting<>(
         "index.search.default_pipeline",
         SearchPipelineService.NOOP_PIPELINE_ID,
@@ -681,7 +703,34 @@ public static IndexMergePolicy fromString(String text) {
         "index.search.concurrent_segment_search.enabled",
         false,
         Property.IndexScope,
-        Property.Dynamic
+        Property.Dynamic,
+        Property.Deprecated
+    );
+
+    public static final Setting<String> INDEX_CONCURRENT_SEGMENT_SEARCH_MODE = Setting.simpleString(
+        "index.search.concurrent_segment_search.mode",
+        CONCURRENT_SEGMENT_SEARCH_MODE_NONE,
+        value -> {
+            switch (value) {
+                case CONCURRENT_SEGMENT_SEARCH_MODE_ALL:
+                case CONCURRENT_SEGMENT_SEARCH_MODE_NONE:
+                case CONCURRENT_SEGMENT_SEARCH_MODE_AUTO:
+                    // valid setting
+                    break;
+                default:
+                    throw new IllegalArgumentException("Setting value must be one of [all, none, auto]");
+            }
+        },
+        Property.Dynamic,
+        Property.IndexScope
+    );
+
+    public static final Setting<Integer> INDEX_CONCURRENT_SEGMENT_SEARCH_MAX_SLICE_COUNT = Setting.intSetting(
+        "index.search.concurrent.max_slice_count",
+        CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_DEFAULT_VALUE,
+        CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_DEFAULT_VALUE,
+        Property.Dynamic,
+        Property.IndexScope
     );
 
     public static final Setting<Boolean> INDEX_DOC_ID_FUZZY_SET_ENABLED_SETTING = Setting.boolSetting(
@@ -718,6 +767,22 @@ public static IndexMergePolicy fromString(String text) {
         Property.IndexScope
     );
 
+    public static final Setting<Long> INDEX_CONTEXT_CREATED_VERSION = Setting.longSetting(
+        "index.context.created_version",
+        0,
+        0,
+        Property.PrivateIndex,
+        Property.IndexScope
+    );
+
+    public static final Setting<Long> INDEX_CONTEXT_CURRENT_VERSION = Setting.longSetting(
+        "index.context.current_version",
+        0,
+        0,
+        Property.PrivateIndex,
+        Property.IndexScope
+    );
+
     private final Index index;
     private final Version version;
     private final Logger logger;
@@ -725,11 +790,11 @@ public static IndexMergePolicy fromString(String text) {
     private final Settings nodeSettings;
     private final int numberOfShards;
     private final ReplicationType replicationType;
-    private final boolean isRemoteStoreEnabled;
+    private volatile boolean isRemoteStoreEnabled;
+    private final boolean isStoreLocalityPartial;
     private volatile TimeValue remoteTranslogUploadBufferInterval;
-    private final String remoteStoreTranslogRepository;
-    private final String remoteStoreRepository;
-    private final boolean isRemoteSnapshot;
+    private volatile String remoteStoreTranslogRepository;
+    private volatile String remoteStoreRepository;
     private int remoteTranslogKeepExtraGen;
     private Version extendedCompatibilitySnapshotVersion;
     // volatile fields are updated via #updateIndexMetadata(IndexMetadata) under lock
@@ -764,6 +829,7 @@ public static IndexMergePolicy fromString(String text) {
     private final boolean assignedOnRemoteNode;
     private final RemoteStorePathStrategy remoteStorePathStrategy;
     private final boolean isTranslogMetadataEnabled;
+    private volatile boolean allowDerivedField;
 
     /**
      * The maximum age of a retention lease before it is considered expired.
@@ -846,6 +912,8 @@ private void setRetentionLeaseMillis(final TimeValue retentionLease) {
      */
     private volatile double docIdFuzzySetFalsePositiveProbability;
 
+    private final boolean isCompositeIndex;
+
     /**
      * Returns the default search fields for this index.
      */
@@ -857,6 +925,10 @@ private void setDefaultFields(List<String> defaultFields) {
         this.defaultFields = defaultFields;
     }
 
+    private void setAllowDerivedField(boolean allowDerivedField) {
+        this.allowDerivedField = allowDerivedField;
+    }
+
     /**
      * Returns <code>true</code> if query string parsing should be lenient. The default is <code>false</code>
      */
@@ -885,6 +957,13 @@ public boolean isDefaultAllowUnmappedFields() {
         return defaultAllowUnmappedFields;
     }
 
+    /**
+     * Returns <code>true</code> if queries are allowed to define and use derived fields. The default is <code>true</code>
+     */
+    public boolean isDerivedFieldAllowed() {
+        return allowDerivedField;
+    }
+
     /**
      * Creates a new {@link IndexSettings} instance. The given node settings will be merged with the settings in the metadata
      * while index level settings will overwrite node settings.
@@ -915,13 +994,16 @@ public IndexSettings(final IndexMetadata indexMetadata, final Settings nodeSetti
         numberOfShards = settings.getAsInt(IndexMetadata.SETTING_NUMBER_OF_SHARDS, null);
         replicationType = IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.get(settings);
         isRemoteStoreEnabled = settings.getAsBoolean(IndexMetadata.SETTING_REMOTE_STORE_ENABLED, false);
+        isStoreLocalityPartial = settings.get(
+            IndexModule.INDEX_STORE_LOCALITY_SETTING.getKey(),
+            IndexModule.DataLocalityType.FULL.toString()
+        ).equalsIgnoreCase(IndexModule.DataLocalityType.PARTIAL.toString());
         remoteStoreTranslogRepository = settings.get(IndexMetadata.SETTING_REMOTE_TRANSLOG_STORE_REPOSITORY);
         remoteTranslogUploadBufferInterval = INDEX_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING.get(settings);
         remoteStoreRepository = settings.get(IndexMetadata.SETTING_REMOTE_SEGMENT_STORE_REPOSITORY);
         this.remoteTranslogKeepExtraGen = INDEX_REMOTE_TRANSLOG_KEEP_EXTRA_GEN_SETTING.get(settings);
-        isRemoteSnapshot = IndexModule.Type.REMOTE_SNAPSHOT.match(this.settings);
 
-        if (isRemoteSnapshot && FeatureFlags.isEnabled(SEARCHABLE_SNAPSHOT_EXTENDED_COMPATIBILITY)) {
+        if (isRemoteSnapshot() && FeatureFlags.isEnabled(SEARCHABLE_SNAPSHOT_EXTENDED_COMPATIBILITY)) {
             extendedCompatibilitySnapshotVersion = SEARCHABLE_SNAPSHOT_EXTENDED_COMPATIBILITY_MINIMUM_VERSION;
         } else {
             extendedCompatibilitySnapshotVersion = Version.CURRENT.minimumIndexCompatibilityVersion();
@@ -932,6 +1014,7 @@ public IndexSettings(final IndexMetadata indexMetadata, final Settings nodeSetti
         this.queryStringAnalyzeWildcard = QUERY_STRING_ANALYZE_WILDCARD.get(nodeSettings);
         this.queryStringAllowLeadingWildcard = QUERY_STRING_ALLOW_LEADING_WILDCARD.get(nodeSettings);
         this.defaultAllowUnmappedFields = scopedSettings.get(ALLOW_UNMAPPED);
+        this.allowDerivedField = scopedSettings.get(ALLOW_DERIVED_FIELDS);
         this.durability = scopedSettings.get(INDEX_TRANSLOG_DURABILITY_SETTING);
         defaultFields = scopedSettings.get(DEFAULT_FIELD_SETTING);
         syncInterval = INDEX_TRANSLOG_SYNC_INTERVAL_SETTING.get(settings);
@@ -993,7 +1076,7 @@ public IndexSettings(final IndexMetadata indexMetadata, final Settings nodeSetti
 
         setEnableFuzzySetForDocId(scopedSettings.get(INDEX_DOC_ID_FUZZY_SET_ENABLED_SETTING));
         setDocIdFuzzySetFalsePositiveProbability(scopedSettings.get(INDEX_DOC_ID_FUZZY_SET_FALSE_POSITIVE_PROBABILITY_SETTING));
-
+        isCompositeIndex = scopedSettings.get(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING);
         scopedSettings.addSettingsUpdateConsumer(
             TieredMergePolicyProvider.INDEX_COMPOUND_FORMAT_SETTING,
             tieredMergePolicyProvider::setNoCFSRatio
@@ -1106,6 +1189,16 @@ public IndexSettings(final IndexMetadata indexMetadata, final Settings nodeSetti
             INDEX_DOC_ID_FUZZY_SET_FALSE_POSITIVE_PROBABILITY_SETTING,
             this::setDocIdFuzzySetFalsePositiveProbability
         );
+        scopedSettings.addSettingsUpdateConsumer(ALLOW_DERIVED_FIELDS, this::setAllowDerivedField);
+        scopedSettings.addSettingsUpdateConsumer(IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING, this::setRemoteStoreEnabled);
+        scopedSettings.addSettingsUpdateConsumer(
+            IndexMetadata.INDEX_REMOTE_SEGMENT_STORE_REPOSITORY_SETTING,
+            this::setRemoteStoreRepository
+        );
+        scopedSettings.addSettingsUpdateConsumer(
+            IndexMetadata.INDEX_REMOTE_TRANSLOG_REPOSITORY_SETTING,
+            this::setRemoteStoreTranslogRepository
+        );
     }
 
     private void setSearchIdleAfter(TimeValue searchIdleAfter) {
@@ -1228,6 +1321,10 @@ public int getNumberOfReplicas() {
         return settings.getAsInt(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, null);
     }
 
+    public boolean isCompositeIndex() {
+        return isCompositeIndex;
+    }
+
     /**
      * Returns true if segment replication is enabled on the index.
      *
@@ -1269,11 +1366,18 @@ public boolean isRemoteTranslogStoreEnabled() {
         return isRemoteStoreEnabled;
     }
 
+    /**
+     * Returns true if the store locality is partial
+     */
+    public boolean isStoreLocalityPartial() {
+        return isStoreLocalityPartial;
+    }
+
     /**
      * Returns true if this is remote/searchable snapshot
      */
     public boolean isRemoteSnapshot() {
-        return isRemoteSnapshot;
+        return indexMetadata.isRemoteSnapshot();
     }
 
     /**
@@ -1918,4 +2022,16 @@ public RemoteStorePathStrategy getRemoteStorePathStrategy() {
     public boolean isTranslogMetadataEnabled() {
         return isTranslogMetadataEnabled;
     }
+
+    public void setRemoteStoreEnabled(boolean isRemoteStoreEnabled) {
+        this.isRemoteStoreEnabled = isRemoteStoreEnabled;
+    }
+
+    public void setRemoteStoreRepository(String remoteStoreRepository) {
+        this.remoteStoreRepository = remoteStoreRepository;
+    }
+
+    public void setRemoteStoreTranslogRepository(String remoteStoreTranslogRepository) {
+        this.remoteStoreTranslogRepository = remoteStoreTranslogRepository;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/codec/CodecService.java b/server/src/main/java/org/opensearch/index/codec/CodecService.java
index 6d179e653a026..250100df60455 100644
--- a/server/src/main/java/org/opensearch/index/codec/CodecService.java
+++ b/server/src/main/java/org/opensearch/index/codec/CodecService.java
@@ -39,6 +39,7 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.collect.MapBuilder;
 import org.opensearch.index.IndexSettings;
+import org.opensearch.index.codec.composite.CompositeCodecFactory;
 import org.opensearch.index.mapper.MapperService;
 
 import java.util.Map;
@@ -63,6 +64,7 @@ public class CodecService {
      * the raw unfiltered lucene default. useful for testing
      */
     public static final String LUCENE_DEFAULT_CODEC = "lucene_default";
+    private final CompositeCodecFactory compositeCodecFactory = new CompositeCodecFactory();
 
     public CodecService(@Nullable MapperService mapperService, IndexSettings indexSettings, Logger logger) {
         final MapBuilder<String, Codec> codecs = MapBuilder.<String, Codec>newMapBuilder();
@@ -73,10 +75,16 @@ public CodecService(@Nullable MapperService mapperService, IndexSettings indexSe
             codecs.put(BEST_COMPRESSION_CODEC, new Lucene99Codec(Mode.BEST_COMPRESSION));
             codecs.put(ZLIB, new Lucene99Codec(Mode.BEST_COMPRESSION));
         } else {
-            codecs.put(DEFAULT_CODEC, new PerFieldMappingPostingFormatCodec(Mode.BEST_SPEED, mapperService, logger));
-            codecs.put(LZ4, new PerFieldMappingPostingFormatCodec(Mode.BEST_SPEED, mapperService, logger));
-            codecs.put(BEST_COMPRESSION_CODEC, new PerFieldMappingPostingFormatCodec(Mode.BEST_COMPRESSION, mapperService, logger));
-            codecs.put(ZLIB, new PerFieldMappingPostingFormatCodec(Mode.BEST_COMPRESSION, mapperService, logger));
+            // CompositeCodec still delegates to PerFieldMappingPostingFormatCodec
+            // We can still support all the compression codecs when composite index is present
+            if (mapperService.isCompositeIndexPresent()) {
+                codecs.putAll(compositeCodecFactory.getCompositeIndexCodecs(mapperService, logger));
+            } else {
+                codecs.put(DEFAULT_CODEC, new PerFieldMappingPostingFormatCodec(Mode.BEST_SPEED, mapperService, logger));
+                codecs.put(LZ4, new PerFieldMappingPostingFormatCodec(Mode.BEST_SPEED, mapperService, logger));
+                codecs.put(BEST_COMPRESSION_CODEC, new PerFieldMappingPostingFormatCodec(Mode.BEST_COMPRESSION, mapperService, logger));
+                codecs.put(ZLIB, new PerFieldMappingPostingFormatCodec(Mode.BEST_COMPRESSION, mapperService, logger));
+            }
         }
         codecs.put(LUCENE_DEFAULT_CODEC, Codec.getDefault());
         for (String codec : Codec.availableCodecs()) {
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/CompositeCodecFactory.java b/server/src/main/java/org/opensearch/index/codec/composite/CompositeCodecFactory.java
new file mode 100644
index 0000000000000..99691d7061ac9
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/CompositeCodecFactory.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.Codec;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.codec.composite.composite99.Composite99Codec;
+import org.opensearch.index.mapper.MapperService;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.opensearch.index.codec.CodecService.BEST_COMPRESSION_CODEC;
+import static org.opensearch.index.codec.CodecService.DEFAULT_CODEC;
+import static org.opensearch.index.codec.CodecService.LZ4;
+import static org.opensearch.index.codec.CodecService.ZLIB;
+
+/**
+ * Factory class to return the latest composite codec for all the modes
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class CompositeCodecFactory {
+
+    // we can use this to track the latest composite codec
+    public static final String COMPOSITE_CODEC = Composite99Codec.COMPOSITE_INDEX_CODEC_NAME;
+
+    public CompositeCodecFactory() {}
+
+    public Map<String, Codec> getCompositeIndexCodecs(MapperService mapperService, Logger logger) {
+        Map<String, Codec> codecs = new HashMap<>();
+        codecs.put(DEFAULT_CODEC, new Composite99Codec(Lucene99Codec.Mode.BEST_SPEED, mapperService, logger));
+        codecs.put(LZ4, new Composite99Codec(Lucene99Codec.Mode.BEST_SPEED, mapperService, logger));
+        codecs.put(BEST_COMPRESSION_CODEC, new Composite99Codec(Lucene99Codec.Mode.BEST_COMPRESSION, mapperService, logger));
+        codecs.put(ZLIB, new Composite99Codec(Lucene99Codec.Mode.BEST_COMPRESSION, mapperService, logger));
+        return codecs;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/CompositeIndexFieldInfo.java b/server/src/main/java/org/opensearch/index/codec/composite/CompositeIndexFieldInfo.java
new file mode 100644
index 0000000000000..8193fcc301e67
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/CompositeIndexFieldInfo.java
@@ -0,0 +1,37 @@
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+
+/**
+ * Field info details of composite index fields
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class CompositeIndexFieldInfo {
+    private final String field;
+    private final CompositeMappedFieldType.CompositeFieldType type;
+
+    public CompositeIndexFieldInfo(String field, CompositeMappedFieldType.CompositeFieldType type) {
+        this.field = field;
+        this.type = type;
+    }
+
+    public String getField() {
+        return field;
+    }
+
+    public CompositeMappedFieldType.CompositeFieldType getType() {
+        return type;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/CompositeIndexReader.java b/server/src/main/java/org/opensearch/index/codec/composite/CompositeIndexReader.java
new file mode 100644
index 0000000000000..9beb99e4a97cd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/CompositeIndexReader.java
@@ -0,0 +1,34 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.startree.index.CompositeIndexValues;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Interface that abstracts the functionality to read composite index structures from the segment
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface CompositeIndexReader {
+    /**
+     * Get list of composite index fields from the segment
+     *
+     */
+    List<CompositeIndexFieldInfo> getCompositeIndexFields();
+
+    /**
+     * Get composite index values based on the field name and the field type
+     */
+    CompositeIndexValues getCompositeIndexValues(CompositeIndexFieldInfo fieldInfo) throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/LuceneDocValuesConsumerFactory.java b/server/src/main/java/org/opensearch/index/codec/composite/LuceneDocValuesConsumerFactory.java
new file mode 100644
index 0000000000000..4b3f62b6171da
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/LuceneDocValuesConsumerFactory.java
@@ -0,0 +1,48 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.lucene90.Lucene90DocValuesConsumerWrapper;
+import org.apache.lucene.index.SegmentWriteState;
+
+import java.io.IOException;
+
+/**
+ * A factory class that provides a factory method for creating {@link DocValuesConsumer} instances
+ * for the latest composite codec.
+ * <p>
+ * The segments are written using the latest composite codec. The codec
+ * internally manages calling the appropriate consumer factory for its abstractions.
+ * <p>
+ * This design ensures forward compatibility for writing operations
+ *
+ * @opensearch.experimental
+ */
+public class LuceneDocValuesConsumerFactory {
+
+    public static DocValuesConsumer getDocValuesConsumerForCompositeCodec(
+        SegmentWriteState state,
+        String dataCodec,
+        String dataExtension,
+        String metaCodec,
+        String metaExtension
+    ) throws IOException {
+        Lucene90DocValuesConsumerWrapper lucene90DocValuesConsumerWrapper = new Lucene90DocValuesConsumerWrapper(
+            state,
+            dataCodec,
+            dataExtension,
+            metaCodec,
+            metaExtension
+        );
+        return lucene90DocValuesConsumerWrapper.getLucene90DocValuesConsumer();
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/LuceneDocValuesProducerFactory.java b/server/src/main/java/org/opensearch/index/codec/composite/LuceneDocValuesProducerFactory.java
new file mode 100644
index 0000000000000..d85205d239648
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/LuceneDocValuesProducerFactory.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene90.Lucene90DocValuesProducerWrapper;
+import org.apache.lucene.index.SegmentReadState;
+import org.opensearch.index.codec.composite.composite99.Composite99Codec;
+
+import java.io.IOException;
+
+/**
+ * A factory class that provides a factory method for creating {@link DocValuesProducer} instances
+ * based on the specified composite codec.
+ * <p>
+ * In producers, we want to ensure compatibility with older codec versions during the segment reads.
+ * This approach allows for writing with only the latest codec while maintaining
+ * the ability to read data encoded with any codec version present in the segment.
+ * <p>
+ * This design ensures backward compatibility for reads across different codec versions.
+ *
+ * @opensearch.experimental
+ */
+public class LuceneDocValuesProducerFactory {
+
+    public static DocValuesProducer getDocValuesProducerForCompositeCodec(
+        String compositeCodec,
+        SegmentReadState state,
+        String dataCodec,
+        String dataExtension,
+        String metaCodec,
+        String metaExtension
+    ) throws IOException {
+
+        switch (compositeCodec) {
+            case Composite99Codec.COMPOSITE_INDEX_CODEC_NAME:
+                Lucene90DocValuesProducerWrapper lucene90DocValuesProducerWrapper = new Lucene90DocValuesProducerWrapper(
+                    state,
+                    dataCodec,
+                    dataExtension,
+                    metaCodec,
+                    metaExtension
+                );
+                return lucene90DocValuesProducerWrapper.getLucene90DocValuesProducer();
+            default:
+                throw new IllegalStateException("Invalid composite codec " + "[" + compositeCodec + "]");
+        }
+
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99Codec.java b/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99Codec.java
new file mode 100644
index 0000000000000..8422932e937c2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99Codec.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite.composite99;
+
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.Codec;
+import org.apache.lucene.codecs.DocValuesFormat;
+import org.apache.lucene.codecs.FilterCodec;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.codec.PerFieldMappingPostingFormatCodec;
+import org.opensearch.index.mapper.MapperService;
+
+/**
+ *  Extends the Codec to support new file formats for composite indices eg: star tree index
+ *  based on the mappings.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class Composite99Codec extends FilterCodec {
+    public static final String COMPOSITE_INDEX_CODEC_NAME = "Composite99Codec";
+    private final MapperService mapperService;
+
+    // needed for SPI - this is used in reader path
+    public Composite99Codec() {
+        this(COMPOSITE_INDEX_CODEC_NAME, new Lucene99Codec(), null);
+    }
+
+    public Composite99Codec(Lucene99Codec.Mode compressionMode, MapperService mapperService, Logger logger) {
+        this(COMPOSITE_INDEX_CODEC_NAME, new PerFieldMappingPostingFormatCodec(compressionMode, mapperService, logger), mapperService);
+    }
+
+    /**
+     * Sole constructor. When subclassing this codec, create a no-arg ctor and pass the delegate codec and a unique name to
+     * this ctor.
+     *
+     * @param name name of the codec
+     * @param delegate codec delegate
+     * @param mapperService mapper service instance
+     */
+    protected Composite99Codec(String name, Codec delegate, MapperService mapperService) {
+        super(name, delegate);
+        this.mapperService = mapperService;
+    }
+
+    @Override
+    public DocValuesFormat docValuesFormat() {
+        return new Composite99DocValuesFormat(mapperService);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesFormat.java b/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesFormat.java
new file mode 100644
index 0000000000000..63fe5a6af76f7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesFormat.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite.composite99;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesFormat;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene90.Lucene90DocValuesFormat;
+import org.apache.lucene.index.SegmentReadState;
+import org.apache.lucene.index.SegmentWriteState;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.mapper.MapperService;
+
+import java.io.IOException;
+
+/**
+ * DocValues format to handle composite indices
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class Composite99DocValuesFormat extends DocValuesFormat {
+    /**
+     * Creates a new docvalues format.
+     *
+     * <p>The provided name will be written into the index segment in some configurations (such as
+     * when using {@code PerFieldDocValuesFormat}): in such configurations, for the segment to be read
+     * this class should be registered with Java's SPI mechanism (registered in META-INF/ of your jar
+     * file, etc).
+     */
+    private final DocValuesFormat delegate;
+    private final MapperService mapperService;
+
+    /** Data codec name for Composite Doc Values Format */
+    public static final String DATA_CODEC_NAME = "Composite99FormatData";
+
+    /** Meta codec name for Composite Doc Values Format */
+    public static final String META_CODEC_NAME = "Composite99FormatMeta";
+
+    /** Filename extension for the composite index data */
+    public static final String DATA_EXTENSION = "cid";
+
+    /** Filename extension for the composite index meta */
+    public static final String META_EXTENSION = "cim";
+
+    /** Data doc values codec name for Composite Doc Values Format */
+    public static final String DATA_DOC_VALUES_CODEC = "Composite99DocValuesData";
+
+    /** Meta doc values codec name for Composite Doc Values Format */
+    public static final String META_DOC_VALUES_CODEC = "Composite99DocValuesMetadata";
+
+    /** Filename extension for the composite index data doc values */
+    public static final String DATA_DOC_VALUES_EXTENSION = "cidvd";
+
+    /** Filename extension for the composite index meta doc values */
+    public static final String META_DOC_VALUES_EXTENSION = "cidvm";
+
+    /** Initial version for the Composite90DocValuesFormat */
+    public static final int VERSION_START = 0;
+
+    /** Current version for the Composite90DocValuesFormat */
+    public static final int VERSION_CURRENT = VERSION_START;
+
+    // needed for SPI
+    public Composite99DocValuesFormat() {
+        this(new Lucene90DocValuesFormat(), null);
+    }
+
+    public Composite99DocValuesFormat(MapperService mapperService) {
+        this(new Lucene90DocValuesFormat(), mapperService);
+    }
+
+    public Composite99DocValuesFormat(DocValuesFormat delegate, MapperService mapperService) {
+        super(delegate.getName());
+        this.delegate = delegate;
+        this.mapperService = mapperService;
+    }
+
+    @Override
+    public DocValuesConsumer fieldsConsumer(SegmentWriteState state) throws IOException {
+        return new Composite99DocValuesWriter(delegate.fieldsConsumer(state), state, mapperService);
+    }
+
+    @Override
+    public DocValuesProducer fieldsProducer(SegmentReadState state) throws IOException {
+        return new Composite99DocValuesReader(delegate.fieldsProducer(state), state);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesReader.java b/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesReader.java
new file mode 100644
index 0000000000000..7901336151c8e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesReader.java
@@ -0,0 +1,301 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite.composite99;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.CodecUtil;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.BinaryDocValues;
+import org.apache.lucene.index.CorruptIndexException;
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.IndexFileNames;
+import org.apache.lucene.index.NumericDocValues;
+import org.apache.lucene.index.SegmentReadState;
+import org.apache.lucene.index.SortedDocValues;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.index.SortedSetDocValues;
+import org.apache.lucene.store.ChecksumIndexInput;
+import org.apache.lucene.store.IndexInput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.index.codec.composite.CompositeIndexFieldInfo;
+import org.opensearch.index.codec.composite.CompositeIndexReader;
+import org.opensearch.index.codec.composite.LuceneDocValuesProducerFactory;
+import org.opensearch.index.compositeindex.CompositeIndexMetadata;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.meta.StarTreeMetadata;
+import org.opensearch.index.compositeindex.datacube.startree.index.CompositeIndexValues;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.COMPOSITE_FIELD_MARKER;
+import static org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter.VERSION_CURRENT;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeDimensionsDocValues;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.getFieldInfoList;
+
+/**
+ * Reader for star tree index and star tree doc values from the segments
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class Composite99DocValuesReader extends DocValuesProducer implements CompositeIndexReader {
+    private static final Logger logger = LogManager.getLogger(Composite99DocValuesReader.class);
+
+    private final DocValuesProducer delegate;
+    private IndexInput dataIn;
+    private ChecksumIndexInput metaIn;
+    private final Map<String, IndexInput> compositeIndexInputMap = new LinkedHashMap<>();
+    private final Map<String, CompositeIndexMetadata> compositeIndexMetadataMap = new LinkedHashMap<>();
+    private final List<String> fields;
+    private DocValuesProducer compositeDocValuesProducer;
+    private final List<CompositeIndexFieldInfo> compositeFieldInfos = new ArrayList<>();
+    private SegmentReadState readState;
+
+    public Composite99DocValuesReader(DocValuesProducer producer, SegmentReadState readState) throws IOException {
+        this.delegate = producer;
+        this.fields = new ArrayList<>();
+
+        String metaFileName = IndexFileNames.segmentFileName(
+            readState.segmentInfo.name,
+            readState.segmentSuffix,
+            Composite99DocValuesFormat.META_EXTENSION
+        );
+
+        String dataFileName = IndexFileNames.segmentFileName(
+            readState.segmentInfo.name,
+            readState.segmentSuffix,
+            Composite99DocValuesFormat.DATA_EXTENSION
+        );
+
+        boolean success = false;
+        try {
+
+            // initialize meta input
+            dataIn = readState.directory.openInput(dataFileName, readState.context);
+            CodecUtil.checkIndexHeader(
+                dataIn,
+                Composite99DocValuesFormat.DATA_CODEC_NAME,
+                Composite99DocValuesFormat.VERSION_START,
+                Composite99DocValuesFormat.VERSION_CURRENT,
+                readState.segmentInfo.getId(),
+                readState.segmentSuffix
+            );
+
+            // initialize data input
+            metaIn = readState.directory.openChecksumInput(metaFileName, readState.context);
+            Throwable priorE = null;
+            try {
+                CodecUtil.checkIndexHeader(
+                    metaIn,
+                    Composite99DocValuesFormat.META_CODEC_NAME,
+                    Composite99DocValuesFormat.VERSION_START,
+                    Composite99DocValuesFormat.VERSION_CURRENT,
+                    readState.segmentInfo.getId(),
+                    readState.segmentSuffix
+                );
+
+                while (true) {
+
+                    // validate magic marker
+                    long magicMarker = metaIn.readLong();
+                    if (magicMarker == -1) {
+                        break;
+                    } else if (magicMarker < 0) {
+                        throw new CorruptIndexException("Unknown token encountered: " + magicMarker, metaIn);
+                    } else if (COMPOSITE_FIELD_MARKER != magicMarker) {
+                        logger.error("Invalid composite field magic marker");
+                        throw new IOException("Invalid composite field magic marker");
+                    }
+
+                    int version = metaIn.readVInt();
+                    if (VERSION_CURRENT != version) {
+                        logger.error("Invalid composite field version");
+                        throw new IOException("Invalid composite field version");
+                    }
+
+                    // construct composite index metadata
+                    String compositeFieldName = metaIn.readString();
+                    CompositeMappedFieldType.CompositeFieldType compositeFieldType = CompositeMappedFieldType.CompositeFieldType.fromName(
+                        metaIn.readString()
+                    );
+
+                    switch (compositeFieldType) {
+                        case STAR_TREE:
+                            StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+                                metaIn,
+                                compositeFieldName,
+                                compositeFieldType,
+                                version
+                            );
+                            compositeFieldInfos.add(new CompositeIndexFieldInfo(compositeFieldName, compositeFieldType));
+
+                            IndexInput starTreeIndexInput = dataIn.slice(
+                                "star-tree data slice for respective star-tree fields",
+                                starTreeMetadata.getDataStartFilePointer(),
+                                starTreeMetadata.getDataLength()
+                            );
+                            compositeIndexInputMap.put(compositeFieldName, starTreeIndexInput);
+                            compositeIndexMetadataMap.put(compositeFieldName, starTreeMetadata);
+
+                            List<String> dimensionFields = starTreeMetadata.getDimensionFields();
+
+                            // generating star tree unique fields (fully qualified name for dimension and metrics)
+                            for (String dimensions : dimensionFields) {
+                                fields.add(fullyQualifiedFieldNameForStarTreeDimensionsDocValues(compositeFieldName, dimensions));
+                            }
+
+                            // adding metric fields
+                            for (Metric metric : starTreeMetadata.getMetrics()) {
+                                for (MetricStat metricStat : metric.getBaseMetrics()) {
+                                    fields.add(
+                                        fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                                            compositeFieldName,
+                                            metric.getField(),
+                                            metricStat.getTypeName()
+                                        )
+                                    );
+
+                                }
+                            }
+
+                            break;
+                        default:
+                            throw new CorruptIndexException("Invalid composite field type found in the file", dataIn);
+                    }
+                }
+
+                // populates the dummy list of field infos to fetch doc id set iterators for respective fields.
+                // the dummy field info is used to fetch the doc id set iterators for respective fields based on field name
+                FieldInfos fieldInfos = new FieldInfos(getFieldInfoList(fields));
+                this.readState = new SegmentReadState(readState.directory, readState.segmentInfo, fieldInfos, readState.context);
+
+                // initialize star-tree doc values producer
+
+                compositeDocValuesProducer = LuceneDocValuesProducerFactory.getDocValuesProducerForCompositeCodec(
+                    Composite99Codec.COMPOSITE_INDEX_CODEC_NAME,
+                    this.readState,
+                    Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+                    Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+                    Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+                    Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+                );
+
+            } catch (Throwable t) {
+                priorE = t;
+            } finally {
+                CodecUtil.checkFooter(metaIn, priorE);
+            }
+            success = true;
+        } finally {
+            if (success == false) {
+                IOUtils.closeWhileHandlingException(this);
+            }
+        }
+    }
+
+    @Override
+    public NumericDocValues getNumeric(FieldInfo field) throws IOException {
+        return delegate.getNumeric(field);
+    }
+
+    @Override
+    public BinaryDocValues getBinary(FieldInfo field) throws IOException {
+        return delegate.getBinary(field);
+    }
+
+    @Override
+    public SortedDocValues getSorted(FieldInfo field) throws IOException {
+        return delegate.getSorted(field);
+    }
+
+    @Override
+    public SortedNumericDocValues getSortedNumeric(FieldInfo field) throws IOException {
+        return delegate.getSortedNumeric(field);
+    }
+
+    @Override
+    public SortedSetDocValues getSortedSet(FieldInfo field) throws IOException {
+        return delegate.getSortedSet(field);
+    }
+
+    @Override
+    public void checkIntegrity() throws IOException {
+        delegate.checkIntegrity();
+        CodecUtil.checksumEntireFile(dataIn);
+    }
+
+    @Override
+    public void close() throws IOException {
+        delegate.close();
+        boolean success = false;
+        try {
+            IOUtils.close(metaIn, dataIn);
+            IOUtils.close(compositeDocValuesProducer);
+            success = true;
+        } finally {
+            if (!success) {
+                IOUtils.closeWhileHandlingException(metaIn, dataIn);
+            }
+            compositeIndexInputMap.clear();
+            compositeIndexMetadataMap.clear();
+            fields.clear();
+            metaIn = null;
+            dataIn = null;
+        }
+    }
+
+    @Override
+    public List<CompositeIndexFieldInfo> getCompositeIndexFields() {
+        return compositeFieldInfos;
+    }
+
+    @Override
+    public CompositeIndexValues getCompositeIndexValues(CompositeIndexFieldInfo compositeIndexFieldInfo) throws IOException {
+
+        switch (compositeIndexFieldInfo.getType()) {
+            case STAR_TREE:
+                return new StarTreeValues(
+                    compositeIndexMetadataMap.get(compositeIndexFieldInfo.getField()),
+                    compositeIndexInputMap.get(compositeIndexFieldInfo.getField()),
+                    compositeDocValuesProducer,
+                    this.readState
+                );
+
+            default:
+                throw new CorruptIndexException("Unsupported composite index field type: ", compositeIndexFieldInfo.getType().getName());
+        }
+
+    }
+
+    /**
+     * Returns the sorted numeric doc values for the given sorted numeric field.
+     * If the sorted numeric field is null, it returns an empty doc id set iterator.
+     * <p>
+     * Sorted numeric field can be null for cases where the segment doesn't hold a particular value.
+     *
+     * @param sortedNumeric the sorted numeric doc values for a field
+     * @return empty sorted numeric values if the field is not present, else sortedNumeric
+     */
+    public static SortedNumericDocValues getSortedNumericDocValues(SortedNumericDocValues sortedNumeric) {
+        return sortedNumeric == null ? DocValues.emptySortedNumeric() : sortedNumeric;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesWriter.java b/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesWriter.java
new file mode 100644
index 0000000000000..0d4e35f7c3ab8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/composite99/Composite99DocValuesWriter.java
@@ -0,0 +1,347 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite.composite99;
+
+import org.apache.lucene.codecs.CodecUtil;
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.EmptyDocValuesProducer;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.IndexFileNames;
+import org.apache.lucene.index.MergeState;
+import org.apache.lucene.index.NumericDocValues;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.index.codec.composite.CompositeIndexFieldInfo;
+import org.opensearch.index.codec.composite.CompositeIndexReader;
+import org.opensearch.index.codec.composite.LuceneDocValuesConsumerFactory;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.builder.StarTreesBuilder;
+import org.opensearch.index.compositeindex.datacube.startree.index.CompositeIndexValues;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+import org.opensearch.index.mapper.DocCountFieldMapper;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.StarTreeMapper;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * This class write the star tree index and star tree doc values
+ * based on the doc values structures of the original index
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class Composite99DocValuesWriter extends DocValuesConsumer {
+    private final DocValuesConsumer delegate;
+    private final SegmentWriteState state;
+    private final MapperService mapperService;
+    AtomicReference<MergeState> mergeState = new AtomicReference<>();
+    private final Set<CompositeMappedFieldType> compositeMappedFieldTypes;
+    private final Set<String> compositeFieldSet;
+    private DocValuesConsumer composite99DocValuesConsumer;
+
+    public IndexOutput dataOut;
+    public IndexOutput metaOut;
+    private final Set<String> segmentFieldSet;
+    private final boolean segmentHasCompositeFields;
+    private final AtomicInteger fieldNumberAcrossCompositeFields;
+
+    private final Map<String, DocValuesProducer> fieldProducerMap = new HashMap<>();
+
+    public Composite99DocValuesWriter(DocValuesConsumer delegate, SegmentWriteState segmentWriteState, MapperService mapperService)
+        throws IOException {
+
+        this.delegate = delegate;
+        this.state = segmentWriteState;
+        this.mapperService = mapperService;
+        this.fieldNumberAcrossCompositeFields = new AtomicInteger();
+        this.compositeMappedFieldTypes = mapperService.getCompositeFieldTypes();
+        compositeFieldSet = new HashSet<>();
+        segmentFieldSet = new HashSet<>();
+        // TODO : add integ test for this
+        for (FieldInfo fi : this.state.fieldInfos) {
+            if (DocValuesType.SORTED_NUMERIC.equals(fi.getDocValuesType())) {
+                segmentFieldSet.add(fi.name);
+            } else if (fi.name.equals(DocCountFieldMapper.NAME)) {
+                segmentFieldSet.add(fi.name);
+            }
+        }
+        for (CompositeMappedFieldType type : compositeMappedFieldTypes) {
+            compositeFieldSet.addAll(type.fields());
+        }
+
+        boolean success = false;
+        try {
+
+            // Get consumer write state with DocIdSetIterator.NO_MORE_DOCS as segment doc count,
+            // so that all the fields are sparse numeric doc values and not dense numeric doc values
+            SegmentWriteState consumerWriteState = getSegmentWriteState(segmentWriteState);
+
+            this.composite99DocValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+                consumerWriteState,
+                Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+                Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+                Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+                Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+            );
+
+            String dataFileName = IndexFileNames.segmentFileName(
+                this.state.segmentInfo.name,
+                this.state.segmentSuffix,
+                Composite99DocValuesFormat.DATA_EXTENSION
+            );
+            dataOut = this.state.directory.createOutput(dataFileName, this.state.context);
+            CodecUtil.writeIndexHeader(
+                dataOut,
+                Composite99DocValuesFormat.DATA_CODEC_NAME,
+                Composite99DocValuesFormat.VERSION_CURRENT,
+                this.state.segmentInfo.getId(),
+                this.state.segmentSuffix
+            );
+
+            String metaFileName = IndexFileNames.segmentFileName(
+                this.state.segmentInfo.name,
+                this.state.segmentSuffix,
+                Composite99DocValuesFormat.META_EXTENSION
+            );
+            metaOut = this.state.directory.createOutput(metaFileName, this.state.context);
+            CodecUtil.writeIndexHeader(
+                metaOut,
+                Composite99DocValuesFormat.META_CODEC_NAME,
+                Composite99DocValuesFormat.VERSION_CURRENT,
+                this.state.segmentInfo.getId(),
+                this.state.segmentSuffix
+            );
+
+            success = true;
+        } finally {
+            if (success == false) {
+                IOUtils.closeWhileHandlingException(this);
+            }
+        }
+        // check if there are any composite fields which are part of the segment
+        // TODO : add integ test where there are no composite fields in a segment, test both flush and merge cases
+        segmentHasCompositeFields = Collections.disjoint(segmentFieldSet, compositeFieldSet) == false;
+    }
+
+    @Override
+    public void addNumericField(FieldInfo field, DocValuesProducer valuesProducer) throws IOException {
+        delegate.addNumericField(field, valuesProducer);
+        // Perform this only during flush flow
+        if (mergeState.get() == null && segmentHasCompositeFields) {
+            createCompositeIndicesIfPossible(valuesProducer, field);
+        }
+    }
+
+    @Override
+    public void addBinaryField(FieldInfo field, DocValuesProducer valuesProducer) throws IOException {
+        delegate.addBinaryField(field, valuesProducer);
+    }
+
+    @Override
+    public void addSortedField(FieldInfo field, DocValuesProducer valuesProducer) throws IOException {
+        delegate.addSortedField(field, valuesProducer);
+    }
+
+    @Override
+    public void addSortedNumericField(FieldInfo field, DocValuesProducer valuesProducer) throws IOException {
+        delegate.addSortedNumericField(field, valuesProducer);
+        // Perform this only during flush flow
+        if (mergeState.get() == null && segmentHasCompositeFields) {
+            createCompositeIndicesIfPossible(valuesProducer, field);
+        }
+    }
+
+    @Override
+    public void addSortedSetField(FieldInfo field, DocValuesProducer valuesProducer) throws IOException {
+        delegate.addSortedSetField(field, valuesProducer);
+    }
+
+    @Override
+    public void close() throws IOException {
+        delegate.close();
+        boolean success = false;
+        try {
+            if (metaOut != null) {
+                metaOut.writeLong(-1); // write EOF marker
+                CodecUtil.writeFooter(metaOut); // write checksum
+            }
+            if (dataOut != null) {
+                CodecUtil.writeFooter(dataOut); // write checksum
+            }
+
+            success = true;
+        } finally {
+            if (success) {
+                IOUtils.close(dataOut, metaOut, composite99DocValuesConsumer);
+            } else {
+                IOUtils.closeWhileHandlingException(dataOut, metaOut, composite99DocValuesConsumer);
+            }
+            metaOut = dataOut = null;
+            composite99DocValuesConsumer = null;
+        }
+    }
+
+    private void createCompositeIndicesIfPossible(DocValuesProducer valuesProducer, FieldInfo field) throws IOException {
+        if (compositeFieldSet.isEmpty()) return;
+        if (compositeFieldSet.contains(field.name)) {
+            fieldProducerMap.put(field.name, valuesProducer);
+            compositeFieldSet.remove(field.name);
+        }
+        segmentFieldSet.remove(field.name);
+        if (segmentFieldSet.isEmpty()) {
+            Set<String> compositeFieldSetCopy = new HashSet<>(compositeFieldSet);
+            for (String compositeField : compositeFieldSetCopy) {
+                addDocValuesForEmptyField(compositeField);
+            }
+        }
+        // we have all the required fields to build composite fields
+        if (compositeFieldSet.isEmpty()) {
+            for (CompositeMappedFieldType mappedType : compositeMappedFieldTypes) {
+                if (mappedType instanceof StarTreeMapper.StarTreeFieldType) {
+                    try (StarTreesBuilder starTreesBuilder = new StarTreesBuilder(state, mapperService, fieldNumberAcrossCompositeFields)) {
+                        starTreesBuilder.build(metaOut, dataOut, fieldProducerMap, composite99DocValuesConsumer);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Add empty doc values for fields not present in segment
+     */
+    private void addDocValuesForEmptyField(String compositeField) {
+        if (compositeField.equals(DocCountFieldMapper.NAME)) {
+            fieldProducerMap.put(compositeField, new EmptyDocValuesProducer() {
+                @Override
+                public NumericDocValues getNumeric(FieldInfo field) {
+                    return DocValues.emptyNumeric();
+                }
+            });
+        } else {
+            fieldProducerMap.put(compositeField, new EmptyDocValuesProducer() {
+                @Override
+                public SortedNumericDocValues getSortedNumeric(FieldInfo field) {
+                    return DocValues.emptySortedNumeric();
+                }
+            });
+        }
+        compositeFieldSet.remove(compositeField);
+    }
+
+    @Override
+    public void merge(MergeState mergeState) throws IOException {
+        this.mergeState.compareAndSet(null, mergeState);
+        super.merge(mergeState);
+        mergeCompositeFields(mergeState);
+    }
+
+    /**
+     * Merges composite fields from multiple segments
+     *
+     * @param mergeState merge state
+     */
+    private void mergeCompositeFields(MergeState mergeState) throws IOException {
+        mergeStarTreeFields(mergeState);
+    }
+
+    /**
+     * Merges star tree data fields from multiple segments
+     *
+     * @param mergeState merge state
+     */
+    private void mergeStarTreeFields(MergeState mergeState) throws IOException {
+        Map<String, List<StarTreeValues>> starTreeSubsPerField = new HashMap<>();
+        StarTreeField starTreeField = null;
+        for (int i = 0; i < mergeState.docValuesProducers.length; i++) {
+            CompositeIndexReader reader = null;
+            if (mergeState.docValuesProducers[i] == null) {
+                continue;
+            }
+            if (mergeState.docValuesProducers[i] instanceof CompositeIndexReader) {
+                reader = (CompositeIndexReader) mergeState.docValuesProducers[i];
+            } else {
+                continue;
+            }
+
+            List<CompositeIndexFieldInfo> compositeFieldInfo = reader.getCompositeIndexFields();
+            for (CompositeIndexFieldInfo fieldInfo : compositeFieldInfo) {
+                if (fieldInfo.getType().equals(CompositeMappedFieldType.CompositeFieldType.STAR_TREE)) {
+                    CompositeIndexValues compositeIndexValues = reader.getCompositeIndexValues(fieldInfo);
+                    if (compositeIndexValues instanceof StarTreeValues) {
+                        StarTreeValues starTreeValues = (StarTreeValues) compositeIndexValues;
+                        List<StarTreeValues> fieldsList = starTreeSubsPerField.getOrDefault(fieldInfo.getField(), new ArrayList<>());
+                        if (starTreeField == null) {
+                            starTreeField = starTreeValues.getStarTreeField();
+                        }
+                        // assert star tree configuration is same across segments
+                        else {
+                            if (starTreeField.equals(starTreeValues.getStarTreeField()) == false) {
+                                throw new IllegalArgumentException(
+                                    "star tree field configuration must match the configuration of the field being merged"
+                                );
+                            }
+                        }
+                        fieldsList.add(starTreeValues);
+                        starTreeSubsPerField.put(fieldInfo.getField(), fieldsList);
+                    }
+                }
+            }
+        }
+        try (StarTreesBuilder starTreesBuilder = new StarTreesBuilder(state, mapperService, fieldNumberAcrossCompositeFields)) {
+            starTreesBuilder.buildDuringMerge(metaOut, dataOut, starTreeSubsPerField, composite99DocValuesConsumer);
+        }
+    }
+
+    private static SegmentWriteState getSegmentWriteState(SegmentWriteState segmentWriteState) {
+
+        SegmentInfo segmentInfo = new SegmentInfo(
+            segmentWriteState.segmentInfo.dir,
+            segmentWriteState.segmentInfo.getVersion(),
+            segmentWriteState.segmentInfo.getMinVersion(),
+            segmentWriteState.segmentInfo.name,
+            DocIdSetIterator.NO_MORE_DOCS,
+            segmentWriteState.segmentInfo.getUseCompoundFile(),
+            segmentWriteState.segmentInfo.getHasBlocks(),
+            segmentWriteState.segmentInfo.getCodec(),
+            segmentWriteState.segmentInfo.getDiagnostics(),
+            segmentWriteState.segmentInfo.getId(),
+            segmentWriteState.segmentInfo.getAttributes(),
+            segmentWriteState.segmentInfo.getIndexSort()
+        );
+
+        return new SegmentWriteState(
+            segmentWriteState.infoStream,
+            segmentWriteState.directory,
+            segmentInfo,
+            segmentWriteState.fieldInfos,
+            segmentWriteState.segUpdates,
+            segmentWriteState.context
+        );
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/composite99/package-info.java b/server/src/main/java/org/opensearch/index/codec/composite/composite99/package-info.java
new file mode 100644
index 0000000000000..3d6f130b9a7c8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/composite99/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ *  Responsible for handling all composite index codecs and operations associated with Composite99 codec
+ */
+package org.opensearch.index.codec.composite.composite99;
diff --git a/server/src/main/java/org/opensearch/index/codec/composite/package-info.java b/server/src/main/java/org/opensearch/index/codec/composite/package-info.java
new file mode 100644
index 0000000000000..5d15e99c00975
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/codec/composite/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ *  classes responsible for handling all composite index codecs and operations
+ */
+package org.opensearch.index.codec.composite;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexConstants.java b/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexConstants.java
new file mode 100644
index 0000000000000..81e19f6cdb1a3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexConstants.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex;
+
+/**
+ * This class contains constants used in the Composite Index implementation.
+ */
+public class CompositeIndexConstants {
+
+    /**
+     * The magic marker value used for sanity checks in the Composite Index implementation.
+     */
+    public static final long COMPOSITE_FIELD_MARKER = 0xC0950513F1E1DL; // Composite Field
+
+    /**
+     * Represents the key to fetch number of non-star aggregated segment documents.
+     */
+    public static final String SEGMENT_DOCS_COUNT = "segmentDocsCount";
+
+    /**
+     * Represents the key to fetch number of total star tree documents in a segment.
+     */
+    public static final String STAR_TREE_DOCS_COUNT = "starTreeDocsCount";
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexMetadata.java b/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexMetadata.java
new file mode 100644
index 0000000000000..4972c877d4ab8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexMetadata.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex;
+
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+
+/**
+ * This class represents the metadata of a Composite Index, which includes information about
+ * the composite field name, type, and the specific metadata for the type of composite field
+ * (e.g., Star Tree metadata).
+ *
+ * @opensearch.experimental
+ */
+public class CompositeIndexMetadata {
+
+    private final String compositeFieldName;
+    private final CompositeMappedFieldType.CompositeFieldType compositeFieldType;
+
+    /**
+     * Constructs a CompositeIndexMetadata object with the provided composite field name and type.
+     *
+     * @param compositeFieldName the name of the composite field
+     * @param compositeFieldType the type of the composite field
+     */
+    public CompositeIndexMetadata(String compositeFieldName, CompositeMappedFieldType.CompositeFieldType compositeFieldType) {
+        this.compositeFieldName = compositeFieldName;
+        this.compositeFieldType = compositeFieldType;
+    }
+
+    /**
+     * Returns the name of the composite field.
+     *
+     * @return the composite field name
+     */
+    public String getCompositeFieldName() {
+        return compositeFieldName;
+    }
+
+    /**
+     * Returns the type of the composite field.
+     *
+     * @return the composite field type
+     */
+    public CompositeMappedFieldType.CompositeFieldType getCompositeFieldType() {
+        return compositeFieldType;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexSettings.java b/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexSettings.java
new file mode 100644
index 0000000000000..a29e642d30f05
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexSettings.java
@@ -0,0 +1,68 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.common.unit.ByteSizeValue;
+
+/**
+ * Cluster level settings for composite indices
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class CompositeIndexSettings {
+    public static final Setting<Boolean> STAR_TREE_INDEX_ENABLED_SETTING = Setting.boolSetting(
+        "indices.composite_index.star_tree.enabled",
+        false,
+        value -> {
+            if (FeatureFlags.isEnabled(FeatureFlags.STAR_TREE_INDEX_SETTING) == false && value == true) {
+                throw new IllegalArgumentException(
+                    "star tree index is under an experimental feature and can be activated only by enabling "
+                        + FeatureFlags.STAR_TREE_INDEX_SETTING.getKey()
+                        + " feature flag in the JVM options"
+                );
+            }
+        },
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    /**
+     * This sets the max flush threshold size for composite index
+     */
+    public static final Setting<ByteSizeValue> COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING = Setting.byteSizeSetting(
+        "indices.composite_index.translog.max_flush_threshold_size",
+        new ByteSizeValue(512, ByteSizeUnit.MB),
+        new ByteSizeValue(128, ByteSizeUnit.MB),
+        new ByteSizeValue(Long.MAX_VALUE, ByteSizeUnit.BYTES),
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    private volatile boolean starTreeIndexCreationEnabled;
+
+    public CompositeIndexSettings(Settings settings, ClusterSettings clusterSettings) {
+        this.starTreeIndexCreationEnabled = STAR_TREE_INDEX_ENABLED_SETTING.get(settings);
+        clusterSettings.addSettingsUpdateConsumer(STAR_TREE_INDEX_ENABLED_SETTING, this::starTreeIndexCreationEnabled);
+    }
+
+    private void starTreeIndexCreationEnabled(boolean value) {
+        this.starTreeIndexCreationEnabled = value;
+    }
+
+    public boolean isStarTreeIndexCreationEnabled() {
+        return starTreeIndexCreationEnabled;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexValidator.java b/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexValidator.java
new file mode 100644
index 0000000000000..995352e3ce6a5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/CompositeIndexValidator.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeValidator;
+import org.opensearch.index.mapper.MapperService;
+
+import java.util.Locale;
+
+/**
+ * Validation for composite indices as part of mappings
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class CompositeIndexValidator {
+
+    public static void validate(MapperService mapperService, CompositeIndexSettings compositeIndexSettings, IndexSettings indexSettings) {
+        StarTreeValidator.validate(mapperService, compositeIndexSettings, indexSettings);
+    }
+
+    public static void validate(
+        MapperService mapperService,
+        CompositeIndexSettings compositeIndexSettings,
+        IndexSettings indexSettings,
+        boolean isCompositeFieldPresent
+    ) {
+        if (!isCompositeFieldPresent && mapperService.isCompositeIndexPresent()) {
+            throw new IllegalArgumentException(
+                String.format(
+                    Locale.ROOT,
+                    "Composite fields must be specified during index creation, addition of new composite fields during update is not supported"
+                )
+            );
+        }
+        StarTreeValidator.validate(mapperService, compositeIndexSettings, indexSettings);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/DateDimension.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DateDimension.java
new file mode 100644
index 0000000000000..074016db2aed7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DateDimension.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+import org.opensearch.common.Rounding;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.mapper.CompositeDataCubeFieldType;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Date dimension class
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class DateDimension implements Dimension {
+    private final List<Rounding.DateTimeUnit> calendarIntervals;
+    public static final String CALENDAR_INTERVALS = "calendar_intervals";
+    public static final String DATE = "date";
+    private final String field;
+
+    public DateDimension(String field, List<Rounding.DateTimeUnit> calendarIntervals) {
+        this.field = field;
+        this.calendarIntervals = calendarIntervals;
+    }
+
+    public List<Rounding.DateTimeUnit> getIntervals() {
+        return calendarIntervals;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(CompositeDataCubeFieldType.NAME, this.getField());
+        builder.field(CompositeDataCubeFieldType.TYPE, DATE);
+        builder.startArray(CALENDAR_INTERVALS);
+        for (Rounding.DateTimeUnit interval : calendarIntervals) {
+            builder.value(interval.shortName());
+        }
+        builder.endArray();
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        DateDimension that = (DateDimension) o;
+        return Objects.equals(field, that.getField()) && Objects.equals(calendarIntervals, that.calendarIntervals);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(field, calendarIntervals);
+    }
+
+    @Override
+    public String getField() {
+        return field;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/Dimension.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/Dimension.java
new file mode 100644
index 0000000000000..0151a474579be
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/Dimension.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.xcontent.ToXContent;
+
+/**
+ * Base interface for data-cube dimensions
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface Dimension extends ToXContent {
+    String getField();
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionFactory.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionFactory.java
new file mode 100644
index 0000000000000..3c418c68fe8ad
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionFactory.java
@@ -0,0 +1,99 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+import org.opensearch.common.Rounding;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.xcontent.support.XContentMapValues;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.mapper.Mapper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static org.opensearch.index.compositeindex.datacube.DateDimension.CALENDAR_INTERVALS;
+
+/**
+ * Dimension factory class mainly used to parse and create dimension from the mappings
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class DimensionFactory {
+    public static Dimension parseAndCreateDimension(
+        String name,
+        String type,
+        Map<String, Object> dimensionMap,
+        Mapper.TypeParser.ParserContext c
+    ) {
+        switch (type) {
+            case DateDimension.DATE:
+                return parseAndCreateDateDimension(name, dimensionMap, c);
+            case NumericDimension.NUMERIC:
+                return new NumericDimension(name);
+            default:
+                throw new IllegalArgumentException(
+                    String.format(Locale.ROOT, "unsupported field type associated with dimension [%s] as part of star tree field", name)
+                );
+        }
+    }
+
+    public static Dimension parseAndCreateDimension(
+        String name,
+        Mapper.Builder builder,
+        Map<String, Object> dimensionMap,
+        Mapper.TypeParser.ParserContext c
+    ) {
+        if (builder.getSupportedDataCubeDimensionType().isPresent()
+            && builder.getSupportedDataCubeDimensionType().get().equals(DimensionType.DATE)) {
+            return parseAndCreateDateDimension(name, dimensionMap, c);
+        } else if (builder.getSupportedDataCubeDimensionType().isPresent()
+            && builder.getSupportedDataCubeDimensionType().get().equals(DimensionType.NUMERIC)) {
+                return new NumericDimension(name);
+            }
+        throw new IllegalArgumentException(
+            String.format(Locale.ROOT, "unsupported field type associated with star tree dimension [%s]", name)
+        );
+    }
+
+    private static DateDimension parseAndCreateDateDimension(
+        String name,
+        Map<String, Object> dimensionMap,
+        Mapper.TypeParser.ParserContext c
+    ) {
+        List<Rounding.DateTimeUnit> calendarIntervals = new ArrayList<>();
+        List<String> intervalStrings = XContentMapValues.extractRawValues(CALENDAR_INTERVALS, dimensionMap)
+            .stream()
+            .map(Object::toString)
+            .collect(Collectors.toList());
+        if (intervalStrings == null || intervalStrings.isEmpty()) {
+            calendarIntervals = StarTreeIndexSettings.DEFAULT_DATE_INTERVALS.get(c.getSettings());
+        } else {
+            if (intervalStrings.size() > StarTreeIndexSettings.STAR_TREE_MAX_DATE_INTERVALS_SETTING.get(c.getSettings())) {
+                throw new IllegalArgumentException(
+                    String.format(
+                        Locale.ROOT,
+                        "At most [%s] calendar intervals are allowed in dimension [%s]",
+                        StarTreeIndexSettings.STAR_TREE_MAX_DATE_INTERVALS_SETTING.get(c.getSettings()),
+                        name
+                    )
+                );
+            }
+            for (String interval : intervalStrings) {
+                calendarIntervals.add(StarTreeIndexSettings.getTimeUnit(interval));
+            }
+            calendarIntervals = new ArrayList<>(calendarIntervals);
+        }
+        dimensionMap.remove(CALENDAR_INTERVALS);
+        return new DateDimension(name, calendarIntervals);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionType.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionType.java
new file mode 100644
index 0000000000000..4b9faea331752
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/DimensionType.java
@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+/**
+ * Represents the types of dimensions supported in a data cube.
+ * <p>
+ * This enum defines the possible types of dimensions that can be used
+ * in a data cube structure within the composite index.
+ *
+ * @opensearch.experimental
+ */
+public enum DimensionType {
+    /**
+     * Represents a numeric dimension type.
+     * This is used for dimensions that contain numerical values.
+     */
+    NUMERIC,
+
+    /**
+     * Represents a date dimension type.
+     * This is used for dimensions that contain date or timestamp values.
+     */
+    DATE
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/Metric.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/Metric.java
new file mode 100644
index 0000000000000..be16f1e9886cd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/Metric.java
@@ -0,0 +1,81 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Holds details of metrics field as part of composite field
+ */
+@ExperimentalApi
+public class Metric implements ToXContent {
+    private final String field;
+    private final List<MetricStat> metrics;
+    private final List<MetricStat> baseMetrics;
+
+    public Metric(String field, List<MetricStat> metrics) {
+        this.field = field;
+        this.metrics = metrics;
+        this.baseMetrics = new ArrayList<>();
+        for (MetricStat metricStat : metrics) {
+            if (metricStat.isDerivedMetric()) {
+                continue;
+            }
+            baseMetrics.add(metricStat);
+        }
+    }
+
+    public String getField() {
+        return field;
+    }
+
+    public List<MetricStat> getMetrics() {
+        return metrics;
+    }
+
+    /**
+     * Returns only the base metrics
+     */
+    public List<MetricStat> getBaseMetrics() {
+        return baseMetrics;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field("name", field);
+        builder.startArray("stats");
+        for (MetricStat metricType : metrics) {
+            builder.value(metricType.getTypeName());
+        }
+        builder.endArray();
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        Metric metric = (Metric) o;
+        return Objects.equals(field, metric.field) && Objects.equals(metrics, metric.metrics);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(field, metrics);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/MetricStat.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/MetricStat.java
new file mode 100644
index 0000000000000..a7b4c96c372d8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/MetricStat.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Supported metric types for composite index
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public enum MetricStat {
+    VALUE_COUNT("value_count", 0),
+    SUM("sum", 1),
+    MIN("min", 2),
+    MAX("max", 3),
+    AVG("avg", 4, VALUE_COUNT, SUM),
+    DOC_COUNT("doc_count", true, 5);
+
+    private final String typeName;
+    private final MetricStat[] baseMetrics;
+    private final int metricOrdinal;
+
+    // System field stats cannot be used as input for user metric types
+    private final boolean isSystemFieldStat;
+
+    MetricStat(String typeName, int metricOrdinal) {
+        this(typeName, false, metricOrdinal);
+    }
+
+    MetricStat(String typeName, int metricOrdinal, MetricStat... baseMetrics) {
+        this(typeName, false, metricOrdinal, baseMetrics);
+    }
+
+    MetricStat(String typeName, boolean isSystemFieldStat, int metricOrdinal, MetricStat... baseMetrics) {
+        this.typeName = typeName;
+        this.isSystemFieldStat = isSystemFieldStat;
+        this.baseMetrics = baseMetrics;
+        this.metricOrdinal = metricOrdinal;
+    }
+
+    public String getTypeName() {
+        return typeName;
+    }
+
+    public int getMetricOrdinal() {
+        return metricOrdinal;
+    }
+
+    /**
+     * Return the list of metrics that this metric is derived from
+     * For example, AVG is derived from COUNT and SUM
+     */
+    public List<MetricStat> getBaseMetrics() {
+        return Arrays.asList(baseMetrics);
+    }
+
+    /**
+     * Return true if this metric is derived from other metrics
+     * For example, AVG is derived from COUNT and SUM
+     */
+    public boolean isDerivedMetric() {
+        return baseMetrics != null && baseMetrics.length > 0;
+    }
+
+    public static MetricStat fromTypeName(String typeName) {
+        for (MetricStat metric : MetricStat.values()) {
+            // prevent system fields to be entered as user input
+            if (metric.getTypeName().equalsIgnoreCase(typeName) && metric.isSystemFieldStat == false) {
+                return metric;
+            }
+        }
+        throw new IllegalArgumentException("Invalid metric stat: " + typeName);
+    }
+
+    public static MetricStat fromMetricOrdinal(int metricOrdinal) {
+        for (MetricStat metric : MetricStat.values()) {
+            if (metric.getMetricOrdinal() == metricOrdinal) {
+                return metric;
+            }
+        }
+        throw new IllegalArgumentException("Invalid metric stat: " + metricOrdinal);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/NumericDimension.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/NumericDimension.java
new file mode 100644
index 0000000000000..9c25ef5b25503
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/NumericDimension.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.mapper.CompositeDataCubeFieldType;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * Composite index numeric dimension class
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class NumericDimension implements Dimension {
+    public static final String NUMERIC = "numeric";
+    private final String field;
+
+    public NumericDimension(String field) {
+        this.field = field;
+    }
+
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(CompositeDataCubeFieldType.NAME, field);
+        builder.field(CompositeDataCubeFieldType.TYPE, NUMERIC);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        NumericDimension dimension = (NumericDimension) o;
+        return Objects.equals(field, dimension.getField());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(field);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/ReadDimension.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/ReadDimension.java
new file mode 100644
index 0000000000000..4264ec87d2c74
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/ReadDimension.java
@@ -0,0 +1,55 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube;
+
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.mapper.CompositeDataCubeFieldType;
+
+import java.io.IOException;
+import java.util.Objects;
+
+/**
+ * Represents a dimension for reconstructing StarTreeField from file formats during searches and merges.
+ *
+ * @opensearch.experimental
+ */
+public class ReadDimension implements Dimension {
+    public static final String READ = "read";
+    private final String field;
+
+    public ReadDimension(String field) {
+        this.field = field;
+    }
+
+    public String getField() {
+        return field;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(CompositeDataCubeFieldType.NAME, field);
+        builder.field(CompositeDataCubeFieldType.TYPE, READ);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ReadDimension dimension = (ReadDimension) o;
+        return Objects.equals(field, dimension.getField());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(field);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/package-info.java
new file mode 100644
index 0000000000000..320876ea937bf
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/package-info.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+/**
+ * Core classes for handling data cube indices such as star tree index.
+ */
+package org.opensearch.index.compositeindex.datacube;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeDocument.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeDocument.java
new file mode 100644
index 0000000000000..0ce2b3a5cdac5
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeDocument.java
@@ -0,0 +1,34 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.Arrays;
+
+/**
+ * Star tree document
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeDocument {
+    public final Long[] dimensions;
+    public final Object[] metrics;
+
+    public StarTreeDocument(Long[] dimensions, Object[] metrics) {
+        this.dimensions = dimensions;
+        this.metrics = metrics;
+    }
+
+    @Override
+    public String toString() {
+        return Arrays.toString(dimensions) + " | " + Arrays.toString(metrics);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeField.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeField.java
new file mode 100644
index 0000000000000..922ddcbea4fe2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeField.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Star tree field which contains dimensions, metrics and specs
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeField implements ToXContent {
+    private final String name;
+    private final List<Dimension> dimensionsOrder;
+    private final List<Metric> metrics;
+    private final StarTreeFieldConfiguration starTreeConfig;
+
+    public StarTreeField(String name, List<Dimension> dimensions, List<Metric> metrics, StarTreeFieldConfiguration starTreeConfig) {
+        this.name = name;
+        this.dimensionsOrder = dimensions;
+        this.metrics = metrics;
+        this.starTreeConfig = starTreeConfig;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<Dimension> getDimensionsOrder() {
+        return dimensionsOrder;
+    }
+
+    public List<Metric> getMetrics() {
+        return metrics;
+    }
+
+    public StarTreeFieldConfiguration getStarTreeConfig() {
+        return starTreeConfig;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field("name", name);
+        if (dimensionsOrder != null && !dimensionsOrder.isEmpty()) {
+            builder.startArray("ordered_dimensions");
+            for (Dimension dimension : dimensionsOrder) {
+                dimension.toXContent(builder, params);
+            }
+            builder.endArray();
+        }
+        if (metrics != null && !metrics.isEmpty()) {
+            builder.startArray("metrics");
+            for (Metric metric : metrics) {
+                metric.toXContent(builder, params);
+            }
+            builder.endArray();
+        }
+        starTreeConfig.toXContent(builder, params);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        StarTreeField that = (StarTreeField) o;
+        return Objects.equals(name, that.name)
+            && Objects.equals(dimensionsOrder, that.dimensionsOrder)
+            && Objects.equals(metrics, that.metrics)
+            && Objects.equals(starTreeConfig, that.starTreeConfig);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, dimensionsOrder, metrics, starTreeConfig);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeFieldConfiguration.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeFieldConfiguration.java
new file mode 100644
index 0000000000000..d732a8598d711
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeFieldConfiguration.java
@@ -0,0 +1,124 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Star tree index specific configuration
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeFieldConfiguration implements ToXContent {
+
+    private final AtomicInteger maxLeafDocs = new AtomicInteger();
+    private final Set<String> skipStarNodeCreationInDims;
+    private final StarTreeBuildMode buildMode;
+
+    public StarTreeFieldConfiguration(int maxLeafDocs, Set<String> skipStarNodeCreationInDims, StarTreeBuildMode buildMode) {
+        this.maxLeafDocs.set(maxLeafDocs);
+        this.skipStarNodeCreationInDims = skipStarNodeCreationInDims;
+        this.buildMode = buildMode;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        // build mode is internal and not part of user mappings config, hence not added as part of toXContent
+        builder.field("max_leaf_docs", maxLeafDocs.get());
+        builder.startArray("skip_star_node_creation_for_dimensions");
+        for (String dim : skipStarNodeCreationInDims) {
+            builder.value(dim);
+        }
+        builder.endArray();
+        return builder;
+    }
+
+    /**
+     * Star tree build mode using which sorting and aggregations are performed during index creation.
+     *
+     * @opensearch.experimental
+     */
+    @ExperimentalApi
+    public enum StarTreeBuildMode {
+        // TODO : remove onheap support unless this proves useful
+        ON_HEAP("onheap", (byte) 0),
+        OFF_HEAP("offheap", (byte) 1);
+
+        private final String typeName;
+        private final byte buildModeOrdinal;
+
+        StarTreeBuildMode(String typeName, byte buildModeOrdinal) {
+            this.typeName = typeName;
+            this.buildModeOrdinal = buildModeOrdinal;
+        }
+
+        public String getTypeName() {
+            return typeName;
+        }
+
+        public byte getBuildModeOrdinal() {
+            return buildModeOrdinal;
+        }
+
+        public static StarTreeBuildMode fromTypeName(String typeName) {
+            for (StarTreeBuildMode starTreeBuildMode : StarTreeBuildMode.values()) {
+                if (starTreeBuildMode.getTypeName().equalsIgnoreCase(typeName)) {
+                    return starTreeBuildMode;
+                }
+            }
+            throw new IllegalArgumentException(String.format(Locale.ROOT, "Invalid star tree build mode: [%s] ", typeName));
+        }
+
+        public static StarTreeBuildMode fromBuildModeOrdinal(byte buildModeOrdinal) {
+            for (StarTreeBuildMode starTreeBuildMode : StarTreeBuildMode.values()) {
+                if (starTreeBuildMode.getBuildModeOrdinal() == buildModeOrdinal) {
+                    return starTreeBuildMode;
+                }
+            }
+            throw new IllegalArgumentException(String.format(Locale.ROOT, "Invalid star tree build mode: [%s] ", buildModeOrdinal));
+        }
+
+    }
+
+    public int maxLeafDocs() {
+        return maxLeafDocs.get();
+    }
+
+    public StarTreeBuildMode getBuildMode() {
+        return buildMode;
+    }
+
+    public Set<String> getSkipStarNodeCreationInDims() {
+        return skipStarNodeCreationInDims;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        StarTreeFieldConfiguration that = (StarTreeFieldConfiguration) o;
+        return Objects.equals(maxLeafDocs.get(), that.maxLeafDocs.get())
+            && Objects.equals(skipStarNodeCreationInDims, that.skipStarNodeCreationInDims)
+            && buildMode == that.buildMode;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(maxLeafDocs.get(), skipStarNodeCreationInDims, buildMode);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeIndexSettings.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeIndexSettings.java
new file mode 100644
index 0000000000000..e665831b83d93
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeIndexSettings.java
@@ -0,0 +1,132 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree;
+
+import org.opensearch.common.Rounding;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * Index settings for star tree fields. The settings are final as right now
+ * there is no support for update of star tree mapping.
+ *
+ * @opensearch.experimental
+ */
+public class StarTreeIndexSettings {
+
+    public static int STAR_TREE_MAX_DIMENSIONS_DEFAULT = 10;
+    public static int STAR_TREE_MAX_BASE_METRICS_DEFAULT = 100;
+    /**
+     * This setting determines the max number of star tree fields that can be part of composite index mapping. For each
+     * star tree field, we will generate associated star tree index.
+     */
+    public static final Setting<Integer> STAR_TREE_MAX_FIELDS_SETTING = Setting.intSetting(
+        "index.composite_index.star_tree.max_fields",
+        1,
+        1,
+        1,
+        Setting.Property.IndexScope,
+        Setting.Property.Final
+    );
+
+    /**
+     * This setting determines the max number of dimensions that can be part of star tree index field. Number of
+     * dimensions and associated cardinality has direct effect of star tree index size and query performance.
+     */
+    public static final Setting<Integer> STAR_TREE_MAX_DIMENSIONS_SETTING = Setting.intSetting(
+        "index.composite_index.star_tree.field.max_dimensions",
+        STAR_TREE_MAX_DIMENSIONS_DEFAULT,
+        2,
+        10,
+        Setting.Property.IndexScope,
+        Setting.Property.Final
+    );
+
+    /**
+     * This setting determines the max number of dimensions that can be part of star tree index field. Number of
+     * dimensions and associated cardinality has direct effect of star tree index size and query performance.
+     */
+    public static final Setting<Integer> STAR_TREE_MAX_BASE_METRICS_SETTING = Setting.intSetting(
+        "index.composite_index.star_tree.field.max_base_metrics",
+        STAR_TREE_MAX_BASE_METRICS_DEFAULT,
+        4,
+        100,
+        Setting.Property.IndexScope,
+        Setting.Property.Final
+    );
+
+    /**
+     * This setting determines the max number of date intervals that can be part of star tree date field.
+     */
+    public static final Setting<Integer> STAR_TREE_MAX_DATE_INTERVALS_SETTING = Setting.intSetting(
+        "index.composite_index.star_tree.field.max_date_intervals",
+        3,
+        1,
+        3,
+        Setting.Property.IndexScope,
+        Setting.Property.Final
+    );
+
+    /**
+     * This setting configures the default "maxLeafDocs" setting of star tree. This affects both query performance and
+     * star tree index size. Lesser the leaves, better the query latency but higher storage size and vice versa
+     * <p>
+     * We can remove this later or change it to an enum based constant setting.
+     *
+     * @opensearch.experimental
+     */
+    public static final Setting<Integer> STAR_TREE_DEFAULT_MAX_LEAF_DOCS = Setting.intSetting(
+        "index.composite_index.star_tree.default.max_leaf_docs",
+        10000,
+        1,
+        Setting.Property.IndexScope,
+        Setting.Property.Final
+    );
+
+    /**
+     * Default intervals for date dimension as part of star tree fields
+     */
+    public static final Setting<List<Rounding.DateTimeUnit>> DEFAULT_DATE_INTERVALS = Setting.listSetting(
+        "index.composite_index.star_tree.field.default.date_intervals",
+        Arrays.asList(Rounding.DateTimeUnit.MINUTES_OF_HOUR.shortName(), Rounding.DateTimeUnit.HOUR_OF_DAY.shortName()),
+        StarTreeIndexSettings::getTimeUnit,
+        Setting.Property.IndexScope,
+        Setting.Property.Final
+    );
+
+    /**
+     * Default metrics for metrics as part of star tree fields
+     */
+    public static final Setting<List<String>> DEFAULT_METRICS_LIST = Setting.listSetting(
+        "index.composite_index.star_tree.field.default.metrics",
+        Arrays.asList(MetricStat.VALUE_COUNT.toString(), MetricStat.SUM.toString()),
+        Function.identity(),
+        Setting.Property.IndexScope,
+        Setting.Property.Final
+    );
+
+    public static Rounding.DateTimeUnit getTimeUnit(String expression) {
+        if (!DateHistogramAggregationBuilder.DATE_FIELD_UNITS.containsKey(expression)) {
+            throw new IllegalArgumentException("unknown calendar intervals specified in star tree index mapping");
+        }
+        return DateHistogramAggregationBuilder.DATE_FIELD_UNITS.get(expression);
+    }
+
+    public static final Setting<Boolean> IS_COMPOSITE_INDEX_SETTING = Setting.boolSetting(
+        "index.composite_index",
+        false,
+        Setting.Property.IndexScope,
+        Setting.Property.Final
+    );
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeValidator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeValidator.java
new file mode 100644
index 0000000000000..203bca3f1c292
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeValidator.java
@@ -0,0 +1,95 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+import org.opensearch.index.mapper.DocCountFieldMapper;
+import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.StarTreeMapper;
+
+import java.util.Locale;
+import java.util.Set;
+
+/**
+ * Validations for star tree fields as part of mappings
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeValidator {
+    public static void validate(MapperService mapperService, CompositeIndexSettings compositeIndexSettings, IndexSettings indexSettings) {
+        Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
+        if (compositeFieldTypes.size() > StarTreeIndexSettings.STAR_TREE_MAX_FIELDS_SETTING.get(indexSettings.getSettings())) {
+            throw new IllegalArgumentException(
+                String.format(
+                    Locale.ROOT,
+                    "Index cannot have more than [%s] star tree fields",
+                    StarTreeIndexSettings.STAR_TREE_MAX_FIELDS_SETTING.get(indexSettings.getSettings())
+                )
+            );
+        }
+        for (CompositeMappedFieldType compositeFieldType : compositeFieldTypes) {
+            if (!(compositeFieldType instanceof StarTreeMapper.StarTreeFieldType)) {
+                continue;
+            }
+            if (!compositeIndexSettings.isStarTreeIndexCreationEnabled()) {
+                throw new IllegalArgumentException(
+                    String.format(
+                        Locale.ROOT,
+                        "star tree index cannot be created, enable it using [%s] setting",
+                        CompositeIndexSettings.STAR_TREE_INDEX_ENABLED_SETTING.getKey()
+                    )
+                );
+            }
+            StarTreeMapper.StarTreeFieldType dataCubeFieldType = (StarTreeMapper.StarTreeFieldType) compositeFieldType;
+            for (Dimension dim : dataCubeFieldType.getDimensions()) {
+                MappedFieldType ft = mapperService.fieldType(dim.getField());
+                if (ft == null) {
+                    throw new IllegalArgumentException(
+                        String.format(Locale.ROOT, "unknown dimension field [%s] as part of star tree field", dim.getField())
+                    );
+                }
+                if (ft.isAggregatable() == false) {
+                    throw new IllegalArgumentException(
+                        String.format(
+                            Locale.ROOT,
+                            "Aggregations not supported for the dimension field [%s] with field type [%s] as part of star tree field",
+                            dim.getField(),
+                            ft.typeName()
+                        )
+                    );
+                }
+            }
+            for (Metric metric : dataCubeFieldType.getMetrics()) {
+                MappedFieldType ft = mapperService.fieldType(metric.getField());
+                if (ft == null) {
+                    throw new IllegalArgumentException(
+                        String.format(Locale.ROOT, "unknown metric field [%s] as part of star tree field", metric.getField())
+                    );
+                }
+                if (ft.isAggregatable() == false && ft instanceof DocCountFieldMapper.DocCountFieldType == false) {
+                    throw new IllegalArgumentException(
+                        String.format(
+                            Locale.ROOT,
+                            "Aggregations not supported for the metrics field [%s] with field type [%s] as part of star tree field",
+                            metric.getField(),
+                            ft.typeName()
+                        )
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregator.java
new file mode 100644
index 0000000000000..2bdbab1cd5b81
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregator.java
@@ -0,0 +1,70 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.NumberFieldMapper;
+
+/**
+ * Count value aggregator for star tree
+ *
+ * @opensearch.experimental
+ */
+public class CountValueAggregator implements ValueAggregator<Long> {
+
+    public static final long DEFAULT_INITIAL_VALUE = 1L;
+    private static final FieldValueConverter VALUE_AGGREGATOR_TYPE = NumberFieldMapper.NumberType.LONG;
+
+    public CountValueAggregator() {}
+
+    @Override
+    public FieldValueConverter getAggregatedValueType() {
+        return VALUE_AGGREGATOR_TYPE;
+    }
+
+    @Override
+    public Long getInitialAggregatedValueForSegmentDocValue(Long segmentDocValue) {
+
+        if (segmentDocValue == null) {
+            return getIdentityMetricValue();
+        }
+
+        return DEFAULT_INITIAL_VALUE;
+    }
+
+    @Override
+    public Long mergeAggregatedValueAndSegmentValue(Long value, Long segmentDocValue) {
+        assert value != null;
+        if (segmentDocValue != null) {
+            return value + 1;
+        }
+        return value;
+    }
+
+    @Override
+    public Long mergeAggregatedValues(Long value, Long aggregatedValue) {
+        if (value == null) {
+            value = getIdentityMetricValue();
+        }
+        if (aggregatedValue == null) {
+            aggregatedValue = getIdentityMetricValue();
+        }
+        return value + aggregatedValue;
+    }
+
+    @Override
+    public Long toAggregatedValueType(Long value) {
+        return value;
+    }
+
+    @Override
+    public Long getIdentityMetricValue() {
+        // in present aggregations, if the metric behind count is missing, we treat it as 0
+        return 0L;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/DocCountAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/DocCountAggregator.java
new file mode 100644
index 0000000000000..0f354aad063c2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/DocCountAggregator.java
@@ -0,0 +1,71 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.NumberFieldMapper;
+
+/**
+ * Aggregator to handle '_doc_count' field
+ *
+ * @opensearch.experimental
+ */
+public class DocCountAggregator implements ValueAggregator<Long> {
+
+    private static final FieldValueConverter VALUE_AGGREGATOR_TYPE = NumberFieldMapper.NumberType.LONG;
+
+    public DocCountAggregator() {}
+
+    @Override
+    public FieldValueConverter getAggregatedValueType() {
+        return VALUE_AGGREGATOR_TYPE;
+    }
+
+    /**
+     * If _doc_count field for a doc is missing, we increment the _doc_count by '1' for the associated doc
+     * otherwise take the actual value present in the field
+     */
+    @Override
+    public Long getInitialAggregatedValueForSegmentDocValue(Long segmentDocValue) {
+        if (segmentDocValue == null) {
+            return getIdentityMetricValue();
+        }
+        return segmentDocValue;
+    }
+
+    @Override
+    public Long mergeAggregatedValueAndSegmentValue(Long value, Long segmentDocValue) {
+        assert value != null;
+        return mergeAggregatedValues(value, segmentDocValue);
+    }
+
+    @Override
+    public Long mergeAggregatedValues(Long value, Long aggregatedValue) {
+        if (value == null) {
+            value = getIdentityMetricValue();
+        }
+        if (aggregatedValue == null) {
+            aggregatedValue = getIdentityMetricValue();
+        }
+        return value + aggregatedValue;
+    }
+
+    @Override
+    public Long toAggregatedValueType(Long rawValue) {
+        return rawValue;
+    }
+
+    /**
+     * If _doc_count field for a doc is missing, we increment the _doc_count by '1' for the associated doc
+     */
+    @Override
+    public Long getIdentityMetricValue() {
+        return 1L;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MaxValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MaxValueAggregator.java
new file mode 100644
index 0000000000000..34a3bdc32226d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MaxValueAggregator.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+
+/**
+ * Max value aggregator for star tree
+ *
+ * @opensearch.experimental
+ */
+class MaxValueAggregator extends StatelessDoubleValueAggregator {
+
+    public MaxValueAggregator(FieldValueConverter fieldValueConverter) {
+        super(fieldValueConverter, null);
+    }
+
+    @Override
+    protected Double performValueAggregation(Double aggregatedValue, Double segmentDocValue) {
+        return Math.max(aggregatedValue, segmentDocValue);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfo.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfo.java
new file mode 100644
index 0000000000000..487e714c9e44e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfo.java
@@ -0,0 +1,121 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.mapper.FieldValueConverter;
+
+import java.util.Comparator;
+import java.util.Objects;
+
+/**
+ * Builds aggregation function and doc values field pair to support various aggregations
+ *
+ * @opensearch.experimental
+ */
+public class MetricAggregatorInfo implements Comparable<MetricAggregatorInfo> {
+
+    public static final String DELIMITER = "_";
+    private final String metric;
+    private final String starFieldName;
+    private final MetricStat metricStat;
+    private final String field;
+    private final ValueAggregator valueAggregators;
+    private final FieldValueConverter fieldValueConverter;
+
+    /**
+     * Constructor for MetricAggregatorInfo
+     */
+    public MetricAggregatorInfo(MetricStat metricStat, String field, String starFieldName, FieldValueConverter fieldValueConverter) {
+        this.metricStat = metricStat;
+        this.fieldValueConverter = fieldValueConverter;
+        this.valueAggregators = ValueAggregatorFactory.getValueAggregator(metricStat, this.fieldValueConverter);
+        this.field = field;
+        this.starFieldName = starFieldName;
+        this.metric = toFieldName();
+    }
+
+    /**
+     * @return metric type
+     */
+    public MetricStat getMetricStat() {
+        return metricStat;
+    }
+
+    /**
+     * @return field Name
+     */
+    public String getField() {
+        return field;
+    }
+
+    /**
+     * @return the metric stat name
+     */
+    public String getMetric() {
+        return metric;
+    }
+
+    /**
+     * @return aggregator for the field value
+     */
+    public ValueAggregator getValueAggregators() {
+        return valueAggregators;
+    }
+
+    /**
+     * @return star tree aggregated value type
+     */
+    public FieldValueConverter getNumericFieldConverter() {
+        return fieldValueConverter;
+    }
+
+    /**
+     * @return field name with metric type and field
+     */
+    public String toFieldName() {
+        return toFieldName(starFieldName, field, metricStat.getTypeName());
+
+    }
+
+    /**
+     * @return field name with star-tree field name metric type and field
+     */
+    public static String toFieldName(String starFieldName, String field, String metricName) {
+        return starFieldName + DELIMITER + field + DELIMITER + metricName;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(toFieldName());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof MetricAggregatorInfo) {
+            MetricAggregatorInfo anotherPair = (MetricAggregatorInfo) obj;
+            return metricStat.equals(anotherPair.metricStat) && field.equals(anotherPair.field);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return toFieldName();
+    }
+
+    @Override
+    public int compareTo(MetricAggregatorInfo other) {
+        return Comparator.comparing((MetricAggregatorInfo o) -> o.field)
+            .thenComparing((MetricAggregatorInfo o) -> o.metricStat)
+            .compare(this, other);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MinValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MinValueAggregator.java
new file mode 100644
index 0000000000000..b085447be758e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MinValueAggregator.java
@@ -0,0 +1,27 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+
+/**
+ * Min value aggregator for star tree
+ *
+ * @opensearch.experimental
+ */
+class MinValueAggregator extends StatelessDoubleValueAggregator {
+
+    public MinValueAggregator(FieldValueConverter fieldValueConverter) {
+        super(fieldValueConverter, null);
+    }
+
+    @Override
+    protected Double performValueAggregation(Double aggregatedValue, Double segmentDocValue) {
+        return Math.min(aggregatedValue, segmentDocValue);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/StatelessDoubleValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/StatelessDoubleValueAggregator.java
new file mode 100644
index 0000000000000..d83a828fb0f9c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/StatelessDoubleValueAggregator.java
@@ -0,0 +1,82 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.NumberFieldMapper;
+
+/**
+ * This is an abstract class that defines the common methods for all double value aggregators
+ * It is stateless.
+ *
+ * @opensearch.experimental
+ */
+abstract class StatelessDoubleValueAggregator implements ValueAggregator<Double> {
+
+    protected final FieldValueConverter fieldValueConverter;
+    protected final Double identityValue;
+    private static final FieldValueConverter VALUE_AGGREGATOR_TYPE = NumberFieldMapper.NumberType.DOUBLE;
+
+    public StatelessDoubleValueAggregator(FieldValueConverter fieldValueConverter, Double identityValue) {
+        this.fieldValueConverter = fieldValueConverter;
+        this.identityValue = identityValue;
+    }
+
+    @Override
+    public FieldValueConverter getAggregatedValueType() {
+        return VALUE_AGGREGATOR_TYPE;
+    }
+
+    @Override
+    public Double getInitialAggregatedValueForSegmentDocValue(Long segmentDocValue) {
+        if (segmentDocValue == null) {
+            return getIdentityMetricValue();
+        }
+        return fieldValueConverter.toDoubleValue(segmentDocValue);
+    }
+
+    @Override
+    public Double mergeAggregatedValues(Double value, Double aggregatedValue) {
+        if (value == null && aggregatedValue != null) {
+            return aggregatedValue;
+        } else if (value != null && aggregatedValue == null) {
+            return value;
+        } else if (value == null) {
+            return getIdentityMetricValue();
+        }
+        return performValueAggregation(value, aggregatedValue);
+    }
+
+    @Override
+    public Double toAggregatedValueType(Long value) {
+        try {
+            if (value == null) {
+                return getIdentityMetricValue();
+            }
+            return VALUE_AGGREGATOR_TYPE.toDoubleValue(value);
+        } catch (Exception e) {
+            throw new IllegalStateException("Cannot convert " + value + " to sortable aggregation type", e);
+        }
+    }
+
+    @Override
+    public Double getIdentityMetricValue() {
+        // the identity value that we return should be inline with the existing aggregations
+        return identityValue;
+    }
+
+    /**
+     * Performs stateless aggregation on the value and the segmentDocValue based on the implementation
+     *
+     * @param aggregatedValue aggregated value for the segment so far
+     * @param segmentDocValue current segment doc value
+     * @return aggregated value
+     */
+    protected abstract Double performValueAggregation(Double aggregatedValue, Double segmentDocValue);
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregator.java
new file mode 100644
index 0000000000000..81eb3558915be
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregator.java
@@ -0,0 +1,107 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.search.aggregations.metrics.CompensatedSum;
+
+/**
+ * Sum value aggregator for star tree
+ *
+ * <p>This implementation follows the Kahan summation algorithm to improve the accuracy
+ * of the sum by tracking and compensating for the accumulated error in each iteration.
+ *
+ * @see <a href="http://en.wikipedia.org/wiki/Kahan_summation_algorithm">Kahan Summation Algorithm</a>
+ *
+ * @opensearch.experimental
+ */
+class SumValueAggregator implements ValueAggregator<Double> {
+
+    private final FieldValueConverter fieldValueConverter;
+    private static final FieldValueConverter VALUE_AGGREGATOR_TYPE = NumberFieldMapper.NumberType.DOUBLE;
+
+    private CompensatedSum kahanSummation = new CompensatedSum(0, 0);
+
+    public SumValueAggregator(FieldValueConverter fieldValueConverter) {
+        this.fieldValueConverter = fieldValueConverter;
+    }
+
+    @Override
+    public FieldValueConverter getAggregatedValueType() {
+        return VALUE_AGGREGATOR_TYPE;
+    }
+
+    @Override
+    public Double getInitialAggregatedValueForSegmentDocValue(Long segmentDocValue) {
+        kahanSummation.reset(0, 0);
+        // add takes care of the sum and compensation internally
+        if (segmentDocValue != null) {
+            kahanSummation.add(fieldValueConverter.toDoubleValue(segmentDocValue));
+        } else {
+            kahanSummation.add(getIdentityMetricValue());
+        }
+        return kahanSummation.value();
+    }
+
+    // we have overridden this method because the reset with sum and compensation helps us keep
+    // track of precision and avoids a potential loss in accuracy of sums.
+    @Override
+    public Double mergeAggregatedValueAndSegmentValue(Double value, Long segmentDocValue) {
+        assert value == null || kahanSummation.value() == value;
+        // add takes care of the sum and compensation internally
+        if (segmentDocValue != null) {
+            kahanSummation.add(fieldValueConverter.toDoubleValue(segmentDocValue));
+        } else {
+            kahanSummation.add(getIdentityMetricValue());
+        }
+        return kahanSummation.value();
+    }
+
+    @Override
+    public Double mergeAggregatedValues(Double value, Double aggregatedValue) {
+        assert aggregatedValue == null || kahanSummation.value() == aggregatedValue;
+        // add takes care of the sum and compensation internally
+        if (value != null) {
+            kahanSummation.add(value);
+        } else {
+            kahanSummation.add(getIdentityMetricValue());
+        }
+        return kahanSummation.value();
+    }
+
+    @Override
+    public Double getInitialAggregatedValue(Double value) {
+        kahanSummation.reset(0, 0);
+        // add takes care of the sum and compensation internally
+        if (value != null) {
+            kahanSummation.add(value);
+        } else {
+            kahanSummation.add(getIdentityMetricValue());
+        }
+        return kahanSummation.value();
+    }
+
+    @Override
+    public Double toAggregatedValueType(Long value) {
+        try {
+            if (value == null) {
+                return getIdentityMetricValue();
+            }
+            return VALUE_AGGREGATOR_TYPE.toDoubleValue(value);
+        } catch (Exception e) {
+            throw new IllegalStateException("Cannot convert " + value + " to sortable aggregation type", e);
+        }
+    }
+
+    @Override
+    public Double getIdentityMetricValue() {
+        // in present aggregations, if the metric behind sum is missing, we treat it as 0
+        return 0D;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregator.java
new file mode 100644
index 0000000000000..8eac45669c063
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregator.java
@@ -0,0 +1,61 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+
+/**
+ * A value aggregator that pre-aggregates on the input values for a specific type of aggregation.
+ *
+ * @opensearch.experimental
+ */
+public interface ValueAggregator<A> {
+
+    /**
+     * Returns the data type of the aggregated value.
+     */
+    FieldValueConverter getAggregatedValueType();
+
+    /**
+     * Returns the initial aggregated value.
+     */
+    A getInitialAggregatedValueForSegmentDocValue(Long segmentDocValue);
+
+    /**
+     * Applies a segment doc value to the current aggregated value.
+     */
+    default A mergeAggregatedValueAndSegmentValue(A value, Long segmentDocValue) {
+        A aggregatedValue = getInitialAggregatedValueForSegmentDocValue(segmentDocValue);
+        return mergeAggregatedValues(value, aggregatedValue);
+    }
+
+    /**
+     * Applies an aggregated value to the current aggregated value.
+     */
+    A mergeAggregatedValues(A value, A aggregatedValue);
+
+    /**
+     * Clones an aggregated value.
+     */
+    default A getInitialAggregatedValue(A value) {
+        if (value == null) {
+            return getIdentityMetricValue();
+        }
+        return value;
+    }
+
+    /**
+     * Converts a segment long value to an aggregated value.
+     */
+    A toAggregatedValueType(Long rawValue);
+
+    /**
+     * Fetches a value that does not alter the result of aggregations
+     */
+    A getIdentityMetricValue();
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactory.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactory.java
new file mode 100644
index 0000000000000..aac5d2b2855d3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactory.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.mapper.FieldValueConverter;
+
+/**
+ * Value aggregator factory for a given aggregation type
+ *
+ * @opensearch.experimental
+ */
+public class ValueAggregatorFactory {
+    private ValueAggregatorFactory() {}
+
+    /**
+     * Returns a new instance of value aggregator for the given aggregation type.
+     *
+     * @param aggregationType     Aggregation type
+     * @param fieldValueConverter Numeric type converter associated with star tree field ( as specified in index mapping )
+     * @return Value aggregator
+     */
+    public static ValueAggregator getValueAggregator(MetricStat aggregationType, FieldValueConverter fieldValueConverter) {
+        switch (aggregationType) {
+            // avg aggregator will be covered in the part of query (using count and sum)
+            case SUM:
+                return new SumValueAggregator(fieldValueConverter);
+            case VALUE_COUNT:
+                return new CountValueAggregator();
+            case MIN:
+                return new MinValueAggregator(fieldValueConverter);
+            case MAX:
+                return new MaxValueAggregator(fieldValueConverter);
+            case DOC_COUNT:
+                return new DocCountAggregator();
+            default:
+                throw new IllegalStateException("Unsupported aggregation type: " + aggregationType);
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/package-info.java
new file mode 100644
index 0000000000000..bddd6a46fbbe8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Aggregators for Composite Index Star Tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractDocumentsFileManager.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractDocumentsFileManager.java
new file mode 100644
index 0000000000000..327fd26c00608
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractDocumentsFileManager.java
@@ -0,0 +1,225 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.RandomAccessInput;
+import org.apache.lucene.store.TrackingDirectoryWrapper;
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+import org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeDocumentBitSetUtil;
+import org.opensearch.index.mapper.FieldValueConverter;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.List;
+
+import static org.opensearch.index.mapper.NumberFieldMapper.NumberType.DOUBLE;
+import static org.opensearch.index.mapper.NumberFieldMapper.NumberType.LONG;
+
+/**
+ * Abstract class for managing star tree file operations.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public abstract class AbstractDocumentsFileManager implements Closeable {
+    private static final Logger logger = LogManager.getLogger(AbstractDocumentsFileManager.class);
+    protected final StarTreeField starTreeField;
+    protected final List<MetricAggregatorInfo> metricAggregatorInfos;
+    protected final int numMetrics;
+    protected final TrackingDirectoryWrapper tmpDirectory;
+    protected final SegmentWriteState state;
+    protected int docSizeInBytes = -1;
+
+    public AbstractDocumentsFileManager(
+        SegmentWriteState state,
+        StarTreeField starTreeField,
+        List<MetricAggregatorInfo> metricAggregatorInfos
+    ) {
+        this.starTreeField = starTreeField;
+        this.tmpDirectory = new TrackingDirectoryWrapper(state.directory);
+        this.metricAggregatorInfos = metricAggregatorInfos;
+        this.state = state;
+        numMetrics = metricAggregatorInfos.size();
+    }
+
+    private void setDocSizeInBytes(int numBytes) {
+        if (docSizeInBytes == -1) {
+            docSizeInBytes = numBytes;
+        }
+        assert docSizeInBytes == numBytes;
+    }
+
+    /**
+     * Write the star tree document to file associated with dimensions and metrics
+     */
+    protected int writeStarTreeDocument(StarTreeDocument starTreeDocument, IndexOutput output, boolean isAggregatedDoc) throws IOException {
+        int numBytes = writeDimensions(starTreeDocument, output);
+        numBytes += writeMetrics(starTreeDocument, output, isAggregatedDoc);
+        setDocSizeInBytes(numBytes);
+        return numBytes;
+    }
+
+    /**
+     * Write dimensions to file
+     */
+    protected int writeDimensions(StarTreeDocument starTreeDocument, IndexOutput output) throws IOException {
+        int numBytes = 0;
+        for (int i = 0; i < starTreeDocument.dimensions.length; i++) {
+            output.writeLong(starTreeDocument.dimensions[i] == null ? 0L : starTreeDocument.dimensions[i]);
+            numBytes += Long.BYTES;
+        }
+        numBytes += StarTreeDocumentBitSetUtil.writeBitSet(starTreeDocument.dimensions, output);
+        return numBytes;
+    }
+
+    /**
+     * Write star tree document metrics to file
+     */
+    protected int writeMetrics(StarTreeDocument starTreeDocument, IndexOutput output, boolean isAggregatedDoc) throws IOException {
+        int numBytes = 0;
+        for (int i = 0; i < starTreeDocument.metrics.length; i++) {
+            FieldValueConverter aggregatedValueType = metricAggregatorInfos.get(i).getValueAggregators().getAggregatedValueType();
+            if (aggregatedValueType.equals(LONG)) {
+                output.writeLong(starTreeDocument.metrics[i] == null ? 0L : (Long) starTreeDocument.metrics[i]);
+                numBytes += Long.BYTES;
+            } else if (aggregatedValueType.equals(DOUBLE)) {
+                if (isAggregatedDoc) {
+                    long val = NumericUtils.doubleToSortableLong(
+                        starTreeDocument.metrics[i] == null ? 0.0 : (Double) starTreeDocument.metrics[i]
+                    );
+                    output.writeLong(val);
+                } else {
+                    output.writeLong(starTreeDocument.metrics[i] == null ? 0L : (Long) starTreeDocument.metrics[i]);
+                }
+                numBytes += Long.BYTES;
+            } else {
+                throw new IllegalStateException("Unsupported metric type");
+            }
+        }
+        numBytes += StarTreeDocumentBitSetUtil.writeBitSet(starTreeDocument.metrics, output);
+        return numBytes;
+    }
+
+    /**
+     * Reads the star tree document from file with given offset
+     *
+     * @param input   RandomAccessInput
+     * @param offset  Offset in the file
+     * @param isAggregatedDoc boolean to indicate if aggregated star tree docs should be read
+     * @return StarTreeDocument
+     * @throws IOException IOException in case of I/O errors
+     */
+    protected StarTreeDocument readStarTreeDocument(RandomAccessInput input, long offset, boolean isAggregatedDoc) throws IOException {
+        int dimSize = starTreeField.getDimensionsOrder().size();
+        Long[] dimensions = new Long[dimSize];
+        long initialOffset = offset;
+        offset = readDimensions(dimensions, input, offset);
+
+        Object[] metrics = new Object[numMetrics];
+        offset = readMetrics(input, offset, numMetrics, metrics, isAggregatedDoc);
+        assert (offset - initialOffset) == docSizeInBytes;
+        return new StarTreeDocument(dimensions, metrics);
+    }
+
+    /**
+     * Read dimensions from file
+     */
+    protected long readDimensions(Long[] dimensions, RandomAccessInput input, long offset) throws IOException {
+        for (int i = 0; i < dimensions.length; i++) {
+            try {
+                dimensions[i] = input.readLong(offset);
+            } catch (Exception e) {
+                logger.error("Error reading dimension value at offset {} for dimension {}", offset, i);
+                throw e;
+            }
+            offset += Long.BYTES;
+        }
+        offset += StarTreeDocumentBitSetUtil.readBitSet(input, offset, dimensions, index -> null);
+        return offset;
+    }
+
+    /**
+     * Read star tree metrics from file
+     */
+    protected long readMetrics(RandomAccessInput input, long offset, int numMetrics, Object[] metrics, boolean isAggregatedDoc)
+        throws IOException {
+        for (int i = 0; i < numMetrics; i++) {
+            FieldValueConverter aggregatedValueType = metricAggregatorInfos.get(i).getValueAggregators().getAggregatedValueType();
+            if (aggregatedValueType.equals(LONG)) {
+                metrics[i] = input.readLong(offset);
+                offset += Long.BYTES;
+            } else if (aggregatedValueType.equals(DOUBLE)) {
+                long val = input.readLong(offset);
+                if (isAggregatedDoc) {
+                    metrics[i] = DOUBLE.toDoubleValue(val);
+                } else {
+                    metrics[i] = val;
+                }
+                offset += Long.BYTES;
+            } else {
+                throw new IllegalStateException("Unsupported metric type");
+            }
+        }
+        offset += StarTreeDocumentBitSetUtil.readBitSet(input, offset, metrics, index -> null);
+        return offset;
+    }
+
+    /**
+     * Write star tree document to file
+     */
+    public abstract void writeStarTreeDocument(StarTreeDocument starTreeDocument, boolean isAggregatedDoc) throws IOException;
+
+    /**
+     * Read star tree document from file based on doc id
+     */
+    public abstract StarTreeDocument readStarTreeDocument(int docId, boolean isAggregatedDoc) throws IOException;
+
+    /**
+     * Read star document dimensions from file based on doc id
+     */
+    public abstract Long[] readDimensions(int docId) throws IOException;
+
+    /**
+     * Read dimension value for given doc id and dimension id
+     */
+    public abstract Long getDimensionValue(int docId, int dimensionId) throws IOException;
+
+    /**
+     * Delete the temporary files created
+     */
+    public void deleteFiles(boolean success) throws IOException {
+        if (success) {
+            for (String file : tmpDirectory.getCreatedFiles()) {
+                tmpDirectory.deleteFile(file);
+            }
+        } else {
+            deleteFilesIgnoringException();
+        }
+
+    }
+
+    /**
+     * Delete the temporary files created
+     */
+    private void deleteFilesIgnoringException() throws IOException {
+        for (String file : tmpDirectory.getCreatedFiles()) {
+            try {
+                tmpDirectory.deleteFile(file);
+            } catch (final IOException ignored) {} // similar to IOUtils.deleteFilesWhileIgnoringExceptions
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java
new file mode 100644
index 0000000000000..a1d638616f2aa
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilder.java
@@ -0,0 +1,897 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.EmptyDocValuesProducer;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.index.SortedNumericDocValuesWriterWrapper;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.util.Counter;
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.ValueAggregator;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.compositeindex.datacube.startree.node.InMemoryTreeNode;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNodeType;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.index.mapper.DocCountFieldMapper;
+import org.opensearch.index.mapper.FieldMapper;
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.Mapper;
+import org.opensearch.index.mapper.MapperService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.ALL;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeDimensionsDocValues;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.getFieldInfo;
+import static org.opensearch.index.mapper.NumberFieldMapper.NumberType.DOUBLE;
+import static org.opensearch.index.mapper.NumberFieldMapper.NumberType.LONG;
+
+/**
+ * Builder for star tree. Defines the algorithm to construct star-tree
+ * See {@link StarTreesBuilder} for information around the construction of star-trees based on star-tree fields
+ *
+ * @opensearch.experimental
+ */
+public abstract class BaseStarTreeBuilder implements StarTreeBuilder {
+
+    private static final Logger logger = LogManager.getLogger(BaseStarTreeBuilder.class);
+
+    /**
+     * Default value for star node
+     */
+    public static final Long STAR_IN_DOC_VALUES_INDEX = null;
+    protected final Set<Integer> skipStarNodeCreationForDimensions;
+
+    protected final List<MetricAggregatorInfo> metricAggregatorInfos;
+    protected final int numMetrics;
+    protected final int numDimensions;
+    protected int numStarTreeDocs;
+    protected int totalSegmentDocs;
+    protected int numStarTreeNodes;
+    protected final int maxLeafDocuments;
+
+    protected final InMemoryTreeNode rootNode = getNewNode();
+
+    protected final StarTreeField starTreeField;
+    private final SegmentWriteState writeState;
+
+    private final IndexOutput metaOut;
+    private final IndexOutput dataOut;
+
+    /**
+     * Reads all the configuration related to dimensions and metrics, builds a star-tree based on the different construction parameters.
+     *
+     * @param starTreeField holds the configuration for the star tree
+     * @param writeState    stores the segment write writeState
+     * @param mapperService helps to find the original type of the field
+     */
+    protected BaseStarTreeBuilder(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        StarTreeField starTreeField,
+        SegmentWriteState writeState,
+        MapperService mapperService
+    ) {
+        logger.debug("Building star tree : {}", starTreeField.getName());
+
+        this.metaOut = metaOut;
+        this.dataOut = dataOut;
+
+        this.starTreeField = starTreeField;
+        StarTreeFieldConfiguration starTreeFieldSpec = starTreeField.getStarTreeConfig();
+
+        List<Dimension> dimensionsSplitOrder = starTreeField.getDimensionsOrder();
+        this.numDimensions = dimensionsSplitOrder.size();
+
+        this.skipStarNodeCreationForDimensions = new HashSet<>();
+        this.totalSegmentDocs = writeState.segmentInfo.maxDoc();
+        this.writeState = writeState;
+
+        Set<String> skipStarNodeCreationForDimensions = starTreeFieldSpec.getSkipStarNodeCreationInDims();
+
+        for (int i = 0; i < numDimensions; i++) {
+            if (skipStarNodeCreationForDimensions.contains(dimensionsSplitOrder.get(i).getField())) {
+                this.skipStarNodeCreationForDimensions.add(i);
+            }
+        }
+
+        this.metricAggregatorInfos = generateMetricAggregatorInfos(mapperService);
+        this.numMetrics = metricAggregatorInfos.size();
+        this.maxLeafDocuments = starTreeFieldSpec.maxLeafDocs();
+    }
+
+    /**
+     * Generates the configuration required to perform aggregation for all the metrics on a field
+     *
+     * @return list of MetricAggregatorInfo
+     */
+    public List<MetricAggregatorInfo> generateMetricAggregatorInfos(MapperService mapperService) {
+        List<MetricAggregatorInfo> metricAggregatorInfos = new ArrayList<>();
+        for (Metric metric : this.starTreeField.getMetrics()) {
+            if (metric.getField().equals(DocCountFieldMapper.NAME)) {
+                MetricAggregatorInfo metricAggregatorInfo = new MetricAggregatorInfo(
+                    MetricStat.DOC_COUNT,
+                    metric.getField(),
+                    starTreeField.getName(),
+                    LONG
+                );
+                metricAggregatorInfos.add(metricAggregatorInfo);
+                continue;
+            }
+            for (MetricStat metricStat : metric.getBaseMetrics()) {
+                FieldValueConverter fieldValueConverter;
+                Mapper fieldMapper = mapperService.documentMapper().mappers().getMapper(metric.getField());
+                if (fieldMapper instanceof FieldMapper && ((FieldMapper) fieldMapper).fieldType() instanceof FieldValueConverter) {
+                    fieldValueConverter = (FieldValueConverter) ((FieldMapper) fieldMapper).fieldType();
+                } else {
+                    logger.error("unsupported mapper type");
+                    throw new IllegalStateException("unsupported mapper type");
+                }
+
+                MetricAggregatorInfo metricAggregatorInfo = new MetricAggregatorInfo(
+                    metricStat,
+                    metric.getField(),
+                    starTreeField.getName(),
+                    fieldValueConverter
+                );
+                metricAggregatorInfos.add(metricAggregatorInfo);
+            }
+        }
+        return metricAggregatorInfos;
+    }
+
+    /**
+     * Generates the configuration required to perform aggregation for all the metrics on a field
+     *
+     * @return list of MetricAggregatorInfo
+     */
+    public List<SequentialDocValuesIterator> getMetricReaders(SegmentWriteState state, Map<String, DocValuesProducer> fieldProducerMap)
+        throws IOException {
+
+        List<SequentialDocValuesIterator> metricReaders = new ArrayList<>();
+        for (Metric metric : this.starTreeField.getMetrics()) {
+            for (MetricStat metricStat : metric.getBaseMetrics()) {
+                SequentialDocValuesIterator metricReader;
+                FieldInfo metricFieldInfo = state.fieldInfos.fieldInfo(metric.getField());
+                if (metricStat.equals(MetricStat.DOC_COUNT)) {
+                    // _doc_count is numeric field , so we convert to sortedNumericDocValues and get iterator
+                    metricReader = getIteratorForNumericField(fieldProducerMap, metricFieldInfo, DocCountFieldMapper.NAME);
+                } else {
+                    if (metricFieldInfo == null) {
+                        metricFieldInfo = getFieldInfo(metric.getField(), DocValuesType.SORTED_NUMERIC);
+                    }
+                    metricReader = new SequentialDocValuesIterator(
+                        fieldProducerMap.get(metricFieldInfo.name).getSortedNumeric(metricFieldInfo)
+                    );
+                }
+                metricReaders.add(metricReader);
+            }
+        }
+        return metricReaders;
+    }
+
+    /**
+     * Builds the star tree from the original segment documents
+     *
+     * @param fieldProducerMap           contain s the docValues producer to get docValues associated with each field
+     * @param fieldNumberAcrossStarTrees maintains a counter for the number of star-tree fields
+     * @param starTreeDocValuesConsumer  consumes the generated star-tree docValues
+     * @throws IOException when we are unable to build star-tree
+     */
+    public void build(
+        Map<String, DocValuesProducer> fieldProducerMap,
+        AtomicInteger fieldNumberAcrossStarTrees,
+        DocValuesConsumer starTreeDocValuesConsumer
+    ) throws IOException {
+        long startTime = System.currentTimeMillis();
+        logger.debug("Star-tree build is a go with star tree field {}", starTreeField.getName());
+
+        List<SequentialDocValuesIterator> metricReaders = getMetricReaders(writeState, fieldProducerMap);
+        List<Dimension> dimensionsSplitOrder = starTreeField.getDimensionsOrder();
+        SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[dimensionsSplitOrder.size()];
+        for (int i = 0; i < numDimensions; i++) {
+            String dimension = dimensionsSplitOrder.get(i).getField();
+            FieldInfo dimensionFieldInfo = writeState.fieldInfos.fieldInfo(dimension);
+            if (dimensionFieldInfo == null) {
+                dimensionFieldInfo = getFieldInfo(dimension, DocValuesType.SORTED_NUMERIC);
+            }
+            dimensionReaders[i] = new SequentialDocValuesIterator(
+                fieldProducerMap.get(dimensionFieldInfo.name).getSortedNumeric(dimensionFieldInfo)
+            );
+        }
+        Iterator<StarTreeDocument> starTreeDocumentIterator = sortAndAggregateSegmentDocuments(dimensionReaders, metricReaders);
+        logger.debug("Sorting and aggregating star-tree in ms : {}", (System.currentTimeMillis() - startTime));
+        build(starTreeDocumentIterator, fieldNumberAcrossStarTrees, starTreeDocValuesConsumer);
+        logger.debug("Finished Building star-tree in ms : {}", (System.currentTimeMillis() - startTime));
+    }
+
+    /**
+     * Builds the star tree using sorted and aggregated star-tree Documents
+     *
+     * @param starTreeDocumentIterator   contains the sorted and aggregated documents
+     * @param fieldNumberAcrossStarTrees maintains a counter for the number of star-tree fields
+     * @param starTreeDocValuesConsumer  consumes the generated star-tree docValues
+     * @throws IOException when we are unable to build star-tree
+     */
+    public void build(
+        Iterator<StarTreeDocument> starTreeDocumentIterator,
+        AtomicInteger fieldNumberAcrossStarTrees,
+        DocValuesConsumer starTreeDocValuesConsumer
+    ) throws IOException {
+        int numSegmentStarTreeDocument = totalSegmentDocs;
+
+        appendDocumentsToStarTree(starTreeDocumentIterator);
+        int numStarTreeDocument = numStarTreeDocs;
+        logger.debug("Generated star tree docs : [{}] from segment docs : [{}]", numStarTreeDocument, numSegmentStarTreeDocument);
+
+        if (numStarTreeDocs == 0) {
+            // serialize the star tree data
+            serializeStarTree(numStarTreeDocument, numStarTreeDocs);
+            return;
+        }
+
+        constructStarTree(rootNode, 0, numStarTreeDocs);
+        int numStarTreeDocumentUnderStarNode = numStarTreeDocs - numStarTreeDocument;
+        logger.debug(
+            "Finished constructing star-tree, got [ {} ] tree nodes and [ {} ] starTreeDocument under star-node",
+            numStarTreeNodes,
+            numStarTreeDocumentUnderStarNode
+        );
+
+        createAggregatedDocs(rootNode);
+        int numAggregatedStarTreeDocument = numStarTreeDocs - numStarTreeDocument - numStarTreeDocumentUnderStarNode;
+        logger.debug("Finished creating aggregated documents : {}", numAggregatedStarTreeDocument);
+
+        // Create doc values indices in disk
+        createSortedDocValuesIndices(starTreeDocValuesConsumer, fieldNumberAcrossStarTrees);
+
+        // serialize star-tree
+        serializeStarTree(numStarTreeDocument, numStarTreeDocs);
+    }
+
+    void appendDocumentsToStarTree(Iterator<StarTreeDocument> starTreeDocumentIterator) throws IOException {
+        while (starTreeDocumentIterator.hasNext()) {
+            appendToStarTree(starTreeDocumentIterator.next());
+        }
+    }
+
+    private void serializeStarTree(int numSegmentStarTreeDocument, int numStarTreeDocs) throws IOException {
+        // serialize the star tree data
+        long dataFilePointer = dataOut.getFilePointer();
+        StarTreeWriter starTreeWriter = new StarTreeWriter();
+        long totalStarTreeDataLength = starTreeWriter.writeStarTree(dataOut, rootNode, numStarTreeNodes, starTreeField.getName());
+
+        // serialize the star tree meta
+        starTreeWriter.writeStarTreeMetadata(
+            metaOut,
+            starTreeField,
+            metricAggregatorInfos,
+            numStarTreeNodes,
+            numSegmentStarTreeDocument,
+            numStarTreeDocs,
+            dataFilePointer,
+            totalStarTreeDataLength
+        );
+    }
+
+    private void createSortedDocValuesIndices(DocValuesConsumer docValuesConsumer, AtomicInteger fieldNumberAcrossStarTrees)
+        throws IOException {
+        List<SortedNumericDocValuesWriterWrapper> dimensionWriters = new ArrayList<>();
+        List<SortedNumericDocValuesWriterWrapper> metricWriters = new ArrayList<>();
+        FieldInfo[] dimensionFieldInfoList = new FieldInfo[starTreeField.getDimensionsOrder().size()];
+        FieldInfo[] metricFieldInfoList = new FieldInfo[metricAggregatorInfos.size()];
+        for (int i = 0; i < dimensionFieldInfoList.length; i++) {
+            final FieldInfo fi = getFieldInfo(
+                fullyQualifiedFieldNameForStarTreeDimensionsDocValues(
+                    starTreeField.getName(),
+                    starTreeField.getDimensionsOrder().get(i).getField()
+                ),
+                DocValuesType.SORTED_NUMERIC,
+                fieldNumberAcrossStarTrees.getAndIncrement()
+            );
+            dimensionFieldInfoList[i] = fi;
+            dimensionWriters.add(new SortedNumericDocValuesWriterWrapper(fi, Counter.newCounter()));
+        }
+        for (int i = 0; i < metricAggregatorInfos.size(); i++) {
+
+            final FieldInfo fi = getFieldInfo(
+                fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                    starTreeField.getName(),
+                    metricAggregatorInfos.get(i).getField(),
+                    metricAggregatorInfos.get(i).getMetricStat().getTypeName()
+                ),
+                DocValuesType.SORTED_NUMERIC,
+                fieldNumberAcrossStarTrees.getAndIncrement()
+            );
+
+            metricFieldInfoList[i] = fi;
+            metricWriters.add(new SortedNumericDocValuesWriterWrapper(fi, Counter.newCounter()));
+        }
+
+        for (int docId = 0; docId < numStarTreeDocs; docId++) {
+            StarTreeDocument starTreeDocument = getStarTreeDocument(docId);
+            for (int i = 0; i < starTreeDocument.dimensions.length; i++) {
+                if (starTreeDocument.dimensions[i] != null) {
+                    dimensionWriters.get(i).addValue(docId, starTreeDocument.dimensions[i]);
+                }
+            }
+
+            for (int i = 0; i < starTreeDocument.metrics.length; i++) {
+                try {
+                    FieldValueConverter aggregatedValueType = metricAggregatorInfos.get(i).getValueAggregators().getAggregatedValueType();
+                    if (aggregatedValueType.equals(LONG)) {
+                        if (starTreeDocument.metrics[i] != null) {
+                            metricWriters.get(i).addValue(docId, (long) starTreeDocument.metrics[i]);
+                        }
+                    } else if (aggregatedValueType.equals(DOUBLE)) {
+                        if (starTreeDocument.metrics[i] != null) {
+                            metricWriters.get(i).addValue(docId, NumericUtils.doubleToSortableLong((Double) starTreeDocument.metrics[i]));
+                        }
+                    } else {
+                        throw new IllegalStateException("Unknown metric doc value type");
+                    }
+                } catch (IllegalArgumentException e) {
+                    logger.error("could not parse the value, exiting creation of star tree");
+                }
+            }
+        }
+
+        addStarTreeDocValueFields(docValuesConsumer, dimensionWriters, dimensionFieldInfoList, starTreeField.getDimensionsOrder().size());
+        addStarTreeDocValueFields(docValuesConsumer, metricWriters, metricFieldInfoList, metricAggregatorInfos.size());
+    }
+
+    private void addStarTreeDocValueFields(
+        DocValuesConsumer docValuesConsumer,
+        List<SortedNumericDocValuesWriterWrapper> docValuesWriters,
+        FieldInfo[] fieldInfoList,
+        int fieldCount
+    ) throws IOException {
+        for (int i = 0; i < fieldCount; i++) {
+            final int writerIndex = i;
+            DocValuesProducer docValuesProducer = new EmptyDocValuesProducer() {
+                @Override
+                public SortedNumericDocValues getSortedNumeric(FieldInfo field) {
+                    return docValuesWriters.get(writerIndex).getDocValues();
+                }
+            };
+            docValuesConsumer.addSortedNumericField(fieldInfoList[i], docValuesProducer);
+        }
+    }
+
+    /**
+     * Get star tree document from the segment for the current docId with the dimensionReaders and metricReaders
+     */
+    protected StarTreeDocument getStarTreeDocument(
+        int currentDocId,
+        SequentialDocValuesIterator[] dimensionReaders,
+        List<SequentialDocValuesIterator> metricReaders
+    ) throws IOException {
+        Long[] dims = new Long[numDimensions];
+        int i = 0;
+        for (SequentialDocValuesIterator dimensionDocValueIterator : dimensionReaders) {
+            dimensionDocValueIterator.nextDoc(currentDocId);
+            Long val = dimensionDocValueIterator.value(currentDocId);
+            dims[i] = val;
+            i++;
+        }
+        i = 0;
+        Object[] metrics = new Object[metricReaders.size()];
+        for (SequentialDocValuesIterator metricDocValuesIterator : metricReaders) {
+            metricDocValuesIterator.nextDoc(currentDocId);
+            // As part of merge, we traverse the star tree doc values
+            // The type of data stored in metric fields is different from the
+            // actual indexing field they're based on
+            metrics[i] = metricAggregatorInfos.get(i)
+                .getValueAggregators()
+                .toAggregatedValueType(metricDocValuesIterator.value(currentDocId));
+            i++;
+        }
+        return new StarTreeDocument(dims, metrics);
+    }
+
+    /**
+     * Adds a document to the star-tree.
+     *
+     * @param starTreeDocument star tree document to be added
+     * @throws IOException if an I/O error occurs while adding the document
+     */
+    public abstract void appendStarTreeDocument(StarTreeDocument starTreeDocument) throws IOException;
+
+    /**
+     * Returns the document of the given document id in the star-tree.
+     *
+     * @param docId document id
+     * @return star tree document
+     * @throws IOException if an I/O error occurs while fetching the star-tree document
+     */
+    public abstract StarTreeDocument getStarTreeDocument(int docId) throws IOException;
+
+    /**
+     * Retrieves the list of star-tree documents in the star-tree.
+     *
+     * @return Star tree documents
+     */
+    public abstract List<StarTreeDocument> getStarTreeDocuments() throws IOException;
+
+    /**
+     * Returns the value of the dimension for the given dimension id and document in the star-tree.
+     *
+     * @param docId       document id
+     * @param dimensionId dimension id
+     * @return dimension value
+     */
+    public abstract Long getDimensionValue(int docId, int dimensionId) throws IOException;
+
+    /**
+     * Sorts and aggregates all the documents in the segment as per the configuration, and returns a star-tree document iterator for all the
+     * aggregated star-tree documents.
+     *
+     * @param dimensionReaders List of docValues readers to read dimensions from the segment
+     * @param metricReaders    List of docValues readers to read metrics from the segment
+     * @return Iterator for the aggregated star-tree document
+     */
+    public abstract Iterator<StarTreeDocument> sortAndAggregateSegmentDocuments(
+        SequentialDocValuesIterator[] dimensionReaders,
+        List<SequentialDocValuesIterator> metricReaders
+    ) throws IOException;
+
+    /**
+     * Generates aggregated star-tree documents for star-node.
+     *
+     * @param startDocId  start document id (inclusive) in the star-tree
+     * @param endDocId    end document id (exclusive) in the star-tree
+     * @param dimensionId dimension id of the star-node
+     * @return Iterator for the aggregated star-tree documents
+     */
+    public abstract Iterator<StarTreeDocument> generateStarTreeDocumentsForStarNode(int startDocId, int endDocId, int dimensionId)
+        throws IOException;
+
+    /**
+     * Returns the star-tree document from the segment based on the current doc id
+     */
+    protected StarTreeDocument getSegmentStarTreeDocument(
+        int currentDocId,
+        SequentialDocValuesIterator[] dimensionReaders,
+        List<SequentialDocValuesIterator> metricReaders
+    ) throws IOException {
+        Long[] dimensions = getStarTreeDimensionsFromSegment(currentDocId, dimensionReaders);
+        Object[] metrics = getStarTreeMetricsFromSegment(currentDocId, metricReaders);
+        return new StarTreeDocument(dimensions, metrics);
+    }
+
+    /**
+     * Returns the dimension values for the next document from the segment
+     *
+     * @return dimension values for each of the star-tree dimension
+     * @throws IOException when we are unable to iterate to the next doc for the given dimension readers
+     */
+    Long[] getStarTreeDimensionsFromSegment(int currentDocId, SequentialDocValuesIterator[] dimensionReaders) throws IOException {
+        Long[] dimensions = new Long[numDimensions];
+        for (int i = 0; i < numDimensions; i++) {
+            if (dimensionReaders[i] != null) {
+                try {
+                    dimensionReaders[i].nextDoc(currentDocId);
+                } catch (IOException e) {
+                    logger.error("unable to iterate to next doc", e);
+                    throw new RuntimeException("unable to iterate to next doc", e);
+                } catch (Exception e) {
+                    logger.error("unable to read the dimension values from the segment", e);
+                    throw new IllegalStateException("unable to read the dimension values from the segment", e);
+                }
+                dimensions[i] = dimensionReaders[i].value(currentDocId);
+            } else {
+                throw new IllegalStateException("dimension readers are empty");
+            }
+        }
+        return dimensions;
+    }
+
+    /**
+     * Returns the metric values for the next document from the segment
+     *
+     * @return metric values for each of the star-tree metric
+     * @throws IOException when we are unable to iterate to the next doc for the given metric readers
+     */
+    private Object[] getStarTreeMetricsFromSegment(int currentDocId, List<SequentialDocValuesIterator> metricsReaders) throws IOException {
+        Object[] metrics = new Object[numMetrics];
+        for (int i = 0; i < numMetrics; i++) {
+            SequentialDocValuesIterator metricStatReader = metricsReaders.get(i);
+            if (metricStatReader != null) {
+                try {
+                    metricStatReader.nextDoc(currentDocId);
+                } catch (IOException e) {
+                    logger.error("unable to iterate to next doc", e);
+                    throw new RuntimeException("unable to iterate to next doc", e);
+                } catch (Exception e) {
+                    logger.error("unable to read the metric values from the segment", e);
+                    throw new IllegalStateException("unable to read the metric values from the segment", e);
+                }
+                metrics[i] = metricStatReader.value(currentDocId);
+            } else {
+                throw new IllegalStateException("metric readers are empty");
+            }
+        }
+        return metrics;
+    }
+
+    /**
+     * Merges a star-tree document from the segment into an aggregated star-tree document.
+     * A new aggregated star-tree document is created if the aggregated segment document is null.
+     *
+     * @param aggregatedSegmentDocument aggregated star-tree document
+     * @param segmentDocument           segment star-tree document
+     * @return merged star-tree document
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    protected StarTreeDocument reduceSegmentStarTreeDocuments(
+        StarTreeDocument aggregatedSegmentDocument,
+        StarTreeDocument segmentDocument,
+        boolean isMerge
+    ) {
+        if (aggregatedSegmentDocument == null) {
+            Long[] dimensions = Arrays.copyOf(segmentDocument.dimensions, numDimensions);
+            Object[] metrics = new Object[numMetrics];
+            for (int i = 0; i < numMetrics; i++) {
+                try {
+                    ValueAggregator metricValueAggregator = metricAggregatorInfos.get(i).getValueAggregators();
+                    if (isMerge) {
+                        metrics[i] = metricValueAggregator.getInitialAggregatedValue(segmentDocument.metrics[i]);
+                    } else {
+                        metrics[i] = metricValueAggregator.getInitialAggregatedValueForSegmentDocValue(getLong(segmentDocument.metrics[i]));
+                    }
+
+                } catch (Exception e) {
+                    logger.error("Cannot parse initial segment doc value", e);
+                    throw new IllegalStateException("Cannot parse initial segment doc value [" + segmentDocument.metrics[i] + "]");
+                }
+            }
+            return new StarTreeDocument(dimensions, metrics);
+        } else {
+            for (int i = 0; i < numMetrics; i++) {
+                try {
+                    ValueAggregator metricValueAggregator = metricAggregatorInfos.get(i).getValueAggregators();
+                    if (isMerge) {
+                        aggregatedSegmentDocument.metrics[i] = metricValueAggregator.mergeAggregatedValues(
+                            segmentDocument.metrics[i],
+                            aggregatedSegmentDocument.metrics[i]
+                        );
+                    } else {
+                        aggregatedSegmentDocument.metrics[i] = metricValueAggregator.mergeAggregatedValueAndSegmentValue(
+                            aggregatedSegmentDocument.metrics[i],
+                            getLong(segmentDocument.metrics[i])
+                        );
+                    }
+                } catch (Exception e) {
+                    logger.error("Cannot apply segment doc value for aggregation", e);
+                    throw new IllegalStateException("Cannot apply segment doc value for aggregation [" + segmentDocument.metrics[i] + "]");
+                }
+            }
+            return aggregatedSegmentDocument;
+        }
+    }
+
+    /**
+     * Safely converts the metric value of object type to long.
+     * Nulls are handled during aggregation
+     *
+     * @param metric value of the metric
+     * @return converted metric value to long
+     */
+    private static Long getLong(Object metric) {
+        Long metricValue = null;
+
+        if (metric instanceof Long) {
+            metricValue = (long) metric;
+        }
+        return metricValue;
+    }
+
+    /**
+     * Merges a star-tree document into an aggregated star-tree document.
+     * A new aggregated star-tree document is created if the aggregated document is null.
+     *
+     * @param aggregatedDocument aggregated star-tree document
+     * @param starTreeDocument   segment star-tree document
+     * @return merged star-tree document
+     */
+    @SuppressWarnings("unchecked")
+    public StarTreeDocument reduceStarTreeDocuments(StarTreeDocument aggregatedDocument, StarTreeDocument starTreeDocument) {
+        // aggregate the documents
+        if (aggregatedDocument == null) {
+            Long[] dimensions = Arrays.copyOf(starTreeDocument.dimensions, numDimensions);
+            Object[] metrics = new Object[numMetrics];
+            for (int i = 0; i < numMetrics; i++) {
+                try {
+                    metrics[i] = metricAggregatorInfos.get(i).getValueAggregators().getInitialAggregatedValue(starTreeDocument.metrics[i]);
+                } catch (Exception e) {
+                    logger.error("Cannot get value for aggregation", e);
+                    throw new IllegalStateException("Cannot get value for aggregation[" + starTreeDocument.metrics[i] + "]");
+                }
+            }
+            return new StarTreeDocument(dimensions, metrics);
+        } else {
+            for (int i = 0; i < numMetrics; i++) {
+                try {
+                    aggregatedDocument.metrics[i] = metricAggregatorInfos.get(i)
+                        .getValueAggregators()
+                        .mergeAggregatedValues(starTreeDocument.metrics[i], aggregatedDocument.metrics[i]);
+                } catch (Exception e) {
+                    logger.error("Cannot apply value to aggregated document for aggregation", e);
+                    throw new IllegalStateException(
+                        "Cannot apply value to aggregated document for aggregation [" + starTreeDocument.metrics[i] + "]"
+                    );
+                }
+            }
+            return aggregatedDocument;
+        }
+    }
+
+    /**
+     * Converts numericDocValues to sortedNumericDocValues and returns SequentialDocValuesIterator
+     */
+    private SequentialDocValuesIterator getIteratorForNumericField(
+        Map<String, DocValuesProducer> fieldProducerMap,
+        FieldInfo fieldInfo,
+        String name
+    ) throws IOException {
+        if (fieldInfo == null) {
+            fieldInfo = getFieldInfo(name, DocValuesType.NUMERIC);
+        }
+        SequentialDocValuesIterator sequentialDocValuesIterator;
+        assert fieldProducerMap.containsKey(fieldInfo.name);
+        sequentialDocValuesIterator = new SequentialDocValuesIterator(
+            DocValues.singleton(fieldProducerMap.get(fieldInfo.name).getNumeric(fieldInfo))
+        );
+        return sequentialDocValuesIterator;
+    }
+
+    /**
+     * Adds a document to star-tree
+     *
+     * @param starTreeDocument star-tree document
+     * @throws IOException throws an exception if we are unable to add the doc
+     */
+    private void appendToStarTree(StarTreeDocument starTreeDocument) throws IOException {
+        appendStarTreeDocument(starTreeDocument);
+        numStarTreeDocs++;
+    }
+
+    /**
+     * Returns a new star-tree node
+     *
+     * @return return new star-tree node
+     */
+    private InMemoryTreeNode getNewNode() {
+        numStarTreeNodes++;
+        return new InMemoryTreeNode();
+    }
+
+    /**
+     * Returns a new star-tree node
+     * @param dimensionId dimension id of the star-tree node
+     * @param startDocId start doc id of the star-tree node
+     * @param endDocId end doc id of the star-tree node
+     * @param nodeType node type of the star-tree node
+     * @param dimensionValue dimension value of the star-tree node
+     * @return
+     */
+    private InMemoryTreeNode getNewNode(int dimensionId, int startDocId, int endDocId, byte nodeType, long dimensionValue) {
+        numStarTreeNodes++;
+        return new InMemoryTreeNode(dimensionId, startDocId, endDocId, nodeType, dimensionValue);
+    }
+
+    /**
+     * Implements the algorithm to construct a star-tree
+     *
+     * @param node       star-tree node
+     * @param startDocId start document id
+     * @param endDocId   end document id
+     * @throws IOException throws an exception if we are unable to construct the tree
+     */
+    private void constructStarTree(InMemoryTreeNode node, int startDocId, int endDocId) throws IOException {
+
+        int childDimensionId = node.getDimensionId() + 1;
+        if (childDimensionId == numDimensions) {
+            return;
+        }
+
+        // Construct all non-star children nodes
+        node.setChildDimensionId(childDimensionId);
+        constructNonStarNodes(node, startDocId, endDocId, childDimensionId);
+
+        // Construct star-node if required
+        if (!skipStarNodeCreationForDimensions.contains(childDimensionId) && node.getChildren().size() > 1) {
+            node.addChildNode(constructStarNode(startDocId, endDocId, childDimensionId), (long) ALL);
+        }
+
+        // Further split star node if needed
+        if (node.getChildStarNode() != null
+            && (node.getChildStarNode().getEndDocId() - node.getChildStarNode().getStartDocId() > maxLeafDocuments)) {
+            constructStarTree(node.getChildStarNode(), node.getChildStarNode().getStartDocId(), node.getChildStarNode().getEndDocId());
+        }
+
+        // Further split on child nodes if required
+        for (InMemoryTreeNode child : node.getChildren().values()) {
+            if (child.getEndDocId() - child.getStartDocId() > maxLeafDocuments) {
+                constructStarTree(child, child.getStartDocId(), child.getEndDocId());
+            }
+        }
+
+    }
+
+    /**
+     * Constructs non star tree nodes
+     *
+     * @param node parent node
+     * @param startDocId  start document id (inclusive)
+     * @param endDocId    end document id (exclusive)
+     * @param dimensionId id of the dimension in the star tree
+     *
+     * @throws IOException throws an exception if we are unable to construct non-star nodes
+     */
+    private void constructNonStarNodes(InMemoryTreeNode node, int startDocId, int endDocId, int dimensionId) throws IOException {
+        int nodeStartDocId = startDocId;
+        Long nodeDimensionValue = getDimensionValue(startDocId, dimensionId);
+        for (int i = startDocId + 1; i < endDocId; i++) {
+            Long dimensionValue = getDimensionValue(i, dimensionId);
+            if (Objects.equals(dimensionValue, nodeDimensionValue) == false) {
+                addChildNode(node, i, dimensionId, nodeStartDocId, nodeDimensionValue);
+
+                nodeStartDocId = i;
+                nodeDimensionValue = dimensionValue;
+            }
+        }
+        addChildNode(node, endDocId, dimensionId, nodeStartDocId, nodeDimensionValue);
+    }
+
+    private void addChildNode(InMemoryTreeNode node, int endDocId, int dimensionId, int nodeStartDocId, Long nodeDimensionValue) {
+        long childNodeDimensionValue;
+        byte childNodeType;
+        if (nodeDimensionValue == null) {
+            childNodeDimensionValue = ALL;
+            childNodeType = StarTreeNodeType.NULL.getValue();
+        } else {
+            childNodeDimensionValue = nodeDimensionValue;
+            childNodeType = StarTreeNodeType.DEFAULT.getValue();
+        }
+
+        InMemoryTreeNode lastNode = getNewNode(dimensionId, nodeStartDocId, endDocId, childNodeType, childNodeDimensionValue);
+        node.addChildNode(lastNode, nodeDimensionValue);
+    }
+
+    /**
+     * Constructs star tree nodes
+     *
+     * @param startDocId  start document id (inclusive)
+     * @param endDocId    end document id (exclusive)
+     * @param dimensionId id of the dimension in the star tree
+     * @return root node with star nodes constructed
+     * @throws IOException throws an exception if we are unable to construct non-star nodes
+     */
+    private InMemoryTreeNode constructStarNode(int startDocId, int endDocId, int dimensionId) throws IOException {
+        int starNodeStartDocId = numStarTreeDocs;
+        Iterator<StarTreeDocument> starTreeDocumentIterator = generateStarTreeDocumentsForStarNode(startDocId, endDocId, dimensionId);
+        appendDocumentsToStarTree(starTreeDocumentIterator);
+        return getNewNode(dimensionId, starNodeStartDocId, numStarTreeDocs, StarTreeNodeType.STAR.getValue(), ALL);
+    }
+
+    /**
+     * Returns aggregated star-tree document
+     *
+     * @param node star-tree node
+     * @return aggregated star-tree documents
+     * @throws IOException throws an exception upon failing to create new aggregated docs based on star tree
+     */
+    private StarTreeDocument createAggregatedDocs(InMemoryTreeNode node) throws IOException {
+        StarTreeDocument aggregatedStarTreeDocument = null;
+
+        // For leaf node
+        if (!node.hasChild()) {
+
+            if (node.getStartDocId() == node.getEndDocId() - 1) {
+                // If it has only one document, use it as the aggregated document
+                aggregatedStarTreeDocument = getStarTreeDocument(node.getStartDocId());
+                node.setAggregatedDocId(node.getStartDocId());
+            } else {
+                // If it has multiple documents, aggregate all of them
+                for (int i = node.getStartDocId(); i < node.getEndDocId(); i++) {
+                    aggregatedStarTreeDocument = reduceStarTreeDocuments(aggregatedStarTreeDocument, getStarTreeDocument(i));
+                }
+                if (null == aggregatedStarTreeDocument) {
+                    throw new IllegalStateException("aggregated star-tree document is null after reducing the documents");
+                }
+                for (int i = node.getDimensionId() + 1; i < numDimensions; i++) {
+                    aggregatedStarTreeDocument.dimensions[i] = STAR_IN_DOC_VALUES_INDEX;
+                }
+                node.setAggregatedDocId(numStarTreeDocs);
+                appendToStarTree(aggregatedStarTreeDocument);
+            }
+        } else {
+            // For non-leaf node
+            if (node.getChildStarNode() != null) {
+                // If it has star child, use the star child aggregated document directly
+                aggregatedStarTreeDocument = createAggregatedDocs(node.getChildStarNode());
+                node.setAggregatedDocId(node.getChildStarNode().getAggregatedDocId());
+
+                for (InMemoryTreeNode child : node.getChildren().values()) {
+                    createAggregatedDocs(child);
+                }
+            } else {
+                // If no star child exists, aggregate all aggregated documents from non-star children
+                if (node.getChildren().values().size() == 1) {
+                    for (InMemoryTreeNode child : node.getChildren().values()) {
+                        aggregatedStarTreeDocument = reduceStarTreeDocuments(aggregatedStarTreeDocument, createAggregatedDocs(child));
+                        node.setAggregatedDocId(child.getAggregatedDocId());
+                    }
+                } else {
+                    for (InMemoryTreeNode child : node.getChildren().values()) {
+                        aggregatedStarTreeDocument = reduceStarTreeDocuments(aggregatedStarTreeDocument, createAggregatedDocs(child));
+                    }
+                    if (null == aggregatedStarTreeDocument) {
+                        throw new IllegalStateException("aggregated star-tree document is null after reducing the documents");
+                    }
+                    for (int i = node.getDimensionId() + 1; i < numDimensions; i++) {
+                        aggregatedStarTreeDocument.dimensions[i] = STAR_IN_DOC_VALUES_INDEX;
+                    }
+                    node.setAggregatedDocId(numStarTreeDocs);
+                    appendToStarTree(aggregatedStarTreeDocument);
+                }
+            }
+        }
+        return aggregatedStarTreeDocument;
+    }
+
+    /**
+     * Handles the dimension of date time field type
+     *
+     * @param fieldName name of the field
+     * @param val       value of the field
+     * @return returns the converted dimension of the field to a particular granularity
+     */
+    private long handleDateDimension(final String fieldName, final long val) {
+        // TODO: handle timestamp granularity
+        return val;
+    }
+
+    public void close() throws IOException {
+
+    }
+
+    abstract Iterator<StarTreeDocument> mergeStarTrees(List<StarTreeValues> starTreeValues) throws IOException;
+
+    public InMemoryTreeNode getRootNode() {
+        return rootNode;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilder.java
new file mode 100644
index 0000000000000..1613b7c5a3ac0
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilder.java
@@ -0,0 +1,362 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeDocumentsSorter;
+import org.opensearch.index.mapper.MapperService;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.SEGMENT_DOCS_COUNT;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
+
+/**
+ * Off-heap implementation of the star tree builder.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class OffHeapStarTreeBuilder extends BaseStarTreeBuilder {
+    private static final Logger logger = LogManager.getLogger(OffHeapStarTreeBuilder.class);
+    private final StarTreeDocsFileManager starTreeDocumentFileManager;
+    private final SegmentDocsFileManager segmentDocumentFileManager;
+
+    /**
+     * Builds star tree based on star tree field configuration consisting of dimensions, metrics and star tree index
+     * specific configuration.
+     *
+     * @param metaOut       an index output to write star-tree metadata
+     * @param dataOut       an index output to write star-tree data
+     * @param starTreeField holds the configuration for the star tree
+     * @param state         stores the segment write state
+     * @param mapperService helps to find the original type of the field
+     */
+    protected OffHeapStarTreeBuilder(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        StarTreeField starTreeField,
+        SegmentWriteState state,
+        MapperService mapperService
+    ) throws IOException {
+        super(metaOut, dataOut, starTreeField, state, mapperService);
+        segmentDocumentFileManager = new SegmentDocsFileManager(state, starTreeField, metricAggregatorInfos);
+        try {
+            starTreeDocumentFileManager = new StarTreeDocsFileManager(state, starTreeField, metricAggregatorInfos);
+        } catch (IOException e) {
+            IOUtils.closeWhileHandlingException(segmentDocumentFileManager);
+            throw e;
+        }
+
+    }
+
+    @Override
+    public void appendStarTreeDocument(StarTreeDocument starTreeDocument) throws IOException {
+        starTreeDocumentFileManager.writeStarTreeDocument(starTreeDocument, true);
+    }
+
+    /**
+     * Builds star tree based on the star tree values from multiple segments
+     *
+     * @param starTreeValuesSubs contains the star tree values from multiple segments
+     */
+    @Override
+    public void build(
+        List<StarTreeValues> starTreeValuesSubs,
+        AtomicInteger fieldNumberAcrossStarTrees,
+        DocValuesConsumer starTreeDocValuesConsumer
+    ) throws IOException {
+        boolean success = false;
+        try {
+            build(mergeStarTrees(starTreeValuesSubs), fieldNumberAcrossStarTrees, starTreeDocValuesConsumer);
+            success = true;
+        } finally {
+            starTreeDocumentFileManager.deleteFiles(success);
+            segmentDocumentFileManager.deleteFiles(success);
+        }
+    }
+
+    /**
+     * Sorts and aggregates all the documents of the segment based on dimension and metrics configuration
+     *
+     * @param dimensionReaders List of docValues readers to read dimensions from the segment
+     * @param metricReaders    List of docValues readers to read metrics from the segment
+     * @return Iterator of star-tree documents
+     */
+    @Override
+    public Iterator<StarTreeDocument> sortAndAggregateSegmentDocuments(
+        SequentialDocValuesIterator[] dimensionReaders,
+        List<SequentialDocValuesIterator> metricReaders
+    ) throws IOException {
+        // Write all dimensions for segment documents into the buffer,
+        // and sort all documents using an int array
+        int[] sortedDocIds = new int[totalSegmentDocs];
+        for (int i = 0; i < totalSegmentDocs; i++) {
+            sortedDocIds[i] = i;
+        }
+        try {
+            for (int i = 0; i < totalSegmentDocs; i++) {
+                StarTreeDocument document = getSegmentStarTreeDocument(i, dimensionReaders, metricReaders);
+                segmentDocumentFileManager.writeStarTreeDocument(document, false);
+            }
+        } catch (IOException ex) {
+            segmentDocumentFileManager.close();
+            throw ex;
+        }
+        // Create an iterator for aggregated documents
+        return sortAndReduceDocuments(sortedDocIds, totalSegmentDocs, false);
+    }
+
+    /**
+     * Sorts and aggregates the star-tree documents from multiple segments and builds star tree based on the newly
+     * aggregated star-tree documents
+     *
+     * @param starTreeValuesSubs StarTreeValues from multiple segments
+     * @return iterator of star tree documents
+     */
+    Iterator<StarTreeDocument> mergeStarTrees(List<StarTreeValues> starTreeValuesSubs) throws IOException {
+        int numDocs = 0;
+        int[] docIds;
+        try {
+            for (StarTreeValues starTreeValues : starTreeValuesSubs) {
+                List<Dimension> dimensionsSplitOrder = starTreeValues.getStarTreeField().getDimensionsOrder();
+                SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[starTreeValues.getStarTreeField()
+                    .getDimensionsOrder()
+                    .size()];
+                for (int i = 0; i < dimensionsSplitOrder.size(); i++) {
+                    String dimension = dimensionsSplitOrder.get(i).getField();
+                    dimensionReaders[i] = new SequentialDocValuesIterator(starTreeValues.getDimensionDocIdSetIterator(dimension));
+                }
+                List<SequentialDocValuesIterator> metricReaders = new ArrayList<>();
+                // get doc id set iterators for metrics
+                for (Metric metric : starTreeValues.getStarTreeField().getMetrics()) {
+                    for (MetricStat metricStat : metric.getBaseMetrics()) {
+                        String metricFullName = fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                            starTreeValues.getStarTreeField().getName(),
+                            metric.getField(),
+                            metricStat.getTypeName()
+                        );
+                        metricReaders.add(new SequentialDocValuesIterator(starTreeValues.getMetricDocIdSetIterator(metricFullName)));
+                    }
+                }
+                int currentDocId = 0;
+                int numSegmentDocs = Integer.parseInt(
+                    starTreeValues.getAttributes().getOrDefault(SEGMENT_DOCS_COUNT, String.valueOf(DocIdSetIterator.NO_MORE_DOCS))
+                );
+                while (currentDocId < numSegmentDocs) {
+                    StarTreeDocument starTreeDocument = getStarTreeDocument(currentDocId, dimensionReaders, metricReaders);
+                    segmentDocumentFileManager.writeStarTreeDocument(starTreeDocument, true);
+                    numDocs++;
+                    currentDocId++;
+                }
+            }
+            docIds = new int[numDocs];
+            for (int i = 0; i < numDocs; i++) {
+                docIds[i] = i;
+            }
+        } catch (IOException ex) {
+            segmentDocumentFileManager.close();
+            throw ex;
+        }
+
+        if (numDocs == 0) {
+            return Collections.emptyIterator();
+        }
+
+        return sortAndReduceDocuments(docIds, numDocs, true);
+    }
+
+    /**
+     * Sorts and reduces the star tree documents based on the dimensions
+     */
+    private Iterator<StarTreeDocument> sortAndReduceDocuments(int[] sortedDocIds, int numDocs, boolean isMerge) throws IOException {
+        try {
+            if (sortedDocIds == null || sortedDocIds.length == 0) {
+                logger.debug("Sorted doc ids array is null");
+                return Collections.emptyIterator();
+            }
+            try {
+                StarTreeDocumentsSorter.sort(sortedDocIds, -1, numDocs, index -> {
+                    try {
+                        return segmentDocumentFileManager.readDimensions(sortedDocIds[index]);
+                    } catch (IOException e) {
+                        throw new UncheckedIOException(e);
+                    }
+                });
+            } catch (UncheckedIOException ex) {
+                // Unwrap UncheckedIOException and throw as IOException
+                if (ex.getCause() != null) {
+                    throw ex.getCause();
+                }
+                throw ex;
+            }
+            final StarTreeDocument currentDocument = segmentDocumentFileManager.readStarTreeDocument(sortedDocIds[0], isMerge);
+            // Create an iterator for aggregated documents
+            return new Iterator<StarTreeDocument>() {
+                StarTreeDocument tempCurrentDocument = currentDocument;
+                boolean hasNext = true;
+                int docId = 1;
+
+                @Override
+                public boolean hasNext() {
+                    return hasNext;
+                }
+
+                @Override
+                public StarTreeDocument next() {
+                    StarTreeDocument next = reduceSegmentStarTreeDocuments(null, tempCurrentDocument, isMerge);
+                    while (docId < numDocs) {
+                        StarTreeDocument doc;
+                        try {
+                            doc = segmentDocumentFileManager.readStarTreeDocument(sortedDocIds[docId++], isMerge);
+                        } catch (IOException e) {
+                            throw new RuntimeException("Reducing documents failed ", e);
+                        }
+                        if (!Arrays.equals(doc.dimensions, next.dimensions)) {
+                            tempCurrentDocument = doc;
+                            return next;
+                        } else {
+                            next = reduceSegmentStarTreeDocuments(next, doc, isMerge);
+                        }
+                    }
+                    hasNext = false;
+                    try {
+                        segmentDocumentFileManager.close();
+                    } catch (IOException ex) {
+                        logger.error("Closing segment documents file failed", ex);
+                    }
+                    return next;
+                }
+            };
+        } catch (IOException ex) {
+            IOUtils.closeWhileHandlingException(segmentDocumentFileManager);
+            throw ex;
+        }
+    }
+
+    /**
+     * Get star tree document for the given docId from the star-tree.documents file
+     */
+    @Override
+    public StarTreeDocument getStarTreeDocument(int docId) throws IOException {
+        return starTreeDocumentFileManager.readStarTreeDocument(docId, true);
+    }
+
+    // This should be only used for testing
+    @Override
+    public List<StarTreeDocument> getStarTreeDocuments() throws IOException {
+        List<StarTreeDocument> starTreeDocuments = new ArrayList<>();
+        for (int i = 0; i < numStarTreeDocs; i++) {
+            starTreeDocuments.add(getStarTreeDocument(i));
+        }
+        return starTreeDocuments;
+    }
+
+    @Override
+    public Long getDimensionValue(int docId, int dimensionId) throws IOException {
+        return starTreeDocumentFileManager.getDimensionValue(docId, dimensionId);
+    }
+
+    /**
+     * Generates a star-tree for a given star-node
+     *
+     * @param startDocId  Start document id in the star-tree
+     * @param endDocId    End document id (exclusive) in the star-tree
+     * @param dimensionId Dimension id of the star-node
+     * @return iterator for star-tree documents of star-node
+     * @throws IOException throws when unable to generate star-tree for star-node
+     */
+    @Override
+    public Iterator<StarTreeDocument> generateStarTreeDocumentsForStarNode(int startDocId, int endDocId, int dimensionId)
+        throws IOException {
+        // Sort all documents using an int array
+        int numDocs = endDocId - startDocId;
+        int[] sortedDocIds = new int[numDocs];
+        for (int i = 0; i < numDocs; i++) {
+            sortedDocIds[i] = startDocId + i;
+        }
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, index -> {
+            try {
+                return starTreeDocumentFileManager.readDimensions(sortedDocIds[index]);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+        // Create an iterator for aggregated documents
+        return new Iterator<StarTreeDocument>() {
+            boolean hasNext = true;
+            StarTreeDocument currentDocument = getStarTreeDocument(sortedDocIds[0]);
+            int docId = 1;
+
+            private boolean hasSameDimensions(StarTreeDocument document1, StarTreeDocument document2) {
+                for (int i = dimensionId + 1; i < starTreeField.getDimensionsOrder().size(); i++) {
+                    if (!Objects.equals(document1.dimensions[i], document2.dimensions[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            @Override
+            public boolean hasNext() {
+                return hasNext;
+            }
+
+            @Override
+            public StarTreeDocument next() {
+                StarTreeDocument next = reduceStarTreeDocuments(null, currentDocument);
+                next.dimensions[dimensionId] = STAR_IN_DOC_VALUES_INDEX;
+                while (docId < numDocs) {
+                    StarTreeDocument document;
+                    try {
+                        document = getStarTreeDocument(sortedDocIds[docId++]);
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                    if (!hasSameDimensions(document, currentDocument)) {
+                        currentDocument = document;
+                        return next;
+                    } else {
+                        next = reduceStarTreeDocuments(next, document);
+                    }
+                }
+                hasNext = false;
+                return next;
+            }
+        };
+    }
+
+    @Override
+    public void close() throws IOException {
+        IOUtils.closeWhileHandlingException(starTreeDocumentFileManager, segmentDocumentFileManager);
+        super.close();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java
new file mode 100644
index 0000000000000..1a5c906ad413b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilder.java
@@ -0,0 +1,307 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.index.mapper.MapperService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.SEGMENT_DOCS_COUNT;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
+
+/**
+ * On heap single tree builder
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class OnHeapStarTreeBuilder extends BaseStarTreeBuilder {
+
+    private final List<StarTreeDocument> starTreeDocuments = new ArrayList<>();
+
+    /**
+     * Constructor for OnHeapStarTreeBuilder
+     *
+     * @param metaOut an index output to write star-tree metadata
+     * @param dataOut an index output to write star-tree data
+     * @param starTreeField     star-tree field
+     * @param segmentWriteState segment write state
+     * @param mapperService     helps with the numeric type of field
+     */
+    public OnHeapStarTreeBuilder(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        StarTreeField starTreeField,
+        SegmentWriteState segmentWriteState,
+        MapperService mapperService
+    ) throws IOException {
+        super(metaOut, dataOut, starTreeField, segmentWriteState, mapperService);
+    }
+
+    @Override
+    public void appendStarTreeDocument(StarTreeDocument starTreeDocument) {
+        starTreeDocuments.add(starTreeDocument);
+    }
+
+    @Override
+    public StarTreeDocument getStarTreeDocument(int docId) {
+        return starTreeDocuments.get(docId);
+    }
+
+    @Override
+    public List<StarTreeDocument> getStarTreeDocuments() {
+        return starTreeDocuments;
+    }
+
+    @Override
+    public Long getDimensionValue(int docId, int dimensionId) {
+        return starTreeDocuments.get(docId).dimensions[dimensionId];
+    }
+
+    /**
+     * Sorts and aggregates all the documents of the segment based on dimension and metrics configuration
+     *
+     * @param dimensionReaders List of docValues readers to read dimensions from the segment
+     * @param metricReaders List of docValues readers to read metrics from the segment
+     * @return Iterator of star-tree documents
+     *
+     */
+    @Override
+    public Iterator<StarTreeDocument> sortAndAggregateSegmentDocuments(
+        SequentialDocValuesIterator[] dimensionReaders,
+        List<SequentialDocValuesIterator> metricReaders
+    ) throws IOException {
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[totalSegmentDocs];
+        for (int currentDocId = 0; currentDocId < totalSegmentDocs; currentDocId++) {
+            // TODO : we can save empty iterator for dimensions which are not part of segment
+            starTreeDocuments[currentDocId] = getSegmentStarTreeDocument(currentDocId, dimensionReaders, metricReaders);
+        }
+        return sortAndAggregateStarTreeDocuments(starTreeDocuments, false);
+    }
+
+    @Override
+    public void build(
+        List<StarTreeValues> starTreeValuesSubs,
+        AtomicInteger fieldNumberAcrossStarTrees,
+        DocValuesConsumer starTreeDocValuesConsumer
+    ) throws IOException {
+        build(mergeStarTrees(starTreeValuesSubs), fieldNumberAcrossStarTrees, starTreeDocValuesConsumer);
+    }
+
+    /**
+     * Sorts and aggregates the star-tree documents from multiple segments and builds star tree based on the newly
+     * aggregated star-tree documents
+     *
+     * @param starTreeValuesSubs StarTreeValues from multiple segments
+     * @return iterator of star tree documents
+     */
+    @Override
+    Iterator<StarTreeDocument> mergeStarTrees(List<StarTreeValues> starTreeValuesSubs) throws IOException {
+        return sortAndAggregateStarTreeDocuments(getSegmentsStarTreeDocuments(starTreeValuesSubs), true);
+    }
+
+    /**
+     * Returns an array of all the starTreeDocuments from all the segments
+     * We only take the non-star documents from all the segments.
+     *
+     * @param starTreeValuesSubs StarTreeValues from multiple segments
+     * @return array of star tree documents
+     */
+    StarTreeDocument[] getSegmentsStarTreeDocuments(List<StarTreeValues> starTreeValuesSubs) throws IOException {
+        List<StarTreeDocument> starTreeDocuments = new ArrayList<>();
+        for (StarTreeValues starTreeValues : starTreeValuesSubs) {
+            List<Dimension> dimensionsSplitOrder = starTreeValues.getStarTreeField().getDimensionsOrder();
+            SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[dimensionsSplitOrder.size()];
+
+            for (int i = 0; i < dimensionsSplitOrder.size(); i++) {
+                String dimension = dimensionsSplitOrder.get(i).getField();
+                dimensionReaders[i] = new SequentialDocValuesIterator(starTreeValues.getDimensionDocIdSetIterator(dimension));
+            }
+
+            List<SequentialDocValuesIterator> metricReaders = new ArrayList<>();
+            // get doc id set iterators for metrics
+            for (Metric metric : starTreeValues.getStarTreeField().getMetrics()) {
+                for (MetricStat metricStat : metric.getBaseMetrics()) {
+                    String metricFullName = fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                        starTreeValues.getStarTreeField().getName(),
+                        metric.getField(),
+                        metricStat.getTypeName()
+                    );
+                    metricReaders.add(new SequentialDocValuesIterator(starTreeValues.getMetricDocIdSetIterator(metricFullName)));
+
+                }
+            }
+
+            int currentDocId = 0;
+            int numSegmentDocs = Integer.parseInt(
+                starTreeValues.getAttributes().getOrDefault(SEGMENT_DOCS_COUNT, String.valueOf(DocIdSetIterator.NO_MORE_DOCS))
+            );
+            while (currentDocId < numSegmentDocs) {
+                starTreeDocuments.add(getStarTreeDocument(currentDocId, dimensionReaders, metricReaders));
+                currentDocId++;
+            }
+        }
+        StarTreeDocument[] starTreeDocumentsArr = new StarTreeDocument[starTreeDocuments.size()];
+        return starTreeDocuments.toArray(starTreeDocumentsArr);
+    }
+
+    /**
+     * Sort, aggregates and merges the star-tree documents
+     *
+     * @param starTreeDocuments star-tree documents
+     * @return iterator for star-tree documents
+     */
+    Iterator<StarTreeDocument> sortAndAggregateStarTreeDocuments(StarTreeDocument[] starTreeDocuments, boolean isMerge) {
+
+        // sort all the documents
+        sortStarTreeDocumentsFromDimensionId(starTreeDocuments, 0);
+
+        // merge the documents
+        return mergeStarTreeDocuments(starTreeDocuments, isMerge);
+    }
+
+    /**
+     * Merges the star-tree documents
+     *
+     * @param starTreeDocuments star-tree documents
+     * @return iterator to aggregate star-tree documents
+     */
+    private Iterator<StarTreeDocument> mergeStarTreeDocuments(StarTreeDocument[] starTreeDocuments, boolean isMerge) {
+        return new Iterator<>() {
+            boolean hasNext = true;
+            StarTreeDocument currentStarTreeDocument = starTreeDocuments[0];
+            // starting from 1 since we have already fetched the 0th document
+            int docId = 1;
+
+            @Override
+            public boolean hasNext() {
+                return hasNext;
+            }
+
+            @Override
+            public StarTreeDocument next() {
+                // aggregate as we move on to the next doc
+                StarTreeDocument next = reduceSegmentStarTreeDocuments(null, currentStarTreeDocument, isMerge);
+                while (docId < starTreeDocuments.length) {
+                    StarTreeDocument starTreeDocument = starTreeDocuments[docId];
+                    docId++;
+                    if (Arrays.equals(starTreeDocument.dimensions, next.dimensions) == false) {
+                        currentStarTreeDocument = starTreeDocument;
+                        return next;
+                    } else {
+                        next = reduceSegmentStarTreeDocuments(next, starTreeDocument, isMerge);
+                    }
+                }
+                hasNext = false;
+                return next;
+            }
+        };
+    }
+
+    /**
+     * Generates a star-tree for a given star-node
+     *
+     * @param startDocId  Start document id in the star-tree
+     * @param endDocId    End document id (exclusive) in the star-tree
+     * @param dimensionId Dimension id of the star-node
+     * @return iterator for star-tree documents of star-node
+     */
+    @Override
+    public Iterator<StarTreeDocument> generateStarTreeDocumentsForStarNode(int startDocId, int endDocId, int dimensionId) {
+        int numDocs = endDocId - startDocId;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[numDocs];
+        for (int i = 0; i < numDocs; i++) {
+            starTreeDocuments[i] = getStarTreeDocument(startDocId + i);
+        }
+
+        // sort star tree documents from given dimension id (as previous dimension ids have already been processed)
+        sortStarTreeDocumentsFromDimensionId(starTreeDocuments, dimensionId + 1);
+
+        return new Iterator<StarTreeDocument>() {
+            boolean hasNext = true;
+            StarTreeDocument currentStarTreeDocument = starTreeDocuments[0];
+            int docId = 1;
+
+            private boolean hasSameDimensions(StarTreeDocument starTreeDocument1, StarTreeDocument starTreeDocument2) {
+                for (int i = dimensionId + 1; i < numDimensions; i++) {
+                    if (!Objects.equals(starTreeDocument1.dimensions[i], starTreeDocument2.dimensions[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            @Override
+            public boolean hasNext() {
+                return hasNext;
+            }
+
+            @Override
+            public StarTreeDocument next() {
+                StarTreeDocument next = reduceStarTreeDocuments(null, currentStarTreeDocument);
+                next.dimensions[dimensionId] = STAR_IN_DOC_VALUES_INDEX;
+                while (docId < numDocs) {
+                    StarTreeDocument starTreeDocument = starTreeDocuments[docId];
+                    docId++;
+                    if (!hasSameDimensions(starTreeDocument, currentStarTreeDocument)) {
+                        currentStarTreeDocument = starTreeDocument;
+                        return next;
+                    } else {
+                        next = reduceStarTreeDocuments(next, starTreeDocument);
+                    }
+                }
+                hasNext = false;
+                return next;
+            }
+        };
+    }
+
+    /**
+     * Sorts the star-tree documents from the given dimension id
+     *
+     * @param starTreeDocuments star-tree documents
+     * @param dimensionId id of the dimension
+     */
+    private void sortStarTreeDocumentsFromDimensionId(StarTreeDocument[] starTreeDocuments, int dimensionId) {
+        Arrays.sort(starTreeDocuments, (o1, o2) -> {
+            for (int i = dimensionId; i < numDimensions; i++) {
+                if (!Objects.equals(o1.dimensions[i], o2.dimensions[i])) {
+                    if (o1.dimensions[i] == null && o2.dimensions[i] == null) {
+                        return 0;
+                    }
+                    if (o1.dimensions[i] == null) {
+                        return 1;
+                    }
+                    if (o2.dimensions[i] == null) {
+                        return -1;
+                    }
+                    return Long.compare(o1.dimensions[i], o2.dimensions[i]);
+                }
+            }
+            return 0;
+        });
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/SegmentDocsFileManager.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/SegmentDocsFileManager.java
new file mode 100644
index 0000000000000..fe94df57d9535
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/SegmentDocsFileManager.java
@@ -0,0 +1,103 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.RandomAccessInput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Class for managing segment documents file.
+ * Segment documents are stored in a single file named 'segment.documents' for sorting and aggregation. A document ID array is created,
+ * and the document IDs in the array are swapped during sorting based on the actual segment document values in the file.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class SegmentDocsFileManager extends AbstractDocumentsFileManager implements Closeable {
+
+    private static final Logger logger = LogManager.getLogger(SegmentDocsFileManager.class);
+    private static final String SEGMENT_DOC_FILE_NAME = "segment.documents";
+    private IndexInput segmentDocsFileInput;
+    private RandomAccessInput segmentRandomInput;
+    final IndexOutput segmentDocsFileOutput;
+
+    public SegmentDocsFileManager(SegmentWriteState state, StarTreeField starTreeField, List<MetricAggregatorInfo> metricAggregatorInfos)
+        throws IOException {
+        super(state, starTreeField, metricAggregatorInfos);
+        try {
+            segmentDocsFileOutput = tmpDirectory.createTempOutput(SEGMENT_DOC_FILE_NAME, state.segmentSuffix, state.context);
+        } catch (IOException e) {
+            IOUtils.closeWhileHandlingException(this);
+            throw e;
+        }
+    }
+
+    @Override
+    public void writeStarTreeDocument(StarTreeDocument starTreeDocument, boolean isAggregatedDoc) throws IOException {
+        writeStarTreeDocument(starTreeDocument, segmentDocsFileOutput, isAggregatedDoc);
+    }
+
+    private void maybeInitializeSegmentInput() throws IOException {
+        try {
+            if (segmentDocsFileInput == null) {
+                IOUtils.closeWhileHandlingException(segmentDocsFileOutput);
+                segmentDocsFileInput = tmpDirectory.openInput(segmentDocsFileOutput.getName(), state.context);
+                segmentRandomInput = segmentDocsFileInput.randomAccessSlice(0, segmentDocsFileInput.length());
+            }
+        } catch (IOException e) {
+            IOUtils.closeWhileHandlingException(this);
+            throw e;
+        }
+    }
+
+    @Override
+    public StarTreeDocument readStarTreeDocument(int docId, boolean isAggregatedDoc) throws IOException {
+        maybeInitializeSegmentInput();
+        return readStarTreeDocument(segmentRandomInput, (long) docId * docSizeInBytes, isAggregatedDoc);
+    }
+
+    @Override
+    public Long[] readDimensions(int docId) throws IOException {
+        maybeInitializeSegmentInput();
+        Long[] dims = new Long[starTreeField.getDimensionsOrder().size()];
+        readDimensions(dims, segmentRandomInput, (long) docId * docSizeInBytes);
+        return dims;
+    }
+
+    @Override
+    public Long getDimensionValue(int docId, int dimensionId) throws IOException {
+        Long[] dims = readDimensions(docId);
+        return dims[dimensionId];
+    }
+
+    @Override
+    public void close() throws IOException {
+        try {
+            if (this.segmentDocsFileOutput != null) {
+                IOUtils.closeWhileHandlingException(segmentDocsFileOutput);
+                tmpDirectory.deleteFile(segmentDocsFileOutput.getName());
+            }
+        } finally {
+            IOUtils.closeWhileHandlingException(segmentDocsFileInput, segmentDocsFileOutput);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeBuilder.java
new file mode 100644
index 0000000000000..23415ddf29132
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeBuilder.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * A star-tree builder that builds a single star-tree.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface StarTreeBuilder extends Closeable {
+    /**
+     * Builds the star tree from the original segment documents
+     *
+     * @param fieldProducerMap           contains the docValues producer to get docValues associated with each field
+     * @param fieldNumberAcrossStarTrees maintains the unique field number across the fields in the star tree
+     * @param starTreeDocValuesConsumer  consumer of star-tree doc values
+     * @throws IOException when we are unable to build star-tree
+     */
+
+    void build(
+        Map<String, DocValuesProducer> fieldProducerMap,
+        AtomicInteger fieldNumberAcrossStarTrees,
+        DocValuesConsumer starTreeDocValuesConsumer
+    ) throws IOException;
+
+    /**
+     * Builds the star tree using Star Tree values from multiple segments
+     *
+     * @param starTreeValuesSubs           contains the star tree values from multiple segments
+     * @param fieldNumberAcrossStarTrees   maintains the unique field number across the fields in the star tree
+     * @param starTreeDocValuesConsumer    consumer of star-tree doc values
+     * @throws IOException when we are unable to build star-tree
+     */
+    void build(
+        List<StarTreeValues> starTreeValuesSubs,
+        AtomicInteger fieldNumberAcrossStarTrees,
+        DocValuesConsumer starTreeDocValuesConsumer
+    ) throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocsFileManager.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocsFileManager.java
new file mode 100644
index 0000000000000..779ed77b0540a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreeDocsFileManager.java
@@ -0,0 +1,294 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.RandomAccessInput;
+import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Star tree document file manager.
+ * This class manages all the temporary files associated with off heap star tree builder.
+ * <p>
+ * Star tree documents are stored in multiple 'star-tree.documents' files. The algorithm works as follows:
+ * <ol>
+ * <li> Initially, aggregated documents are created based on the segment documents.</li>
+ * <li> Further, star tree documents are generated (e.g., in the {@code generateStarTreeDocumentsForStarNode} method) by reading the current
+ * aggregated documents and creating new aggregated star tree documents, which are appended to the 'star-tree.documents' files. </li>
+ * <li> This process is repeated until all combinations of star tree documents are generated. </li>
+ * </ol>
+ * <p>In cases where previously written star tree documents need to be read from the 'star-tree.documents' files, the current
+ * 'star-tree.documents' file is closed, and the values are read. Then, the derived values gets appended to a new 'star-tree.documents' file.
+ * This is necessary because Lucene maintains immutability of data, and an {@code IndexOutput} cannot be kept open while creating an
+ * {@code IndexInput} on the same file, as all file contents may not be visible in the reader. Therefore, the {@code IndexOutput} must be
+ * closed to ensure all data can be read before creating an {@code IndexInput}. Additionally, an {@code IndexOutput} cannot be reopened,
+ * so a new file is created for the new star tree documents.
+ * <p>The set of 'star-tree.documents' files is maintained, and a tracker array is used to keep track of the start document ID for each file.
+ * Once the number of files reaches a set threshold, the files are merged.
+ *
+ */
+public class StarTreeDocsFileManager extends AbstractDocumentsFileManager implements Closeable {
+    private static final Logger logger = LogManager.getLogger(StarTreeDocsFileManager.class);
+    private static final String STAR_TREE_DOC_FILE_NAME = "star-tree.documents";
+    public static final int DEFAULT_FILE_COUNT_MERGE_THRESHOLD = 5;
+    private IndexInput starTreeDocsFileInput;
+    private RandomAccessInput starTreeDocsFileRandomInput;
+    private IndexOutput starTreeDocsFileOutput;
+    private final Map<String, Integer> fileToEndDocIdMap;
+    private final List<Integer> starTreeDocumentOffsets = new ArrayList<>();
+    private int currentFileStartDocId;
+    private int numReadableStarTreeDocuments;
+    private int starTreeFileCount = -1;
+    private int currBytes = 0;
+    private final int fileCountMergeThreshold;
+    private int numStarTreeDocs = 0;
+
+    public StarTreeDocsFileManager(SegmentWriteState state, StarTreeField starTreeField, List<MetricAggregatorInfo> metricAggregatorInfos)
+        throws IOException {
+        this(state, starTreeField, metricAggregatorInfos, DEFAULT_FILE_COUNT_MERGE_THRESHOLD);
+    }
+
+    public StarTreeDocsFileManager(
+        SegmentWriteState state,
+        StarTreeField starTreeField,
+        List<MetricAggregatorInfo> metricAggregatorInfos,
+        int fileCountThreshold
+    ) throws IOException {
+        super(state, starTreeField, metricAggregatorInfos);
+        fileToEndDocIdMap = new LinkedHashMap<>();
+        try {
+            starTreeDocsFileOutput = createStarTreeDocumentsFileOutput();
+        } catch (IOException e) {
+            IOUtils.closeWhileHandlingException(starTreeDocsFileOutput);
+            IOUtils.closeWhileHandlingException(this);
+            throw e;
+        }
+        fileCountMergeThreshold = fileCountThreshold;
+    }
+
+    /**
+     * Creates a new star tree document temporary file to store star tree documents.
+     */
+    IndexOutput createStarTreeDocumentsFileOutput() throws IOException {
+        starTreeFileCount++;
+        return tmpDirectory.createTempOutput(STAR_TREE_DOC_FILE_NAME + starTreeFileCount, state.segmentSuffix, state.context);
+    }
+
+    @Override
+    public void writeStarTreeDocument(StarTreeDocument starTreeDocument, boolean isAggregatedDoc) throws IOException {
+        assert isAggregatedDoc == true;
+        int numBytes = writeStarTreeDocument(starTreeDocument, starTreeDocsFileOutput, true);
+        addStarTreeDocumentOffset(numBytes);
+        numStarTreeDocs++;
+    }
+
+    @Override
+    public StarTreeDocument readStarTreeDocument(int docId, boolean isAggregatedDoc) throws IOException {
+        assert isAggregatedDoc == true;
+        ensureDocumentReadable(docId);
+        return readStarTreeDocument(starTreeDocsFileRandomInput, starTreeDocumentOffsets.get(docId), true);
+    }
+
+    @Override
+    public Long getDimensionValue(int docId, int dimensionId) throws IOException {
+        Long[] dims = readDimensions(docId);
+        return dims[dimensionId];
+    }
+
+    @Override
+    public Long[] readDimensions(int docId) throws IOException {
+        ensureDocumentReadable(docId);
+        Long[] dims = new Long[starTreeField.getDimensionsOrder().size()];
+        readDimensions(dims, starTreeDocsFileRandomInput, starTreeDocumentOffsets.get(docId));
+        return dims;
+    }
+
+    private void addStarTreeDocumentOffset(int bytes) {
+        starTreeDocumentOffsets.add(currBytes);
+        currBytes += bytes;
+        if (docSizeInBytes == -1) {
+            docSizeInBytes = bytes;
+        }
+        assert docSizeInBytes == bytes;
+    }
+
+    /**
+     * Load the correct StarTreeDocuments file based on the docId
+     */
+    private void ensureDocumentReadable(int docId) throws IOException {
+        ensureDocumentReadable(docId, true);
+    }
+
+    /**
+     * Load the correct StarTreeDocuments file based on the docId
+     * "currentFileStartDocId" and "numReadableStarTreeDocuments" tracks the "start doc id" and "end doc id + 1"
+     * of the range in the current open 'star-tree.documents' file
+     */
+    private void ensureDocumentReadable(int docId, boolean shouldCreateFileOutput) throws IOException {
+        try {
+            if (docId >= currentFileStartDocId && docId < numReadableStarTreeDocuments) {
+                return;
+            }
+            IOUtils.closeWhileHandlingException(starTreeDocsFileInput);
+            starTreeDocsFileInput = null;
+            if (docId < numStarTreeDocs) {
+                loadStarTreeDocumentFile(docId);
+            }
+            if (starTreeDocsFileInput != null) {
+                return;
+            }
+            closeAndMaybeCreateNewFile(shouldCreateFileOutput, numStarTreeDocs);
+            loadStarTreeDocumentFile(docId);
+        } catch (IOException ex) {
+            IOUtils.closeWhileHandlingException(this);
+            throw ex;
+        }
+    }
+
+    /**
+     * The fileToByteSizeMap is in the following format
+     * file1 == 521 [ contains docs from 0 to 520 ]
+     * file2 == 780 [ contains docs from 521 to 779 ]
+     * <p>
+     * This method loads the correct 'star-tree.documents' file based on the docId
+     * and updates the "currentFileStartDocId" and "numReadableStarTreeDocuments"
+     */
+    private void loadStarTreeDocumentFile(int docId) throws IOException {
+        int currentFileStartDocId = 0;
+        for (Map.Entry<String, Integer> entry : fileToEndDocIdMap.entrySet()) {
+            if (docId < entry.getValue()) {
+                starTreeDocsFileInput = tmpDirectory.openInput(entry.getKey(), state.context);
+                starTreeDocsFileRandomInput = starTreeDocsFileInput.randomAccessSlice(
+                    starTreeDocsFileInput.getFilePointer(),
+                    starTreeDocsFileInput.length() - starTreeDocsFileInput.getFilePointer()
+                );
+                numReadableStarTreeDocuments = entry.getValue();
+                break;
+            }
+            currentFileStartDocId = entry.getValue();
+        }
+        this.currentFileStartDocId = currentFileStartDocId;
+    }
+
+    /**
+     * This case handles when the requested document ID is beyond the range of the currently open 'star-tree.documents' file.
+     * In this scenario, the following steps are taken:
+     * <p>
+     * 1. Close the current 'star-tree.documents' file.
+     * 2. Create a new 'star-tree.documents' file if the operation involves appending new documents.
+     *    If the operation is only for reading existing documents, a new file is not created.
+     */
+    private void closeAndMaybeCreateNewFile(boolean shouldCreateFileForAppend, int numStarTreeDocs) throws IOException {
+        currBytes = 0;
+        if (starTreeDocsFileOutput != null) {
+            fileToEndDocIdMap.put(starTreeDocsFileOutput.getName(), numStarTreeDocs);
+            IOUtils.close(starTreeDocsFileOutput);
+        }
+        if (shouldCreateFileForAppend) {
+            starTreeDocsFileOutput = createStarTreeDocumentsFileOutput();
+            if (fileToEndDocIdMap.size() >= fileCountMergeThreshold) {
+                mergeFiles(numStarTreeDocs);
+            }
+        }
+        if (starTreeDocsFileRandomInput != null) {
+            starTreeDocsFileRandomInput = null;
+        }
+    }
+
+    /**
+     * Merge temporary star tree files once the number of files reach threshold
+     */
+    private void mergeFiles(int numStarTreeDocs) throws IOException {
+        long st = System.currentTimeMillis();
+        try (IndexOutput mergedOutput = createStarTreeDocumentsFileOutput()) {
+            long mergeBytes = mergeFilesToOutput(mergedOutput);
+            logger.debug(
+                "Created merge file : {} in : {} ms with size of : {} KB",
+                starTreeDocsFileOutput.getName(),
+                System.currentTimeMillis() - st,
+                mergeBytes / 1024
+            );
+
+            deleteOldFiles();
+            fileToEndDocIdMap.clear();
+            fileToEndDocIdMap.put(mergedOutput.getName(), numStarTreeDocs);
+            resetStarTreeDocumentOffsets();
+        }
+    }
+
+    /**
+     * Merge all files to single IndexOutput
+     */
+    private long mergeFilesToOutput(IndexOutput mergedOutput) throws IOException {
+        long mergeBytes = 0L;
+        for (Map.Entry<String, Integer> entry : fileToEndDocIdMap.entrySet()) {
+            IndexInput input = tmpDirectory.openInput(entry.getKey(), state.context);
+            mergedOutput.copyBytes(input, input.length());
+            mergeBytes += input.length();
+            input.close();
+        }
+        return mergeBytes;
+    }
+
+    /**
+     * Delete the old star-tree.documents files
+     */
+    private void deleteOldFiles() throws IOException {
+        for (String fileName : fileToEndDocIdMap.keySet()) {
+            tmpDirectory.deleteFile(fileName);
+        }
+    }
+
+    /**
+     * Reset the star tree document offsets based on the merged file
+     */
+    private void resetStarTreeDocumentOffsets() {
+        int curr = 0;
+        for (int i = 0; i < starTreeDocumentOffsets.size(); i++) {
+            starTreeDocumentOffsets.set(i, curr);
+            curr += docSizeInBytes;
+        }
+    }
+
+    @Override
+    public void close() {
+        try {
+            if (starTreeDocsFileOutput != null) {
+                IOUtils.closeWhileHandlingException(starTreeDocsFileOutput);
+                try {
+                    tmpDirectory.deleteFile(starTreeDocsFileOutput.getName());
+                } catch (IOException ignored) {} // similar to IOUtils.deleteFilesIgnoringExceptions
+            }
+        } finally {
+            IOUtils.closeWhileHandlingException(starTreeDocsFileInput, starTreeDocsFileOutput);
+        }
+        // Delete all temporary star tree document files
+        for (String file : fileToEndDocIdMap.keySet()) {
+            try {
+                tmpDirectory.deleteFile(file);
+            } catch (IOException ignored) {} // similar to IOUtils.deleteFilesIgnoringExceptions
+        }
+        starTreeDocumentOffsets.clear();
+        fileToEndDocIdMap.clear();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilder.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilder.java
new file mode 100644
index 0000000000000..bc598c9aeab7c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilder.java
@@ -0,0 +1,165 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.StarTreeMapper;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Builder to construct star-trees based on multiple star-tree fields.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreesBuilder implements Closeable {
+
+    private static final Logger logger = LogManager.getLogger(StarTreesBuilder.class);
+
+    private final List<StarTreeField> starTreeFields;
+    private final SegmentWriteState state;
+    private final MapperService mapperService;
+    private AtomicInteger fieldNumberAcrossStarTrees;
+
+    public StarTreesBuilder(SegmentWriteState segmentWriteState, MapperService mapperService, AtomicInteger fieldNumberAcrossStarTrees) {
+        List<StarTreeField> starTreeFields = new ArrayList<>();
+        for (CompositeMappedFieldType compositeMappedFieldType : mapperService.getCompositeFieldTypes()) {
+            if (compositeMappedFieldType instanceof StarTreeMapper.StarTreeFieldType) {
+                StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) compositeMappedFieldType;
+                starTreeFields.add(
+                    new StarTreeField(
+                        starTreeFieldType.name(),
+                        starTreeFieldType.getDimensions(),
+                        starTreeFieldType.getMetrics(),
+                        starTreeFieldType.getStarTreeConfig()
+                    )
+                );
+            }
+        }
+        this.starTreeFields = starTreeFields;
+        this.state = segmentWriteState;
+        this.mapperService = mapperService;
+        this.fieldNumberAcrossStarTrees = fieldNumberAcrossStarTrees;
+    }
+
+    /**
+     * Builds all star-trees for given star-tree fields.
+     *
+     * @param metaOut                      an IndexInput for star-tree metadata
+     * @param dataOut                      an IndexInput for star-tree data
+     * @param fieldProducerMap             fetches iterators for the fields (dimensions and metrics)
+     * @param starTreeDocValuesConsumer    a consumer to write star-tree doc values
+     * @throws IOException                 when an error occurs while building the star-trees
+     */
+    public void build(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        Map<String, DocValuesProducer> fieldProducerMap,
+        DocValuesConsumer starTreeDocValuesConsumer
+    ) throws IOException {
+        if (starTreeFields.isEmpty()) {
+            logger.debug("no star-tree fields found, returning from star-tree builder");
+            return;
+        }
+        long startTime = System.currentTimeMillis();
+
+        int numStarTrees = starTreeFields.size();
+        logger.debug("Starting building {} star-trees with star-tree fields", numStarTrees);
+
+        // Build all star-trees
+        for (StarTreeField starTreeField : starTreeFields) {
+            try (StarTreeBuilder starTreeBuilder = getStarTreeBuilder(metaOut, dataOut, starTreeField, state, mapperService)) {
+                starTreeBuilder.build(fieldProducerMap, fieldNumberAcrossStarTrees, starTreeDocValuesConsumer);
+            }
+        }
+        logger.debug("Took {} ms to build {} star-trees with star-tree fields", System.currentTimeMillis() - startTime, numStarTrees);
+    }
+
+    @Override
+    public void close() throws IOException {
+        // TODO : close files
+    }
+
+    /**
+     * Merges star tree fields from multiple segments
+     *
+     * @param metaOut                      an IndexInput for star-tree metadata
+     * @param dataOut                      an IndexInput for star-tree data
+     * @param starTreeValuesSubsPerField   starTreeValuesSubs per field
+     * @param starTreeDocValuesConsumer    a consumer to write star-tree doc values
+     */
+    public void buildDuringMerge(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        final Map<String, List<StarTreeValues>> starTreeValuesSubsPerField,
+        DocValuesConsumer starTreeDocValuesConsumer
+    ) throws IOException {
+        logger.debug("Starting merge of {} star-trees with star-tree fields", starTreeValuesSubsPerField.size());
+        long startTime = System.currentTimeMillis();
+        for (Map.Entry<String, List<StarTreeValues>> entry : starTreeValuesSubsPerField.entrySet()) {
+            List<StarTreeValues> starTreeValuesList = entry.getValue();
+            if (starTreeValuesList.isEmpty()) {
+                logger.debug("StarTreeValues is empty for all segments for field : {}", entry.getKey());
+                continue;
+            }
+            StarTreeField starTreeField = starTreeValuesList.get(0).getStarTreeField();
+            try (StarTreeBuilder builder = getStarTreeBuilder(metaOut, dataOut, starTreeField, state, mapperService)) {
+                builder.build(starTreeValuesList, fieldNumberAcrossStarTrees, starTreeDocValuesConsumer);
+            }
+        }
+        logger.debug(
+            "Took {} ms to merge {} star-trees with star-tree fields",
+            System.currentTimeMillis() - startTime,
+            starTreeValuesSubsPerField.size()
+        );
+    }
+
+    /**
+     * Get star-tree builder based on build mode.
+     */
+    StarTreeBuilder getStarTreeBuilder(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        StarTreeField starTreeField,
+        SegmentWriteState state,
+        MapperService mapperService
+    ) throws IOException {
+        switch (starTreeField.getStarTreeConfig().getBuildMode()) {
+            case ON_HEAP:
+                return new OnHeapStarTreeBuilder(metaOut, dataOut, starTreeField, state, mapperService);
+            case OFF_HEAP:
+                return new OffHeapStarTreeBuilder(metaOut, dataOut, starTreeField, state, mapperService);
+            default:
+                throw new IllegalArgumentException(
+                    String.format(
+                        Locale.ROOT,
+                        "No star tree implementation is available for [%s] build mode",
+                        starTreeField.getStarTreeConfig().getBuildMode()
+                    )
+                );
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/package-info.java
new file mode 100644
index 0000000000000..9c97b076371a3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/builder/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Builders for Composite Index Star Tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.builder;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/StarTreeWriter.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/StarTreeWriter.java
new file mode 100644
index 0000000000000..e5890be3ccb5b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/StarTreeWriter.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.fileformats;
+
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.data.StarTreeDataWriter;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.meta.StarTreeMetadataWriter;
+import org.opensearch.index.compositeindex.datacube.startree.node.InMemoryTreeNode;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Util class for building star tree
+ *
+ * @opensearch.experimental
+ */
+public class StarTreeWriter {
+
+    /** Initial version for the star tree writer */
+    public static final int VERSION_START = 0;
+
+    /** Current version for the star tree writer */
+    public static final int VERSION_CURRENT = VERSION_START;
+
+    public StarTreeWriter() {}
+
+    /**
+     * Write star tree to index output stream
+     *
+     * @param dataOut  data index output
+     * @param rootNode root star-tree node
+     * @param numNodes number of nodes in the star tree
+     * @param name     name of the star-tree field
+     * @return total size of the three
+     * @throws IOException when star-tree data serialization fails
+     */
+    public long writeStarTree(IndexOutput dataOut, InMemoryTreeNode rootNode, int numNodes, String name) throws IOException {
+        return StarTreeDataWriter.writeStarTree(dataOut, rootNode, numNodes, name);
+    }
+
+    /**
+     * Write star tree metadata to index output stream
+     *
+     * @param metaOut                meta index output
+     * @param starTreeField          star tree field
+     * @param metricAggregatorInfos  metric aggregator infos
+     * @param numNodes               number of nodes in the star tree
+     * @param segmentAggregatedCount segment aggregated count
+     * @param numStarTreeDocs           the total number of star tree documents for the segment
+     * @param dataFilePointer        data file pointer
+     * @param dataFileLength         data file length
+     * @throws IOException when star-tree data serialization fails
+     */
+    public void writeStarTreeMetadata(
+        IndexOutput metaOut,
+        StarTreeField starTreeField,
+        List<MetricAggregatorInfo> metricAggregatorInfos,
+        Integer numNodes,
+        Integer segmentAggregatedCount,
+        Integer numStarTreeDocs,
+        long dataFilePointer,
+        long dataFileLength
+    ) throws IOException {
+        StarTreeMetadataWriter.writeStarTreeMetadata(
+            metaOut,
+            starTreeField,
+            metricAggregatorInfos,
+            numNodes,
+            segmentAggregatedCount,
+            numStarTreeDocs,
+            dataFilePointer,
+            dataFileLength
+        );
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/StarTreeDataWriter.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/StarTreeDataWriter.java
new file mode 100644
index 0000000000000..5fe70d3c075cf
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/StarTreeDataWriter.java
@@ -0,0 +1,112 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.data;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.index.compositeindex.datacube.startree.node.InMemoryTreeNode;
+
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.Queue;
+
+import static org.opensearch.index.compositeindex.datacube.startree.fileformats.node.FixedLengthStarTreeNode.SERIALIZABLE_DATA_SIZE_IN_BYTES;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.ALL;
+
+/**
+ * Utility class for serializing a star-tree data structure.
+ *
+ * @opensearch.experimental
+ */
+public class StarTreeDataWriter {
+
+    private static final Logger logger = LogManager.getLogger(StarTreeDataWriter.class);
+
+    /**
+     * Writes the star-tree data structure.
+     *
+     * @param indexOutput the IndexOutput to write the star-tree data
+     * @param rootNode    the root node of the star-tree
+     * @param numNodes    the total number of nodes in the star-tree
+     * @param name        the name of the star-tree field
+     * @return the total size in bytes of the serialized star-tree data
+     * @throws IOException if an I/O error occurs while writing the star-tree data
+     */
+    public static long writeStarTree(IndexOutput indexOutput, InMemoryTreeNode rootNode, int numNodes, String name) throws IOException {
+        long totalSizeInBytes = (long) numNodes * SERIALIZABLE_DATA_SIZE_IN_BYTES;
+
+        logger.debug("Star tree data size in bytes : {} for star-tree field {}", totalSizeInBytes, name);
+
+        writeStarTreeNodes(indexOutput, rootNode);
+        return totalSizeInBytes;
+    }
+
+    /**
+     * Writes the star-tree nodes in a breadth-first order.
+     *
+     * @param output   the IndexOutput to write the nodes
+     * @param rootNode the root node of the star-tree
+     * @throws IOException if an I/O error occurs while writing the nodes
+     */
+    private static void writeStarTreeNodes(IndexOutput output, InMemoryTreeNode rootNode) throws IOException {
+        Queue<InMemoryTreeNode> queue = new LinkedList<>();
+        queue.add(rootNode);
+
+        int currentNodeId = 0;
+        while (!queue.isEmpty()) {
+            InMemoryTreeNode node = queue.remove();
+
+            if (!node.hasChild()) {
+                writeStarTreeNode(output, node, ALL, ALL);
+            } else {
+
+                int totalNumberOfChildren = 0;
+                int firstChildId = currentNodeId + queue.size() + 1;
+
+                if (node.getChildStarNode() != null) {
+                    totalNumberOfChildren++;
+                    queue.add(node.getChildStarNode());
+                }
+
+                if (node.getChildren() != null) {
+                    totalNumberOfChildren = totalNumberOfChildren + node.getChildren().values().size();
+                    queue.addAll(node.getChildren().values());
+                }
+
+                int lastChildId = firstChildId + totalNumberOfChildren - 1;
+                writeStarTreeNode(output, node, firstChildId, lastChildId);
+
+            }
+
+            currentNodeId++;
+        }
+    }
+
+    /**
+     * Writes a single star-tree node
+     *
+     * @param output       the IndexOutput to write the node
+     * @param node         the star tree node to write
+     * @param firstChildId the ID of the first child node
+     * @param lastChildId  the ID of the last child node
+     * @throws IOException if an I/O error occurs while writing the node
+     */
+    private static void writeStarTreeNode(IndexOutput output, InMemoryTreeNode node, int firstChildId, int lastChildId) throws IOException {
+        output.writeInt(node.getDimensionId());
+        output.writeLong(node.getDimensionValue());
+        output.writeInt(node.getStartDocId());
+        output.writeInt(node.getEndDocId());
+        output.writeInt(node.getAggregatedDocId());
+        output.writeByte(node.getNodeType());
+        output.writeInt(firstChildId);
+        output.writeInt(lastChildId);
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/package-info.java
new file mode 100644
index 0000000000000..1c6df3886e08d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Writer package for star tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.data;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadata.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadata.java
new file mode 100644
index 0000000000000..7352c215ee390
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadata.java
@@ -0,0 +1,408 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.meta;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.CorruptIndexException;
+import org.apache.lucene.store.IndexInput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.CompositeIndexMetadata;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Holds the associated metadata for the building of star-tree.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeMetadata extends CompositeIndexMetadata {
+    private static final Logger logger = LogManager.getLogger(StarTreeMetadata.class);
+
+    /**
+     * The index input for reading metadata from the segment file.
+     */
+    private final IndexInput meta;
+
+    /**
+     * The version of the star tree stored in the segments.
+     */
+    private final int version;
+
+    /**
+     * The number of the nodes in the respective star tree
+     */
+    private final int numberOfNodes;
+
+    /**
+     * The name of the star-tree field, used to identify the star-tree.
+     */
+    private final String starTreeFieldName;
+
+    /**
+     * The type of the star-tree field, indicating the specific implementation or version.
+     * Here, STAR_TREE field.
+     */
+    private final String starTreeFieldType;
+
+    /**
+     * List of dimension fields used in the star-tree.
+     */
+    private final List<String> dimensionFields;
+
+    /**
+     * List of metrics, containing field names and associated metric statistics.
+     */
+    private final List<Metric> metrics;
+
+    /**
+     * The total number of documents aggregated in this star-tree segment.
+     */
+    private final int segmentAggregatedDocCount;
+
+    /**
+     * The maximum number of documents allowed in a leaf node.
+     */
+    private final int maxLeafDocs;
+
+    /**
+     * Set of dimensions for which star node creation should be skipped.
+     */
+    private final Set<String> skipStarNodeCreationInDims;
+
+    /**
+     * The build mode used for constructing the star-tree.
+     */
+    private final StarTreeFieldConfiguration.StarTreeBuildMode starTreeBuildMode;
+
+    /**
+     * The file pointer to the start of the associated star-tree data in the (.cid) file
+     */
+    private final long dataStartFilePointer;
+
+    /**
+     * The length of the star-tree data in bytes, used for reading the correct amount of data from (.cid) file
+     */
+    private final long dataLength;
+
+    /**
+     * The number of star tree documents in the star tree.
+     */
+    private final int starTreeDocCount;
+
+    /**
+     * A star tree metadata constructor to initialize star tree metadata from the segment file (.cim) using index input.
+     *
+     * @param metaIn             an index input to read star-tree meta
+     * @param compositeFieldName name of the composite field. Here, name of the star-tree field.
+     * @param compositeFieldType type of the composite field. Here, STAR_TREE field.
+     * @param version The version of the star tree stored in the segments.
+     * @throws IOException if unable to read star-tree metadata from the file
+     */
+    public StarTreeMetadata(
+        IndexInput metaIn,
+        String compositeFieldName,
+        CompositeMappedFieldType.CompositeFieldType compositeFieldType,
+        Integer version
+    ) throws IOException {
+        super(compositeFieldName, compositeFieldType);
+        this.meta = metaIn;
+        try {
+            this.starTreeFieldName = this.getCompositeFieldName();
+            this.starTreeFieldType = this.getCompositeFieldType().getName();
+            this.version = version;
+            this.numberOfNodes = readNumberOfNodes();
+            this.dimensionFields = readStarTreeDimensions();
+            this.metrics = readMetricEntries();
+            this.segmentAggregatedDocCount = readSegmentAggregatedDocCount();
+            this.starTreeDocCount = readStarTreeDocCount();
+            this.maxLeafDocs = readMaxLeafDocs();
+            this.skipStarNodeCreationInDims = readSkipStarNodeCreationInDims();
+            this.starTreeBuildMode = readBuildMode();
+            this.dataStartFilePointer = readDataStartFilePointer();
+            this.dataLength = readDataLength();
+        } catch (Exception e) {
+            logger.error("Unable to read star-tree metadata from the file");
+            throw new CorruptIndexException("Unable to read star-tree metadata from the file", metaIn);
+        }
+    }
+
+    /**
+     * A star tree metadata constructor to initialize star tree metadata.
+     * Used for testing.
+     *
+     * @param meta                       an index input to read star-tree meta
+     * @param compositeFieldName         name of the composite field. Here, name of the star-tree field.
+     * @param compositeFieldType         type of the composite field. Here, STAR_TREE field.
+     * @param version The version of the star tree stored in the segments.
+     * @param dimensionFields            list of dimension fields
+     * @param metrics              list of metric entries
+     * @param segmentAggregatedDocCount  segment aggregated doc count
+     * @param starTreeDocCount        the total number of star tree documents for the segment
+     * @param maxLeafDocs                max leaf docs
+     * @param skipStarNodeCreationInDims set of dimensions to skip star node creation
+     * @param starTreeBuildMode          star tree build mode
+     * @param dataStartFilePointer       star file pointer to the associated star tree data in (.cid) file
+     * @param dataLength                 length of the corresponding star-tree data in (.cid) file
+     */
+    public StarTreeMetadata(
+        String compositeFieldName,
+        CompositeMappedFieldType.CompositeFieldType compositeFieldType,
+        IndexInput meta,
+        Integer version,
+        Integer numberOfNodes,
+        List<String> dimensionFields,
+        List<Metric> metrics,
+        Integer segmentAggregatedDocCount,
+        Integer starTreeDocCount,
+        Integer maxLeafDocs,
+        Set<String> skipStarNodeCreationInDims,
+        StarTreeFieldConfiguration.StarTreeBuildMode starTreeBuildMode,
+        long dataStartFilePointer,
+        long dataLength
+    ) {
+        super(compositeFieldName, compositeFieldType);
+        this.meta = meta;
+        this.starTreeFieldName = compositeFieldName;
+        this.starTreeFieldType = compositeFieldType.getName();
+        this.version = version;
+        this.numberOfNodes = numberOfNodes;
+        this.dimensionFields = dimensionFields;
+        this.metrics = metrics;
+        this.segmentAggregatedDocCount = segmentAggregatedDocCount;
+        this.starTreeDocCount = starTreeDocCount;
+        this.maxLeafDocs = maxLeafDocs;
+        this.skipStarNodeCreationInDims = skipStarNodeCreationInDims;
+        this.starTreeBuildMode = starTreeBuildMode;
+        this.dataStartFilePointer = dataStartFilePointer;
+        this.dataLength = dataLength;
+    }
+
+    private int readNumberOfNodes() throws IOException {
+        return meta.readVInt();
+    }
+
+    private int readDimensionsCount() throws IOException {
+        return meta.readVInt();
+    }
+
+    private List<String> readStarTreeDimensions() throws IOException {
+        int dimensionCount = readDimensionsCount();
+        List<String> dimensionFields = new ArrayList<>();
+
+        for (int i = 0; i < dimensionCount; i++) {
+            dimensionFields.add(meta.readString());
+        }
+
+        return dimensionFields;
+    }
+
+    private int readMetricsCount() throws IOException {
+        return meta.readVInt();
+    }
+
+    private List<Metric> readMetricEntries() throws IOException {
+        int metricCount = readMetricsCount();
+
+        Map<String, List<MetricStat>> starTreeMetricStatMap = new LinkedHashMap<>();
+        for (int i = 0; i < metricCount; i++) {
+            String metricName = meta.readString();
+            int metricStatOrdinal = meta.readVInt();
+            MetricStat metricStat = MetricStat.fromMetricOrdinal(metricStatOrdinal);
+            List<MetricStat> metricStats = starTreeMetricStatMap.computeIfAbsent(metricName, field -> new ArrayList<>());
+            metricStats.add(metricStat);
+        }
+        List<Metric> starTreeMetricMap = new ArrayList<>();
+        for (Map.Entry<String, List<MetricStat>> metricStatsEntry : starTreeMetricStatMap.entrySet()) {
+            addEligibleDerivedMetrics(metricStatsEntry.getValue());
+            starTreeMetricMap.add(new Metric(metricStatsEntry.getKey(), metricStatsEntry.getValue()));
+
+        }
+        return starTreeMetricMap;
+    }
+
+    /**
+     * Add derived metrics if all associated base metrics are present
+     */
+    private void addEligibleDerivedMetrics(List<MetricStat> metricStatsList) {
+        Set<MetricStat> metricStatsSet = new HashSet<>(metricStatsList);
+        for (MetricStat metric : MetricStat.values()) {
+            if (metric.isDerivedMetric() && !metricStatsSet.contains(metric)) {
+                List<MetricStat> sourceMetrics = metric.getBaseMetrics();
+                if (metricStatsSet.containsAll(sourceMetrics)) {
+                    metricStatsList.add(metric);
+                    metricStatsSet.add(metric);
+                }
+            }
+        }
+    }
+
+    private int readSegmentAggregatedDocCount() throws IOException {
+        return meta.readVInt();
+    }
+
+    private Integer readStarTreeDocCount() throws IOException {
+        return meta.readVInt();
+    }
+
+    private int readMaxLeafDocs() throws IOException {
+        return meta.readVInt();
+    }
+
+    private int readSkipStarNodeCreationInDimsCount() throws IOException {
+        return meta.readVInt();
+    }
+
+    private Set<String> readSkipStarNodeCreationInDims() throws IOException {
+
+        int skipStarNodeCreationInDimsCount = readSkipStarNodeCreationInDimsCount();
+        Set<String> skipStarNodeCreationInDims = new HashSet<>();
+        for (int i = 0; i < skipStarNodeCreationInDimsCount; i++) {
+            skipStarNodeCreationInDims.add(meta.readString());
+        }
+        return skipStarNodeCreationInDims;
+    }
+
+    private StarTreeFieldConfiguration.StarTreeBuildMode readBuildMode() throws IOException {
+        return StarTreeFieldConfiguration.StarTreeBuildMode.fromBuildModeOrdinal(meta.readByte());
+    }
+
+    private long readDataStartFilePointer() throws IOException {
+        return meta.readVLong();
+    }
+
+    private long readDataLength() throws IOException {
+        return meta.readVLong();
+    }
+
+    /**
+     * Returns the name of the star-tree field.
+     *
+     * @return star-tree field name
+     */
+    public String getStarTreeFieldName() {
+        return starTreeFieldName;
+    }
+
+    /**
+     * Returns the type of the star tree field.
+     *
+     * @return star-tree field type
+     */
+    public String getStarTreeFieldType() {
+        return starTreeFieldType;
+    }
+
+    /**
+     * Returns the list of dimension field numbers.
+     *
+     * @return star-tree dimension field numbers
+     */
+    public List<String> getDimensionFields() {
+        return dimensionFields;
+    }
+
+    /**
+     * Returns the list of metric entries.
+     *
+     * @return star-tree metric entries
+     */
+    public List<Metric> getMetrics() {
+        return metrics;
+    }
+
+    /**
+     * Returns the aggregated document count for the star-tree.
+     *
+     * @return the aggregated document count for the star-tree.
+     */
+    public int getSegmentAggregatedDocCount() {
+        return segmentAggregatedDocCount;
+    }
+
+    /**
+     * Returns the total number of star tree documents in the segment
+     *
+     * @return the number of star tree documents in the segment
+     */
+    public int getStarTreeDocCount() {
+        return starTreeDocCount;
+    }
+
+    /**
+     * Returns the max leaf docs for the star-tree.
+     *
+     * @return the max leaf docs.
+     */
+    public int getMaxLeafDocs() {
+        return maxLeafDocs;
+    }
+
+    /**
+     * Returns the set of dimensions for which star node will not be created in the star-tree.
+     *
+     * @return the set of dimensions.
+     */
+    public Set<String> getSkipStarNodeCreationInDims() {
+        return skipStarNodeCreationInDims;
+    }
+
+    /**
+     * Returns the build mode for the star-tree.
+     *
+     * @return the star-tree build mode.
+     */
+    public StarTreeFieldConfiguration.StarTreeBuildMode getStarTreeBuildMode() {
+        return starTreeBuildMode;
+    }
+
+    /**
+     * Returns the file pointer to the start of the star-tree data.
+     *
+     * @return start file pointer for star-tree data
+     */
+    public long getDataStartFilePointer() {
+        return dataStartFilePointer;
+    }
+
+    /**
+     * Returns the length of star-tree data
+     *
+     * @return star-tree length
+     */
+    public long getDataLength() {
+        return dataLength;
+    }
+
+    /**
+     * Returns the version with which the star tree is stored in the segments
+     * @return star-tree version
+     */
+    public int getVersion() {
+        return version;
+    }
+
+    /**
+     * Returns the number of nodes in the star tree
+     * @return number of nodes in the star tree
+     */
+    public int getNumberOfNodes() {
+        return numberOfNodes;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataWriter.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataWriter.java
new file mode 100644
index 0000000000000..1c04350e25047
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataWriter.java
@@ -0,0 +1,177 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.meta;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+
+import java.io.IOException;
+import java.util.List;
+
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.COMPOSITE_FIELD_MARKER;
+import static org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter.VERSION_CURRENT;
+
+/**
+ * The utility class for serializing the metadata of a star-tree data structure.
+ * The metadata includes information about the dimensions, metrics, and other relevant details
+ * related to the star tree.
+ *
+ * @opensearch.experimental
+ */
+public class StarTreeMetadataWriter {
+
+    private static final Logger logger = LogManager.getLogger(StarTreeMetadataWriter.class);
+
+    /**
+     * Writes the star-tree metadata.
+     *
+     * @param metaOut                the IndexOutput to write the metadata
+     * @param starTreeField          the star-tree field
+     * @param metricAggregatorInfos  the list of metric aggregator information
+     * @param segmentAggregatedCount the aggregated document count for the segment
+     * @param numNodes               number of nodes in the star tree
+     * @param dataFilePointer        the file pointer to the start of the star tree data
+     * @param dataFileLength         the length of the star tree data file
+     * @throws IOException if an I/O error occurs while serializing the metadata
+     */
+    public static void writeStarTreeMetadata(
+        IndexOutput metaOut,
+        StarTreeField starTreeField,
+        List<MetricAggregatorInfo> metricAggregatorInfos,
+        Integer numNodes,
+        Integer segmentAggregatedCount,
+        Integer numStarTreeDocs,
+        long dataFilePointer,
+        long dataFileLength
+    ) throws IOException {
+
+        long initialMetaFilePointer = metaOut.getFilePointer();
+
+        writeMetaHeader(metaOut);
+
+        // TODO: Replace the parameters with StarTreeMetadata class object
+        writeMeta(
+            metaOut,
+            metricAggregatorInfos,
+            starTreeField,
+            numNodes,
+            segmentAggregatedCount,
+            numStarTreeDocs,
+            dataFilePointer,
+            dataFileLength
+        );
+
+        logger.debug(
+            "Star tree meta size in bytes : {} for star-tree field {}",
+            metaOut.getFilePointer() - initialMetaFilePointer,
+            starTreeField.getName()
+        );
+    }
+
+    /**
+     * Writes the star-tree metadata header.
+     *
+     * @param metaOut            the IndexOutput to write the header
+     * @throws IOException if an I/O error occurs while writing the header
+     */
+    private static void writeMetaHeader(IndexOutput metaOut) throws IOException {
+        // magic marker for sanity
+        metaOut.writeLong(COMPOSITE_FIELD_MARKER);
+
+        // version
+        metaOut.writeVInt(VERSION_CURRENT);
+
+    }
+
+    /**
+     * Writes the star-tree metadata.
+     *
+     * @param metaOut                   the IndexOutput to write the metadata
+     * @param metricAggregatorInfos     the list of metric aggregator information
+     * @param starTreeField             the star tree field
+     * @param numNodes                  number of nodes in the star tree
+     * @param segmentAggregatedDocCount the aggregated document count for the segment
+     * @param numStarTreeDocs           the total number of star tree documents for the segment
+     * @param dataFilePointer           the file pointer to the start of the star-tree data
+     * @param dataFileLength            the length of the star-tree data file
+     * @throws IOException if an I/O error occurs while writing the metadata
+     */
+    private static void writeMeta(
+        IndexOutput metaOut,
+        List<MetricAggregatorInfo> metricAggregatorInfos,
+        StarTreeField starTreeField,
+        int numNodes,
+        Integer segmentAggregatedDocCount,
+        Integer numStarTreeDocs,
+        long dataFilePointer,
+        long dataFileLength
+    ) throws IOException {
+
+        // star tree field name
+        metaOut.writeString(starTreeField.getName());
+
+        // star tree field type
+        metaOut.writeString(CompositeMappedFieldType.CompositeFieldType.STAR_TREE.getName());
+
+        // number of nodes
+        metaOut.writeVInt(numNodes);
+
+        // number of dimensions
+        // TODO: Revisit the number of dimensions for timestamps (as we will split timestamp into min, hour, etc.)
+        metaOut.writeVInt(starTreeField.getDimensionsOrder().size());
+
+        // dimensions
+        // TODO: Add sub-dimensions for timestamps (as we will split timestamp into min, hour, etc.)
+        for (Dimension dimension : starTreeField.getDimensionsOrder()) {
+            metaOut.writeString(dimension.getField());
+        }
+
+        // number of metrics
+        metaOut.writeVInt(metricAggregatorInfos.size());
+
+        // metric - metric stat pair
+        for (MetricAggregatorInfo metricAggregatorInfo : metricAggregatorInfos) {
+            metaOut.writeString(metricAggregatorInfo.getField());
+            int metricStatOrdinal = metricAggregatorInfo.getMetricStat().getMetricOrdinal();
+            metaOut.writeVInt(metricStatOrdinal);
+        }
+
+        // segment aggregated document count
+        metaOut.writeVInt(segmentAggregatedDocCount);
+
+        // segment star tree document count
+        metaOut.writeVInt(numStarTreeDocs);
+
+        // max leaf docs
+        metaOut.writeVInt(starTreeField.getStarTreeConfig().maxLeafDocs());
+
+        // number of skip star node creation dimensions
+        metaOut.writeVInt(starTreeField.getStarTreeConfig().getSkipStarNodeCreationInDims().size());
+
+        // skip star node creations
+        for (String dimension : starTreeField.getStarTreeConfig().getSkipStarNodeCreationInDims()) {
+            metaOut.writeString(dimension);
+        }
+
+        // star tree build-mode
+        metaOut.writeByte(starTreeField.getStarTreeConfig().getBuildMode().getBuildModeOrdinal());
+
+        // star-tree data file pointer
+        metaOut.writeVLong(dataFilePointer);
+
+        // star-tree data file length
+        metaOut.writeVLong(dataFileLength);
+
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/package-info.java
new file mode 100644
index 0000000000000..a2480f03c4b5a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Meta package for star tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.meta;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/FixedLengthStarTreeNode.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/FixedLengthStarTreeNode.java
new file mode 100644
index 0000000000000..df2ce9096bfc1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/FixedLengthStarTreeNode.java
@@ -0,0 +1,300 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.node;
+
+import org.apache.lucene.store.RandomAccessInput;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNode;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNodeType;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.Iterator;
+
+/**
+ * Fixed Length implementation of {@link StarTreeNode}.
+ * <p>
+ * This class represents a node in a star tree with a fixed-length serialization format.
+ * It provides efficient storage and retrieval of node information using a RandomAccessInput.
+ * The node structure includes the methods to access all the constructs of InMemoryTreeNode.
+ *
+ * <p>
+ * Key features:
+ * - Fixed-size serialization for each node, allowing for efficient random access
+ * - Binary search capability for finding child nodes
+ * - Support for star nodes, null nodes and other default nodes
+ * - Iteration over child nodes
+ * <p>
+ * The class uses specific byte offsets for each field in the serialized format,
+ * enabling direct access to node properties without parsing the entire node structure.
+ *
+ * @opensearch.experimental
+ */
+public class FixedLengthStarTreeNode implements StarTreeNode {
+
+    /**
+     * Number of integer fields in the serializable data
+     */
+    public static final int NUM_INT_SERIALIZABLE_FIELDS = 6;
+
+    /**
+     * Number of long fields in the serializable data
+     */
+    public static final int NUM_LONG_SERIALIZABLE_FIELDS = 1;
+
+    /**
+     * Number of byte fields in the serializable data
+     */
+    public static final int NUM_BYTE_SERIALIZABLE_FIELDS = 1;
+
+    /**
+     * Total size in bytes of the serializable data for each node
+     */
+    public static final long SERIALIZABLE_DATA_SIZE_IN_BYTES = (Integer.BYTES * NUM_INT_SERIALIZABLE_FIELDS) + (Long.BYTES
+        * NUM_LONG_SERIALIZABLE_FIELDS) + (NUM_BYTE_SERIALIZABLE_FIELDS * Byte.BYTES);
+
+    // Byte offsets for each field in the serialized data
+    static final int DIMENSION_ID_OFFSET = 0;
+    static final int DIMENSION_VALUE_OFFSET = DIMENSION_ID_OFFSET + Integer.BYTES;
+    static final int START_DOC_ID_OFFSET = DIMENSION_VALUE_OFFSET + Long.BYTES;
+    static final int END_DOC_ID_OFFSET = START_DOC_ID_OFFSET + Integer.BYTES;
+    static final int AGGREGATE_DOC_ID_OFFSET = END_DOC_ID_OFFSET + Integer.BYTES;
+    static final int STAR_NODE_TYPE_OFFSET = AGGREGATE_DOC_ID_OFFSET + Integer.BYTES;
+    static final int FIRST_CHILD_ID_OFFSET = STAR_NODE_TYPE_OFFSET + Byte.BYTES;
+    static final int LAST_CHILD_ID_OFFSET = FIRST_CHILD_ID_OFFSET + Integer.BYTES;
+
+    /**
+     * Constant representing an invalid node ID
+     */
+    public static final int INVALID_ID = -1;
+
+    /**
+     * The ID of this node
+     */
+    private final int nodeId;
+
+    /**
+     * The ID of the first child of this node
+     */
+    private final int firstChildId;
+
+    /**
+     * The input source for reading node data
+     */
+    RandomAccessInput in;
+
+    /**
+     * Constructs a FixedLengthStarTreeNode.
+     *
+     * @param in     The RandomAccessInput to read node data from
+     * @param nodeId The ID of this node
+     * @throws IOException If there's an error reading from the input
+     */
+    public FixedLengthStarTreeNode(RandomAccessInput in, int nodeId) throws IOException {
+        this.in = in;
+        this.nodeId = nodeId;
+        firstChildId = getInt(FIRST_CHILD_ID_OFFSET);
+    }
+
+    /**
+     * Reads an integer value from the specified offset in the node's data.
+     *
+     * @param fieldOffset The offset of the field to read
+     * @return The integer value at the specified offset
+     * @throws IOException If there's an error reading from the input
+     */
+    private int getInt(int fieldOffset) throws IOException {
+        return in.readInt(nodeId * SERIALIZABLE_DATA_SIZE_IN_BYTES + fieldOffset);
+    }
+
+    /**
+     * Reads a long value from the specified offset in the node's data.
+     *
+     * @param fieldOffset The offset of the field to read
+     * @return The long value at the specified offset
+     * @throws IOException If there's an error reading from the input
+     */
+    private long getLong(int fieldOffset) throws IOException {
+        return in.readLong(nodeId * SERIALIZABLE_DATA_SIZE_IN_BYTES + fieldOffset);
+    }
+
+    /**
+     * Reads a byte value from the specified offset in the node's data.
+     *
+     * @param fieldOffset The offset of the field to read
+     * @return The byte value at the specified offset
+     * @throws IOException If there's an error reading from the input
+     */
+    private byte getByte(int fieldOffset) throws IOException {
+        return in.readByte(nodeId * SERIALIZABLE_DATA_SIZE_IN_BYTES + fieldOffset);
+    }
+
+    @Override
+    public int getDimensionId() throws IOException {
+        return getInt(DIMENSION_ID_OFFSET);
+    }
+
+    @Override
+    public long getDimensionValue() throws IOException {
+        return getLong(DIMENSION_VALUE_OFFSET);
+    }
+
+    @Override
+    public int getChildDimensionId() throws IOException {
+        if (firstChildId == INVALID_ID) {
+            return INVALID_ID;
+        } else {
+            return in.readInt(firstChildId * SERIALIZABLE_DATA_SIZE_IN_BYTES);
+        }
+    }
+
+    @Override
+    public int getStartDocId() throws IOException {
+        return getInt(START_DOC_ID_OFFSET);
+    }
+
+    @Override
+    public int getEndDocId() throws IOException {
+        return getInt(END_DOC_ID_OFFSET);
+    }
+
+    @Override
+    public int getAggregatedDocId() throws IOException {
+        return getInt(AGGREGATE_DOC_ID_OFFSET);
+    }
+
+    @Override
+    public int getNumChildren() throws IOException {
+        if (firstChildId == INVALID_ID) {
+            return 0;
+        } else {
+            return getInt(LAST_CHILD_ID_OFFSET) - firstChildId + 1;
+        }
+    }
+
+    @Override
+    public boolean isLeaf() {
+        return firstChildId == INVALID_ID;
+    }
+
+    @Override
+    public byte getStarTreeNodeType() throws IOException {
+        return getByte(STAR_NODE_TYPE_OFFSET);
+    }
+
+    @Override
+    public StarTreeNode getChildStarNode() throws IOException {
+        return handleStarNode();
+    }
+
+    @Override
+    public StarTreeNode getChildForDimensionValue(Long dimensionValue) throws IOException {
+        // there will be no children for leaf nodes
+        if (isLeaf()) {
+            return null;
+        }
+
+        StarTreeNode resultStarTreeNode = null;
+        if (null != dimensionValue) {
+            resultStarTreeNode = binarySearchChild(dimensionValue);
+        }
+        return resultStarTreeNode;
+    }
+
+    /**
+     * Handles the special case of a star node.
+     *
+     * @return The star node if found, null otherwise
+     * @throws IOException If there's an error reading from the input
+     */
+    private FixedLengthStarTreeNode handleStarNode() throws IOException {
+        FixedLengthStarTreeNode firstNode = new FixedLengthStarTreeNode(in, firstChildId);
+        return matchStarTreeNodeTypeOrNull(firstNode, StarTreeNodeType.STAR);
+    }
+
+    /**
+     * Checks if the given node matches the specified StarTreeNodeType.
+     *
+     * @param firstNode The FixedLengthStarTreeNode to check.
+     * @param starTreeNodeType The StarTreeNodeType to match against.
+     * @return The firstNode if its type matches the targetType, null otherwise.
+     * @throws IOException If an I/O error occurs during the operation.
+     */
+    private static FixedLengthStarTreeNode matchStarTreeNodeTypeOrNull(FixedLengthStarTreeNode firstNode, StarTreeNodeType starTreeNodeType)
+        throws IOException {
+        if (firstNode.getStarTreeNodeType() == starTreeNodeType.getValue()) {
+            return firstNode;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Performs a binary search to find a child node with the given dimension value.
+     *
+     * @param dimensionValue The dimension value to search for
+     * @return The child node if found, null otherwise
+     * @throws IOException If there's an error reading from the input
+     */
+    private FixedLengthStarTreeNode binarySearchChild(long dimensionValue) throws IOException {
+
+        int low = firstChildId;
+
+        // if the current node is star node, increment the low to reduce the search space
+        if (matchStarTreeNodeTypeOrNull(new FixedLengthStarTreeNode(in, firstChildId), StarTreeNodeType.STAR) != null) {
+            low++;
+        }
+
+        int high = getInt(LAST_CHILD_ID_OFFSET);
+        // if the current node is null node, decrement the high to reduce the search space
+        if (matchStarTreeNodeTypeOrNull(new FixedLengthStarTreeNode(in, high), StarTreeNodeType.NULL) != null) {
+            high--;
+        }
+
+        while (low <= high) {
+            int mid = low + (high - low) / 2;
+            FixedLengthStarTreeNode midNode = new FixedLengthStarTreeNode(in, mid);
+            long midDimensionValue = midNode.getDimensionValue();
+
+            if (midDimensionValue == dimensionValue) {
+                return midNode;
+            } else if (midDimensionValue < dimensionValue) {
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Iterator<FixedLengthStarTreeNode> getChildrenIterator() throws IOException {
+        return new Iterator<>() {
+            private int currentChildId = firstChildId;
+            private final int lastChildId = getInt(LAST_CHILD_ID_OFFSET);
+
+            @Override
+            public boolean hasNext() {
+                return currentChildId <= lastChildId;
+            }
+
+            @Override
+            public FixedLengthStarTreeNode next() {
+                try {
+                    return new FixedLengthStarTreeNode(in, currentChildId++);
+                } catch (IOException e) {
+                    throw new UncheckedIOException(e);
+                }
+            }
+
+            @Override
+            public void remove() {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/package-info.java
new file mode 100644
index 0000000000000..84271be81f5e4
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Holds classes associated with star tree node with file formats
+ */
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.node;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/package-info.java
new file mode 100644
index 0000000000000..917327757fc9b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * File formats for star tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.fileformats;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/CompositeIndexValues.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/CompositeIndexValues.java
new file mode 100644
index 0000000000000..3c5c6b71849f2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/CompositeIndexValues.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.index;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * Interface for composite index values
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface CompositeIndexValues {
+    CompositeIndexValues getValues();
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/StarTreeValues.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/StarTreeValues.java
new file mode 100644
index 0000000000000..a34bbbe9ee738
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/StarTreeValues.java
@@ -0,0 +1,274 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.index;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.SegmentReadState;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.store.IndexInput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.CompositeIndexMetadata;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.ReadDimension;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.meta.StarTreeMetadata;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeFactory;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNode;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Supplier;
+
+import static org.opensearch.index.codec.composite.composite99.Composite99DocValuesReader.getSortedNumericDocValues;
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.SEGMENT_DOCS_COUNT;
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.STAR_TREE_DOCS_COUNT;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeDimensionsDocValues;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
+
+/**
+ * Concrete class that holds the star tree associated values from the segment
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeValues implements CompositeIndexValues {
+
+    /**
+     * Representing the star tree field configuration.
+     */
+    private final StarTreeField starTreeField;
+
+    /**
+     * The root node of the star tree.
+     */
+    private final StarTreeNode root;
+
+    /**
+     * A map containing suppliers for DocIdSetIterators for dimensions.
+     */
+    private final Map<String, Supplier<DocIdSetIterator>> dimensionDocValuesIteratorMap;
+
+    /**
+     * A map containing suppliers for DocIdSetIterators for metrics.
+     */
+    private final Map<String, Supplier<DocIdSetIterator>> metricDocValuesIteratorMap;
+
+    /**
+     * A map containing attributes associated with the star tree values.
+     */
+    private final Map<String, String> attributes;
+
+    /**
+     * A metadata for the star-tree
+     */
+    private final StarTreeMetadata starTreeMetadata;
+
+    /**
+     * Constructs a new StarTreeValues object with the provided parameters.
+     * Used for testing.
+     *
+     * @param starTreeField                 The StarTreeField object representing the star tree field configuration.
+     * @param root                          The root node of the star tree.
+     * @param dimensionDocValuesIteratorMap A map containing suppliers for DocIdSetIterators for dimensions.
+     * @param metricDocValuesIteratorMap    A map containing suppliers for DocIdSetIterators for metrics.
+     * @param attributes                    A map containing attributes associated with the star tree values.
+     */
+    public StarTreeValues(
+        StarTreeField starTreeField,
+        StarTreeNode root,
+        Map<String, Supplier<DocIdSetIterator>> dimensionDocValuesIteratorMap,
+        Map<String, Supplier<DocIdSetIterator>> metricDocValuesIteratorMap,
+        Map<String, String> attributes,
+        StarTreeMetadata compositeIndexMetadata
+    ) {
+        this.starTreeField = starTreeField;
+        this.root = root;
+        this.dimensionDocValuesIteratorMap = dimensionDocValuesIteratorMap;
+        this.metricDocValuesIteratorMap = metricDocValuesIteratorMap;
+        this.attributes = attributes;
+        this.starTreeMetadata = compositeIndexMetadata;
+    }
+
+    /**
+     * Constructs a new StarTreeValues object by reading the data from the segment
+     *
+     * @param compositeIndexMetadata     The CompositeIndexMetadata object containing metadata for the composite index.
+     * @param compositeIndexDataIn       The IndexInput object for reading the composite index data.
+     * @param compositeDocValuesProducer The DocValuesProducer object for producing doc values.
+     * @param readState                  The SegmentReadState object representing the state of the segment being read.
+     * @throws IOException If an I/O error occurs while reading the data.
+     */
+    public StarTreeValues(
+        CompositeIndexMetadata compositeIndexMetadata,
+        IndexInput compositeIndexDataIn,
+        DocValuesProducer compositeDocValuesProducer,
+        SegmentReadState readState
+    ) throws IOException {
+
+        starTreeMetadata = (StarTreeMetadata) compositeIndexMetadata;
+
+        // build skip star node dimensions
+        Set<String> skipStarNodeCreationInDims = starTreeMetadata.getSkipStarNodeCreationInDims();
+
+        // build dimensions
+        List<Dimension> readDimensions = new ArrayList<>();
+        for (String dimension : starTreeMetadata.getDimensionFields()) {
+            readDimensions.add(new ReadDimension(dimension));
+        }
+
+        // star-tree field
+        this.starTreeField = new StarTreeField(
+            starTreeMetadata.getCompositeFieldName(),
+            readDimensions,
+            starTreeMetadata.getMetrics(),
+            new StarTreeFieldConfiguration(
+                starTreeMetadata.getMaxLeafDocs(),
+                skipStarNodeCreationInDims,
+                starTreeMetadata.getStarTreeBuildMode()
+            )
+        );
+
+        this.root = StarTreeFactory.createStarTree(compositeIndexDataIn, starTreeMetadata);
+
+        // get doc id set iterators for metrics and dimensions
+        dimensionDocValuesIteratorMap = new LinkedHashMap<>();
+        metricDocValuesIteratorMap = new LinkedHashMap<>();
+
+        // get doc id set iterators for dimensions
+        for (String dimension : starTreeMetadata.getDimensionFields()) {
+            dimensionDocValuesIteratorMap.put(dimension, () -> {
+                try {
+                    SortedNumericDocValues dimensionSortedNumericDocValues = null;
+                    if (readState != null) {
+                        FieldInfo dimensionfieldInfo = readState.fieldInfos.fieldInfo(
+                            fullyQualifiedFieldNameForStarTreeDimensionsDocValues(starTreeField.getName(), dimension)
+                        );
+                        if (dimensionfieldInfo != null) {
+                            dimensionSortedNumericDocValues = compositeDocValuesProducer.getSortedNumeric(dimensionfieldInfo);
+                        }
+                    }
+                    return getSortedNumericDocValues(dimensionSortedNumericDocValues);
+                } catch (IOException e) {
+                    throw new RuntimeException("Error loading dimension DocIdSetIterator", e);
+                }
+            });
+        }
+
+        // get doc id set iterators for metrics
+        for (Metric metric : starTreeMetadata.getMetrics()) {
+            for (MetricStat metricStat : metric.getBaseMetrics()) {
+                String metricFullName = fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                    starTreeField.getName(),
+                    metric.getField(),
+                    metricStat.getTypeName()
+                );
+                metricDocValuesIteratorMap.put(metricFullName, () -> {
+                    try {
+                        SortedNumericDocValues metricSortedNumericDocValues = null;
+                        if (readState != null) {
+                            FieldInfo metricFieldInfo = readState.fieldInfos.fieldInfo(metricFullName);
+                            if (metricFieldInfo != null) {
+                                metricSortedNumericDocValues = compositeDocValuesProducer.getSortedNumeric(metricFieldInfo);
+                            }
+                        }
+                        return getSortedNumericDocValues(metricSortedNumericDocValues);
+                    } catch (IOException e) {
+                        throw new RuntimeException("Error loading metric DocIdSetIterator", e);
+                    }
+                });
+            }
+        }
+
+        // create star-tree attributes map
+
+        // Create an unmodifiable view of the map
+        attributes = Map.of(
+            SEGMENT_DOCS_COUNT,
+            String.valueOf(starTreeMetadata.getSegmentAggregatedDocCount()),
+            STAR_TREE_DOCS_COUNT,
+            String.valueOf(starTreeMetadata.getStarTreeDocCount())
+        );
+
+    }
+
+    @Override
+    public CompositeIndexValues getValues() {
+        return this;
+    }
+
+    /**
+     * Returns an object representing the star tree field configuration.
+     *
+     * @return The StarTreeField object representing the star tree field configuration.
+     */
+    public StarTreeField getStarTreeField() {
+        return starTreeField;
+    }
+
+    /**
+     * Returns the root node of the star tree.
+     *
+     * @return The root node of the star tree.
+     */
+    public StarTreeNode getRoot() {
+        return root;
+    }
+
+    /**
+     * Returns the map containing attributes associated with the star tree values.
+     *
+     * @return The map containing attributes associated with the star tree values.
+     */
+    public Map<String, String> getAttributes() {
+        return attributes;
+    }
+
+    /**
+     * Returns the DocIdSetIterator for the specified dimension.
+     *
+     * @param dimension The name of the dimension.
+     * @return The DocIdSetIterator for the specified dimension.
+     */
+    public DocIdSetIterator getDimensionDocIdSetIterator(String dimension) {
+
+        if (dimensionDocValuesIteratorMap.containsKey(dimension)) {
+            return dimensionDocValuesIteratorMap.get(dimension).get();
+        }
+
+        throw new IllegalArgumentException("dimension [" + dimension + "] does not exist in the segment.");
+    }
+
+    /**
+     * Returns the DocIdSetIterator for the specified fully qualified metric name.
+     *
+     * @param fullyQualifiedMetricName The fully qualified name of the metric.
+     * @return The DocIdSetIterator for the specified fully qualified metric name.
+     */
+    public DocIdSetIterator getMetricDocIdSetIterator(String fullyQualifiedMetricName) {
+
+        if (metricDocValuesIteratorMap.containsKey(fullyQualifiedMetricName)) {
+            return metricDocValuesIteratorMap.get(fullyQualifiedMetricName).get();
+        }
+
+        throw new IllegalArgumentException("metric [" + fullyQualifiedMetricName + "] does not exist in the segment.");
+    }
+
+    public int getStarTreeDocumentCount() {
+        return starTreeMetadata.getStarTreeDocCount();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/package-info.java
new file mode 100644
index 0000000000000..06029042ab407
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/index/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ *  Classes responsible for handling all star tree values from the segment
+ */
+package org.opensearch.index.compositeindex.datacube.startree.index;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/InMemoryTreeNode.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/InMemoryTreeNode.java
new file mode 100644
index 0000000000000..c3bf4475f75c2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/InMemoryTreeNode.java
@@ -0,0 +1,170 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.node;
+
+import org.opensearch.common.SetOnce;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.ALL;
+
+/**
+ * Represents a node in a tree data structure, specifically designed for a star-tree implementation.
+ * A star-tree node will represent both star and non-star nodes.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class InMemoryTreeNode {
+
+    public InMemoryTreeNode() {
+        this.dimensionId = ALL;
+        this.startDocId = ALL;
+        this.endDocId = ALL;
+        this.nodeType = (byte) 0;
+        this.dimensionValue = ALL;
+        this.childStarNode = new SetOnce<>();
+        this.children = new LinkedHashMap<>();
+    }
+
+    public InMemoryTreeNode(int dimensionId, int startDocId, int endDocId, byte nodeType, long dimensionValue) {
+        this.dimensionId = dimensionId;
+        this.startDocId = startDocId;
+        this.endDocId = endDocId;
+        this.nodeType = nodeType;
+        this.dimensionValue = dimensionValue;
+        this.childStarNode = new SetOnce<>();
+        this.children = new LinkedHashMap<>();
+    }
+
+    /**
+     * The dimension id for the dimension (field) associated with this star-tree node.
+     */
+    private final int dimensionId;
+
+    /**
+     * The starting document id (inclusive) associated with this star-tree node.
+     */
+    private final int startDocId;
+
+    /**
+     * The ending document id (exclusive) associated with this star-tree node.
+     */
+    private final int endDocId;
+
+    /**
+     * The aggregated document id associated with this star-tree node.
+     */
+    private int aggregatedDocId = ALL;
+
+    /**
+     * The child dimension identifier associated with this star-tree node.
+     */
+    private int childDimensionId = ALL;
+
+    /**
+     * The value of the dimension associated with this star-tree node.
+     */
+    private final long dimensionValue;
+
+    /**
+     * A byte indicating whether the node is star node, null node or default node (with dimension value present).
+     */
+    private byte nodeType;
+
+    /**
+     * A map containing the child nodes of this star-tree node, keyed by their dimension id.
+     */
+    private final Map<Long, InMemoryTreeNode> children;
+
+    /**
+     * A map containing the child star node of this star-tree node.
+     */
+    private final SetOnce<InMemoryTreeNode> childStarNode;
+
+    public long getDimensionValue() {
+        return dimensionValue;
+    }
+
+    public byte getNodeType() {
+        return nodeType;
+    }
+
+    public boolean hasChild() {
+        return !(this.children.isEmpty() && this.childStarNode.get() == null);
+    }
+
+    public int getDimensionId() {
+        return dimensionId;
+    }
+
+    public int getStartDocId() {
+        return startDocId;
+    }
+
+    public int getEndDocId() {
+        return endDocId;
+    }
+
+    public void setNodeType(byte nodeType) {
+        this.nodeType = nodeType;
+    }
+
+    public void addChildNode(InMemoryTreeNode childNode, Long dimensionValue) {
+        if (childNode.getNodeType() == StarTreeNodeType.STAR.getValue()) {
+            this.childStarNode.set(childNode);
+        } else {
+            this.children.put(dimensionValue, childNode);
+            assert assertStarTreeChildOrder(childNode);
+        }
+    }
+
+    public Map<Long, InMemoryTreeNode> getChildren() {
+        return children;
+    }
+
+    public InMemoryTreeNode getChildStarNode() {
+        return childStarNode.get();
+    }
+
+    public int getChildDimensionId() {
+        return childDimensionId;
+    }
+
+    public void setChildDimensionId(int childDimensionId) {
+        this.childDimensionId = childDimensionId;
+    }
+
+    public int getAggregatedDocId() {
+        return aggregatedDocId;
+    }
+
+    public void setAggregatedDocId(int aggregatedDocId) {
+        this.aggregatedDocId = aggregatedDocId;
+    }
+
+    private boolean assertStarTreeChildOrder(InMemoryTreeNode childNode) {
+        if (childNode.nodeType != StarTreeNodeType.NULL.getValue() && !this.children.isEmpty()) {
+            InMemoryTreeNode lastNode = null;
+            for (Map.Entry<Long, InMemoryTreeNode> entry : this.children.entrySet()) {
+                lastNode = entry.getValue();
+            }
+            assert lastNode.dimensionValue <= childNode.dimensionValue;
+        } else if (childNode.nodeType == StarTreeNodeType.NULL.getValue() && !this.children.isEmpty()) {
+            InMemoryTreeNode lastNode = null;
+            for (Map.Entry<Long, InMemoryTreeNode> entry : this.children.entrySet()) {
+                lastNode = entry.getValue();
+            }
+            assert lastNode.nodeType == StarTreeNodeType.NULL.getValue();
+        }
+        return true;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeFactory.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeFactory.java
new file mode 100644
index 0000000000000..79b5947d4f00a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeFactory.java
@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.node;
+
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.RandomAccessInput;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.meta.StarTreeMetadata;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.node.FixedLengthStarTreeNode;
+
+import java.io.IOException;
+
+/**
+ * A factory class for creating off-heap implementations of star-tree nodes.
+ *
+ * <p>This class provides a static factory method to create instances of {@link StarTreeNode}
+ * from an {@link IndexInput} and {@link StarTreeMetadata}. The implementation uses an
+ * off-heap data structure to store and access the star-tree data efficiently using random access.
+ *
+ * @opensearch.experimental
+ */
+public class StarTreeFactory {
+
+    /**
+     * Creates a new instance of {@link StarTreeNode} from the provided {@link IndexInput} and
+     * {@link StarTreeMetadata}.
+     *
+     * @param data The {@link IndexInput} containing the star-tree data.
+     * @param starTreeMetadata The {@link StarTreeMetadata} containing metadata about the star-tree.
+     * @return A new instance of {@link StarTreeNode} representing the root of the star-tree.
+     * @throws IOException If an error occurs while reading the star-tree data.
+     */
+    public static StarTreeNode createStarTree(IndexInput data, StarTreeMetadata starTreeMetadata) throws IOException {
+        RandomAccessInput in = data.randomAccessSlice(0, starTreeMetadata.getDataLength());
+        return new FixedLengthStarTreeNode(in, 0);
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNode.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNode.java
new file mode 100644
index 0000000000000..fce3e30e9ebf6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNode.java
@@ -0,0 +1,127 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.node;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+/**
+ * Interface that represents star tree node
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface StarTreeNode {
+
+    /**
+     * Returns the dimension ID of the current star-tree node.
+     *
+     * @return the dimension ID
+     * @throws IOException if an I/O error occurs while reading the dimension ID
+     */
+    int getDimensionId() throws IOException;
+
+    /**
+     * Returns the dimension value of the current star-tree node.
+     *
+     * @return the dimension value
+     * @throws IOException if an I/O error occurs while reading the dimension value
+     */
+    long getDimensionValue() throws IOException;
+
+    /**
+     * Returns the dimension ID of the child star-tree node.
+     *
+     * @return the child dimension ID
+     * @throws IOException if an I/O error occurs while reading the child dimension ID
+     */
+    int getChildDimensionId() throws IOException;
+
+    /**
+     * Returns the start document ID of the current star-tree node.
+     *
+     * @return the start document ID
+     * @throws IOException if an I/O error occurs while reading the start document ID
+     */
+    int getStartDocId() throws IOException;
+
+    /**
+     * Returns the end document ID of the current star-tree node.
+     *
+     * @return the end document ID
+     * @throws IOException if an I/O error occurs while reading the end document ID
+     */
+    int getEndDocId() throws IOException;
+
+    /**
+     * Returns the aggregated document ID of the current star-tree node.
+     *
+     * @return the aggregated document ID
+     * @throws IOException if an I/O error occurs while reading the aggregated document ID
+     */
+    int getAggregatedDocId() throws IOException;
+
+    /**
+     * Returns the number of children of the current star-tree node.
+     *
+     * @return the number of children
+     * @throws IOException if an I/O error occurs while reading the number of children
+     */
+    int getNumChildren() throws IOException;
+
+    /**
+     * Checks if the current node is a leaf star-tree node.
+     *
+     * @return true if the node is a leaf node, false otherwise
+     */
+    boolean isLeaf();
+
+    /**
+     * Determines the type of the current node in the Star Tree index structure.
+     *
+     * <p>The node type can be one of the following:
+     * <ul>
+     *     <li>Star Node: Represented by the value -2.
+     *     <li>Null Node: Represented by the value -1.
+     *     <li>Default Node: Represented by the value 0.
+     * </ul>
+     * @see StarTreeNodeType
+     *
+     * @return The type of the current node, represented by the corresponding integer value (-2, -1, or 0).
+     * @throws IOException if an I/O error occurs while reading the node type
+     */
+    byte getStarTreeNodeType() throws IOException;
+
+    /**
+     * Returns the child node for the given dimension value in the star-tree.
+     *
+     * @param dimensionValue the dimension value
+     * @return the child node for the given dimension value or null if child is not present
+     * @throws IOException if an I/O error occurs while retrieving the child node
+     */
+    StarTreeNode getChildForDimensionValue(Long dimensionValue) throws IOException;
+
+    /**
+     * Returns the child star node for a node in the star-tree.
+     *
+     * @return the child node for the star node if star child node is not present
+     * @throws IOException if an I/O error occurs while retrieving the child node
+     */
+    StarTreeNode getChildStarNode() throws IOException;
+
+    /**
+     * Returns an iterator over the children of the current star-tree node.
+     *
+     * @return an iterator over the children
+     * @throws IOException if an I/O error occurs while retrieving the children iterator
+     */
+    Iterator<? extends StarTreeNode> getChildrenIterator() throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNodeType.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNodeType.java
new file mode 100644
index 0000000000000..9d7a31bda4deb
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNodeType.java
@@ -0,0 +1,103 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.node;
+
+/**
+ * Represents the different types of nodes in a Star Tree data structure.
+ *
+ * <p>
+ * In order to handle different node types, we use a byte value to represent the node type.
+ * This enum provides a convenient way to map byte values to their corresponding node types.
+ *
+ * <p>
+ * Star and Null Nodes are represented as special cases. Default is the general case.
+ * Star and null nodes are represented with negative ordinal values to ensure that they are
+ * sorted before the default nodes, which are sorted based on their dimension values.
+ *
+ * <p>
+ * The node type can be one of the following:
+ * <ul>
+ *     <li>Star Node: Represented by the value -1. A star node is a special node that represents
+ *     all possible values for a dimension.</li>
+ *     <li>Null Node: Represented by the value 0. A null node indicates the absence of any value
+ *     for a dimension.</li>
+ *     <li>Default Node: Represented by the value -1. A default node represents a node with an
+ *     actual dimension value.</li>
+ * </ul>
+ *
+ * By default, we want to consider nodes as default node.
+ *
+ * @opensearch.experimental
+ * @see StarTreeNode
+ */
+public enum StarTreeNodeType {
+
+    /**
+     * Represents a star node type.
+     *
+     */
+    STAR("star", (byte) -1),
+
+    /**
+     * Represents a default node type.
+     */
+    DEFAULT("default", (byte) 0),
+
+    /**
+     * Represents a null node type.
+     */
+    NULL("null", (byte) 1);
+
+    private final String name;
+    private final byte value;
+
+    /**
+     * Constructs a new StarTreeNodeType with the given name and value.
+     *
+     * @param name  the name of the node type
+     * @param value the value associated with the node type
+     */
+    StarTreeNodeType(String name, byte value) {
+        this.name = name;
+        this.value = value;
+    }
+
+    /**
+     * Returns the name of the node type.
+     *
+     * @return the name of the node type
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Returns the value associated with the node type.
+     *
+     * @return the value associated with the node type
+     */
+    public byte getValue() {
+        return value;
+    }
+
+    /**
+     * Returns the StarTreeNodeType enum constant with the specified value.
+     *
+     * @param value the value of the enum constant to return
+     * @return the enum constant with the specified value, or null if no such constant exists
+     */
+    public static StarTreeNodeType fromValue(byte value) {
+        for (StarTreeNodeType nodeType : StarTreeNodeType.values()) {
+            if (nodeType.getValue() == value) {
+                return nodeType;
+            }
+        }
+        throw new IllegalStateException("Unrecognized value byte to determine star-tree node type: [" + value + "]");
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/package-info.java
new file mode 100644
index 0000000000000..19d12bc6318d7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/node/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Holds classes associated with star tree node
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.node;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/package-info.java
new file mode 100644
index 0000000000000..6d6cb420f4a9e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/package-info.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+/**
+ * Core classes for handling star tree index.
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIterator.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIterator.java
new file mode 100644
index 0000000000000..061841d3e140a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIterator.java
@@ -0,0 +1,104 @@
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+
+/**
+ * Coordinates the reading of documents across multiple DocIdSetIterators.
+ * It encapsulates a single DocIdSetIterator and maintains the latest document ID and its associated value.
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class SequentialDocValuesIterator {
+
+    /**
+     * The doc id set iterator associated for each field.
+     */
+    private final DocIdSetIterator docIdSetIterator;
+
+    /**
+     * The value associated with the latest document.
+     */
+    private Long docValue;
+
+    /**
+     * The id of the latest document.
+     */
+    private int docId = -1;
+
+    /**
+     * Constructs a new SequentialDocValuesIterator instance with the given DocIdSetIterator.
+     *
+     * @param docIdSetIterator the DocIdSetIterator to be associated with this instance
+     */
+    public SequentialDocValuesIterator(DocIdSetIterator docIdSetIterator) {
+        this.docIdSetIterator = docIdSetIterator;
+    }
+
+    /**
+     * Returns the id of the latest document.
+     *
+     * @return the id of the latest document
+     */
+    public int getDocId() {
+        return docId;
+    }
+
+    /**
+     * Sets the id of the latest document.
+     *
+     * @param docId the ID of the latest document
+     */
+    private void setDocId(int docId) {
+        this.docId = docId;
+    }
+
+    /**
+     * Returns the DocIdSetIterator associated with this instance.
+     *
+     * @return the DocIdSetIterator associated with this instance
+     */
+    public DocIdSetIterator getDocIdSetIterator() {
+        return docIdSetIterator;
+    }
+
+    public int nextDoc(int currentDocId) throws IOException {
+        // if doc id stored is less than or equal to the requested doc id , return the stored doc id
+        if (docId >= currentDocId) {
+            return docId;
+        }
+        setDocId(this.docIdSetIterator.nextDoc());
+        return docId;
+    }
+
+    public Long value(int currentDocId) throws IOException {
+        if (this.getDocIdSetIterator() instanceof SortedNumericDocValues) {
+            SortedNumericDocValues sortedNumericDocValues = (SortedNumericDocValues) this.getDocIdSetIterator();
+            if (currentDocId < 0) {
+                throw new IllegalStateException("invalid doc id to fetch the next value");
+            }
+            if (currentDocId == DocIdSetIterator.NO_MORE_DOCS) {
+                throw new IllegalStateException("DocValuesIterator is already exhausted");
+            }
+            if (docId == DocIdSetIterator.NO_MORE_DOCS || docId != currentDocId) {
+                return null;
+            }
+            return sortedNumericDocValues.nextValue();
+
+        } else {
+            throw new IllegalStateException("Unsupported Iterator requested for SequentialDocValuesIterator");
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentBitSetUtil.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentBitSetUtil.java
new file mode 100644
index 0000000000000..a508e497adcdf
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentBitSetUtil.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.RandomAccessInput;
+import org.opensearch.common.util.ByteArrayBackedBitset;
+
+import java.io.IOException;
+import java.util.function.Function;
+
+/**
+ * Helper class to read/write bitset for null values and identity values.
+ */
+public class StarTreeDocumentBitSetUtil {
+    /**
+     * Write bitset for null values.
+     *
+     * @param array array of objects
+     * @param output output stream
+     * @return number of bytes written
+     * @throws IOException if an I/O error occurs while writing to the output stream
+     */
+    public static int writeBitSet(Object[] array, IndexOutput output) throws IOException {
+        ByteArrayBackedBitset bitset = new ByteArrayBackedBitset(getLength(array));
+        for (int i = 0; i < array.length; i++) {
+            if (array[i] == null) {
+                bitset.set(i);
+            }
+        }
+        return bitset.write(output);
+    }
+
+    /**
+     * Set identity values based on bitset.
+     */
+    public static int readBitSet(RandomAccessInput input, long offset, Object[] array, Function<Integer, Object> identityValueSupplier)
+        throws IOException {
+        ByteArrayBackedBitset bitset = new ByteArrayBackedBitset(input, offset, getLength(array));
+        for (int i = 0; i < array.length; i++) {
+            if (bitset.get(i)) {
+                array[i] = identityValueSupplier.apply(i);
+            }
+        }
+        return bitset.getCurrBytesRead();
+    }
+
+    private static int getLength(Object[] array) {
+        return (array.length / 8) + (array.length % 8 == 0 ? 0 : 1);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentsSorter.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentsSorter.java
new file mode 100644
index 0000000000000..7b1c63bc611ee
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentsSorter.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.util.IntroSorter;
+
+import java.util.Objects;
+import java.util.function.IntFunction;
+
+/**
+ * Utility class for building star tree
+ */
+public class StarTreeDocumentsSorter {
+    /**
+     * Sort documents based on the dimension values off heap using intro sorter.
+     */
+    public static void sort(
+        final int[] sortedDocIds,
+        final int dimensionId,
+        final int numDocs,
+        final IntFunction<Long[]> dimensionsReader
+    ) {
+        new IntroSorter() {
+            private Long[] dimensions;
+
+            @Override
+            protected void swap(int i, int j) {
+                int temp = sortedDocIds[i];
+                sortedDocIds[i] = sortedDocIds[j];
+                sortedDocIds[j] = temp;
+            }
+
+            @Override
+            protected void setPivot(int i) {
+                dimensions = dimensionsReader.apply(i);
+            }
+
+            @Override
+            protected int comparePivot(int j) {
+                Long[] currentDimensions = dimensionsReader.apply(j);
+                for (int i = dimensionId + 1; i < dimensions.length; i++) {
+                    Long dimension = currentDimensions[i];
+                    if (!Objects.equals(dimensions[i], dimension)) {
+                        if (dimensions[i] == null && dimension == null) {
+                            return 0;
+                        }
+                        if (dimension == null) {
+                            return -1;
+                        }
+                        if (dimensions[i] == null) {
+                            return 1;
+                        }
+                        return Long.compare(dimensions[i], dimension);
+                    }
+                }
+                return 0;
+            }
+        }.sort(0, numDocs);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeUtils.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeUtils.java
new file mode 100644
index 0000000000000..2aae0d4ca7e29
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeUtils.java
@@ -0,0 +1,145 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Util class for building star tree
+ *
+ * @opensearch.experimental
+ */
+public class StarTreeUtils {
+
+    private StarTreeUtils() {}
+
+    public static final int ALL = -1;
+
+    /**
+     * The suffix appended to dimension field names in the Star Tree index.
+     */
+    public static final String DIMENSION_SUFFIX = "dim";
+
+    /**
+     * The suffix appended to metric field names in the Star Tree index.
+     */
+    public static final String METRIC_SUFFIX = "metric";
+
+    /**
+     * Returns the full field name for a dimension in the star-tree index.
+     *
+     * @param starTreeFieldName star-tree field name
+     * @param dimensionName     name of the dimension
+     * @return full field name for the dimension in the star-tree index
+     */
+    public static String fullyQualifiedFieldNameForStarTreeDimensionsDocValues(String starTreeFieldName, String dimensionName) {
+        return starTreeFieldName + "_" + dimensionName + "_" + DIMENSION_SUFFIX;
+    }
+
+    /**
+     * Returns the full field name for a metric in the star-tree index.
+     *
+     * @param starTreeFieldName star-tree field name
+     * @param fieldName         name of the metric field
+     * @param metricName        name of the metric
+     * @return full field name for the metric in the star-tree index
+     */
+    public static String fullyQualifiedFieldNameForStarTreeMetricsDocValues(String starTreeFieldName, String fieldName, String metricName) {
+        return MetricAggregatorInfo.toFieldName(starTreeFieldName, fieldName, metricName) + "_" + METRIC_SUFFIX;
+    }
+
+    /**
+     * Get field infos from field names
+     *
+     * @param fields field names
+     * @return field infos
+     */
+    public static FieldInfo[] getFieldInfoList(List<String> fields) {
+        FieldInfo[] fieldInfoList = new FieldInfo[fields.size()];
+
+        // field number is not really used. We depend on unique field names to get the desired iterator
+        int fieldNumber = 0;
+
+        for (String fieldName : fields) {
+            fieldInfoList[fieldNumber] = getFieldInfo(fieldName, DocValuesType.SORTED_NUMERIC, fieldNumber);
+            fieldNumber++;
+        }
+        return fieldInfoList;
+    }
+
+    /**
+     * Get new field info instance for a given field name and field number
+     * @param fieldName name of the field
+     * @param docValuesType doc value type of the field
+     * @param fieldNumber number of the field
+     * @return new field info instance
+     */
+    public static FieldInfo getFieldInfo(String fieldName, DocValuesType docValuesType, int fieldNumber) {
+        return new FieldInfo(
+            fieldName,
+            fieldNumber,
+            false,
+            false,
+            true,
+            IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+            docValuesType,
+            -1,
+            Collections.emptyMap(),
+            0,
+            0,
+            0,
+            0,
+            VectorEncoding.FLOAT32,
+            VectorSimilarityFunction.EUCLIDEAN,
+            false,
+            false
+        );
+    }
+
+    /**
+     * Get new field info instance for a given field name and field number.
+     * It's a dummy field info to fetch doc id set iterators based on field name.
+     * <p>
+     * Actual field infos uses fieldNumberAcrossStarTrees parameter to achieve consistent
+     * and unique field numbers across fields and across multiple star trees
+     *
+     * @param fieldName name of the field
+     * @param docValuesType doc value type of the field
+     * @return new field info instance
+     */
+    public static FieldInfo getFieldInfo(String fieldName, DocValuesType docValuesType) {
+        return new FieldInfo(
+            fieldName,
+            0,
+            false,
+            false,
+            true,
+            IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+            docValuesType,
+            -1,
+            Collections.emptyMap(),
+            0,
+            0,
+            0,
+            0,
+            VectorEncoding.FLOAT32,
+            VectorSimilarityFunction.EUCLIDEAN,
+            false,
+            false
+        );
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/package-info.java
new file mode 100644
index 0000000000000..c7e8b04d42178
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/datacube/startree/utils/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Utility to support Composite Index Star Tree
+ *
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex.datacube.startree.utils;
diff --git a/server/src/main/java/org/opensearch/index/compositeindex/package-info.java b/server/src/main/java/org/opensearch/index/compositeindex/package-info.java
new file mode 100644
index 0000000000000..59f18efec26b1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/compositeindex/package-info.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Core classes for handling composite indices.
+ * @opensearch.experimental
+ */
+package org.opensearch.index.compositeindex;
diff --git a/server/src/main/java/org/opensearch/index/engine/SegmentsStats.java b/server/src/main/java/org/opensearch/index/engine/SegmentsStats.java
index 34aecfc62b8b2..8a5a4a5a94ce6 100644
--- a/server/src/main/java/org/opensearch/index/engine/SegmentsStats.java
+++ b/server/src/main/java/org/opensearch/index/engine/SegmentsStats.java
@@ -41,6 +41,7 @@
 import org.opensearch.core.xcontent.ToXContentFragment;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.ReplicationStats;
+import org.opensearch.index.codec.composite.composite99.Composite99DocValuesFormat;
 import org.opensearch.index.codec.fuzzy.FuzzyFilterPostingsFormat;
 import org.opensearch.index.remote.RemoteSegmentStats;
 
@@ -97,6 +98,10 @@ public class SegmentsStats implements Writeable, ToXContentFragment {
         Map.entry("tvd", "Term Vector Documents"),
         Map.entry("tvf", "Term Vector Fields"),
         Map.entry("liv", "Live Documents"),
+        Map.entry(Composite99DocValuesFormat.DATA_EXTENSION, "Composite Index"),
+        Map.entry(Composite99DocValuesFormat.META_EXTENSION, "Composite Index"),
+        Map.entry(Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION, "Composite Index DocValues"),
+        Map.entry(Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION, "Composite Index DocValues"),
         Map.entry(FuzzyFilterPostingsFormat.FUZZY_FILTER_FILE_EXTENSION, "Fuzzy Filter")
     );
 
diff --git a/server/src/main/java/org/opensearch/index/engine/TranslogLeafReader.java b/server/src/main/java/org/opensearch/index/engine/TranslogLeafReader.java
index dea389bb6a0ff..94b8c6181de4e 100644
--- a/server/src/main/java/org/opensearch/index/engine/TranslogLeafReader.java
+++ b/server/src/main/java/org/opensearch/index/engine/TranslogLeafReader.java
@@ -264,13 +264,13 @@ public CacheHelper getReaderCacheHelper() {
     }
 
     @Override
-    public FloatVectorValues getFloatVectorValues(String field) throws IOException {
-        return getFloatVectorValues(field);
+    public FloatVectorValues getFloatVectorValues(String field) {
+        throw new UnsupportedOperationException();
     }
 
     @Override
-    public ByteVectorValues getByteVectorValues(String field) throws IOException {
-        return getByteVectorValues(field);
+    public ByteVectorValues getByteVectorValues(String field) {
+        throw new UnsupportedOperationException();
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/index/fielddata/fieldcomparator/UnsignedLongValuesComparatorSource.java b/server/src/main/java/org/opensearch/index/fielddata/fieldcomparator/UnsignedLongValuesComparatorSource.java
index 3714561b63e44..9db5817450cd0 100644
--- a/server/src/main/java/org/opensearch/index/fielddata/fieldcomparator/UnsignedLongValuesComparatorSource.java
+++ b/server/src/main/java/org/opensearch/index/fielddata/fieldcomparator/UnsignedLongValuesComparatorSource.java
@@ -81,9 +81,13 @@ public Object missingObject(Object missingValue, boolean reversed) {
             return min ? Numbers.MIN_UNSIGNED_LONG_VALUE : Numbers.MAX_UNSIGNED_LONG_VALUE;
         } else {
             if (missingValue instanceof Number) {
-                return ((Number) missingValue);
+                return Numbers.toUnsignedLongExact((Number) missingValue);
             } else {
-                return new BigInteger(missingValue.toString());
+                BigInteger missing = new BigInteger(missingValue.toString());
+                if (missing.signum() < 0) {
+                    throw new IllegalArgumentException("Value [" + missingValue + "] is out of range for an unsigned long");
+                }
+                return missing;
             }
         }
     }
diff --git a/server/src/main/java/org/opensearch/index/get/GetResult.java b/server/src/main/java/org/opensearch/index/get/GetResult.java
index 5f5937e58bc5c..b390958bac19c 100644
--- a/server/src/main/java/org/opensearch/index/get/GetResult.java
+++ b/server/src/main/java/org/opensearch/index/get/GetResult.java
@@ -38,6 +38,7 @@
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.document.DocumentField;
 import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.core.common.ParsingException;
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -57,6 +58,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 
@@ -411,6 +413,14 @@ public static GetResult fromXContentEmbedded(XContentParser parser, String index
                 }
             }
         }
+
+        if (found == null) {
+            throw new ParsingException(
+                parser.getTokenLocation(),
+                String.format(Locale.ROOT, "Missing required field [%s]", GetResult.FOUND)
+            );
+        }
+
         return new GetResult(index, id, seqNo, primaryTerm, version, found, source, documentFields, metaFields);
     }
 
diff --git a/server/src/main/java/org/opensearch/index/mapper/CompositeDataCubeFieldType.java b/server/src/main/java/org/opensearch/index/mapper/CompositeDataCubeFieldType.java
new file mode 100644
index 0000000000000..baf6442f0c08c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/CompositeDataCubeFieldType.java
@@ -0,0 +1,56 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Base class for multi field data cube fields
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public abstract class CompositeDataCubeFieldType extends CompositeMappedFieldType {
+    public static final String NAME = "name";
+    public static final String TYPE = "type";
+    private final List<Dimension> dimensions;
+    private final List<Metric> metrics;
+
+    public CompositeDataCubeFieldType(String name, List<Dimension> dims, List<Metric> metrics, CompositeFieldType type) {
+        super(name, getFields(dims, metrics), type);
+        this.dimensions = dims;
+        this.metrics = metrics;
+    }
+
+    private static List<String> getFields(List<Dimension> dims, List<Metric> metrics) {
+        Set<String> fields = new HashSet<>();
+        for (Dimension dim : dims) {
+            fields.add(dim.getField());
+        }
+        for (Metric metric : metrics) {
+            fields.add(metric.getField());
+        }
+        return new ArrayList<>(fields);
+    }
+
+    public List<Dimension> getDimensions() {
+        return dimensions;
+    }
+
+    public List<Metric> getMetrics() {
+        return metrics;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/CompositeMappedFieldType.java b/server/src/main/java/org/opensearch/index/mapper/CompositeMappedFieldType.java
new file mode 100644
index 0000000000000..7239ddfb26c0d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/CompositeMappedFieldType.java
@@ -0,0 +1,82 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Base class for composite field types
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public abstract class CompositeMappedFieldType extends MappedFieldType {
+    private final List<String> fields;
+    private final CompositeFieldType type;
+
+    public CompositeMappedFieldType(
+        String name,
+        boolean isIndexed,
+        boolean isStored,
+        boolean hasDocValues,
+        TextSearchInfo textSearchInfo,
+        Map<String, String> meta,
+        List<String> fields,
+        CompositeFieldType type
+    ) {
+        super(name, isIndexed, isStored, hasDocValues, textSearchInfo, meta);
+        this.fields = fields;
+        this.type = type;
+    }
+
+    public CompositeMappedFieldType(String name, List<String> fields, CompositeFieldType type) {
+        this(name, false, false, false, TextSearchInfo.NONE, Collections.emptyMap(), fields, type);
+    }
+
+    /**
+     * Supported composite field types
+     *
+     * @opensearch.experimental
+     */
+    @ExperimentalApi
+    public enum CompositeFieldType {
+        STAR_TREE("star_tree");
+
+        private final String name;
+
+        CompositeFieldType(String name) {
+            this.name = name;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public static CompositeFieldType fromName(String name) {
+            for (CompositeFieldType metric : CompositeFieldType.values()) {
+                if (metric.getName().equalsIgnoreCase(name)) {
+                    return metric;
+                }
+            }
+            throw new IllegalArgumentException("Invalid metric stat: " + name);
+        }
+    }
+
+    public CompositeFieldType getCompositeIndexType() {
+        return type;
+    }
+
+    public List<String> fields() {
+        return fields;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/ConstantFieldType.java b/server/src/main/java/org/opensearch/index/mapper/ConstantFieldType.java
index a28a6369b1aa4..cc581651e5295 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ConstantFieldType.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ConstantFieldType.java
@@ -76,7 +76,7 @@ public final boolean isAggregatable() {
      */
     protected abstract boolean matches(String pattern, boolean caseInsensitive, QueryShardContext context);
 
-    private static String valueToString(Object value) {
+    static String valueToString(Object value) {
         return value instanceof BytesRef ? ((BytesRef) value).utf8ToString() : value.toString();
     }
 
diff --git a/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java
index f4730c70362d1..02c2214c18e72 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ConstantKeywordFieldMapper.java
@@ -9,10 +9,21 @@
 package org.opensearch.index.mapper;
 
 import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.search.MatchNoDocsQuery;
+import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.RegexpQuery;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.automaton.Automaton;
+import org.apache.lucene.util.automaton.ByteRunAutomaton;
+import org.apache.lucene.util.automaton.RegExp;
 import org.opensearch.OpenSearchParseException;
+import org.opensearch.common.Nullable;
 import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.geo.ShapeRelation;
+import org.opensearch.common.lucene.BytesRefs;
 import org.opensearch.common.regex.Regex;
+import org.opensearch.common.time.DateMathParser;
 import org.opensearch.index.fielddata.IndexFieldData;
 import org.opensearch.index.fielddata.plain.ConstantIndexFieldData;
 import org.opensearch.index.query.QueryShardContext;
@@ -20,6 +31,7 @@
 import org.opensearch.search.lookup.SearchLookup;
 
 import java.io.IOException;
+import java.time.ZoneId;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
@@ -68,11 +80,11 @@ private static ConstantKeywordFieldMapper toType(FieldMapper in) {
      */
     public static class Builder extends ParametrizedFieldMapper.Builder {
 
-        private final Parameter<String> value;
+        private final Parameter<String> value = Parameter.stringParam(valuePropertyName, false, m -> toType(m).value, null);
 
         public Builder(String name, String value) {
             super(name);
-            this.value = Parameter.stringParam(valuePropertyName, false, m -> toType(m).value, value);
+            this.value.setValue(value);
         }
 
         @Override
@@ -122,6 +134,60 @@ public Query existsQuery(QueryShardContext context) {
             return new MatchAllDocsQuery();
         }
 
+        @Override
+        public Query rangeQuery(
+            Object lowerTerm,
+            Object upperTerm,
+            boolean includeLower,
+            boolean includeUpper,
+            ShapeRelation relation,
+            ZoneId timeZone,
+            DateMathParser parser,
+            QueryShardContext context
+        ) {
+            if (lowerTerm != null) {
+                lowerTerm = valueToString(lowerTerm);
+            }
+            if (upperTerm != null) {
+                upperTerm = valueToString(upperTerm);
+            }
+
+            if (lowerTerm != null && upperTerm != null && ((String) lowerTerm).compareTo((String) upperTerm) > 0) {
+                return new MatchNoDocsQuery();
+            }
+
+            if (lowerTerm != null && ((String) lowerTerm).compareTo(value) > (includeLower ? 0 : -1)) {
+                return new MatchNoDocsQuery();
+            }
+
+            if (upperTerm != null && ((String) upperTerm).compareTo(value) < (includeUpper ? 0 : 1)) {
+                return new MatchNoDocsQuery();
+            }
+            return new MatchAllDocsQuery();
+        }
+
+        @Override
+        public Query regexpQuery(
+            String value,
+            int syntaxFlags,
+            int matchFlags,
+            int maxDeterminizedStates,
+            @Nullable MultiTermQuery.RewriteMethod method,
+            QueryShardContext context
+        ) {
+            Automaton automaton = new RegExp(value, syntaxFlags, matchFlags).toAutomaton(
+                RegexpQuery.DEFAULT_PROVIDER,
+                maxDeterminizedStates
+            );
+            ByteRunAutomaton byteRunAutomaton = new ByteRunAutomaton(automaton);
+            BytesRef valueBytes = BytesRefs.toBytesRef(this.value);
+            if (byteRunAutomaton.run(valueBytes.bytes, valueBytes.offset, valueBytes.length)) {
+                return new MatchAllDocsQuery();
+            } else {
+                return new MatchNoDocsQuery();
+            }
+        }
+
         @Override
         public IndexFieldData.Builder fielddataBuilder(String fullyQualifiedIndexName, Supplier<SearchLookup> searchLookup) {
             return new ConstantIndexFieldData.Builder(fullyQualifiedIndexName, name(), CoreValuesSourceType.BYTES);
diff --git a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
index d5aa6420520f1..4df06c59b4508 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
@@ -62,6 +62,8 @@
 import org.opensearch.index.query.QueryRewriteContext;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.search.DocValueFormat;
+import org.opensearch.search.approximate.ApproximateIndexOrDocValuesQuery;
+import org.opensearch.search.approximate.ApproximatePointRangeQuery;
 import org.opensearch.search.lookup.SearchLookup;
 
 import java.io.IOException;
@@ -81,6 +83,7 @@
 import java.util.function.Supplier;
 
 import static org.opensearch.common.time.DateUtils.toLong;
+import static org.apache.lucene.document.LongPoint.pack;
 
 /**
  * A {@link FieldMapper} for dates.
@@ -109,6 +112,21 @@ public static DateFormatter getDefaultDateTimeFormatter() {
             : LEGACY_DEFAULT_DATE_TIME_FORMATTER;
     }
 
+    public static Query getDefaultQuery(Query pointRangeQuery, Query dvQuery, String name, long l, long u) {
+        return FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY_SETTING)
+            ? new ApproximateIndexOrDocValuesQuery(
+                pointRangeQuery,
+                new ApproximatePointRangeQuery(name, pack(new long[] { l }).bytes, pack(new long[] { u }).bytes, new long[] { l }.length) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return Long.toString(LongPoint.decodeDimension(value, 0));
+                    }
+                },
+                dvQuery
+            )
+            : new IndexOrDocValuesQuery(pointRangeQuery, dvQuery);
+    }
+
     /**
      * Resolution of the date time
      *
@@ -336,6 +354,7 @@ public DateFieldMapper build(BuilderContext context) {
             Long nullTimestamp = parseNullValue(ft);
             return new DateFieldMapper(name, ft, multiFieldsBuilder.build(this, context), copyTo.build(), nullTimestamp, resolution, this);
         }
+
     }
 
     public static final TypeParser MILLIS_PARSER = new TypeParser((n, c) -> {
@@ -353,7 +372,7 @@ public DateFieldMapper build(BuilderContext context) {
      *
      * @opensearch.internal
      */
-    public static final class DateFieldType extends MappedFieldType {
+    public static final class DateFieldType extends MappedFieldType implements NumericPointEncoder {
         protected final DateFormatter dateTimeFormatter;
         protected final DateMathParser dateMathParser;
         protected final Resolution resolution;
@@ -468,24 +487,22 @@ public Query rangeQuery(
             }
             DateMathParser parser = forcedDateParser == null ? dateMathParser : forcedDateParser;
             return dateRangeQuery(lowerTerm, upperTerm, includeLower, includeUpper, timeZone, parser, context, resolution, (l, u) -> {
+                Query pointRangeQuery = isSearchable() ? LongPoint.newRangeQuery(name(), l, u) : null;
+                Query dvQuery = hasDocValues() ? SortedNumericDocValuesField.newSlowRangeQuery(name(), l, u) : null;
                 if (isSearchable() && hasDocValues()) {
-                    Query query = LongPoint.newRangeQuery(name(), l, u);
-                    Query dvQuery = SortedNumericDocValuesField.newSlowRangeQuery(name(), l, u);
-                    query = new IndexOrDocValuesQuery(query, dvQuery);
-
+                    Query query = getDefaultQuery(pointRangeQuery, dvQuery, name(), l, u);
                     if (context.indexSortedOnField(name())) {
                         query = new IndexSortSortedNumericDocValuesRangeQuery(name(), l, u, query);
                     }
                     return query;
                 }
                 if (hasDocValues()) {
-                    Query query = SortedNumericDocValuesField.newSlowRangeQuery(name(), l, u);
                     if (context.indexSortedOnField(name())) {
-                        query = new IndexSortSortedNumericDocValuesRangeQuery(name(), l, u, query);
+                        dvQuery = new IndexSortSortedNumericDocValuesRangeQuery(name(), l, u, dvQuery);
                     }
-                    return query;
+                    return dvQuery;
                 }
-                return LongPoint.newRangeQuery(name(), l, u);
+                return pointRangeQuery;
             });
         }
 
@@ -554,6 +571,13 @@ public static long parseToLong(
             return resolution.convert(dateParser.parse(BytesRefs.toString(value), now, roundUp, zone));
         }
 
+        @Override
+        public byte[] encodePoint(Number value) {
+            byte[] point = new byte[Long.BYTES];
+            LongPoint.encodeDimension(value.longValue(), point, 0);
+            return point;
+        }
+
         @Override
         public Query distanceFeatureQuery(Object origin, String pivot, float boost, QueryShardContext context) {
             failIfNotIndexedAndNoDocValues();
diff --git a/server/src/main/java/org/opensearch/index/mapper/DefaultDerivedFieldResolver.java b/server/src/main/java/org/opensearch/index/mapper/DefaultDerivedFieldResolver.java
new file mode 100644
index 0000000000000..4dd17703b6f55
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/DefaultDerivedFieldResolver.java
@@ -0,0 +1,255 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.Script;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.opensearch.index.mapper.FieldMapper.IGNORE_MALFORMED_SETTING;
+
+/**
+ * Accepts definition of DerivedField from search request in both forms: map parsed from SearchRequest and {@link DerivedField} defined using client.
+ * The object is initialized per search request and is responsible to resolve {@link DerivedFieldType} given a field name.
+ * It uses {@link FieldTypeInference} to infer field type for a nested field within DerivedField of {@link DerivedFieldSupportedTypes#OBJECT} type.
+ */
+public class DefaultDerivedFieldResolver implements DerivedFieldResolver {
+    private final QueryShardContext queryShardContext;
+    private final Map<String, DerivedFieldType> derivedFieldTypeMap = new ConcurrentHashMap<>();
+    private final FieldTypeInference typeInference;
+    private static final Logger logger = LogManager.getLogger(DefaultDerivedFieldResolver.class);
+
+    DefaultDerivedFieldResolver(
+        QueryShardContext queryShardContext,
+        Map<String, Object> derivedFieldsObject,
+        List<DerivedField> derivedFields
+    ) {
+        this(
+            queryShardContext,
+            derivedFieldsObject,
+            derivedFields,
+            new FieldTypeInference(
+                queryShardContext.index().getName(),
+                queryShardContext.getMapperService(),
+                queryShardContext.getIndexReader()
+            )
+        );
+    }
+
+    DefaultDerivedFieldResolver(
+        QueryShardContext queryShardContext,
+        Map<String, Object> derivedFieldsObject,
+        List<DerivedField> derivedFields,
+        FieldTypeInference typeInference
+    ) {
+        this.queryShardContext = queryShardContext;
+        initDerivedFieldTypes(derivedFieldsObject, derivedFields);
+        this.typeInference = typeInference;
+    }
+
+    @Override
+    public Set<String> resolvePattern(String pattern) {
+        Set<String> derivedFields = new HashSet<>();
+        if (queryShardContext != null && queryShardContext.getMapperService() != null) {
+            for (MappedFieldType fieldType : queryShardContext.getMapperService().fieldTypes()) {
+                if (Regex.simpleMatch(pattern, fieldType.name()) && fieldType instanceof DerivedFieldType) {
+                    derivedFields.add(fieldType.name());
+                }
+            }
+        }
+        for (String fieldName : derivedFieldTypeMap.keySet()) {
+            if (Regex.simpleMatch(pattern, fieldName)) {
+                derivedFields.add(fieldName);
+            }
+        }
+        return derivedFields;
+    }
+
+    /**
+     * Resolves the fieldName. The search request definitions are given precedence over derived fields definitions in the index mapping.
+     * It caches the response for previously resolved field names
+     * @param fieldName name of the field. It also accepts nested derived field
+     * @return DerivedFieldType if resolved successfully, a null otherwise.
+     */
+    @Override
+    public DerivedFieldType resolve(String fieldName) {
+        return Optional.ofNullable(resolveUsingSearchDefinitions(fieldName)).orElseGet(() -> resolveUsingMappings(fieldName));
+    }
+
+    private DerivedFieldType resolveUsingSearchDefinitions(String fieldName) {
+        return Optional.ofNullable(derivedFieldTypeMap.get(fieldName))
+            .orElseGet(
+                () -> Optional.ofNullable((DerivedFieldType) getParentDerivedField(fieldName))
+                    .map(
+                        // compute and cache nested derived field
+                        parentDerivedField -> derivedFieldTypeMap.computeIfAbsent(
+                            fieldName,
+                            f -> this.resolveNestedField(f, parentDerivedField)
+                        )
+                    )
+                    .orElse(null)
+            );
+    }
+
+    private DerivedFieldType resolveNestedField(String fieldName, DerivedFieldType parentDerivedField) {
+        Objects.requireNonNull(parentDerivedField);
+        try {
+            Script script = parentDerivedField.derivedField.getScript();
+            String nestedType = explicitTypeFromParent(parentDerivedField.derivedField, fieldName.substring(fieldName.indexOf(".") + 1));
+            if (nestedType == null) {
+                Mapper inferredFieldMapper = typeInference.infer(
+                    getValueFetcher(fieldName, script, parentDerivedField.derivedField.getIgnoreMalformed())
+                );
+                if (inferredFieldMapper != null) {
+                    nestedType = inferredFieldMapper.typeName();
+                }
+            }
+            if (nestedType != null) {
+                DerivedField derivedField = new DerivedField(fieldName, nestedType, script);
+                if (parentDerivedField.derivedField.getProperties() != null) {
+                    derivedField.setProperties(parentDerivedField.derivedField.getProperties());
+                }
+                if (parentDerivedField.derivedField.getPrefilterField() != null) {
+                    derivedField.setPrefilterField(parentDerivedField.derivedField.getPrefilterField());
+                }
+                if (parentDerivedField.derivedField.getFormat() != null) {
+                    derivedField.setFormat(parentDerivedField.derivedField.getFormat());
+                }
+                if (parentDerivedField.derivedField.getIgnoreMalformed()) {
+                    derivedField.setIgnoreMalformed(parentDerivedField.derivedField.getIgnoreMalformed());
+                }
+                return getDerivedFieldType(derivedField);
+            } else {
+                logger.warn(
+                    "Field type cannot be inferred. Ensure the field {} is not rare across entire index or provide explicit mapping using [properties] under parent object [{}] ",
+                    fieldName,
+                    parentDerivedField.derivedField.getName()
+                );
+            }
+        } catch (IOException e) {
+            logger.warn(e.getMessage());
+        }
+        return null;
+    }
+
+    private MappedFieldType getParentDerivedField(String fieldName) {
+        if (fieldName.contains(".")) {
+            return resolve(fieldName.split("\\.")[0]);
+        }
+        return null;
+    }
+
+    private static String explicitTypeFromParent(DerivedField parentDerivedField, String subField) {
+        if (parentDerivedField == null) {
+            return null;
+        }
+        return parentDerivedField.getNestedFieldType(subField);
+    }
+
+    ValueFetcher getValueFetcher(String fieldName, Script script, boolean ignoreMalformed) {
+        String subFieldName = fieldName.substring(fieldName.indexOf(".") + 1);
+        return new ObjectDerivedFieldType.ObjectDerivedFieldValueFetcher(
+            subFieldName,
+            DerivedFieldType.getDerivedFieldLeafFactory(script, queryShardContext, queryShardContext.lookup()),
+            o -> o, // raw object returned will be used to infer the type without modifying it
+            ignoreMalformed
+        );
+    }
+
+    private void initDerivedFieldTypes(Map<String, Object> derivedFieldsObject, List<DerivedField> derivedFields) {
+        if (derivedFieldsObject != null && !derivedFieldsObject.isEmpty()) {
+            Map<String, Object> derivedFieldObject = new HashMap<>();
+            derivedFieldObject.put(DerivedFieldMapper.CONTENT_TYPE, derivedFieldsObject);
+            derivedFieldTypeMap.putAll(getAllDerivedFieldTypeFromObject(derivedFieldObject));
+        }
+        if (derivedFields != null) {
+            for (DerivedField derivedField : derivedFields) {
+                derivedFieldTypeMap.put(derivedField.getName(), getDerivedFieldType(derivedField));
+            }
+        }
+    }
+
+    private Map<String, DerivedFieldType> getAllDerivedFieldTypeFromObject(Map<String, Object> derivedFieldObject) {
+        Map<String, DerivedFieldType> derivedFieldTypes = new HashMap<>();
+        // deep copy of derivedFieldObject is required as DocumentMapperParser modifies the map
+        DocumentMapper documentMapper = queryShardContext.getMapperService()
+            .documentMapperParser()
+            .parse(DerivedFieldMapper.CONTENT_TYPE, (Map) deepCopy(derivedFieldObject));
+        if (documentMapper != null && documentMapper.mappers() != null) {
+            for (Mapper mapper : documentMapper.mappers()) {
+                if (mapper instanceof DerivedFieldMapper) {
+                    DerivedFieldType derivedFieldType = ((DerivedFieldMapper) mapper).fieldType();
+                    derivedFieldTypes.put(derivedFieldType.name(), derivedFieldType);
+                }
+            }
+        }
+        return derivedFieldTypes;
+    }
+
+    private DerivedFieldType getDerivedFieldType(DerivedField derivedField) {
+        Mapper.BuilderContext builderContext = new Mapper.BuilderContext(
+            queryShardContext.getMapperService().getIndexSettings().getSettings(),
+            new ContentPath(1)
+        );
+        DerivedFieldMapper.Builder builder = new DerivedFieldMapper.Builder(
+            derivedField,
+            queryShardContext.getMapperService().getIndexAnalyzers(),
+            null,
+            IGNORE_MALFORMED_SETTING.getDefault(queryShardContext.getIndexSettings().getSettings())
+        );
+        return builder.build(builderContext).fieldType();
+    }
+
+    private DerivedFieldType resolveUsingMappings(String name) {
+        if (queryShardContext != null && queryShardContext.getMapperService() != null) {
+            MappedFieldType mappedFieldType = queryShardContext.getMapperService().fieldType(name);
+            if (mappedFieldType instanceof DerivedFieldType) {
+                return (DerivedFieldType) mappedFieldType;
+            }
+        }
+        return null;
+    }
+
+    private static Object deepCopy(Object value) {
+        if (value instanceof Map) {
+            Map<?, ?> mapValue = (Map<?, ?>) value;
+            Map<Object, Object> copy = new HashMap<>(mapValue.size());
+            for (Map.Entry<?, ?> entry : mapValue.entrySet()) {
+                copy.put(entry.getKey(), deepCopy(entry.getValue()));
+            }
+            return copy;
+        } else if (value instanceof List) {
+            List<?> listValue = (List<?>) value;
+            List<Object> copy = new ArrayList<>(listValue.size());
+            for (Object itemValue : listValue) {
+                copy.add(deepCopy(itemValue));
+            }
+            return copy;
+        } else if (value instanceof byte[]) {
+            byte[] bytes = (byte[]) value;
+            return Arrays.copyOf(bytes, bytes.length);
+        } else {
+            return value;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedField.java b/server/src/main/java/org/opensearch/index/mapper/DerivedField.java
index 7ebe4e5f0b0e8..249b60a1c4ec5 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedField.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedField.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.index.mapper;
 
+import org.opensearch.Version;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -18,6 +19,7 @@
 import org.opensearch.script.Script;
 
 import java.io.IOException;
+import java.util.Map;
 import java.util.Objects;
 
 /**
@@ -25,10 +27,13 @@
  */
 @PublicApi(since = "2.14.0")
 public class DerivedField implements Writeable, ToXContentFragment {
-
     private final String name;
     private final String type;
     private final Script script;
+    private String prefilterField;
+    private Map<String, Object> properties;
+    private Boolean ignoreMalformed;
+    private String format;
 
     public DerivedField(String name, String type, Script script) {
         this.name = name;
@@ -40,6 +45,14 @@ public DerivedField(StreamInput in) throws IOException {
         name = in.readString();
         type = in.readString();
         script = new Script(in);
+        if (in.getVersion().onOrAfter(Version.V_2_15_0)) {
+            if (in.readBoolean()) {
+                properties = in.readMap();
+            }
+            prefilterField = in.readOptionalString();
+            format = in.readOptionalString();
+            ignoreMalformed = in.readOptionalBoolean();
+        }
     }
 
     @Override
@@ -47,6 +60,17 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(name);
         out.writeString(type);
         script.writeTo(out);
+        if (out.getVersion().onOrAfter(Version.V_2_15_0)) {
+            if (properties == null) {
+                out.writeBoolean(false);
+            } else {
+                out.writeBoolean(true);
+                out.writeMap(properties);
+            }
+            out.writeOptionalString(prefilterField);
+            out.writeOptionalString(format);
+            out.writeOptionalBoolean(ignoreMalformed);
+        }
     }
 
     @Override
@@ -54,6 +78,18 @@ public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params par
         builder.startObject(name);
         builder.field("type", type);
         builder.field("script", script);
+        if (properties != null) {
+            builder.field("properties", properties);
+        }
+        if (prefilterField != null) {
+            builder.field("prefilter_field", prefilterField);
+        }
+        if (format != null) {
+            builder.field("format", format);
+        }
+        if (ignoreMalformed != null) {
+            builder.field("ignore_malformed", ignoreMalformed);
+        }
         builder.endObject();
         return builder;
     }
@@ -70,9 +106,48 @@ public Script getScript() {
         return script;
     }
 
+    public Map<String, Object> getProperties() {
+        return properties;
+    }
+
+    public String getNestedFieldType(String fieldName) {
+        if (properties == null || properties.isEmpty() || fieldName == null || fieldName.isEmpty()) {
+            return null;
+        }
+        return (String) properties.get(fieldName);
+    }
+
+    public String getPrefilterField() {
+        return prefilterField;
+    }
+
+    public String getFormat() {
+        return format;
+    }
+
+    public boolean getIgnoreMalformed() {
+        return Boolean.TRUE.equals(ignoreMalformed);
+    }
+
+    public void setProperties(Map<String, Object> properties) {
+        this.properties = properties;
+    }
+
+    public void setPrefilterField(String prefilterField) {
+        this.prefilterField = prefilterField;
+    }
+
+    public void setFormat(String format) {
+        this.format = format;
+    }
+
+    public void setIgnoreMalformed(boolean ignoreMalformed) {
+        this.ignoreMalformed = ignoreMalformed;
+    }
+
     @Override
     public int hashCode() {
-        return Objects.hash(name, type, script);
+        return Objects.hash(name, type, script, prefilterField, properties, ignoreMalformed, format);
     }
 
     @Override
@@ -84,7 +159,12 @@ public boolean equals(Object obj) {
             return false;
         }
         DerivedField other = (DerivedField) obj;
-        return Objects.equals(name, other.name) && Objects.equals(type, other.type) && Objects.equals(script, other.script);
+        return Objects.equals(name, other.name)
+            && Objects.equals(type, other.type)
+            && Objects.equals(script, other.script)
+            && Objects.equals(prefilterField, other.prefilterField)
+            && Objects.equals(properties, other.properties)
+            && Objects.equals(ignoreMalformed, other.ignoreMalformed)
+            && Objects.equals(format, other.format);
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java
index c6ae71320c35c..e08e46e1ea969 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java
@@ -9,16 +9,20 @@
 package org.opensearch.index.mapper;
 
 import org.apache.lucene.index.IndexableField;
+import org.opensearch.common.time.DateFormatter;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.analysis.IndexAnalyzers;
 import org.opensearch.script.Script;
 
 import java.io.IOException;
 import java.util.Arrays;
-import java.util.HashMap;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 
+import static org.opensearch.index.mapper.DateFieldMapper.getDefaultDateTimeFormatter;
+
 /**
  * A field mapper for derived fields
  *
@@ -28,6 +32,8 @@ public class DerivedFieldMapper extends ParametrizedFieldMapper {
 
     public static final String CONTENT_TYPE = "derived";
 
+    protected final IndexAnalyzers indexAnalyzers;
+
     private static DerivedFieldMapper toType(FieldMapper in) {
         return (DerivedFieldMapper) in;
     }
@@ -38,62 +44,180 @@ private static DerivedFieldMapper toType(FieldMapper in) {
      * @opensearch.internal
      */
     public static class Builder extends ParametrizedFieldMapper.Builder {
-        // TODO: The type of parameter may change here if the actual underlying FieldType object is needed
-        private final Parameter<String> type = Parameter.stringParam("type", false, m -> toType(m).type, "");
+        private final Parameter<String> type = Parameter.stringParam("type", true, m -> toType(m).type, "");
+        private final IndexAnalyzers indexAnalyzers;
+        private final boolean defaultIgnoreMalformed;
+        private final DateFormatter defaultDateFormatter;
 
         private final Parameter<Script> script = new Parameter<>(
             "script",
-            false,
+            true,
             () -> null,
             (n, c, o) -> o == null ? null : Script.parse(o),
             m -> toType(m).script
         ).setSerializerCheck((id, ic, value) -> value != null);
 
-        public Builder(String name) {
+        private final Parameter<Map<String, Object>> properties = new Parameter<>(
+            "properties",
+            true,
+            Collections::emptyMap,
+            (n, c, o) -> parseProperties(n, o),
+            m -> toType(m).properties
+        );
+        private final Parameter<String> prefilterField = Parameter.stringParam("prefilter_field", true, m -> toType(m).prefilterField, "");
+        private final Parameter<String> format = Parameter.stringParam(
+            "format",
+            true,
+            m -> toType(m).format,
+            getDefaultDateTimeFormatter().pattern()
+        );
+        private final Parameter<Boolean> ignoreMalformed;
+
+        private static Map<String, Object> parseProperties(String name, Object propertiesObject) {
+            if (propertiesObject instanceof Map == false) {
+                throw new MapperParsingException(
+                    "[properties] must be an object, got "
+                        + propertiesObject.getClass().getSimpleName()
+                        + "["
+                        + propertiesObject
+                        + "] for field ["
+                        + name
+                        + "]"
+                );
+            }
+            @SuppressWarnings("unchecked")
+            Map<String, ?> properties = (Map<String, ?>) propertiesObject;
+            for (Object value : properties.values()) {
+                if (value == null) {
+                    throw new MapperParsingException("[properties] values can't be null (field [" + name + "])");
+                } else if (!(value instanceof String)) {
+                    // In the future, we can accept an Object too if needed
+                    throw new MapperParsingException(
+                        "[properties] values can only be strings, but got "
+                            + value.getClass().getSimpleName()
+                            + "["
+                            + value
+                            + "] for field ["
+                            + name
+                            + "]"
+                    );
+                }
+            }
+            return (Map<String, Object>) properties;
+        }
+
+        public Builder(String name, IndexAnalyzers indexAnalyzers, DateFormatter defaultDateFormatter, boolean defaultIgnoreMalformed) {
             super(name);
+            this.indexAnalyzers = indexAnalyzers;
+            this.defaultDateFormatter = defaultDateFormatter;
+            this.defaultIgnoreMalformed = defaultIgnoreMalformed;
+            if (defaultDateFormatter != null) {
+                this.format.setValue(defaultDateFormatter.pattern());
+            }
+            this.ignoreMalformed = Parameter.boolParam("ignore_malformed", true, m -> toType(m).ignoreMalformed, defaultIgnoreMalformed);
         }
 
-        public Builder(DerivedField derivedField) {
-            super(derivedField.getName());
+        public Builder(
+            DerivedField derivedField,
+            IndexAnalyzers indexAnalyzers,
+            DateFormatter defaultDateFormatter,
+            boolean defaultIgnoreMalformed
+        ) {
+            this(derivedField.getName(), indexAnalyzers, defaultDateFormatter, defaultIgnoreMalformed);
             this.type.setValue(derivedField.getType());
             this.script.setValue(derivedField.getScript());
+            if (derivedField.getProperties() != null) {
+                this.properties.setValue(derivedField.getProperties());
+            }
+            if (derivedField.getPrefilterField() != null) {
+                this.prefilterField.setValue(derivedField.getPrefilterField());
+            }
+            if (derivedField.getFormat() != null) {
+                this.format.setValue(derivedField.getFormat());
+            }
+            if (derivedField.getIgnoreMalformed()) {
+                this.ignoreMalformed.setValue(derivedField.getIgnoreMalformed());
+            }
         }
 
         @Override
         protected List<Parameter<?>> getParameters() {
-            return Arrays.asList(type, script);
+            return Arrays.asList(type, script, properties, prefilterField, format, ignoreMalformed);
         }
 
         @Override
         public DerivedFieldMapper build(BuilderContext context) {
-            FieldMapper fieldMapper = DerivedFieldSupportedTypes.getFieldMapperFromType(type.getValue(), name, context);
+            DerivedField derivedField = new DerivedField(buildFullName(context), type.getValue(), script.getValue());
+            if (properties.isConfigured()) {
+                derivedField.setProperties(properties.getValue());
+            }
+            if (prefilterField.isConfigured()) {
+                derivedField.setPrefilterField(prefilterField.getValue());
+            }
+            if (format.isConfigured()) {
+                derivedField.setFormat(format.getValue());
+            }
+            if (ignoreMalformed.isConfigured()) {
+                derivedField.setIgnoreMalformed(ignoreMalformed.getValue());
+            }
+            FieldMapper fieldMapper = DerivedFieldSupportedTypes.getFieldMapperFromType(type.getValue(), name, context, indexAnalyzers);
             Function<Object, IndexableField> fieldFunction = DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(
                 type.getValue(),
                 name
             );
-            DerivedFieldType ft = new DerivedFieldType(
-                new DerivedField(buildFullName(context), type.getValue(), script.getValue()),
-                fieldMapper,
-                fieldFunction
+            DerivedFieldType ft;
+            if (name.contains(".")) {
+                ft = new ObjectDerivedFieldType(derivedField, fieldMapper, fieldFunction, indexAnalyzers);
+            } else {
+                ft = new DerivedFieldType(derivedField, fieldMapper, fieldFunction, indexAnalyzers);
+            }
+            return new DerivedFieldMapper(
+                name,
+                ft,
+                multiFieldsBuilder.build(this, context),
+                copyTo.build(),
+                this,
+                indexAnalyzers,
+                defaultDateFormatter,
+                defaultIgnoreMalformed
             );
-            return new DerivedFieldMapper(name, ft, multiFieldsBuilder.build(this, context), copyTo.build(), this);
         }
     }
 
-    public static final TypeParser PARSER = new TypeParser((n, c) -> new Builder(n));
+    public static final TypeParser PARSER = new TypeParser((n, c) -> {
+        boolean ignoreMalformedByDefault = IGNORE_MALFORMED_SETTING.get(c.getSettings());
+        return new Builder(n, c.getIndexAnalyzers(), c.getDateFormatter(), ignoreMalformedByDefault);
+    });
+
     private final String type;
     private final Script script;
+    private final String prefilterField;
+    private final Map<String, Object> properties;
+    private final boolean ignoreMalformed;
+    private final boolean defaultIgnoreMalformed;
+    private final DateFormatter defaultDateFormatter;
+    private final String format;
 
     protected DerivedFieldMapper(
         String simpleName,
         MappedFieldType mappedFieldType,
         MultiFields multiFields,
         CopyTo copyTo,
-        Builder builder
+        Builder builder,
+        IndexAnalyzers indexAnalyzers,
+        DateFormatter defaultDateFormatter,
+        boolean ignoreMalformed
     ) {
         super(simpleName, mappedFieldType, multiFields, copyTo);
         this.type = builder.type.getValue();
         this.script = builder.script.getValue();
+        this.prefilterField = builder.prefilterField.getValue();
+        this.properties = builder.properties.getValue();
+        this.ignoreMalformed = builder.ignoreMalformed.getValue();
+        this.format = builder.format.getValue();
+        this.indexAnalyzers = indexAnalyzers;
+        this.defaultDateFormatter = defaultDateFormatter;
+        this.defaultIgnoreMalformed = ignoreMalformed;
     }
 
     @Override
@@ -110,7 +234,7 @@ protected void parseCreateField(ParseContext context) throws IOException {
 
     @Override
     public ParametrizedFieldMapper.Builder getMergeBuilder() {
-        return new Builder(simpleName()).init(this);
+        return new Builder(simpleName(), this.indexAnalyzers, defaultDateFormatter, defaultIgnoreMalformed).init(this);
     }
 
     @Override
@@ -133,26 +257,4 @@ public Script getScript() {
         return script;
     }
 
-    public static Map<String, DerivedFieldType> getAllDerivedFieldTypeFromObject(
-        Map<String, Object> derivedFieldObject,
-        MapperService mapperService
-    ) {
-        Map<String, DerivedFieldType> derivedFieldTypes = new HashMap<>();
-        DocumentMapper documentMapper = mapperService.documentMapperParser().parse(DerivedFieldMapper.CONTENT_TYPE, derivedFieldObject);
-        if (documentMapper != null && documentMapper.mappers() != null) {
-            for (Mapper mapper : documentMapper.mappers()) {
-                if (mapper instanceof DerivedFieldMapper) {
-                    DerivedFieldType derivedFieldType = ((DerivedFieldMapper) mapper).fieldType();
-                    derivedFieldTypes.put(derivedFieldType.name(), derivedFieldType);
-                }
-            }
-        }
-        return derivedFieldTypes;
-    }
-
-    public static DerivedFieldType getDerivedFieldType(DerivedField derivedField, MapperService mapperService) {
-        BuilderContext builderContext = new Mapper.BuilderContext(mapperService.getIndexSettings().getSettings(), new ContentPath(1));
-        Builder builder = new Builder(derivedField);
-        return builder.build(builderContext).fieldType();
-    }
 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolver.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolver.java
new file mode 100644
index 0000000000000..adcbaf56f854a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolver.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.common.annotation.PublicApi;
+
+import java.util.Set;
+
+/**
+ * DerivedFieldResolver is used as a lookup to resolve derived fields from their name.
+ * It is created per search request and needs to be set at {@link org.opensearch.index.query.QueryShardContext#setDerivedFieldResolver(DerivedFieldResolver)}
+ * for derived fields resolution.
+ */
+@PublicApi(since = "2.15.0")
+public interface DerivedFieldResolver {
+    /**
+     * Resolves all derived fields matching a given pattern. It includes derived fields defined both in search requests
+     * and index mapping.
+     * @param pattern regex pattern
+     * @return all derived fields matching the pattern
+     */
+    Set<String> resolvePattern(String pattern);
+
+    /**
+     * Resolves the MappedFieldType associated with a derived field
+     * @param fieldName field name to lookup
+     * @return mapped field type
+     */
+    MappedFieldType resolve(String fieldName);
+
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolverFactory.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolverFactory.java
new file mode 100644
index 0000000000000..a66c61806e3e3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolverFactory.java
@@ -0,0 +1,58 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.OpenSearchException;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.search.SearchService;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.opensearch.search.SearchService.ALLOW_EXPENSIVE_QUERIES;
+
+/**
+ * Used to create DerivedFieldResolver. It chooses between {@link DefaultDerivedFieldResolver} and {@link NoOpDerivedFieldResolver}
+ * depending on whether derived field is enabled.
+ */
+public class DerivedFieldResolverFactory {
+
+    public static DerivedFieldResolver createResolver(
+        QueryShardContext queryShardContext,
+        Map<String, Object> derivedFieldsObject,
+        List<DerivedField> derivedFields,
+        boolean derivedFieldAllowed
+    ) {
+        boolean derivedFieldsPresent = derivedFieldsPresent(derivedFieldsObject, derivedFields);
+        if (derivedFieldsPresent && !derivedFieldAllowed) {
+            throw new OpenSearchException(
+                "[derived field] queries cannot be executed when '"
+                    + IndexSettings.ALLOW_DERIVED_FIELDS.getKey()
+                    + "' or '"
+                    + SearchService.CLUSTER_ALLOW_DERIVED_FIELD_SETTING.getKey()
+                    + "' is set to false."
+            );
+        }
+        if (derivedFieldsPresent && queryShardContext.allowExpensiveQueries() == false) {
+            throw new OpenSearchException(
+                "[derived field] queries cannot be executed when '" + ALLOW_EXPENSIVE_QUERIES.getKey() + "' is set to false."
+            );
+        }
+        if (derivedFieldAllowed) {
+            return new DefaultDerivedFieldResolver(queryShardContext, derivedFieldsObject, derivedFields);
+        } else {
+            return new NoOpDerivedFieldResolver();
+        }
+    }
+
+    private static boolean derivedFieldsPresent(Map<String, Object> derivedFieldsObject, List<DerivedField> derivedFields) {
+        return (derivedFieldsObject != null && !derivedFieldsObject.isEmpty()) || (derivedFields != null && !derivedFields.isEmpty());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldSupportedTypes.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldSupportedTypes.java
index aa6936bf6529a..c2bfaffa206a5 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldSupportedTypes.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldSupportedTypes.java
@@ -11,24 +11,29 @@
 import org.apache.lucene.document.DoubleField;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.document.FieldType;
+import org.apache.lucene.document.FloatField;
 import org.apache.lucene.document.InetAddressPoint;
 import org.apache.lucene.document.KeywordField;
 import org.apache.lucene.document.LatLonPoint;
 import org.apache.lucene.document.LongField;
 import org.apache.lucene.document.LongPoint;
+import org.apache.lucene.document.TextField;
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.index.IndexableField;
+import org.opensearch.OpenSearchException;
 import org.opensearch.Version;
 import org.opensearch.common.Booleans;
+import org.opensearch.common.TriFunction;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.geo.GeoPoint;
 import org.opensearch.common.lucene.Lucene;
 import org.opensearch.common.network.InetAddresses;
+import org.opensearch.common.time.DateFormatter;
+import org.opensearch.index.analysis.IndexAnalyzers;
 
 import java.net.InetAddress;
 import java.util.Arrays;
 import java.util.Map;
-import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -39,7 +44,7 @@
  */
 public enum DerivedFieldSupportedTypes {
 
-    BOOLEAN("boolean", (name, context) -> {
+    BOOLEAN("boolean", (name, context, indexAnalyzers) -> {
         BooleanFieldMapper.Builder builder = new BooleanFieldMapper.Builder(name);
         return builder.build(context);
     }, name -> o -> {
@@ -52,8 +57,8 @@ public enum DerivedFieldSupportedTypes {
             value = Booleans.parseBooleanStrict(textValue, false);
         }
         return new Field(name, value ? "T" : "F", BooleanFieldMapper.Defaults.FIELD_TYPE);
-    }, o -> o),
-    DATE("date", (name, context) -> {
+    }, formatter -> o -> o),
+    DATE("date", (name, context, indexAnalyzers) -> {
         // TODO: should we support mapping settings exposed by a given field type from derived fields too?
         // for example, support `format` for date type?
         DateFieldMapper.Builder builder = new DateFieldMapper.Builder(
@@ -64,8 +69,13 @@ public enum DerivedFieldSupportedTypes {
             Version.CURRENT
         );
         return builder.build(context);
-    }, name -> o -> new LongPoint(name, (long) o), o -> DateFieldMapper.getDefaultDateTimeFormatter().formatMillis((long) o)),
-    GEO_POINT("geo_point", (name, context) -> {
+    },
+        name -> o -> new LongPoint(name, (long) o),
+        formatter -> o -> formatter == null
+            ? DateFieldMapper.getDefaultDateTimeFormatter().formatMillis((long) o)
+            : formatter.formatMillis((long) o)
+    ),
+    GEO_POINT("geo_point", (name, context, indexAnalyzers) -> {
         GeoPointFieldMapper.Builder builder = new GeoPointFieldMapper.Builder(name);
         return builder.build(context);
     }, name -> o -> {
@@ -74,8 +84,8 @@ public enum DerivedFieldSupportedTypes {
             throw new ClassCastException("geo_point should be in format emit(double lat, double lon) for derived fields");
         }
         return new LatLonPoint(name, (double) ((Tuple<?, ?>) o).v1(), (double) ((Tuple<?, ?>) o).v2());
-    }, o -> new GeoPoint((double) ((Tuple) o).v1(), (double) ((Tuple) o).v2())),
-    IP("ip", (name, context) -> {
+    }, formatter -> o -> new GeoPoint((double) ((Tuple) o).v1(), (double) ((Tuple) o).v2())),
+    IP("ip", (name, context, indexAnalyzers) -> {
         IpFieldMapper.Builder builder = new IpFieldMapper.Builder(name, false, Version.CURRENT);
         return builder.build(context);
     }, name -> o -> {
@@ -86,8 +96,8 @@ public enum DerivedFieldSupportedTypes {
             address = InetAddresses.forString(o.toString());
         }
         return new InetAddressPoint(name, address);
-    }, o -> o),
-    KEYWORD("keyword", (name, context) -> {
+    }, formatter -> o -> o),
+    KEYWORD("keyword", (name, context, indexAnalyzers) -> {
         FieldType dummyFieldType = new FieldType();
         dummyFieldType.setIndexOptions(IndexOptions.DOCS_AND_FREQS);
         KeywordFieldMapper.Builder keywordBuilder = new KeywordFieldMapper.Builder(name);
@@ -101,28 +111,54 @@ public enum DerivedFieldSupportedTypes {
             keywordBuilder.copyTo.build(),
             keywordBuilder
         );
-    }, name -> o -> new KeywordField(name, (String) o, Field.Store.NO), o -> o),
-    LONG("long", (name, context) -> {
+    }, name -> o -> new KeywordField(name, (String) o, Field.Store.NO), formatter -> o -> o),
+    TEXT("text", (name, context, indexAnalyzers) -> {
+        FieldType dummyFieldType = new FieldType();
+        dummyFieldType.setIndexOptions(IndexOptions.DOCS_AND_FREQS);
+        TextFieldMapper.Builder textBuilder = new TextFieldMapper.Builder(name, indexAnalyzers);
+        return textBuilder.build(context);
+    }, name -> o -> new TextField(name, (String) o, Field.Store.NO), formatter -> o -> o),
+    LONG("long", (name, context, indexAnalyzers) -> {
         NumberFieldMapper.Builder longBuilder = new NumberFieldMapper.Builder(name, NumberFieldMapper.NumberType.LONG, false, false);
         return longBuilder.build(context);
-    }, name -> o -> new LongField(name, Long.parseLong(o.toString()), Field.Store.NO), o -> o),
-    DOUBLE("double", (name, context) -> {
+    }, name -> o -> new LongField(name, Long.parseLong(o.toString()), Field.Store.NO), formatter -> o -> o),
+    DOUBLE("double", (name, context, indexAnalyzers) -> {
         NumberFieldMapper.Builder doubleBuilder = new NumberFieldMapper.Builder(name, NumberFieldMapper.NumberType.DOUBLE, false, false);
         return doubleBuilder.build(context);
-    }, name -> o -> new DoubleField(name, Double.parseDouble(o.toString()), Field.Store.NO), o -> o);
+    }, name -> o -> new DoubleField(name, Double.parseDouble(o.toString()), Field.Store.NO), formatter -> o -> o),
+    FLOAT("float", (name, context, indexAnalyzers) -> {
+        NumberFieldMapper.Builder floatBuilder = new NumberFieldMapper.Builder(name, NumberFieldMapper.NumberType.FLOAT, false, false);
+        return floatBuilder.build(context);
+    }, name -> o -> new FloatField(name, Float.parseFloat(o.toString()), Field.Store.NO), formatter -> o -> o),
+    OBJECT("object", (name, context, indexAnalyzers) -> {
+        // we create a keyword field type with index options set as NONE as we don't support queries directly on object type
+        KeywordFieldMapper.Builder keywordBuilder = new KeywordFieldMapper.Builder(name);
+        KeywordFieldMapper.KeywordFieldType keywordFieldType = keywordBuilder.buildFieldType(context, new FieldType());
+        return new KeywordFieldMapper(
+            name,
+            new FieldType(),
+            keywordFieldType,
+            keywordBuilder.multiFieldsBuilder.build(keywordBuilder, context),
+            keywordBuilder.copyTo.build(),
+            keywordBuilder
+        );
+    },
+        name -> o -> { throw new OpenSearchException("Cannot create IndexableField to execute queries on object derived field"); },
+        formatter -> o -> o
+    );
 
     final String name;
-    private final BiFunction<String, Mapper.BuilderContext, FieldMapper> builder;
+    private final TriFunction<String, Mapper.BuilderContext, IndexAnalyzers, FieldMapper> builder;
 
     private final Function<String, Function<Object, IndexableField>> indexableFieldBuilder;
 
-    private final Function<Object, Object> valueForDisplay;
+    private final Function<DateFormatter, Function<Object, Object>> valueForDisplay;
 
     DerivedFieldSupportedTypes(
         String name,
-        BiFunction<String, Mapper.BuilderContext, FieldMapper> builder,
+        TriFunction<String, Mapper.BuilderContext, IndexAnalyzers, FieldMapper> builder,
         Function<String, Function<Object, IndexableField>> indexableFieldBuilder,
-        Function<Object, Object> valueForDisplay
+        Function<DateFormatter, Function<Object, Object>> valueForDisplay
     ) {
         this.name = name;
         this.builder = builder;
@@ -134,26 +170,31 @@ public String getName() {
         return name;
     }
 
-    private FieldMapper getFieldMapper(String name, Mapper.BuilderContext context) {
-        return builder.apply(name, context);
+    private FieldMapper getFieldMapper(String name, Mapper.BuilderContext context, IndexAnalyzers indexAnalyzers) {
+        return builder.apply(name, context, indexAnalyzers);
     }
 
     private Function<Object, IndexableField> getIndexableFieldGenerator(String name) {
         return indexableFieldBuilder.apply(name);
     }
 
-    private Function<Object, Object> getValueForDisplayGenerator() {
-        return valueForDisplay;
+    private Function<Object, Object> getValueForDisplayGenerator(DateFormatter formatter) {
+        return valueForDisplay.apply(formatter);
     }
 
     private static final Map<String, DerivedFieldSupportedTypes> enumMap = Arrays.stream(DerivedFieldSupportedTypes.values())
         .collect(Collectors.toMap(DerivedFieldSupportedTypes::getName, enumValue -> enumValue));
 
-    public static FieldMapper getFieldMapperFromType(String type, String name, Mapper.BuilderContext context) {
+    public static FieldMapper getFieldMapperFromType(
+        String type,
+        String name,
+        Mapper.BuilderContext context,
+        IndexAnalyzers indexAnalyzers
+    ) {
         if (!enumMap.containsKey(type)) {
             throw new IllegalArgumentException("Type [" + type + "] isn't supported in Derived field context.");
         }
-        return enumMap.get(type).getFieldMapper(name, context);
+        return enumMap.get(type).getFieldMapper(name, context, indexAnalyzers);
     }
 
     public static Function<Object, IndexableField> getIndexableFieldGeneratorType(String type, String name) {
@@ -163,10 +204,10 @@ public static Function<Object, IndexableField> getIndexableFieldGeneratorType(St
         return enumMap.get(type).getIndexableFieldGenerator(name);
     }
 
-    public static Function<Object, Object> getValueForDisplayGenerator(String type) {
+    public static Function<Object, Object> getValueForDisplayGenerator(String type, DateFormatter formatter) {
         if (!enumMap.containsKey(type)) {
             throw new IllegalArgumentException("Type [" + type + "] isn't supported in Derived field context.");
         }
-        return enumMap.get(type).getValueForDisplayGenerator();
+        return enumMap.get(type).getValueForDisplayGenerator(formatter);
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldType.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldType.java
index 8b480819acd0e..fe81f19d74b21 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldType.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldType.java
@@ -9,42 +9,63 @@
 package org.opensearch.index.mapper;
 
 import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.document.InetAddressPoint;
 import org.apache.lucene.index.IndexableField;
+import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.queries.spans.SpanMultiTermQueryWrapper;
 import org.apache.lucene.queries.spans.SpanQuery;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.util.BytesRef;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.geo.ShapeRelation;
+import org.opensearch.common.network.InetAddresses;
+import org.opensearch.common.time.DateFormatter;
 import org.opensearch.common.time.DateMathParser;
 import org.opensearch.common.unit.Fuzziness;
 import org.opensearch.geometry.Geometry;
+import org.opensearch.index.analysis.IndexAnalyzers;
 import org.opensearch.index.analysis.NamedAnalyzer;
+import org.opensearch.index.fielddata.IndexFieldData;
 import org.opensearch.index.query.DerivedFieldQuery;
 import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.AggregationScript;
 import org.opensearch.script.DerivedFieldScript;
+import org.opensearch.script.Script;
+import org.opensearch.search.DocValueFormat;
+import org.opensearch.search.lookup.LeafSearchLookup;
 import org.opensearch.search.lookup.SearchLookup;
 
 import java.io.IOException;
+import java.net.InetAddress;
 import java.time.ZoneId;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
 
 /**
  * MappedFieldType for Derived Fields
  * Contains logic to execute different type of queries on a derived field of given type.
+ *
  * @opensearch.internal
  */
-public final class DerivedFieldType extends MappedFieldType implements GeoShapeQueryable {
-
-    private final DerivedField derivedField;
-
-    FieldMapper typeFieldMapper;
 
+public class DerivedFieldType extends MappedFieldType implements GeoShapeQueryable {
+    final DerivedField derivedField;
+    final FieldMapper typeFieldMapper;
     final Function<Object, IndexableField> indexableFieldGenerator;
 
+    @Override
+    public DocValueFormat docValueFormat(String format, ZoneId timeZone) {
+        return typeFieldMapper.mappedFieldType.docValueFormat(format, timeZone);
+    }
+
     public DerivedFieldType(
         DerivedField derivedField,
         boolean isIndexed,
@@ -60,10 +81,40 @@ public DerivedFieldType(
         this.indexableFieldGenerator = fieldFunction;
     }
 
-    public DerivedFieldType(DerivedField derivedField, FieldMapper typeFieldMapper, Function<Object, IndexableField> fieldFunction) {
+    public DerivedFieldType(
+        DerivedField derivedField,
+        FieldMapper typeFieldMapper,
+        Function<Object, IndexableField> fieldFunction,
+        IndexAnalyzers indexAnalyzers
+    ) {
         this(derivedField, false, false, false, Collections.emptyMap(), typeFieldMapper, fieldFunction);
     }
 
+    @Override
+    public TextSearchInfo getTextSearchInfo() {
+        return typeFieldMapper.fieldType().getTextSearchInfo();
+    }
+
+    TextFieldMapper.TextFieldType getPrefilterFieldType(QueryShardContext context) {
+        if (derivedField.getPrefilterField() == null || derivedField.getPrefilterField().isEmpty()) {
+            return null;
+        }
+        MappedFieldType mappedFieldType = context.fieldMapper(derivedField.getPrefilterField());
+        if (mappedFieldType == null) {
+            throw new MapperException("prefilter_field[" + derivedField.getPrefilterField() + "] is not defined in the index mappings");
+        }
+        if (!(mappedFieldType instanceof TextFieldMapper.TextFieldType)) {
+            throw new MapperException(
+                "prefilter_field["
+                    + derivedField.getPrefilterField()
+                    + "] should be of type text. Type found ["
+                    + mappedFieldType.typeName()
+                    + "]."
+            );
+        }
+        return (TextFieldMapper.TextFieldType) mappedFieldType;
+    }
+
     @Override
     public String typeName() {
         return "derived";
@@ -73,12 +124,16 @@ public String getType() {
         return derivedField.getType();
     }
 
-    public MappedFieldType getTypeMappedFieldType() {
-        return typeFieldMapper.mappedFieldType;
+    public FieldMapper getFieldMapper() {
+        return typeFieldMapper;
+    }
+
+    public Function<Object, IndexableField> getIndexableFieldGenerator() {
+        return indexableFieldGenerator;
     }
 
     public NamedAnalyzer getIndexAnalyzer() {
-        return typeFieldMapper.mappedFieldType.indexAnalyzer();
+        return getFieldMapper().mappedFieldType.indexAnalyzer();
     }
 
     @Override
@@ -86,33 +141,69 @@ public DerivedFieldValueFetcher valueFetcher(QueryShardContext context, SearchLo
         if (format != null) {
             throw new IllegalArgumentException("Field [" + name() + "] of type [" + typeName() + "] doesn't support formats.");
         }
-        Function<Object, Object> valueForDisplay = DerivedFieldSupportedTypes.getValueForDisplayGenerator(getType());
+        Function<Object, Object> valueForDisplay = DerivedFieldSupportedTypes.getValueForDisplayGenerator(
+            getType(),
+            derivedField.getFormat() != null ? DateFormatter.forPattern(derivedField.getFormat()) : null
+        );
         return new DerivedFieldValueFetcher(
-            getDerivedFieldLeafFactory(context, searchLookup == null ? context.lookup() : searchLookup),
-            valueForDisplay,
-            indexableFieldGenerator
+            getDerivedFieldLeafFactory(derivedField.getScript(), context, searchLookup == null ? context.lookup() : searchLookup),
+            valueForDisplay
         );
     }
 
+    @Override
+    public IndexFieldData.Builder fielddataBuilder(String fullyQualifiedIndexName, Supplier<SearchLookup> searchLookup) {
+        return getFieldMapper().mappedFieldType.fielddataBuilder(fullyQualifiedIndexName, searchLookup);
+    }
+
     @Override
     public Query termQuery(Object value, QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.termQuery(value, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(prefilterFieldType -> createConjuctionQuery(prefilterFieldType.termQuery(value, context), derivedFieldQuery))
+            .orElse(derivedFieldQuery);
     }
 
     @Override
     public Query termQueryCaseInsensitive(Object value, @Nullable QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.termQueryCaseInsensitive(value, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(
+                prefilterFieldType -> createConjuctionQuery(prefilterFieldType.termQueryCaseInsensitive(value, context), derivedFieldQuery)
+            )
+            .orElse(derivedFieldQuery);
     }
 
     @Override
     public Query termsQuery(List<?> values, @Nullable QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.termsQuery(values, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(prefilterFieldType -> createConjuctionQuery(prefilterFieldType.termsQuery(values, context), derivedFieldQuery))
+            .orElse(derivedFieldQuery);
     }
 
     @Override
@@ -136,8 +227,14 @@ public Query rangeQuery(
             parser,
             context
         );
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
     }
 
     @Override
@@ -150,8 +247,22 @@ public Query fuzzyQuery(
         QueryShardContext context
     ) {
         Query query = typeFieldMapper.mappedFieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(
+                prefilterFieldType -> createConjuctionQuery(
+                    prefilterFieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, context),
+                    derivedFieldQuery
+                )
+            )
+            .orElse(derivedFieldQuery);
     }
 
     @Override
@@ -173,8 +284,22 @@ public Query fuzzyQuery(
             method,
             context
         );
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(
+                prefilterFieldType -> createConjuctionQuery(
+                    prefilterFieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, method, context),
+                    derivedFieldQuery
+                )
+            )
+            .orElse(derivedFieldQuery);
     }
 
     @Override
@@ -185,8 +310,22 @@ public Query prefixQuery(
         QueryShardContext context
     ) {
         Query query = typeFieldMapper.mappedFieldType.prefixQuery(value, method, caseInsensitive, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(
+                prefilterFieldType -> createConjuctionQuery(
+                    prefilterFieldType.prefixQuery(value, method, caseInsensitive, context),
+                    derivedFieldQuery
+                )
+            )
+            .orElse(derivedFieldQuery);
     }
 
     @Override
@@ -197,15 +336,43 @@ public Query wildcardQuery(
         QueryShardContext context
     ) {
         Query query = typeFieldMapper.mappedFieldType.wildcardQuery(value, method, caseInsensitive, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(
+                prefilterFieldType -> createConjuctionQuery(
+                    prefilterFieldType.wildcardQuery(value, method, caseInsensitive, context),
+                    derivedFieldQuery
+                )
+            )
+            .orElse(derivedFieldQuery);
     }
 
     @Override
     public Query normalizedWildcardQuery(String value, @Nullable MultiTermQuery.RewriteMethod method, QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.normalizedWildcardQuery(value, method, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(
+                prefilterFieldType -> createConjuctionQuery(
+                    prefilterFieldType.normalizedWildcardQuery(value, method, context),
+                    derivedFieldQuery
+                )
+            )
+            .orElse(derivedFieldQuery);
     }
 
     @Override
@@ -218,30 +385,89 @@ public Query regexpQuery(
         QueryShardContext context
     ) {
         Query query = typeFieldMapper.mappedFieldType.regexpQuery(value, syntaxFlags, matchFlags, maxDeterminizedStates, method, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context))
+            .map(
+                prefilterFieldType -> createConjuctionQuery(
+                    prefilterFieldType.regexpQuery(value, syntaxFlags, matchFlags, maxDeterminizedStates, method, context),
+                    derivedFieldQuery
+                )
+            )
+            .orElse(derivedFieldQuery);
     }
 
     @Override
     public Query phraseQuery(TokenStream stream, int slop, boolean enablePositionIncrements, QueryShardContext context) throws IOException {
         Query query = typeFieldMapper.mappedFieldType.phraseQuery(stream, slop, enablePositionIncrements, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context)).map(prefilterFieldType -> {
+            try {
+                return createConjuctionQuery(
+                    prefilterFieldType.phraseQuery(stream, slop, enablePositionIncrements, context),
+                    derivedFieldQuery
+                );
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }).orElse(derivedFieldQuery);
     }
 
     @Override
     public Query multiPhraseQuery(TokenStream stream, int slop, boolean enablePositionIncrements, QueryShardContext context)
         throws IOException {
         Query query = typeFieldMapper.mappedFieldType.multiPhraseQuery(stream, slop, enablePositionIncrements, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context)).map(prefilterFieldType -> {
+            try {
+                return createConjuctionQuery(
+                    prefilterFieldType.multiPhraseQuery(stream, slop, enablePositionIncrements, context),
+                    derivedFieldQuery
+                );
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }).orElse(derivedFieldQuery);
     }
 
     @Override
     public Query phrasePrefixQuery(TokenStream stream, int slop, int maxExpansions, QueryShardContext context) throws IOException {
         Query query = typeFieldMapper.mappedFieldType.phrasePrefixQuery(stream, slop, maxExpansions, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
+        return Optional.ofNullable(getPrefilterFieldType(context)).map(prefilterFieldType -> {
+            try {
+                return createConjuctionQuery(prefilterFieldType.phrasePrefixQuery(stream, slop, maxExpansions, context), derivedFieldQuery);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }).orElse(derivedFieldQuery);
     }
 
     @Override
@@ -254,15 +480,27 @@ public SpanQuery spanPrefixQuery(String value, SpanMultiTermQueryWrapper.SpanRew
     @Override
     public Query distanceFeatureQuery(Object origin, String pivot, float boost, QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.distanceFeatureQuery(origin, pivot, boost, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
     }
 
     @Override
     public Query geoShapeQuery(Geometry shape, String fieldName, ShapeRelation relation, QueryShardContext context) {
         Query query = ((GeoShapeQueryable) (typeFieldMapper.mappedFieldType)).geoShapeQuery(shape, fieldName, relation, context);
-        DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(
+            query,
+            () -> valueFetcher(context, context.lookup(), null),
+            context.lookup(),
+            getIndexAnalyzer(),
+            indexableFieldGenerator,
+            derivedField.getIgnoreMalformed()
+        );
     }
 
     @Override
@@ -272,10 +510,21 @@ public Query existsQuery(QueryShardContext context) {
 
     @Override
     public boolean isAggregatable() {
-        return false;
+        return true;
+    }
+
+    private Query createConjuctionQuery(Query filterQuery, DerivedFieldQuery derivedFieldQuery) {
+        BooleanQuery.Builder builder = new BooleanQuery.Builder();
+        builder.add(filterQuery, BooleanClause.Occur.FILTER);
+        builder.add(derivedFieldQuery, BooleanClause.Occur.FILTER);
+        return builder.build();
     }
 
-    private DerivedFieldScript.LeafFactory getDerivedFieldLeafFactory(QueryShardContext context, SearchLookup searchLookup) {
+    public static DerivedFieldScript.LeafFactory getDerivedFieldLeafFactory(
+        Script script,
+        QueryShardContext context,
+        SearchLookup searchLookup
+    ) {
         if (!context.documentMapper("").sourceMapper().enabled()) {
             throw new IllegalArgumentException(
                 "DerivedFieldQuery error: unable to fetch fields from _source field: _source is disabled in the mappings "
@@ -284,7 +533,58 @@ private DerivedFieldScript.LeafFactory getDerivedFieldLeafFactory(QueryShardCont
                     + "]"
             );
         }
-        DerivedFieldScript.Factory factory = context.compile(derivedField.getScript(), DerivedFieldScript.CONTEXT);
-        return factory.newFactory(derivedField.getScript().getParams(), searchLookup);
+        DerivedFieldScript.Factory factory = context.compile(script, DerivedFieldScript.CONTEXT);
+        return factory.newFactory(script.getParams(), searchLookup);
+    }
+
+    public AggregationScript.LeafFactory getAggregationScript(QueryShardContext context) {
+        return new AggregationScript.LeafFactory() {
+            @Override
+            public AggregationScript newInstance(LeafReaderContext ctx) throws IOException {
+                final DerivedFieldValueFetcher derivedFieldValueFetcher = valueFetcher(context, context.lookup(), null);
+                derivedFieldValueFetcher.setNextReader(ctx);
+                final LeafSearchLookup leafSearchLookup = context.lookup().getLeafSearchLookup(ctx);
+
+                return new AggregationScript(derivedField.getScript().getParams(), context.lookup(), ctx) {
+                    @Override
+                    public Object execute() {
+                        return formatValues(derivedFieldValueFetcher.fetchValuesInternal(leafSearchLookup.source()));
+                    }
+
+                    @Override
+                    public void setDocument(int docid) {
+                        super.setDocument(docid);
+                        leafSearchLookup.source().setSegmentAndDocument(ctx, docid);
+                    }
+                };
+            }
+
+            @Override
+            public boolean needs_score() {
+                return false;
+            }
+        };
+    }
+
+    // perform any formatting on the returned Object before passing to
+    // any values source.
+    private Object formatValues(List<Object> objects) {
+        // ips are returned as raw strings, format them as BytesRefs
+        // This ensures that ip_range aggs compare the bytesRef against ranges computed in the
+        // same way.
+        if (typeFieldMapper instanceof IpFieldMapper) {
+            return objects.stream().map(o -> (String) o).map(this::toBytesRef).collect(Collectors.toList());
+        }
+        return objects;
+    }
+
+    // format the ip string as BytesRef.
+    private BytesRef toBytesRef(String ip) {
+        if (ip == null) {
+            return null;
+        }
+        InetAddress address = InetAddresses.forString(ip);
+        byte[] bytes = InetAddressPoint.encode(address);
+        return new BytesRef(bytes);
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
index 2d9379e04c512..09cdea882d10c 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
@@ -10,6 +10,7 @@
 
 import org.apache.lucene.index.IndexableField;
 import org.apache.lucene.index.LeafReaderContext;
+import org.opensearch.common.annotation.DeprecatedApi;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.script.DerivedFieldScript;
 import org.opensearch.search.lookup.SourceLookup;
@@ -25,13 +26,17 @@
  * {@link #setNextReader(LeafReaderContext)} whenever a segment is switched.
  */
 @PublicApi(since = "2.14.0")
-public final class DerivedFieldValueFetcher implements ValueFetcher {
+public class DerivedFieldValueFetcher implements ValueFetcher {
     private DerivedFieldScript derivedFieldScript;
     private final DerivedFieldScript.LeafFactory derivedFieldScriptFactory;
-
     private final Function<Object, Object> valueForDisplay;
-    private final Function<Object, IndexableField> indexableFieldFunction;
 
+    public DerivedFieldValueFetcher(DerivedFieldScript.LeafFactory derivedFieldScriptFactory, Function<Object, Object> valueForDisplay) {
+        this.derivedFieldScriptFactory = derivedFieldScriptFactory;
+        this.valueForDisplay = valueForDisplay;
+    }
+
+    @DeprecatedApi(since = "2.15.0")
     public DerivedFieldValueFetcher(
         DerivedFieldScript.LeafFactory derivedFieldScriptFactory,
         Function<Object, Object> valueForDisplay,
@@ -39,7 +44,6 @@ public DerivedFieldValueFetcher(
     ) {
         this.derivedFieldScriptFactory = derivedFieldScriptFactory;
         this.valueForDisplay = valueForDisplay;
-        this.indexableFieldFunction = indexableFieldFunction;
     }
 
     @Override
@@ -55,21 +59,31 @@ public List<Object> fetchValues(SourceLookup lookup) {
         return result;
     }
 
-    private List<Object> fetchValuesInternal(SourceLookup lookup) {
+    public List<Object> fetchValuesInternal(SourceLookup lookup) {
         derivedFieldScript.setDocument(lookup.docId());
         derivedFieldScript.execute();
         return derivedFieldScript.getEmittedValues();
     }
 
-    public List<IndexableField> getIndexableField(SourceLookup lookup) {
+    public List<IndexableField> getIndexableField(SourceLookup lookup, Function<Object, IndexableField> indexableFieldFunction) {
         List<Object> values = fetchValuesInternal(lookup);
         List<IndexableField> indexableFields = new ArrayList<>();
         for (Object v : values) {
-            indexableFields.add(indexableFieldFunction.apply(v));
+            if (v != null) {
+                indexableFields.add(indexableFieldFunction.apply(v));
+            }
         }
         return indexableFields;
     }
 
+    /**
+     * Use {@link #getIndexableField(SourceLookup, Function)} instead
+     */
+    @DeprecatedApi(since = "2.15.0")
+    public List<IndexableField> getIndexableField(SourceLookup sourceLookup) {
+        throw new UnsupportedOperationException("Use getIndexableField(SourceLookup, Function) instead.");
+    }
+
     @Override
     public void setNextReader(LeafReaderContext context) {
         try {
diff --git a/server/src/main/java/org/opensearch/index/mapper/DocCountFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DocCountFieldMapper.java
index 0a461fff38fac..db4770adf6666 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DocCountFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DocCountFieldMapper.java
@@ -75,6 +75,11 @@ protected List<Parameter<?>> getParameters() {
         public DocCountFieldMapper build(BuilderContext context) {
             return new DocCountFieldMapper();
         }
+
+        @Override
+        public boolean isDataCubeMetricSupported() {
+            return true;
+        }
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/index/mapper/DocumentParser.java b/server/src/main/java/org/opensearch/index/mapper/DocumentParser.java
index f276d6ee2e579..50ff816695156 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DocumentParser.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DocumentParser.java
@@ -54,6 +54,7 @@
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Locale;
 
 import static org.opensearch.index.mapper.FieldMapper.IGNORE_MALFORMED_SETTING;
 
@@ -205,6 +206,9 @@ private static MapperParsingException wrapInMapperParsingException(SourceToParse
     private static String[] splitAndValidatePath(String fullFieldPath) {
         if (fullFieldPath.contains(".")) {
             String[] parts = fullFieldPath.split("\\.");
+            if (parts.length == 0) {
+                throw new IllegalArgumentException("field name cannot contain only the character [.]");
+            }
             for (String part : parts) {
                 if (Strings.hasText(part) == false) {
                     // check if the field name contains only whitespace
@@ -545,22 +549,32 @@ private static void parseObject(final ParseContext context, ObjectMapper mapper,
             Tuple<Integer, ObjectMapper> parentMapperTuple = getDynamicParentMapper(context, paths, mapper);
             ObjectMapper parentMapper = parentMapperTuple.v2();
             ObjectMapper.Dynamic dynamic = dynamicOrDefault(parentMapper, context);
-            if (dynamic == ObjectMapper.Dynamic.STRICT) {
-                throw new StrictDynamicMappingException(mapper.fullPath(), currentFieldName);
-            } else if (dynamic == ObjectMapper.Dynamic.TRUE) {
-                Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.OBJECT);
-                if (builder == null) {
-                    builder = new ObjectMapper.Builder(currentFieldName).enabled(true);
-                }
-                Mapper.BuilderContext builderContext = new Mapper.BuilderContext(context.indexSettings().getSettings(), context.path());
-                objectMapper = builder.build(builderContext);
-                context.addDynamicMapper(objectMapper);
-                context.path().add(currentFieldName);
-                parseObjectOrField(context, objectMapper);
-                context.path().remove();
-            } else {
-                // not dynamic, read everything up to end object
-                context.parser().skipChildren();
+            switch (dynamic) {
+                case STRICT:
+                    throw new StrictDynamicMappingException(dynamic.name().toLowerCase(Locale.ROOT), mapper.fullPath(), currentFieldName);
+                case TRUE:
+                case STRICT_ALLOW_TEMPLATES:
+                    Mapper.Builder builder = findTemplateBuilder(
+                        context,
+                        currentFieldName,
+                        XContentFieldType.OBJECT,
+                        dynamic,
+                        mapper.fullPath()
+                    );
+
+                    if (builder == null) {
+                        builder = new ObjectMapper.Builder(currentFieldName).enabled(true);
+                    }
+                    Mapper.BuilderContext builderContext = new Mapper.BuilderContext(context.indexSettings().getSettings(), context.path());
+                    objectMapper = builder.build(builderContext);
+                    context.addDynamicMapper(objectMapper);
+                    context.path().add(currentFieldName);
+                    parseObjectOrField(context, objectMapper);
+                    context.path().remove();
+                    break;
+                case FALSE:
+                    // not dynamic, read everything up to end object
+                    context.parser().skipChildren();
             }
             for (int i = 0; i < parentMapperTuple.v1(); i++) {
                 context.path().remove();
@@ -591,31 +605,44 @@ private static void parseArray(ParseContext context, ObjectMapper parentMapper,
                 Tuple<Integer, ObjectMapper> parentMapperTuple = getDynamicParentMapper(context, paths, parentMapper);
                 parentMapper = parentMapperTuple.v2();
                 ObjectMapper.Dynamic dynamic = dynamicOrDefault(parentMapper, context);
-                if (dynamic == ObjectMapper.Dynamic.STRICT) {
-                    throw new StrictDynamicMappingException(parentMapper.fullPath(), arrayFieldName);
-                } else if (dynamic == ObjectMapper.Dynamic.TRUE) {
-                    Mapper.Builder builder = context.root().findTemplateBuilder(context, arrayFieldName, XContentFieldType.OBJECT);
-                    if (builder == null) {
-                        parseNonDynamicArray(context, parentMapper, lastFieldName, arrayFieldName);
-                    } else {
-                        Mapper.BuilderContext builderContext = new Mapper.BuilderContext(
-                            context.indexSettings().getSettings(),
-                            context.path()
+                switch (dynamic) {
+                    case STRICT:
+                        throw new StrictDynamicMappingException(
+                            dynamic.name().toLowerCase(Locale.ROOT),
+                            parentMapper.fullPath(),
+                            arrayFieldName
                         );
-                        mapper = builder.build(builderContext);
-                        assert mapper != null;
-                        if (parsesArrayValue(mapper)) {
-                            context.addDynamicMapper(mapper);
-                            context.path().add(arrayFieldName);
-                            parseObjectOrField(context, mapper);
-                            context.path().remove();
-                        } else {
+                    case TRUE:
+                    case STRICT_ALLOW_TEMPLATES:
+                        Mapper.Builder builder = findTemplateBuilder(
+                            context,
+                            arrayFieldName,
+                            XContentFieldType.OBJECT,
+                            dynamic,
+                            parentMapper.fullPath()
+                        );
+                        if (builder == null) {
                             parseNonDynamicArray(context, parentMapper, lastFieldName, arrayFieldName);
+                        } else {
+                            Mapper.BuilderContext builderContext = new Mapper.BuilderContext(
+                                context.indexSettings().getSettings(),
+                                context.path()
+                            );
+                            mapper = builder.build(builderContext);
+                            assert mapper != null;
+                            if (parsesArrayValue(mapper)) {
+                                context.addDynamicMapper(mapper);
+                                context.path().add(arrayFieldName);
+                                parseObjectOrField(context, mapper);
+                                context.path().remove();
+                            } else {
+                                parseNonDynamicArray(context, parentMapper, lastFieldName, arrayFieldName);
+                            }
                         }
-                    }
-                } else {
-                    // TODO: shouldn't this skip, not parse?
-                    parseNonDynamicArray(context, parentMapper, lastFieldName, arrayFieldName);
+                        break;
+                    case FALSE:
+                        // TODO: shouldn't this skip, not parse?
+                        parseNonDynamicArray(context, parentMapper, lastFieldName, arrayFieldName);
                 }
                 for (int i = 0; i < parentMapperTuple.v1(); i++) {
                     context.path().remove();
@@ -634,6 +661,17 @@ private static void parseNonDynamicArray(ParseContext context, ObjectMapper mapp
         throws IOException {
         XContentParser parser = context.parser();
         XContentParser.Token token;
+        // block array values for composite index fields
+        if (context.indexSettings().isCompositeIndex() && context.mapperService().isFieldPartOfCompositeIndex(arrayFieldName)) {
+            throw new MapperParsingException(
+                String.format(
+                    Locale.ROOT,
+                    "object mapping for [%s] with array for [%s] cannot be accepted as field is also part of composite index mapping which does not accept arrays",
+                    mapper.name(),
+                    arrayFieldName
+                )
+            );
+        }
         final String[] paths = splitAndValidatePath(lastFieldName);
         while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
             if (token == XContentParser.Token.START_OBJECT) {
@@ -692,11 +730,12 @@ private static void parseNullValue(ParseContext context, ObjectMapper parentMapp
         throws IOException {
         // we can only handle null values if we have mappings for them
         Mapper mapper = getMapper(context, parentMapper, lastFieldName, paths);
+        ObjectMapper.Dynamic dynamic = parentMapper.dynamic();
         if (mapper != null) {
             // TODO: passing null to an object seems bogus?
             parseObjectOrField(context, mapper);
-        } else if (parentMapper.dynamic() == ObjectMapper.Dynamic.STRICT) {
-            throw new StrictDynamicMappingException(parentMapper.fullPath(), lastFieldName);
+        } else if (dynamic == ObjectMapper.Dynamic.STRICT || dynamic == ObjectMapper.Dynamic.STRICT_ALLOW_TEMPLATES) {
+            throw new StrictDynamicMappingException(dynamic.name().toLowerCase(Locale.ROOT), parentMapper.fullPath(), lastFieldName);
         }
     }
 
@@ -711,7 +750,9 @@ private static Mapper.Builder<?> newFloatBuilder(String name, Settings settings)
     private static Mapper.Builder<?> createBuilderFromDynamicValue(
         final ParseContext context,
         XContentParser.Token token,
-        String currentFieldName
+        String currentFieldName,
+        ObjectMapper.Dynamic dynamic,
+        String fullPath
     ) throws IOException {
         if (token == XContentParser.Token.VALUE_STRING) {
             String text = context.parser().text();
@@ -733,13 +774,13 @@ private static Mapper.Builder<?> createBuilderFromDynamicValue(
             }
 
             if (parseableAsLong && context.root().numericDetection()) {
-                Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.LONG);
+                Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, XContentFieldType.LONG, dynamic, fullPath);
                 if (builder == null) {
                     builder = newLongBuilder(currentFieldName, context.indexSettings().getSettings());
                 }
                 return builder;
             } else if (parseableAsDouble && context.root().numericDetection()) {
-                Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.DOUBLE);
+                Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, XContentFieldType.DOUBLE, dynamic, fullPath);
                 if (builder == null) {
                     builder = newFloatBuilder(currentFieldName, context.indexSettings().getSettings());
                 }
@@ -755,7 +796,7 @@ private static Mapper.Builder<?> createBuilderFromDynamicValue(
                         // failure to parse this, continue
                         continue;
                     }
-                    Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, dateTimeFormatter);
+                    Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, dateTimeFormatter, dynamic, fullPath);
                     if (builder == null) {
                         boolean ignoreMalformed = IGNORE_MALFORMED_SETTING.get(context.indexSettings().getSettings());
                         builder = new DateFieldMapper.Builder(
@@ -771,7 +812,7 @@ private static Mapper.Builder<?> createBuilderFromDynamicValue(
                 }
             }
 
-            Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.STRING);
+            Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, XContentFieldType.STRING, dynamic, fullPath);
             if (builder == null) {
                 builder = new TextFieldMapper.Builder(currentFieldName, context.mapperService().getIndexAnalyzers()).addMultiField(
                     new KeywordFieldMapper.Builder("keyword").ignoreAbove(256)
@@ -783,7 +824,7 @@ private static Mapper.Builder<?> createBuilderFromDynamicValue(
             if (numberType == XContentParser.NumberType.INT
                 || numberType == XContentParser.NumberType.LONG
                 || numberType == XContentParser.NumberType.BIG_INTEGER) {
-                Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.LONG);
+                Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, XContentFieldType.LONG, dynamic, fullPath);
                 if (builder == null) {
                     builder = newLongBuilder(currentFieldName, context.indexSettings().getSettings());
                 }
@@ -791,7 +832,7 @@ private static Mapper.Builder<?> createBuilderFromDynamicValue(
             } else if (numberType == XContentParser.NumberType.FLOAT
                 || numberType == XContentParser.NumberType.DOUBLE
                 || numberType == XContentParser.NumberType.BIG_DECIMAL) {
-                    Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.DOUBLE);
+                    Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, XContentFieldType.DOUBLE, dynamic, fullPath);
                     if (builder == null) {
                         // no templates are defined, we use float by default instead of double
                         // since this is much more space-efficient and should be enough most of
@@ -801,19 +842,19 @@ private static Mapper.Builder<?> createBuilderFromDynamicValue(
                     return builder;
                 }
         } else if (token == XContentParser.Token.VALUE_BOOLEAN) {
-            Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.BOOLEAN);
+            Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, XContentFieldType.BOOLEAN, dynamic, fullPath);
             if (builder == null) {
                 builder = new BooleanFieldMapper.Builder(currentFieldName);
             }
             return builder;
         } else if (token == XContentParser.Token.VALUE_EMBEDDED_OBJECT) {
-            Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.BINARY);
+            Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, XContentFieldType.BINARY, dynamic, fullPath);
             if (builder == null) {
                 builder = new BinaryFieldMapper.Builder(currentFieldName);
             }
             return builder;
         } else {
-            Mapper.Builder builder = context.root().findTemplateBuilder(context, currentFieldName, XContentFieldType.STRING);
+            Mapper.Builder builder = findTemplateBuilder(context, currentFieldName, XContentFieldType.STRING, dynamic, fullPath);
             if (builder != null) {
                 return builder;
             }
@@ -832,13 +873,13 @@ private static void parseDynamicValue(
     ) throws IOException {
         ObjectMapper.Dynamic dynamic = dynamicOrDefault(parentMapper, context);
         if (dynamic == ObjectMapper.Dynamic.STRICT) {
-            throw new StrictDynamicMappingException(parentMapper.fullPath(), currentFieldName);
+            throw new StrictDynamicMappingException(dynamic.name().toLowerCase(Locale.ROOT), parentMapper.fullPath(), currentFieldName);
         }
         if (dynamic == ObjectMapper.Dynamic.FALSE) {
             return;
         }
         final Mapper.BuilderContext builderContext = new Mapper.BuilderContext(context.indexSettings().getSettings(), context.path());
-        final Mapper.Builder<?> builder = createBuilderFromDynamicValue(context, token, currentFieldName);
+        final Mapper.Builder<?> builder = createBuilderFromDynamicValue(context, token, currentFieldName, dynamic, parentMapper.fullPath());
         Mapper mapper = builder.build(builderContext);
         context.addDynamicMapper(mapper);
 
@@ -926,9 +967,16 @@ private static Tuple<Integer, ObjectMapper> getDynamicParentMapper(
 
                 switch (dynamic) {
                     case STRICT:
-                        throw new StrictDynamicMappingException(parent.fullPath(), paths[i]);
+                        throw new StrictDynamicMappingException(dynamic.name().toLowerCase(Locale.ROOT), parent.fullPath(), paths[i]);
+                    case STRICT_ALLOW_TEMPLATES:
                     case TRUE:
-                        Mapper.Builder builder = context.root().findTemplateBuilder(context, paths[i], XContentFieldType.OBJECT);
+                        Mapper.Builder builder = findTemplateBuilder(
+                            context,
+                            paths[i],
+                            XContentFieldType.OBJECT,
+                            dynamic,
+                            parent.fullPath()
+                        );
                         if (builder == null) {
                             builder = new ObjectMapper.Builder(paths[i]).enabled(true);
                         }
@@ -1010,4 +1058,37 @@ private static Mapper getMapper(final ParseContext context, ObjectMapper objectM
         }
         return objectMapper.getMapper(subfields[subfields.length - 1]);
     }
+
+    // Throws exception if no dynamic templates found but `dynamic` is set to strict_allow_templates
+    @SuppressWarnings("rawtypes")
+    private static Mapper.Builder findTemplateBuilder(
+        ParseContext context,
+        String name,
+        XContentFieldType matchType,
+        ObjectMapper.Dynamic dynamic,
+        String fieldFullPath
+    ) {
+        Mapper.Builder builder = context.root().findTemplateBuilder(context, name, matchType);
+        if (builder == null && dynamic == ObjectMapper.Dynamic.STRICT_ALLOW_TEMPLATES) {
+            throw new StrictDynamicMappingException(dynamic.name().toLowerCase(Locale.ROOT), fieldFullPath, name);
+        }
+
+        return builder;
+    }
+
+    // Throws exception if no dynamic templates found but `dynamic` is set to strict_allow_templates
+    @SuppressWarnings("rawtypes")
+    private static Mapper.Builder findTemplateBuilder(
+        ParseContext context,
+        String name,
+        DateFormatter dateFormat,
+        ObjectMapper.Dynamic dynamic,
+        String fieldFullPath
+    ) {
+        Mapper.Builder builder = context.root().findTemplateBuilder(context, name, dateFormat);
+        if (builder == null && dynamic == ObjectMapper.Dynamic.STRICT_ALLOW_TEMPLATES) {
+            throw new StrictDynamicMappingException(dynamic.name().toLowerCase(Locale.ROOT), fieldFullPath, name);
+        }
+        return builder;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/FieldTypeInference.java b/server/src/main/java/org/opensearch/index/mapper/FieldTypeInference.java
new file mode 100644
index 0000000000000..713bdc4e691cd
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/FieldTypeInference.java
@@ -0,0 +1,181 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.ReaderUtil;
+import org.opensearch.common.Randomness;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.search.lookup.SourceLookup;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * This class performs type inference by analyzing the _source documents. It uses a random sample of documents to infer the field type, similar to dynamic mapping type guessing logic.
+ * Unlike guessing based on the first document, where field could be missing, this method generates a random sample to make a more accurate inference.
+ * This approach is especially useful for handling missing fields, which is common in nested fields within derived fields of object types.
+ *
+ * <p>The sample size should be chosen carefully to ensure a high probability of selecting at least one document where the field is present.
+ * However, it's essential to strike a balance because a large sample size can lead to performance issues since each sample document's _source field is loaded and examined until the field is found.
+ *
+ * <p>Determining the sample size ({@code S}) is akin to deciding how many balls to draw from a bin, ensuring a high probability ({@code >=P}) of drawing at least one green ball (documents with the field) from a mixture of {@code R } red balls (documents without the field) and {@code G } green balls:
+ * <pre>{@code
+ * P >= 1 - C(R, S) / C(R + G, S)
+ * }</pre>
+ * Here, {@code C()} represents the binomial coefficient.
+ * For a high confidence level, we aim for {@code P >= 0.95 }. For example, with {@code 10^7 } documents where the field is present in {@code 2% } of them, the sample size {@code S } should be around 149 to achieve a probability of {@code 0.95}.
+ */
+public class FieldTypeInference {
+    private final IndexReader indexReader;
+    private final String indexName;
+    private final MapperService mapperService;
+    // TODO expose using a index setting
+    private int sampleSize;
+    private static final int DEFAULT_SAMPLE_SIZE = 150;
+    private static final int MAX_SAMPLE_SIZE_ALLOWED = 1000;
+
+    public FieldTypeInference(String indexName, MapperService mapperService, IndexReader indexReader) {
+        this.indexName = indexName;
+        this.mapperService = mapperService;
+        this.indexReader = indexReader;
+        this.sampleSize = DEFAULT_SAMPLE_SIZE;
+    }
+
+    public void setSampleSize(int sampleSize) {
+        if (sampleSize > MAX_SAMPLE_SIZE_ALLOWED) {
+            throw new IllegalArgumentException("sample_size should be less than " + MAX_SAMPLE_SIZE_ALLOWED);
+        }
+        this.sampleSize = sampleSize;
+    }
+
+    public int getSampleSize() {
+        return sampleSize;
+    }
+
+    public Mapper infer(ValueFetcher valueFetcher) throws IOException {
+        RandomSourceValuesGenerator valuesGenerator = new RandomSourceValuesGenerator(sampleSize, indexReader, valueFetcher);
+        Mapper inferredMapper = null;
+        while (inferredMapper == null && valuesGenerator.hasNext()) {
+            List<Object> values = valuesGenerator.next();
+            if (values == null || values.isEmpty()) {
+                continue;
+            }
+            // always use first value in case of multi value field to infer type
+            inferredMapper = inferTypeFromObject(values.get(0));
+        }
+        return inferredMapper;
+    }
+
+    private Mapper inferTypeFromObject(Object o) throws IOException {
+        if (o == null) {
+            return null;
+        }
+        DocumentMapper mapper = mapperService.documentMapper();
+        XContentBuilder builder = XContentFactory.jsonBuilder().startObject().field("field", o).endObject();
+        BytesReference bytesReference = BytesReference.bytes(builder);
+        SourceToParse sourceToParse = new SourceToParse(indexName, "_id", bytesReference, JsonXContent.jsonXContent.mediaType());
+        ParsedDocument parsedDocument = mapper.parse(sourceToParse);
+        Mapping mapping = parsedDocument.dynamicMappingsUpdate();
+        return mapping.root.getMapper("field");
+    }
+
+    private static class RandomSourceValuesGenerator implements Iterator<List<Object>> {
+        private final ValueFetcher valueFetcher;
+        private final IndexReader indexReader;
+        private final SourceLookup sourceLookup;
+        private final int[] docs;
+        private int iter;
+        private int leaf;
+        private final int MAX_ATTEMPTS_TO_GENERATE_RANDOM_SAMPLES = 10000;
+
+        public RandomSourceValuesGenerator(int sampleSize, IndexReader indexReader, ValueFetcher valueFetcher) {
+            this.valueFetcher = valueFetcher;
+            this.indexReader = indexReader;
+            sampleSize = Math.min(sampleSize, indexReader.numDocs());
+            this.docs = getSortedRandomNum(
+                sampleSize,
+                indexReader.numDocs(),
+                Math.max(sampleSize, MAX_ATTEMPTS_TO_GENERATE_RANDOM_SAMPLES)
+            );
+            this.iter = 0;
+            this.leaf = -1;
+            this.sourceLookup = new SourceLookup();
+            if (hasNext()) {
+                setNextLeaf();
+            }
+        }
+
+        @Override
+        public boolean hasNext() {
+            return iter < docs.length && leaf < indexReader.leaves().size();
+        }
+
+        /**
+         * Ensure hasNext() is called before calling next()
+         */
+        @Override
+        public List<Object> next() {
+            int docID = docs[iter] - indexReader.leaves().get(leaf).docBase;
+            if (docID >= indexReader.leaves().get(leaf).reader().numDocs()) {
+                setNextLeaf();
+            }
+            // deleted docs are getting used to infer type, which should be okay?
+            sourceLookup.setSegmentAndDocument(indexReader.leaves().get(leaf), docs[iter] - indexReader.leaves().get(leaf).docBase);
+            try {
+                iter++;
+                return valueFetcher.fetchValues(sourceLookup);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        private void setNextLeaf() {
+            int readerIndex = ReaderUtil.subIndex(docs[iter], indexReader.leaves());
+            if (readerIndex != leaf) {
+                leaf = readerIndex;
+            } else {
+                // this will only happen when leaves are exhausted and readerIndex will be indexReader.leaves()-1.
+                leaf++;
+            }
+            if (leaf < indexReader.leaves().size()) {
+                valueFetcher.setNextReader(indexReader.leaves().get(leaf));
+            }
+        }
+
+        private static int[] getSortedRandomNum(int sampleSize, int upperBound, int attempts) {
+            Set<Integer> generatedNumbers = new TreeSet<>();
+            Random random = Randomness.get();
+            int itr = 0;
+            if (upperBound <= 10 * sampleSize) {
+                List<Integer> numberList = new ArrayList<>();
+                for (int i = 0; i < upperBound; i++) {
+                    numberList.add(i);
+                }
+                Collections.shuffle(numberList, random);
+                generatedNumbers.addAll(numberList.subList(0, sampleSize));
+            } else {
+                while (generatedNumbers.size() < sampleSize && itr++ < attempts) {
+                    int randomNumber = random.nextInt(upperBound);
+                    generatedNumbers.add(randomNumber);
+                }
+            }
+            return generatedNumbers.stream().mapToInt(Integer::valueOf).toArray();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/FieldValueConverter.java b/server/src/main/java/org/opensearch/index/mapper/FieldValueConverter.java
new file mode 100644
index 0000000000000..cb16dba6ab640
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/FieldValueConverter.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+/**
+ * <p>
+ * Implementations of this interface should define the conversion logic
+ * from a sortable long value to a double value, taking into account any necessary
+ * scaling, normalization, or other transformations required by the specific
+ * field type.
+ *
+ * @opensearch.experimental
+ */
+public interface FieldValueConverter {
+
+    /**
+     * Converts the Lucene representation of the value as a long to an actual double representation
+     *
+     * @param value the long value to be converted
+     * @return the corresponding double value
+     */
+    double toDoubleValue(long value);
+
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/FlatObjectFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/FlatObjectFieldMapper.java
index 9a3f2595a7c9e..bf8f83e1b95df 100644
--- a/server/src/main/java/org/opensearch/index/mapper/FlatObjectFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/FlatObjectFieldMapper.java
@@ -568,8 +568,8 @@ protected void parseCreateField(ParseContext context) throws IOException {
         if (context.externalValueSet()) {
             String value = context.externalValue().toString();
             parseValueAddFields(context, value, fieldType().name());
-        } else {
-            JsonToStringXContentParser JsonToStringParser = new JsonToStringXContentParser(
+        } else if (context.parser().currentToken() != XContentParser.Token.VALUE_NULL) {
+            JsonToStringXContentParser jsonToStringParser = new JsonToStringXContentParser(
                 NamedXContentRegistry.EMPTY,
                 DeprecationHandler.IGNORE_DEPRECATIONS,
                 context.parser(),
@@ -579,7 +579,7 @@ protected void parseCreateField(ParseContext context) throws IOException {
               JsonToStringParser is the main parser class to transform JSON into stringFields in a XContentParser
               It reads the JSON object and parsed to a list of string
              */
-            XContentParser parser = JsonToStringParser.parseObject();
+            XContentParser parser = jsonToStringParser.parseObject();
 
             XContentParser.Token currentToken;
             while ((currentToken = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
@@ -594,7 +594,6 @@ protected void parseCreateField(ParseContext context) throws IOException {
                 }
 
             }
-
         }
 
     }
diff --git a/server/src/main/java/org/opensearch/index/mapper/KeywordFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/KeywordFieldMapper.java
index 42b974734e5e7..2116ac522b705 100644
--- a/server/src/main/java/org/opensearch/index/mapper/KeywordFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/KeywordFieldMapper.java
@@ -549,7 +549,7 @@ public Query fuzzyQuery(
                 );
             }
             if (isSearchable() && hasDocValues()) {
-                Query indexQuery = super.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, context);
+                Query indexQuery = super.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, method, context);
                 Query dvQuery = super.fuzzyQuery(
                     value,
                     fuzziness,
@@ -703,7 +703,7 @@ protected void parseCreateField(ParseContext context) throws IOException {
         }
     }
 
-    private static String normalizeValue(NamedAnalyzer normalizer, String field, String value) throws IOException {
+    static String normalizeValue(NamedAnalyzer normalizer, String field, String value) throws IOException {
         try (TokenStream ts = normalizer.tokenStream(field, value)) {
             final CharTermAttribute termAtt = ts.addAttribute(CharTermAttribute.class);
             ts.reset();
diff --git a/server/src/main/java/org/opensearch/index/mapper/Mapper.java b/server/src/main/java/org/opensearch/index/mapper/Mapper.java
index bd5d3f15c0706..87fdd8266a795 100644
--- a/server/src/main/java/org/opensearch/index/mapper/Mapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/Mapper.java
@@ -100,7 +100,7 @@ public Version indexCreatedVersionOrDefault(@Nullable Version defaultValue) {
      * @opensearch.api
      */
     @PublicApi(since = "1.0.0")
-    public abstract static class Builder<T extends Builder> {
+    public abstract static class Builder<T extends Builder> implements MapperBuilderProperties {
 
         public String name;
 
@@ -253,6 +253,11 @@ public boolean isWithinMultiField() {
         }
 
         Mapper.Builder<?> parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException;
+
+        default Mapper.Builder<?> parse(String name, Map<String, Object> node, ParserContext parserContext, ObjectMapper.Builder objBuilder)
+            throws MapperParsingException {
+            throw new UnsupportedOperationException("should not be invoked");
+        }
     }
 
     private final String simpleName;
diff --git a/server/src/main/java/org/opensearch/index/mapper/MapperBuilderProperties.java b/server/src/main/java/org/opensearch/index/mapper/MapperBuilderProperties.java
new file mode 100644
index 0000000000000..ce7b8f28b0b29
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/MapperBuilderProperties.java
@@ -0,0 +1,41 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.index.compositeindex.datacube.DimensionType;
+
+import java.util.Optional;
+
+/**
+ * An interface that defines properties for MapperBuilder implementations.
+ *
+ * @opensearch.experimental
+ */
+public interface MapperBuilderProperties {
+
+    /**
+     * Indicates whether the implementation supports data cube dimensions.
+     *
+     * @return an Optional containing the supported DimensionType if data cube dimensions are supported,
+     *         or an empty Optional if not supported
+     */
+    default Optional<DimensionType> getSupportedDataCubeDimensionType() {
+        return Optional.empty();
+    }
+
+    /**
+     * Indicates whether the implementation supports data cube metrics.
+     *
+     * @return true if data cube metrics are supported, false otherwise
+     */
+    default boolean isDataCubeMetricSupported() {
+        return false;
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/MapperService.java b/server/src/main/java/org/opensearch/index/mapper/MapperService.java
index 5cd1e0849a36d..a3f9d75cbb00a 100644
--- a/server/src/main/java/org/opensearch/index/mapper/MapperService.java
+++ b/server/src/main/java/org/opensearch/index/mapper/MapperService.java
@@ -227,6 +227,9 @@ public enum MergeReason {
 
     private final BooleanSupplier idFieldDataEnabled;
 
+    private volatile Set<CompositeMappedFieldType> compositeMappedFieldTypes;
+    private volatile Set<String> fieldsPartOfCompositeMappings;
+
     public MapperService(
         IndexSettings indexSettings,
         IndexAnalyzers indexAnalyzers,
@@ -538,9 +541,21 @@ private synchronized Map<String, DocumentMapper> internalMerge(DocumentMapper ma
         }
 
         assert results.values().stream().allMatch(this::assertSerialization);
+
+        // initialize composite fields post merge
+        this.compositeMappedFieldTypes = getCompositeFieldTypesFromMapper();
+        buildCompositeFieldLookup();
         return results;
     }
 
+    private void buildCompositeFieldLookup() {
+        Set<String> fieldsPartOfCompositeMappings = new HashSet<>();
+        for (CompositeMappedFieldType fieldType : compositeMappedFieldTypes) {
+            fieldsPartOfCompositeMappings.addAll(fieldType.fields());
+        }
+        this.fieldsPartOfCompositeMappings = fieldsPartOfCompositeMappings;
+    }
+
     private boolean assertSerialization(DocumentMapper mapper) {
         // capture the source now, it may change due to concurrent parsing
         final CompressedXContent mappingSource = mapper.mappingSource();
@@ -646,6 +661,31 @@ public Iterable<MappedFieldType> fieldTypes() {
         return this.mapper == null ? Collections.emptySet() : this.mapper.fieldTypes();
     }
 
+    public boolean isCompositeIndexPresent() {
+        return this.mapper != null && !getCompositeFieldTypes().isEmpty();
+    }
+
+    public Set<CompositeMappedFieldType> getCompositeFieldTypes() {
+        return compositeMappedFieldTypes;
+    }
+
+    private Set<CompositeMappedFieldType> getCompositeFieldTypesFromMapper() {
+        Set<CompositeMappedFieldType> compositeMappedFieldTypes = new HashSet<>();
+        if (this.mapper == null) {
+            return Collections.emptySet();
+        }
+        for (MappedFieldType type : this.mapper.fieldTypes()) {
+            if (type instanceof CompositeMappedFieldType) {
+                compositeMappedFieldTypes.add((CompositeMappedFieldType) type);
+            }
+        }
+        return compositeMappedFieldTypes;
+    }
+
+    public boolean isFieldPartOfCompositeIndex(String field) {
+        return fieldsPartOfCompositeMappings.contains(field);
+    }
+
     public ObjectMapper getObjectMapper(String name) {
         return this.mapper == null ? null : this.mapper.objectMappers().get(name);
     }
@@ -710,6 +750,13 @@ public boolean isMetadataField(String field) {
         return mapperRegistry.isMetadataField(indexVersionCreated, field);
     }
 
+    /**
+     * Returns a set containing the registered metadata fields
+     */
+    public Set<String> getMetadataFields() {
+        return Collections.unmodifiableSet(mapperRegistry.getMetadataMapperParsers(indexVersionCreated).keySet());
+    }
+
     /**
      * An analyzer wrapper that can lookup fields within the index mappings
      */
diff --git a/server/src/main/java/org/opensearch/index/mapper/NoOpDerivedFieldResolver.java b/server/src/main/java/org/opensearch/index/mapper/NoOpDerivedFieldResolver.java
new file mode 100644
index 0000000000000..b3b8c83685407
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/NoOpDerivedFieldResolver.java
@@ -0,0 +1,28 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import java.util.Collections;
+import java.util.Set;
+
+/**
+ * Used when the derived field feature is disabled
+ */
+public class NoOpDerivedFieldResolver implements DerivedFieldResolver {
+
+    @Override
+    public Set<String> resolvePattern(String pattern) {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public MappedFieldType resolve(String fieldName) {
+        return null;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
index eb3a99b0e0388..43e975f95757b 100644
--- a/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
@@ -46,8 +46,10 @@
 import org.apache.lucene.sandbox.document.HalfFloatPoint;
 import org.apache.lucene.search.BoostQuery;
 import org.apache.lucene.search.IndexOrDocValuesQuery;
+import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.IndexSortSortedNumericDocValuesRangeQuery;
 import org.apache.lucene.search.MatchNoDocsQuery;
+import org.apache.lucene.search.PointInSetQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.NumericUtils;
@@ -58,8 +60,10 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.core.xcontent.XContentParser.Token;
+import org.opensearch.index.compositeindex.datacube.DimensionType;
 import org.opensearch.index.document.SortedUnsignedLongDocValuesRangeQuery;
 import org.opensearch.index.document.SortedUnsignedLongDocValuesSetQuery;
 import org.opensearch.index.fielddata.IndexFieldData;
@@ -68,20 +72,26 @@
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.lookup.SearchLookup;
+import org.opensearch.search.query.BitmapDocValuesQuery;
 
 import java.io.IOException;
 import java.math.BigInteger;
+import java.nio.ByteBuffer;
 import java.time.ZoneId;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+import org.roaringbitmap.RoaringBitmap;
+
 /**
  * A {@link FieldMapper} for numeric types: byte, short, int, long, float and double.
  *
@@ -164,6 +174,22 @@ public NumberFieldMapper build(BuilderContext context) {
             MappedFieldType ft = new NumberFieldType(buildFullName(context), this);
             return new NumberFieldMapper(name, ft, multiFieldsBuilder.build(this, context), copyTo.build(), this);
         }
+
+        @Override
+        public Optional<DimensionType> getSupportedDataCubeDimensionType() {
+
+            // unsigned long is not supported as dimension for star tree
+            if (type.numericType.equals(NumericType.UNSIGNED_LONG)) {
+                return Optional.empty();
+            }
+
+            return Optional.of(DimensionType.NUMERIC);
+        }
+
+        @Override
+        public boolean isDataCubeMetricSupported() {
+            return true;
+        }
     }
 
     /**
@@ -171,7 +197,7 @@ public NumberFieldMapper build(BuilderContext context) {
      *
      * @opensearch.internal
      */
-    public enum NumberType {
+    public enum NumberType implements NumericPointEncoder, FieldValueConverter {
         HALF_FLOAT("half_float", NumericType.HALF_FLOAT) {
             @Override
             public Float parse(Object value, boolean coerce) {
@@ -194,6 +220,18 @@ public Number parsePoint(byte[] value) {
                 return HalfFloatPoint.decodeDimension(value, 0);
             }
 
+            @Override
+            public byte[] encodePoint(Number value) {
+                byte[] point = new byte[HalfFloatPoint.BYTES];
+                HalfFloatPoint.encodeDimension(value.floatValue(), point, 0);
+                return point;
+            }
+
+            @Override
+            public double toDoubleValue(long value) {
+                return HalfFloatPoint.sortableShortToHalfFloat((short) value);
+            }
+
             @Override
             public Float parse(XContentParser parser, boolean coerce) throws IOException {
                 float parsed = parser.floatValue(coerce);
@@ -331,6 +369,18 @@ public Number parsePoint(byte[] value) {
                 return FloatPoint.decodeDimension(value, 0);
             }
 
+            @Override
+            public byte[] encodePoint(Number value) {
+                byte[] point = new byte[Float.BYTES];
+                FloatPoint.encodeDimension(value.floatValue(), point, 0);
+                return point;
+            }
+
+            @Override
+            public double toDoubleValue(long value) {
+                return NumericUtils.sortableIntToFloat((int) value);
+            }
+
             @Override
             public Float parse(XContentParser parser, boolean coerce) throws IOException {
                 float parsed = parser.floatValue(coerce);
@@ -457,6 +507,18 @@ public Number parsePoint(byte[] value) {
                 return DoublePoint.decodeDimension(value, 0);
             }
 
+            @Override
+            public byte[] encodePoint(Number value) {
+                byte[] point = new byte[Double.BYTES];
+                DoublePoint.encodeDimension(value.doubleValue(), point, 0);
+                return point;
+            }
+
+            @Override
+            public double toDoubleValue(long value) {
+                return NumericUtils.sortableLongToDouble(value);
+            }
+
             @Override
             public Double parse(XContentParser parser, boolean coerce) throws IOException {
                 double parsed = parser.doubleValue(coerce);
@@ -582,6 +644,18 @@ public Number parsePoint(byte[] value) {
                 return INTEGER.parsePoint(value).byteValue();
             }
 
+            @Override
+            public byte[] encodePoint(Number value) {
+                byte[] point = new byte[Integer.BYTES];
+                IntPoint.encodeDimension(value.intValue(), point, 0);
+                return point;
+            }
+
+            @Override
+            public double toDoubleValue(long value) {
+                return objectToDouble(value);
+            }
+
             @Override
             public Short parse(XContentParser parser, boolean coerce) throws IOException {
                 int value = parser.intValue(coerce);
@@ -654,6 +728,18 @@ public Number parsePoint(byte[] value) {
                 return INTEGER.parsePoint(value).shortValue();
             }
 
+            @Override
+            public byte[] encodePoint(Number value) {
+                byte[] point = new byte[Integer.BYTES];
+                IntPoint.encodeDimension(value.intValue(), point, 0);
+                return point;
+            }
+
+            @Override
+            public double toDoubleValue(long value) {
+                return (double) value;
+            }
+
             @Override
             public Short parse(XContentParser parser, boolean coerce) throws IOException {
                 return parser.shortValue(coerce);
@@ -722,6 +808,18 @@ public Number parsePoint(byte[] value) {
                 return IntPoint.decodeDimension(value, 0);
             }
 
+            @Override
+            public byte[] encodePoint(Number value) {
+                byte[] point = new byte[Integer.BYTES];
+                IntPoint.encodeDimension(value.intValue(), point, 0);
+                return point;
+            }
+
+            @Override
+            public double toDoubleValue(long value) {
+                return (double) value;
+            }
+
             @Override
             public Integer parse(XContentParser parser, boolean coerce) throws IOException {
                 return parser.intValue(coerce);
@@ -780,6 +878,24 @@ public Query termsQuery(String field, List<Object> values, boolean hasDocValues,
                 return IntPoint.newSetQuery(field, v);
             }
 
+            @Override
+            public Query bitmapQuery(String field, BytesArray bitmapArray, boolean isSearchable, boolean hasDocValues) {
+                RoaringBitmap bitmap = new RoaringBitmap();
+                try {
+                    bitmap.deserialize(ByteBuffer.wrap(bitmapArray.array()));
+                } catch (Exception e) {
+                    throw new IllegalArgumentException("Failed to deserialize the bitmap.", e);
+                }
+
+                if (isSearchable && hasDocValues) {
+                    return new IndexOrDocValuesQuery(bitmapIndexQuery(field, bitmap), new BitmapDocValuesQuery(field, bitmap));
+                }
+                if (isSearchable) {
+                    return bitmapIndexQuery(field, bitmap);
+                }
+                return new BitmapDocValuesQuery(field, bitmap);
+            }
+
             @Override
             public Query rangeQuery(
                 String field,
@@ -868,6 +984,18 @@ public Number parsePoint(byte[] value) {
                 return LongPoint.decodeDimension(value, 0);
             }
 
+            @Override
+            public byte[] encodePoint(Number value) {
+                byte[] point = new byte[Long.BYTES];
+                LongPoint.encodeDimension(value.longValue(), point, 0);
+                return point;
+            }
+
+            @Override
+            public double toDoubleValue(long value) {
+                return (double) value;
+            }
+
             @Override
             public Long parse(XContentParser parser, boolean coerce) throws IOException {
                 return parser.longValue(coerce);
@@ -988,6 +1116,18 @@ public Number parsePoint(byte[] value) {
                 return BigIntegerPoint.decodeDimension(value, 0);
             }
 
+            @Override
+            public byte[] encodePoint(Number value) {
+                byte[] point = new byte[BigIntegerPoint.BYTES];
+                BigIntegerPoint.encodeDimension(objectToUnsignedLong(value, false, true), point, 0);
+                return point;
+            }
+
+            @Override
+            public double toDoubleValue(long value) {
+                return Numbers.unsignedLongToDouble(value);
+            }
+
             @Override
             public BigInteger parse(XContentParser parser, boolean coerce) throws IOException {
                 return parser.bigIntegerValue(coerce);
@@ -1100,12 +1240,16 @@ Number valueForSearch(String value) {
             this.parser = new TypeParser((n, c) -> new Builder(n, this, c.getSettings()));
         }
 
-        /** Get the associated type name. */
+        /**
+         * Get the associated type name.
+         */
         public final String typeName() {
             return name;
         }
 
-        /** Get the associated numeric type */
+        /**
+         * Get the associated numeric type
+         */
         public final NumericType numericType() {
             return numericType;
         }
@@ -1118,6 +1262,10 @@ public final TypeParser parser() {
 
         public abstract Query termsQuery(String field, List<Object> values, boolean hasDocValues, boolean isSearchable);
 
+        public Query bitmapQuery(String field, BytesArray bitmap, boolean isSearchable, boolean hasDocValues) {
+            throw new IllegalArgumentException("Field [" + name + "] of type [" + typeName() + "] does not support bitmap queries");
+        }
+
         public abstract Query rangeQuery(
             String field,
             Object lowerTerm,
@@ -1215,16 +1363,30 @@ public static long objectToLong(Object value, boolean coerce) {
             return Numbers.toLong(stringValue, coerce);
         }
 
+        public static BigInteger objectToUnsignedLong(Object value, boolean coerce) {
+            return objectToUnsignedLong(value, coerce, false);
+        }
+
         /**
-         * Converts and Object to a {@code long} by checking it against known
+         * Converts an Object to a {@code BigInteger} by checking it against known
          * types and checking its range.
+         *
+         * @param lenientBound if true, use MIN or MAX if the value is out of bound
          */
-        public static BigInteger objectToUnsignedLong(Object value, boolean coerce) {
+        public static BigInteger objectToUnsignedLong(Object value, boolean coerce, boolean lenientBound) {
             if (value instanceof Long) {
                 return Numbers.toUnsignedBigInteger(((Long) value).longValue());
             }
 
             double doubleValue = objectToDouble(value);
+            if (lenientBound) {
+                if (doubleValue < Numbers.MIN_UNSIGNED_LONG_VALUE.doubleValue()) {
+                    return Numbers.MIN_UNSIGNED_LONG_VALUE;
+                }
+                if (doubleValue > Numbers.MAX_UNSIGNED_LONG_VALUE.doubleValue()) {
+                    return Numbers.MAX_UNSIGNED_LONG_VALUE;
+                }
+            }
             if (doubleValue < Numbers.MIN_UNSIGNED_LONG_VALUE.doubleValue()
                 || doubleValue > Numbers.MAX_UNSIGNED_LONG_VALUE.doubleValue()) {
                 throw new IllegalArgumentException("Value [" + value + "] is out of range for an unsigned long");
@@ -1340,8 +1502,45 @@ public static Query unsignedLongRangeQuery(
                     u = u.subtract(BigInteger.ONE);
                 }
             }
+            if (l.compareTo(u) > 0) {
+                return new MatchNoDocsQuery();
+            }
             return builder.apply(l, u);
         }
+
+        static PointInSetQuery bitmapIndexQuery(String field, RoaringBitmap bitmap) {
+            final BytesRef encoded = new BytesRef(new byte[Integer.BYTES]);
+            return new PointInSetQuery(field, 1, Integer.BYTES, new PointInSetQuery.Stream() {
+
+                final Iterator<Integer> iterator = bitmap.iterator();
+
+                @Override
+                public BytesRef next() {
+                    int value;
+                    if (iterator.hasNext()) {
+                        value = iterator.next();
+                    } else {
+                        return null;
+                    }
+                    IntPoint.encodeDimension(value, encoded.bytes, 0);
+                    return encoded;
+                }
+            }) {
+                @Override
+                public Query rewrite(IndexSearcher indexSearcher) throws IOException {
+                    if (bitmap.isEmpty()) {
+                        return new MatchNoDocsQuery();
+                    }
+                    return super.rewrite(indexSearcher);
+                }
+
+                @Override
+                protected String toString(byte[] value) {
+                    assert value.length == Integer.BYTES;
+                    return Integer.toString(IntPoint.decodeDimension(value, 0));
+                }
+            };
+        }
     }
 
     /**
@@ -1349,7 +1548,7 @@ public static Query unsignedLongRangeQuery(
      *
      * @opensearch.internal
      */
-    public static class NumberFieldType extends SimpleMappedFieldType {
+    public static class NumberFieldType extends SimpleMappedFieldType implements NumericPointEncoder, FieldValueConverter {
 
         private final NumberType type;
         private final boolean coerce;
@@ -1394,6 +1593,10 @@ public String typeName() {
             return type.name;
         }
 
+        public NumberType numberType() {
+            return type;
+        }
+
         public NumericType numericType() {
             return type.numericType();
         }
@@ -1418,6 +1621,11 @@ public Query termsQuery(List values, QueryShardContext context) {
             return query;
         }
 
+        public Query bitmapQuery(BytesArray bitmap) {
+            failIfNotIndexedAndNoDocValues();
+            return type.bitmapQuery(name(), bitmap, isSearchable(), hasDocValues());
+        }
+
         @Override
         public Query rangeQuery(Object lowerTerm, Object upperTerm, boolean includeLower, boolean includeUpper, QueryShardContext context) {
             failIfNotIndexedAndNoDocValues();
@@ -1501,6 +1709,16 @@ public DocValueFormat docValueFormat(String format, ZoneId timeZone) {
         public Number parsePoint(byte[] value) {
             return type.parsePoint(value);
         }
+
+        @Override
+        public byte[] encodePoint(Number value) {
+            return type.encodePoint(value);
+        }
+
+        @Override
+        public double toDoubleValue(long value) {
+            return type.toDoubleValue(value);
+        }
     }
 
     private final NumberType type;
diff --git a/server/src/main/java/org/opensearch/index/mapper/NumericPointEncoder.java b/server/src/main/java/org/opensearch/index/mapper/NumericPointEncoder.java
new file mode 100644
index 0000000000000..be746a5526594
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/NumericPointEncoder.java
@@ -0,0 +1,16 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+/**
+ * Interface for encoding a point value
+ */
+public interface NumericPointEncoder {
+    byte[] encodePoint(Number value);
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/ObjectDerivedFieldType.java b/server/src/main/java/org/opensearch/index/mapper/ObjectDerivedFieldType.java
new file mode 100644
index 0000000000000..3d0165f702fda
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/ObjectDerivedFieldType.java
@@ -0,0 +1,185 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.index.IndexableField;
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.common.time.DateFormatter;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.index.analysis.IndexAnalyzers;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.DerivedFieldScript;
+import org.opensearch.search.lookup.SearchLookup;
+import org.opensearch.search.lookup.SourceLookup;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * Represents a derived field in OpenSearch, which behaves similarly to an Object field type within the context of derived fields.
+ * It is not a primitive field type and does not directly support queries. However, any nested derived fields contained within a DerivedField object
+ * are also classified as Object derived fields, which support queries depending on their inferred type.
+ *
+ * <p>
+ * For example, consider the following mapping:
+ * <pre>
+ * mappings:
+ *     derived:
+ *         regular_field:
+ *             type: keyword
+ *             script: "emit(keyword_string)"
+ *         derived_obj:
+ *             type: object
+ *             script: "emit(json_obj)"
+ * </pre>
+ *
+ * Here, we have a regular keyword derived field and an object type derived field. Any nested field within `derived_obj` does not need to be explicitly defined.
+ * Their type will be inferred, and the value will be extracted from the `json_obj` emitted by the script associated with the parent object `derived_obj`.
+ * The {@link ObjectDerivedFieldValueFetcher} is used for this purpose, which accepts `sub_field` and can extract the nested fields from JSON.
+ *
+ * <p>
+ * For instance, if `derived_obj` emits the following document:
+ * <pre>
+ * "derived_obj" : {
+ *     "sub_field_1": "value 1",
+ *     "sub_field_2": {
+ *         "sub_field_3": "value_3"
+ *     }
+ * }
+ * </pre>
+ *
+ * Then nested fields such as `sub_field_1` and `sub_field_3` can be used in the query as `derived_obj.sub_field_1` and `derived_obj.sub_field_2.sub_field_3` respectively.
+ * Both of these nested derived fields will be an instance of `ObjectDerivedFieldType`; however, their mapped field type will be inferred based on the type of value they hold, to support queries on them.
+ *
+ * @see FieldTypeInference for details on the type inference logic used in derived fields.
+ */
+public class ObjectDerivedFieldType extends DerivedFieldType {
+
+    ObjectDerivedFieldType(
+        DerivedField derivedField,
+        FieldMapper typeFieldMapper,
+        Function<Object, IndexableField> fieldFunction,
+        IndexAnalyzers indexAnalyzers
+    ) {
+        super(derivedField, typeFieldMapper, derivedField.getType().equals(DerivedFieldSupportedTypes.DATE.getName()) ? (o -> {
+            // this is needed to support date type for nested fields as they are required to be converted to long to create
+            // IndexableField
+            if (o instanceof String) {
+                return fieldFunction.apply(((DateFieldMapper) typeFieldMapper).fieldType().parse((String) o));
+            } else {
+                return fieldFunction.apply(o);
+            }
+        }) : fieldFunction, indexAnalyzers);
+    }
+
+    @Override
+    public DerivedFieldValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
+        if (format != null) {
+            throw new IllegalArgumentException("Field [" + name() + "] of type [" + typeName() + "] doesn't support formats.");
+        }
+        Function<Object, Object> valueForDisplay = DerivedFieldSupportedTypes.getValueForDisplayGenerator(
+            getType(),
+            derivedField.getFormat() != null ? DateFormatter.forPattern(derivedField.getFormat()) : null
+        );
+
+        Function<Object, Object> dateFormatter = derivedField.getType().equals(DerivedFieldSupportedTypes.DATE.getName()) ? (o -> {
+            // this is needed to support date type for nested fields as they are required to be converted to long
+            if (o instanceof String) {
+                return ((DateFieldMapper) typeFieldMapper).fieldType().parse((String) o);
+            } else {
+                return o;
+            }
+        }) : null;
+
+        String subFieldName = name().substring(name().indexOf(".") + 1);
+        return new ObjectDerivedFieldValueFetcher(
+            subFieldName,
+            getDerivedFieldLeafFactory(derivedField.getScript(), context, searchLookup == null ? context.lookup() : searchLookup),
+            valueForDisplay,
+            derivedField.getIgnoreMalformed(),
+            dateFormatter
+        );
+    }
+
+    static class ObjectDerivedFieldValueFetcher extends DerivedFieldValueFetcher {
+        private final String subField;
+
+        // TODO add it as part of index setting?
+        private final boolean ignoreOnMalFormed;
+
+        private final Function<Object, Object> dateFormatter;
+
+        ObjectDerivedFieldValueFetcher(
+            String subField,
+            DerivedFieldScript.LeafFactory derivedFieldScriptFactory,
+            Function<Object, Object> valueForDisplay,
+            boolean ignoreOnMalFormed
+        ) {
+            super(derivedFieldScriptFactory, valueForDisplay);
+            this.subField = subField;
+            this.ignoreOnMalFormed = ignoreOnMalFormed;
+            this.dateFormatter = null;
+        }
+
+        ObjectDerivedFieldValueFetcher(
+            String subField,
+            DerivedFieldScript.LeafFactory derivedFieldScriptFactory,
+            Function<Object, Object> valueForDisplay,
+            boolean ignoreOnMalFormed,
+            Function<Object, Object> dateFormatter
+        ) {
+            super(derivedFieldScriptFactory, valueForDisplay);
+            this.subField = subField;
+            this.ignoreOnMalFormed = ignoreOnMalFormed;
+            this.dateFormatter = dateFormatter;
+        }
+
+        @Override
+        public List<Object> fetchValuesInternal(SourceLookup lookup) {
+            List<Object> jsonObjects = super.fetchValuesInternal(lookup);
+            List<Object> result = new ArrayList<>();
+            for (Object o : jsonObjects) {
+                try {
+                    if (o == null) {
+                        continue;
+                    }
+                    Map<String, Object> s = XContentHelper.convertToMap(JsonXContent.jsonXContent, (String) o, false);
+                    Object nestedFieldObj = getNestedField(s, subField);
+                    if (nestedFieldObj instanceof List) {
+                        result.addAll((List<?>) nestedFieldObj);
+                    } else {
+                        result.add(dateFormatter != null ? dateFormatter.apply(nestedFieldObj) : nestedFieldObj);
+                    }
+                } catch (OpenSearchParseException e) {
+                    if (!ignoreOnMalFormed) {
+                        throw e;
+                    }
+                }
+            }
+            return result;
+        }
+
+        private static Object getNestedField(Map<String, Object> obj, String key) {
+            String[] keyParts = key.split("\\.");
+            Map<String, Object> currentObj = obj;
+            for (int i = 0; i < keyParts.length - 1; i++) {
+                Object value = currentObj.get(keyParts[i]);
+                if (value instanceof Map) {
+                    currentObj = (Map<String, Object>) value;
+                } else {
+                    return null;
+                }
+            }
+            return currentObj.get(keyParts[keyParts.length - 1]);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java b/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
index 92ffdb60e6cde..dd984373fc9df 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
@@ -42,9 +42,11 @@
 import org.opensearch.common.collect.CopyOnWriteHashMap;
 import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.support.XContentMapValues;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
 import org.opensearch.index.mapper.MapperService.MergeReason;
 
 import java.io.IOException;
@@ -90,7 +92,8 @@ public static class Defaults {
     public enum Dynamic {
         TRUE,
         FALSE,
-        STRICT
+        STRICT,
+        STRICT_ALLOW_TEMPLATES
     }
 
     /**
@@ -176,6 +179,7 @@ public void setIncludeInRoot(boolean value) {
      * @opensearch.internal
      */
     @SuppressWarnings("rawtypes")
+    @PublicApi(since = "1.0.0")
     public static class Builder<T extends Builder> extends Mapper.Builder<T> {
 
         protected Explicit<Boolean> enabled = new Explicit<>(true, false);
@@ -262,14 +266,25 @@ public static class TypeParser implements Mapper.TypeParser {
         public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext parserContext) throws MapperParsingException {
             ObjectMapper.Builder builder = new Builder(name);
             parseNested(name, node, builder, parserContext);
+            Object compositeField = null;
             for (Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator(); iterator.hasNext();) {
                 Map.Entry<String, Object> entry = iterator.next();
                 String fieldName = entry.getKey();
                 Object fieldNode = entry.getValue();
-                if (parseObjectOrDocumentTypeProperties(fieldName, fieldNode, parserContext, builder)) {
+                if (fieldName.equals("composite")) {
+                    compositeField = fieldNode;
                     iterator.remove();
+                } else {
+                    if (parseObjectOrDocumentTypeProperties(fieldName, fieldNode, parserContext, builder)) {
+                        iterator.remove();
+                    }
                 }
             }
+            // Important : Composite field is made up of 2 or more source fields of the index, so this must be called
+            // after parsing all other properties
+            if (compositeField != null) {
+                parseCompositeField(builder, (Map<String, Object>) compositeField, parserContext);
+            }
             return builder;
         }
 
@@ -283,6 +298,8 @@ protected static boolean parseObjectOrDocumentTypeProperties(
                 String value = fieldNode.toString();
                 if (value.equalsIgnoreCase("strict")) {
                     builder.dynamic(Dynamic.STRICT);
+                } else if (value.equalsIgnoreCase("strict_allow_templates")) {
+                    builder.dynamic(Dynamic.STRICT_ALLOW_TEMPLATES);
                 } else {
                     boolean dynamic = XContentMapValues.nodeBooleanValue(fieldNode, fieldName + ".dynamic");
                     builder.dynamic(dynamic ? Dynamic.TRUE : Dynamic.FALSE);
@@ -407,6 +424,105 @@ protected static void parseDerived(ObjectMapper.Builder objBuilder, Map<String,
             );
         }
 
+        /**
+         * Contains logic to parse 'composite' section of mappings. This should be called only after
+         * parsing normal properties as this checks if the given fields are also source fields of the index.
+         */
+        protected static void parseCompositeField(
+            ObjectMapper.Builder objBuilder,
+            Map<String, Object> compositeNode,
+            ParserContext parserContext
+        ) {
+            if (!FeatureFlags.isEnabled(FeatureFlags.STAR_TREE_INDEX_SETTING)) {
+                throw new IllegalArgumentException(
+                    "star tree index is under an experimental feature and can be activated only by enabling "
+                        + FeatureFlags.STAR_TREE_INDEX_SETTING.getKey()
+                        + " feature flag in the JVM options"
+                );
+            }
+            if (StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.get(parserContext.getSettings()) == false) {
+                throw new IllegalArgumentException(
+                    String.format(
+                        Locale.ROOT,
+                        "Set '%s' as true as part of index settings to use star tree index",
+                        StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey()
+                    )
+                );
+            }
+            Iterator<Map.Entry<String, Object>> iterator = compositeNode.entrySet().iterator();
+            if (compositeNode.size() > StarTreeIndexSettings.STAR_TREE_MAX_FIELDS_SETTING.get(parserContext.getSettings())) {
+                throw new IllegalArgumentException(
+                    String.format(
+                        Locale.ROOT,
+                        "Composite fields cannot have more than [%s] fields",
+                        StarTreeIndexSettings.STAR_TREE_MAX_FIELDS_SETTING.get(parserContext.getSettings())
+                    )
+                );
+            }
+            while (iterator.hasNext()) {
+                Map.Entry<String, Object> entry = iterator.next();
+                String fieldName = entry.getKey();
+                // Should accept empty arrays, as a work around for when the
+                // user can't provide an empty Map. (PHP for example)
+                boolean isEmptyList = entry.getValue() instanceof List && ((List<?>) entry.getValue()).isEmpty();
+                if (entry.getValue() instanceof Map) {
+                    @SuppressWarnings("unchecked")
+                    Map<String, Object> propNode = (Map<String, Object>) entry.getValue();
+                    String type;
+                    Object typeNode = propNode.get("type");
+                    if (typeNode != null) {
+                        type = typeNode.toString();
+                    } else {
+                        // lets see if we can derive this...
+                        throw new MapperParsingException("No type specified for field [" + fieldName + "]");
+                    }
+                    Mapper.TypeParser typeParser = getSupportedCompositeTypeParser(type, parserContext);
+                    if (typeParser == null) {
+                        throw new MapperParsingException("No handler for type [" + type + "] declared on field [" + fieldName + "]");
+                    }
+                    String[] fieldNameParts = fieldName.split("\\.");
+                    // field name is just ".", which is invalid
+                    if (fieldNameParts.length < 1) {
+                        throw new MapperParsingException("Invalid field name " + fieldName);
+                    }
+                    String realFieldName = fieldNameParts[fieldNameParts.length - 1];
+                    Mapper.Builder<?> fieldBuilder = typeParser.parse(realFieldName, propNode, parserContext, objBuilder);
+                    for (int i = fieldNameParts.length - 2; i >= 0; --i) {
+                        ObjectMapper.Builder<?> intermediate = new ObjectMapper.Builder<>(fieldNameParts[i]);
+                        intermediate.add(fieldBuilder);
+                        fieldBuilder = intermediate;
+                    }
+                    objBuilder.add(fieldBuilder);
+                    propNode.remove("type");
+                    DocumentMapperParser.checkNoRemainingFields(fieldName, propNode, parserContext.indexVersionCreated());
+                    iterator.remove();
+                } else if (isEmptyList) {
+                    iterator.remove();
+                } else {
+                    throw new MapperParsingException(
+                        "Expected map for property [fields] on field [" + fieldName + "] but got a " + fieldName.getClass()
+                    );
+                }
+            }
+
+            DocumentMapperParser.checkNoRemainingFields(
+                compositeNode,
+                parserContext.indexVersionCreated(),
+                "DocType mapping definition has unsupported parameters: "
+            );
+        }
+
+        private static Mapper.TypeParser getSupportedCompositeTypeParser(String type, ParserContext parserContext) {
+            switch (type) {
+                case StarTreeMapper.CONTENT_TYPE:
+                    return parserContext.typeParser(type);
+                default:
+                    throw new IllegalArgumentException(
+                        String.format(Locale.ROOT, "Type [%s] isn't supported in composite field context.", type)
+                    );
+            }
+        }
+
         protected static void parseProperties(ObjectMapper.Builder objBuilder, Map<String, Object> propsNode, ParserContext parserContext) {
             Iterator<Map.Entry<String, Object>> iterator = propsNode.entrySet().iterator();
             while (iterator.hasNext()) {
diff --git a/server/src/main/java/org/opensearch/index/mapper/RootObjectMapper.java b/server/src/main/java/org/opensearch/index/mapper/RootObjectMapper.java
index 4c02f86ac923b..d8c501a18976e 100644
--- a/server/src/main/java/org/opensearch/index/mapper/RootObjectMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/RootObjectMapper.java
@@ -178,15 +178,26 @@ public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext
 
             RootObjectMapper.Builder builder = new Builder(name);
             Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
+            Object compositeField = null;
             while (iterator.hasNext()) {
                 Map.Entry<String, Object> entry = iterator.next();
                 String fieldName = entry.getKey();
                 Object fieldNode = entry.getValue();
-                if (parseObjectOrDocumentTypeProperties(fieldName, fieldNode, parserContext, builder)
-                    || processField(builder, fieldName, fieldNode, parserContext)) {
+                if (fieldName.equals("composite")) {
+                    compositeField = fieldNode;
                     iterator.remove();
+                } else {
+                    if (parseObjectOrDocumentTypeProperties(fieldName, fieldNode, parserContext, builder)
+                        || processField(builder, fieldName, fieldNode, parserContext)) {
+                        iterator.remove();
+                    }
                 }
             }
+            // Important : Composite field is made up of 2 or more source properties of the index, so this must be called
+            // after parsing all other properties
+            if (compositeField != null) {
+                parseCompositeField(builder, (Map<String, Object>) compositeField, parserContext);
+            }
             return builder;
         }
 
diff --git a/server/src/main/java/org/opensearch/index/mapper/SourceFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/SourceFieldMapper.java
index a2d769d486a0f..54f1528c04bf5 100644
--- a/server/src/main/java/org/opensearch/index/mapper/SourceFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/SourceFieldMapper.java
@@ -74,6 +74,7 @@ public class SourceFieldMapper extends MetadataFieldMapper {
 
     public static final String CONTENT_TYPE = "_source";
     private final Function<Map<String, ?>, Map<String, Object>> filter;
+    private final Function<Map<String, ?>, Map<String, Object>> recoverySourceFilter;
 
     /**
      * Default parameters for source fields
@@ -119,13 +120,64 @@ public static class Builder extends MetadataFieldMapper.Builder {
             Collections.emptyList()
         );
 
+        /**
+         * A mapping parameter which define whether the recovery_source should be added or not. Default value is true.
+         * <p>
+         * Recovery source gets added if source is disabled or there are filters that are applied on _source using
+         * {@link #includes}/{@link #excludes}, which has the possibility to change the original document provided by
+         * customer. Recovery source is not a permanent field and gets removed during merges. Refer this merge
+         * policy: org.opensearch.index.engine.RecoverySourcePruneMergePolicy
+         * <p>
+         * The main reason for adding the _recovery_source was to ensure Peer to Peer recovery if segments
+         * are not flushed to the disk. If you are disabling the recovery source, then ensure that you are calling
+         * flush operation of Opensearch periodically to ensure that segments are flushed to the disk and if required
+         * Peer to Peer recovery can happen using segment files rather than replaying traffic by querying Lucene
+         * snapshot.
+         *
+         * <p>
+         * This is an expert mapping parameter.
+         *
+         */
+        private final Parameter<Boolean> recoverySourceEnabled = Parameter.boolParam(
+            "recovery_source_enabled",
+            false,
+            m -> toType(m).recoverySourceEnabled,
+            Defaults.ENABLED
+        );
+
+        /**
+         * Provides capability to add specific fields in the recovery_source.
+         * <p>
+         * Refer {@link #recoverySourceEnabled} for more details
+         * This is an expert parameter.
+         */
+        private final Parameter<List<String>> recoverySourceIncludes = Parameter.stringArrayParam(
+            "recovery_source_includes",
+            false,
+            m -> Arrays.asList(toType(m).recoverySourceIncludes),
+            Collections.emptyList()
+        );
+
+        /**
+         * Provides capability to remove specific fields in the recovery_source.
+         *
+         * Refer {@link #recoverySourceEnabled} for more details
+         * This is an expert parameter.
+         */
+        private final Parameter<List<String>> recoverySourceExcludes = Parameter.stringArrayParam(
+            "recovery_source_excludes",
+            false,
+            m -> Arrays.asList(toType(m).recoverySourceExcludes),
+            Collections.emptyList()
+        );
+
         public Builder() {
             super(Defaults.NAME);
         }
 
         @Override
         protected List<Parameter<?>> getParameters() {
-            return Arrays.asList(enabled, includes, excludes);
+            return Arrays.asList(enabled, includes, excludes, recoverySourceEnabled, recoverySourceIncludes, recoverySourceExcludes);
         }
 
         @Override
@@ -133,7 +185,10 @@ public SourceFieldMapper build(BuilderContext context) {
             return new SourceFieldMapper(
                 enabled.getValue(),
                 includes.getValue().toArray(new String[0]),
-                excludes.getValue().toArray(new String[0])
+                excludes.getValue().toArray(new String[0]),
+                recoverySourceEnabled.getValue(),
+                recoverySourceIncludes.getValue().toArray(new String[0]),
+                recoverySourceExcludes.getValue().toArray(new String[0])
             );
         }
     }
@@ -173,17 +228,27 @@ public Query termQuery(Object value, QueryShardContext context) {
     }
 
     private final boolean enabled;
+    private final boolean recoverySourceEnabled;
     /** indicates whether the source will always exist and be complete, for use by features like the update API */
     private final boolean complete;
 
     private final String[] includes;
     private final String[] excludes;
+    private final String[] recoverySourceIncludes;
+    private final String[] recoverySourceExcludes;
 
     private SourceFieldMapper() {
-        this(Defaults.ENABLED, Strings.EMPTY_ARRAY, Strings.EMPTY_ARRAY);
+        this(Defaults.ENABLED, Strings.EMPTY_ARRAY, Strings.EMPTY_ARRAY, Defaults.ENABLED, Strings.EMPTY_ARRAY, Strings.EMPTY_ARRAY);
     }
 
-    private SourceFieldMapper(boolean enabled, String[] includes, String[] excludes) {
+    private SourceFieldMapper(
+        boolean enabled,
+        String[] includes,
+        String[] excludes,
+        boolean recoverySourceEnabled,
+        String[] recoverySourceIncludes,
+        String[] recoverySourceExcludes
+    ) {
         super(new SourceFieldType(enabled));
         this.enabled = enabled;
         this.includes = includes;
@@ -191,6 +256,16 @@ private SourceFieldMapper(boolean enabled, String[] includes, String[] excludes)
         final boolean filtered = CollectionUtils.isEmpty(includes) == false || CollectionUtils.isEmpty(excludes) == false;
         this.filter = enabled && filtered ? XContentMapValues.filter(includes, excludes) : null;
         this.complete = enabled && CollectionUtils.isEmpty(includes) && CollectionUtils.isEmpty(excludes);
+
+        // Set parameters for recovery source
+        this.recoverySourceEnabled = recoverySourceEnabled;
+        this.recoverySourceIncludes = recoverySourceIncludes;
+        this.recoverySourceExcludes = recoverySourceExcludes;
+        final boolean recoverySourcefiltered = CollectionUtils.isEmpty(recoverySourceIncludes) == false
+            || CollectionUtils.isEmpty(recoverySourceExcludes) == false;
+        this.recoverySourceFilter = this.recoverySourceEnabled && recoverySourcefiltered
+            ? XContentMapValues.filter(recoverySourceIncludes, recoverySourceExcludes)
+            : null;
     }
 
     public boolean enabled() {
@@ -212,22 +287,40 @@ public void preParse(ParseContext context) throws IOException {
             context.doc().add(new StoredField(fieldType().name(), ref.bytes, ref.offset, ref.length));
         }
 
-        if (originalSource != null && adaptedSource != originalSource) {
-            // if we omitted source or modified it we add the _recovery_source to ensure we have it for ops based recovery
-            BytesRef ref = originalSource.toBytesRef();
-            context.doc().add(new StoredField(RECOVERY_SOURCE_NAME, ref.bytes, ref.offset, ref.length));
-            context.doc().add(new NumericDocValuesField(RECOVERY_SOURCE_NAME, 1));
+        if (recoverySourceEnabled) {
+            if (originalSource != null && adaptedSource != originalSource) {
+                final BytesReference adaptedRecoverySource = applyFilters(
+                    originalSource,
+                    contentType,
+                    recoverySourceEnabled,
+                    recoverySourceFilter
+                );
+                // if we omitted source or modified it we add the _recovery_source to ensure we have it for ops based recovery
+                BytesRef ref = adaptedRecoverySource.toBytesRef();
+                context.doc().add(new StoredField(RECOVERY_SOURCE_NAME, ref.bytes, ref.offset, ref.length));
+                context.doc().add(new NumericDocValuesField(RECOVERY_SOURCE_NAME, 1));
+            }
         }
     }
 
     @Nullable
     public BytesReference applyFilters(@Nullable BytesReference originalSource, @Nullable MediaType contentType) throws IOException {
-        if (enabled && originalSource != null) {
+        return applyFilters(originalSource, contentType, enabled, filter);
+    }
+
+    @Nullable
+    private BytesReference applyFilters(
+        @Nullable BytesReference originalSource,
+        @Nullable MediaType contentType,
+        boolean isProvidedSourceEnabled,
+        @Nullable final Function<Map<String, ?>, Map<String, Object>> filters
+    ) throws IOException {
+        if (isProvidedSourceEnabled && originalSource != null) {
             // Percolate and tv APIs may not set the source and that is ok, because these APIs will not index any data
-            if (filter != null) {
+            if (filters != null) {
                 // we don't update the context source if we filter, we want to keep it as is...
                 Tuple<? extends MediaType, Map<String, Object>> mapTuple = XContentHelper.convertToMap(originalSource, true, contentType);
-                Map<String, Object> filteredSource = filter.apply(mapTuple.v2());
+                Map<String, Object> filteredSource = filters.apply(mapTuple.v2());
                 BytesStreamOutput bStream = new BytesStreamOutput();
                 MediaType actualContentType = mapTuple.v1();
                 XContentBuilder builder = MediaTypeRegistry.contentBuilder(actualContentType, bStream).map(filteredSource);
diff --git a/server/src/main/java/org/opensearch/index/mapper/StarTreeMapper.java b/server/src/main/java/org/opensearch/index/mapper/StarTreeMapper.java
new file mode 100644
index 0000000000000..52dab17e0b0bb
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/StarTreeMapper.java
@@ -0,0 +1,497 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.search.Query;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.xcontent.support.XContentMapValues;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.DimensionFactory;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.search.lookup.SearchLookup;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * A field mapper for star tree fields
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class StarTreeMapper extends ParametrizedFieldMapper {
+    public static final String CONTENT_TYPE = "star_tree";
+    public static final String CONFIG = "config";
+    public static final String MAX_LEAF_DOCS = "max_leaf_docs";
+    public static final String SKIP_STAR_NODE_IN_DIMS = "skip_star_node_creation_for_dimensions";
+    public static final String BUILD_MODE = "build_mode";
+    public static final String ORDERED_DIMENSIONS = "ordered_dimensions";
+    public static final String METRICS = "metrics";
+    public static final String STATS = "stats";
+
+    @Override
+    public ParametrizedFieldMapper.Builder getMergeBuilder() {
+        return new Builder(simpleName(), objBuilder).init(this);
+
+    }
+
+    /**
+     * Builder for the star tree field mapper
+     *
+     * @opensearch.internal
+     */
+    public static class Builder extends ParametrizedFieldMapper.Builder {
+        private ObjectMapper.Builder objbuilder;
+
+        @SuppressWarnings("unchecked")
+        private final Parameter<StarTreeField> config = new Parameter<>(CONFIG, false, () -> null, (name, context, nodeObj) -> {
+            if (nodeObj instanceof Map<?, ?>) {
+                Map<String, Object> paramMap = (Map<String, Object>) nodeObj;
+                int maxLeafDocs = XContentMapValues.nodeIntegerValue(
+                    paramMap.get(MAX_LEAF_DOCS),
+                    StarTreeIndexSettings.STAR_TREE_DEFAULT_MAX_LEAF_DOCS.get(context.getSettings())
+                );
+                if (maxLeafDocs < 1) {
+                    throw new IllegalArgumentException(
+                        String.format(Locale.ROOT, "%s [%s] must be greater than 0", MAX_LEAF_DOCS, maxLeafDocs)
+                    );
+                }
+                paramMap.remove(MAX_LEAF_DOCS);
+                Set<String> skipStarInDims = new LinkedHashSet<>(
+                    List.of(XContentMapValues.nodeStringArrayValue(paramMap.getOrDefault(SKIP_STAR_NODE_IN_DIMS, new ArrayList<String>())))
+                );
+                paramMap.remove(SKIP_STAR_NODE_IN_DIMS);
+                StarTreeFieldConfiguration.StarTreeBuildMode buildMode = StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP;
+
+                List<Dimension> dimensions = buildDimensions(name, paramMap, context);
+                paramMap.remove(ORDERED_DIMENSIONS);
+                List<Metric> metrics = buildMetrics(name, paramMap, context);
+                paramMap.remove(METRICS);
+                paramMap.remove(CompositeDataCubeFieldType.NAME);
+                for (String dim : skipStarInDims) {
+                    if (dimensions.stream().filter(d -> d.getField().equals(dim)).findAny().isEmpty()) {
+                        throw new IllegalArgumentException(
+                            String.format(
+                                Locale.ROOT,
+                                "[%s] in skip_star_node_creation_for_dimensions should be part of ordered_dimensions",
+                                dim
+                            )
+                        );
+                    }
+                }
+                StarTreeFieldConfiguration spec = new StarTreeFieldConfiguration(maxLeafDocs, skipStarInDims, buildMode);
+                DocumentMapperParser.checkNoRemainingFields(
+                    paramMap,
+                    context.indexVersionCreated(),
+                    "Star tree mapping definition has unsupported parameters: "
+                );
+                return new StarTreeField(this.name, dimensions, metrics, spec);
+
+            } else {
+                throw new IllegalArgumentException(
+                    String.format(Locale.ROOT, "unable to parse config for star tree field [%s]", this.name)
+                );
+            }
+        }, m -> toType(m).starTreeField);
+
+        /**
+         * Build dimensions from mapping
+         */
+        @SuppressWarnings("unchecked")
+        private List<Dimension> buildDimensions(String fieldName, Map<String, Object> map, Mapper.TypeParser.ParserContext context) {
+            Object dims = XContentMapValues.extractValue("ordered_dimensions", map);
+            if (dims == null) {
+                throw new IllegalArgumentException(
+                    String.format(Locale.ROOT, "ordered_dimensions is required for star tree field [%s]", fieldName)
+                );
+            }
+            List<Dimension> dimensions = new LinkedList<>();
+            if (dims instanceof List<?>) {
+                List<Object> dimList = (List<Object>) dims;
+                if (dimList.size() > context.getSettings()
+                    .getAsInt(
+                        StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_SETTING.getKey(),
+                        StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_DEFAULT
+                    )) {
+                    throw new IllegalArgumentException(
+                        String.format(
+                            Locale.ROOT,
+                            "ordered_dimensions cannot have more than %s dimensions for star tree field [%s]",
+                            context.getSettings()
+                                .getAsInt(
+                                    StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_SETTING.getKey(),
+                                    StarTreeIndexSettings.STAR_TREE_MAX_DIMENSIONS_DEFAULT
+                                ),
+                            fieldName
+                        )
+                    );
+                }
+                if (dimList.size() < 2) {
+                    throw new IllegalArgumentException(
+                        String.format(Locale.ROOT, "Atleast two dimensions are required to build star tree index field [%s]", fieldName)
+                    );
+                }
+                Set<String> dimensionFieldNames = new HashSet<>();
+                for (Object dim : dimList) {
+                    Dimension dimension = getDimension(fieldName, dim, context);
+                    if (dimensionFieldNames.add(dimension.getField()) == false) {
+                        throw new IllegalArgumentException(
+                            String.format(
+                                Locale.ROOT,
+                                "Duplicate dimension [%s] present as part star tree index field [%s]",
+                                dimension.getField(),
+                                fieldName
+                            )
+                        );
+                    }
+                    dimensions.add(dimension);
+                }
+            } else {
+                throw new MapperParsingException(
+                    String.format(Locale.ROOT, "unable to parse ordered_dimensions for star tree field [%s]", fieldName)
+                );
+            }
+            return dimensions;
+        }
+
+        /**
+         * Get dimension based on mapping
+         */
+        @SuppressWarnings("unchecked")
+        private Dimension getDimension(String fieldName, Object dimensionMapping, Mapper.TypeParser.ParserContext context) {
+            Dimension dimension;
+            Map<String, Object> dimensionMap = (Map<String, Object>) dimensionMapping;
+            String name = (String) XContentMapValues.extractValue(CompositeDataCubeFieldType.NAME, dimensionMap);
+            dimensionMap.remove(CompositeDataCubeFieldType.NAME);
+            if (this.objbuilder == null || this.objbuilder.mappersBuilders == null) {
+                String type = (String) XContentMapValues.extractValue(CompositeDataCubeFieldType.TYPE, dimensionMap);
+                dimensionMap.remove(CompositeDataCubeFieldType.TYPE);
+                if (type == null) {
+                    throw new MapperParsingException(
+                        String.format(Locale.ROOT, "unable to parse ordered_dimensions for star tree field [%s]", fieldName)
+                    );
+                }
+                return DimensionFactory.parseAndCreateDimension(name, type, dimensionMap, context);
+            } else {
+                Optional<Mapper.Builder> dimBuilder = findMapperBuilderByName(name, this.objbuilder.mappersBuilders);
+                if (dimBuilder.isEmpty()) {
+                    throw new IllegalArgumentException(String.format(Locale.ROOT, "unknown dimension field [%s]", name));
+                }
+                if (!isBuilderAllowedForDimension(dimBuilder.get())) {
+                    throw new IllegalArgumentException(
+                        String.format(
+                            Locale.ROOT,
+                            "unsupported field type associated with dimension [%s] as part of star tree field [%s]",
+                            name,
+                            fieldName
+                        )
+                    );
+                }
+                dimension = DimensionFactory.parseAndCreateDimension(name, dimBuilder.get(), dimensionMap, context);
+            }
+            DocumentMapperParser.checkNoRemainingFields(
+                dimensionMap,
+                context.indexVersionCreated(),
+                "Star tree mapping definition has unsupported parameters: "
+            );
+            return dimension;
+        }
+
+        /**
+         * Build metrics from mapping
+         */
+        @SuppressWarnings("unchecked")
+        private List<Metric> buildMetrics(String fieldName, Map<String, Object> map, Mapper.TypeParser.ParserContext context) {
+            List<Metric> metrics = new LinkedList<>();
+            Object metricsFromInput = XContentMapValues.extractValue(METRICS, map);
+            if (metricsFromInput == null) {
+                throw new IllegalArgumentException(
+                    String.format(Locale.ROOT, "metrics section is required for star tree field [%s]", fieldName)
+                );
+            }
+            if (metricsFromInput instanceof List<?>) {
+                List<?> metricsList = (List<?>) metricsFromInput;
+                Set<String> metricFieldNames = new HashSet<>();
+                for (Object metric : metricsList) {
+                    Map<String, Object> metricMap = (Map<String, Object>) metric;
+                    String name = (String) XContentMapValues.extractValue(CompositeDataCubeFieldType.NAME, metricMap);
+                    // Handle _doc_count metric separately at the end
+                    if (name.equals(DocCountFieldMapper.NAME)) {
+                        continue;
+                    }
+                    metricMap.remove(CompositeDataCubeFieldType.NAME);
+                    if (objbuilder == null || objbuilder.mappersBuilders == null) {
+                        Metric metricFromParser = getMetric(name, metricMap, context);
+                        if (metricFieldNames.add(metricFromParser.getField()) == false) {
+                            throw new IllegalArgumentException(
+                                String.format(
+                                    Locale.ROOT,
+                                    "Duplicate metrics [%s] present as part star tree index field [%s]",
+                                    metricFromParser.getField(),
+                                    fieldName
+                                )
+                            );
+                        }
+                        metrics.add(metricFromParser);
+                    } else {
+                        Optional<Mapper.Builder> meticBuilder = findMapperBuilderByName(name, this.objbuilder.mappersBuilders);
+                        if (meticBuilder.isEmpty()) {
+                            throw new IllegalArgumentException(String.format(Locale.ROOT, "unknown metric field [%s]", name));
+                        }
+                        if (!isBuilderAllowedForMetric(meticBuilder.get())) {
+                            throw new IllegalArgumentException(
+                                String.format(Locale.ROOT, "non-numeric field type is associated with star tree metric [%s]", this.name)
+                            );
+                        }
+                        Metric metricFromParser = getMetric(name, metricMap, context);
+                        if (metricFieldNames.add(metricFromParser.getField()) == false) {
+                            throw new IllegalArgumentException(
+                                String.format(
+                                    Locale.ROOT,
+                                    "Duplicate metrics [%s] present as part star tree index field [%s]",
+                                    metricFromParser.getField(),
+                                    fieldName
+                                )
+                            );
+                        }
+                        metrics.add(metricFromParser);
+                        DocumentMapperParser.checkNoRemainingFields(
+                            metricMap,
+                            context.indexVersionCreated(),
+                            "Star tree mapping definition has unsupported parameters: "
+                        );
+                    }
+                }
+            } else {
+                throw new MapperParsingException(String.format(Locale.ROOT, "unable to parse metrics for star tree field [%s]", this.name));
+            }
+            int numBaseMetrics = 0;
+            for (Metric metric : metrics) {
+                numBaseMetrics += metric.getBaseMetrics().size();
+            }
+            if (numBaseMetrics > context.getSettings()
+                .getAsInt(
+                    StarTreeIndexSettings.STAR_TREE_MAX_BASE_METRICS_SETTING.getKey(),
+                    StarTreeIndexSettings.STAR_TREE_MAX_BASE_METRICS_DEFAULT
+                )) {
+                throw new IllegalArgumentException(
+                    String.format(
+                        Locale.ROOT,
+                        "There cannot be more than [%s] base metrics for star tree field [%s]",
+                        context.getSettings()
+                            .getAsInt(
+                                StarTreeIndexSettings.STAR_TREE_MAX_BASE_METRICS_SETTING.getKey(),
+                                StarTreeIndexSettings.STAR_TREE_MAX_BASE_METRICS_DEFAULT
+                            ),
+                        fieldName
+                    )
+                );
+            }
+            Metric docCountMetric = new Metric(DocCountFieldMapper.NAME, List.of(MetricStat.DOC_COUNT));
+            metrics.add(docCountMetric);
+            return metrics;
+        }
+
+        @SuppressWarnings("unchecked")
+        private Metric getMetric(String name, Map<String, Object> metric, Mapper.TypeParser.ParserContext context) {
+            List<MetricStat> metricTypes;
+            List<String> metricStrings = XContentMapValues.extractRawValues(STATS, metric)
+                .stream()
+                .map(Object::toString)
+                .collect(Collectors.toList());
+            metric.remove(STATS);
+            if (metricStrings.isEmpty()) {
+                metricStrings = new ArrayList<>(StarTreeIndexSettings.DEFAULT_METRICS_LIST.get(context.getSettings()));
+            }
+            // Add all required metrics initially
+            Set<MetricStat> metricSet = new LinkedHashSet<>();
+            for (String metricString : metricStrings) {
+                MetricStat metricStat = MetricStat.fromTypeName(metricString);
+                metricSet.add(metricStat);
+                addBaseMetrics(metricStat, metricSet);
+            }
+            addEligibleDerivedMetrics(metricSet);
+            metricTypes = new ArrayList<>(metricSet);
+            return new Metric(name, metricTypes);
+        }
+
+        /**
+         * Add base metrics of derived metric to metric set
+         */
+        private void addBaseMetrics(MetricStat metricStat, Set<MetricStat> metricSet) {
+            if (metricStat.isDerivedMetric()) {
+                Queue<MetricStat> metricQueue = new LinkedList<>(metricStat.getBaseMetrics());
+                while (metricQueue.isEmpty() == false) {
+                    MetricStat metric = metricQueue.poll();
+                    if (metric.isDerivedMetric() && !metricSet.contains(metric)) {
+                        metricQueue.addAll(metric.getBaseMetrics());
+                    }
+                    metricSet.add(metric);
+                }
+            }
+        }
+
+        /**
+         * Add derived metrics if all associated base metrics are present
+         */
+        private void addEligibleDerivedMetrics(Set<MetricStat> metricStats) {
+            for (MetricStat metric : MetricStat.values()) {
+                if (metric.isDerivedMetric() && !metricStats.contains(metric)) {
+                    List<MetricStat> sourceMetrics = metric.getBaseMetrics();
+                    if (metricStats.containsAll(sourceMetrics)) {
+                        metricStats.add(metric);
+                    }
+                }
+            }
+        }
+
+        @Override
+        protected List<Parameter<?>> getParameters() {
+            return List.of(config);
+        }
+
+        private static boolean isBuilderAllowedForDimension(Mapper.Builder builder) {
+            return builder.getSupportedDataCubeDimensionType().isPresent();
+        }
+
+        private static boolean isBuilderAllowedForMetric(Mapper.Builder builder) {
+            return builder.isDataCubeMetricSupported();
+        }
+
+        private Optional<Mapper.Builder> findMapperBuilderByName(String field, List<Mapper.Builder> mappersBuilders) {
+            return mappersBuilders.stream().filter(builder -> builder.name().equals(field)).findFirst();
+        }
+
+        public Builder(String name, ObjectMapper.Builder objBuilder) {
+            super(name);
+            this.objbuilder = objBuilder;
+        }
+
+        @Override
+        public ParametrizedFieldMapper build(BuilderContext context) {
+            StarTreeFieldType type = new StarTreeFieldType(name, this.config.get());
+            return new StarTreeMapper(name, type, this, objbuilder);
+        }
+    }
+
+    private static StarTreeMapper toType(FieldMapper in) {
+        return (StarTreeMapper) in;
+    }
+
+    /**
+     * Concrete parse for star tree type
+     *
+     * @opensearch.internal
+     */
+    public static class TypeParser implements Mapper.TypeParser {
+
+        /**
+         * default constructor of VectorFieldMapper.TypeParser
+         */
+        public TypeParser() {}
+
+        @Override
+        public Mapper.Builder<?> parse(String name, Map<String, Object> node, ParserContext context) throws MapperParsingException {
+            Builder builder = new StarTreeMapper.Builder(name, null);
+            builder.parse(name, context, node);
+            return builder;
+        }
+
+        @Override
+        public Mapper.Builder<?> parse(String name, Map<String, Object> node, ParserContext context, ObjectMapper.Builder objBuilder)
+            throws MapperParsingException {
+            Builder builder = new StarTreeMapper.Builder(name, objBuilder);
+            builder.parse(name, context, node);
+            return builder;
+        }
+    }
+
+    private final StarTreeField starTreeField;
+
+    private final ObjectMapper.Builder objBuilder;
+
+    protected StarTreeMapper(String simpleName, StarTreeFieldType type, Builder builder, ObjectMapper.Builder objbuilder) {
+        super(simpleName, type, MultiFields.empty(), CopyTo.empty());
+        this.starTreeField = builder.config.get();
+        this.objBuilder = objbuilder;
+    }
+
+    @Override
+    public StarTreeFieldType fieldType() {
+        return (StarTreeFieldType) super.fieldType();
+    }
+
+    @Override
+    protected String contentType() {
+        return CONTENT_TYPE;
+    }
+
+    @Override
+    protected void parseCreateField(ParseContext context) {
+        throw new MapperParsingException(
+            String.format(
+                Locale.ROOT,
+                "Field [%s] is a star tree field and cannot be added inside a document. Use the index API request parameters.",
+                name()
+            )
+        );
+    }
+
+    /**
+     * Star tree mapped field type containing dimensions, metrics, star tree specs
+     *
+     * @opensearch.experimental
+     */
+    @ExperimentalApi
+    public static final class StarTreeFieldType extends CompositeDataCubeFieldType {
+
+        private final StarTreeFieldConfiguration starTreeConfig;
+
+        public StarTreeFieldType(String name, StarTreeField starTreeField) {
+            super(name, starTreeField.getDimensionsOrder(), starTreeField.getMetrics(), CompositeFieldType.STAR_TREE);
+            this.starTreeConfig = starTreeField.getStarTreeConfig();
+        }
+
+        public StarTreeFieldConfiguration getStarTreeConfig() {
+            return starTreeConfig;
+        }
+
+        @Override
+        public ValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
+            // TODO : evaluate later
+            throw new UnsupportedOperationException("Cannot fetch values for star tree field [" + name() + "].");
+        }
+
+        @Override
+        public String typeName() {
+            return CONTENT_TYPE;
+        }
+
+        @Override
+        public Query termQuery(Object value, QueryShardContext context) {
+            // TODO : evaluate later
+            throw new UnsupportedOperationException("Cannot perform terms query on star tree field [" + name() + "].");
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/StrictDynamicMappingException.java b/server/src/main/java/org/opensearch/index/mapper/StrictDynamicMappingException.java
index 9127641128dad..0524c672011c5 100644
--- a/server/src/main/java/org/opensearch/index/mapper/StrictDynamicMappingException.java
+++ b/server/src/main/java/org/opensearch/index/mapper/StrictDynamicMappingException.java
@@ -43,8 +43,8 @@
  */
 public class StrictDynamicMappingException extends MapperParsingException {
 
-    public StrictDynamicMappingException(String path, String fieldName) {
-        super("mapping set to strict, dynamic introduction of [" + fieldName + "] within [" + path + "] is not allowed");
+    public StrictDynamicMappingException(String dynamic, String path, String fieldName) {
+        super("mapping set to " + dynamic + ", dynamic introduction of [" + fieldName + "] within [" + path + "] is not allowed");
     }
 
     public StrictDynamicMappingException(StreamInput in) throws IOException {
diff --git a/server/src/main/java/org/opensearch/index/mapper/StringFieldType.java b/server/src/main/java/org/opensearch/index/mapper/StringFieldType.java
index fbfca44c3062a..682ccc13f769d 100644
--- a/server/src/main/java/org/opensearch/index/mapper/StringFieldType.java
+++ b/server/src/main/java/org/opensearch/index/mapper/StringFieldType.java
@@ -55,6 +55,7 @@
 import java.util.regex.Pattern;
 
 import static org.opensearch.search.SearchService.ALLOW_EXPENSIVE_QUERIES;
+import static org.apache.lucene.search.FuzzyQuery.defaultRewriteMethod;
 
 /** Base class for {@link MappedFieldType} implementations that use the same
  * representation for internal index terms as the external representation so
@@ -102,6 +103,35 @@ public Query fuzzyQuery(
         );
     }
 
+    @Override
+    public Query fuzzyQuery(
+        Object value,
+        Fuzziness fuzziness,
+        int prefixLength,
+        int maxExpansions,
+        boolean transpositions,
+        MultiTermQuery.RewriteMethod method,
+        QueryShardContext context
+    ) {
+        if (!context.allowExpensiveQueries()) {
+            throw new OpenSearchException(
+                "[fuzzy] queries cannot be executed when '" + ALLOW_EXPENSIVE_QUERIES.getKey() + "' is set to false."
+            );
+        }
+        failIfNotIndexed();
+        if (method == null) {
+            method = defaultRewriteMethod(maxExpansions);
+        }
+        return new FuzzyQuery(
+            new Term(name(), indexedValueForSearch(value)),
+            fuzziness.asDistance(BytesRefs.toString(value)),
+            prefixLength,
+            maxExpansions,
+            transpositions,
+            method
+        );
+    }
+
     @Override
     public Query prefixQuery(String value, MultiTermQuery.RewriteMethod method, boolean caseInsensitive, QueryShardContext context) {
         if (context.allowExpensiveQueries() == false) {
diff --git a/server/src/main/java/org/opensearch/index/mapper/TextFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/TextFieldMapper.java
index ef0f7b33e826e..785bd5a355392 100644
--- a/server/src/main/java/org/opensearch/index/mapper/TextFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/TextFieldMapper.java
@@ -449,7 +449,6 @@ protected PrefixFieldMapper buildPrefixMapper(BuilderContext context, FieldType
                 pft.setStoreTermVectorOffsets(true);
             }
             PrefixFieldType prefixFieldType = new PrefixFieldType(tft, fullName + "._index_prefix", indexPrefixes.get());
-            prefixFieldType.setAnalyzer(analyzers.getIndexAnalyzer());
             tft.setPrefixFieldType(prefixFieldType);
             return new PrefixFieldMapper(pft, prefixFieldType);
         }
@@ -523,12 +522,14 @@ private static class PrefixWrappedAnalyzer extends AnalyzerWrapper {
         private final int minChars;
         private final int maxChars;
         private final Analyzer delegate;
+        private final int positionIncrementGap;
 
-        PrefixWrappedAnalyzer(Analyzer delegate, int minChars, int maxChars) {
+        PrefixWrappedAnalyzer(Analyzer delegate, int minChars, int maxChars, int positionIncrementGap) {
             super(delegate.getReuseStrategy());
             this.delegate = delegate;
             this.minChars = minChars;
             this.maxChars = maxChars;
+            this.positionIncrementGap = positionIncrementGap;
         }
 
         @Override
@@ -536,6 +537,11 @@ protected Analyzer getWrappedAnalyzer(String fieldName) {
             return delegate;
         }
 
+        @Override
+        public int getPositionIncrementGap(String fieldName) {
+            return positionIncrementGap;
+        }
+
         @Override
         protected TokenStreamComponents wrapComponents(String fieldName, TokenStreamComponents components) {
             TokenFilter filter = new EdgeNGramTokenFilter(components.getTokenStream(), minChars, maxChars, false);
@@ -589,17 +595,18 @@ static final class PrefixFieldType extends StringFieldType {
 
         final int minChars;
         final int maxChars;
-        final TextFieldType parentField;
+        final TextFieldType parent;
 
         PrefixFieldType(TextFieldType parentField, String name, PrefixConfig config) {
             this(parentField, name, config.minChars, config.maxChars);
         }
 
-        PrefixFieldType(TextFieldType parentField, String name, int minChars, int maxChars) {
-            super(name, true, false, false, parentField.getTextSearchInfo(), Collections.emptyMap());
+        PrefixFieldType(TextFieldType parent, String name, int minChars, int maxChars) {
+            super(name, true, false, false, parent.getTextSearchInfo(), Collections.emptyMap());
             this.minChars = minChars;
             this.maxChars = maxChars;
-            this.parentField = parentField;
+            this.parent = parent;
+            setAnalyzer(parent.indexAnalyzer());
         }
 
         @Override
@@ -610,8 +617,13 @@ public ValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchL
         }
 
         void setAnalyzer(NamedAnalyzer delegate) {
+            String analyzerName = delegate.name();
             setIndexAnalyzer(
-                new NamedAnalyzer(delegate.name(), AnalyzerScope.INDEX, new PrefixWrappedAnalyzer(delegate.analyzer(), minChars, maxChars))
+                new NamedAnalyzer(
+                    analyzerName,
+                    AnalyzerScope.INDEX,
+                    new PrefixWrappedAnalyzer(delegate.analyzer(), minChars, maxChars, delegate.getPositionIncrementGap(analyzerName))
+                )
             );
         }
 
@@ -640,7 +652,7 @@ public Query prefixQuery(String value, MultiTermQuery.RewriteMethod method, bool
             Automaton automaton = Operations.concatenate(automata);
             AutomatonQuery query = AutomatonQueries.createAutomatonQuery(new Term(name(), value + "*"), automaton, method);
             return new BooleanQuery.Builder().add(query, BooleanClause.Occur.SHOULD)
-                .add(new TermQuery(new Term(parentField.name(), value)), BooleanClause.Occur.SHOULD)
+                .add(new TermQuery(new Term(parent.name(), value)), BooleanClause.Occur.SHOULD)
                 .build();
         }
 
diff --git a/server/src/main/java/org/opensearch/index/mapper/WildcardFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/WildcardFieldMapper.java
new file mode 100644
index 0000000000000..cd95e320209ee
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/WildcardFieldMapper.java
@@ -0,0 +1,859 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.analysis.Tokenizer;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.FieldType;
+import org.apache.lucene.document.SortedSetDocValuesField;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.ConstantScoreScorer;
+import org.apache.lucene.search.ConstantScoreWeight;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.search.MatchNoDocsQuery;
+import org.apache.lucene.search.MultiTermQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.QueryVisitor;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.ScorerSupplier;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.TwoPhaseIterator;
+import org.apache.lucene.search.Weight;
+import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.automaton.Automaton;
+import org.apache.lucene.util.automaton.CompiledAutomaton;
+import org.apache.lucene.util.automaton.RegExp;
+import org.opensearch.common.lucene.BytesRefs;
+import org.opensearch.common.lucene.Lucene;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.common.unit.Fuzziness;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.analysis.IndexAnalyzers;
+import org.opensearch.index.analysis.NamedAnalyzer;
+import org.opensearch.index.fielddata.IndexFieldData;
+import org.opensearch.index.fielddata.plain.SortedSetOrdinalsIndexFieldData;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.search.DocValueFormat;
+import org.opensearch.search.aggregations.support.CoreValuesSourceType;
+import org.opensearch.search.lookup.LeafSearchLookup;
+import org.opensearch.search.lookup.SearchLookup;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.io.UncheckedIOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+
+import static org.opensearch.index.mapper.KeywordFieldMapper.normalizeValue;
+
+/**
+ * Mapper for the "wildcard" field type, which supports (relatively) efficient matching by wildcard, prefix, and regexp
+ * queries. It's not really a "full-text" field type, but rather an "unstructured string" field type.
+ *
+ * @opensearch.internal
+ */
+public class WildcardFieldMapper extends ParametrizedFieldMapper {
+    private final String nullValue;
+    private final int ignoreAbove;
+    private final String normalizerName;
+    private final boolean hasDocValues;
+    private final IndexAnalyzers indexAnalyzers;
+
+    /**
+     * The builder for the field mapper.
+     *
+     * @opensearch.internal
+     */
+    public static final class Builder extends ParametrizedFieldMapper.Builder {
+
+        // Copy relevant parameters from KeywordFieldMapper
+        private final Parameter<String> nullValue = Parameter.stringParam("null_value", false, m -> toType(m).nullValue, null)
+            .acceptsNull();
+        private final Parameter<Integer> ignoreAbove = Parameter.intParam(
+            "ignore_above",
+            true,
+            m -> toType(m).ignoreAbove,
+            Integer.MAX_VALUE
+        );
+        private final Parameter<String> normalizer = Parameter.stringParam("normalizer", false, m -> toType(m).normalizerName, "default");
+        private final Parameter<Map<String, String>> meta = Parameter.metaParam();
+        private final Parameter<Boolean> hasDocValues = Parameter.docValuesParam(m -> toType(m).hasDocValues, false);
+        private final IndexAnalyzers indexAnalyzers;
+
+        public Builder(String name, IndexAnalyzers indexAnalyzers) {
+            super(name);
+            this.indexAnalyzers = indexAnalyzers;
+        }
+
+        public Builder(String name) {
+            this(name, null);
+        }
+
+        public WildcardFieldMapper.Builder ignoreAbove(int ignoreAbove) {
+            this.ignoreAbove.setValue(ignoreAbove);
+            return this;
+        }
+
+        WildcardFieldMapper.Builder normalizer(String normalizerName) {
+            this.normalizer.setValue(normalizerName);
+            return this;
+        }
+
+        WildcardFieldMapper.Builder nullValue(String nullValue) {
+            this.nullValue.setValue(nullValue);
+            return this;
+        }
+
+        public WildcardFieldMapper.Builder docValues(boolean hasDocValues) {
+            this.hasDocValues.setValue(hasDocValues);
+            return this;
+        }
+
+        @Override
+        protected List<Parameter<?>> getParameters() {
+            return Arrays.asList(nullValue, ignoreAbove, normalizer, hasDocValues, meta);
+        }
+
+        @Override
+        public WildcardFieldMapper build(BuilderContext context) {
+            String normalizerName = normalizer.getValue();
+            NamedAnalyzer normalizer = Lucene.KEYWORD_ANALYZER;
+            if ("default".equals(normalizerName) == false) {
+                assert indexAnalyzers != null;
+                normalizer = indexAnalyzers.getNormalizer(normalizerName);
+            }
+
+            return new WildcardFieldMapper(
+                name,
+                new WildcardFieldType(context.path().pathAsText(name), normalizer, this),
+                multiFieldsBuilder.build(this, context),
+                copyTo.build(),
+                this
+            );
+        }
+
+    }
+
+    public static final String CONTENT_TYPE = "wildcard";
+    public static final TypeParser PARSER = new TypeParser((n, c) -> new WildcardFieldMapper.Builder(n, c.getIndexAnalyzers()));
+
+    protected WildcardFieldMapper(
+        String simpleName,
+        MappedFieldType mappedFieldType,
+        MultiFields multiFields,
+        CopyTo copyTo,
+        Builder builder
+    ) {
+        super(simpleName, mappedFieldType, multiFields, copyTo);
+        this.nullValue = builder.nullValue.getValue();
+        this.ignoreAbove = builder.ignoreAbove.getValue();
+        this.normalizerName = builder.normalizer.getValue();
+        this.hasDocValues = builder.hasDocValues.getValue();
+        this.indexAnalyzers = builder.indexAnalyzers;
+    }
+
+    public int ignoreAbove() {
+        return ignoreAbove;
+    }
+
+    private static final FieldType FIELD_TYPE = new FieldType();
+    static {
+        FIELD_TYPE.setIndexOptions(IndexOptions.DOCS);
+        FIELD_TYPE.setTokenized(true);
+        FIELD_TYPE.setOmitNorms(true);
+        FIELD_TYPE.setStored(false);
+        FIELD_TYPE.freeze();
+    }
+
+    @Override
+    protected void parseCreateField(ParseContext context) throws IOException {
+        String value;
+        if (context.externalValueSet()) {
+            value = context.externalValue().toString();
+        } else {
+            XContentParser parser = context.parser();
+            if (parser.currentToken() == XContentParser.Token.VALUE_NULL) {
+                value = nullValue;
+            } else {
+                value = parser.textOrNull();
+            }
+        }
+
+        if (value == null || value.length() > ignoreAbove) {
+            return;
+        }
+
+        NamedAnalyzer normalizer = fieldType().normalizer();
+        if (normalizer != null) {
+            value = normalizeValue(normalizer, name(), value);
+        }
+
+        // convert to utf8 only once before feeding postings/dv/stored fields
+        final BytesRef binaryValue = new BytesRef(value);
+        Tokenizer tokenizer = new WildcardFieldTokenizer();
+        tokenizer.setReader(new StringReader(value));
+        context.doc().add(new Field(fieldType().name(), tokenizer, FIELD_TYPE));
+        if (fieldType().hasDocValues()) {
+            context.doc().add(new SortedSetDocValuesField(fieldType().name(), binaryValue));
+        } else {
+            if (fieldType().hasDocValues() == false) {
+                createFieldNamesField(context);
+            }
+        }
+    }
+
+    /**
+     * Tokenizer to emit tokens to support wildcard first-phase matching.
+     * <p>
+     * Will emit all substrings of length 1,2, and 3, with 0-valued anchors for the prefix/suffix.
+     * <p>
+     * For example, given the string "lucene", output the following terms:
+     * <p>
+     * [0, 'l']
+     * [0, 'l', 'u']
+     * ['l']
+     * ['l', 'u']
+     * ['l', 'u', 'c']
+     * ['u']
+     * ['u','c']
+     * ['u','c','e']
+     * ['c']
+     * ['c', 'e']
+     * ['c', 'e', 'n']
+     * ['e']
+     * ['e', 'n']
+     * ['e', 'n', 'e']
+     * ['n']
+     * ['n', 'e']
+     * ['n', 'e', 0]
+     * ['e']
+     * ['e', 0]
+     * <p>
+     * Visible for testing.
+     */
+    static final class WildcardFieldTokenizer extends Tokenizer {
+        private final CharTermAttribute charTermAttribute = addAttribute(CharTermAttribute.class);
+        private final char[] buffer = new char[3]; // Ring buffer for up to 3 chars
+        private int offset = 0; // Position in the buffer
+        private int length = 2; // First token is anchor + first char
+
+        @Override
+        public void reset() throws IOException {
+            super.reset();
+            buffer[0] = 0;
+            int firstChar = input.read();
+            if (firstChar != -1) {
+                buffer[1] = (char) firstChar;
+                int secondChar = input.read();
+                if (secondChar != -1) {
+                    buffer[2] = (char) secondChar;
+                } else {
+                    buffer[2] = 0;
+                }
+            } else {
+                buffer[1] = 0;
+            }
+
+        }
+
+        @Override
+        public boolean incrementToken() throws IOException {
+            charTermAttribute.setLength(length);
+            int numZeroes = 0;
+            for (int i = 0; i < length; i++) {
+                char curChar = buffer[(i + offset) % 3];
+                if (curChar == 0) {
+                    numZeroes++;
+                }
+                charTermAttribute.buffer()[i] = buffer[(i + offset) % 3];
+            }
+            if (numZeroes == 2) {
+                // Two zeroes usually means we're done.
+                if (length == 3 && charTermAttribute.buffer()[1] != 0) {
+                    // The only case where we're not done is if the input has exactly 1 character, so the buffer
+                    // contains 0, char, 0. In that case, we return char now, then return char, 0 on the next iteration
+                    charTermAttribute.buffer()[0] = charTermAttribute.buffer()[1];
+                    charTermAttribute.buffer()[1] = 0;
+                    charTermAttribute.setLength(1);
+                    length = 2;
+                    offset = 1;
+                    return true;
+                }
+                return false;
+            }
+            if (length == 3) {
+                // Read the next character, overwriting the current offset
+                int nextChar = input.read();
+                if (nextChar != -1) {
+                    buffer[offset] = (char) nextChar;
+                } else {
+                    // End of input. Pad with extra 0 to trigger the logic above.
+                    buffer[offset] = 0;
+                }
+                offset = (offset + 1) % 3;
+                length = 1;
+            } else {
+                length = length + 1;
+            }
+            return true;
+        }
+    }
+
+    /**
+     * Implements the various query types over wildcard fields.
+     */
+    public static final class WildcardFieldType extends StringFieldType {
+        private final int ignoreAbove;
+        private final String nullValue;
+
+        public WildcardFieldType(String name) {
+            this(name, Collections.emptyMap());
+        }
+
+        public WildcardFieldType(String name, Map<String, String> meta) {
+            super(name, true, false, false, TextSearchInfo.SIMPLE_MATCH_ONLY, meta);
+            setIndexAnalyzer(Lucene.KEYWORD_ANALYZER);
+            this.ignoreAbove = Integer.MAX_VALUE;
+            this.nullValue = null;
+        }
+
+        public WildcardFieldType(String name, NamedAnalyzer normalizer, Builder builder) {
+            super(name, true, true, builder.hasDocValues.getValue(), TextSearchInfo.SIMPLE_MATCH_ONLY, builder.meta.getValue());
+            setIndexAnalyzer(normalizer);
+            this.ignoreAbove = builder.ignoreAbove.getValue();
+            this.nullValue = builder.nullValue.getValue();
+        }
+
+        @Override
+        public ValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
+            // Copied from KeywordFieldMapper.KeywordFieldType
+            if (format != null) {
+                throw new IllegalArgumentException("Field [" + name() + "] of type [" + typeName() + "] doesn't " + "support formats.");
+            }
+
+            if (hasDocValues()) {
+                return new DocValueFetcher(DocValueFormat.RAW, searchLookup.doc().getForField(this));
+            }
+
+            return new SourceValueFetcher(name(), context, nullValue) {
+                @Override
+                protected String parseSourceValue(Object value) {
+                    String keywordValue = value.toString();
+                    if (keywordValue.length() > ignoreAbove) {
+                        return null;
+                    }
+
+                    NamedAnalyzer normalizer = normalizer();
+                    if (normalizer == null) {
+                        return keywordValue;
+                    }
+
+                    try {
+                        return normalizeValue(normalizer, name(), keywordValue);
+                    } catch (IOException e) {
+                        throw new UncheckedIOException(e);
+                    }
+                }
+            };
+        }
+
+        @Override
+        public String typeName() {
+            return CONTENT_TYPE;
+        }
+
+        NamedAnalyzer normalizer() {
+            return indexAnalyzer();
+        }
+
+        @Override
+        public IndexFieldData.Builder fielddataBuilder(String fullyQualifiedIndexName, Supplier<SearchLookup> searchLookup) {
+            failIfNoDocValues();
+            return new SortedSetOrdinalsIndexFieldData.Builder(name(), CoreValuesSourceType.BYTES);
+        }
+
+        @Override
+        public Query fuzzyQuery(
+            Object value,
+            Fuzziness fuzziness,
+            int prefixLength,
+            int maxExpansions,
+            boolean transpositions,
+            QueryShardContext context
+        ) {
+            // TODO: Not sure if we can reasonably describe a fuzzy query in terms of n-grams without exploding the cardinality
+            throw new IllegalArgumentException(
+                "Can only use fuzzy queries on keyword and text fields - not on [" + name() + "] which is of type [" + typeName() + "]"
+            );
+        }
+
+        @Override
+        public Query prefixQuery(String value, MultiTermQuery.RewriteMethod method, boolean caseInsensitive, QueryShardContext context) {
+            return wildcardQuery(value + "*", method, caseInsensitive, context);
+        }
+
+        @Override
+        public Query wildcardQuery(String value, MultiTermQuery.RewriteMethod method, boolean caseInsensitive, QueryShardContext context) {
+            NamedAnalyzer normalizer = normalizer();
+            if (normalizer != null) {
+                value = normalizeWildcardPattern(name(), value, normalizer);
+            }
+            final String finalValue;
+            if (caseInsensitive) {
+                // Use ROOT locale, as it seems to be consistent with AutomatonQueries.toCaseInsensitiveChar.
+                finalValue = value.toLowerCase(Locale.ROOT);
+            } else {
+                finalValue = value;
+            }
+            Predicate<String> matchPredicate;
+            if (value.contains("?")) {
+                Automaton automaton = WildcardQuery.toAutomaton(new Term(name(), finalValue));
+                CompiledAutomaton compiledAutomaton = new CompiledAutomaton(automaton);
+                matchPredicate = s -> {
+                    if (caseInsensitive) {
+                        s = s.toLowerCase(Locale.ROOT);
+                    }
+                    BytesRef valueBytes = BytesRefs.toBytesRef(s);
+                    return compiledAutomaton.runAutomaton.run(valueBytes.bytes, valueBytes.offset, valueBytes.length);
+                };
+            } else {
+                matchPredicate = s -> {
+                    if (caseInsensitive) {
+                        s = s.toLowerCase(Locale.ROOT);
+                    }
+                    return Regex.simpleMatch(finalValue, s);
+                };
+            }
+
+            Set<String> requiredNGrams = getRequiredNGrams(finalValue);
+            Query approximation;
+            if (requiredNGrams.isEmpty()) {
+                // This only happens when all characters are wildcard characters (* or ?),
+                // or it's the empty string.
+                if (value.length() == 0 || value.contains("?")) {
+                    approximation = this.existsQuery(context);
+                } else {
+                    return existsQuery(context);
+                }
+            } else {
+                approximation = matchAllTermsQuery(name(), requiredNGrams);
+            }
+            return new WildcardMatchingQuery(name(), approximation, matchPredicate, value, context, this);
+        }
+
+        // Package-private for testing
+        static Set<String> getRequiredNGrams(String value) {
+            Set<String> terms = new HashSet<>();
+            int pos = 0;
+            String currentSequence = null;
+            if (!value.startsWith("?") && !value.startsWith("*")) {
+                // Can add prefix term
+                currentSequence = getNonWildcardSequence(value, 0);
+                if (currentSequence.length() == 1) {
+                    terms.add(new String(new char[] { 0, currentSequence.charAt(0) }));
+                } else {
+                    terms.add(new String(new char[] { 0, currentSequence.charAt(0), currentSequence.charAt(1) }));
+                }
+            } else {
+                pos = findNonWildcardSequence(value, pos);
+                currentSequence = getNonWildcardSequence(value, pos);
+            }
+            while (pos < value.length()) {
+                boolean isEndOfValue = pos + currentSequence.length() == value.length();
+                if (!currentSequence.isEmpty() && currentSequence.length() < 3 && !isEndOfValue && pos > 0) {
+                    // If this is a prefix or suffix of length < 3, then we already have a longer token including the anchor.
+                    terms.add(currentSequence);
+                } else {
+                    for (int i = 0; i < currentSequence.length() - 2; i++) {
+                        terms.add(currentSequence.substring(i, i + 3));
+                    }
+                }
+                if (isEndOfValue) {
+                    // This is the end of the input. We can attach a suffix anchor.
+                    if (currentSequence.length() == 1) {
+                        terms.add(new String(new char[] { currentSequence.charAt(0), 0 }));
+                    } else {
+                        char a = currentSequence.charAt(currentSequence.length() - 2);
+                        char b = currentSequence.charAt(currentSequence.length() - 1);
+                        terms.add(new String(new char[] { a, b, 0 }));
+                    }
+                }
+                pos = findNonWildcardSequence(value, pos + currentSequence.length());
+                currentSequence = getNonWildcardSequence(value, pos);
+            }
+            return terms;
+        }
+
+        private static String getNonWildcardSequence(String value, int startFrom) {
+            for (int i = startFrom; i < value.length(); i++) {
+                char c = value.charAt(i);
+                if (c == '?' || c == '*') {
+                    return value.substring(startFrom, i);
+                }
+            }
+            // Made it to the end. No more wildcards.
+            return value.substring(startFrom);
+        }
+
+        private static int findNonWildcardSequence(String value, int startFrom) {
+            for (int i = startFrom; i < value.length(); i++) {
+                char c = value.charAt(i);
+                if (c != '?' && c != '*') {
+                    return i;
+                }
+            }
+            return value.length();
+        }
+
+        @Override
+        public Query regexpQuery(
+            String value,
+            int syntaxFlags,
+            int matchFlags,
+            int maxDeterminizedStates,
+            MultiTermQuery.RewriteMethod method,
+            QueryShardContext context
+        ) {
+            NamedAnalyzer normalizer = normalizer();
+            if (normalizer != null) {
+                value = normalizer.normalize(name(), value).utf8ToString();
+            }
+
+            RegExp regExp = new RegExp(value, syntaxFlags, matchFlags);
+            Automaton automaton = regExp.toAutomaton(maxDeterminizedStates);
+            CompiledAutomaton compiledAutomaton = new CompiledAutomaton(automaton);
+
+            Predicate<String> regexpPredicate;
+            if (compiledAutomaton.type == CompiledAutomaton.AUTOMATON_TYPE.ALL) {
+                return existsQuery(context);
+            } else if (compiledAutomaton.type == CompiledAutomaton.AUTOMATON_TYPE.NONE) {
+                return new MatchNoDocsQuery("Regular expression matches nothing");
+            } else {
+                regexpPredicate = s -> {
+                    BytesRef valueBytes = BytesRefs.toBytesRef(s);
+                    return compiledAutomaton.runAutomaton.run(valueBytes.bytes, valueBytes.offset, valueBytes.length);
+                };
+            }
+
+            Query approximation = regexpToQuery(name(), regExp);
+            if (approximation instanceof MatchAllDocsQuery) {
+                approximation = existsQuery(context);
+            }
+            return new WildcardMatchingQuery(name(), approximation, regexpPredicate, "/" + value + "/", context, this);
+        }
+
+        /**
+         * Implement the match rules described in <a href="https://swtch.com/~rsc/regexp/regexp4.html">Regular Expression Matching with a Trigram Index</a>.
+         *
+         * @param fieldName name of the wildcard field
+         * @param regExp a parsed node in the {@link RegExp} tree
+         * @return a query that matches on the known required parts of the given regular expression
+         */
+        private static Query regexpToQuery(String fieldName, RegExp regExp) {
+            BooleanQuery query;
+            if (Objects.requireNonNull(regExp.kind) == RegExp.Kind.REGEXP_UNION) {
+                List<Query> clauses = new ArrayList<>();
+                while (regExp.exp1.kind == RegExp.Kind.REGEXP_UNION) {
+                    clauses.add(regexpToQuery(fieldName, regExp.exp2));
+                    regExp = regExp.exp1;
+                }
+                clauses.add(regexpToQuery(fieldName, regExp.exp2));
+                clauses.add(regexpToQuery(fieldName, regExp.exp1));
+                BooleanQuery.Builder builder = new BooleanQuery.Builder();
+                for (int i = clauses.size() - 1; i >= 0; i--) {
+                    Query clause = clauses.get(i);
+                    if (clause instanceof MatchAllDocsQuery) {
+                        return clause;
+                    }
+                    builder.add(clause, BooleanClause.Occur.SHOULD);
+                }
+                query = builder.build();
+            } else if (regExp.kind == RegExp.Kind.REGEXP_STRING) {
+                BooleanQuery.Builder builder = new BooleanQuery.Builder();
+                for (String string : getRequiredNGrams("*" + regExp.s + "*")) {
+                    builder.add(new TermQuery(new Term(fieldName, string)), BooleanClause.Occur.FILTER);
+                }
+                query = builder.build();
+            } else if (regExp.kind == RegExp.Kind.REGEXP_CONCATENATION) {
+                List<Query> clauses = new ArrayList<>();
+                while (regExp.exp1.kind == RegExp.Kind.REGEXP_CONCATENATION) {
+                    clauses.add(regexpToQuery(fieldName, regExp.exp2));
+                    regExp = regExp.exp1;
+                }
+                clauses.add(regexpToQuery(fieldName, regExp.exp2));
+                clauses.add(regexpToQuery(fieldName, regExp.exp1));
+                BooleanQuery.Builder builder = new BooleanQuery.Builder();
+                for (int i = clauses.size() - 1; i >= 0; i--) {
+                    Query clause = clauses.get(i);
+                    if (!(clause instanceof MatchAllDocsQuery)) {
+                        builder.add(clause, BooleanClause.Occur.FILTER);
+                    }
+                }
+                query = builder.build();
+            } else if ((regExp.kind == RegExp.Kind.REGEXP_REPEAT_MIN || regExp.kind == RegExp.Kind.REGEXP_REPEAT_MINMAX)
+                && regExp.min > 0) {
+                    return regexpToQuery(fieldName, regExp.exp1);
+                } else {
+                    return new MatchAllDocsQuery();
+                }
+            if (query.clauses().size() == 1) {
+                return query.iterator().next().getQuery();
+            } else if (query.clauses().size() == 0) {
+                return new MatchAllDocsQuery();
+            }
+            return query;
+        }
+
+        @Override
+        public Query rangeQuery(Object lowerTerm, Object upperTerm, boolean includeLower, boolean includeUpper, QueryShardContext context) {
+            throw new UnsupportedOperationException("TODO");
+        }
+
+        @Override
+        public Query termQueryCaseInsensitive(Object value, QueryShardContext context) {
+            return wildcardQuery(BytesRefs.toString(value), MultiTermQuery.CONSTANT_SCORE_REWRITE, true, context);
+        }
+
+        @Override
+        public Query termQuery(Object value, QueryShardContext context) {
+            return wildcardQuery(BytesRefs.toString(value), MultiTermQuery.CONSTANT_SCORE_REWRITE, false, context);
+        }
+
+        @Override
+        public Query termsQuery(List<?> values, QueryShardContext context) {
+            BooleanQuery.Builder builder = new BooleanQuery.Builder();
+            Set<String> expectedValues = new HashSet<>();
+            StringBuilder pattern = new StringBuilder();
+            for (Object value : values) {
+                String stringVal = BytesRefs.toString(value);
+                builder.add(matchAllTermsQuery(name(), getRequiredNGrams(stringVal)), BooleanClause.Occur.SHOULD);
+                expectedValues.add(stringVal);
+                if (pattern.length() > 0) {
+                    pattern.append('|');
+                }
+                pattern.append(stringVal);
+            }
+            return new WildcardMatchingQuery(name(), builder.build(), expectedValues::contains, pattern.toString(), context, this);
+        }
+
+        private static BooleanQuery matchAllTermsQuery(String fieldName, Set<String> terms) {
+            BooleanQuery.Builder matchAllTermsBuilder = new BooleanQuery.Builder();
+            for (String term : terms) {
+                matchAllTermsBuilder.add(new TermQuery(new Term(fieldName, term)), BooleanClause.Occur.FILTER);
+            }
+            return matchAllTermsBuilder.build();
+        }
+    }
+
+    /**
+     * Custom two-phase query type for queries over the wildcard field. The expected behavior is that a first-phase
+     * query provides the best possible filter over the indexed trigrams, while the second phase matcher eliminates
+     * false positives by evaluating the true field value.
+     */
+    static class WildcardMatchingQuery extends Query {
+        private static final long MATCH_COST_ESTIMATE = 1000L;
+        private final String fieldName;
+        private final Query firstPhaseQuery;
+        private final Predicate<String> secondPhaseMatcher;
+        private final String patternString; // For toString
+        private final ValueFetcher valueFetcher;
+        private final SearchLookup searchLookup;
+
+        WildcardMatchingQuery(String fieldName, Query firstPhaseQuery, String patternString) {
+            this(fieldName, firstPhaseQuery, s -> true, patternString, (QueryShardContext) null, null);
+        }
+
+        public WildcardMatchingQuery(
+            String fieldName,
+            Query firstPhaseQuery,
+            Predicate<String> secondPhaseMatcher,
+            String patternString,
+            QueryShardContext context,
+            WildcardFieldType fieldType
+        ) {
+            this.fieldName = Objects.requireNonNull(fieldName);
+            this.firstPhaseQuery = Objects.requireNonNull(firstPhaseQuery);
+            this.secondPhaseMatcher = Objects.requireNonNull(secondPhaseMatcher);
+            this.patternString = Objects.requireNonNull(patternString);
+            if (context != null) {
+                this.searchLookup = context.lookup();
+                this.valueFetcher = fieldType.valueFetcher(context, context.lookup(), null);
+            } else {
+                this.searchLookup = null;
+                this.valueFetcher = null;
+            }
+        }
+
+        private WildcardMatchingQuery(
+            String fieldName,
+            Query firstPhaseQuery,
+            Predicate<String> secondPhaseMatcher,
+            String patternString,
+            ValueFetcher valueFetcher,
+            SearchLookup searchLookup
+        ) {
+            this.fieldName = fieldName;
+            this.firstPhaseQuery = firstPhaseQuery;
+            this.secondPhaseMatcher = secondPhaseMatcher;
+            this.patternString = patternString;
+            this.valueFetcher = valueFetcher;
+            this.searchLookup = searchLookup;
+        }
+
+        @Override
+        public String toString(String s) {
+            return "WildcardMatchingQuery(" + fieldName + ":\"" + patternString + "\")";
+        }
+
+        @Override
+        public void visit(QueryVisitor queryVisitor) {
+            firstPhaseQuery.visit(queryVisitor);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            WildcardMatchingQuery that = (WildcardMatchingQuery) o;
+            return Objects.equals(fieldName, that.fieldName)
+                && Objects.equals(firstPhaseQuery, that.firstPhaseQuery)
+                && Objects.equals(patternString, that.patternString);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(fieldName, firstPhaseQuery, patternString);
+        }
+
+        @Override
+        public Query rewrite(IndexSearcher indexSearcher) throws IOException {
+            Query rewriteFirstPhase = firstPhaseQuery.rewrite(indexSearcher);
+            if (rewriteFirstPhase != firstPhaseQuery) {
+                return new WildcardMatchingQuery(
+                    fieldName,
+                    rewriteFirstPhase,
+                    secondPhaseMatcher,
+                    patternString,
+                    valueFetcher,
+                    searchLookup
+                );
+            }
+            return this;
+        }
+
+        @Override
+        public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
+            Weight firstPhaseWeight = firstPhaseQuery.createWeight(searcher, scoreMode, boost);
+            return new ConstantScoreWeight(this, boost) {
+                @Override
+                public Scorer scorer(LeafReaderContext leafReaderContext) throws IOException {
+                    ScorerSupplier supplier = scorerSupplier(leafReaderContext);
+                    if (supplier == null) {
+                        return null;
+                    }
+                    return supplier.get(Long.MAX_VALUE);
+                }
+
+                @Override
+                public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException {
+                    Weight weight = this;
+                    ScorerSupplier firstPhaseSupplier = firstPhaseWeight.scorerSupplier(context);
+                    if (firstPhaseSupplier == null) {
+                        return null;
+                    }
+                    return new ScorerSupplier() {
+                        @Override
+                        public Scorer get(long leadCost) throws IOException {
+                            Scorer approximateScorer = firstPhaseSupplier.get(leadCost);
+                            DocIdSetIterator approximation = approximateScorer.iterator();
+                            LeafSearchLookup leafSearchLookup = searchLookup.getLeafSearchLookup(context);
+                            valueFetcher.setNextReader(context);
+
+                            TwoPhaseIterator twoPhaseIterator = new TwoPhaseIterator(approximation) {
+                                @Override
+                                public boolean matches() throws IOException {
+                                    leafSearchLookup.setDocument(approximation.docID());
+                                    List<?> values = valueFetcher.fetchValues(leafSearchLookup.source());
+                                    for (Object value : values) {
+                                        if (secondPhaseMatcher.test(value.toString())) {
+                                            return true;
+                                        }
+                                    }
+                                    return false;
+                                }
+
+                                @Override
+                                public float matchCost() {
+                                    return MATCH_COST_ESTIMATE;
+                                }
+                            };
+                            return new ConstantScoreScorer(weight, score(), scoreMode, twoPhaseIterator);
+                        }
+
+                        @Override
+                        public long cost() {
+                            long firstPhaseCost = firstPhaseSupplier.cost();
+                            if (firstPhaseCost >= Long.MAX_VALUE / MATCH_COST_ESTIMATE) {
+                                return Long.MAX_VALUE;
+                            }
+                            return firstPhaseCost * MATCH_COST_ESTIMATE;
+                        }
+                    };
+                }
+
+                @Override
+                public boolean isCacheable(LeafReaderContext leafReaderContext) {
+                    return true;
+                }
+            };
+        }
+
+        // Visible for testing
+        Predicate<String> getSecondPhaseMatcher() {
+            return secondPhaseMatcher;
+        }
+    }
+
+    @Override
+    public WildcardFieldType fieldType() {
+        return (WildcardFieldType) super.fieldType();
+    }
+
+    @Override
+    protected String contentType() {
+        return CONTENT_TYPE;
+    }
+
+    @Override
+    public ParametrizedFieldMapper.Builder getMergeBuilder() {
+        return new Builder(simpleName(), indexAnalyzers).init(this);
+    }
+
+    private static WildcardFieldMapper toType(FieldMapper in) {
+        return (WildcardFieldMapper) in;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/query/DerivedFieldQuery.java b/server/src/main/java/org/opensearch/index/query/DerivedFieldQuery.java
index 42ac61bf98f73..dcc02726cb0ef 100644
--- a/server/src/main/java/org/opensearch/index/query/DerivedFieldQuery.java
+++ b/server/src/main/java/org/opensearch/index/query/DerivedFieldQuery.java
@@ -29,6 +29,8 @@
 import java.io.IOException;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Function;
+import java.util.function.Supplier;
 
 /**
  * DerivedFieldQuery used for querying derived fields. It contains the logic to execute an input lucene query against
@@ -36,21 +38,32 @@
  */
 public final class DerivedFieldQuery extends Query {
     private final Query query;
-    private final DerivedFieldValueFetcher valueFetcher;
+    private final Supplier<DerivedFieldValueFetcher> valueFetcherSupplier;
     private final SearchLookup searchLookup;
     private final Analyzer indexAnalyzer;
+    private final boolean ignoreMalformed;
+
+    private final Function<Object, IndexableField> indexableFieldGenerator;
 
     /**
      * @param query lucene query to be executed against the derived field
-     * @param valueFetcher DerivedFieldValueFetcher ValueFetcher to fetch the value of a derived field from _source
-     *                     using LeafSearchLookup
+     * @param valueFetcherSupplier Supplier of a DerivedFieldValueFetcher that will be reconstructed per leaf
      * @param searchLookup SearchLookup to get the LeafSearchLookup look used by valueFetcher to fetch the _source
      */
-    public DerivedFieldQuery(Query query, DerivedFieldValueFetcher valueFetcher, SearchLookup searchLookup, Analyzer indexAnalyzer) {
+    public DerivedFieldQuery(
+        Query query,
+        Supplier<DerivedFieldValueFetcher> valueFetcherSupplier,
+        SearchLookup searchLookup,
+        Analyzer indexAnalyzer,
+        Function<Object, IndexableField> indexableFieldGenerator,
+        boolean ignoreMalformed
+    ) {
         this.query = query;
-        this.valueFetcher = valueFetcher;
+        this.valueFetcherSupplier = valueFetcherSupplier;
         this.searchLookup = searchLookup;
         this.indexAnalyzer = indexAnalyzer;
+        this.indexableFieldGenerator = indexableFieldGenerator;
+        this.ignoreMalformed = ignoreMalformed;
     }
 
     @Override
@@ -60,11 +73,19 @@ public void visit(QueryVisitor visitor) {
 
     @Override
     public Query rewrite(IndexSearcher indexSearcher) throws IOException {
-        Query rewritten = indexSearcher.rewrite(query);
+        Query rewritten = query.rewrite(indexSearcher);
         if (rewritten == query) {
             return this;
         }
-        return new DerivedFieldQuery(rewritten, valueFetcher, searchLookup, indexAnalyzer);
+        ;
+        return new DerivedFieldQuery(
+            rewritten,
+            valueFetcherSupplier,
+            searchLookup,
+            indexAnalyzer,
+            indexableFieldGenerator,
+            ignoreMalformed
+        );
     }
 
     @Override
@@ -73,16 +94,28 @@ public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float bo
         return new ConstantScoreWeight(this, boost) {
             @Override
             public Scorer scorer(LeafReaderContext context) {
-                DocIdSetIterator approximation = DocIdSetIterator.all(context.reader().maxDoc());
+                DocIdSetIterator approximation;
+                approximation = DocIdSetIterator.all(context.reader().maxDoc());
+
+                // Create a new ValueFetcher per thread.
+                // ValueFetcher.setNextReader creates a DerivedFieldScript and internally SourceLookup and these objects are not
+                // thread safe.
+                final DerivedFieldValueFetcher valueFetcher = valueFetcherSupplier.get();
                 valueFetcher.setNextReader(context);
                 LeafSearchLookup leafSearchLookup = searchLookup.getLeafSearchLookup(context);
                 TwoPhaseIterator twoPhase = new TwoPhaseIterator(approximation) {
                     @Override
                     public boolean matches() {
                         leafSearchLookup.source().setSegmentAndDocument(context, approximation.docID());
-                        List<IndexableField> indexableFields = valueFetcher.getIndexableField(leafSearchLookup.source());
-                        // TODO: in case of errors from script, should it be ignored and treated as missing field
-                        // by using a configurable setting?
+                        List<IndexableField> indexableFields;
+                        try {
+                            indexableFields = valueFetcher.getIndexableField(leafSearchLookup.source(), indexableFieldGenerator);
+                        } catch (Exception e) {
+                            if (ignoreMalformed) {
+                                return false;
+                            }
+                            throw e;
+                        }
                         MemoryIndex memoryIndex = new MemoryIndex();
                         for (IndexableField indexableField : indexableFields) {
                             memoryIndex.addField(indexableField, indexAnalyzer);
diff --git a/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java b/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
index 3011a48fbb296..6ae40fe1b1e64 100644
--- a/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
+++ b/server/src/main/java/org/opensearch/index/query/ExistsQueryBuilder.java
@@ -230,20 +230,16 @@ private static Collection<String> getMappedField(QueryShardContext context, Stri
         if (context.getObjectMapper(fieldPattern) != null) {
             // the _field_names field also indexes objects, so we don't have to
             // do any more work to support exists queries on whole objects
-            fields = Collections.singleton(fieldPattern);
+            return Collections.singleton(fieldPattern);
         } else {
             fields = context.simpleMatchToIndexNames(fieldPattern);
         }
 
         if (fields.size() == 1) {
             String field = fields.iterator().next();
-            MappedFieldType fieldType = context.getMapperService().fieldType(field);
+            MappedFieldType fieldType = context.fieldMapper(field);
             if (fieldType == null) {
-                // The field does not exist as a leaf but could be an object so
-                // check for an object mapper
-                if (context.getObjectMapper(field) == null) {
-                    return Collections.emptySet();
-                }
+                return Collections.emptySet();
             }
         }
 
diff --git a/server/src/main/java/org/opensearch/index/query/FuzzyQueryBuilder.java b/server/src/main/java/org/opensearch/index/query/FuzzyQueryBuilder.java
index a25a426792e31..93c32bbedcef4 100644
--- a/server/src/main/java/org/opensearch/index/query/FuzzyQueryBuilder.java
+++ b/server/src/main/java/org/opensearch/index/query/FuzzyQueryBuilder.java
@@ -357,7 +357,7 @@ protected Query doToQuery(QueryShardContext context) throws IOException {
             throw new IllegalStateException("Rewrite first");
         }
         String rewrite = this.rewrite;
-        Query query = fieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, context);
+        Query query = fieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, null, context);
         if (query instanceof MultiTermQuery) {
             MultiTermQuery.RewriteMethod rewriteMethod = QueryParsers.parseRewriteMethod(rewrite, null, LoggingDeprecationHandler.INSTANCE);
             QueryParsers.setRewriteMethod((MultiTermQuery) query, rewriteMethod);
diff --git a/server/src/main/java/org/opensearch/index/query/NestedQueryBuilder.java b/server/src/main/java/org/opensearch/index/query/NestedQueryBuilder.java
index 3f97b3918a126..5908882472ce7 100644
--- a/server/src/main/java/org/opensearch/index/query/NestedQueryBuilder.java
+++ b/server/src/main/java/org/opensearch/index/query/NestedQueryBuilder.java
@@ -34,6 +34,7 @@
 
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.ReaderUtil;
+import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.MatchNoDocsQuery;
 import org.apache.lucene.search.MultiCollector;
 import org.apache.lucene.search.Query;
@@ -401,16 +402,32 @@ protected void doBuild(SearchContext parentSearchContext, InnerHitsContext inner
                 }
             }
             String name = innerHitBuilder.getName() != null ? innerHitBuilder.getName() : nestedObjectMapper.fullPath();
-            ObjectMapper parentObjectMapper = queryShardContext.nestedScope().nextLevel(nestedObjectMapper);
-            NestedInnerHitSubContext nestedInnerHits = new NestedInnerHitSubContext(
-                name,
-                parentSearchContext,
-                parentObjectMapper,
-                nestedObjectMapper
-            );
-            setupInnerHitsContext(queryShardContext, nestedInnerHits);
-            queryShardContext.nestedScope().previousLevel();
-            innerHitsContext.addInnerHitDefinition(nestedInnerHits);
+            ObjectMapper parentObjectMapper = queryShardContext.nestedScope().getObjectMapper();
+            BitSetProducer parentFilter;
+            if (parentObjectMapper == null) {
+                parentFilter = queryShardContext.bitsetFilter(Queries.newNonNestedFilter());
+            } else {
+                parentFilter = queryShardContext.bitsetFilter(parentObjectMapper.nestedTypeFilter());
+            }
+            BitSetProducer previousParentFilter = queryShardContext.getParentFilter();
+            try {
+                queryShardContext.setParentFilter(parentFilter);
+                queryShardContext.nestedScope().nextLevel(nestedObjectMapper);
+                try {
+                    NestedInnerHitSubContext nestedInnerHits = new NestedInnerHitSubContext(
+                        name,
+                        parentSearchContext,
+                        parentObjectMapper,
+                        nestedObjectMapper
+                    );
+                    setupInnerHitsContext(queryShardContext, nestedInnerHits);
+                    innerHitsContext.addInnerHitDefinition(nestedInnerHits);
+                } finally {
+                    queryShardContext.nestedScope().previousLevel();
+                }
+            } finally {
+                queryShardContext.setParentFilter(previousParentFilter);
+            }
         }
     }
 
@@ -489,4 +506,12 @@ public TopDocsAndMaxScore topDocs(SearchHit hit) throws IOException {
             }
         }
     }
+
+    @Override
+    public void visit(QueryBuilderVisitor visitor) {
+        visitor.accept(this);
+        if (query != null) {
+            visitor.getChildVisitor(BooleanClause.Occur.MUST).accept(query);
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/query/QueryShapeVisitor.java b/server/src/main/java/org/opensearch/index/query/QueryShapeVisitor.java
deleted file mode 100644
index 3ba13bc7a2da4..0000000000000
--- a/server/src/main/java/org/opensearch/index/query/QueryShapeVisitor.java
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.index.query;
-
-import org.apache.lucene.search.BooleanClause;
-import org.opensearch.common.SetOnce;
-
-import java.util.ArrayList;
-import java.util.EnumMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
-/**
- * Class to traverse the QueryBuilder tree and capture the query shape
- */
-public final class QueryShapeVisitor implements QueryBuilderVisitor {
-    private final SetOnce<String> queryType = new SetOnce<>();
-    private final Map<BooleanClause.Occur, List<QueryShapeVisitor>> childVisitors = new EnumMap<>(BooleanClause.Occur.class);
-
-    @Override
-    public void accept(QueryBuilder qb) {
-        queryType.set(qb.getName());
-    }
-
-    @Override
-    public QueryBuilderVisitor getChildVisitor(BooleanClause.Occur occur) {
-        // Should get called once per Occur value
-        if (childVisitors.containsKey(occur)) {
-            throw new IllegalStateException("child visitor already called for " + occur);
-        }
-        final List<QueryShapeVisitor> childVisitorList = new ArrayList<>();
-        QueryBuilderVisitor childVisitorWrapper = new QueryBuilderVisitor() {
-            QueryShapeVisitor currentChild;
-
-            @Override
-            public void accept(QueryBuilder qb) {
-                currentChild = new QueryShapeVisitor();
-                childVisitorList.add(currentChild);
-                currentChild.accept(qb);
-            }
-
-            @Override
-            public QueryBuilderVisitor getChildVisitor(BooleanClause.Occur occur) {
-                return currentChild.getChildVisitor(occur);
-            }
-        };
-        childVisitors.put(occur, childVisitorList);
-        return childVisitorWrapper;
-    }
-
-    String toJson() {
-        StringBuilder outputBuilder = new StringBuilder("{\"type\":\"").append(queryType.get()).append("\"");
-        for (Map.Entry<BooleanClause.Occur, List<QueryShapeVisitor>> entry : childVisitors.entrySet()) {
-            outputBuilder.append(",\"").append(entry.getKey().name().toLowerCase(Locale.ROOT)).append("\"[");
-            boolean first = true;
-            for (QueryShapeVisitor child : entry.getValue()) {
-                if (!first) {
-                    outputBuilder.append(",");
-                }
-                outputBuilder.append(child.toJson());
-                first = false;
-            }
-            outputBuilder.append("]");
-        }
-        outputBuilder.append("}");
-        return outputBuilder.toString();
-    }
-
-    public String prettyPrintTree(String indent) {
-        StringBuilder outputBuilder = new StringBuilder(indent).append(queryType.get()).append("\n");
-        for (Map.Entry<BooleanClause.Occur, List<QueryShapeVisitor>> entry : childVisitors.entrySet()) {
-            outputBuilder.append(indent).append("  ").append(entry.getKey().name().toLowerCase(Locale.ROOT)).append(":\n");
-            for (QueryShapeVisitor child : entry.getValue()) {
-                outputBuilder.append(child.prettyPrintTree(indent + "    "));
-            }
-        }
-        return outputBuilder.toString();
-    }
-}
diff --git a/server/src/main/java/org/opensearch/index/query/QueryShardContext.java b/server/src/main/java/org/opensearch/index/query/QueryShardContext.java
index 64643ad6d2c94..05c07a0f32d5a 100644
--- a/server/src/main/java/org/opensearch/index/query/QueryShardContext.java
+++ b/server/src/main/java/org/opensearch/index/query/QueryShardContext.java
@@ -43,9 +43,9 @@
 import org.opensearch.common.CheckedFunction;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.TriFunction;
+import org.opensearch.common.annotation.DeprecatedApi;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.lucene.search.Queries;
-import org.opensearch.common.regex.Regex;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.ParsingException;
@@ -59,6 +59,9 @@
 import org.opensearch.index.cache.bitset.BitsetFilterCache;
 import org.opensearch.index.fielddata.IndexFieldData;
 import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.DerivedFieldResolver;
+import org.opensearch.index.mapper.DerivedFieldResolverFactory;
+import org.opensearch.index.mapper.DerivedFieldType;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.index.mapper.Mapper;
@@ -88,6 +91,8 @@
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
 import static java.util.Collections.unmodifiableMap;
 
 /**
@@ -120,8 +125,7 @@ public class QueryShardContext extends QueryRewriteContext {
     private NestedScope nestedScope;
     private final ValuesSourceRegistry valuesSourceRegistry;
     private BitSetProducer parentFilter;
-
-    private Map<String, MappedFieldType> derivedFieldTypeMap = new HashMap<>();
+    private DerivedFieldResolver derivedFieldResolver;
 
     public QueryShardContext(
         int shardId,
@@ -268,6 +272,12 @@ private QueryShardContext(
         this.fullyQualifiedIndex = fullyQualifiedIndex;
         this.allowExpensiveQueries = allowExpensiveQueries;
         this.valuesSourceRegistry = valuesSourceRegistry;
+        this.derivedFieldResolver = DerivedFieldResolverFactory.createResolver(
+            this,
+            emptyMap(),
+            emptyList(),
+            indexSettings.isDerivedFieldAllowed()
+        );
     }
 
     private void reset() {
@@ -333,17 +343,9 @@ public Map<String, Query> copyNamedQueries() {
      * type then the fields will be returned with a type prefix.
      */
     public Set<String> simpleMatchToIndexNames(String pattern) {
-        Set<String> matchingFields = mapperService.simpleMatchToFullName(pattern);
-        if (derivedFieldTypeMap != null && !derivedFieldTypeMap.isEmpty()) {
-            Set<String> matchingDerivedFields = new HashSet<>(matchingFields);
-            for (String fieldName : derivedFieldTypeMap.keySet()) {
-                if (!matchingDerivedFields.contains(fieldName) && Regex.simpleMatch(pattern, fieldName)) {
-                    matchingDerivedFields.add(fieldName);
-                }
-            }
-            return matchingDerivedFields;
-        }
-        return matchingFields;
+        Set<String> allMatchingFields = new HashSet<>(mapperService.simpleMatchToFullName(pattern));
+        allMatchingFields.addAll(derivedFieldResolver.resolvePattern(pattern));
+        return allMatchingFields;
     }
 
     /**
@@ -409,12 +411,18 @@ public ValuesSourceRegistry getValuesSourceRegistry() {
         return valuesSourceRegistry;
     }
 
+    public void setDerivedFieldResolver(DerivedFieldResolver derivedFieldResolver) {
+        this.derivedFieldResolver = derivedFieldResolver;
+    }
+
+    @DeprecatedApi(since = "2.15.0")
     public void setDerivedFieldTypes(Map<String, MappedFieldType> derivedFieldTypeMap) {
-        this.derivedFieldTypeMap = derivedFieldTypeMap;
+        throw new UnsupportedOperationException("Use setDerivedFieldResolver() instead.");
     }
 
+    @DeprecatedApi(since = "2.15.0")
     public MappedFieldType getDerivedFieldType(String fieldName) {
-        return derivedFieldTypeMap == null ? null : derivedFieldTypeMap.get(fieldName);
+        throw new UnsupportedOperationException("Use resolveDerivedFieldType() instead.");
     }
 
     public void setAllowUnmappedFields(boolean allowUnmappedFields) {
@@ -427,9 +435,14 @@ public void setMapUnmappedFieldAsString(boolean mapUnmappedFieldAsString) {
 
     MappedFieldType failIfFieldMappingNotFound(String name, MappedFieldType fieldMapping) {
         if (fieldMapping != null) {
+            if (fieldMapping instanceof DerivedFieldType) {
+                // resolveDerivedFieldType() will give precedence to search time definitions over index mapping, thus
+                // calling it instead of directly returning. It also ensures the feature flags are honoured.
+                return resolveDerivedFieldType(name);
+            }
+            return fieldMapping;
+        } else if ((fieldMapping = resolveDerivedFieldType(name)) != null) {
             return fieldMapping;
-        } else if (getDerivedFieldType(name) != null) {
-            return getDerivedFieldType(name);
         } else if (allowUnmappedFields) {
             return fieldMapping;
         } else if (mapUnmappedFieldAsString) {
@@ -440,6 +453,10 @@ MappedFieldType failIfFieldMappingNotFound(String name, MappedFieldType fieldMap
         }
     }
 
+    public MappedFieldType resolveDerivedFieldType(String name) {
+        return derivedFieldResolver.resolve(name);
+    }
+
     private SearchLookup lookup = null;
 
     /**
diff --git a/server/src/main/java/org/opensearch/index/query/SourceFieldMatchQuery.java b/server/src/main/java/org/opensearch/index/query/SourceFieldMatchQuery.java
index b0be20e417efe..e9abcb698f68f 100644
--- a/server/src/main/java/org/opensearch/index/query/SourceFieldMatchQuery.java
+++ b/server/src/main/java/org/opensearch/index/query/SourceFieldMatchQuery.java
@@ -73,7 +73,7 @@ public void visit(QueryVisitor visitor) {
 
     @Override
     public Query rewrite(IndexSearcher indexSearcher) throws IOException {
-        Query rewritten = indexSearcher.rewrite(delegateQuery);
+        Query rewritten = delegateQuery.rewrite(indexSearcher);
         if (rewritten == delegateQuery) {
             return this;
         }
diff --git a/server/src/main/java/org/opensearch/index/query/TermsQueryBuilder.java b/server/src/main/java/org/opensearch/index/query/TermsQueryBuilder.java
index ac0ca3919ea38..4b92d6a1f5460 100644
--- a/server/src/main/java/org/opensearch/index/query/TermsQueryBuilder.java
+++ b/server/src/main/java/org/opensearch/index/query/TermsQueryBuilder.java
@@ -37,14 +37,17 @@
 import org.apache.lucene.search.Query;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.BytesRefBuilder;
+import org.opensearch.Version;
 import org.opensearch.action.get.GetRequest;
 import org.opensearch.client.Client;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.xcontent.support.XContentMapValues;
+import org.opensearch.core.ParseField;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.ParsingException;
 import org.opensearch.core.common.Strings;
+import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -53,6 +56,7 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.mapper.ConstantFieldType;
 import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.index.mapper.NumberFieldMapper;
 import org.opensearch.indices.TermsLookup;
 
 import java.io.IOException;
@@ -60,6 +64,7 @@
 import java.util.AbstractList;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Base64;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
@@ -82,6 +87,39 @@ public class TermsQueryBuilder extends AbstractQueryBuilder<TermsQueryBuilder> {
     private final TermsLookup termsLookup;
     private final Supplier<List<?>> supplier;
 
+    private static final ParseField VALUE_TYPE_FIELD = new ParseField("value_type");
+    private ValueType valueType = ValueType.DEFAULT;
+
+    /**
+     * Terms query may accept different types of value
+     * <p>
+     * This flag is used to decide how to parse the value and build query upon later
+     */
+    public enum ValueType {
+        DEFAULT("default"),
+        BITMAP("bitmap");
+
+        private final String type;
+
+        ValueType(String type) {
+            this.type = type;
+        }
+
+        static ValueType fromString(String type) {
+            for (ValueType valueType : ValueType.values()) {
+                if (valueType.type.equalsIgnoreCase(type)) {
+                    return valueType;
+                }
+            }
+            throw new IllegalArgumentException(type + " is not valid " + VALUE_TYPE_FIELD);
+        }
+    }
+
+    public TermsQueryBuilder valueType(ValueType valueType) {
+        this.valueType = valueType;
+        return this;
+    }
+
     public TermsQueryBuilder(String fieldName, TermsLookup termsLookup) {
         this(fieldName, null, termsLookup);
     }
@@ -187,6 +225,11 @@ public TermsQueryBuilder(String fieldName, Iterable<?> values) {
         this.supplier = null;
     }
 
+    private TermsQueryBuilder(String fieldName, Iterable<?> values, ValueType valueType) {
+        this(fieldName, values);
+        this.valueType = valueType;
+    }
+
     private TermsQueryBuilder(String fieldName, Supplier<List<?>> supplier) {
         this.fieldName = fieldName;
         this.values = null;
@@ -194,6 +237,11 @@ private TermsQueryBuilder(String fieldName, Supplier<List<?>> supplier) {
         this.supplier = supplier;
     }
 
+    private TermsQueryBuilder(String fieldName, Supplier<List<?>> supplier, ValueType valueType) {
+        this(fieldName, supplier);
+        this.valueType = valueType;
+    }
+
     /**
      * Read from a stream.
      */
@@ -203,6 +251,9 @@ public TermsQueryBuilder(StreamInput in) throws IOException {
         termsLookup = in.readOptionalWriteable(TermsLookup::new);
         values = (List<?>) in.readGenericValue();
         this.supplier = null;
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            valueType = in.readEnum(ValueType.class);
+        }
     }
 
     @Override
@@ -213,6 +264,9 @@ protected void doWriteTo(StreamOutput out) throws IOException {
         out.writeString(fieldName);
         out.writeOptionalWriteable(termsLookup);
         out.writeGenericValue(values);
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeEnum(valueType);
+        }
     }
 
     public String fieldName() {
@@ -360,6 +414,9 @@ protected void doXContent(XContentBuilder builder, Params params) throws IOExcep
             builder.field(fieldName, convertBack(values));
         }
         printBoostAndQueryName(builder);
+        if (valueType != ValueType.DEFAULT) {
+            builder.field(VALUE_TYPE_FIELD.getPreferredName(), valueType.type);
+        }
         builder.endObject();
     }
 
@@ -371,6 +428,8 @@ public static TermsQueryBuilder fromXContent(XContentParser parser) throws IOExc
         String queryName = null;
         float boost = AbstractQueryBuilder.DEFAULT_BOOST;
 
+        String valueTypeStr = ValueType.DEFAULT.type;
+
         XContentParser.Token token;
         String currentFieldName = null;
         while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
@@ -406,6 +465,8 @@ public static TermsQueryBuilder fromXContent(XContentParser parser) throws IOExc
                     boost = parser.floatValue();
                 } else if (AbstractQueryBuilder.NAME_FIELD.match(currentFieldName, parser.getDeprecationHandler())) {
                     queryName = parser.text();
+                } else if (VALUE_TYPE_FIELD.match(currentFieldName, parser.getDeprecationHandler())) {
+                    valueTypeStr = parser.text();
                 } else {
                     throw new ParsingException(
                         parser.getTokenLocation(),
@@ -430,7 +491,18 @@ public static TermsQueryBuilder fromXContent(XContentParser parser) throws IOExc
             );
         }
 
-        return new TermsQueryBuilder(fieldName, values, termsLookup).boost(boost).queryName(queryName);
+        ValueType valueType = ValueType.fromString(valueTypeStr);
+        if (valueType == ValueType.BITMAP) {
+            if (values != null && values.size() == 1 && values.get(0) instanceof BytesRef) {
+                values.set(0, new BytesArray(Base64.getDecoder().decode(((BytesRef) values.get(0)).utf8ToString())));
+            } else if (termsLookup == null) {
+                throw new IllegalArgumentException(
+                    "Invalid value for bitmap type: Expected a single-element array with a base64 encoded serialized bitmap."
+                );
+            }
+        }
+
+        return new TermsQueryBuilder(fieldName, values, termsLookup).boost(boost).queryName(queryName).valueType(valueType);
     }
 
     static List<Object> parseValues(XContentParser parser) throws IOException {
@@ -473,17 +545,37 @@ protected Query doToQuery(QueryShardContext context) throws IOException {
         if (fieldType == null) {
             throw new IllegalStateException("Rewrite first");
         }
+        if (valueType == ValueType.BITMAP) {
+            if (values.size() == 1 && values.get(0) instanceof BytesArray) {
+                if (fieldType instanceof NumberFieldMapper.NumberFieldType) {
+                    return ((NumberFieldMapper.NumberFieldType) fieldType).bitmapQuery((BytesArray) values.get(0));
+                }
+            }
+        }
         return fieldType.termsQuery(values, context);
     }
 
     private void fetch(TermsLookup termsLookup, Client client, ActionListener<List<Object>> actionListener) {
         GetRequest getRequest = new GetRequest(termsLookup.index(), termsLookup.id());
         getRequest.preference("_local").routing(termsLookup.routing());
+        if (termsLookup.store()) {
+            getRequest.storedFields(termsLookup.path());
+        }
         client.get(getRequest, ActionListener.delegateFailure(actionListener, (delegatedListener, getResponse) -> {
             List<Object> terms = new ArrayList<>();
-            if (getResponse.isSourceEmpty() == false) { // extract terms only if the doc source exists
-                List<Object> extractedValues = XContentMapValues.extractRawValues(termsLookup.path(), getResponse.getSourceAsMap());
-                terms.addAll(extractedValues);
+            if (termsLookup.store()) {
+                List<Object> values = getResponse.getField(termsLookup.path()).getValues();
+                if (values.size() != 1 && valueType == ValueType.BITMAP) {
+                    throw new IllegalArgumentException(
+                        "Invalid value for bitmap type: Expected a single base64 encoded serialized bitmap."
+                    );
+                }
+                terms.addAll(values);
+            } else {
+                if (getResponse.isSourceEmpty() == false) { // extract terms only if the doc source exists
+                    List<Object> extractedValues = XContentMapValues.extractRawValues(termsLookup.path(), getResponse.getSourceAsMap());
+                    terms.addAll(extractedValues);
+                }
             }
             delegatedListener.onResponse(terms);
         }));
@@ -491,7 +583,7 @@ private void fetch(TermsLookup termsLookup, Client client, ActionListener<List<O
 
     @Override
     protected int doHashCode() {
-        return Objects.hash(fieldName, values, termsLookup, supplier);
+        return Objects.hash(fieldName, values, termsLookup, supplier, valueType);
     }
 
     @Override
@@ -499,20 +591,21 @@ protected boolean doEquals(TermsQueryBuilder other) {
         return Objects.equals(fieldName, other.fieldName)
             && Objects.equals(values, other.values)
             && Objects.equals(termsLookup, other.termsLookup)
-            && Objects.equals(supplier, other.supplier);
+            && Objects.equals(supplier, other.supplier)
+            && Objects.equals(valueType, other.valueType);
     }
 
     @Override
     protected QueryBuilder doRewrite(QueryRewriteContext queryRewriteContext) {
         if (supplier != null) {
-            return supplier.get() == null ? this : new TermsQueryBuilder(this.fieldName, supplier.get());
+            return supplier.get() == null ? this : new TermsQueryBuilder(this.fieldName, supplier.get(), valueType);
         } else if (this.termsLookup != null) {
             SetOnce<List<?>> supplier = new SetOnce<>();
             queryRewriteContext.registerAsyncAction((client, listener) -> fetch(termsLookup, client, ActionListener.map(listener, list -> {
                 supplier.set(list);
                 return null;
             })));
-            return new TermsQueryBuilder(this.fieldName, supplier::get);
+            return new TermsQueryBuilder(this.fieldName, supplier::get, valueType);
         }
 
         if (values == null || values.isEmpty()) {
diff --git a/server/src/main/java/org/opensearch/index/query/VectorGeoPointShapeQueryProcessor.java b/server/src/main/java/org/opensearch/index/query/VectorGeoPointShapeQueryProcessor.java
index c55d88439b11f..c4237cd94a834 100644
--- a/server/src/main/java/org/opensearch/index/query/VectorGeoPointShapeQueryProcessor.java
+++ b/server/src/main/java/org/opensearch/index/query/VectorGeoPointShapeQueryProcessor.java
@@ -81,7 +81,7 @@ private void validateIsGeoPointFieldType(String fieldName, QueryShardContext con
         MappedFieldType fieldType = context.fieldMapper(fieldName);
         if (fieldType instanceof GeoPointFieldMapper.GeoPointFieldType == false
             && !(fieldType instanceof DerivedFieldType
-                && (((DerivedFieldType) fieldType).getTypeMappedFieldType() instanceof GeoPointFieldMapper.GeoPointFieldType))) {
+                && (((DerivedFieldType) fieldType).getFieldMapper().fieldType() instanceof GeoPointFieldMapper.GeoPointFieldType))) {
             throw new QueryShardException(
                 context,
                 "Expected "
diff --git a/server/src/main/java/org/opensearch/index/recovery/RemoteStoreRestoreService.java b/server/src/main/java/org/opensearch/index/recovery/RemoteStoreRestoreService.java
index fe90f24b0f544..03d841d13b7f7 100644
--- a/server/src/main/java/org/opensearch/index/recovery/RemoteStoreRestoreService.java
+++ b/server/src/main/java/org/opensearch/index/recovery/RemoteStoreRestoreService.java
@@ -152,7 +152,11 @@ public RemoteRestoreResult restore(
                     throw new IllegalArgumentException("clusterUUID to restore from should be different from current cluster UUID");
                 }
                 logger.info("Restoring cluster state from remote store from cluster UUID : [{}]", restoreClusterUUID);
-                remoteState = remoteClusterStateService.getLatestClusterState(currentState.getClusterName().value(), restoreClusterUUID);
+                remoteState = remoteClusterStateService.getLatestClusterState(
+                    currentState.getClusterName().value(),
+                    restoreClusterUUID,
+                    false
+                );
                 remoteState.getMetadata().getIndices().values().forEach(indexMetadata -> {
                     indexMetadataMap.put(indexMetadata.getIndex().getName(), new Tuple<>(true, indexMetadata));
                 });
@@ -223,7 +227,8 @@ private RemoteRestoreResult executeRestore(
                     .build();
             }
 
-            IndexId indexId = new IndexId(indexName, updatedIndexMetadata.getIndexUUID());
+            // This instance of IndexId is not related to Snapshot Restore. Hence, we are using the ctor without pathType.
+            IndexId indexId = new IndexId(indexName, updatedIndexMetadata.getIndexUUID(), IndexId.DEFAULT_SHARD_PATH_TYPE);
 
             if (metadataFromRemoteStore == false) {
                 Map<ShardId, IndexShardRoutingTable> indexShardRoutingTableMap = currentState.routingTable()
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteIndexPath.java b/server/src/main/java/org/opensearch/index/remote/RemoteIndexPath.java
index 89b642b79df86..82d7e81275340 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteIndexPath.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteIndexPath.java
@@ -18,7 +18,9 @@
 import org.opensearch.index.remote.RemoteStoreEnums.DataType;
 import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy.BasePathInput;
 import org.opensearch.index.remote.RemoteStorePathStrategy.PathInput;
+import org.opensearch.indices.RemoteStoreSettings;
 
 import java.io.IOException;
 import java.util.Collections;
@@ -67,6 +69,7 @@ public class RemoteIndexPath implements ToXContentFragment {
     private final Iterable<String> basePath;
     private final PathType pathType;
     private final PathHashAlgorithm pathHashAlgorithm;
+    private final RemoteStoreSettings remoteStoreSettings;
 
     /**
      * This keeps the map of paths that would be present in the content of the index path file. For eg - It is possible
@@ -81,7 +84,8 @@ public RemoteIndexPath(
         Iterable<String> basePath,
         PathType pathType,
         PathHashAlgorithm pathHashAlgorithm,
-        Map<DataCategory, List<DataType>> pathCreationMap
+        Map<DataCategory, List<DataType>> pathCreationMap,
+        RemoteStoreSettings remoteStoreSettings
     ) {
         if (Objects.isNull(pathCreationMap)
             || Objects.isNull(pathType)
@@ -118,6 +122,7 @@ public RemoteIndexPath(
         this.pathType = pathType;
         this.pathHashAlgorithm = pathHashAlgorithm;
         this.pathCreationMap = pathCreationMap;
+        this.remoteStoreSettings = remoteStoreSettings;
     }
 
     @Override
@@ -141,12 +146,17 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
             DataCategory dataCategory = entry.getKey();
             for (DataType type : entry.getValue()) {
                 for (int shardNo = 0; shardNo < shardCount; shardNo++) {
-                    PathInput pathInput = PathInput.builder()
+                    BasePathInput pathInput = PathInput.builder()
                         .basePath(new BlobPath().add(basePath))
                         .indexUUID(indexUUID)
                         .shardId(Integer.toString(shardNo))
                         .dataCategory(dataCategory)
                         .dataType(type)
+                        .fixedPrefix(
+                            dataCategory == TRANSLOG
+                                ? remoteStoreSettings.getTranslogPathFixedPrefix()
+                                : remoteStoreSettings.getSegmentsPathFixedPrefix()
+                        )
                         .build();
                     builder.value(pathType.path(pathInput, pathHashAlgorithm).buildAsString());
                 }
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteIndexPathUploader.java b/server/src/main/java/org/opensearch/index/remote/RemoteIndexPathUploader.java
index d736a82d57a7c..5878dff03acc2 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteIndexPathUploader.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteIndexPathUploader.java
@@ -23,8 +23,9 @@
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.Index;
 import org.opensearch.gateway.remote.IndexMetadataUploadListener;
-import org.opensearch.gateway.remote.RemoteClusterStateService.RemoteStateTransferException;
+import org.opensearch.gateway.remote.RemoteStateTransferException;
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.node.Node;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
 import org.opensearch.repositories.RepositoriesService;
@@ -45,7 +46,7 @@
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
-import static org.opensearch.gateway.remote.RemoteClusterStateService.INDEX_METADATA_UPLOAD_TIMEOUT_SETTING;
+import static org.opensearch.gateway.remote.RemoteGlobalMetadataManager.GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING;
 import static org.opensearch.index.remote.RemoteIndexPath.COMBINED_PATH;
 import static org.opensearch.index.remote.RemoteIndexPath.SEGMENT_PATH;
 import static org.opensearch.index.remote.RemoteIndexPath.TRANSLOG_PATH;
@@ -79,8 +80,9 @@ public class RemoteIndexPathUploader extends IndexMetadataUploadListener {
     private final Settings settings;
     private final boolean isRemoteDataAttributePresent;
     private final boolean isTranslogSegmentRepoSame;
+    private final RemoteStoreSettings remoteStoreSettings;
     private final Supplier<RepositoriesService> repositoriesService;
-    private volatile TimeValue indexMetadataUploadTimeout;
+    private volatile TimeValue metadataUploadTimeout;
 
     private BlobStoreRepository translogRepository;
     private BlobStoreRepository segmentRepository;
@@ -89,7 +91,8 @@ public RemoteIndexPathUploader(
         ThreadPool threadPool,
         Settings settings,
         Supplier<RepositoriesService> repositoriesService,
-        ClusterSettings clusterSettings
+        ClusterSettings clusterSettings,
+        RemoteStoreSettings remoteStoreSettings
     ) {
         super(threadPool, ThreadPool.Names.GENERIC);
         this.settings = Objects.requireNonNull(settings);
@@ -98,8 +101,9 @@ public RemoteIndexPathUploader(
         // If the remote data attributes are not present, then there is no effect of translog and segment being same or different or null.
         isTranslogSegmentRepoSame = isTranslogSegmentRepoSame();
         Objects.requireNonNull(clusterSettings);
-        indexMetadataUploadTimeout = clusterSettings.get(INDEX_METADATA_UPLOAD_TIMEOUT_SETTING);
-        clusterSettings.addSettingsUpdateConsumer(INDEX_METADATA_UPLOAD_TIMEOUT_SETTING, this::setIndexMetadataUploadTimeout);
+        metadataUploadTimeout = clusterSettings.get(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING);
+        clusterSettings.addSettingsUpdateConsumer(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING, this::setMetadataUploadTimeout);
+        this.remoteStoreSettings = remoteStoreSettings;
     }
 
     @Override
@@ -131,7 +135,7 @@ protected void doOnUpload(
             logger.trace(new ParameterizedMessage("Remote index path upload started for {}", indexNames));
 
             try {
-                if (latch.await(indexMetadataUploadTimeout.millis(), TimeUnit.MILLISECONDS) == false) {
+                if (latch.await(metadataUploadTimeout.millis(), TimeUnit.MILLISECONDS) == false) {
                     RemoteStateTransferException ex = new RemoteStateTransferException(
                         String.format(Locale.ROOT, TIMEOUT_EXCEPTION_MSG, indexNames)
                     );
@@ -208,7 +212,8 @@ private void writePathToRemoteStore(
                 basePath,
                 pathType,
                 hashAlgorithm,
-                pathCreationMap
+                pathCreationMap,
+                remoteStoreSettings
             );
             String fileName = generateFileName(indexUUID, idxMD.getVersion(), remoteIndexPath.getVersion());
             REMOTE_INDEX_PATH_FORMAT.writeAsyncWithUrgentPriority(remoteIndexPath, blobContainer, fileName, actionListener);
@@ -289,8 +294,8 @@ private boolean requiresPathUpload(IndexMetadata indexMetadata, IndexMetadata pr
         return pathType == PathType.HASHED_PREFIX && (Objects.isNull(prevPathType) || prevPathType != PathType.HASHED_PREFIX);
     }
 
-    private void setIndexMetadataUploadTimeout(TimeValue newIndexMetadataUploadTimeout) {
-        this.indexMetadataUploadTimeout = newIndexMetadataUploadTimeout;
+    private void setMetadataUploadTimeout(TimeValue newIndexMetadataUploadTimeout) {
+        this.metadataUploadTimeout = newIndexMetadataUploadTimeout;
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteSegmentTransferTracker.java b/server/src/main/java/org/opensearch/index/remote/RemoteSegmentTransferTracker.java
index f1843ea3eef38..a29bd1d840b43 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteSegmentTransferTracker.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteSegmentTransferTracker.java
@@ -65,7 +65,7 @@ public class RemoteSegmentTransferTracker extends RemoteTransferTracker {
     private volatile long remoteRefreshSeqNo;
 
     /**
-     * The refresh time of most recent remote refresh.
+     * The refresh time of the most recent remote refresh.
      */
     private volatile long remoteRefreshTimeMs;
 
@@ -76,7 +76,7 @@ public class RemoteSegmentTransferTracker extends RemoteTransferTracker {
     private volatile long remoteRefreshStartTimeMs = -1;
 
     /**
-     * The refresh time(clock) of most recent remote refresh.
+     * The refresh time(clock) of the most recent remote refresh.
      */
     private volatile long remoteRefreshClockTimeMs;
 
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStoreEnums.java b/server/src/main/java/org/opensearch/index/remote/RemoteStoreEnums.java
index c1ac74724e405..5fbcfb1d2f531 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteStoreEnums.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteStoreEnums.java
@@ -13,7 +13,8 @@
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.hash.FNV1a;
-import org.opensearch.index.remote.RemoteStorePathStrategy.PathInput;
+import org.opensearch.core.common.Strings;
+import org.opensearch.index.remote.RemoteStorePathStrategy.BasePathInput;
 
 import java.util.HashMap;
 import java.util.Locale;
@@ -92,14 +93,10 @@ public String getName() {
     public enum PathType {
         FIXED(0) {
             @Override
-            public BlobPath generatePath(PathInput pathInput, PathHashAlgorithm hashAlgorithm) {
+            public BlobPath generatePath(BasePathInput pathInput, PathHashAlgorithm hashAlgorithm) {
                 assert Objects.isNull(hashAlgorithm) : "hashAlgorithm is expected to be null with fixed remote store path type";
                 // Hash algorithm is not used in FIXED path type
-                return pathInput.basePath()
-                    .add(pathInput.indexUUID())
-                    .add(pathInput.shardId())
-                    .add(pathInput.dataCategory().getName())
-                    .add(pathInput.dataType().getName());
+                return pathInput.basePath().add(pathInput.fixedSubPath());
             }
 
             @Override
@@ -109,15 +106,13 @@ boolean requiresHashAlgorithm() {
         },
         HASHED_PREFIX(1) {
             @Override
-            public BlobPath generatePath(PathInput pathInput, PathHashAlgorithm hashAlgorithm) {
+            public BlobPath generatePath(BasePathInput pathInput, PathHashAlgorithm hashAlgorithm) {
                 assert Objects.nonNull(hashAlgorithm) : "hashAlgorithm is expected to be non-null";
+                String fixedPrefix = pathInput.fixedPrefix();
                 return BlobPath.cleanPath()
-                    .add(hashAlgorithm.hash(pathInput))
+                    .add(Strings.isNullOrEmpty(fixedPrefix) ? hashAlgorithm.hash(pathInput) : fixedPrefix + hashAlgorithm.hash(pathInput))
                     .add(pathInput.basePath())
-                    .add(pathInput.indexUUID())
-                    .add(pathInput.shardId())
-                    .add(pathInput.dataCategory().getName())
-                    .add(pathInput.dataType().getName());
+                    .add(pathInput.fixedSubPath());
             }
 
             @Override
@@ -127,14 +122,12 @@ boolean requiresHashAlgorithm() {
         },
         HASHED_INFIX(2) {
             @Override
-            public BlobPath generatePath(PathInput pathInput, PathHashAlgorithm hashAlgorithm) {
+            public BlobPath generatePath(BasePathInput pathInput, PathHashAlgorithm hashAlgorithm) {
                 assert Objects.nonNull(hashAlgorithm) : "hashAlgorithm is expected to be non-null";
+                String fixedPrefix = pathInput.fixedPrefix();
                 return pathInput.basePath()
-                    .add(hashAlgorithm.hash(pathInput))
-                    .add(pathInput.indexUUID())
-                    .add(pathInput.shardId())
-                    .add(pathInput.dataCategory().getName())
-                    .add(pathInput.dataType().getName());
+                    .add(Strings.isNullOrEmpty(fixedPrefix) ? hashAlgorithm.hash(pathInput) : fixedPrefix + hashAlgorithm.hash(pathInput))
+                    .add(pathInput.fixedSubPath());
             }
 
             @Override
@@ -185,18 +178,18 @@ public static PathType fromCode(int code) {
          * @param hashAlgorithm hashing algorithm.
          * @return the blob path for the path input.
          */
-        public BlobPath path(PathInput pathInput, PathHashAlgorithm hashAlgorithm) {
-            DataCategory dataCategory = pathInput.dataCategory();
-            DataType dataType = pathInput.dataType();
-            assert dataCategory.isSupportedDataType(dataType) : "category:"
-                + dataCategory
-                + " type:"
-                + dataType
-                + " are not supported together";
+        public BlobPath path(BasePathInput pathInput, PathHashAlgorithm hashAlgorithm) {
+            pathInput.assertIsValid();
+            return generatePath(pathInput, hashAlgorithm);
+        }
+
+        // Added for BWC
+        public BlobPath path(RemoteStorePathStrategy.PathInput pathInput, PathHashAlgorithm hashAlgorithm) {
+            pathInput.assertIsValid();
             return generatePath(pathInput, hashAlgorithm);
         }
 
-        protected abstract BlobPath generatePath(PathInput pathInput, PathHashAlgorithm hashAlgorithm);
+        protected abstract BlobPath generatePath(BasePathInput pathInput, PathHashAlgorithm hashAlgorithm);
 
         abstract boolean requiresHashAlgorithm();
 
@@ -226,10 +219,12 @@ public enum PathHashAlgorithm {
 
         FNV_1A_BASE64(0) {
             @Override
-            String hash(PathInput pathInput) {
-                String input = pathInput.indexUUID() + pathInput.shardId() + pathInput.dataCategory().getName() + pathInput.dataType()
-                    .getName();
-                long hash = FNV1a.hash64(input);
+            String hash(BasePathInput pathInput) {
+                StringBuilder input = new StringBuilder();
+                for (String path : pathInput.hashPath().toArray()) {
+                    input.append(path);
+                }
+                long hash = FNV1a.hash64(input.toString());
                 return longToUrlBase64(hash);
             }
         },
@@ -239,10 +234,12 @@ String hash(PathInput pathInput) {
          */
         FNV_1A_COMPOSITE_1(1) {
             @Override
-            String hash(PathInput pathInput) {
-                String input = pathInput.indexUUID() + pathInput.shardId() + pathInput.dataCategory().getName() + pathInput.dataType()
-                    .getName();
-                long hash = FNV1a.hash64(input);
+            String hash(BasePathInput pathInput) {
+                StringBuilder input = new StringBuilder();
+                for (String path : pathInput.hashPath().toArray()) {
+                    input.append(path);
+                }
+                long hash = FNV1a.hash64(input.toString());
                 return longToCompositeBase64AndBinaryEncoding(hash, 20);
             }
         };
@@ -281,7 +278,7 @@ public static PathHashAlgorithm fromCode(int code) {
             return CODE_TO_ENUM.get(code);
         }
 
-        abstract String hash(PathInput pathInput);
+        abstract String hash(BasePathInput pathInput);
 
         public static PathHashAlgorithm parseString(String pathHashAlgorithm) {
             try {
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategy.java b/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategy.java
index c58f6c3faac84..6506387e26367 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategy.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteStorePathStrategy.java
@@ -17,6 +17,7 @@
 import org.opensearch.index.remote.RemoteStoreEnums.DataType;
 import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
 
 import java.util.Objects;
 
@@ -67,29 +68,39 @@ public String toString() {
         return "RemoteStorePathStrategy{" + "type=" + type + ", hashAlgorithm=" + hashAlgorithm + '}';
     }
 
+    public BlobPath generatePath(BasePathInput pathInput) {
+        return type.path(pathInput, hashAlgorithm);
+    }
+
+    // Added for BWC
     public BlobPath generatePath(PathInput pathInput) {
         return type.path(pathInput, hashAlgorithm);
     }
 
     /**
-     * Wrapper class for the input required to generate path for remote store uploads.
+     * Wrapper class for the path input required to generate path for remote store uploads. This input is composed of
+     * basePath and indexUUID.
+     *
      * @opensearch.internal
      */
     @PublicApi(since = "2.14.0")
     @ExperimentalApi
-    public static class PathInput {
+    public static class BasePathInput {
         private final BlobPath basePath;
         private final String indexUUID;
-        private final String shardId;
-        private final DataCategory dataCategory;
-        private final DataType dataType;
+        private final String fixedPrefix;
 
-        public PathInput(BlobPath basePath, String indexUUID, String shardId, DataCategory dataCategory, DataType dataType) {
-            this.basePath = Objects.requireNonNull(basePath);
-            this.indexUUID = Objects.requireNonNull(indexUUID);
-            this.shardId = Objects.requireNonNull(shardId);
-            this.dataCategory = Objects.requireNonNull(dataCategory);
-            this.dataType = Objects.requireNonNull(dataType);
+        // Adding for BWC
+        public BasePathInput(BlobPath basePath, String indexUUID) {
+            this.basePath = basePath;
+            this.indexUUID = indexUUID;
+            this.fixedPrefix = null;
+        }
+
+        public BasePathInput(Builder<?> builder) {
+            this.basePath = Objects.requireNonNull(builder.basePath);
+            this.indexUUID = Objects.requireNonNull(builder.indexUUID);
+            this.fixedPrefix = Objects.isNull(builder.fixedPrefix) ? "" : builder.fixedPrefix;
         }
 
         BlobPath basePath() {
@@ -100,6 +111,159 @@ String indexUUID() {
             return indexUUID;
         }
 
+        String fixedPrefix() {
+            return fixedPrefix;
+        }
+
+        BlobPath fixedSubPath() {
+            return BlobPath.cleanPath().add(indexUUID);
+        }
+
+        BlobPath hashPath() {
+            return fixedSubPath();
+        }
+
+        /**
+         * Returns a new builder for {@link BasePathInput}.
+         */
+        public static Builder<?> builder() {
+            return new Builder<>();
+        }
+
+        public void assertIsValid() {
+            // Input is always valid here.
+        }
+
+        /**
+         * Builder for {@link BasePathInput}.
+         *
+         * @opensearch.internal
+         */
+        @PublicApi(since = "2.14.0")
+        @ExperimentalApi
+        public static class Builder<T extends Builder<T>> {
+            private BlobPath basePath;
+            private String indexUUID;
+            private String fixedPrefix;
+
+            public T basePath(BlobPath basePath) {
+                this.basePath = basePath;
+                return self();
+            }
+
+            public T indexUUID(String indexUUID) {
+                this.indexUUID = indexUUID;
+                return self();
+            }
+
+            public T fixedPrefix(String fixedPrefix) {
+                this.fixedPrefix = fixedPrefix;
+                return self();
+            }
+
+            protected T self() {
+                return (T) this;
+            }
+
+            public BasePathInput build() {
+                return new BasePathInput(this);
+            }
+        }
+    }
+
+    /**
+     * A subclass of {@link PathInput} that represents the input required to generate a path
+     * for a shard in a snapshot. It includes the base path, index UUID, and shard ID.
+     *
+     * @opensearch.internal
+     */
+    public static class SnapshotShardPathInput extends BasePathInput {
+        private final String shardId;
+
+        public SnapshotShardPathInput(SnapshotShardPathInput.Builder builder) {
+            super(builder);
+            this.shardId = Objects.requireNonNull(builder.shardId);
+        }
+
+        @Override
+        BlobPath fixedSubPath() {
+            return BlobPath.cleanPath().add(BlobStoreRepository.INDICES_DIR).add(super.fixedSubPath()).add(shardId);
+        }
+
+        @Override
+        BlobPath hashPath() {
+            return BlobPath.cleanPath().add(shardId).add(indexUUID());
+        }
+
+        public String shardId() {
+            return shardId;
+        }
+
+        /**
+         * Returns a new builder for {@link SnapshotShardPathInput}.
+         */
+        public static SnapshotShardPathInput.Builder builder() {
+            return new SnapshotShardPathInput.Builder();
+        }
+
+        /**
+         * Builder for {@link SnapshotShardPathInput}.
+         *
+         * @opensearch.internal
+         */
+        public static class Builder extends BasePathInput.Builder<SnapshotShardPathInput.Builder> {
+            private String shardId;
+
+            public SnapshotShardPathInput.Builder shardId(String shardId) {
+                this.shardId = shardId;
+                return this;
+            }
+
+            @Override
+            protected SnapshotShardPathInput.Builder self() {
+                return this;
+            }
+
+            public SnapshotShardPathInput build() {
+                return new SnapshotShardPathInput(this);
+            }
+        }
+    }
+
+    /**
+     * Wrapper class for the data aware path input required to generate path for remote store uploads. This input is
+     * composed of the parent inputs, shard id, data category and data type.
+     *
+     * @opensearch.internal
+     */
+    @PublicApi(since = "2.14.0")
+    @ExperimentalApi
+    public static class PathInput extends BasePathInput {
+        private final String shardId;
+        private final DataCategory dataCategory;
+        private final DataType dataType;
+
+        // Adding for BWC
+        public PathInput(BlobPath basePath, String indexUUID, String shardId, DataCategory dataCategory, DataType dataType) {
+            super(basePath, indexUUID);
+            this.shardId = shardId;
+            this.dataCategory = dataCategory;
+            this.dataType = dataType;
+        }
+
+        public PathInput(Builder builder) {
+            super(builder);
+            this.shardId = Objects.requireNonNull(builder.shardId);
+            this.dataCategory = Objects.requireNonNull(builder.dataCategory);
+            this.dataType = Objects.requireNonNull(builder.dataType);
+            assert dataCategory.isSupportedDataType(dataType) : "category:"
+                + dataCategory
+                + " type:"
+                + dataType
+                + " are not supported together";
+
+        }
+
         String shardId() {
             return shardId;
         }
@@ -112,6 +276,11 @@ DataType dataType() {
             return dataType;
         }
 
+        @Override
+        BlobPath fixedSubPath() {
+            return super.fixedSubPath().add(shardId).add(dataCategory.getName()).add(dataType.getName());
+        }
+
         /**
          * Returns a new builder for {@link PathInput}.
          */
@@ -126,20 +295,18 @@ public static Builder builder() {
          */
         @PublicApi(since = "2.14.0")
         @ExperimentalApi
-        public static class Builder {
-            private BlobPath basePath;
-            private String indexUUID;
+        public static class Builder extends BasePathInput.Builder<Builder> {
             private String shardId;
             private DataCategory dataCategory;
             private DataType dataType;
 
             public Builder basePath(BlobPath basePath) {
-                this.basePath = basePath;
+                super.basePath = basePath;
                 return this;
             }
 
             public Builder indexUUID(String indexUUID) {
-                this.indexUUID = indexUUID;
+                super.indexUUID = indexUUID;
                 return this;
             }
 
@@ -158,8 +325,13 @@ public Builder dataType(DataType dataType) {
                 return this;
             }
 
+            @Override
+            protected Builder self() {
+                return this;
+            }
+
             public PathInput build() {
-                return new PathInput(basePath, indexUUID, shardId, dataCategory, dataType);
+                return new PathInput(this);
             }
         }
     }
diff --git a/server/src/main/java/org/opensearch/index/remote/RemoteStoreUtils.java b/server/src/main/java/org/opensearch/index/remote/RemoteStoreUtils.java
index 9a9de6c819424..edcfe17d31fb8 100644
--- a/server/src/main/java/org/opensearch/index/remote/RemoteStoreUtils.java
+++ b/server/src/main/java/org/opensearch/index/remote/RemoteStoreUtils.java
@@ -11,25 +11,40 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.Version;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingTable;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
+import org.opensearch.node.remotestore.RemoteStoreNodeService;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
 
 import java.nio.ByteBuffer;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Base64;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
+import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdater.indexHasRemoteStoreSettings;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_HASH_ALGORITHM_SETTING;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING;
 import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_METADATA;
@@ -214,13 +229,13 @@ public static Map<String, String> determineRemoteStoreCustomMetadataDuringMigrat
         // does not support custom metadata.
         // https://github.com/opensearch-project/OpenSearch/issues/13745
         boolean blobStoreMetadataEnabled = false;
-        boolean translogMetadata = Version.CURRENT.compareTo(minNodeVersion) <= 0
+        boolean translogMetadata = Version.V_2_15_0.compareTo(minNodeVersion) <= 0
             && CLUSTER_REMOTE_STORE_TRANSLOG_METADATA.get(clusterSettings)
             && blobStoreMetadataEnabled;
 
         remoteCustomData.put(IndexMetadata.TRANSLOG_METADATA_KEY, Boolean.toString(translogMetadata));
 
-        RemoteStoreEnums.PathType pathType = Version.CURRENT.compareTo(minNodeVersion) <= 0
+        RemoteStoreEnums.PathType pathType = Version.V_2_15_0.compareTo(minNodeVersion) <= 0
             ? CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING.get(clusterSettings)
             : RemoteStoreEnums.PathType.FIXED;
         RemoteStoreEnums.PathHashAlgorithm pathHashAlgorithm = pathType == RemoteStoreEnums.PathType.FIXED
@@ -250,4 +265,318 @@ public static Map<String, String> getRemoteStoreRepoName(DiscoveryNodes discover
             .findFirst();
         return remoteNode.map(RemoteStoreNodeAttribute::getDataRepoNames).orElseGet(HashMap::new);
     }
+
+    /**
+     * Invoked after a cluster settings update.
+     * Checks if the applied cluster settings has switched the cluster to STRICT mode.
+     * If so, checks and applies appropriate index settings depending on the current set
+     * of node types in the cluster
+     * This has been intentionally done after the cluster settings update
+     * flow. That way we are not interfering with the usual settings update
+     * and the cluster state mutation that comes along with it
+     *
+     * @param isCompatibilityModeChanging flag passed from cluster settings update call to denote if a compatibility mode change has been done
+     * @param request request payload passed from cluster settings update
+     * @param currentState cluster state generated after changing cluster settings were applied
+     * @param logger Logger reference
+     * @return Mutated cluster state with remote store index settings applied, no-op if the cluster is not switching to `STRICT` compatibility mode
+     */
+    public static ClusterState checkAndFinalizeRemoteStoreMigration(
+        boolean isCompatibilityModeChanging,
+        ClusterUpdateSettingsRequest request,
+        ClusterState currentState,
+        Logger logger
+    ) {
+        if (isCompatibilityModeChanging && isSwitchToStrictCompatibilityMode(request)) {
+            return finalizeMigration(currentState, logger);
+        }
+        return currentState;
+    }
+
+    /**
+     * Finalizes the docrep to remote-store migration process by applying remote store based index settings
+     * on indices that are missing them. No-Op if all indices already have the settings applied through
+     * IndexMetadataUpdater
+     *
+     * @param incomingState mutated cluster state after cluster settings were applied
+     * @return new cluster state with index settings updated
+     */
+    public static ClusterState finalizeMigration(ClusterState incomingState, Logger logger) {
+        Map<String, DiscoveryNode> discoveryNodeMap = incomingState.nodes().getNodes();
+        if (discoveryNodeMap.isEmpty() == false) {
+            // At this point, we have already validated that all nodes in the cluster are of uniform type.
+            // Either all of them are remote store enabled, or all of them are docrep enabled
+            boolean remoteStoreEnabledNodePresent = discoveryNodeMap.values().stream().findFirst().get().isRemoteStoreNode();
+            if (remoteStoreEnabledNodePresent == true) {
+                List<IndexMetadata> indicesWithoutRemoteStoreSettings = getIndicesWithoutRemoteStoreSettings(incomingState, logger);
+                if (indicesWithoutRemoteStoreSettings.isEmpty() == true) {
+                    logger.info("All indices in the cluster has remote store based index settings");
+                } else {
+                    Metadata mutatedMetadata = applyRemoteStoreSettings(incomingState, indicesWithoutRemoteStoreSettings, logger);
+                    return ClusterState.builder(incomingState).metadata(mutatedMetadata).build();
+                }
+            } else {
+                logger.debug("All nodes in the cluster are not remote nodes. Skipping.");
+            }
+        }
+        return incomingState;
+    }
+
+    /**
+     * Filters out indices which does not have remote store based
+     * index settings applied even after all shard copies have
+     * migrated to remote store enabled nodes
+     */
+    private static List<IndexMetadata> getIndicesWithoutRemoteStoreSettings(ClusterState clusterState, Logger logger) {
+        Collection<IndexMetadata> allIndicesMetadata = clusterState.metadata().indices().values();
+        if (allIndicesMetadata.isEmpty() == false) {
+            List<IndexMetadata> indicesWithoutRemoteSettings = allIndicesMetadata.stream()
+                .filter(idxMd -> indexHasRemoteStoreSettings(idxMd.getSettings()) == false)
+                .collect(Collectors.toList());
+            logger.debug(
+                "Attempting to switch to strict mode. Count of indices without remote store settings {}",
+                indicesWithoutRemoteSettings.size()
+            );
+            return indicesWithoutRemoteSettings;
+        }
+        return Collections.emptyList();
+    }
+
+    /**
+     * Applies remote store index settings through {@link RemoteMigrationIndexMetadataUpdater}
+     */
+    private static Metadata applyRemoteStoreSettings(
+        ClusterState clusterState,
+        List<IndexMetadata> indicesWithoutRemoteStoreSettings,
+        Logger logger
+    ) {
+        Metadata.Builder metadataBuilder = Metadata.builder(clusterState.getMetadata());
+        RoutingTable currentRoutingTable = clusterState.getRoutingTable();
+        DiscoveryNodes currentDiscoveryNodes = clusterState.getNodes();
+        Settings currentClusterSettings = clusterState.metadata().settings();
+        for (IndexMetadata indexMetadata : indicesWithoutRemoteStoreSettings) {
+            IndexMetadata.Builder indexMetadataBuilder = IndexMetadata.builder(indexMetadata);
+            RemoteMigrationIndexMetadataUpdater indexMetadataUpdater = new RemoteMigrationIndexMetadataUpdater(
+                currentDiscoveryNodes,
+                currentRoutingTable,
+                indexMetadata,
+                currentClusterSettings,
+                logger
+            );
+            indexMetadataUpdater.maybeAddRemoteIndexSettings(indexMetadataBuilder, indexMetadata.getIndex().getName());
+            metadataBuilder.put(indexMetadataBuilder);
+        }
+        return metadataBuilder.build();
+    }
+
+    /**
+     * Checks if the incoming cluster settings payload is attempting to switch
+     * the cluster to `STRICT` compatibility mode
+     * Visible only for tests
+     */
+    public static boolean isSwitchToStrictCompatibilityMode(ClusterUpdateSettingsRequest request) {
+        Settings incomingSettings = Settings.builder().put(request.persistentSettings()).put(request.transientSettings()).build();
+        return RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING.get(
+            incomingSettings
+        ) == RemoteStoreNodeService.CompatibilityMode.STRICT;
+    }
+
+    /**
+     * Determines and returns a set of metadata files that match provided pinned timestamps.
+     *
+     * This method is an overloaded version of getPinnedTimestampLockedFiles and do not use cached entries to find
+     * the metadata file
+     *
+     * @param metadataFiles A list of metadata file names. Expected to be sorted in descending order of timestamp.
+     * @param pinnedTimestampSet A set of timestamps representing pinned points in time.
+     * @param getTimestampFunction A function that extracts the timestamp from a metadata file name.
+     * @param prefixFunction A function that extracts a tuple of prefix information from a metadata file name.
+     * @param ignorePinnedTimestampEnabledSetting A flag to ignore pinned timestamp enabled setting
+     * @return A set of metadata file names that are implicitly locked based on the pinned timestamps.
+     */
+    public static Set<String> getPinnedTimestampLockedFiles(
+        List<String> metadataFiles,
+        Set<Long> pinnedTimestampSet,
+        Function<String, Long> getTimestampFunction,
+        Function<String, Tuple<String, String>> prefixFunction,
+        boolean ignorePinnedTimestampEnabledSetting
+    ) {
+        return getPinnedTimestampLockedFiles(
+            metadataFiles,
+            pinnedTimestampSet,
+            new HashMap<>(),
+            getTimestampFunction,
+            prefixFunction,
+            ignorePinnedTimestampEnabledSetting
+        );
+    }
+
+    /**
+     * Determines and returns a set of metadata files that match provided pinned timestamps. If pinned timestamp
+     * feature is not enabled, this function is a no-op.
+     *
+     * This method identifies metadata files that are considered implicitly locked due to their timestamps
+     * matching or being the closest preceding timestamp to the pinned timestamps. It uses a caching mechanism
+     * to improve performance for previously processed timestamps.
+     *
+     * The method performs the following steps:
+     *           1. Validates input parameters.
+     *           2. Updates the cache (metadataFilePinnedTimestampMap) to remove outdated entries.
+     *           3. Processes cached entries and identifies new timestamps to process.
+     *           4. For new timestamps, iterates through metadata files to find matching or closest preceding files.
+     *           5. Updates the cache with newly processed timestamps and their corresponding metadata files.
+     *
+     * @param metadataFiles A list of metadata file names. Expected to be sorted in descending order of timestamp.
+     * @param pinnedTimestampSet A set of timestamps representing pinned points in time.
+     * @param metadataFilePinnedTimestampMap A map used for caching processed timestamps and their corresponding metadata files.
+     * @param getTimestampFunction A function that extracts the timestamp from a metadata file name.
+     * @param prefixFunction A function that extracts a tuple of prefix information from a metadata file name.
+     * @return A set of metadata file names that are implicitly locked based on the pinned timestamps.
+     *
+     */
+    public static Set<String> getPinnedTimestampLockedFiles(
+        List<String> metadataFiles,
+        Set<Long> pinnedTimestampSet,
+        Map<Long, String> metadataFilePinnedTimestampMap,
+        Function<String, Long> getTimestampFunction,
+        Function<String, Tuple<String, String>> prefixFunction
+    ) {
+        return getPinnedTimestampLockedFiles(
+            metadataFiles,
+            pinnedTimestampSet,
+            metadataFilePinnedTimestampMap,
+            getTimestampFunction,
+            prefixFunction,
+            false
+        );
+    }
+
+    private static Set<String> getPinnedTimestampLockedFiles(
+        List<String> metadataFiles,
+        Set<Long> pinnedTimestampSet,
+        Map<Long, String> metadataFilePinnedTimestampMap,
+        Function<String, Long> getTimestampFunction,
+        Function<String, Tuple<String, String>> prefixFunction,
+        boolean ignorePinnedTimestampEnabledSetting
+    ) {
+        Set<String> implicitLockedFiles = new HashSet<>();
+
+        if (ignorePinnedTimestampEnabledSetting == false && RemoteStoreSettings.isPinnedTimestampsEnabled() == false) {
+            return implicitLockedFiles;
+        }
+
+        if (metadataFiles == null || metadataFiles.isEmpty() || pinnedTimestampSet == null) {
+            return implicitLockedFiles;
+        }
+
+        // Remove entries for timestamps that are no longer pinned
+        metadataFilePinnedTimestampMap.keySet().retainAll(pinnedTimestampSet);
+
+        // Add cached entries and collect new timestamps
+        Set<Long> newPinnedTimestamps = new TreeSet<>(Collections.reverseOrder());
+        for (Long pinnedTimestamp : pinnedTimestampSet) {
+            String cachedFile = metadataFilePinnedTimestampMap.get(pinnedTimestamp);
+            if (cachedFile != null) {
+                implicitLockedFiles.add(cachedFile);
+            } else {
+                newPinnedTimestamps.add(pinnedTimestamp);
+            }
+        }
+
+        if (newPinnedTimestamps.isEmpty()) {
+            return implicitLockedFiles;
+        }
+
+        // Sort metadata files in descending order of timestamp
+        // ToDo: Do we really need this? Files fetched from remote store are already lexicographically sorted.
+        metadataFiles.sort(String::compareTo);
+
+        // If we have metadata files from multiple writers, it can result in picking file generated by stale primary.
+        // To avoid this, we fail fast.
+        RemoteStoreUtils.verifyNoMultipleWriters(metadataFiles, prefixFunction);
+
+        Iterator<Long> timestampIterator = newPinnedTimestamps.iterator();
+        Long currentPinnedTimestamp = timestampIterator.next();
+        long prevMdTimestamp = Long.MAX_VALUE;
+        for (String metadataFileName : metadataFiles) {
+            long currentMdTimestamp = getTimestampFunction.apply(metadataFileName);
+            // We always prefer md file with higher values of prefix like primary term, generation etc.
+            if (currentMdTimestamp > prevMdTimestamp) {
+                continue;
+            }
+            while (currentMdTimestamp <= currentPinnedTimestamp && prevMdTimestamp > currentPinnedTimestamp) {
+                implicitLockedFiles.add(metadataFileName);
+                // Do not cache entry for latest metadata file as the next metadata can also match the same pinned timestamp
+                if (prevMdTimestamp != Long.MAX_VALUE) {
+                    metadataFilePinnedTimestampMap.put(currentPinnedTimestamp, metadataFileName);
+                }
+                if (timestampIterator.hasNext() == false) {
+                    return implicitLockedFiles;
+                }
+                currentPinnedTimestamp = timestampIterator.next();
+            }
+            prevMdTimestamp = currentMdTimestamp;
+        }
+
+        return implicitLockedFiles;
+    }
+
+    /**
+     * Filters out metadata files based on their age and pinned timestamps settings.
+     *
+     * This method filters a list of metadata files, keeping only those that are older
+     * than a certain threshold determined by the last successful fetch of pinned timestamps
+     * and a configured lookback interval.
+     *
+     * @param metadataFiles A list of metadata file names to be filtered.
+     * @param getTimestampFunction A function that extracts a timestamp from a metadata file name.
+     * @param lastSuccessfulFetchOfPinnedTimestamps The timestamp of the last successful fetch of pinned timestamps.
+     * @return A new list containing only the metadata files that meet the age criteria.
+     *         If pinned timestamps are not enabled, returns a copy of the input list.
+     */
+    public static List<String> filterOutMetadataFilesBasedOnAge(
+        List<String> metadataFiles,
+        Function<String, Long> getTimestampFunction,
+        long lastSuccessfulFetchOfPinnedTimestamps
+    ) {
+        if (RemoteStoreSettings.isPinnedTimestampsEnabled() == false) {
+            return new ArrayList<>(metadataFiles);
+        }
+        // We allow now() - loopback interval to be pinned. Also, the actual pinning can take at most loopback interval
+        // This means the pinned timestamp can be available for read after at most (2 * loopback interval)
+        long maximumAllowedTimestamp = lastSuccessfulFetchOfPinnedTimestamps - (2 * RemoteStoreSettings
+            .getPinnedTimestampsLookbackInterval()
+            .getMillis());
+        List<String> metadataFilesWithMinAge = new ArrayList<>();
+        for (String metadataFileName : metadataFiles) {
+            long metadataTimestamp = getTimestampFunction.apply(metadataFileName);
+            if (metadataTimestamp < maximumAllowedTimestamp) {
+                metadataFilesWithMinAge.add(metadataFileName);
+            }
+        }
+        return metadataFilesWithMinAge;
+    }
+
+    /**
+     * Determines if the pinned timestamp state is stale.
+     *
+     * This method checks whether the last successful fetch of pinned timestamps
+     * is considered stale based on the current time and configured intervals.
+     * The state is considered stale if the last successful fetch occurred before
+     * a certain threshold, which is calculated as three times the scheduler interval
+     * plus the lookback interval.
+     *
+     * @return true if the pinned timestamp state is stale, false otherwise.
+     *         Always returns false if pinned timestamps are not enabled.
+     */
+    public static boolean isPinnedTimestampStateStale() {
+        if (RemoteStoreSettings.isPinnedTimestampsEnabled() == false) {
+            return false;
+        }
+        long lastSuccessfulFetchTimestamp = RemoteStorePinnedTimestampService.getPinnedTimestamps().v1();
+        long staleBufferInMillis = (RemoteStoreSettings.getPinnedTimestampsSchedulerInterval().millis() * 3) + RemoteStoreSettings
+            .getPinnedTimestampsLookbackInterval()
+            .millis();
+        return lastSuccessfulFetchTimestamp < (System.currentTimeMillis() - staleBufferInMillis);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/search/QueryParserHelper.java b/server/src/main/java/org/opensearch/index/search/QueryParserHelper.java
index 5e9839385ce20..603e81f6bf113 100644
--- a/server/src/main/java/org/opensearch/index/search/QueryParserHelper.java
+++ b/server/src/main/java/org/opensearch/index/search/QueryParserHelper.java
@@ -38,7 +38,7 @@
 import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.index.query.QueryShardException;
-import org.opensearch.search.SearchModule;
+import org.opensearch.search.SearchService;
 
 import java.util.Collection;
 import java.util.HashMap;
@@ -143,7 +143,10 @@ static Map<String, Float> resolveMappingField(
                 fieldName = fieldName + fieldSuffix;
             }
 
-            MappedFieldType fieldType = context.getMapperService().fieldType(fieldName);
+            MappedFieldType fieldType = context.fieldMapper(fieldName);
+            if (fieldType == null) {
+                fieldType = context.resolveDerivedFieldType(fieldName);
+            }
             if (fieldType == null) {
                 continue;
             }
@@ -177,7 +180,7 @@ static Map<String, Float> resolveMappingField(
     }
 
     static void checkForTooManyFields(int numberOfFields, QueryShardContext context, @Nullable String inputPattern) {
-        Integer limit = SearchModule.INDICES_MAX_CLAUSE_COUNT_SETTING.get(context.getIndexSettings().getSettings());
+        int limit = SearchService.INDICES_MAX_CLAUSE_COUNT_SETTING.get(context.getIndexSettings().getSettings());
         if (numberOfFields > limit) {
             StringBuilder errorMsg = new StringBuilder("field expansion ");
             if (inputPattern != null) {
diff --git a/server/src/main/java/org/opensearch/index/search/stats/SearchStats.java b/server/src/main/java/org/opensearch/index/search/stats/SearchStats.java
index bb61e1afa05f4..d6ea803c9ee13 100644
--- a/server/src/main/java/org/opensearch/index/search/stats/SearchStats.java
+++ b/server/src/main/java/org/opensearch/index/search/stats/SearchStats.java
@@ -110,7 +110,7 @@ public void writeTo(StreamOutput out) throws IOException {
     }
 
     /**
-     * Holds requests stats for different phases.
+     * Holds all requests stats.
      *
      * @opensearch.api
      */
@@ -124,6 +124,7 @@ public Map<String, PhaseStatsLongHolder> getRequestStatsHolder() {
         }
 
         RequestStatsLongHolder() {
+            requestStatsHolder.put(Fields.TOOK, new PhaseStatsLongHolder());
             for (SearchPhaseName searchPhaseName : SearchPhaseName.values()) {
                 requestStatsHolder.put(searchPhaseName.getName(), new PhaseStatsLongHolder());
             }
@@ -512,6 +513,15 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
             if (requestStatsLongHolder != null) {
                 builder.startObject(Fields.REQUEST);
 
+                PhaseStatsLongHolder tookStatsLongHolder = requestStatsLongHolder.requestStatsHolder.get(Fields.TOOK);
+                if (tookStatsLongHolder != null) {
+                    builder.startObject(Fields.TOOK);
+                    builder.humanReadableField(Fields.TIME_IN_MILLIS, Fields.TIME, new TimeValue(tookStatsLongHolder.timeInMillis));
+                    builder.field(Fields.CURRENT, tookStatsLongHolder.current);
+                    builder.field(Fields.TOTAL, tookStatsLongHolder.total);
+                    builder.endObject();
+                }
+
                 for (SearchPhaseName searchPhaseName : SearchPhaseName.values()) {
                     PhaseStatsLongHolder statsLongHolder = requestStatsLongHolder.requestStatsHolder.get(searchPhaseName.getName());
                     if (statsLongHolder == null) {
@@ -545,6 +555,17 @@ public void setSearchRequestStats(SearchRequestStats searchRequestStats) {
             totalStats.requestStatsLongHolder = new RequestStatsLongHolder();
         }
 
+        // Set took stats
+        totalStats.requestStatsLongHolder.requestStatsHolder.put(
+            Fields.TOOK,
+            new PhaseStatsLongHolder(
+                searchRequestStats.getTookCurrent(),
+                searchRequestStats.getTookTotal(),
+                searchRequestStats.getTookMetric()
+            )
+        );
+
+        // Set phase stats
         for (SearchPhaseName searchPhaseName : SearchPhaseName.values()) {
             totalStats.requestStatsLongHolder.requestStatsHolder.put(
                 searchPhaseName.getName(),
@@ -678,6 +699,7 @@ static final class Fields {
         static final String CURRENT = "current";
         static final String TOTAL = "total";
         static final String SEARCH_IDLE_REACTIVATE_COUNT_TOTAL = "search_idle_reactivate_count_total";
+        static final String TOOK = "took";
 
     }
 
diff --git a/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
index c6a1f5f27a875..fedf239871368 100644
--- a/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/GlobalCheckpointSyncAction.java
@@ -44,6 +44,7 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.index.shard.ShardId;
@@ -98,7 +99,7 @@ public GlobalCheckpointSyncAction(
     public void updateGlobalCheckpointForShard(final ShardId shardId) {
         final ThreadContext threadContext = threadPool.getThreadContext();
         try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             execute(new Request(shardId), ActionListener.wrap(r -> {}, e -> {
                 if (ExceptionsHelper.unwrap(e, AlreadyClosedException.class, IndexShardClosedException.class) == null) {
                     logger.info(new ParameterizedMessage("{} global checkpoint sync failed", shardId), e);
diff --git a/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java b/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
index 4e818d02fa0a9..9bffaedcbf482 100644
--- a/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
+++ b/server/src/main/java/org/opensearch/index/seqno/ReplicationTracker.java
@@ -1253,12 +1253,13 @@ public ReplicationCheckpoint getLatestReplicationCheckpoint() {
         return this.latestReplicationCheckpoint;
     }
 
-    private boolean isPrimaryRelocation(String allocationId) {
+    // skip any shard that is a relocating primary or search only replica (not tracked by primary)
+    private boolean shouldSkipReplicationTimer(String allocationId) {
         Optional<ShardRouting> shardRouting = routingTable.shards()
             .stream()
             .filter(routing -> routing.allocationId().getId().equals(allocationId))
             .findAny();
-        return shardRouting.isPresent() && shardRouting.get().primary();
+        return shardRouting.isPresent() && (shardRouting.get().primary() || shardRouting.get().isSearchOnly());
     }
 
     private void createReplicationLagTimers() {
@@ -1270,7 +1271,7 @@ private void createReplicationLagTimers() {
                 // it is possible for a shard to be in-sync but not yet removed from the checkpoints collection after a failover event.
                 if (cps.inSync
                     && replicationGroup.getUnavailableInSyncShards().contains(allocationId) == false
-                    && isPrimaryRelocation(allocationId) == false
+                    && shouldSkipReplicationTimer(allocationId) == false
                     && latestReplicationCheckpoint.isAheadOf(cps.visibleReplicationCheckpoint)
                     && (indexSettings.isSegRepLocalEnabled() == true
                         || isShardOnRemoteEnabledNode.apply(routingTable.getByAllocationId(allocationId).currentNodeId()))) {
@@ -1304,7 +1305,7 @@ public synchronized void startReplicationLagTimers(ReplicationCheckpoint checkpo
                 final CheckpointState cps = e.getValue();
                 if (cps.inSync
                     && replicationGroup.getUnavailableInSyncShards().contains(allocationId) == false
-                    && isPrimaryRelocation(e.getKey()) == false
+                    && shouldSkipReplicationTimer(e.getKey()) == false
                     && latestReplicationCheckpoint.isAheadOf(cps.visibleReplicationCheckpoint)
                     && cps.checkpointTimers.containsKey(latestReplicationCheckpoint)) {
                     cps.checkpointTimers.get(latestReplicationCheckpoint).start();
@@ -1323,13 +1324,27 @@ public synchronized Set<SegmentReplicationShardStats> getSegmentReplicationStats
         if (primaryMode) {
             return this.checkpoints.entrySet()
                 .stream()
-                // filter out this shard's allocation id, any shards that are out of sync or unavailable (shard marked in-sync but has not
-                // been assigned to a node).
+                /* Filter out:
+                - This shard's allocation id
+                - Any shards that are out of sync or unavailable (shard marked in-sync but has not been assigned to a node).
+                - (For remote store enabled clusters) Any shard that is not yet migrated to remote store enabled nodes during migration
+                 */
                 .filter(
                     entry -> entry.getKey().equals(this.shardAllocationId) == false
                         && entry.getValue().inSync
                         && replicationGroup.getUnavailableInSyncShards().contains(entry.getKey()) == false
-                        && isPrimaryRelocation(entry.getKey()) == false
+                        && shouldSkipReplicationTimer(entry.getKey()) == false
+                        /*Check if the current primary shard is migrating to remote and
+                        all the other shard copies of the same index still hasn't completely moved over
+                        to the remote enabled nodes. Ensures that:
+                        - Vanilla segrep is not enabled
+                        - Remote Store settings are not enabled (This would be done after all shard copies migrate to remote enabled nodes)
+                        - Index is assigned to remote node (Primary has been seeded) but the corresponding replication group entry has not yet moved to remote
+                        */
+                        && (indexSettings.isRemoteStoreEnabled()
+                            || indexSettings.isSegRepLocalEnabled()
+                            || (indexSettings.isAssignedOnRemoteNode()
+                                && isShardOnRemoteEnabledNode.apply(routingTable.getByAllocationId(entry.getKey()).currentNodeId())))
                 )
                 .map(entry -> buildShardStats(entry.getKey(), entry.getValue()))
                 .collect(Collectors.toUnmodifiableSet());
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
index 5fa0a1a6459e7..e8ebf11ef0e5c 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseBackgroundSyncAction.java
@@ -48,6 +48,7 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -122,7 +123,7 @@ final void backgroundSync(ShardId shardId, String primaryAllocationId, long prim
         final ThreadContext threadContext = threadPool.getThreadContext();
         try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
             // we have to execute under the system context so that if security is enabled the sync is authorized
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             final Request request = new Request(shardId, retentionLeases);
             final ReplicationTask task = (ReplicationTask) taskManager.register("transport", "retention_lease_background_sync", request);
             transportService.sendChildRequest(
diff --git a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
index ca3c7e1d49700..9e8437ca78879 100644
--- a/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
+++ b/server/src/main/java/org/opensearch/index/seqno/RetentionLeaseSyncAction.java
@@ -50,6 +50,7 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -137,7 +138,7 @@ final void sync(
         final ThreadContext threadContext = threadPool.getThreadContext();
         try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
             // we have to execute under the system context so that if security is enabled the sync is authorized
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             final Request request = new Request(shardId, retentionLeases);
             final ReplicationTask task = (ReplicationTask) taskManager.register("transport", "retention_lease_sync", request);
             transportService.sendChildRequest(
diff --git a/server/src/main/java/org/opensearch/index/shard/IndexShard.java b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
index 96e9473663385..0ea738a3b9900 100644
--- a/server/src/main/java/org/opensearch/index/shard/IndexShard.java
+++ b/server/src/main/java/org/opensearch/index/shard/IndexShard.java
@@ -525,7 +525,6 @@ public boolean shouldSeedRemoteStore() {
     public Function<String, Boolean> isShardOnRemoteEnabledNode = nodeId -> {
         DiscoveryNode node = discoveryNodes.get(nodeId);
         if (node != null) {
-            logger.trace("Node {} has remote_enabled as {}", nodeId, node.isRemoteStoreNode());
             return node.isRemoteStoreNode();
         }
         return false;
@@ -2156,7 +2155,7 @@ public void waitForRemoteStoreSync(Runnable onProgress) throws IOException {
                         segmentUploadeCount = directory.getSegmentsUploadedToRemoteStore().size();
                     }
                     try {
-                        Thread.sleep(TimeValue.timeValueSeconds(30).seconds());
+                        Thread.sleep(TimeValue.timeValueSeconds(30).millis());
                     } catch (InterruptedException ie) {
                         throw new OpenSearchException("Interrupted waiting for completion of [{}]", ie);
                     }
@@ -2900,7 +2899,14 @@ public void restoreFromSnapshotAndRemoteStore(
             assert recoveryState.getRecoverySource().getType() == RecoverySource.Type.SNAPSHOT : "invalid recovery type: "
                 + recoveryState.getRecoverySource();
             StoreRecovery storeRecovery = new StoreRecovery(shardId, logger);
-            storeRecovery.recoverFromSnapshotAndRemoteStore(this, repository, repositoriesService, listener, threadPool);
+            storeRecovery.recoverFromSnapshotAndRemoteStore(
+                this,
+                repository,
+                repositoriesService,
+                listener,
+                remoteStoreSettings.getSegmentsPathFixedPrefix(),
+                threadPool
+            );
         } catch (Exception e) {
             listener.onFailure(e);
         }
@@ -5131,10 +5137,23 @@ public void syncSegmentsFromGivenRemoteSegmentStore(
         }
         Map<String, RemoteSegmentStoreDirectory.UploadedSegmentMetadata> uploadedSegments = sourceRemoteDirectory
             .getSegmentsUploadedToRemoteStore();
-        final Directory storeDirectory = store.directory();
         store.incRef();
-
         try {
+            final Directory storeDirectory;
+            if (recoveryState.getStage() == RecoveryState.Stage.INDEX) {
+                storeDirectory = new StoreRecovery.StatsDirectoryWrapper(store.directory(), recoveryState.getIndex());
+                for (String file : uploadedSegments.keySet()) {
+                    long checksum = Long.parseLong(uploadedSegments.get(file).getChecksum());
+                    if (overrideLocal || localDirectoryContains(storeDirectory, file, checksum) == false) {
+                        recoveryState.getIndex().addFileDetail(file, uploadedSegments.get(file).getLength(), false);
+                    } else {
+                        recoveryState.getIndex().addFileDetail(file, uploadedSegments.get(file).getLength(), true);
+                    }
+                }
+            } else {
+                storeDirectory = store.directory();
+            }
+
             String segmentsNFile = copySegmentFiles(
                 storeDirectory,
                 sourceRemoteDirectory,
diff --git a/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java b/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
index 243af4ec248c3..d68798f063782 100644
--- a/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
+++ b/server/src/main/java/org/opensearch/index/shard/RemoteStoreRefreshListener.java
@@ -30,6 +30,7 @@
 import org.opensearch.index.engine.InternalEngine;
 import org.opensearch.index.remote.RemoteSegmentTransferTracker;
 import org.opensearch.index.seqno.SequenceNumbers;
+import org.opensearch.index.store.CompositeDirectory;
 import org.opensearch.index.store.RemoteSegmentStoreDirectory;
 import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadata;
 import org.opensearch.index.translog.Translog;
@@ -170,6 +171,13 @@ protected boolean performAfterRefreshWithPermit(boolean didRefresh) {
      * @return true if sync is needed
      */
     private boolean shouldSync(boolean didRefresh, boolean skipPrimaryTermCheck) {
+        // Ignore syncing segments if the underlying shard is closed
+        // This also makes sure that retries are not scheduled for shards
+        // with failed syncSegments invocation after they are closed
+        if (shardClosed()) {
+            logger.info("Shard is already closed. Not attempting sync to remote store");
+            return false;
+        }
         boolean shouldSync = didRefresh // If the readers change, didRefresh is always true.
             // The third condition exists for uploading the zero state segments where the refresh has not changed the reader
             // reference, but it is important to upload the zero state segments so that the restore does not break.
@@ -432,6 +440,7 @@ private void uploadNewSegments(
         logger.debug("Effective new segments files to upload {}", filteredFiles);
         ActionListener<Collection<Void>> mappedListener = ActionListener.map(listener, resp -> null);
         GroupedActionListener<Void> batchUploadListener = new GroupedActionListener<>(mappedListener, filteredFiles.size());
+        Directory directory = ((FilterDirectory) (((FilterDirectory) storeDirectory).getDelegate())).getDelegate();
 
         for (String src : filteredFiles) {
             // Initializing listener here to ensure that the stats increment operations are thread-safe
@@ -439,6 +448,9 @@ private void uploadNewSegments(
             ActionListener<Void> aggregatedListener = ActionListener.wrap(resp -> {
                 statsListener.onSuccess(src);
                 batchUploadListener.onResponse(resp);
+                if (directory instanceof CompositeDirectory) {
+                    ((CompositeDirectory) directory).afterSyncToRemote(src);
+                }
             }, ex -> {
                 logger.warn(() -> new ParameterizedMessage("Exception: [{}] while uploading segment files", ex), ex);
                 if (ex instanceof CorruptIndexException) {
@@ -452,8 +464,8 @@ private void uploadNewSegments(
         }
     }
 
-    private boolean isLowPriorityUpload() {
-        return isLocalOrSnapshotRecovery();
+    boolean isLowPriorityUpload() {
+        return isLocalOrSnapshotRecoveryOrSeeding();
     }
 
     /**
@@ -543,7 +555,7 @@ private void initializeRemoteDirectoryOnTermUpdate() throws IOException {
      * @return true iff the shard is a started with primary mode true or it is local or snapshot recovery.
      */
     private boolean isReadyForUpload() {
-        boolean isReady = indexShard.isStartedPrimary() || isLocalOrSnapshotRecovery() || indexShard.shouldSeedRemoteStore();
+        boolean isReady = indexShard.isStartedPrimary() || isLocalOrSnapshotRecoveryOrSeeding();
 
         if (isReady == false) {
             StringBuilder sb = new StringBuilder("Skipped syncing segments with");
@@ -565,14 +577,15 @@ private boolean isReadyForUpload() {
         return isReady;
     }
 
-    private boolean isLocalOrSnapshotRecovery() {
+    boolean isLocalOrSnapshotRecoveryOrSeeding() {
         // In this case when the primary mode is false, we need to upload segments to Remote Store
-        // This is required in case of snapshots/shrink/ split/clone where we need to durable persist
+        // This is required in case of remote migration seeding/snapshots/shrink/ split/clone where we need to durable persist
         // all segments to remote before completing the recovery to ensure durability.
         return (indexShard.state() == IndexShardState.RECOVERING && indexShard.shardRouting.primary())
             && indexShard.recoveryState() != null
             && (indexShard.recoveryState().getRecoverySource().getType() == RecoverySource.Type.LOCAL_SHARDS
-                || indexShard.recoveryState().getRecoverySource().getType() == RecoverySource.Type.SNAPSHOT);
+                || indexShard.recoveryState().getRecoverySource().getType() == RecoverySource.Type.SNAPSHOT
+                || indexShard.shouldSeedRemoteStore());
     }
 
     /**
@@ -608,6 +621,15 @@ public void onFailure(String file) {
         };
     }
 
+    /**
+     * Checks if the underlying IndexShard instance is closed
+     *
+     * @return true if it is closed, false otherwise
+     */
+    private boolean shardClosed() {
+        return indexShard.state() == IndexShardState.CLOSED;
+    }
+
     @Override
     protected Logger getLogger() {
         return logger;
diff --git a/server/src/main/java/org/opensearch/index/shard/ReplicationGroup.java b/server/src/main/java/org/opensearch/index/shard/ReplicationGroup.java
index f585267f21832..ccfaf50da1c6b 100644
--- a/server/src/main/java/org/opensearch/index/shard/ReplicationGroup.java
+++ b/server/src/main/java/org/opensearch/index/shard/ReplicationGroup.java
@@ -72,7 +72,8 @@ public ReplicationGroup(
         this.replicationTargets = new ArrayList<>();
         this.skippedShards = new ArrayList<>();
         for (final ShardRouting shard : routingTable) {
-            if (shard.unassigned()) {
+            // search only replicas never receive any replicated operations
+            if (shard.unassigned() || shard.isSearchOnly()) {
                 assert shard.primary() == false : "primary shard should not be unassigned in a replication group: " + shard;
                 skippedShards.add(shard);
             } else {
diff --git a/server/src/main/java/org/opensearch/index/shard/SearchOperationListener.java b/server/src/main/java/org/opensearch/index/shard/SearchOperationListener.java
index 94079db468f9c..5e63262df0d70 100644
--- a/server/src/main/java/org/opensearch/index/shard/SearchOperationListener.java
+++ b/server/src/main/java/org/opensearch/index/shard/SearchOperationListener.java
@@ -71,6 +71,33 @@ default void onFailedQueryPhase(SearchContext searchContext) {}
      */
     default void onQueryPhase(SearchContext searchContext, long tookInNanos) {}
 
+    /**
+     * Executed before the slice execution in
+     * {@link org.opensearch.search.internal.ContextIndexSearcher#search(List, org.apache.lucene.search.Weight, org.apache.lucene.search.Collector)}.
+     * This will be called once per slice in concurrent search and only once in non-concurrent search.
+     * @param searchContext the current search context
+     */
+    default void onPreSliceExecution(SearchContext searchContext) {}
+
+    /**
+     * Executed if the slice execution in
+     * {@link org.opensearch.search.internal.ContextIndexSearcher#search(List, org.apache.lucene.search.Weight, org.apache.lucene.search.Collector)} failed.
+     * This will be called once per slice in concurrent search and only once in non-concurrent search.
+     * @param searchContext the current search context
+     */
+    default void onFailedSliceExecution(SearchContext searchContext) {}
+
+    /**
+     * Executed after the slice execution in
+     * {@link org.opensearch.search.internal.ContextIndexSearcher#search(List, org.apache.lucene.search.Weight, org.apache.lucene.search.Collector)} successfully finished.
+     * This will be called once per slice in concurrent search and only once in non-concurrent search.
+     * Note: this is not invoked if the slice execution failed.*
+     * @param searchContext the current search context
+     *
+     * @see #onFailedSliceExecution(org.opensearch.search.internal.SearchContext)
+     */
+    default void onSliceExecution(SearchContext searchContext) {}
+
     /**
      * Executed before the fetch phase is executed
      * @param searchContext the current search context
@@ -195,6 +222,39 @@ public void onQueryPhase(SearchContext searchContext, long tookInNanos) {
             }
         }
 
+        @Override
+        public void onPreSliceExecution(SearchContext searchContext) {
+            for (SearchOperationListener listener : listeners) {
+                try {
+                    listener.onPreSliceExecution(searchContext);
+                } catch (Exception e) {
+                    logger.warn(() -> new ParameterizedMessage("onPreSliceExecution listener [{}] failed", listener), e);
+                }
+            }
+        }
+
+        @Override
+        public void onFailedSliceExecution(SearchContext searchContext) {
+            for (SearchOperationListener listener : listeners) {
+                try {
+                    listener.onFailedSliceExecution(searchContext);
+                } catch (Exception e) {
+                    logger.warn(() -> new ParameterizedMessage("onFailedSliceExecution listener [{}] failed", listener), e);
+                }
+            }
+        }
+
+        @Override
+        public void onSliceExecution(SearchContext searchContext) {
+            for (SearchOperationListener listener : listeners) {
+                try {
+                    listener.onSliceExecution(searchContext);
+                } catch (Exception e) {
+                    logger.warn(() -> new ParameterizedMessage("onSliceExecution listener [{}] failed", listener), e);
+                }
+            }
+        }
+
         @Override
         public void onPreFetchPhase(SearchContext searchContext) {
             for (SearchOperationListener listener : listeners) {
diff --git a/server/src/main/java/org/opensearch/index/shard/ShardPath.java b/server/src/main/java/org/opensearch/index/shard/ShardPath.java
index d16e5707b2e0e..911bfec94e190 100644
--- a/server/src/main/java/org/opensearch/index/shard/ShardPath.java
+++ b/server/src/main/java/org/opensearch/index/shard/ShardPath.java
@@ -32,10 +32,10 @@
 package org.opensearch.index.shard;
 
 import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.util.Strings;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.common.Strings;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.env.NodeEnvironment;
@@ -205,7 +205,7 @@ public static ShardPath loadShardPath(
         } else {
             final Path dataPath;
             final Path statePath = loadedPath;
-            final boolean hasCustomDataPath = Strings.isNotEmpty(customDataPath);
+            final boolean hasCustomDataPath = !Strings.isNullOrEmpty(customDataPath);
             if (hasCustomDataPath) {
                 dataPath = NodeEnvironment.resolveCustomLocation(customDataPath, shardId, sharedDataPath, nodeLockId);
             } else {
diff --git a/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java b/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
index 8d689e8769728..8649da936d81c 100644
--- a/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
+++ b/server/src/main/java/org/opensearch/index/shard/StoreRecovery.java
@@ -367,6 +367,7 @@ void recoverFromSnapshotAndRemoteStore(
         Repository repository,
         RepositoriesService repositoriesService,
         ActionListener<Boolean> listener,
+        String segmentsPathFixedPrefix,
         ThreadPool threadPool
     ) {
         try {
@@ -397,7 +398,8 @@ void recoverFromSnapshotAndRemoteStore(
 
                 RemoteSegmentStoreDirectoryFactory directoryFactory = new RemoteSegmentStoreDirectoryFactory(
                     () -> repositoriesService,
-                    threadPool
+                    threadPool,
+                    segmentsPathFixedPrefix
                 );
                 RemoteSegmentStoreDirectory sourceRemoteDirectory = (RemoteSegmentStoreDirectory) directoryFactory.newDirectory(
                     remoteStoreRepository,
diff --git a/server/src/main/java/org/opensearch/index/store/CloseableFilterIndexOutput.java b/server/src/main/java/org/opensearch/index/store/CloseableFilterIndexOutput.java
new file mode 100644
index 0000000000000..291f714369a74
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/store/CloseableFilterIndexOutput.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store;
+
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.lucene.store.FilterIndexOutput;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * FilterIndexOutput which takes in an additional FunctionalInterface as a parameter to perform required operations once the IndexOutput is closed
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class CloseableFilterIndexOutput extends FilterIndexOutput {
+
+    /**
+     * Functional Interface which takes the name of the file as input on which the required operations are to be performed
+     */
+    @FunctionalInterface
+    public interface OnCloseListener {
+        void onClose(String name) throws IOException;
+    }
+
+    private final OnCloseListener onCloseListener;
+    private final String fileName;
+    private final AtomicBoolean isClosed;
+
+    public CloseableFilterIndexOutput(IndexOutput out, String fileName, OnCloseListener onCloseListener) {
+        super("CloseableFilterIndexOutput for file " + fileName, out);
+        this.fileName = fileName;
+        this.onCloseListener = onCloseListener;
+        this.isClosed = new AtomicBoolean(false);
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (isClosed.get() == false) {
+            super.close();
+            onCloseListener.onClose(fileName);
+            isClosed.set(true);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/store/CompositeDirectory.java b/server/src/main/java/org/opensearch/index/store/CompositeDirectory.java
new file mode 100644
index 0000000000000..eb89c86ae687f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/store/CompositeDirectory.java
@@ -0,0 +1,344 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.FSDirectory;
+import org.apache.lucene.store.FilterDirectory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.util.Version;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.lucene.store.InputStreamIndexInput;
+import org.opensearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshot;
+import org.opensearch.index.store.remote.file.OnDemandBlockSnapshotIndexInput;
+import org.opensearch.index.store.remote.filecache.CachedFullFileIndexInput;
+import org.opensearch.index.store.remote.filecache.CachedIndexInput;
+import org.opensearch.index.store.remote.filecache.FileCache;
+import org.opensearch.index.store.remote.utils.BlockIOContext;
+import org.opensearch.index.store.remote.utils.FileTypeUtils;
+import org.opensearch.index.store.remote.utils.TransferManager;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Composite Directory will contain both local and remote directory
+ * Consumers of Composite directory need not worry whether file is in local or remote
+ * All such abstractions will be handled by the Composite directory itself
+ * Implements all required methods by Directory abstraction
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class CompositeDirectory extends FilterDirectory {
+    private static final Logger logger = LogManager.getLogger(CompositeDirectory.class);
+    private final FSDirectory localDirectory;
+    private final RemoteSegmentStoreDirectory remoteDirectory;
+    private final FileCache fileCache;
+    private final TransferManager transferManager;
+
+    /**
+     * Constructor to initialise the composite directory
+     * @param localDirectory corresponding to the local FSDirectory
+     * @param remoteDirectory corresponding to the remote directory
+     * @param fileCache used to cache the remote files locally
+     */
+    public CompositeDirectory(Directory localDirectory, Directory remoteDirectory, FileCache fileCache) {
+        super(localDirectory);
+        validate(localDirectory, remoteDirectory, fileCache);
+        this.localDirectory = (FSDirectory) localDirectory;
+        this.remoteDirectory = (RemoteSegmentStoreDirectory) remoteDirectory;
+        this.fileCache = fileCache;
+        transferManager = new TransferManager(
+            (name, position, length) -> new InputStreamIndexInput(
+                remoteDirectory.openInput(name, new BlockIOContext(IOContext.DEFAULT, position, length)),
+                length
+            ),
+            fileCache
+        );
+    }
+
+    /**
+     * Returns names of all files stored in this directory in sorted order
+     * Does not include locally stored block files (having _block_ in their names) and files pending deletion
+     *
+     * @throws IOException in case of I/O error
+     */
+    @Override
+    public String[] listAll() throws IOException {
+        ensureOpen();
+        logger.trace("Composite Directory[{}]: listAll() called", this::toString);
+        String[] localFiles = localDirectory.listAll();
+        Set<String> allFiles = new HashSet<>(Arrays.asList(localFiles));
+        String[] remoteFiles = getRemoteFiles();
+        allFiles.addAll(Arrays.asList(remoteFiles));
+        logger.trace("Composite Directory[{}]: Local Directory files - {}", this::toString, () -> Arrays.toString(localFiles));
+        logger.trace("Composite Directory[{}]: Remote Directory files - {}", this::toString, () -> Arrays.toString(remoteFiles));
+        Set<String> nonBlockLuceneFiles = allFiles.stream()
+            .filter(file -> !FileTypeUtils.isBlockFile(file))
+            .collect(Collectors.toUnmodifiableSet());
+        String[] files = new String[nonBlockLuceneFiles.size()];
+        nonBlockLuceneFiles.toArray(files);
+        Arrays.sort(files);
+        logger.trace("Composite Directory[{}]: listAll() returns : {}", this::toString, () -> Arrays.toString(files));
+        return files;
+    }
+
+    /**
+     * Removes an existing file in the directory.
+     * Currently deleting only from local directory as files from remote should not be deleted as that is taken care by garbage collection logic of remote directory
+     * @param name the name of an existing file.
+     * @throws IOException in case of I/O error
+     */
+    @Override
+    public void deleteFile(String name) throws IOException {
+        ensureOpen();
+        logger.trace("Composite Directory[{}]: deleteFile() called {}", this::toString, () -> name);
+        if (FileTypeUtils.isTempFile(name)) {
+            localDirectory.deleteFile(name);
+        } else if (Arrays.asList(listAll()).contains(name) == false) {
+            throw new NoSuchFileException("File " + name + " not found in directory");
+        } else {
+            fileCache.remove(getFilePath(name));
+        }
+    }
+
+    /**
+     * Returns the byte length of a file in the directory.
+     * Throws {@link NoSuchFileException} or {@link FileNotFoundException} in case file is not present locally and in remote as well
+     * @param name the name of an existing file.
+     * @throws IOException in case of I/O error
+     */
+    @Override
+    public long fileLength(String name) throws IOException {
+        ensureOpen();
+        logger.trace("Composite Directory[{}]: fileLength() called {}", this::toString, () -> name);
+        long fileLength;
+        Path key = getFilePath(name);
+        if (FileTypeUtils.isTempFile(name) || fileCache.get(key) != null) {
+            try {
+                fileLength = localDirectory.fileLength(name);
+                logger.trace(
+                    "Composite Directory[{}]: fileLength of {} fetched from Local - {}",
+                    this::toString,
+                    () -> name,
+                    () -> fileLength
+                );
+            } finally {
+                fileCache.decRef(key);
+            }
+        } else {
+            fileLength = remoteDirectory.fileLength(name);
+            logger.trace(
+                "Composite Directory[{}]: fileLength of {} fetched from Remote - {}",
+                this::toString,
+                () -> name,
+                () -> fileLength
+            );
+        }
+        return fileLength;
+    }
+
+    /**
+     * Creates a new, empty file in the directory and returns an {@link IndexOutput} instance for
+     * appending data to this file.
+     * @param name the name of the file to create.
+     * @throws IOException in case of I/O error
+     */
+    @Override
+    public IndexOutput createOutput(String name, IOContext context) throws IOException {
+        ensureOpen();
+        logger.trace("Composite Directory[{}]: createOutput() called {}", this::toString, () -> name);
+        // The CloseableFilterIndexOutput will ensure that the file is added to FileCache once write is completed on this file
+        return new CloseableFilterIndexOutput(localDirectory.createOutput(name, context), name, this::cacheFile);
+    }
+
+    /**
+     * Ensures that any writes to these files are moved to stable storage (made durable).
+     * @throws IOException in case of I/O error
+     */
+    @Override
+    public void sync(Collection<String> names) throws IOException {
+        ensureOpen();
+        logger.trace("Composite Directory[{}]: sync() called {}", this::toString, () -> names);
+        Collection<String> remoteFiles = Arrays.asList(getRemoteFiles());
+        Collection<String> filesToSync = names.stream().filter(name -> remoteFiles.contains(name) == false).collect(Collectors.toList());
+        logger.trace("Composite Directory[{}]: Synced files : {}", this::toString, () -> filesToSync);
+        localDirectory.sync(filesToSync);
+    }
+
+    /**
+     * Renames {@code source} file to {@code dest} file where {@code dest} must not already exist in
+     * the directory.
+     * @throws IOException in case of I/O error
+     */
+    @Override
+    public void rename(String source, String dest) throws IOException {
+        ensureOpen();
+        logger.trace("Composite Directory[{}]: rename() called : source-{}, dest-{}", this::toString, () -> source, () -> dest);
+        localDirectory.rename(source, dest);
+        fileCache.remove(getFilePath(source));
+        cacheFile(dest);
+    }
+
+    /**
+     * Opens a stream for reading an existing file.
+     * Check whether the file is present locally or in remote and return the IndexInput accordingly
+     * @param name the name of an existing file.
+     * @throws IOException in case of I/O error
+     */
+    @Override
+    public IndexInput openInput(String name, IOContext context) throws IOException {
+        ensureOpen();
+        logger.trace("Composite Directory[{}]: openInput() called {}", this::toString, () -> name);
+        // We aren't tracking temporary files (created via createTempOutput) currently in FileCache as these are created and then deleted
+        // within a very short span of time
+        // We will be reading them directory from the local directory
+        if (FileTypeUtils.isTempFile(name)) {
+            return localDirectory.openInput(name, context);
+        }
+        // Return directly from the FileCache (via TransferManager) if complete file is present
+        Path key = getFilePath(name);
+        CachedIndexInput indexInput = fileCache.get(key);
+        if (indexInput != null) {
+            logger.trace("Composite Directory[{}]: Complete file {} found in FileCache", this::toString, () -> name);
+            try {
+                return indexInput.getIndexInput().clone();
+            } finally {
+                fileCache.decRef(key);
+            }
+        }
+        // If file has been uploaded to the Remote Store, fetch it from the Remote Store in blocks via OnDemandCompositeBlockIndexInput
+        else {
+            logger.trace(
+                "Composite Directory[{}]: Complete file {} not in FileCache, to be fetched in Blocks from Remote",
+                this::toString,
+                () -> name
+            );
+            RemoteSegmentStoreDirectory.UploadedSegmentMetadata uploadedSegmentMetadata = remoteDirectory.getSegmentsUploadedToRemoteStore()
+                .get(name);
+            if (uploadedSegmentMetadata == null) {
+                throw new NoSuchFileException("File " + name + " not found in directory");
+            }
+            // TODO : Refactor FileInfo and OnDemandBlockSnapshotIndexInput to more generic names as they are not Remote Snapshot specific
+            BlobStoreIndexShardSnapshot.FileInfo fileInfo = new BlobStoreIndexShardSnapshot.FileInfo(
+                name,
+                new StoreFileMetadata(name, uploadedSegmentMetadata.getLength(), uploadedSegmentMetadata.getChecksum(), Version.LATEST),
+                null
+            );
+            return new OnDemandBlockSnapshotIndexInput(fileInfo, localDirectory, transferManager);
+        }
+    }
+
+    /**
+     * Closing the local directory here
+     * @throws IOException in case of I/O error
+     */
+    @Override
+    public void close() throws IOException {
+        ensureOpen();
+        logger.trace("Composite Directory[{}]: close() called", this::toString);
+        localDirectory.close();
+    }
+
+    @Override
+    public String toString() {
+        return "Composite Directory @ " + Integer.toHexString(hashCode());
+    }
+
+    /**
+     * Function to perform operations once files have been uploaded to Remote Store
+     * Currently deleting the local files here, as once uploaded to Remote, local files become eligible for eviction from FileCache
+     * @param file : recent files which have been successfully uploaded to Remote Store
+     */
+    public void afterSyncToRemote(String file) {
+        ensureOpen();
+        /*
+        Decrementing the refCount here for the path so that it becomes eligible for eviction
+        This is a temporary solution until pinning support is added
+        TODO - Unpin the files here from FileCache so that they become eligible for eviction, once pinning/unpinning support is added in FileCache
+        Uncomment the below commented line(to remove the file from cache once uploaded) to test block based functionality
+         */
+        logger.trace(
+            "Composite Directory[{}]: File {} uploaded to Remote Store and now can be eligible for eviction in FileCache",
+            this::toString,
+            () -> file
+        );
+        fileCache.decRef(getFilePath(file));
+        // fileCache.remove(getFilePath(fileName));
+    }
+
+    // Visibility public since we need it in IT tests
+    public Path getFilePath(String name) {
+        return localDirectory.getDirectory().resolve(name);
+    }
+
+    /**
+     * Basic validations for Composite Directory parameters (null checks and instance type checks)
+     *
+     * Note: Currently Composite Directory only supports local directory to be of type FSDirectory
+     * The reason is that FileCache currently has it key type as Path
+     * Composite Directory currently uses FSDirectory's getDirectory() method to fetch and use the Path for operating on FileCache
+     * TODO : Refactor FileCache to have key in form of String instead of Path. Once that is done we can remove this assertion
+     */
+    private void validate(Directory localDirectory, Directory remoteDirectory, FileCache fileCache) {
+        if (localDirectory == null || remoteDirectory == null) throw new IllegalStateException(
+            "Local and remote directory cannot be null for Composite Directory"
+        );
+        if (fileCache == null) throw new IllegalStateException(
+            "File Cache not initialized on this Node, cannot create Composite Directory without FileCache"
+        );
+        if (localDirectory instanceof FSDirectory == false) throw new IllegalStateException(
+            "For Composite Directory, local directory must be of type FSDirectory"
+        );
+        if (remoteDirectory instanceof RemoteSegmentStoreDirectory == false) throw new IllegalStateException(
+            "For Composite Directory, remote directory must be of type RemoteSegmentStoreDirectory"
+        );
+    }
+
+    /**
+     * Return the list of files present in Remote
+     */
+    private String[] getRemoteFiles() throws IOException {
+        String[] remoteFiles;
+        try {
+            remoteFiles = remoteDirectory.listAll();
+        } catch (NullPointerException e) {
+            /*
+            We can encounter NPE when no data has been uploaded to remote store yet and as a result the metadata is empty
+            Empty metadata means that there are no files currently in remote, hence returning an empty list in this scenario
+            TODO : Catch the NPE in listAll of RemoteSegmentStoreDirectory itself instead of catching here
+             */
+            remoteFiles = new String[0];
+        }
+        return remoteFiles;
+    }
+
+    private void cacheFile(String name) throws IOException {
+        Path filePath = getFilePath(name);
+        // put will increase the refCount for the path, making sure it is not evicted, will decrease the ref after it is uploaded to Remote
+        // so that it can be evicted after that
+        // this is just a temporary solution, will pin the file once support for that is added in FileCache
+        // TODO : Pin the above filePath in the file cache once pinning support is added so that it cannot be evicted unless it has been
+        // successfully uploaded to Remote
+        fileCache.put(filePath, new CachedFullFileIndexInput(fileCache, filePath, localDirectory.openInput(name, IOContext.DEFAULT)));
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteDirectory.java b/server/src/main/java/org/opensearch/index/store/RemoteDirectory.java
index ab76150f8f83d..c61fae74c0bc0 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteDirectory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteDirectory.java
@@ -28,9 +28,11 @@
 import org.opensearch.common.blobstore.transfer.RemoteTransferContainer;
 import org.opensearch.common.blobstore.transfer.stream.OffsetRangeIndexInputStream;
 import org.opensearch.common.blobstore.transfer.stream.OffsetRangeInputStream;
+import org.opensearch.common.lucene.store.ByteArrayIndexInput;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.unit.ByteSizeUnit;
 import org.opensearch.index.store.exception.ChecksumCombinationException;
+import org.opensearch.index.store.remote.utils.BlockIOContext;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -64,6 +66,8 @@ public class RemoteDirectory extends Directory {
 
     private final UnaryOperator<OffsetRangeInputStream> uploadRateLimiter;
 
+    private final UnaryOperator<OffsetRangeInputStream> lowPriorityUploadRateLimiter;
+
     private final UnaryOperator<InputStream> downloadRateLimiter;
 
     /**
@@ -76,15 +80,17 @@ public BlobContainer getBlobContainer() {
     }
 
     public RemoteDirectory(BlobContainer blobContainer) {
-        this(blobContainer, UnaryOperator.identity(), UnaryOperator.identity());
+        this(blobContainer, UnaryOperator.identity(), UnaryOperator.identity(), UnaryOperator.identity());
     }
 
     public RemoteDirectory(
         BlobContainer blobContainer,
         UnaryOperator<OffsetRangeInputStream> uploadRateLimiter,
+        UnaryOperator<OffsetRangeInputStream> lowPriorityUploadRateLimiter,
         UnaryOperator<InputStream> downloadRateLimiter
     ) {
         this.blobContainer = blobContainer;
+        this.lowPriorityUploadRateLimiter = lowPriorityUploadRateLimiter;
         this.uploadRateLimiter = uploadRateLimiter;
         this.downloadRateLimiter = downloadRateLimiter;
     }
@@ -199,10 +205,14 @@ public IndexInput openInput(String name, IOContext context) throws IOException {
     public IndexInput openInput(String name, long fileLength, IOContext context) throws IOException {
         InputStream inputStream = null;
         try {
-            inputStream = blobContainer.readBlob(name);
-            return new RemoteIndexInput(name, downloadRateLimiter.apply(inputStream), fileLength);
+            if (context instanceof BlockIOContext) {
+                return getBlockInput(name, fileLength, (BlockIOContext) context);
+            } else {
+                inputStream = blobContainer.readBlob(name);
+                return new RemoteIndexInput(name, downloadRateLimiter.apply(inputStream), fileLength);
+            }
         } catch (Exception e) {
-            // Incase the RemoteIndexInput creation fails, close the input stream to avoid file handler leak.
+            // In case the RemoteIndexInput creation fails, close the input stream to avoid file handler leak.
             if (inputStream != null) {
                 try {
                     inputStream.close();
@@ -357,13 +367,23 @@ private void uploadBlob(
             remoteIntegrityEnabled = ((AsyncMultiStreamBlobContainer) getBlobContainer()).remoteIntegrityCheckSupported();
         }
         lowPriorityUpload = lowPriorityUpload || contentLength > ByteSizeUnit.GB.toBytes(15);
+        RemoteTransferContainer.OffsetRangeInputStreamSupplier offsetRangeInputStreamSupplier;
+        if (lowPriorityUpload) {
+            offsetRangeInputStreamSupplier = (size, position) -> lowPriorityUploadRateLimiter.apply(
+                new OffsetRangeIndexInputStream(from.openInput(src, ioContext), size, position)
+            );
+        } else {
+            offsetRangeInputStreamSupplier = (size, position) -> uploadRateLimiter.apply(
+                new OffsetRangeIndexInputStream(from.openInput(src, ioContext), size, position)
+            );
+        }
         RemoteTransferContainer remoteTransferContainer = new RemoteTransferContainer(
             src,
             remoteFileName,
             contentLength,
             true,
             lowPriorityUpload ? WritePriority.LOW : WritePriority.NORMAL,
-            (size, position) -> uploadRateLimiter.apply(new OffsetRangeIndexInputStream(from.openInput(src, ioContext), size, position)),
+            offsetRangeInputStreamSupplier,
             expectedChecksum,
             remoteIntegrityEnabled
         );
@@ -420,4 +440,18 @@ private long calculateChecksumOfChecksum(Directory directory, String file) throw
             }
         }
     }
+
+    private IndexInput getBlockInput(String name, long fileLength, BlockIOContext blockIOContext) throws IOException {
+        long position = blockIOContext.getBlockStart();
+        long length = blockIOContext.getBlockSize();
+        if (position < 0 || length < 0 || (position + length > fileLength)) {
+            throw new IllegalArgumentException("Invalid values of block start and size");
+        }
+        byte[] bytes;
+        try (InputStream inputStream = blobContainer.readBlob(name, position, length)) {
+            // TODO - Explore how we can buffer small chunks of data instead of having the whole 8MB block in memory
+            bytes = downloadRateLimiter.apply(inputStream).readAllBytes();
+        }
+        return new ByteArrayIndexInput(name, bytes);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
index 3e4e027922285..5e5686ab3a419 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectory.java
@@ -40,6 +40,7 @@
 import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadata;
 import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadataHandler;
 import org.opensearch.indices.replication.checkpoint.ReplicationCheckpoint;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.FileNotFoundException;
@@ -91,6 +92,8 @@ public final class RemoteSegmentStoreDirectory extends FilterDirectory implement
 
     private final RemoteStoreLockManager mdLockManager;
 
+    private final Map<Long, String> metadataFilePinnedTimestampMap;
+
     private final ThreadPool threadPool;
 
     /**
@@ -132,6 +135,7 @@ public RemoteSegmentStoreDirectory(
         this.remoteMetadataDirectory = remoteMetadataDirectory;
         this.mdLockManager = mdLockManager;
         this.threadPool = threadPool;
+        this.metadataFilePinnedTimestampMap = new HashMap<>();
         this.logger = Loggers.getLogger(getClass(), shardId);
         init();
     }
@@ -176,6 +180,43 @@ public RemoteSegmentMetadata initializeToSpecificCommit(long primaryTerm, long c
         return remoteSegmentMetadata;
     }
 
+    /**
+     * Initializes the remote segment metadata to a specific timestamp.
+     *
+     * @param timestamp The timestamp to initialize the remote segment metadata to.
+     * @return The RemoteSegmentMetadata object corresponding to the specified timestamp, or null if no metadata file is found for that timestamp.
+     * @throws IOException If an I/O error occurs while reading the metadata file.
+     */
+    public RemoteSegmentMetadata initializeToSpecificTimestamp(long timestamp) throws IOException {
+        List<String> metadataFiles = remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+            MetadataFilenameUtils.METADATA_PREFIX,
+            Integer.MAX_VALUE
+        );
+        Set<String> lockedMetadataFiles = RemoteStoreUtils.getPinnedTimestampLockedFiles(
+            metadataFiles,
+            Set.of(timestamp),
+            MetadataFilenameUtils::getTimestamp,
+            MetadataFilenameUtils::getNodeIdByPrimaryTermAndGen,
+            true
+        );
+        if (lockedMetadataFiles.isEmpty()) {
+            return null;
+        }
+        if (lockedMetadataFiles.size() > 1) {
+            throw new IOException(
+                "Expected exactly one metadata file matching timestamp: " + timestamp + " but got " + lockedMetadataFiles
+            );
+        }
+        String metadataFile = lockedMetadataFiles.iterator().next();
+        RemoteSegmentMetadata remoteSegmentMetadata = readMetadataFile(metadataFile);
+        if (remoteSegmentMetadata != null) {
+            this.segmentsUploadedToRemoteStore = new ConcurrentHashMap<>(remoteSegmentMetadata.getMetadata());
+        } else {
+            this.segmentsUploadedToRemoteStore = new ConcurrentHashMap<>();
+        }
+        return remoteSegmentMetadata;
+    }
+
     /**
      * Read the latest metadata file to get the list of segments uploaded to the remote segment store.
      * We upload a metadata file per refresh, but it is not unique per refresh. Refresh metadata file is unique for a given commit.
@@ -324,7 +365,8 @@ public static String getMetadataFilename(
             long translogGeneration,
             long uploadCounter,
             int metadataVersion,
-            String nodeId
+            String nodeId,
+            long creationTimestamp
         ) {
             return String.join(
                 SEPARATOR,
@@ -334,11 +376,30 @@ public static String getMetadataFilename(
                 RemoteStoreUtils.invertLong(translogGeneration),
                 RemoteStoreUtils.invertLong(uploadCounter),
                 String.valueOf(Objects.hash(nodeId)),
-                RemoteStoreUtils.invertLong(System.currentTimeMillis()),
+                RemoteStoreUtils.invertLong(creationTimestamp),
                 String.valueOf(metadataVersion)
             );
         }
 
+        public static String getMetadataFilename(
+            long primaryTerm,
+            long generation,
+            long translogGeneration,
+            long uploadCounter,
+            int metadataVersion,
+            String nodeId
+        ) {
+            return getMetadataFilename(
+                primaryTerm,
+                generation,
+                translogGeneration,
+                uploadCounter,
+                metadataVersion,
+                nodeId,
+                System.currentTimeMillis()
+            );
+        }
+
         // Visible for testing
         static long getPrimaryTerm(String[] filenameTokens) {
             return RemoteStoreUtils.invertLong(filenameTokens[1]);
@@ -349,6 +410,11 @@ static long getGeneration(String[] filenameTokens) {
             return RemoteStoreUtils.invertLong(filenameTokens[2]);
         }
 
+        public static long getTimestamp(String filename) {
+            String[] filenameTokens = filename.split(SEPARATOR);
+            return RemoteStoreUtils.invertLong(filenameTokens[6]);
+        }
+
         public static Tuple<String, String> getNodeIdByPrimaryTermAndGen(String filename) {
             String[] tokens = filename.split(SEPARATOR);
             if (tokens.length < 8) {
@@ -788,6 +854,7 @@ public void deleteStaleSegments(int lastNMetadataFilesToKeep) throws IOException
             );
             return;
         }
+
         List<String> sortedMetadataFileList = remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
             MetadataFilenameUtils.METADATA_PREFIX,
             Integer.MAX_VALUE
@@ -801,16 +868,44 @@ public void deleteStaleSegments(int lastNMetadataFilesToKeep) throws IOException
             return;
         }
 
-        List<String> metadataFilesEligibleToDelete = new ArrayList<>(
-            sortedMetadataFileList.subList(lastNMetadataFilesToKeep, sortedMetadataFileList.size())
+        // Check last fetch status of pinned timestamps. If stale, return.
+        if (RemoteStoreUtils.isPinnedTimestampStateStale()) {
+            logger.warn("Skipping remote segment store garbage collection as last fetch of pinned timestamp is stale");
+            return;
+        }
+
+        Tuple<Long, Set<Long>> pinnedTimestampsState = RemoteStorePinnedTimestampService.getPinnedTimestamps();
+
+        Set<String> implicitLockedFiles = RemoteStoreUtils.getPinnedTimestampLockedFiles(
+            sortedMetadataFileList,
+            pinnedTimestampsState.v2(),
+            metadataFilePinnedTimestampMap,
+            MetadataFilenameUtils::getTimestamp,
+            MetadataFilenameUtils::getNodeIdByPrimaryTermAndGen
         );
-        Set<String> allLockFiles;
+        final Set<String> allLockFiles = new HashSet<>(implicitLockedFiles);
+
         try {
-            allLockFiles = ((RemoteStoreMetadataLockManager) mdLockManager).fetchLockedMetadataFiles(MetadataFilenameUtils.METADATA_PREFIX);
+            allLockFiles.addAll(
+                ((RemoteStoreMetadataLockManager) mdLockManager).fetchLockedMetadataFiles(MetadataFilenameUtils.METADATA_PREFIX)
+            );
         } catch (Exception e) {
             logger.error("Exception while fetching segment metadata lock files, skipping deleteStaleSegments", e);
             return;
         }
+
+        List<String> metadataFilesEligibleToDelete = new ArrayList<>(
+            sortedMetadataFileList.subList(lastNMetadataFilesToKeep, sortedMetadataFileList.size())
+        );
+
+        // Along with last N files, we need to keep files since last successful run of scheduler
+        long lastSuccessfulFetchOfPinnedTimestamps = pinnedTimestampsState.v1();
+        metadataFilesEligibleToDelete = RemoteStoreUtils.filterOutMetadataFilesBasedOnAge(
+            metadataFilesEligibleToDelete,
+            MetadataFilenameUtils::getTimestamp,
+            lastSuccessfulFetchOfPinnedTimestamps
+        );
+
         List<String> metadataFilesToBeDeleted = metadataFilesEligibleToDelete.stream()
             .filter(metadataFile -> allLockFiles.contains(metadataFile) == false)
             .collect(Collectors.toList());
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
index e462f6d4ac011..85b3f25d950ef 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactory.java
@@ -40,11 +40,22 @@
 @PublicApi(since = "2.3.0")
 public class RemoteSegmentStoreDirectoryFactory implements IndexStorePlugin.DirectoryFactory {
     private final Supplier<RepositoriesService> repositoriesService;
+    private final String segmentsPathFixedPrefix;
 
     private final ThreadPool threadPool;
 
+    // Added for passing breaking change check
     public RemoteSegmentStoreDirectoryFactory(Supplier<RepositoriesService> repositoriesService, ThreadPool threadPool) {
+        this(repositoriesService, threadPool, null);
+    }
+
+    public RemoteSegmentStoreDirectoryFactory(
+        Supplier<RepositoriesService> repositoriesService,
+        ThreadPool threadPool,
+        String segmentsPathFixedPrefix
+    ) {
         this.repositoriesService = repositoriesService;
+        this.segmentsPathFixedPrefix = segmentsPathFixedPrefix;
         this.threadPool = threadPool;
     }
 
@@ -71,12 +82,14 @@ public Directory newDirectory(String repositoryName, String indexUUID, ShardId s
                 .shardId(shardIdStr)
                 .dataCategory(SEGMENTS)
                 .dataType(DATA)
+                .fixedPrefix(segmentsPathFixedPrefix)
                 .build();
             // Derive the path for data directory of SEGMENTS
             BlobPath dataPath = pathStrategy.generatePath(dataPathInput);
             RemoteDirectory dataDirectory = new RemoteDirectory(
                 blobStoreRepository.blobStore().blobContainer(dataPath),
                 blobStoreRepository::maybeRateLimitRemoteUploadTransfers,
+                blobStoreRepository::maybeRateLimitLowPriorityRemoteUploadTransfers,
                 blobStoreRepository::maybeRateLimitRemoteDownloadTransfers
             );
 
@@ -86,6 +99,7 @@ public Directory newDirectory(String repositoryName, String indexUUID, ShardId s
                 .shardId(shardIdStr)
                 .dataCategory(SEGMENTS)
                 .dataType(METADATA)
+                .fixedPrefix(segmentsPathFixedPrefix)
                 .build();
             // Derive the path for metadata directory of SEGMENTS
             BlobPath mdPath = pathStrategy.generatePath(mdPathInput);
@@ -97,7 +111,8 @@ public Directory newDirectory(String repositoryName, String indexUUID, ShardId s
                 repositoryName,
                 indexUUID,
                 shardIdStr,
-                pathStrategy
+                pathStrategy,
+                segmentsPathFixedPrefix
             );
 
             return new RemoteSegmentStoreDirectory(dataDirectory, metadataDirectory, mdLockManager, threadPool, shardId);
diff --git a/server/src/main/java/org/opensearch/index/store/RemoteStoreFileDownloader.java b/server/src/main/java/org/opensearch/index/store/RemoteStoreFileDownloader.java
index 134994c0ae32c..ad42b6d677b41 100644
--- a/server/src/main/java/org/opensearch/index/store/RemoteStoreFileDownloader.java
+++ b/server/src/main/java/org/opensearch/index/store/RemoteStoreFileDownloader.java
@@ -149,6 +149,7 @@ private void copyOneFile(
                 try {
                     cancellableThreads.executeIO(() -> {
                         destination.copyFrom(source, file, file, IOContext.DEFAULT);
+                        logger.trace("Downloaded file {} of size {}", file, destination.fileLength(file));
                         onFileCompletion.run();
                         if (secondDestination != null) {
                             secondDestination.copyFrom(destination, file, file, IOContext.DEFAULT);
diff --git a/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java b/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
index 45d466d3a8ce8..26d1f26188ecd 100644
--- a/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
+++ b/server/src/main/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactory.java
@@ -31,9 +31,17 @@
 @PublicApi(since = "2.8.0")
 public class RemoteStoreLockManagerFactory {
     private final Supplier<RepositoriesService> repositoriesService;
+    private final String segmentsPathFixedPrefix;
 
+    // Added for passing breaking change check
     public RemoteStoreLockManagerFactory(Supplier<RepositoriesService> repositoriesService) {
         this.repositoriesService = repositoriesService;
+        this.segmentsPathFixedPrefix = null;
+    }
+
+    public RemoteStoreLockManagerFactory(Supplier<RepositoriesService> repositoriesService, String segmentsPathFixedPrefix) {
+        this.repositoriesService = repositoriesService;
+        this.segmentsPathFixedPrefix = segmentsPathFixedPrefix;
     }
 
     public RemoteStoreLockManager newLockManager(
@@ -42,15 +50,27 @@ public RemoteStoreLockManager newLockManager(
         String shardId,
         RemoteStorePathStrategy pathStrategy
     ) {
-        return newLockManager(repositoriesService.get(), repositoryName, indexUUID, shardId, pathStrategy);
+        return newLockManager(repositoriesService.get(), repositoryName, indexUUID, shardId, pathStrategy, segmentsPathFixedPrefix);
     }
 
+    // Added for passing breaking change check
     public static RemoteStoreMetadataLockManager newLockManager(
         RepositoriesService repositoriesService,
         String repositoryName,
         String indexUUID,
         String shardId,
         RemoteStorePathStrategy pathStrategy
+    ) {
+        return newLockManager(repositoriesService, repositoryName, indexUUID, shardId, pathStrategy, null);
+    }
+
+    public static RemoteStoreMetadataLockManager newLockManager(
+        RepositoriesService repositoriesService,
+        String repositoryName,
+        String indexUUID,
+        String shardId,
+        RemoteStorePathStrategy pathStrategy,
+        String segmentsPathFixedPrefix
     ) {
         try (Repository repository = repositoriesService.repository(repositoryName)) {
             assert repository instanceof BlobStoreRepository : "repository should be instance of BlobStoreRepository";
@@ -62,6 +82,7 @@ public static RemoteStoreMetadataLockManager newLockManager(
                 .shardId(shardId)
                 .dataCategory(SEGMENTS)
                 .dataType(LOCK_FILES)
+                .fixedPrefix(segmentsPathFixedPrefix)
                 .build();
             BlobPath lockDirectoryPath = pathStrategy.generatePath(lockFilesPathInput);
             BlobContainer lockDirectoryBlobContainer = ((BlobStoreRepository) repository).blobStore().blobContainer(lockDirectoryPath);
diff --git a/server/src/main/java/org/opensearch/index/store/remote/directory/RemoteSnapshotDirectoryFactory.java b/server/src/main/java/org/opensearch/index/store/remote/directory/RemoteSnapshotDirectoryFactory.java
index 7cfa738e75e52..e027e8b7cb3b1 100644
--- a/server/src/main/java/org/opensearch/index/store/remote/directory/RemoteSnapshotDirectoryFactory.java
+++ b/server/src/main/java/org/opensearch/index/store/remote/directory/RemoteSnapshotDirectoryFactory.java
@@ -11,14 +11,15 @@
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.store.FSDirectory;
 import org.opensearch.common.blobstore.BlobContainer;
-import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.index.IndexSettings;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.shard.ShardPath;
 import org.opensearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshot;
 import org.opensearch.index.snapshots.blobstore.IndexShardSnapshot;
 import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.index.store.remote.utils.TransferManager;
 import org.opensearch.plugins.IndexStorePlugin;
+import org.opensearch.repositories.IndexId;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
@@ -74,10 +75,11 @@ private Future<RemoteSnapshotDirectory> createRemoteSnapshotDirectoryFromSnapsho
         ShardPath localShardPath,
         BlobStoreRepository blobStoreRepository
     ) throws IOException {
-        final BlobPath blobPath = blobStoreRepository.basePath()
-            .add("indices")
-            .add(IndexSettings.SEARCHABLE_SNAPSHOT_INDEX_ID.get(indexSettings.getSettings()))
-            .add(Integer.toString(localShardPath.getShardId().getId()));
+        // The below information like the snapshot generated indexId, shard_path_type and shardId are used for
+        // creating the shard BlobContainer. This information has been updated as per the hashed_prefix snapshots.
+        String indexId = IndexSettings.SEARCHABLE_SNAPSHOT_INDEX_ID.get(indexSettings.getSettings());
+        PathType pathType = IndexSettings.SEARCHABLE_SNAPSHOT_SHARD_PATH_TYPE.get(indexSettings.getSettings());
+        int shardId = localShardPath.getShardId().getId();
         final SnapshotId snapshotId = new SnapshotId(
             IndexSettings.SEARCHABLE_SNAPSHOT_ID_NAME.get(indexSettings.getSettings()),
             IndexSettings.SEARCHABLE_SNAPSHOT_ID_UUID.get(indexSettings.getSettings())
@@ -89,12 +91,17 @@ private Future<RemoteSnapshotDirectory> createRemoteSnapshotDirectoryFromSnapsho
         // this trick is needed to bypass assertions in BlobStoreRepository::assertAllowableThreadPools in case of node restart and a remote
         // index restore is invoked
         return threadPool.executor(ThreadPool.Names.SNAPSHOT).submit(() -> {
-            final BlobContainer blobContainer = blobStoreRepository.blobStore().blobContainer(blobPath);
+            // shardContainer(IndexId, shardId) method uses the id and pathType information to generate the blobPath and
+            // hence the blobContainer. We have used a dummy name as it plays no relevance in the blobPath generation.
+            final BlobContainer blobContainer = blobStoreRepository.shardContainer(
+                new IndexId("DUMMY", indexId, pathType.getCode()),
+                shardId
+            );
             final IndexShardSnapshot indexShardSnapshot = blobStoreRepository.loadShardSnapshot(blobContainer, snapshotId);
             assert indexShardSnapshot instanceof BlobStoreIndexShardSnapshot
                 : "indexShardSnapshot should be an instance of BlobStoreIndexShardSnapshot";
             final BlobStoreIndexShardSnapshot snapshot = (BlobStoreIndexShardSnapshot) indexShardSnapshot;
-            TransferManager transferManager = new TransferManager(blobContainer, remoteStoreFileCache);
+            TransferManager transferManager = new TransferManager(blobContainer::readBlob, remoteStoreFileCache);
             return new RemoteSnapshotDirectory(snapshot, localStoreDir, transferManager);
         });
     }
diff --git a/server/src/main/java/org/opensearch/index/store/remote/file/OnDemandBlockSnapshotIndexInput.java b/server/src/main/java/org/opensearch/index/store/remote/file/OnDemandBlockSnapshotIndexInput.java
index 8097fd08da50a..ad56127394779 100644
--- a/server/src/main/java/org/opensearch/index/store/remote/file/OnDemandBlockSnapshotIndexInput.java
+++ b/server/src/main/java/org/opensearch/index/store/remote/file/OnDemandBlockSnapshotIndexInput.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.index.store.remote.file;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.apache.lucene.store.FSDirectory;
 import org.apache.lucene.store.IndexInput;
 import org.opensearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshot.FileInfo;
@@ -26,6 +28,7 @@
  * @opensearch.internal
  */
 public class OnDemandBlockSnapshotIndexInput extends OnDemandBlockIndexInput {
+    private static final Logger logger = LogManager.getLogger(OnDemandBlockSnapshotIndexInput.class);
     /**
      * Where this class fetches IndexInput parts from
      */
@@ -133,10 +136,19 @@ protected OnDemandBlockSnapshotIndexInput buildSlice(String sliceDescription, lo
 
     @Override
     protected IndexInput fetchBlock(int blockId) throws IOException {
-        final String blockFileName = fileName + "." + blockId;
+        logger.trace("fetchBlock called with blockId -> {}", blockId);
+        final String blockFileName = fileName + "_block_" + blockId;
 
         final long blockStart = getBlockStart(blockId);
         final long blockEnd = blockStart + getActualBlockSize(blockId);
+        logger.trace(
+            "File: {} , Block File: {} , BlockStart: {} , BlockEnd: {} , OriginalFileSize: {}",
+            fileName,
+            blockFileName,
+            blockStart,
+            blockEnd,
+            originalFileSize
+        );
 
         // Block may be present on multiple chunks of a file, so we need
         // to fetch each chunk/blob part separately to fetch an entire block.
diff --git a/server/src/main/java/org/opensearch/index/store/remote/filecache/CachedFullFileIndexInput.java b/server/src/main/java/org/opensearch/index/store/remote/filecache/CachedFullFileIndexInput.java
new file mode 100644
index 0000000000000..286739cb6cd90
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/store/remote/filecache/CachedFullFileIndexInput.java
@@ -0,0 +1,74 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.filecache;
+
+import org.apache.lucene.store.AlreadyClosedException;
+import org.apache.lucene.store.IndexInput;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.nio.file.Path;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Implementation of the CachedIndexInput for full files which takes in an IndexInput as parameter
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class CachedFullFileIndexInput implements CachedIndexInput {
+    private final FileCache fileCache;
+    private final Path path;
+    private final FullFileCachedIndexInput fullFileCachedIndexInput;
+    private final AtomicBoolean isClosed;
+
+    /**
+     * Constructor - takes IndexInput as parameter
+     */
+    public CachedFullFileIndexInput(FileCache fileCache, Path path, IndexInput indexInput) {
+        this.fileCache = fileCache;
+        this.path = path;
+        fullFileCachedIndexInput = new FullFileCachedIndexInput(fileCache, path, indexInput);
+        isClosed = new AtomicBoolean(false);
+    }
+
+    /**
+     * Returns the wrapped indexInput
+     */
+    @Override
+    public IndexInput getIndexInput() {
+        if (isClosed.get()) throw new AlreadyClosedException("Index input is already closed");
+        return fullFileCachedIndexInput;
+    }
+
+    /**
+     * Returns the length of the wrapped indexInput
+     */
+    @Override
+    public long length() {
+        return fullFileCachedIndexInput.length();
+    }
+
+    /**
+     * Checks if the wrapped indexInput is closed
+     */
+    @Override
+    public boolean isClosed() {
+        return isClosed.get();
+    }
+
+    /**
+     * Closes the wrapped indexInput
+     */
+    @Override
+    public void close() throws Exception {
+        if (!isClosed.getAndSet(true)) {
+            fullFileCachedIndexInput.close();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCache.java b/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCache.java
index 2029b461674c7..2491e525993a0 100644
--- a/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCache.java
+++ b/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCache.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.index.store.remote.filecache;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.apache.lucene.store.IndexInput;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.settings.Setting;
@@ -48,25 +50,13 @@
  */
 @PublicApi(since = "2.7.0")
 public class FileCache implements RefCountedCache<Path, CachedIndexInput> {
+    private static final Logger logger = LogManager.getLogger(FileCache.class);
+    // This constant moved, but exists here for backward compatibility
+    public static final Setting<Double> DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING = FileCacheSettings.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING;
     private final SegmentedCache<Path, CachedIndexInput> theCache;
 
     private final CircuitBreaker circuitBreaker;
 
-    /**
-     * Defines a limit of how much total remote data can be referenced as a ratio of the size of the disk reserved for
-     * the file cache. For example, if 100GB disk space is configured for use as a file cache and the
-     * remote_data_ratio of 5 is defined, then a total of 500GB of remote data can be loaded as searchable snapshots.
-     * This is designed to be a safeguard to prevent oversubscribing a cluster.
-     * Specify a value of zero for no limit, which is the default for compatibility reasons.
-     */
-    public static final Setting<Double> DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING = Setting.doubleSetting(
-        "cluster.filecache.remote_data_ratio",
-        0.0,
-        0.0,
-        Setting.Property.NodeScope,
-        Setting.Property.Dynamic
-    );
-
     public FileCache(SegmentedCache<Path, CachedIndexInput> cache, CircuitBreaker circuitBreaker) {
         this.theCache = cache;
         this.circuitBreaker = circuitBreaker;
@@ -155,6 +145,14 @@ public CacheStats stats() {
         return theCache.stats();
     }
 
+    // To be used only for debugging purposes
+    public void logCurrentState() {
+        logger.trace("CURRENT STATE OF FILE CACHE \n");
+        CacheUsage cacheUsage = theCache.usage();
+        logger.trace("Total Usage: " + cacheUsage.usage() + " , Active Usage: " + cacheUsage.activeUsage());
+        theCache.logCurrentState();
+    }
+
     /**
      * Ensures that the PARENT breaker is not tripped when an entry is added to the cache
      * @param filePath the path key for which entry is added
diff --git a/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCacheSettings.java b/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCacheSettings.java
new file mode 100644
index 0000000000000..76086be932ecb
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCacheSettings.java
@@ -0,0 +1,50 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.filecache;
+
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+
+/**
+ * Settings relate to file cache
+ *
+ * @opensearch.internal
+ */
+public class FileCacheSettings {
+    /**
+     * Defines a limit of how much total remote data can be referenced as a ratio of the size of the disk reserved for
+     * the file cache. For example, if 100GB disk space is configured for use as a file cache and the
+     * remote_data_ratio of 5 is defined, then a total of 500GB of remote data can be loaded as searchable snapshots.
+     * This is designed to be a safeguard to prevent oversubscribing a cluster.
+     * Specify a value of zero for no limit, which is the default for compatibility reasons.
+     */
+    public static final Setting<Double> DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING = Setting.doubleSetting(
+        "cluster.filecache.remote_data_ratio",
+        0.0,
+        0.0,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    private volatile double remoteDataRatio;
+
+    public FileCacheSettings(Settings settings, ClusterSettings clusterSettings) {
+        setRemoteDataRatio(DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.get(settings));
+        clusterSettings.addSettingsUpdateConsumer(DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING, this::setRemoteDataRatio);
+    }
+
+    public void setRemoteDataRatio(double remoteDataRatio) {
+        this.remoteDataRatio = remoteDataRatio;
+    }
+
+    public double getRemoteDataRatio() {
+        return remoteDataRatio;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCachedIndexInput.java b/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCachedIndexInput.java
index 7d7c40be3a833..ab6f5f931da0f 100644
--- a/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCachedIndexInput.java
+++ b/server/src/main/java/org/opensearch/index/store/remote/filecache/FileCachedIndexInput.java
@@ -39,9 +39,9 @@ public class FileCachedIndexInput extends IndexInput implements RandomAccessInpu
     protected IndexInput luceneIndexInput;
 
     /** indicates if this IndexInput instance is a clone or not */
-    private final boolean isClone;
+    protected final boolean isClone;
 
-    private volatile boolean closed = false;
+    protected volatile boolean closed = false;
 
     public FileCachedIndexInput(FileCache cache, Path filePath, IndexInput underlyingIndexInput) {
         this(cache, filePath, underlyingIndexInput, false);
diff --git a/server/src/main/java/org/opensearch/index/store/remote/filecache/FullFileCachedIndexInput.java b/server/src/main/java/org/opensearch/index/store/remote/filecache/FullFileCachedIndexInput.java
new file mode 100644
index 0000000000000..9383c53d6d830
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/store/remote/filecache/FullFileCachedIndexInput.java
@@ -0,0 +1,108 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.filecache;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.store.AlreadyClosedException;
+import org.apache.lucene.store.IndexInput;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Extension of {@link FileCachedIndexInput} for full files for handling clones and slices
+ * We maintain a clone map so that we can close them when the parent IndexInput is closed so that ref count is properly maintained in file cache
+ * Closing of clones explicitly is needed as Lucene does not guarantee that it will close the clones
+ * https://github.com/apache/lucene/blob/8340b01c3cc229f33584ce2178b07b8984daa6a9/lucene/core/src/java/org/apache/lucene/store/IndexInput.java#L32-L33
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class FullFileCachedIndexInput extends FileCachedIndexInput {
+    private static final Logger logger = LogManager.getLogger(FullFileCachedIndexInput.class);
+    private final Set<FullFileCachedIndexInput> clones;
+
+    public FullFileCachedIndexInput(FileCache cache, Path filePath, IndexInput underlyingIndexInput) {
+        this(cache, filePath, underlyingIndexInput, false);
+    }
+
+    public FullFileCachedIndexInput(FileCache cache, Path filePath, IndexInput underlyingIndexInput, boolean isClone) {
+        super(cache, filePath, underlyingIndexInput, isClone);
+        clones = new HashSet<>();
+    }
+
+    /**
+     * Clones the index input and returns the clone
+     * Increase the ref count whenever the index input is cloned and add it to the clone map as well
+     */
+    @Override
+    public FullFileCachedIndexInput clone() {
+        FullFileCachedIndexInput clonedIndexInput = new FullFileCachedIndexInput(cache, filePath, luceneIndexInput.clone(), true);
+        cache.incRef(filePath);
+        clones.add(clonedIndexInput);
+        return clonedIndexInput;
+    }
+
+    /**
+     * Clones the index input and returns the slice
+     * Increase the ref count whenever the index input is sliced and add it to the clone map as well
+     */
+    @Override
+    public IndexInput slice(String sliceDescription, long offset, long length) throws IOException {
+        if (offset < 0 || length < 0 || offset + length > this.length()) {
+            throw new IllegalArgumentException(
+                "slice() "
+                    + sliceDescription
+                    + " out of bounds: offset="
+                    + offset
+                    + ",length="
+                    + length
+                    + ",fileLength="
+                    + this.length()
+                    + ": "
+                    + this
+            );
+        }
+        IndexInput slicedLuceneIndexInput = luceneIndexInput.slice(sliceDescription, offset, length);
+        FullFileCachedIndexInput slicedIndexInput = new FullFileCachedIndexInput(cache, filePath, slicedLuceneIndexInput, true);
+        clones.add(slicedIndexInput);
+        cache.incRef(filePath);
+        return slicedIndexInput;
+    }
+
+    /**
+     * Closes the index input and it's clones as well
+     */
+    @Override
+    public void close() throws IOException {
+        if (!closed) {
+            if (isClone) {
+                cache.decRef(filePath);
+            }
+            clones.forEach(indexInput -> {
+                try {
+                    indexInput.close();
+                } catch (Exception e) {
+                    logger.trace("Exception while closing clone - {}", e.getMessage());
+                }
+            });
+            try {
+                luceneIndexInput.close();
+            } catch (AlreadyClosedException e) {
+                logger.trace("FullFileCachedIndexInput already closed");
+            }
+            luceneIndexInput = null;
+            clones.clear();
+            closed = true;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/store/remote/utils/BlockIOContext.java b/server/src/main/java/org/opensearch/index/store/remote/utils/BlockIOContext.java
new file mode 100644
index 0000000000000..a78dd85d6f194
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/store/remote/utils/BlockIOContext.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.utils;
+
+import org.apache.lucene.store.IOContext;
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * BlockIOContext is an extension of IOContext which can be used to pass block related information to the openInput() method of any directory
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class BlockIOContext extends IOContext {
+
+    private long blockStart;
+    private long blockSize;
+
+    /**
+     * Constructor to initialise BlockIOContext with block related information
+     */
+    public BlockIOContext(IOContext ctx, long blockStart, long blockSize) {
+        super(ctx.context);
+        verifyBlockStartAndSize(blockStart, blockSize);
+        this.blockStart = blockStart;
+        this.blockSize = blockSize;
+    }
+
+    /**
+     * Getter for blockStart
+     */
+    public long getBlockStart() {
+        return blockStart;
+    }
+
+    /**
+     * Getter for blockSize
+     */
+    public long getBlockSize() {
+        return blockSize;
+    }
+
+    private void verifyBlockStartAndSize(long blockStart, long blockSize) {
+        if (blockStart < 0) throw new IllegalArgumentException("blockStart must be greater than or equal to 0");
+        if (blockSize <= 0) throw new IllegalArgumentException(("blockSize must be greater than 0"));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/store/remote/utils/FileTypeUtils.java b/server/src/main/java/org/opensearch/index/store/remote/utils/FileTypeUtils.java
new file mode 100644
index 0000000000000..e78480bd500ee
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/store/remote/utils/FileTypeUtils.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.utils;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+/**
+ * Utility class for checking file types
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public class FileTypeUtils {
+
+    public static boolean isTempFile(String name) {
+        return name.endsWith(".tmp");
+    }
+
+    public static boolean isBlockFile(String name) {
+        return name.contains("_block_");
+    }
+
+    public static boolean isExtraFSFile(String name) {
+        return name.startsWith("extra");
+    }
+
+    public static boolean isLockFile(String name) {
+        return name.endsWith(".lock");
+    }
+
+    public static boolean isSegmentsFile(String name) {
+        return name.startsWith("segments_");
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/store/remote/utils/TransferManager.java b/server/src/main/java/org/opensearch/index/store/remote/utils/TransferManager.java
index 98cad7bfadb09..f07c4832d982c 100644
--- a/server/src/main/java/org/opensearch/index/store/remote/utils/TransferManager.java
+++ b/server/src/main/java/org/opensearch/index/store/remote/utils/TransferManager.java
@@ -12,7 +12,6 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.store.IOContext;
 import org.apache.lucene.store.IndexInput;
-import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.index.store.remote.filecache.CachedIndexInput;
 import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.index.store.remote.filecache.FileCachedIndexInput;
@@ -39,11 +38,19 @@
 public class TransferManager {
     private static final Logger logger = LogManager.getLogger(TransferManager.class);
 
-    private final BlobContainer blobContainer;
+    /**
+     * Functional interface to get an InputStream for a file at a certain offset and size
+     */
+    @FunctionalInterface
+    public interface StreamReader {
+        InputStream read(String name, long position, long length) throws IOException;
+    }
+
+    private final StreamReader streamReader;
     private final FileCache fileCache;
 
-    public TransferManager(final BlobContainer blobContainer, final FileCache fileCache) {
-        this.blobContainer = blobContainer;
+    public TransferManager(final StreamReader streamReader, final FileCache fileCache) {
+        this.streamReader = streamReader;
         this.fileCache = fileCache;
     }
 
@@ -55,15 +62,24 @@ public TransferManager(final BlobContainer blobContainer, final FileCache fileCa
     public IndexInput fetchBlob(BlobFetchRequest blobFetchRequest) throws IOException {
 
         final Path key = blobFetchRequest.getFilePath();
+        logger.trace("fetchBlob called for {}", key.toString());
 
-        final CachedIndexInput cacheEntry = fileCache.compute(key, (path, cachedIndexInput) -> {
-            if (cachedIndexInput == null || cachedIndexInput.isClosed()) {
-                // Doesn't exist or is closed, either way create a new one
-                return new DelayedCreationCachedIndexInput(fileCache, blobContainer, blobFetchRequest);
-            } else {
-                // already in the cache and ready to be used (open)
-                return cachedIndexInput;
-            }
+        // We need to do a privileged action here in order to fetch from remote
+        // and write/evict from local file cache in case this is invoked as a side
+        // effect of a plugin (such as a scripted search) that doesn't have the
+        // necessary permissions.
+        final CachedIndexInput cacheEntry = AccessController.doPrivileged((PrivilegedAction<CachedIndexInput>) () -> {
+            return fileCache.compute(key, (path, cachedIndexInput) -> {
+                if (cachedIndexInput == null || cachedIndexInput.isClosed()) {
+                    logger.trace("Transfer Manager - IndexInput closed or not in cache");
+                    // Doesn't exist or is closed, either way create a new one
+                    return new DelayedCreationCachedIndexInput(fileCache, streamReader, blobFetchRequest);
+                } else {
+                    logger.trace("Transfer Manager - Already in cache");
+                    // already in the cache and ready to be used (open)
+                    return cachedIndexInput;
+                }
+            });
         });
 
         // Cache entry was either retrieved from the cache or newly added, either
@@ -77,37 +93,32 @@ public IndexInput fetchBlob(BlobFetchRequest blobFetchRequest) throws IOExceptio
     }
 
     @SuppressWarnings("removal")
-    private static FileCachedIndexInput createIndexInput(FileCache fileCache, BlobContainer blobContainer, BlobFetchRequest request) {
-        // We need to do a privileged action here in order to fetch from remote
-        // and write to the local file cache in case this is invoked as a side
-        // effect of a plugin (such as a scripted search) that doesn't have the
-        // necessary permissions.
-        return AccessController.doPrivileged((PrivilegedAction<FileCachedIndexInput>) () -> {
-            try {
-                if (Files.exists(request.getFilePath()) == false) {
-                    try (
-                        OutputStream fileOutputStream = Files.newOutputStream(request.getFilePath());
-                        OutputStream localFileOutputStream = new BufferedOutputStream(fileOutputStream)
-                    ) {
-                        for (BlobFetchRequest.BlobPart blobPart : request.blobParts()) {
-                            try (
-                                InputStream snapshotFileInputStream = blobContainer.readBlob(
-                                    blobPart.getBlobName(),
-                                    blobPart.getPosition(),
-                                    blobPart.getLength()
-                                );
-                            ) {
-                                snapshotFileInputStream.transferTo(localFileOutputStream);
-                            }
+    private static FileCachedIndexInput createIndexInput(FileCache fileCache, StreamReader streamReader, BlobFetchRequest request) {
+        try {
+            if (Files.exists(request.getFilePath()) == false) {
+                logger.trace("Fetching from Remote in createIndexInput of Transfer Manager");
+                try (
+                    OutputStream fileOutputStream = Files.newOutputStream(request.getFilePath());
+                    OutputStream localFileOutputStream = new BufferedOutputStream(fileOutputStream)
+                ) {
+                    for (BlobFetchRequest.BlobPart blobPart : request.blobParts()) {
+                        try (
+                            InputStream snapshotFileInputStream = streamReader.read(
+                                blobPart.getBlobName(),
+                                blobPart.getPosition(),
+                                blobPart.getLength()
+                            );
+                        ) {
+                            snapshotFileInputStream.transferTo(localFileOutputStream);
                         }
                     }
                 }
-                final IndexInput luceneIndexInput = request.getDirectory().openInput(request.getFileName(), IOContext.READ);
-                return new FileCachedIndexInput(fileCache, request.getFilePath(), luceneIndexInput);
-            } catch (IOException e) {
-                throw new UncheckedIOException(e);
             }
-        });
+            final IndexInput luceneIndexInput = request.getDirectory().openInput(request.getFileName(), IOContext.READ);
+            return new FileCachedIndexInput(fileCache, request.getFilePath(), luceneIndexInput);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
     }
 
     /**
@@ -119,15 +130,15 @@ private static FileCachedIndexInput createIndexInput(FileCache fileCache, BlobCo
      */
     private static class DelayedCreationCachedIndexInput implements CachedIndexInput {
         private final FileCache fileCache;
-        private final BlobContainer blobContainer;
+        private final StreamReader streamReader;
         private final BlobFetchRequest request;
         private final CompletableFuture<IndexInput> result = new CompletableFuture<>();
         private final AtomicBoolean isStarted = new AtomicBoolean(false);
         private final AtomicBoolean isClosed = new AtomicBoolean(false);
 
-        private DelayedCreationCachedIndexInput(FileCache fileCache, BlobContainer blobContainer, BlobFetchRequest request) {
+        private DelayedCreationCachedIndexInput(FileCache fileCache, StreamReader streamReader, BlobFetchRequest request) {
             this.fileCache = fileCache;
-            this.blobContainer = blobContainer;
+            this.streamReader = streamReader;
             this.request = request;
         }
 
@@ -139,7 +150,7 @@ public IndexInput getIndexInput() throws IOException {
             if (isStarted.getAndSet(true) == false) {
                 // We're the first one here, need to download the block
                 try {
-                    result.complete(createIndexInput(fileCache, blobContainer, request));
+                    result.complete(createIndexInput(fileCache, streamReader, request));
                 } catch (Exception e) {
                     result.completeExceptionally(e);
                     fileCache.remove(request.getFilePath());
diff --git a/server/src/main/java/org/opensearch/index/store/remote/utils/cache/LRUCache.java b/server/src/main/java/org/opensearch/index/store/remote/utils/cache/LRUCache.java
index 03d03711f914a..7f7d42e8fbce8 100644
--- a/server/src/main/java/org/opensearch/index/store/remote/utils/cache/LRUCache.java
+++ b/server/src/main/java/org/opensearch/index/store/remote/utils/cache/LRUCache.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.index.store.remote.utils.cache;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.opensearch.common.cache.RemovalListener;
 import org.opensearch.common.cache.RemovalNotification;
 import org.opensearch.common.cache.RemovalReason;
@@ -19,6 +21,7 @@
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.BiFunction;
@@ -43,6 +46,7 @@
  * @opensearch.internal
  */
 class LRUCache<K, V> implements RefCountedCache<K, V> {
+    private static final Logger logger = LogManager.getLogger(LRUCache.class);
     private final long capacity;
 
     private final HashMap<K, Node<K, V>> data;
@@ -192,8 +196,10 @@ public void clear() {
             usage = 0L;
             activeUsage = 0L;
             lru.clear();
-            for (Node<K, V> node : data.values()) {
-                data.remove(node.key);
+            final Iterator<Node<K, V>> iterator = data.values().iterator();
+            while (iterator.hasNext()) {
+                Node<K, V> node = iterator.next();
+                iterator.remove();
                 statsCounter.recordRemoval(node.weight);
                 listener.onRemoval(new RemovalNotification<>(node.key, node.value, RemovalReason.EXPLICIT));
             }
@@ -300,6 +306,22 @@ public CacheStats stats() {
         }
     }
 
+    // To be used only for debugging purposes
+    public void logCurrentState() {
+        lock.lock();
+        try {
+            String allFiles = "\n";
+            for (Map.Entry<K, Node<K, V>> entry : data.entrySet()) {
+                String path = entry.getKey().toString();
+                String file = path.substring(path.lastIndexOf('/'));
+                allFiles += file + " [RefCount: " + entry.getValue().refCount + " , Weight: " + entry.getValue().weight + " ]\n";
+            }
+            logger.trace("Cache entries : " + allFiles);
+        } finally {
+            lock.unlock();
+        }
+    }
+
     private void addNode(K key, V value) {
         final long weight = weigher.weightOf(value);
         Node<K, V> newNode = new Node<>(key, value, weight);
diff --git a/server/src/main/java/org/opensearch/index/store/remote/utils/cache/SegmentedCache.java b/server/src/main/java/org/opensearch/index/store/remote/utils/cache/SegmentedCache.java
index d3eb03df37e1b..9ff6ddb1fb667 100644
--- a/server/src/main/java/org/opensearch/index/store/remote/utils/cache/SegmentedCache.java
+++ b/server/src/main/java/org/opensearch/index/store/remote/utils/cache/SegmentedCache.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.index.store.remote.utils.cache;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.opensearch.common.cache.RemovalListener;
 import org.opensearch.common.cache.RemovalNotification;
 import org.opensearch.common.cache.Weigher;
@@ -25,6 +27,7 @@
  * @opensearch.internal
  */
 public class SegmentedCache<K, V> implements RefCountedCache<K, V> {
+    private static final Logger logger = LogManager.getLogger(SegmentedCache.class);
 
     private static final int HASH_BITS = 0x7fffffff;
 
@@ -49,15 +52,15 @@ private static final int ceilingNextPowerOfTwo(int x) {
     private final Weigher<V> weigher;
 
     public SegmentedCache(Builder<K, V> builder) {
-        this.capacity = builder.capacity;
         final int segments = ceilingNextPowerOfTwo(builder.concurrencyLevel);
         this.segmentMask = segments - 1;
         this.table = newSegmentArray(segments);
-        this.perSegmentCapacity = (capacity + (segments - 1)) / segments;
+        this.perSegmentCapacity = (builder.capacity + (segments - 1)) / segments;
         this.weigher = builder.weigher;
         for (int i = 0; i < table.length; i++) {
             table[i] = new LRUCache<>(perSegmentCapacity, builder.listener, builder.weigher);
         }
+        this.capacity = perSegmentCapacity * segments;
     }
 
     @SuppressWarnings("unchecked")
@@ -183,6 +186,16 @@ public CacheStats stats() {
         return new CacheStats(hitCount, missCount, removeCount, removeWeight, replaceCount, evictionCount, evictionWeight);
     }
 
+    // To be used only for debugging purposes
+    public void logCurrentState() {
+        int i = 0;
+        for (RefCountedCache<K, V> cache : table) {
+            logger.trace("SegmentedCache " + i);
+            ((LRUCache<K, V>) cache).logCurrentState();
+            i++;
+        }
+    }
+
     enum SingletonWeigher implements Weigher<Object> {
         INSTANCE;
 
diff --git a/server/src/main/java/org/opensearch/index/translog/BufferedChecksumStreamOutput.java b/server/src/main/java/org/opensearch/index/translog/BufferedChecksumStreamOutput.java
index 9e96664c79cc5..9d52cf18d47a3 100644
--- a/server/src/main/java/org/opensearch/index/translog/BufferedChecksumStreamOutput.java
+++ b/server/src/main/java/org/opensearch/index/translog/BufferedChecksumStreamOutput.java
@@ -33,10 +33,20 @@
 package org.opensearch.index.translog;
 
 import org.apache.lucene.store.BufferedChecksum;
+import org.opensearch.common.Nullable;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
 import java.util.zip.CRC32;
 import java.util.zip.Checksum;
 
@@ -91,4 +101,75 @@ public void reset() throws IOException {
     public void resetDigest() {
         digest.reset();
     }
+
+    @Override
+    public void writeMap(@Nullable Map<String, Object> map) throws IOException {
+        Map<String, Object> newMap = new TreeMap<>(map);
+        writeGenericValue(newMap);
+    }
+
+    @Override
+    public <K, V> void writeMap(Map<K, V> map, final Writeable.Writer<K> keyWriter, final Writeable.Writer<V> valueWriter)
+        throws IOException {
+        writeVInt(map.size());
+        map.keySet().stream().sorted().forEachOrdered(key -> {
+            try {
+                keyWriter.write(this, key);
+                valueWriter.write(this, map.get(key));
+            } catch (IOException e) {
+                throw new RuntimeException("Failed to write map values.", e);
+            }
+        });
+    }
+
+    public <K, V> void writeMapValues(Map<K, V> map, final Writeable.Writer<V> valueWriter) throws IOException {
+        writeVInt(map.size());
+        map.keySet().stream().sorted().forEachOrdered(key -> {
+            try {
+                valueWriter.write(this, map.get(key));
+            } catch (IOException e) {
+                throw new RuntimeException("Failed to write map values.", e);
+            }
+        });
+    }
+
+    @Override
+    public void writeStringArray(String[] array) throws IOException {
+        String[] copyArray = Arrays.copyOf(array, array.length);
+        Arrays.sort(copyArray);
+        super.writeStringArray(copyArray);
+    }
+
+    @Override
+    public void writeVLongArray(long[] values) throws IOException {
+        long[] copyValues = Arrays.copyOf(values, values.length);
+        Arrays.sort(copyValues);
+        super.writeVLongArray(copyValues);
+    }
+
+    @Override
+    public void writeCollection(final Collection<? extends Writeable> collection) throws IOException {
+        List<? extends Writeable> sortedList = collection.stream().sorted().collect(Collectors.toList());
+        super.writeCollection(sortedList, (o, v) -> v.writeTo(o));
+    }
+
+    @Override
+    public void writeStringCollection(final Collection<String> collection) throws IOException {
+        List<String> listCollection = new ArrayList<>(collection);
+        Collections.sort(listCollection);
+        writeCollection(listCollection, StreamOutput::writeString);
+    }
+
+    @Override
+    public void writeOptionalStringCollection(final Collection<String> collection) throws IOException {
+        if (collection != null) {
+            List<String> listCollection = new ArrayList<>(collection);
+            Collections.sort(listCollection);
+            writeBoolean(true);
+            writeCollection(listCollection, StreamOutput::writeString);
+        } else {
+            writeBoolean(false);
+        }
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java b/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
index 4599aa32325c1..5dc2ad076d21c 100644
--- a/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteBlobStoreInternalTranslogFactory.java
@@ -69,19 +69,35 @@ public Translog newTranslog(
 
         assert repository instanceof BlobStoreRepository : "repository should be instance of BlobStoreRepository";
         BlobStoreRepository blobStoreRepository = ((BlobStoreRepository) repository);
-        return new RemoteFsTranslog(
-            config,
-            translogUUID,
-            deletionPolicy,
-            globalCheckpointSupplier,
-            primaryTermSupplier,
-            persistedSequenceNumberConsumer,
-            blobStoreRepository,
-            threadPool,
-            startedPrimarySupplier,
-            remoteTranslogTransferTracker,
-            remoteStoreSettings
-        );
+        if (RemoteStoreSettings.isPinnedTimestampsEnabled()) {
+            return new RemoteFsTimestampAwareTranslog(
+                config,
+                translogUUID,
+                deletionPolicy,
+                globalCheckpointSupplier,
+                primaryTermSupplier,
+                persistedSequenceNumberConsumer,
+                blobStoreRepository,
+                threadPool,
+                startedPrimarySupplier,
+                remoteTranslogTransferTracker,
+                remoteStoreSettings
+            );
+        } else {
+            return new RemoteFsTranslog(
+                config,
+                translogUUID,
+                deletionPolicy,
+                globalCheckpointSupplier,
+                primaryTermSupplier,
+                persistedSequenceNumberConsumer,
+                blobStoreRepository,
+                threadPool,
+                startedPrimarySupplier,
+                remoteTranslogTransferTracker,
+                remoteStoreSettings
+            );
+        }
     }
 
     public Repository getRepository() {
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java b/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java
new file mode 100644
index 0000000000000..0b134b3bddbec
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslog.java
@@ -0,0 +1,377 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.translog;
+
+import org.apache.logging.log4j.Logger;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.blobstore.BlobMetadata;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.logging.Loggers;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.remote.RemoteTranslogTransferTracker;
+import org.opensearch.index.translog.transfer.TranslogTransferManager;
+import org.opensearch.index.translog.transfer.TranslogTransferMetadata;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.function.BooleanSupplier;
+import java.util.function.LongConsumer;
+import java.util.function.LongSupplier;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+import static org.opensearch.index.translog.transfer.TranslogTransferMetadata.METADATA_SEPARATOR;
+
+/**
+ * A Translog implementation which syncs local FS with a remote store
+ * The current impl uploads translog , ckp and metadata to remote store
+ * for every sync, post syncing to disk. Post that, a new generation is
+ * created. This implementation is also aware of pinned timestamp and makes
+ * sure data against pinned timestamp is retained.
+ *
+ * @opensearch.internal
+ */
+public class RemoteFsTimestampAwareTranslog extends RemoteFsTranslog {
+
+    private final Logger logger;
+    private final Map<Long, String> metadataFilePinnedTimestampMap;
+    // For metadata files, with no min generation in the name, we cache generation data to avoid multiple reads.
+    private final Map<String, Tuple<Long, Long>> oldFormatMetadataFileGenerationMap;
+
+    public RemoteFsTimestampAwareTranslog(
+        TranslogConfig config,
+        String translogUUID,
+        TranslogDeletionPolicy deletionPolicy,
+        LongSupplier globalCheckpointSupplier,
+        LongSupplier primaryTermSupplier,
+        LongConsumer persistedSequenceNumberConsumer,
+        BlobStoreRepository blobStoreRepository,
+        ThreadPool threadPool,
+        BooleanSupplier startedPrimarySupplier,
+        RemoteTranslogTransferTracker remoteTranslogTransferTracker,
+        RemoteStoreSettings remoteStoreSettings
+    ) throws IOException {
+        super(
+            config,
+            translogUUID,
+            deletionPolicy,
+            globalCheckpointSupplier,
+            primaryTermSupplier,
+            persistedSequenceNumberConsumer,
+            blobStoreRepository,
+            threadPool,
+            startedPrimarySupplier,
+            remoteTranslogTransferTracker,
+            remoteStoreSettings
+        );
+        logger = Loggers.getLogger(getClass(), shardId);
+        this.metadataFilePinnedTimestampMap = new HashMap<>();
+        this.oldFormatMetadataFileGenerationMap = new HashMap<>();
+    }
+
+    @Override
+    protected void onDelete() {
+        ClusterService.assertClusterOrClusterManagerStateThread();
+        // clean up all remote translog files
+        try {
+            trimUnreferencedReaders(true, false);
+        } catch (IOException e) {
+            logger.error("Exception while deleting translog files from remote store", e);
+        }
+    }
+
+    @Override
+    public void trimUnreferencedReaders() throws IOException {
+        trimUnreferencedReaders(false, true);
+    }
+
+    // Visible for testing
+    protected void trimUnreferencedReaders(boolean indexDeleted, boolean trimLocal) throws IOException {
+        if (trimLocal) {
+            // clean up local translog files and updates readers
+            super.trimUnreferencedReaders();
+        }
+
+        // Update file tracker to reflect local translog state
+        Optional<Long> minLiveGeneration = readers.stream().map(BaseTranslogReader::getGeneration).min(Long::compareTo);
+        if (minLiveGeneration.isPresent()) {
+            List<String> staleFilesInTracker = new ArrayList<>();
+            for (String file : fileTransferTracker.allUploaded()) {
+                if (file.endsWith(TRANSLOG_FILE_SUFFIX)) {
+                    long generation = Translog.parseIdFromFileName(file);
+                    if (generation < minLiveGeneration.get()) {
+                        staleFilesInTracker.add(file);
+                        staleFilesInTracker.add(Translog.getCommitCheckpointFileName(generation));
+                    }
+                }
+                fileTransferTracker.delete(staleFilesInTracker);
+            }
+        }
+
+        // This is to ensure that after the permits are acquired during primary relocation, there are no further modification on remote
+        // store.
+        if (startedPrimarySupplier.getAsBoolean() == false || pauseSync.get()) {
+            return;
+        }
+
+        // This is to fail fast and avoid listing md files un-necessarily.
+        if (indexDeleted == false && RemoteStoreUtils.isPinnedTimestampStateStale()) {
+            logger.warn("Skipping remote segment store garbage collection as last fetch of pinned timestamp is stale");
+            return;
+        }
+
+        // Since remote generation deletion is async, this ensures that only one generation deletion happens at a time.
+        // Remote generations involves 2 async operations - 1) Delete translog generation files 2) Delete metadata files
+        // We try to acquire 2 permits and if we can not, we return from here itself.
+        if (remoteGenerationDeletionPermits.tryAcquire(REMOTE_DELETION_PERMITS) == false) {
+            return;
+        }
+
+        ActionListener<List<BlobMetadata>> listMetadataFilesListener = new ActionListener<>() {
+            @Override
+            public void onResponse(List<BlobMetadata> blobMetadata) {
+                List<String> metadataFiles = blobMetadata.stream().map(BlobMetadata::name).collect(Collectors.toList());
+
+                try {
+                    if (metadataFiles.size() <= 1) {
+                        logger.debug("No stale translog metadata files found");
+                        remoteGenerationDeletionPermits.release(REMOTE_DELETION_PERMITS);
+                        return;
+                    }
+
+                    // Check last fetch status of pinned timestamps. If stale, return.
+                    if (indexDeleted == false && RemoteStoreUtils.isPinnedTimestampStateStale()) {
+                        logger.warn("Skipping remote segment store garbage collection as last fetch of pinned timestamp is stale");
+                        remoteGenerationDeletionPermits.release(REMOTE_DELETION_PERMITS);
+                        return;
+                    }
+
+                    List<String> metadataFilesToBeDeleted = getMetadataFilesToBeDeleted(metadataFiles);
+
+                    // If index is not deleted, make sure to keep latest metadata file
+                    if (indexDeleted == false) {
+                        metadataFilesToBeDeleted.remove(metadataFiles.get(0));
+                    }
+
+                    if (metadataFilesToBeDeleted.isEmpty()) {
+                        logger.debug("No metadata files to delete");
+                        remoteGenerationDeletionPermits.release(REMOTE_DELETION_PERMITS);
+                        return;
+                    }
+
+                    logger.debug(() -> "metadataFilesToBeDeleted = " + metadataFilesToBeDeleted);
+                    // For all the files that we are keeping, fetch min and max generations
+                    List<String> metadataFilesNotToBeDeleted = new ArrayList<>(metadataFiles);
+                    metadataFilesNotToBeDeleted.removeAll(metadataFilesToBeDeleted);
+
+                    logger.debug(() -> "metadataFilesNotToBeDeleted = " + metadataFilesNotToBeDeleted);
+                    Set<Long> generationsToBeDeleted = getGenerationsToBeDeleted(
+                        metadataFilesNotToBeDeleted,
+                        metadataFilesToBeDeleted,
+                        indexDeleted
+                    );
+
+                    logger.debug(() -> "generationsToBeDeleted = " + generationsToBeDeleted);
+                    if (generationsToBeDeleted.isEmpty() == false) {
+                        // Delete stale generations
+                        translogTransferManager.deleteGenerationAsync(
+                            primaryTermSupplier.getAsLong(),
+                            generationsToBeDeleted,
+                            remoteGenerationDeletionPermits::release
+                        );
+
+                        // Delete stale metadata files
+                        translogTransferManager.deleteMetadataFilesAsync(
+                            metadataFilesToBeDeleted,
+                            remoteGenerationDeletionPermits::release
+                        );
+
+                        // Update cache to keep only those metadata files that are not getting deleted
+                        oldFormatMetadataFileGenerationMap.keySet().retainAll(metadataFilesNotToBeDeleted);
+
+                        // Delete stale primary terms
+                        deleteStaleRemotePrimaryTerms(metadataFiles);
+                    } else {
+                        remoteGenerationDeletionPermits.release(REMOTE_DELETION_PERMITS);
+                    }
+                } catch (Exception e) {
+                    remoteGenerationDeletionPermits.release(REMOTE_DELETION_PERMITS);
+                }
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                remoteGenerationDeletionPermits.release(REMOTE_DELETION_PERMITS);
+                logger.error("Exception while listing translog metadata files", e);
+            }
+        };
+        translogTransferManager.listTranslogMetadataFilesAsync(listMetadataFilesListener);
+    }
+
+    // Visible for testing
+    protected Set<Long> getGenerationsToBeDeleted(
+        List<String> metadataFilesNotToBeDeleted,
+        List<String> metadataFilesToBeDeleted,
+        boolean indexDeleted
+    ) throws IOException {
+        long maxGenerationToBeDeleted = Long.MAX_VALUE;
+
+        if (indexDeleted == false) {
+            maxGenerationToBeDeleted = minRemoteGenReferenced - 1 - indexSettings().getRemoteTranslogExtraKeep();
+        }
+
+        Set<Long> generationsFromMetadataFilesToBeDeleted = new HashSet<>();
+        for (String mdFile : metadataFilesToBeDeleted) {
+            Tuple<Long, Long> minMaxGen = getMinMaxTranslogGenerationFromMetadataFile(mdFile, translogTransferManager);
+            generationsFromMetadataFilesToBeDeleted.addAll(
+                LongStream.rangeClosed(minMaxGen.v1(), minMaxGen.v2()).boxed().collect(Collectors.toList())
+            );
+        }
+
+        Map<String, Tuple<Long, Long>> metadataFileNotToBeDeletedGenerationMap = getGenerationForMetadataFiles(metadataFilesNotToBeDeleted);
+        TreeSet<Tuple<Long, Long>> pinnedGenerations = getOrderedPinnedMetadataGenerations(metadataFileNotToBeDeletedGenerationMap);
+        Set<Long> generationsToBeDeleted = new HashSet<>();
+        for (long generation : generationsFromMetadataFilesToBeDeleted) {
+            // Check if the generation is not referred by metadata file matching pinned timestamps
+            if (generation <= maxGenerationToBeDeleted && isGenerationPinned(generation, pinnedGenerations) == false) {
+                generationsToBeDeleted.add(generation);
+            }
+        }
+        return generationsToBeDeleted;
+    }
+
+    // Visible for testing
+    protected List<String> getMetadataFilesToBeDeleted(List<String> metadataFiles) {
+        Tuple<Long, Set<Long>> pinnedTimestampsState = RemoteStorePinnedTimestampService.getPinnedTimestamps();
+
+        // Keep files since last successful run of scheduler
+        List<String> metadataFilesToBeDeleted = RemoteStoreUtils.filterOutMetadataFilesBasedOnAge(
+            metadataFiles,
+            file -> RemoteStoreUtils.invertLong(file.split(METADATA_SEPARATOR)[3]),
+            pinnedTimestampsState.v1()
+        );
+
+        logger.trace(
+            "metadataFiles.size = {}, metadataFilesToBeDeleted based on age based filtering = {}",
+            metadataFiles.size(),
+            metadataFilesToBeDeleted.size()
+        );
+
+        // Get md files matching pinned timestamps
+        Set<String> implicitLockedFiles = RemoteStoreUtils.getPinnedTimestampLockedFiles(
+            metadataFilesToBeDeleted,
+            pinnedTimestampsState.v2(),
+            metadataFilePinnedTimestampMap,
+            file -> RemoteStoreUtils.invertLong(file.split(METADATA_SEPARATOR)[3]),
+            TranslogTransferMetadata::getNodeIdByPrimaryTermAndGen
+        );
+
+        // Filter out metadata files matching pinned timestamps
+        metadataFilesToBeDeleted.removeAll(implicitLockedFiles);
+
+        logger.trace(
+            "implicitLockedFiles.size = {}, metadataFilesToBeDeleted based on pinned timestamp filtering = {}",
+            implicitLockedFiles.size(),
+            metadataFilesToBeDeleted.size()
+        );
+
+        return metadataFilesToBeDeleted;
+    }
+
+    // Visible for testing
+    protected boolean isGenerationPinned(long generation, TreeSet<Tuple<Long, Long>> pinnedGenerations) {
+        Tuple<Long, Long> ceilingGenerationRange = pinnedGenerations.ceiling(new Tuple<>(generation, generation));
+        if (ceilingGenerationRange != null && generation >= ceilingGenerationRange.v1() && generation <= ceilingGenerationRange.v2()) {
+            return true;
+        }
+        Tuple<Long, Long> floorGenerationRange = pinnedGenerations.floor(new Tuple<>(generation, generation));
+        if (floorGenerationRange != null && generation >= floorGenerationRange.v1() && generation <= floorGenerationRange.v2()) {
+            return true;
+        }
+        return false;
+    }
+
+    private TreeSet<Tuple<Long, Long>> getOrderedPinnedMetadataGenerations(Map<String, Tuple<Long, Long>> metadataFileGenerationMap) {
+        TreeSet<Tuple<Long, Long>> pinnedGenerations = new TreeSet<>((o1, o2) -> {
+            if (Objects.equals(o1.v1(), o2.v1()) == false) {
+                return o1.v1().compareTo(o2.v1());
+            } else {
+                return o1.v2().compareTo(o2.v2());
+            }
+        });
+        pinnedGenerations.addAll(metadataFileGenerationMap.values());
+        return pinnedGenerations;
+    }
+
+    // Visible for testing
+    protected Map<String, Tuple<Long, Long>> getGenerationForMetadataFiles(List<String> metadataFiles) throws IOException {
+        Map<String, Tuple<Long, Long>> metadataFileGenerationMap = new HashMap<>();
+        for (String metadataFile : metadataFiles) {
+            metadataFileGenerationMap.put(metadataFile, getMinMaxTranslogGenerationFromMetadataFile(metadataFile, translogTransferManager));
+        }
+        return metadataFileGenerationMap;
+    }
+
+    // Visible for testing
+    protected Tuple<Long, Long> getMinMaxTranslogGenerationFromMetadataFile(
+        String metadataFile,
+        TranslogTransferManager translogTransferManager
+    ) throws IOException {
+        Tuple<Long, Long> minMaxGenerationFromFileName = TranslogTransferMetadata.getMinMaxTranslogGenerationFromFilename(metadataFile);
+        if (minMaxGenerationFromFileName != null) {
+            return minMaxGenerationFromFileName;
+        } else {
+            if (oldFormatMetadataFileGenerationMap.containsKey(metadataFile)) {
+                return oldFormatMetadataFileGenerationMap.get(metadataFile);
+            } else {
+                TranslogTransferMetadata metadata = translogTransferManager.readMetadata(metadataFile);
+                Tuple<Long, Long> minMaxGenTuple = new Tuple<>(metadata.getMinTranslogGeneration(), metadata.getGeneration());
+                oldFormatMetadataFileGenerationMap.put(metadataFile, minMaxGenTuple);
+                return minMaxGenTuple;
+            }
+        }
+    }
+
+    /**
+     * This method must be called only after there are valid generations to delete in trimUnreferencedReaders as it ensures
+     * implicitly that minimum primary term in latest translog metadata in remote store is the current primary term.
+     * <br>
+     * This will also delete all stale translog metadata files from remote except the latest basis the metadata file comparator.
+     */
+    private void deleteStaleRemotePrimaryTerms(List<String> metadataFiles) {
+        // The deletion of older translog files in remote store is on best-effort basis, there is a possibility that there
+        // are older files that are no longer needed and should be cleaned up. In here, we delete all files that are part
+        // of older primary term.
+        if (olderPrimaryCleaned.trySet(Boolean.TRUE)) {
+            if (metadataFiles.isEmpty()) {
+                logger.trace("No metadata is uploaded yet, returning from deleteStaleRemotePrimaryTerms");
+                return;
+            }
+            Optional<Long> minPrimaryTerm = metadataFiles.stream()
+                .map(file -> RemoteStoreUtils.invertLong(file.split(METADATA_SEPARATOR)[1]))
+                .min(Long::compareTo);
+            // First we delete all stale primary terms folders from remote store
+            long minimumReferencedPrimaryTerm = minPrimaryTerm.get() - 1;
+            translogTransferManager.deletePrimaryTermsAsync(minimumReferencedPrimaryTerm);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java b/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
index 67549c86b7dd2..71809b1f468cb 100644
--- a/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
+++ b/server/src/main/java/org/opensearch/index/translog/RemoteFsTranslog.java
@@ -67,30 +67,30 @@
 public class RemoteFsTranslog extends Translog {
 
     private final Logger logger;
-    private final TranslogTransferManager translogTransferManager;
-    private final FileTransferTracker fileTransferTracker;
-    private final BooleanSupplier startedPrimarySupplier;
+    protected final TranslogTransferManager translogTransferManager;
+    protected final FileTransferTracker fileTransferTracker;
+    protected final BooleanSupplier startedPrimarySupplier;
     private final RemoteTranslogTransferTracker remoteTranslogTransferTracker;
     private volatile long maxRemoteTranslogGenerationUploaded;
 
     private volatile long minSeqNoToKeep;
 
     // min generation referred by last uploaded translog
-    private volatile long minRemoteGenReferenced;
+    protected volatile long minRemoteGenReferenced;
 
     // clean up translog folder uploaded by previous primaries once
-    private final SetOnce<Boolean> olderPrimaryCleaned = new SetOnce<>();
+    protected final SetOnce<Boolean> olderPrimaryCleaned = new SetOnce<>();
 
-    private static final int REMOTE_DELETION_PERMITS = 2;
+    protected static final int REMOTE_DELETION_PERMITS = 2;
     private static final int DOWNLOAD_RETRIES = 2;
 
     // Semaphore used to allow only single remote generation to happen at a time
-    private final Semaphore remoteGenerationDeletionPermits = new Semaphore(REMOTE_DELETION_PERMITS);
+    protected final Semaphore remoteGenerationDeletionPermits = new Semaphore(REMOTE_DELETION_PERMITS);
 
     // These permits exist to allow any inflight background triggered upload.
     private static final int SYNC_PERMIT = 1;
     private final Semaphore syncPermit = new Semaphore(SYNC_PERMIT);
-    private final AtomicBoolean pauseSync = new AtomicBoolean(false);
+    protected final AtomicBoolean pauseSync = new AtomicBoolean(false);
     private final boolean isTranslogMetadataEnabled;
 
     public RemoteFsTranslog(
@@ -105,6 +105,36 @@ public RemoteFsTranslog(
         BooleanSupplier startedPrimarySupplier,
         RemoteTranslogTransferTracker remoteTranslogTransferTracker,
         RemoteStoreSettings remoteStoreSettings
+    ) throws IOException {
+        this(
+            config,
+            translogUUID,
+            deletionPolicy,
+            globalCheckpointSupplier,
+            primaryTermSupplier,
+            persistedSequenceNumberConsumer,
+            blobStoreRepository,
+            threadPool,
+            startedPrimarySupplier,
+            remoteTranslogTransferTracker,
+            remoteStoreSettings,
+            0
+        );
+    }
+
+    public RemoteFsTranslog(
+        TranslogConfig config,
+        String translogUUID,
+        TranslogDeletionPolicy deletionPolicy,
+        LongSupplier globalCheckpointSupplier,
+        LongSupplier primaryTermSupplier,
+        LongConsumer persistedSequenceNumberConsumer,
+        BlobStoreRepository blobStoreRepository,
+        ThreadPool threadPool,
+        BooleanSupplier startedPrimarySupplier,
+        RemoteTranslogTransferTracker remoteTranslogTransferTracker,
+        RemoteStoreSettings remoteStoreSettings,
+        long timestamp
     ) throws IOException {
         super(config, translogUUID, deletionPolicy, globalCheckpointSupplier, primaryTermSupplier, persistedSequenceNumberConsumer);
         logger = Loggers.getLogger(getClass(), shardId);
@@ -123,7 +153,7 @@ public RemoteFsTranslog(
             isTranslogMetadataEnabled
         );
         try {
-            download(translogTransferManager, location, logger, config.shouldSeedRemote());
+            download(translogTransferManager, location, logger, config.shouldSeedRemote(), timestamp);
             Checkpoint checkpoint = readCheckpoint(location);
             logger.info("Downloaded data from remote translog till maxSeqNo = {}", checkpoint.maxSeqNo);
             this.readers.addAll(recoverFromFiles(checkpoint));
@@ -174,6 +204,32 @@ public static void download(
         Logger logger,
         boolean seedRemote,
         boolean isTranslogMetadataEnabled
+    ) throws IOException {
+        download(
+            repository,
+            shardId,
+            threadPool,
+            location,
+            pathStrategy,
+            remoteStoreSettings,
+            logger,
+            seedRemote,
+            isTranslogMetadataEnabled,
+            0
+        );
+    }
+
+    public static void download(
+        Repository repository,
+        ShardId shardId,
+        ThreadPool threadPool,
+        Path location,
+        RemoteStorePathStrategy pathStrategy,
+        RemoteStoreSettings remoteStoreSettings,
+        Logger logger,
+        boolean seedRemote,
+        boolean isTranslogMetadataEnabled,
+        long timestamp
     ) throws IOException {
         assert repository instanceof BlobStoreRepository : String.format(
             Locale.ROOT,
@@ -195,11 +251,12 @@ public static void download(
             remoteStoreSettings,
             isTranslogMetadataEnabled
         );
-        RemoteFsTranslog.download(translogTransferManager, location, logger, seedRemote);
+        RemoteFsTranslog.download(translogTransferManager, location, logger, seedRemote, timestamp);
         logger.trace(remoteTranslogTransferTracker.toString());
     }
 
-    static void download(TranslogTransferManager translogTransferManager, Path location, Logger logger, boolean seedRemote)
+    // Visible for testing
+    static void download(TranslogTransferManager translogTransferManager, Path location, Logger logger, boolean seedRemote, long timestamp)
         throws IOException {
         /*
         In Primary to Primary relocation , there can be concurrent upload and download of translog.
@@ -213,7 +270,7 @@ static void download(TranslogTransferManager translogTransferManager, Path locat
             boolean success = false;
             long startTimeMs = System.currentTimeMillis();
             try {
-                downloadOnce(translogTransferManager, location, logger, seedRemote);
+                downloadOnce(translogTransferManager, location, logger, seedRemote, timestamp);
                 success = true;
                 return;
             } catch (FileNotFoundException | NoSuchFileException e) {
@@ -227,13 +284,18 @@ static void download(TranslogTransferManager translogTransferManager, Path locat
         throw ex;
     }
 
-    private static void downloadOnce(TranslogTransferManager translogTransferManager, Path location, Logger logger, boolean seedRemote)
-        throws IOException {
+    private static void downloadOnce(
+        TranslogTransferManager translogTransferManager,
+        Path location,
+        Logger logger,
+        boolean seedRemote,
+        long timestamp
+    ) throws IOException {
         logger.debug("Downloading translog files from remote");
         RemoteTranslogTransferTracker statsTracker = translogTransferManager.getRemoteTranslogTransferTracker();
         long prevDownloadBytesSucceeded = statsTracker.getDownloadBytesSucceeded();
         long prevDownloadTimeInMillis = statsTracker.getTotalDownloadTimeInMillis();
-        TranslogTransferMetadata translogMetadata = translogTransferManager.readMetadata();
+        TranslogTransferMetadata translogMetadata = translogTransferManager.readMetadata(timestamp);
         if (translogMetadata != null) {
             if (Files.notExists(location)) {
                 Files.createDirectories(location);
@@ -310,6 +372,7 @@ public static TranslogTransferManager buildTranslogTransferManager(
             .shardId(shardIdStr)
             .dataCategory(TRANSLOG)
             .dataType(DATA)
+            .fixedPrefix(remoteStoreSettings.getTranslogPathFixedPrefix())
             .build();
         BlobPath dataPath = pathStrategy.generatePath(dataPathInput);
         RemoteStorePathStrategy.PathInput mdPathInput = RemoteStorePathStrategy.PathInput.builder()
@@ -318,6 +381,7 @@ public static TranslogTransferManager buildTranslogTransferManager(
             .shardId(shardIdStr)
             .dataCategory(TRANSLOG)
             .dataType(METADATA)
+            .fixedPrefix(remoteStoreSettings.getTranslogPathFixedPrefix())
             .build();
         BlobPath mdPath = pathStrategy.generatePath(mdPathInput);
         BlobStoreTransferService transferService = new BlobStoreTransferService(blobStoreRepository.blobStore(), threadPool);
@@ -706,6 +770,10 @@ int availablePermits() {
      */
     @Override
     protected boolean shouldFlush() {
-        return readers.size() >= translogTransferManager.getMaxRemoteTranslogReadersSettings();
+        int maxRemoteTlogReaders = translogTransferManager.getMaxRemoteTranslogReadersSettings();
+        if (maxRemoteTlogReaders == -1) {
+            return false;
+        }
+        return readers.size() >= maxRemoteTlogReaders;
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/translog/Translog.java b/server/src/main/java/org/opensearch/index/translog/Translog.java
index 842e9c77d2350..1556cf1da17db 100644
--- a/server/src/main/java/org/opensearch/index/translog/Translog.java
+++ b/server/src/main/java/org/opensearch/index/translog/Translog.java
@@ -315,6 +315,10 @@ TranslogReader openReader(Path path, Checkpoint checkpoint) throws IOException {
      */
     public static long parseIdFromFileName(Path translogFile) {
         final String fileName = translogFile.getFileName().toString();
+        return parseIdFromFileName(fileName);
+    }
+
+    public static long parseIdFromFileName(String fileName) {
         final Matcher matcher = PARSE_STRICT_ID_PATTERN.matcher(fileName);
         if (matcher.matches()) {
             try {
diff --git a/server/src/main/java/org/opensearch/index/translog/transfer/BlobStoreTransferService.java b/server/src/main/java/org/opensearch/index/translog/transfer/BlobStoreTransferService.java
index 704f6419da60a..22bb4cf0514bf 100644
--- a/server/src/main/java/org/opensearch/index/translog/transfer/BlobStoreTransferService.java
+++ b/server/src/main/java/org/opensearch/index/translog/transfer/BlobStoreTransferService.java
@@ -11,6 +11,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.apache.lucene.store.IndexInput;
 import org.opensearch.action.ActionRunnable;
 import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
@@ -19,11 +20,13 @@
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.BlobStore;
 import org.opensearch.common.blobstore.InputStreamWithMetadata;
-import org.opensearch.common.blobstore.stream.write.WriteContext;
 import org.opensearch.common.blobstore.stream.write.WritePriority;
 import org.opensearch.common.blobstore.transfer.RemoteTransferContainer;
 import org.opensearch.common.blobstore.transfer.stream.OffsetRangeFileInputStream;
+import org.opensearch.common.blobstore.transfer.stream.OffsetRangeIndexInputStream;
+import org.opensearch.common.lucene.store.ByteArrayIndexInput;
 import org.opensearch.core.action.ActionListener;
+import org.opensearch.index.store.exception.ChecksumCombinationException;
 import org.opensearch.index.translog.ChannelFactory;
 import org.opensearch.index.translog.transfer.FileSnapshot.TransferFileSnapshot;
 import org.opensearch.threadpool.ThreadPool;
@@ -41,6 +44,7 @@
 import java.util.Set;
 
 import static org.opensearch.common.blobstore.BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC;
+import static org.opensearch.common.blobstore.transfer.RemoteTransferContainer.checksumOfChecksum;
 import static org.opensearch.index.translog.transfer.TranslogTransferManager.CHECKPOINT_FILE_DATA_KEY;
 
 /**
@@ -53,6 +57,7 @@ public class BlobStoreTransferService implements TransferService {
     private final BlobStore blobStore;
     private final ThreadPool threadPool;
 
+    private static final int CHECKSUM_BYTES_LENGTH = 8;
     private static final Logger logger = LogManager.getLogger(BlobStoreTransferService.class);
 
     public BlobStoreTransferService(BlobStore blobStore, ThreadPool threadPool) {
@@ -108,6 +113,38 @@ public void uploadBlobs(
 
     }
 
+    @Override
+    public void uploadBlob(
+        InputStream inputStream,
+        Iterable<String> remotePath,
+        String fileName,
+        WritePriority writePriority,
+        ActionListener<Void> listener
+    ) throws IOException {
+        assert remotePath instanceof BlobPath;
+        BlobPath blobPath = (BlobPath) remotePath;
+        final BlobContainer blobContainer = blobStore.blobContainer(blobPath);
+        if (blobContainer instanceof AsyncMultiStreamBlobContainer == false) {
+            blobContainer.writeBlob(fileName, inputStream, inputStream.available(), false);
+            listener.onResponse(null);
+            return;
+        }
+        final String resourceDescription = "BlobStoreTransferService.uploadBlob(blob=\"" + fileName + "\")";
+        byte[] bytes = inputStream.readAllBytes();
+        long expectedChecksum = computeChecksum(bytes, resourceDescription);
+        uploadBlobAsyncInternal(
+            fileName,
+            fileName,
+            bytes.length,
+            blobPath,
+            writePriority,
+            (size, position) -> new OffsetRangeIndexInputStream(new ByteArrayIndexInput(resourceDescription, bytes), size, position),
+            expectedChecksum,
+            listener,
+            null
+        );
+    }
+
     // Builds a metadata map containing the Base64-encoded checkpoint file data associated with a translog file.
     static Map<String, String> buildTransferFileMetadata(InputStream metadataInputStream) throws IOException {
         Map<String, String> metadata = new HashMap<>();
@@ -150,37 +187,23 @@ private void uploadBlob(
             try (FileChannel channel = channelFactory.open(fileSnapshot.getPath(), StandardOpenOption.READ)) {
                 contentLength = channel.size();
             }
-            boolean remoteIntegrityEnabled = false;
-            BlobContainer blobContainer = blobStore.blobContainer(blobPath);
-            if (blobContainer instanceof AsyncMultiStreamBlobContainer) {
-                remoteIntegrityEnabled = ((AsyncMultiStreamBlobContainer) blobContainer).remoteIntegrityCheckSupported();
-            }
-            RemoteTransferContainer remoteTransferContainer = new RemoteTransferContainer(
+            ActionListener<Void> completionListener = ActionListener.wrap(resp -> listener.onResponse(fileSnapshot), ex -> {
+                logger.error(() -> new ParameterizedMessage("Failed to upload blob {}", fileSnapshot.getName()), ex);
+                listener.onFailure(new FileTransferException(fileSnapshot, ex));
+            });
+
+            Objects.requireNonNull(fileSnapshot.getChecksum());
+            uploadBlobAsyncInternal(
                 fileSnapshot.getName(),
                 fileSnapshot.getName(),
                 contentLength,
-                true,
+                blobPath,
                 writePriority,
                 (size, position) -> new OffsetRangeFileInputStream(fileSnapshot.getPath(), size, position),
-                Objects.requireNonNull(fileSnapshot.getChecksum()),
-                remoteIntegrityEnabled,
+                fileSnapshot.getChecksum(),
+                completionListener,
                 metadata
             );
-            ActionListener<Void> completionListener = ActionListener.wrap(resp -> listener.onResponse(fileSnapshot), ex -> {
-                logger.error(() -> new ParameterizedMessage("Failed to upload blob {}", fileSnapshot.getName()), ex);
-                listener.onFailure(new FileTransferException(fileSnapshot, ex));
-            });
-
-            completionListener = ActionListener.runBefore(completionListener, () -> {
-                try {
-                    remoteTransferContainer.close();
-                } catch (Exception e) {
-                    logger.warn("Error occurred while closing streams", e);
-                }
-            });
-
-            WriteContext writeContext = remoteTransferContainer.createWriteContext();
-            ((AsyncMultiStreamBlobContainer) blobStore.blobContainer(blobPath)).asyncBlobUpload(writeContext, completionListener);
 
         } catch (Exception e) {
             logger.error(() -> new ParameterizedMessage("Failed to upload blob {}", fileSnapshot.getName()), e);
@@ -195,6 +218,41 @@ private void uploadBlob(
 
     }
 
+    // package private for testing
+    void uploadBlobAsyncInternal(
+        String fileName,
+        String remoteFileName,
+        long contentLength,
+        BlobPath blobPath,
+        WritePriority writePriority,
+        RemoteTransferContainer.OffsetRangeInputStreamSupplier inputStreamSupplier,
+        long expectedChecksum,
+        ActionListener<Void> completionListener,
+        Map<String, String> metadata
+    ) throws IOException {
+        BlobContainer blobContainer = blobStore.blobContainer(blobPath);
+        assert blobContainer instanceof AsyncMultiStreamBlobContainer;
+        boolean remoteIntegrityEnabled = ((AsyncMultiStreamBlobContainer) blobContainer).remoteIntegrityCheckSupported();
+        try (
+            RemoteTransferContainer remoteTransferContainer = new RemoteTransferContainer(
+                fileName,
+                remoteFileName,
+                contentLength,
+                true,
+                writePriority,
+                inputStreamSupplier,
+                expectedChecksum,
+                remoteIntegrityEnabled,
+                metadata
+            )
+        ) {
+            ((AsyncMultiStreamBlobContainer) blobContainer).asyncBlobUpload(
+                remoteTransferContainer.createWriteContext(),
+                completionListener
+            );
+        }
+    }
+
     @Override
     public InputStream downloadBlob(Iterable<String> path, String fileName) throws IOException {
         return blobStore.blobContainer((BlobPath) path).readBlob(fileName);
@@ -276,4 +334,19 @@ public void listAllInSortedOrderAsync(
         threadPool.executor(threadpoolName).execute(() -> { listAllInSortedOrder(path, filenamePrefix, limit, listener); });
     }
 
+    private static long computeChecksum(byte[] bytes, String resourceDescription) throws ChecksumCombinationException {
+        long expectedChecksum;
+        try (IndexInput indexInput = new ByteArrayIndexInput(resourceDescription, bytes)) {
+            expectedChecksum = checksumOfChecksum(indexInput, CHECKSUM_BYTES_LENGTH);
+        } catch (Exception e) {
+            throw new ChecksumCombinationException(
+                "Potentially corrupted file: Checksum combination failed while combining stored checksum "
+                    + "and calculated checksum of stored checksum",
+                resourceDescription,
+                e
+            );
+        }
+        return expectedChecksum;
+    }
+
 }
diff --git a/server/src/main/java/org/opensearch/index/translog/transfer/TransferService.java b/server/src/main/java/org/opensearch/index/translog/transfer/TransferService.java
index 0ff983739438b..1182c626fb0e9 100644
--- a/server/src/main/java/org/opensearch/index/translog/transfer/TransferService.java
+++ b/server/src/main/java/org/opensearch/index/translog/transfer/TransferService.java
@@ -66,6 +66,23 @@ void uploadBlobs(
      */
     void uploadBlob(final TransferFileSnapshot fileSnapshot, Iterable<String> remotePath, WritePriority writePriority) throws IOException;
 
+    /**
+     * Reads the input stream and uploads as a blob
+     * @param inputStream the stream to read from
+     * @param remotePath the remote path where upload should be made
+     * @param blobName the name of blob file
+     * @param writePriority Priority by which content needs to be written.
+     * @param listener the callback to be invoked once uploads complete successfully/fail
+     * @throws IOException the exception thrown while uploading
+     */
+    void uploadBlob(
+        InputStream inputStream,
+        Iterable<String> remotePath,
+        String blobName,
+        WritePriority writePriority,
+        ActionListener<Void> listener
+    ) throws IOException;
+
     void deleteBlobs(Iterable<String> path, List<String> fileNames) throws IOException;
 
     /**
diff --git a/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferManager.java b/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferManager.java
index 1cc39cdf442e2..527fb0123d800 100644
--- a/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferManager.java
+++ b/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferManager.java
@@ -45,10 +45,12 @@
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import static org.opensearch.index.translog.transfer.FileSnapshot.TransferFileSnapshot;
 import static org.opensearch.index.translog.transfer.FileSnapshot.TranslogFileSnapshot;
+import static org.opensearch.index.translog.transfer.TranslogTransferMetadata.METADATA_SEPARATOR;
 
 /**
  * The class responsible for orchestrating the transfer of a {@link TransferSnapshot} via a {@link TransferService}
@@ -337,35 +339,54 @@ private void deleteFileIfExists(Path filePath) throws IOException {
         }
     }
 
+    public TranslogTransferMetadata readMetadata(long pinnedTimestamp) throws IOException {
+        if (pinnedTimestamp <= 0) {
+            return readMetadata();
+        }
+        return readMetadata((blobMetadataList) -> {
+            List<String> metadataFiles = blobMetadataList.stream().map(BlobMetadata::name).collect(Collectors.toList());
+            Set<String> metadataFilesMatchingTimestamp = RemoteStoreUtils.getPinnedTimestampLockedFiles(
+                metadataFiles,
+                Set.of(pinnedTimestamp),
+                file -> RemoteStoreUtils.invertLong(file.split(METADATA_SEPARATOR)[3]),
+                TranslogTransferMetadata::getNodeIdByPrimaryTermAndGen,
+                true
+            );
+            if (metadataFilesMatchingTimestamp.isEmpty()) {
+                return null;
+            }
+            assert metadataFilesMatchingTimestamp.size() == 1 : "There should be only 1 metadata file matching given timestamp";
+            return metadataFilesMatchingTimestamp.stream().findFirst().get();
+        }, Integer.MAX_VALUE);
+    }
+
     public TranslogTransferMetadata readMetadata() throws IOException {
+        return readMetadata((blobMetadataList) -> {
+            RemoteStoreUtils.verifyNoMultipleWriters(
+                blobMetadataList.stream().map(BlobMetadata::name).collect(Collectors.toList()),
+                TranslogTransferMetadata::getNodeIdByPrimaryTermAndGen
+            );
+            return blobMetadataList.get(0).name();
+        }, METADATA_FILES_TO_FETCH);
+    }
+
+    private TranslogTransferMetadata readMetadata(Function<List<BlobMetadata>, String> getMetadataFileToRead, int numberOfFilesToFetch)
+        throws IOException {
         SetOnce<TranslogTransferMetadata> metadataSetOnce = new SetOnce<>();
         SetOnce<IOException> exceptionSetOnce = new SetOnce<>();
         final CountDownLatch latch = new CountDownLatch(1);
         LatchedActionListener<List<BlobMetadata>> latchedActionListener = new LatchedActionListener<>(
             ActionListener.wrap(blobMetadataList -> {
                 if (blobMetadataList.isEmpty()) return;
-                RemoteStoreUtils.verifyNoMultipleWriters(
-                    blobMetadataList.stream().map(BlobMetadata::name).collect(Collectors.toList()),
-                    TranslogTransferMetadata::getNodeIdByPrimaryTermAndGen
-                );
-                String filename = blobMetadataList.get(0).name();
-                boolean downloadStatus = false;
-                long downloadStartTime = System.nanoTime(), bytesToRead = 0;
-                try (InputStream inputStream = transferService.downloadBlob(remoteMetadataTransferPath, filename)) {
-                    // Capture number of bytes for stats before reading
-                    bytesToRead = inputStream.available();
-                    IndexInput indexInput = new ByteArrayIndexInput("metadata file", inputStream.readAllBytes());
-                    metadataSetOnce.set(metadataStreamWrapper.readStream(indexInput));
-                    downloadStatus = true;
+                String filename = getMetadataFileToRead.apply(blobMetadataList);
+                if (filename == null) {
+                    return;
+                }
+                try {
+                    metadataSetOnce.set(readMetadata(filename));
                 } catch (IOException e) {
                     logger.error(() -> new ParameterizedMessage("Exception while reading metadata file: {}", filename), e);
                     exceptionSetOnce.set(e);
-                } finally {
-                    remoteTranslogTransferTracker.addDownloadTimeInMillis((System.nanoTime() - downloadStartTime) / 1_000_000L);
-                    logger.debug("translogMetadataDownloadStatus={}", downloadStatus);
-                    if (downloadStatus) {
-                        remoteTranslogTransferTracker.addDownloadBytesSucceeded(bytesToRead);
-                    }
                 }
             }, e -> {
                 if (e instanceof RuntimeException) {
@@ -381,12 +402,14 @@ public TranslogTransferMetadata readMetadata() throws IOException {
             transferService.listAllInSortedOrder(
                 remoteMetadataTransferPath,
                 TranslogTransferMetadata.METADATA_PREFIX,
-                METADATA_FILES_TO_FETCH,
+                numberOfFilesToFetch,
                 latchedActionListener
             );
-            latch.await();
+            if (latch.await(remoteStoreSettings.getClusterRemoteTranslogTransferTimeout().millis(), TimeUnit.MILLISECONDS) == false) {
+                throw new RuntimeException("Timed out reading metadata file");
+            }
         } catch (InterruptedException e) {
-            throw new IOException("Exception while reading/downloading metadafile", e);
+            throw new IOException("Exception while reading/downloading metadata file", e);
         }
 
         if (exceptionSetOnce.get() != null) {
@@ -396,6 +419,26 @@ public TranslogTransferMetadata readMetadata() throws IOException {
         return metadataSetOnce.get();
     }
 
+    public TranslogTransferMetadata readMetadata(String metadataFilename) throws IOException {
+        boolean downloadStatus = false;
+        TranslogTransferMetadata translogTransferMetadata = null;
+        long downloadStartTime = System.nanoTime(), bytesToRead = 0;
+        try (InputStream inputStream = transferService.downloadBlob(remoteMetadataTransferPath, metadataFilename)) {
+            // Capture number of bytes for stats before reading
+            bytesToRead = inputStream.available();
+            IndexInput indexInput = new ByteArrayIndexInput("metadata file", inputStream.readAllBytes());
+            translogTransferMetadata = metadataStreamWrapper.readStream(indexInput);
+            downloadStatus = true;
+        } finally {
+            remoteTranslogTransferTracker.addDownloadTimeInMillis((System.nanoTime() - downloadStartTime) / 1_000_000L);
+            logger.debug("translogMetadataDownloadStatus={}", downloadStatus);
+            if (downloadStatus) {
+                remoteTranslogTransferTracker.addDownloadBytesSucceeded(bytesToRead);
+            }
+        }
+        return translogTransferMetadata;
+    }
+
     private TransferFileSnapshot prepareMetadata(TransferSnapshot transferSnapshot) throws IOException {
         Map<String, String> generationPrimaryTermMap = transferSnapshot.getTranslogFileSnapshots().stream().map(s -> {
             assert s instanceof TranslogFileSnapshot;
@@ -549,6 +592,16 @@ public void onFailure(Exception e) {
         });
     }
 
+    public void listTranslogMetadataFilesAsync(ActionListener<List<BlobMetadata>> listener) {
+        transferService.listAllInSortedOrderAsync(
+            ThreadPool.Names.REMOTE_PURGE,
+            remoteMetadataTransferPath,
+            TranslogTransferMetadata.METADATA_PREFIX,
+            Integer.MAX_VALUE,
+            listener
+        );
+    }
+
     public void deleteStaleTranslogMetadataFilesAsync(Runnable onCompletion) {
         try {
             transferService.listAllInSortedOrderAsync(
@@ -635,7 +688,7 @@ public void onFailure(Exception e) {
      * @param files list of metadata files to be deleted.
      * @param onCompletion runnable to run on completion of deletion regardless of success/failure.
      */
-    private void deleteMetadataFilesAsync(List<String> files, Runnable onCompletion) {
+    public void deleteMetadataFilesAsync(List<String> files, Runnable onCompletion) {
         try {
             transferService.deleteBlobsAsync(ThreadPool.Names.REMOTE_PURGE, remoteMetadataTransferPath, files, new ActionListener<>() {
                 @Override
diff --git a/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferMetadata.java b/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferMetadata.java
index 052206d807fa6..745fa9a8a219a 100644
--- a/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferMetadata.java
+++ b/server/src/main/java/org/opensearch/index/translog/transfer/TranslogTransferMetadata.java
@@ -8,6 +8,10 @@
 
 package org.opensearch.index.translog.transfer;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.Version;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.index.remote.RemoteStoreUtils;
@@ -25,6 +29,8 @@
  */
 public class TranslogTransferMetadata {
 
+    public static final Logger logger = LogManager.getLogger(TranslogTransferMetadata.class);
+
     private final long primaryTerm;
 
     private final long generation;
@@ -101,6 +107,7 @@ public String getFileName() {
                 RemoteStoreUtils.invertLong(generation),
                 RemoteStoreUtils.invertLong(createdAt),
                 String.valueOf(Objects.hash(nodeId)),
+                RemoteStoreUtils.invertLong(minTranslogGeneration),
                 String.valueOf(CURRENT_VERSION)
             )
         );
@@ -127,6 +134,24 @@ public static Tuple<String, String> getNodeIdByPrimaryTermAndGen(String filename
         return new Tuple<>(primaryTermAndGen, nodeId);
     }
 
+    public static Tuple<Long, Long> getMinMaxTranslogGenerationFromFilename(String filename) {
+        String[] tokens = filename.split(METADATA_SEPARATOR);
+        if (tokens.length < 7) {
+            // For versions < 2.17, we don't have min translog generation.
+            return null;
+        }
+        assert Version.CURRENT.onOrAfter(Version.V_2_17_0);
+        try {
+            // instead of direct index, we go backwards to avoid running into same separator in nodeId
+            String minGeneration = tokens[tokens.length - 2];
+            String maxGeneration = tokens[2];
+            return new Tuple<>(RemoteStoreUtils.invertLong(minGeneration), RemoteStoreUtils.invertLong(maxGeneration));
+        } catch (NumberFormatException e) {
+            logger.error(() -> new ParameterizedMessage("Exception while getting min and max translog generation from: {}", filename), e);
+            return null;
+        }
+    }
+
     @Override
     public int hashCode() {
         return Objects.hash(primaryTerm, generation);
diff --git a/server/src/main/java/org/opensearch/indices/IndicesModule.java b/server/src/main/java/org/opensearch/indices/IndicesModule.java
index d2c26157b1963..f7e52ce9fc1ae 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesModule.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesModule.java
@@ -70,8 +70,10 @@
 import org.opensearch.index.mapper.RoutingFieldMapper;
 import org.opensearch.index.mapper.SeqNoFieldMapper;
 import org.opensearch.index.mapper.SourceFieldMapper;
+import org.opensearch.index.mapper.StarTreeMapper;
 import org.opensearch.index.mapper.TextFieldMapper;
 import org.opensearch.index.mapper.VersionFieldMapper;
+import org.opensearch.index.mapper.WildcardFieldMapper;
 import org.opensearch.index.remote.RemoteStorePressureService;
 import org.opensearch.index.seqno.GlobalCheckpointSyncAction;
 import org.opensearch.index.seqno.RetentionLeaseBackgroundSyncAction;
@@ -172,6 +174,8 @@ public static Map<String, Mapper.TypeParser> getMappers(List<MapperPlugin> mappe
         mappers.put(FlatObjectFieldMapper.CONTENT_TYPE, FlatObjectFieldMapper.PARSER);
         mappers.put(ConstantKeywordFieldMapper.CONTENT_TYPE, new ConstantKeywordFieldMapper.TypeParser());
         mappers.put(DerivedFieldMapper.CONTENT_TYPE, DerivedFieldMapper.PARSER);
+        mappers.put(WildcardFieldMapper.CONTENT_TYPE, WildcardFieldMapper.PARSER);
+        mappers.put(StarTreeMapper.CONTENT_TYPE, new StarTreeMapper.TypeParser());
 
         for (MapperPlugin mapperPlugin : mapperPlugins) {
             for (Map.Entry<String, Mapper.TypeParser> entry : mapperPlugin.getMappers().entrySet()) {
diff --git a/server/src/main/java/org/opensearch/indices/IndicesRequestCache.java b/server/src/main/java/org/opensearch/indices/IndicesRequestCache.java
index 77a55f3f0d775..416cd73abbd25 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesRequestCache.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesRequestCache.java
@@ -75,13 +75,13 @@
 import java.io.IOException;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -153,7 +153,8 @@ public final class IndicesRequestCache implements RemovalListener<ICacheKey<Indi
     private final TimeValue expire;
     private final ICache<Key, BytesReference> cache;
     private final ClusterService clusterService;
-    private final Function<ShardId, Optional<CacheEntity>> cacheEntityLookup;
+    // pkg-private for testing
+    final Function<ShardId, Optional<CacheEntity>> cacheEntityLookup;
     // pkg-private for testing
     final IndicesRequestCacheCleanupManager cacheCleanupManager;
 
@@ -310,12 +311,11 @@ BytesReference getOrCompute(
      * @param cacheKey the cache key to invalidate
      */
     void invalidate(IndicesService.IndexShardCacheEntity cacheEntity, DirectoryReader reader, BytesReference cacheKey) {
-        assert reader.getReaderCacheHelper() != null;
-        String readerCacheKeyId = null;
-        if (reader instanceof OpenSearchDirectoryReader) {
-            IndexReader.CacheHelper cacheHelper = ((OpenSearchDirectoryReader) reader).getDelegatingCacheHelper();
-            readerCacheKeyId = ((OpenSearchDirectoryReader.DelegatingCacheHelper) cacheHelper).getDelegatingCacheKey().getId();
-        }
+        assert reader.getReaderCacheHelper() instanceof OpenSearchDirectoryReader.DelegatingCacheHelper;
+        OpenSearchDirectoryReader.DelegatingCacheHelper delegatingCacheHelper = (OpenSearchDirectoryReader.DelegatingCacheHelper) reader
+            .getReaderCacheHelper();
+        String readerCacheKeyId = delegatingCacheHelper.getDelegatingCacheKey().getId();
+
         IndexShard indexShard = (IndexShard) cacheEntity.getCacheIdentity();
         cache.invalidate(getICacheKey(new Key(indexShard.shardId(), cacheKey, readerCacheKeyId, System.identityHashCode(indexShard))));
     }
@@ -507,7 +507,7 @@ public int hashCode() {
      * */
     class IndicesRequestCacheCleanupManager implements Closeable {
         private final Set<CleanupKey> keysToClean;
-        private final ConcurrentMap<ShardId, HashMap<String, Integer>> cleanupKeyToCountMap;
+        private final ConcurrentHashMap<ShardId, ConcurrentHashMap<String, Integer>> cleanupKeyToCountMap;
         private final AtomicInteger staleKeysCount;
         private volatile double stalenessThreshold;
         private final IndicesRequestCacheCleaner cacheCleaner;
@@ -515,7 +515,7 @@ class IndicesRequestCacheCleanupManager implements Closeable {
         IndicesRequestCacheCleanupManager(ThreadPool threadpool, TimeValue cleanInterval, double stalenessThreshold) {
             this.stalenessThreshold = stalenessThreshold;
             this.keysToClean = ConcurrentCollections.newConcurrentSet();
-            this.cleanupKeyToCountMap = ConcurrentCollections.newConcurrentMap();
+            this.cleanupKeyToCountMap = new ConcurrentHashMap<>();
             this.staleKeysCount = new AtomicInteger(0);
             this.cacheCleaner = new IndicesRequestCacheCleaner(this, threadpool, cleanInterval);
             threadpool.schedule(cacheCleaner, cleanInterval, ThreadPool.Names.SAME);
@@ -568,7 +568,12 @@ private void updateStaleCountOnCacheInsert(CleanupKey cleanupKey) {
 
             // If the key doesn't exist, it's added with a value of 1.
             // If the key exists, its value is incremented by 1.
-            cleanupKeyToCountMap.computeIfAbsent(shardId, k -> new HashMap<>()).merge(cleanupKey.readerCacheKeyId, 1, Integer::sum);
+            addToCleanupKeyToCountMap(shardId, cleanupKey.readerCacheKeyId);
+        }
+
+        // pkg-private for testing
+        void addToCleanupKeyToCountMap(ShardId shardId, String readerCacheKeyId) {
+            cleanupKeyToCountMap.computeIfAbsent(shardId, k -> new ConcurrentHashMap<>()).merge(readerCacheKeyId, 1, Integer::sum);
         }
 
         /**
@@ -716,23 +721,28 @@ private synchronized void cleanCache(double stalenessThreshold) {
             }
             // Contains CleanupKey objects with open shard but invalidated readerCacheKeyId.
             final Set<CleanupKey> cleanupKeysFromOutdatedReaders = new HashSet<>();
-            // Contains CleanupKey objects of a closed shard.
+            // Contains CleanupKey objects for a full cache cleanup.
+            final Set<Tuple<ShardId, Integer>> cleanupKeysFromFullClean = new HashSet<>();
+            // Contains CleanupKey objects for a closed shard.
             final Set<Tuple<ShardId, Integer>> cleanupKeysFromClosedShards = new HashSet<>();
 
             for (Iterator<CleanupKey> iterator = keysToClean.iterator(); iterator.hasNext();) {
                 CleanupKey cleanupKey = iterator.next();
                 iterator.remove();
-                if (cleanupKey.readerCacheKeyId == null || !cleanupKey.entity.isOpen()) {
-                    // null indicates full cleanup, as does a closed shard
-                    IndexShard indexShard = (IndexShard) cleanupKey.entity.getCacheIdentity();
+                final IndexShard indexShard = (IndexShard) cleanupKey.entity.getCacheIdentity();
+                if (cleanupKey.readerCacheKeyId == null) {
+                    // null indicates full cleanup
                     // Add both shardId and indexShardHashCode to uniquely identify an indexShard.
+                    cleanupKeysFromFullClean.add(new Tuple<>(indexShard.shardId(), indexShard.hashCode()));
+                } else if (!cleanupKey.entity.isOpen()) {
+                    // The shard is closed
                     cleanupKeysFromClosedShards.add(new Tuple<>(indexShard.shardId(), indexShard.hashCode()));
                 } else {
                     cleanupKeysFromOutdatedReaders.add(cleanupKey);
                 }
             }
 
-            if (cleanupKeysFromOutdatedReaders.isEmpty() && cleanupKeysFromClosedShards.isEmpty()) {
+            if (cleanupKeysFromOutdatedReaders.isEmpty() && cleanupKeysFromFullClean.isEmpty() && cleanupKeysFromClosedShards.isEmpty()) {
                 return;
             }
 
@@ -741,15 +751,15 @@ private synchronized void cleanCache(double stalenessThreshold) {
             for (Iterator<ICacheKey<Key>> iterator = cache.keys().iterator(); iterator.hasNext();) {
                 ICacheKey<Key> key = iterator.next();
                 Key delegatingKey = key.key;
-                if (cleanupKeysFromClosedShards.contains(new Tuple<>(delegatingKey.shardId, delegatingKey.indexShardHashCode))) {
-                    // Since the shard is closed, the cache should drop stats for this shard.
-                    dimensionListsToDrop.add(key.dimensions);
+                Tuple<ShardId, Integer> shardIdInfo = new Tuple<>(delegatingKey.shardId, delegatingKey.indexShardHashCode);
+                if (cleanupKeysFromFullClean.contains(shardIdInfo) || cleanupKeysFromClosedShards.contains(shardIdInfo)) {
                     iterator.remove();
                 } else {
                     CacheEntity cacheEntity = cacheEntityLookup.apply(delegatingKey.shardId).orElse(null);
                     if (cacheEntity == null) {
                         // If cache entity is null, it means that index or shard got deleted/closed meanwhile.
                         // So we will delete this key.
+                        dimensionListsToDrop.add(key.dimensions);
                         iterator.remove();
                     } else {
                         CleanupKey cleanupKey = new CleanupKey(cacheEntity, delegatingKey.readerCacheKeyId);
@@ -758,6 +768,12 @@ private synchronized void cleanCache(double stalenessThreshold) {
                         }
                     }
                 }
+
+                if (cleanupKeysFromClosedShards.contains(shardIdInfo)) {
+                    // Since the shard is closed, the cache should drop stats for this shard.
+                    // This should not happen on a full cache cleanup.
+                    dimensionListsToDrop.add(key.dimensions);
+                }
             }
             for (List<String> closedDimensions : dimensionListsToDrop) {
                 // Invalidate a dummy key containing the dimensions we need to drop stats for
@@ -815,7 +831,7 @@ public void close() {
         }
 
         // for testing
-        ConcurrentMap<ShardId, HashMap<String, Integer>> getCleanupKeyToCountMap() {
+        ConcurrentHashMap<ShardId, ConcurrentHashMap<String, Integer>> getCleanupKeyToCountMap() {
             return cleanupKeyToCountMap;
         }
 
diff --git a/server/src/main/java/org/opensearch/indices/IndicesService.java b/server/src/main/java/org/opensearch/indices/IndicesService.java
index ce8d23db87c30..1981e5c08d7c3 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesService.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesService.java
@@ -70,6 +70,7 @@
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
+import org.opensearch.common.lucene.index.OpenSearchDirectoryReader.DelegatingCacheHelper;
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Setting.Property;
@@ -108,6 +109,7 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.analysis.AnalysisRegistry;
 import org.opensearch.index.cache.request.ShardRequestCache;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
 import org.opensearch.index.engine.CommitStats;
 import org.opensearch.index.engine.EngineConfig;
 import org.opensearch.index.engine.EngineConfigFactory;
@@ -138,6 +140,7 @@
 import org.opensearch.index.shard.IndexingOperationListener;
 import org.opensearch.index.shard.IndexingStats;
 import org.opensearch.index.shard.IndexingStats.Stats.DocStatusStats;
+import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.index.translog.InternalTranslogFactory;
 import org.opensearch.index.translog.RemoteBlobStoreInternalTranslogFactory;
 import org.opensearch.index.translog.TranslogFactory;
@@ -356,6 +359,9 @@ public class IndicesService extends AbstractLifecycleComponent
     private final BiFunction<IndexSettings, ShardRouting, TranslogFactory> translogFactorySupplier;
     private volatile TimeValue clusterDefaultRefreshInterval;
     private final SearchRequestStats searchRequestStats;
+    private final FileCache fileCache;
+    private final CompositeIndexSettings compositeIndexSettings;
+    private final Consumer<IndexShard> replicator;
 
     @Override
     protected void doStart() {
@@ -390,7 +396,10 @@ public IndicesService(
         @Nullable RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
         RecoverySettings recoverySettings,
         CacheService cacheService,
-        RemoteStoreSettings remoteStoreSettings
+        RemoteStoreSettings remoteStoreSettings,
+        FileCache fileCache,
+        CompositeIndexSettings compositeIndexSettings,
+        Consumer<IndexShard> replicator
     ) {
         this.settings = settings;
         this.threadPool = threadPool;
@@ -406,7 +415,7 @@ public IndicesService(
             if (indexService == null) {
                 return Optional.empty();
             }
-            return Optional.of(new IndexShardCacheEntity(indexService.getShard(shardId.id())));
+            return Optional.of(new IndexShardCacheEntity(indexService.getShardOrNull(shardId.id())));
         }), cacheService, threadPool, clusterService);
         this.indicesQueryCache = new IndicesQueryCache(settings);
         this.mapperRegistry = mapperRegistry;
@@ -497,6 +506,136 @@ protected void closeInternal() {
             .addSettingsUpdateConsumer(CLUSTER_DEFAULT_INDEX_REFRESH_INTERVAL_SETTING, this::onRefreshIntervalUpdate);
         this.recoverySettings = recoverySettings;
         this.remoteStoreSettings = remoteStoreSettings;
+        this.compositeIndexSettings = compositeIndexSettings;
+        this.fileCache = fileCache;
+        this.replicator = replicator;
+    }
+
+    public IndicesService(
+        Settings settings,
+        PluginsService pluginsService,
+        NodeEnvironment nodeEnv,
+        NamedXContentRegistry xContentRegistry,
+        AnalysisRegistry analysisRegistry,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        MapperRegistry mapperRegistry,
+        NamedWriteableRegistry namedWriteableRegistry,
+        ThreadPool threadPool,
+        IndexScopedSettings indexScopedSettings,
+        CircuitBreakerService circuitBreakerService,
+        BigArrays bigArrays,
+        ScriptService scriptService,
+        ClusterService clusterService,
+        Client client,
+        MetaStateService metaStateService,
+        Collection<Function<IndexSettings, Optional<EngineFactory>>> engineFactoryProviders,
+        Map<String, IndexStorePlugin.DirectoryFactory> directoryFactories,
+        ValuesSourceRegistry valuesSourceRegistry,
+        Map<String, IndexStorePlugin.RecoveryStateFactory> recoveryStateFactories,
+        IndexStorePlugin.DirectoryFactory remoteDirectoryFactory,
+        Supplier<RepositoriesService> repositoriesServiceSupplier,
+        SearchRequestStats searchRequestStats,
+        @Nullable RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+        RecoverySettings recoverySettings,
+        CacheService cacheService,
+        RemoteStoreSettings remoteStoreSettings,
+        FileCache fileCache
+    ) {
+        this(
+            settings,
+            pluginsService,
+            nodeEnv,
+            xContentRegistry,
+            analysisRegistry,
+            indexNameExpressionResolver,
+            mapperRegistry,
+            namedWriteableRegistry,
+            threadPool,
+            indexScopedSettings,
+            circuitBreakerService,
+            bigArrays,
+            scriptService,
+            clusterService,
+            client,
+            metaStateService,
+            engineFactoryProviders,
+            directoryFactories,
+            valuesSourceRegistry,
+            recoveryStateFactories,
+            remoteDirectoryFactory,
+            repositoriesServiceSupplier,
+            searchRequestStats,
+            remoteStoreStatsTrackerFactory,
+            recoverySettings,
+            cacheService,
+            remoteStoreSettings,
+            fileCache,
+            null,
+            (s) -> {}
+        );
+    }
+
+    public IndicesService(
+        Settings settings,
+        PluginsService pluginsService,
+        NodeEnvironment nodeEnv,
+        NamedXContentRegistry xContentRegistry,
+        AnalysisRegistry analysisRegistry,
+        IndexNameExpressionResolver indexNameExpressionResolver,
+        MapperRegistry mapperRegistry,
+        NamedWriteableRegistry namedWriteableRegistry,
+        ThreadPool threadPool,
+        IndexScopedSettings indexScopedSettings,
+        CircuitBreakerService circuitBreakerService,
+        BigArrays bigArrays,
+        ScriptService scriptService,
+        ClusterService clusterService,
+        Client client,
+        MetaStateService metaStateService,
+        Collection<Function<IndexSettings, Optional<EngineFactory>>> engineFactoryProviders,
+        Map<String, IndexStorePlugin.DirectoryFactory> directoryFactories,
+        ValuesSourceRegistry valuesSourceRegistry,
+        Map<String, IndexStorePlugin.RecoveryStateFactory> recoveryStateFactories,
+        IndexStorePlugin.DirectoryFactory remoteDirectoryFactory,
+        Supplier<RepositoriesService> repositoriesServiceSupplier,
+        SearchRequestStats searchRequestStats,
+        @Nullable RemoteStoreStatsTrackerFactory remoteStoreStatsTrackerFactory,
+        RecoverySettings recoverySettings,
+        CacheService cacheService,
+        RemoteStoreSettings remoteStoreSettings
+    ) {
+        this(
+            settings,
+            pluginsService,
+            nodeEnv,
+            xContentRegistry,
+            analysisRegistry,
+            indexNameExpressionResolver,
+            mapperRegistry,
+            namedWriteableRegistry,
+            threadPool,
+            indexScopedSettings,
+            circuitBreakerService,
+            bigArrays,
+            scriptService,
+            clusterService,
+            client,
+            metaStateService,
+            engineFactoryProviders,
+            directoryFactories,
+            valuesSourceRegistry,
+            recoveryStateFactories,
+            remoteDirectoryFactory,
+            repositoriesServiceSupplier,
+            searchRequestStats,
+            remoteStoreStatsTrackerFactory,
+            recoverySettings,
+            cacheService,
+            remoteStoreSettings,
+            null,
+            null,
+            null
+        );
     }
 
     /**
@@ -624,8 +763,12 @@ public NodeIndicesStats stats(CommonStatsFlags flags) {
                     break;
             }
         }
-
-        return new NodeIndicesStats(commonStats, statsByShard(this, flags), searchRequestStats);
+        if (flags.getIncludeIndicesStatsByLevel()) {
+            NodeIndicesStats.StatsLevel statsLevel = NodeIndicesStats.getAcceptedLevel(flags.getLevels());
+            return new NodeIndicesStats(commonStats, statsByShard(this, flags), searchRequestStats, statsLevel);
+        } else {
+            return new NodeIndicesStats(commonStats, statsByShard(this, flags), searchRequestStats);
+        }
     }
 
     Map<Index, List<IndexShardStats>> statsByShard(final IndicesService indicesService, final CommonStatsFlags flags) {
@@ -876,7 +1019,9 @@ private synchronized IndexService createIndexService(
             directoryFactories,
             () -> allowExpensiveQueries,
             indexNameExpressionResolver,
-            recoveryStateFactories
+            recoveryStateFactories,
+            fileCache,
+            compositeIndexSettings
         );
         for (IndexingOperationListener operationListener : indexingOperationListeners) {
             indexModule.addIndexOperationListener(operationListener);
@@ -906,7 +1051,8 @@ private synchronized IndexService createIndexService(
             translogFactorySupplier,
             this::getClusterDefaultRefreshInterval,
             this.recoverySettings,
-            this.remoteStoreSettings
+            this.remoteStoreSettings,
+            replicator
         );
     }
 
@@ -966,7 +1112,9 @@ public synchronized MapperService createIndexMapperService(IndexMetadata indexMe
             directoryFactories,
             () -> allowExpensiveQueries,
             indexNameExpressionResolver,
-            recoveryStateFactories
+            recoveryStateFactories,
+            fileCache,
+            compositeIndexSettings
         );
         pluginsService.onIndexModule(indexModule);
         return indexModule.newIndexMapperService(xContentRegistry, mapperRegistry, scriptService);
@@ -1683,8 +1831,7 @@ public boolean canCache(ShardSearchRequest request, SearchContext context) {
         if (context.getQueryShardContext().isCacheable() == false) {
             return false;
         }
-        return true;
-
+        return context.searcher().getDirectoryReader().getReaderCacheHelper() instanceof DelegatingCacheHelper;
     }
 
     /**
@@ -2034,4 +2181,8 @@ private TimeValue getClusterDefaultRefreshInterval() {
     public RemoteStoreSettings getRemoteStoreSettings() {
         return this.remoteStoreSettings;
     }
+
+    public CompositeIndexSettings getCompositeIndexSettings() {
+        return this.compositeIndexSettings;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/indices/InvalidIndexContextException.java b/server/src/main/java/org/opensearch/indices/InvalidIndexContextException.java
new file mode 100644
index 0000000000000..40e9d25bf95c3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/InvalidIndexContextException.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices;
+
+import org.opensearch.OpenSearchException;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.rest.RestStatus;
+
+import java.io.IOException;
+
+/**
+ * Exception when the context provided in the creation of an index is invalid.
+ */
+public class InvalidIndexContextException extends OpenSearchException {
+
+    /**
+     *
+     * @param indexName name of the index
+     * @param name context name provided
+     * @param description error message
+     */
+    public InvalidIndexContextException(String indexName, String name, String description) {
+        super("Invalid context name [{}] provide for index: {}, [{}]", name, indexName, description);
+    }
+
+    public InvalidIndexContextException(StreamInput in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public RestStatus status() {
+        return RestStatus.BAD_REQUEST;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/NodeIndicesStats.java b/server/src/main/java/org/opensearch/indices/NodeIndicesStats.java
index 35b6fd395ee12..b9c90fdedc435 100644
--- a/server/src/main/java/org/opensearch/indices/NodeIndicesStats.java
+++ b/server/src/main/java/org/opensearch/indices/NodeIndicesStats.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.indices;
 
+import org.opensearch.Version;
 import org.opensearch.action.admin.indices.stats.CommonStats;
 import org.opensearch.action.admin.indices.stats.IndexShardStats;
 import org.opensearch.action.admin.indices.stats.ShardStats;
@@ -63,9 +64,11 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 /**
  * Global information on indices stats running on a specific node.
@@ -74,26 +77,27 @@
  */
 @PublicApi(since = "1.0.0")
 public class NodeIndicesStats implements Writeable, ToXContentFragment {
-    private CommonStats stats;
-    private Map<Index, List<IndexShardStats>> statsByShard;
+    protected CommonStats stats;
+    protected Map<Index, CommonStats> statsByIndex;
+    protected Map<Index, List<IndexShardStats>> statsByShard;
 
     public NodeIndicesStats(StreamInput in) throws IOException {
         stats = new CommonStats(in);
-        if (in.readBoolean()) {
-            int entries = in.readVInt();
-            statsByShard = new HashMap<>();
-            for (int i = 0; i < entries; i++) {
-                Index index = new Index(in);
-                int indexShardListSize = in.readVInt();
-                List<IndexShardStats> indexShardStats = new ArrayList<>(indexShardListSize);
-                for (int j = 0; j < indexShardListSize; j++) {
-                    indexShardStats.add(new IndexShardStats(in));
-                }
-                statsByShard.put(index, indexShardStats);
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            // contains statsByIndex
+            if (in.readBoolean()) {
+                statsByIndex = readStatsByIndex(in);
             }
         }
+        if (in.readBoolean()) {
+            statsByShard = readStatsByShard(in);
+        }
     }
 
+    /**
+     * Without passing the information of the levels to the constructor, we return the Node-level aggregated stats as
+     * {@link CommonStats} along with a hash-map containing Index to List of Shard Stats.
+     */
     public NodeIndicesStats(CommonStats oldStats, Map<Index, List<IndexShardStats>> statsByShard, SearchRequestStats searchRequestStats) {
         // this.stats = stats;
         this.statsByShard = statsByShard;
@@ -112,6 +116,90 @@ public NodeIndicesStats(CommonStats oldStats, Map<Index, List<IndexShardStats>>
         }
     }
 
+    /**
+     * Passing the level information to the nodes allows us to aggregate the stats based on the level passed. This
+     * allows us to aggregate based on NodeLevel (default - if no level is passed) or Index level if `indices` level is
+     * passed and finally return the statsByShards map if `shards` level is passed. This allows us to reduce ser/de of
+     * stats and return only the information that is required while returning to the client.
+     */
+    public NodeIndicesStats(
+        CommonStats oldStats,
+        Map<Index, List<IndexShardStats>> statsByShard,
+        SearchRequestStats searchRequestStats,
+        StatsLevel level
+    ) {
+        // make a total common stats from old ones and current ones
+        this.stats = oldStats;
+        for (List<IndexShardStats> shardStatsList : statsByShard.values()) {
+            for (IndexShardStats indexShardStats : shardStatsList) {
+                for (ShardStats shardStats : indexShardStats.getShards()) {
+                    stats.add(shardStats.getStats());
+                }
+            }
+        }
+
+        if (this.stats.search != null) {
+            this.stats.search.setSearchRequestStats(searchRequestStats);
+        }
+
+        if (level != null) {
+            switch (level) {
+                case INDICES:
+                    this.statsByIndex = createStatsByIndex(statsByShard);
+                    break;
+                case SHARDS:
+                    this.statsByShard = statsByShard;
+                    break;
+            }
+        }
+    }
+
+    /**
+     * By default, the levels passed from the transport action will be a list of strings, since NodeIndicesStats can
+     * only aggregate on one level, we pick the first accepted level else we ignore if no known level is passed. Level is
+     * selected based on enum defined in {@link StatsLevel}
+     *
+     * Note - we are picking the first level as multiple levels are not supported in the previous versions.
+     * @param levels - levels sent in the request.
+     *
+     * @return Corresponding identified enum {@link StatsLevel}
+     */
+    public static StatsLevel getAcceptedLevel(String[] levels) {
+        if (levels != null && levels.length > 0) {
+            Optional<StatsLevel> level = Arrays.stream(StatsLevel.values())
+                .filter(field -> field.getRestName().equals(levels[0]))
+                .findFirst();
+            return level.orElseThrow(() -> new IllegalArgumentException("Level provided is not supported by NodeIndicesStats"));
+        }
+        return null;
+    }
+
+    private Map<Index, CommonStats> readStatsByIndex(StreamInput in) throws IOException {
+        Map<Index, CommonStats> statsByIndex = new HashMap<>();
+        int indexEntries = in.readVInt();
+        for (int i = 0; i < indexEntries; i++) {
+            Index index = new Index(in);
+            CommonStats commonStats = new CommonStats(in);
+            statsByIndex.put(index, commonStats);
+        }
+        return statsByIndex;
+    }
+
+    private Map<Index, List<IndexShardStats>> readStatsByShard(StreamInput in) throws IOException {
+        Map<Index, List<IndexShardStats>> statsByShard = new HashMap<>();
+        int entries = in.readVInt();
+        for (int i = 0; i < entries; i++) {
+            Index index = new Index(in);
+            int indexShardListSize = in.readVInt();
+            List<IndexShardStats> indexShardStats = new ArrayList<>(indexShardListSize);
+            for (int j = 0; j < indexShardListSize; j++) {
+                indexShardStats.add(new IndexShardStats(in));
+            }
+            statsByShard.put(index, indexShardStats);
+        }
+        return statsByShard;
+    }
+
     @Nullable
     public StoreStats getStore() {
         return stats.getStore();
@@ -195,7 +283,31 @@ public RecoveryStats getRecoveryStats() {
     @Override
     public void writeTo(StreamOutput out) throws IOException {
         stats.writeTo(out);
+
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeBoolean(statsByIndex != null);
+            if (statsByIndex != null) {
+                writeStatsByIndex(out);
+            }
+        }
+
         out.writeBoolean(statsByShard != null);
+        if (statsByShard != null) {
+            writeStatsByShards(out);
+        }
+    }
+
+    private void writeStatsByIndex(StreamOutput out) throws IOException {
+        if (statsByIndex != null) {
+            out.writeVInt(statsByIndex.size());
+            for (Map.Entry<Index, CommonStats> entry : statsByIndex.entrySet()) {
+                entry.getKey().writeTo(out);
+                entry.getValue().writeTo(out);
+            }
+        }
+    }
+
+    private void writeStatsByShards(StreamOutput out) throws IOException {
         if (statsByShard != null) {
             out.writeVInt(statsByShard.size());
             for (Map.Entry<Index, List<IndexShardStats>> entry : statsByShard.entrySet()) {
@@ -210,29 +322,46 @@ public void writeTo(StreamOutput out) throws IOException {
 
     @Override
     public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
-        final String level = params.param("level", "node");
-        final boolean isLevelValid = "indices".equalsIgnoreCase(level)
-            || "node".equalsIgnoreCase(level)
-            || "shards".equalsIgnoreCase(level);
+        final String level = params.param("level", StatsLevel.NODE.getRestName());
+        final boolean isLevelValid = StatsLevel.NODE.getRestName().equalsIgnoreCase(level)
+            || StatsLevel.INDICES.getRestName().equalsIgnoreCase(level)
+            || StatsLevel.SHARDS.getRestName().equalsIgnoreCase(level);
         if (!isLevelValid) {
-            throw new IllegalArgumentException("level parameter must be one of [indices] or [node] or [shards] but was [" + level + "]");
+            throw new IllegalArgumentException(
+                "level parameter must be one of ["
+                    + StatsLevel.INDICES.getRestName()
+                    + "] or ["
+                    + StatsLevel.NODE.getRestName()
+                    + "] or ["
+                    + StatsLevel.SHARDS.getRestName()
+                    + "] but was ["
+                    + level
+                    + "]"
+            );
         }
 
         // "node" level
-        builder.startObject(Fields.INDICES);
+        builder.startObject(StatsLevel.INDICES.getRestName());
         stats.toXContent(builder, params);
 
-        if ("indices".equals(level)) {
-            Map<Index, CommonStats> indexStats = createStatsByIndex();
-            builder.startObject(Fields.INDICES);
-            for (Map.Entry<Index, CommonStats> entry : indexStats.entrySet()) {
+        if (StatsLevel.INDICES.getRestName().equals(level)) {
+            assert statsByIndex != null || statsByShard != null : "Expected shard stats or index stats in response for generating ["
+                + StatsLevel.INDICES
+                + "] field";
+            if (statsByIndex == null) {
+                statsByIndex = createStatsByIndex(statsByShard);
+            }
+
+            builder.startObject(StatsLevel.INDICES.getRestName());
+            for (Map.Entry<Index, CommonStats> entry : statsByIndex.entrySet()) {
                 builder.startObject(entry.getKey().getName());
                 entry.getValue().toXContent(builder, params);
                 builder.endObject();
             }
             builder.endObject();
-        } else if ("shards".equals(level)) {
-            builder.startObject("shards");
+        } else if (StatsLevel.SHARDS.getRestName().equals(level)) {
+            builder.startObject(StatsLevel.SHARDS.getRestName());
+            assert statsByShard != null : "Expected shard stats in response for generating [" + StatsLevel.SHARDS + "] field";
             for (Map.Entry<Index, List<IndexShardStats>> entry : statsByShard.entrySet()) {
                 builder.startArray(entry.getKey().getName());
                 for (IndexShardStats indexShardStats : entry.getValue()) {
@@ -251,7 +380,7 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         return builder;
     }
 
-    private Map<Index, CommonStats> createStatsByIndex() {
+    private Map<Index, CommonStats> createStatsByIndex(Map<Index, List<IndexShardStats>> statsByShard) {
         Map<Index, CommonStats> statsMap = new HashMap<>();
         for (Map.Entry<Index, List<IndexShardStats>> entry : statsByShard.entrySet()) {
             if (!statsMap.containsKey(entry.getKey())) {
@@ -281,7 +410,21 @@ public List<IndexShardStats> getShardStats(Index index) {
      *
      * @opensearch.internal
      */
-    static final class Fields {
-        static final String INDICES = "indices";
+    @PublicApi(since = "2.17.0")
+    public enum StatsLevel {
+        INDICES("indices"),
+        SHARDS("shards"),
+        NODE("node");
+
+        private final String restName;
+
+        StatsLevel(String restName) {
+            this.restName = restName;
+        }
+
+        public String getRestName() {
+            return restName;
+        }
+
     }
 }
diff --git a/server/src/main/java/org/opensearch/indices/RemoteStoreSettings.java b/server/src/main/java/org/opensearch/indices/RemoteStoreSettings.java
index 074186f64a75d..4bd0caa709436 100644
--- a/server/src/main/java/org/opensearch/indices/RemoteStoreSettings.java
+++ b/server/src/main/java/org/opensearch/indices/RemoteStoreSettings.java
@@ -25,6 +25,7 @@
  */
 @PublicApi(since = "2.14.0")
 public class RemoteStoreSettings {
+    private static final int MIN_CLUSTER_REMOTE_MAX_TRANSLOG_READERS = 100;
 
     /**
      * Used to specify the default translog buffer interval for remote store backed indexes.
@@ -112,7 +113,12 @@ public class RemoteStoreSettings {
     public static final Setting<Integer> CLUSTER_REMOTE_MAX_TRANSLOG_READERS = Setting.intSetting(
         "cluster.remote_store.translog.max_readers",
         1000,
-        100,
+        -1,
+        v -> {
+            if (v != -1 && v < MIN_CLUSTER_REMOTE_MAX_TRANSLOG_READERS) {
+                throw new IllegalArgumentException("Cannot set value lower than " + MIN_CLUSTER_REMOTE_MAX_TRANSLOG_READERS);
+            }
+        },
         Property.Dynamic,
         Property.NodeScope
     );
@@ -128,6 +134,56 @@ public class RemoteStoreSettings {
         Property.Dynamic
     );
 
+    /**
+     * Controls pinned timestamp feature enablement
+     */
+    public static final Setting<Boolean> CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED = Setting.boolSetting(
+        "cluster.remote_store.pinned_timestamps.enabled",
+        false,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Controls pinned timestamp scheduler interval
+     */
+    public static final Setting<TimeValue> CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_SCHEDULER_INTERVAL = Setting.timeSetting(
+        "cluster.remote_store.pinned_timestamps.scheduler_interval",
+        TimeValue.timeValueMinutes(3),
+        TimeValue.timeValueMinutes(1),
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Controls allowed timestamp values to be pinned from past
+     */
+    public static final Setting<TimeValue> CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_LOOKBACK_INTERVAL = Setting.timeSetting(
+        "cluster.remote_store.pinned_timestamps.lookback_interval",
+        TimeValue.timeValueMinutes(1),
+        TimeValue.timeValueMinutes(1),
+        TimeValue.timeValueMinutes(5),
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * Controls the fixed prefix for the translog path on remote store.
+     */
+    public static final Setting<String> CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX = Setting.simpleString(
+        "cluster.remote_store.translog.path.prefix",
+        "",
+        Property.NodeScope,
+        Property.Final
+    );
+
+    /**
+     * Controls the fixed prefix for the segments path on remote store.
+     */
+    public static final Setting<String> CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX = Setting.simpleString(
+        "cluster.remote_store.segments.path.prefix",
+        "",
+        Property.NodeScope,
+        Property.Final
+    );
+
     private volatile TimeValue clusterRemoteTranslogBufferInterval;
     private volatile int minRemoteSegmentMetadataFiles;
     private volatile TimeValue clusterRemoteTranslogTransferTimeout;
@@ -136,6 +192,11 @@ public class RemoteStoreSettings {
     private volatile RemoteStoreEnums.PathHashAlgorithm pathHashAlgorithm;
     private volatile int maxRemoteTranslogReaders;
     private volatile boolean isTranslogMetadataEnabled;
+    private static volatile boolean isPinnedTimestampsEnabled;
+    private static volatile TimeValue pinnedTimestampsSchedulerInterval;
+    private static volatile TimeValue pinnedTimestampsLookbackInterval;
+    private final String translogPathFixedPrefix;
+    private final String segmentsPathFixedPrefix;
 
     public RemoteStoreSettings(Settings settings, ClusterSettings clusterSettings) {
         clusterRemoteTranslogBufferInterval = CLUSTER_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING.get(settings);
@@ -173,6 +234,13 @@ public RemoteStoreSettings(Settings settings, ClusterSettings clusterSettings) {
             CLUSTER_REMOTE_SEGMENT_TRANSFER_TIMEOUT_SETTING,
             this::setClusterRemoteSegmentTransferTimeout
         );
+
+        pinnedTimestampsSchedulerInterval = CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_SCHEDULER_INTERVAL.get(settings);
+        pinnedTimestampsLookbackInterval = CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_LOOKBACK_INTERVAL.get(settings);
+        isPinnedTimestampsEnabled = CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.get(settings);
+
+        translogPathFixedPrefix = CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.get(settings);
+        segmentsPathFixedPrefix = CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(settings);
     }
 
     public TimeValue getClusterRemoteTranslogBufferInterval() {
@@ -240,4 +308,29 @@ public int getMaxRemoteTranslogReaders() {
     private void setMaxRemoteTranslogReaders(int maxRemoteTranslogReaders) {
         this.maxRemoteTranslogReaders = maxRemoteTranslogReaders;
     }
+
+    public static TimeValue getPinnedTimestampsSchedulerInterval() {
+        return pinnedTimestampsSchedulerInterval;
+    }
+
+    public static TimeValue getPinnedTimestampsLookbackInterval() {
+        return pinnedTimestampsLookbackInterval;
+    }
+
+    // Visible for testing
+    public static void setPinnedTimestampsLookbackInterval(TimeValue pinnedTimestampsLookbackInterval) {
+        RemoteStoreSettings.pinnedTimestampsLookbackInterval = pinnedTimestampsLookbackInterval;
+    }
+
+    public static boolean isPinnedTimestampsEnabled() {
+        return isPinnedTimestampsEnabled;
+    }
+
+    public String getTranslogPathFixedPrefix() {
+        return translogPathFixedPrefix;
+    }
+
+    public String getSegmentsPathFixedPrefix() {
+        return segmentsPathFixedPrefix;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/indices/ShardLimitValidator.java b/server/src/main/java/org/opensearch/indices/ShardLimitValidator.java
index e345b613eebbd..94e91e2d4c3ac 100644
--- a/server/src/main/java/org/opensearch/indices/ShardLimitValidator.java
+++ b/server/src/main/java/org/opensearch/indices/ShardLimitValidator.java
@@ -261,14 +261,15 @@ static Optional<String> checkShardLimit(
             return Optional.empty();
         }
 
+        int computedMaxShards = (int) Math.min(Integer.MAX_VALUE, (long) maxShardsPerNodeSetting * nodeCount);
         int maxShardsInCluster = maxShardsPerClusterSetting;
         if (maxShardsInCluster == -1) {
-            maxShardsInCluster = maxShardsPerNodeSetting * nodeCount;
+            maxShardsInCluster = computedMaxShards;
         } else {
-            maxShardsInCluster = Math.min(maxShardsInCluster, maxShardsPerNodeSetting * nodeCount);
+            maxShardsInCluster = Math.min(maxShardsInCluster, computedMaxShards);
         }
 
-        int currentOpenShards = state.getMetadata().getTotalOpenIndexShards();
+        long currentOpenShards = state.getMetadata().getTotalOpenIndexShards();
         if ((currentOpenShards + newShards) > maxShardsInCluster) {
             String errorMessage = "this action would add ["
                 + newShards
diff --git a/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java b/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java
index f3592a3561d3a..f3212b1e2fae1 100644
--- a/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java
+++ b/server/src/main/java/org/opensearch/indices/SystemIndexDescriptor.java
@@ -33,6 +33,7 @@
 package org.opensearch.indices;
 
 import org.apache.lucene.util.automaton.CharacterRunAutomaton;
+import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.regex.Regex;
 
 import java.util.Objects;
@@ -40,8 +41,9 @@
 /**
  * Describes a system index. Provides the information required to create and maintain the system index.
  *
- * @opensearch.internal
+ * @opensearch.api
  */
+@PublicApi(since = "2.16.0")
 public class SystemIndexDescriptor {
     private final String indexPattern;
     private final String description;
diff --git a/server/src/main/java/org/opensearch/indices/SystemIndexRegistry.java b/server/src/main/java/org/opensearch/indices/SystemIndexRegistry.java
new file mode 100644
index 0000000000000..ab2cbd4ef1a73
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/SystemIndexRegistry.java
@@ -0,0 +1,140 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices;
+
+import org.apache.lucene.util.automaton.Automaton;
+import org.apache.lucene.util.automaton.Operations;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.tasks.TaskResultsService;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static java.util.Collections.singletonList;
+import static java.util.Collections.singletonMap;
+import static java.util.Collections.unmodifiableMap;
+import static org.opensearch.tasks.TaskResultsService.TASK_INDEX;
+
+/**
+ * This class holds the {@link SystemIndexDescriptor} objects that represent system indices the
+ * node knows about. This class also contains static methods that identify if index expressions match
+ * registered system index patterns
+ *
+ * @opensearch.api
+ */
+@ExperimentalApi
+public class SystemIndexRegistry {
+    private static final SystemIndexDescriptor TASK_INDEX_DESCRIPTOR = new SystemIndexDescriptor(TASK_INDEX + "*", "Task Result Index");
+    private static final Map<String, Collection<SystemIndexDescriptor>> SERVER_SYSTEM_INDEX_DESCRIPTORS = singletonMap(
+        TaskResultsService.class.getName(),
+        singletonList(TASK_INDEX_DESCRIPTOR)
+    );
+
+    private volatile static String[] SYSTEM_INDEX_PATTERNS = new String[0];
+    private volatile static Map<String, Collection<SystemIndexDescriptor>> SYSTEM_INDEX_DESCRIPTORS_MAP = Collections.emptyMap();
+
+    static void register(Map<String, Collection<SystemIndexDescriptor>> pluginAndModulesDescriptors) {
+        final Map<String, Collection<SystemIndexDescriptor>> descriptorsMap = buildSystemIndexDescriptorMap(pluginAndModulesDescriptors);
+        checkForOverlappingPatterns(descriptorsMap);
+
+        SYSTEM_INDEX_DESCRIPTORS_MAP = descriptorsMap;
+        SYSTEM_INDEX_PATTERNS = getAllDescriptors().stream().map(SystemIndexDescriptor::getIndexPattern).toArray(String[]::new);
+    }
+
+    public static Set<String> matchesSystemIndexPattern(Set<String> indexExpressions) {
+        return indexExpressions.stream().filter(pattern -> Regex.simpleMatch(SYSTEM_INDEX_PATTERNS, pattern)).collect(Collectors.toSet());
+    }
+
+    public static Set<String> matchesPluginSystemIndexPattern(String pluginClassName, Set<String> indexExpressions) {
+        if (!SYSTEM_INDEX_DESCRIPTORS_MAP.containsKey(pluginClassName)) {
+            return Collections.emptySet();
+        }
+        String[] pluginSystemIndexPatterns = SYSTEM_INDEX_DESCRIPTORS_MAP.get(pluginClassName)
+            .stream()
+            .map(SystemIndexDescriptor::getIndexPattern)
+            .toArray(String[]::new);
+        return indexExpressions.stream()
+            .filter(pattern -> Regex.simpleMatch(pluginSystemIndexPatterns, pattern))
+            .collect(Collectors.toSet());
+    }
+
+    static List<SystemIndexDescriptor> getAllDescriptors() {
+        return SYSTEM_INDEX_DESCRIPTORS_MAP.values().stream().flatMap(Collection::stream).collect(Collectors.toList());
+    }
+
+    /**
+     * Given a collection of {@link SystemIndexDescriptor}s and their sources, checks to see if the index patterns of the listed
+     * descriptors overlap with any of the other patterns. If any do, throws an exception.
+     *
+     * @param sourceToDescriptors A map of source (plugin) names to the SystemIndexDescriptors they provide.
+     * @throws IllegalStateException Thrown if any of the index patterns overlaps with another.
+     */
+    static void checkForOverlappingPatterns(Map<String, Collection<SystemIndexDescriptor>> sourceToDescriptors) {
+        List<Tuple<String, SystemIndexDescriptor>> sourceDescriptorPair = sourceToDescriptors.entrySet()
+            .stream()
+            .flatMap(entry -> entry.getValue().stream().map(descriptor -> new Tuple<>(entry.getKey(), descriptor)))
+            .sorted(Comparator.comparing(d -> d.v1() + ":" + d.v2().getIndexPattern())) // Consistent ordering -> consistent error message
+            .collect(Collectors.toList());
+
+        // This is O(n^2) with the number of system index descriptors, and each check is quadratic with the number of states in the
+        // automaton, but the absolute number of system index descriptors should be quite small (~10s at most), and the number of states
+        // per pattern should be low as well. If these assumptions change, this might need to be reworked.
+        sourceDescriptorPair.forEach(descriptorToCheck -> {
+            List<Tuple<String, SystemIndexDescriptor>> descriptorsMatchingThisPattern = sourceDescriptorPair.stream()
+
+                .filter(d -> descriptorToCheck.v2() != d.v2()) // Exclude the pattern currently being checked
+                .filter(d -> overlaps(descriptorToCheck.v2(), d.v2()))
+                .collect(Collectors.toList());
+            if (descriptorsMatchingThisPattern.isEmpty() == false) {
+                throw new IllegalStateException(
+                    "a system index descriptor ["
+                        + descriptorToCheck.v2()
+                        + "] from ["
+                        + descriptorToCheck.v1()
+                        + "] overlaps with other system index descriptors: ["
+                        + descriptorsMatchingThisPattern.stream()
+                            .map(descriptor -> descriptor.v2() + " from [" + descriptor.v1() + "]")
+                            .collect(Collectors.joining(", "))
+                );
+            }
+        });
+    }
+
+    private static boolean overlaps(SystemIndexDescriptor a1, SystemIndexDescriptor a2) {
+        Automaton a1Automaton = Regex.simpleMatchToAutomaton(a1.getIndexPattern());
+        Automaton a2Automaton = Regex.simpleMatchToAutomaton(a2.getIndexPattern());
+        return Operations.isEmpty(Operations.intersection(a1Automaton, a2Automaton)) == false;
+    }
+
+    private static Map<String, Collection<SystemIndexDescriptor>> buildSystemIndexDescriptorMap(
+        Map<String, Collection<SystemIndexDescriptor>> pluginAndModulesMap
+    ) {
+        final Map<String, Collection<SystemIndexDescriptor>> map = new HashMap<>(
+            pluginAndModulesMap.size() + SERVER_SYSTEM_INDEX_DESCRIPTORS.size()
+        );
+        map.putAll(pluginAndModulesMap);
+        // put the server items last since we expect less of them
+        SERVER_SYSTEM_INDEX_DESCRIPTORS.forEach((source, descriptors) -> {
+            if (map.putIfAbsent(source, descriptors) != null) {
+                throw new IllegalArgumentException(
+                    "plugin or module attempted to define the same source [" + source + "] as a built-in system index"
+                );
+            }
+        });
+        return unmodifiableMap(map);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/SystemIndices.java b/server/src/main/java/org/opensearch/indices/SystemIndices.java
index a85e938c61b7a..6e9e5e7707877 100644
--- a/server/src/main/java/org/opensearch/indices/SystemIndices.java
+++ b/server/src/main/java/org/opensearch/indices/SystemIndices.java
@@ -40,25 +40,15 @@
 import org.apache.lucene.util.automaton.MinimizationOperations;
 import org.apache.lucene.util.automaton.Operations;
 import org.opensearch.common.Nullable;
-import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.regex.Regex;
 import org.opensearch.core.index.Index;
-import org.opensearch.tasks.TaskResultsService;
 
 import java.util.Collection;
-import java.util.Comparator;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
-import static java.util.Collections.singletonList;
-import static java.util.Collections.singletonMap;
-import static java.util.Collections.unmodifiableList;
-import static java.util.Collections.unmodifiableMap;
-import static org.opensearch.tasks.TaskResultsService.TASK_INDEX;
-
 /**
  * This class holds the {@link SystemIndexDescriptor} objects that represent system indices the
  * node knows about. Methods for determining if an index should be a system index are also provided
@@ -69,21 +59,11 @@
 public class SystemIndices {
     private static final Logger logger = LogManager.getLogger(SystemIndices.class);
 
-    private static final Map<String, Collection<SystemIndexDescriptor>> SERVER_SYSTEM_INDEX_DESCRIPTORS = singletonMap(
-        TaskResultsService.class.getName(),
-        singletonList(new SystemIndexDescriptor(TASK_INDEX + "*", "Task Result Index"))
-    );
-
     private final CharacterRunAutomaton runAutomaton;
-    private final Collection<SystemIndexDescriptor> systemIndexDescriptors;
 
     public SystemIndices(Map<String, Collection<SystemIndexDescriptor>> pluginAndModulesDescriptors) {
-        final Map<String, Collection<SystemIndexDescriptor>> descriptorsMap = buildSystemIndexDescriptorMap(pluginAndModulesDescriptors);
-        checkForOverlappingPatterns(descriptorsMap);
-        this.systemIndexDescriptors = unmodifiableList(
-            descriptorsMap.values().stream().flatMap(Collection::stream).collect(Collectors.toList())
-        );
-        this.runAutomaton = buildCharacterRunAutomaton(systemIndexDescriptors);
+        SystemIndexRegistry.register(pluginAndModulesDescriptors);
+        this.runAutomaton = buildCharacterRunAutomaton(SystemIndexRegistry.getAllDescriptors());
     }
 
     /**
@@ -111,7 +91,8 @@ public boolean isSystemIndex(String indexName) {
      * @throws IllegalStateException if multiple descriptors match the name
      */
     public @Nullable SystemIndexDescriptor findMatchingDescriptor(String name) {
-        final List<SystemIndexDescriptor> matchingDescriptors = systemIndexDescriptors.stream()
+        final List<SystemIndexDescriptor> matchingDescriptors = SystemIndexRegistry.getAllDescriptors()
+            .stream()
             .filter(descriptor -> descriptor.matchesIndexPattern(name))
             .collect(Collectors.toList());
 
@@ -168,66 +149,4 @@ private static CharacterRunAutomaton buildCharacterRunAutomaton(Collection<Syste
             .reduce(Operations::union);
         return new CharacterRunAutomaton(MinimizationOperations.minimize(automaton.orElse(Automata.makeEmpty()), Integer.MAX_VALUE));
     }
-
-    /**
-     * Given a collection of {@link SystemIndexDescriptor}s and their sources, checks to see if the index patterns of the listed
-     * descriptors overlap with any of the other patterns. If any do, throws an exception.
-     *
-     * @param sourceToDescriptors A map of source (plugin) names to the SystemIndexDescriptors they provide.
-     * @throws IllegalStateException Thrown if any of the index patterns overlaps with another.
-     */
-    static void checkForOverlappingPatterns(Map<String, Collection<SystemIndexDescriptor>> sourceToDescriptors) {
-        List<Tuple<String, SystemIndexDescriptor>> sourceDescriptorPair = sourceToDescriptors.entrySet()
-            .stream()
-            .flatMap(entry -> entry.getValue().stream().map(descriptor -> new Tuple<>(entry.getKey(), descriptor)))
-            .sorted(Comparator.comparing(d -> d.v1() + ":" + d.v2().getIndexPattern())) // Consistent ordering -> consistent error message
-            .collect(Collectors.toList());
-
-        // This is O(n^2) with the number of system index descriptors, and each check is quadratic with the number of states in the
-        // automaton, but the absolute number of system index descriptors should be quite small (~10s at most), and the number of states
-        // per pattern should be low as well. If these assumptions change, this might need to be reworked.
-        sourceDescriptorPair.forEach(descriptorToCheck -> {
-            List<Tuple<String, SystemIndexDescriptor>> descriptorsMatchingThisPattern = sourceDescriptorPair.stream()
-
-                .filter(d -> descriptorToCheck.v2() != d.v2()) // Exclude the pattern currently being checked
-                .filter(d -> overlaps(descriptorToCheck.v2(), d.v2()))
-                .collect(Collectors.toList());
-            if (descriptorsMatchingThisPattern.isEmpty() == false) {
-                throw new IllegalStateException(
-                    "a system index descriptor ["
-                        + descriptorToCheck.v2()
-                        + "] from ["
-                        + descriptorToCheck.v1()
-                        + "] overlaps with other system index descriptors: ["
-                        + descriptorsMatchingThisPattern.stream()
-                            .map(descriptor -> descriptor.v2() + " from [" + descriptor.v1() + "]")
-                            .collect(Collectors.joining(", "))
-                );
-            }
-        });
-    }
-
-    private static boolean overlaps(SystemIndexDescriptor a1, SystemIndexDescriptor a2) {
-        Automaton a1Automaton = Regex.simpleMatchToAutomaton(a1.getIndexPattern());
-        Automaton a2Automaton = Regex.simpleMatchToAutomaton(a2.getIndexPattern());
-        return Operations.isEmpty(Operations.intersection(a1Automaton, a2Automaton)) == false;
-    }
-
-    private static Map<String, Collection<SystemIndexDescriptor>> buildSystemIndexDescriptorMap(
-        Map<String, Collection<SystemIndexDescriptor>> pluginAndModulesMap
-    ) {
-        final Map<String, Collection<SystemIndexDescriptor>> map = new HashMap<>(
-            pluginAndModulesMap.size() + SERVER_SYSTEM_INDEX_DESCRIPTORS.size()
-        );
-        map.putAll(pluginAndModulesMap);
-        // put the server items last since we expect less of them
-        SERVER_SYSTEM_INDEX_DESCRIPTORS.forEach((source, descriptors) -> {
-            if (map.putIfAbsent(source, descriptors) != null) {
-                throw new IllegalArgumentException(
-                    "plugin or module attempted to define the same source [" + source + "] as a built-in system index"
-                );
-            }
-        });
-        return unmodifiableMap(map);
-    }
 }
diff --git a/server/src/main/java/org/opensearch/indices/TermsLookup.java b/server/src/main/java/org/opensearch/indices/TermsLookup.java
index 37533c0809d7a..7337ed31ce41e 100644
--- a/server/src/main/java/org/opensearch/indices/TermsLookup.java
+++ b/server/src/main/java/org/opensearch/indices/TermsLookup.java
@@ -87,6 +87,9 @@ public TermsLookup(StreamInput in) throws IOException {
         path = in.readString();
         index = in.readString();
         routing = in.readOptionalString();
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            store = in.readBoolean();
+        }
     }
 
     @Override
@@ -98,6 +101,9 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(path);
         out.writeString(index);
         out.writeOptionalString(routing);
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeBoolean(store);
+        }
     }
 
     public String index() {
@@ -121,6 +127,17 @@ public TermsLookup routing(String routing) {
         return this;
     }
 
+    private boolean store;
+
+    public boolean store() {
+        return store;
+    }
+
+    public TermsLookup store(boolean store) {
+        this.store = store;
+        return this;
+    }
+
     private static final ConstructingObjectParser<TermsLookup, Void> PARSER = new ConstructingObjectParser<>("terms_lookup", args -> {
         String index = (String) args[0];
         String id = (String) args[1];
@@ -132,6 +149,7 @@ public TermsLookup routing(String routing) {
         PARSER.declareString(constructorArg(), new ParseField("id"));
         PARSER.declareString(constructorArg(), new ParseField("path"));
         PARSER.declareString(TermsLookup::routing, new ParseField("routing"));
+        PARSER.declareBoolean(TermsLookup::store, new ParseField("store"));
     }
 
     public static TermsLookup parseTermsLookup(XContentParser parser) throws IOException {
@@ -151,12 +169,15 @@ public XContentBuilder toXContent(XContentBuilder builder, Params params) throws
         if (routing != null) {
             builder.field("routing", routing);
         }
+        if (store) {
+            builder.field("store", true);
+        }
         return builder;
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(index, id, path, routing);
+        return Objects.hash(index, id, path, routing, store);
     }
 
     @Override
@@ -171,6 +192,7 @@ public boolean equals(Object obj) {
         return Objects.equals(index, other.index)
             && Objects.equals(id, other.id)
             && Objects.equals(path, other.path)
-            && Objects.equals(routing, other.routing);
+            && Objects.equals(routing, other.routing)
+            && Objects.equals(store, other.store);
     }
 }
diff --git a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
index 139e7b51d2200..bd600e1204fa8 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/PeerRecoveryTargetService.java
@@ -295,6 +295,7 @@ private void doRecovery(final long recoveryId, final StartRecoveryRequest preExi
                 logger.debug("{} reestablishing recovery from {}", startRequest.shardId(), startRequest.sourceNode());
             }
         }
+
         transportService.sendRequest(
             startRequest.sourceNode(),
             actionName,
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoverySettings.java b/server/src/main/java/org/opensearch/indices/recovery/RecoverySettings.java
index 92704260322fd..21279dc583d18 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoverySettings.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoverySettings.java
@@ -179,6 +179,15 @@ public class RecoverySettings {
     // choose 512KB-16B to ensure that the resulting byte[] is not a humongous allocation in G1.
     public static final ByteSizeValue DEFAULT_CHUNK_SIZE = new ByteSizeValue(512 * 1024 - 16, ByteSizeUnit.BYTES);
 
+    public static final Setting<ByteSizeValue> INDICES_RECOVERY_CHUNK_SIZE_SETTING = Setting.byteSizeSetting(
+        "indices.recovery.chunk_size",
+        DEFAULT_CHUNK_SIZE,
+        new ByteSizeValue(1, ByteSizeUnit.BYTES),
+        new ByteSizeValue(100, ByteSizeUnit.MB),
+        Property.Dynamic,
+        Property.NodeScope
+    );
+
     private volatile ByteSizeValue recoveryMaxBytesPerSec;
     private volatile ByteSizeValue replicationMaxBytesPerSec;
     private volatile int maxConcurrentFileChunks;
@@ -193,7 +202,7 @@ public class RecoverySettings {
     private volatile TimeValue internalActionRetryTimeout;
     private volatile TimeValue internalActionLongTimeout;
 
-    private volatile ByteSizeValue chunkSize = DEFAULT_CHUNK_SIZE;
+    private volatile ByteSizeValue chunkSize;
     private volatile TimeValue internalRemoteUploadTimeout;
 
     public RecoverySettings(Settings settings, ClusterSettings clusterSettings) {
@@ -221,6 +230,7 @@ public RecoverySettings(Settings settings, ClusterSettings clusterSettings) {
 
         logger.debug("using recovery max_bytes_per_sec[{}]", recoveryMaxBytesPerSec);
         this.internalRemoteUploadTimeout = INDICES_INTERNAL_REMOTE_UPLOAD_TIMEOUT.get(settings);
+        this.chunkSize = INDICES_RECOVERY_CHUNK_SIZE_SETTING.get(settings);
 
         clusterSettings.addSettingsUpdateConsumer(INDICES_RECOVERY_MAX_BYTES_PER_SEC_SETTING, this::setRecoveryMaxBytesPerSec);
         clusterSettings.addSettingsUpdateConsumer(INDICES_REPLICATION_MAX_BYTES_PER_SEC_SETTING, this::setReplicationMaxBytesPerSec);
@@ -239,7 +249,11 @@ public RecoverySettings(Settings settings, ClusterSettings clusterSettings) {
         );
         clusterSettings.addSettingsUpdateConsumer(INDICES_RECOVERY_ACTIVITY_TIMEOUT_SETTING, this::setActivityTimeout);
         clusterSettings.addSettingsUpdateConsumer(INDICES_INTERNAL_REMOTE_UPLOAD_TIMEOUT, this::setInternalRemoteUploadTimeout);
-
+        clusterSettings.addSettingsUpdateConsumer(INDICES_RECOVERY_CHUNK_SIZE_SETTING, this::setChunkSize);
+        clusterSettings.addSettingsUpdateConsumer(
+            INDICES_RECOVERY_INTERNAL_ACTION_RETRY_TIMEOUT_SETTING,
+            this::setInternalActionRetryTimeout
+        );
     }
 
     /**
@@ -292,10 +306,7 @@ public ByteSizeValue getChunkSize() {
         return chunkSize;
     }
 
-    public void setChunkSize(ByteSizeValue chunkSize) { // only settable for tests
-        if (chunkSize.bytesAsInt() <= 0) {
-            throw new IllegalArgumentException("chunkSize must be > 0");
-        }
+    public void setChunkSize(ByteSizeValue chunkSize) {
         this.chunkSize = chunkSize;
     }
 
@@ -323,6 +334,10 @@ public void setInternalRemoteUploadTimeout(TimeValue internalRemoteUploadTimeout
         this.internalRemoteUploadTimeout = internalRemoteUploadTimeout;
     }
 
+    public void setInternalActionRetryTimeout(TimeValue internalActionRetryTimeout) {
+        this.internalActionRetryTimeout = internalActionRetryTimeout;
+    }
+
     private void setRecoveryMaxBytesPerSec(ByteSizeValue recoveryMaxBytesPerSec) {
         this.recoveryMaxBytesPerSec = recoveryMaxBytesPerSec;
         if (recoveryMaxBytesPerSec.getBytes() <= 0) {
diff --git a/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandler.java b/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandler.java
index 470b6602a9a3a..e4ec3cd517f16 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandler.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/RecoverySourceHandler.java
@@ -541,7 +541,7 @@ void sendFiles(Store store, StoreFileMetadata[] files, IntSupplier translogOps,
 
     void createRetentionLease(final long startingSeqNo, ActionListener<RetentionLease> listener) {
         RunUnderPrimaryPermit.run(() -> {
-            // Clone the peer recovery retention lease belonging to the source shard. We are retaining history between the the local
+            // Clone the peer recovery retention lease belonging to the source shard. We are retaining history between the local
             // checkpoint of the safe commit we're creating and this lease's retained seqno with the retention lock, and by cloning an
             // existing lease we (approximately) know that all our peers are also retaining history as requested by the cloned lease. If
             // the recovery now fails before copying enough history over then a subsequent attempt will find this lease, determine it is
diff --git a/server/src/main/java/org/opensearch/indices/recovery/StartRecoveryRequest.java b/server/src/main/java/org/opensearch/indices/recovery/StartRecoveryRequest.java
index 1df0d3861f686..7309712314acd 100644
--- a/server/src/main/java/org/opensearch/indices/recovery/StartRecoveryRequest.java
+++ b/server/src/main/java/org/opensearch/indices/recovery/StartRecoveryRequest.java
@@ -144,8 +144,8 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeLong(recoveryId);
         shardId.writeTo(out);
         out.writeString(targetAllocationId);
-        sourceNode.writeTo(out);
-        targetNode.writeTo(out);
+        sourceNode.writeToWithAttribute(out);
+        targetNode.writeToWithAttribute(out);
         metadataSnapshot.writeTo(out);
         out.writeBoolean(primaryRelocation);
         out.writeLong(startingSeqNo);
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
index fbd7ab7cea346..8fee3f671ecc9 100644
--- a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicationTargetService.java
@@ -11,9 +11,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
-import org.apache.lucene.index.CorruptIndexException;
 import org.opensearch.ExceptionsHelper;
-import org.opensearch.OpenSearchCorruptionException;
 import org.opensearch.action.support.ChannelActionListener;
 import org.opensearch.cluster.ClusterChangedEvent;
 import org.opensearch.cluster.ClusterStateListener;
@@ -24,7 +22,6 @@
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.CancellableThreads;
-import org.opensearch.common.util.concurrent.AbstractRunnable;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.shard.ShardId;
@@ -33,7 +30,6 @@
 import org.opensearch.index.shard.IndexEventListener;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardState;
-import org.opensearch.index.store.Store;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.recovery.FileChunkRequest;
 import org.opensearch.indices.recovery.ForceSyncRequest;
@@ -61,7 +57,7 @@
 import static org.opensearch.indices.replication.SegmentReplicationSourceService.Actions.UPDATE_VISIBLE_CHECKPOINT;
 
 /**
- * Service class that orchestrates replication events on replicas.
+ * Service class that handles incoming checkpoints to initiate replication events on replicas.
  *
  * @opensearch.internal
  */
@@ -72,10 +68,6 @@ public class SegmentReplicationTargetService extends AbstractLifecycleComponent
     private final ThreadPool threadPool;
     private final RecoverySettings recoverySettings;
 
-    private final ReplicationCollection<SegmentReplicationTarget> onGoingReplications;
-
-    private final Map<ShardId, SegmentReplicationState> completedReplications = ConcurrentCollections.newConcurrentMap();
-
     private final SegmentReplicationSourceFactory sourceFactory;
 
     protected final Map<ShardId, ReplicationCheckpoint> latestReceivedCheckpoint = ConcurrentCollections.newConcurrentMap();
@@ -83,6 +75,7 @@ public class SegmentReplicationTargetService extends AbstractLifecycleComponent
     private final IndicesService indicesService;
     private final ClusterService clusterService;
     private final TransportService transportService;
+    private final SegmentReplicator replicator;
 
     /**
      * The internal actions
@@ -94,6 +87,7 @@ public static class Actions {
         public static final String FORCE_SYNC = "internal:index/shard/replication/segments_sync";
     }
 
+    @Deprecated
     public SegmentReplicationTargetService(
         final ThreadPool threadPool,
         final RecoverySettings recoverySettings,
@@ -113,6 +107,7 @@ public SegmentReplicationTargetService(
         );
     }
 
+    @Deprecated
     public SegmentReplicationTargetService(
         final ThreadPool threadPool,
         final RecoverySettings recoverySettings,
@@ -121,14 +116,34 @@ public SegmentReplicationTargetService(
         final IndicesService indicesService,
         final ClusterService clusterService,
         final ReplicationCollection<SegmentReplicationTarget> ongoingSegmentReplications
+    ) {
+        this(
+            threadPool,
+            recoverySettings,
+            transportService,
+            sourceFactory,
+            indicesService,
+            clusterService,
+            new SegmentReplicator(threadPool)
+        );
+    }
+
+    public SegmentReplicationTargetService(
+        final ThreadPool threadPool,
+        final RecoverySettings recoverySettings,
+        final TransportService transportService,
+        final SegmentReplicationSourceFactory sourceFactory,
+        final IndicesService indicesService,
+        final ClusterService clusterService,
+        final SegmentReplicator replicator
     ) {
         this.threadPool = threadPool;
         this.recoverySettings = recoverySettings;
-        this.onGoingReplications = ongoingSegmentReplications;
         this.sourceFactory = sourceFactory;
         this.indicesService = indicesService;
         this.clusterService = clusterService;
         this.transportService = transportService;
+        this.replicator = replicator;
 
         transportService.registerRequestHandler(
             Actions.FILE_CHUNK,
@@ -142,6 +157,7 @@ public SegmentReplicationTargetService(
             ForceSyncRequest::new,
             new ForceSyncTransportRequestHandler()
         );
+        replicator.setSourceFactory(sourceFactory);
     }
 
     @Override
@@ -154,7 +170,7 @@ protected void doStart() {
     @Override
     protected void doStop() {
         if (DiscoveryNode.isDataNode(clusterService.getSettings())) {
-            assert onGoingReplications.size() == 0 : "Replication collection should be empty on shutdown";
+            assert replicator.size() == 0 : "Replication collection should be empty on shutdown";
             clusterService.removeListener(this);
         }
     }
@@ -171,7 +187,7 @@ public void clusterChanged(ClusterChangedEvent event) {
                 if (indexService.getIndexSettings().isSegRepEnabledOrRemoteNode()
                     && event.indexRoutingTableChanged(indexService.index().getName())) {
                     for (IndexShard shard : indexService) {
-                        if (shard.routingEntry().primary() == false) {
+                        if (shard.routingEntry().primary() == false && shard.routingEntry().isSearchOnly() == false) {
                             // for this shard look up its primary routing, if it has completed a relocation trigger replication
                             final String previousNode = event.previousState()
                                 .routingTable()
@@ -199,7 +215,7 @@ public void clusterChanged(ClusterChangedEvent event) {
     @Override
     public void beforeIndexShardClosed(ShardId shardId, @Nullable IndexShard indexShard, Settings indexSettings) {
         if (indexShard != null && indexShard.indexSettings().isSegRepEnabledOrRemoteNode()) {
-            onGoingReplications.cancelForShard(indexShard.shardId(), "Shard closing");
+            replicator.cancel(indexShard.shardId(), "Shard closing");
             latestReceivedCheckpoint.remove(shardId);
         }
     }
@@ -224,7 +240,7 @@ public void shardRoutingChanged(IndexShard indexShard, @Nullable ShardRouting ol
             && indexShard.indexSettings().isSegRepEnabledOrRemoteNode()
             && oldRouting.primary() == false
             && newRouting.primary()) {
-            onGoingReplications.cancelForShard(indexShard.shardId(), "Shard has been promoted to primary");
+            replicator.cancel(indexShard.shardId(), "Shard has been promoted to primary");
             latestReceivedCheckpoint.remove(indexShard.shardId());
         }
     }
@@ -234,9 +250,7 @@ public void shardRoutingChanged(IndexShard indexShard, @Nullable ShardRouting ol
      */
     @Nullable
     public SegmentReplicationState getOngoingEventSegmentReplicationState(ShardId shardId) {
-        return Optional.ofNullable(onGoingReplications.getOngoingReplicationTarget(shardId))
-            .map(SegmentReplicationTarget::state)
-            .orElse(null);
+        return Optional.ofNullable(replicator.get(shardId)).map(SegmentReplicationTarget::state).orElse(null);
     }
 
     /**
@@ -244,7 +258,7 @@ public SegmentReplicationState getOngoingEventSegmentReplicationState(ShardId sh
      */
     @Nullable
     public SegmentReplicationState getlatestCompletedEventSegmentReplicationState(ShardId shardId) {
-        return completedReplications.get(shardId);
+        return replicator.getCompleted(shardId);
     }
 
     /**
@@ -257,11 +271,11 @@ public SegmentReplicationState getSegmentReplicationState(ShardId shardId) {
     }
 
     public ReplicationRef<SegmentReplicationTarget> get(long replicationId) {
-        return onGoingReplications.get(replicationId);
+        return replicator.get(replicationId);
     }
 
     public SegmentReplicationTarget get(ShardId shardId) {
-        return onGoingReplications.getOngoingReplicationTarget(shardId);
+        return replicator.get(shardId);
     }
 
     /**
@@ -285,7 +299,7 @@ public synchronized void onNewCheckpoint(final ReplicationCheckpoint receivedChe
         // checkpoint to be replayed once the shard is Active.
         if (replicaShard.state().equals(IndexShardState.STARTED) == true) {
             // Checks if received checkpoint is already present and ahead then it replaces old received checkpoint
-            SegmentReplicationTarget ongoingReplicationTarget = onGoingReplications.getOngoingReplicationTarget(replicaShard.shardId());
+            SegmentReplicationTarget ongoingReplicationTarget = replicator.get(replicaShard.shardId());
             if (ongoingReplicationTarget != null) {
                 if (ongoingReplicationTarget.getCheckpoint().getPrimaryTerm() < receivedCheckpoint.getPrimaryTerm()) {
                     logger.debug(
@@ -384,7 +398,7 @@ private void logReplicationFailure(SegmentReplicationState state, ReplicationFai
     protected void updateVisibleCheckpoint(long replicationId, IndexShard replicaShard) {
         // Update replication checkpoint on source via transport call only supported for remote store integration. For node-
         // node communication, checkpoint update is piggy-backed to GET_SEGMENT_FILES transport call
-        if (replicaShard.indexSettings().isRemoteStoreEnabled() == false) {
+        if (replicaShard.indexSettings().isAssignedOnRemoteNode() == false) {
             return;
         }
         ShardRouting primaryShard = clusterService.state().routingTable().shardRoutingTable(replicaShard.shardId()).primaryShard();
@@ -504,28 +518,12 @@ public SegmentReplicationTarget startReplication(
         final ReplicationCheckpoint checkpoint,
         final SegmentReplicationListener listener
     ) {
-        final SegmentReplicationTarget target = new SegmentReplicationTarget(
-            indexShard,
-            checkpoint,
-            sourceFactory.get(indexShard),
-            listener
-        );
-        startReplication(target);
-        return target;
+        return replicator.startReplication(indexShard, checkpoint, sourceFactory.get(indexShard), listener);
     }
 
     // pkg-private for integration tests
     void startReplication(final SegmentReplicationTarget target) {
-        final long replicationId;
-        try {
-            replicationId = onGoingReplications.startSafe(target, recoverySettings.activityTimeout());
-        } catch (ReplicationFailedException e) {
-            // replication already running for shard.
-            target.fail(e, false);
-            return;
-        }
-        logger.trace(() -> new ParameterizedMessage("Added new replication to collection {}", target.description()));
-        threadPool.generic().execute(new ReplicationRunner(replicationId));
+        replicator.startReplication(target, recoverySettings.activityTimeout());
     }
 
     /**
@@ -550,81 +548,6 @@ default void onFailure(ReplicationState state, ReplicationFailedException e, boo
         void onReplicationFailure(SegmentReplicationState state, ReplicationFailedException e, boolean sendShardFailure);
     }
 
-    /**
-     * Runnable implementation to trigger a replication event.
-     */
-    private class ReplicationRunner extends AbstractRunnable {
-
-        final long replicationId;
-
-        public ReplicationRunner(long replicationId) {
-            this.replicationId = replicationId;
-        }
-
-        @Override
-        public void onFailure(Exception e) {
-            onGoingReplications.fail(replicationId, new ReplicationFailedException("Unexpected Error during replication", e), false);
-        }
-
-        @Override
-        public void doRun() {
-            start(replicationId);
-        }
-    }
-
-    private void start(final long replicationId) {
-        final SegmentReplicationTarget target;
-        try (ReplicationRef<SegmentReplicationTarget> replicationRef = onGoingReplications.get(replicationId)) {
-            // This check is for handling edge cases where the reference is removed before the ReplicationRunner is started by the
-            // threadpool.
-            if (replicationRef == null) {
-                return;
-            }
-            target = replicationRef.get();
-        }
-        target.startReplication(new ActionListener<>() {
-            @Override
-            public void onResponse(Void o) {
-                logger.debug(() -> new ParameterizedMessage("Finished replicating {} marking as done.", target.description()));
-                onGoingReplications.markAsDone(replicationId);
-                if (target.state().getIndex().recoveredFileCount() != 0 && target.state().getIndex().recoveredBytes() != 0) {
-                    completedReplications.put(target.shardId(), target.state());
-                }
-            }
-
-            @Override
-            public void onFailure(Exception e) {
-                logger.debug("Replication failed {}", target.description());
-                if (isStoreCorrupt(target) || e instanceof CorruptIndexException || e instanceof OpenSearchCorruptionException) {
-                    onGoingReplications.fail(replicationId, new ReplicationFailedException("Store corruption during replication", e), true);
-                    return;
-                }
-                onGoingReplications.fail(replicationId, new ReplicationFailedException("Segment Replication failed", e), false);
-            }
-        });
-    }
-
-    private boolean isStoreCorrupt(SegmentReplicationTarget target) {
-        // ensure target is not already closed. In that case
-        // we can assume the store is not corrupt and that the replication
-        // event completed successfully.
-        if (target.refCount() > 0) {
-            final Store store = target.store();
-            if (store.tryIncRef()) {
-                try {
-                    return store.isMarkedCorrupted();
-                } catch (IOException ex) {
-                    logger.warn("Unable to determine if store is corrupt", ex);
-                    return false;
-                } finally {
-                    store.decRef();
-                }
-            }
-        }
-        // store already closed.
-        return false;
-    }
-
     private class FileChunkTransportRequestHandler implements TransportRequestHandler<FileChunkRequest> {
 
         // How many bytes we've copied since we last called RateLimiter.pause
@@ -632,7 +555,7 @@ private class FileChunkTransportRequestHandler implements TransportRequestHandle
 
         @Override
         public void messageReceived(final FileChunkRequest request, TransportChannel channel, Task task) throws Exception {
-            try (ReplicationRef<SegmentReplicationTarget> ref = onGoingReplications.getSafe(request.recoveryId(), request.shardId())) {
+            try (ReplicationRef<SegmentReplicationTarget> ref = replicator.get(request.recoveryId(), request.shardId())) {
                 final SegmentReplicationTarget target = ref.get();
                 final ActionListener<Void> listener = target.createOrFinishListener(channel, Actions.FILE_CHUNK, request);
                 target.handleFileChunk(request, target, bytesSinceLastPause, recoverySettings.replicationRateLimiter(), listener);
diff --git a/server/src/main/java/org/opensearch/indices/replication/SegmentReplicator.java b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicator.java
new file mode 100644
index 0000000000000..ad3bc1933208c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/replication/SegmentReplicator.java
@@ -0,0 +1,217 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.replication;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.apache.lucene.index.CorruptIndexException;
+import org.opensearch.OpenSearchCorruptionException;
+import org.opensearch.common.SetOnce;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.AbstractRunnable;
+import org.opensearch.common.util.concurrent.ConcurrentCollections;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.store.Store;
+import org.opensearch.indices.replication.checkpoint.ReplicationCheckpoint;
+import org.opensearch.indices.replication.common.ReplicationCollection;
+import org.opensearch.indices.replication.common.ReplicationFailedException;
+import org.opensearch.indices.replication.common.ReplicationListener;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * This class is responsible for managing segment replication events on replicas.
+ * It uses a {@link ReplicationCollection} to track ongoing replication events and
+ * manages the state of each replication event.
+ *
+ * @opensearch.internal
+ */
+public class SegmentReplicator {
+
+    private static final Logger logger = LogManager.getLogger(SegmentReplicator.class);
+
+    private final ReplicationCollection<SegmentReplicationTarget> onGoingReplications;
+    private final Map<ShardId, SegmentReplicationState> completedReplications = ConcurrentCollections.newConcurrentMap();
+    private final ThreadPool threadPool;
+
+    private final SetOnce<SegmentReplicationSourceFactory> sourceFactory;
+
+    public SegmentReplicator(ThreadPool threadPool) {
+        this.onGoingReplications = new ReplicationCollection<>(logger, threadPool);
+        this.threadPool = threadPool;
+        this.sourceFactory = new SetOnce<>();
+    }
+
+    /**
+     * Starts a replication event for the given shard.
+     * @param shard - {@link IndexShard} replica shard
+     */
+    public void startReplication(IndexShard shard) {
+        if (sourceFactory.get() == null) return;
+        startReplication(
+            shard,
+            shard.getLatestReplicationCheckpoint(),
+            sourceFactory.get().get(shard),
+            new SegmentReplicationTargetService.SegmentReplicationListener() {
+                @Override
+                public void onReplicationDone(SegmentReplicationState state) {
+                    logger.trace("Completed replication for {}", shard.shardId());
+                }
+
+                @Override
+                public void onReplicationFailure(SegmentReplicationState state, ReplicationFailedException e, boolean sendShardFailure) {
+                    logger.error(() -> new ParameterizedMessage("Failed segment replication for {}", shard.shardId()), e);
+                    if (sendShardFailure) {
+                        shard.failShard("unrecoverable replication failure", e);
+                    }
+                }
+            }
+        );
+    }
+
+    void setSourceFactory(SegmentReplicationSourceFactory sourceFactory) {
+        this.sourceFactory.set(sourceFactory);
+    }
+
+    /**
+     * Start a round of replication and sync to at least the given checkpoint.
+     * @param indexShard - {@link IndexShard} replica shard
+     * @param checkpoint - {@link ReplicationCheckpoint} checkpoint to sync to
+     * @param listener - {@link ReplicationListener}
+     * @return {@link SegmentReplicationTarget} target event orchestrating the event.
+     */
+    SegmentReplicationTarget startReplication(
+        final IndexShard indexShard,
+        final ReplicationCheckpoint checkpoint,
+        final SegmentReplicationSource source,
+        final SegmentReplicationTargetService.SegmentReplicationListener listener
+    ) {
+        final SegmentReplicationTarget target = new SegmentReplicationTarget(indexShard, checkpoint, source, listener);
+        startReplication(target, indexShard.getRecoverySettings().activityTimeout());
+        return target;
+    }
+
+    /**
+     * Runnable implementation to trigger a replication event.
+     */
+    private class ReplicationRunner extends AbstractRunnable {
+
+        final long replicationId;
+
+        public ReplicationRunner(long replicationId) {
+            this.replicationId = replicationId;
+        }
+
+        @Override
+        public void onFailure(Exception e) {
+            onGoingReplications.fail(replicationId, new ReplicationFailedException("Unexpected Error during replication", e), false);
+        }
+
+        @Override
+        public void doRun() {
+            start(replicationId);
+        }
+    }
+
+    private void start(final long replicationId) {
+        final SegmentReplicationTarget target;
+        try (ReplicationCollection.ReplicationRef<SegmentReplicationTarget> replicationRef = onGoingReplications.get(replicationId)) {
+            // This check is for handling edge cases where the reference is removed before the ReplicationRunner is started by the
+            // threadpool.
+            if (replicationRef == null) {
+                return;
+            }
+            target = replicationRef.get();
+        }
+        target.startReplication(new ActionListener<>() {
+            @Override
+            public void onResponse(Void o) {
+                logger.debug(() -> new ParameterizedMessage("Finished replicating {} marking as done.", target.description()));
+                onGoingReplications.markAsDone(replicationId);
+                if (target.state().getIndex().recoveredFileCount() != 0 && target.state().getIndex().recoveredBytes() != 0) {
+                    completedReplications.put(target.shardId(), target.state());
+                }
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                logger.debug("Replication failed {}", target.description());
+                if (isStoreCorrupt(target) || e instanceof CorruptIndexException || e instanceof OpenSearchCorruptionException) {
+                    onGoingReplications.fail(replicationId, new ReplicationFailedException("Store corruption during replication", e), true);
+                    return;
+                }
+                onGoingReplications.fail(replicationId, new ReplicationFailedException("Segment Replication failed", e), false);
+            }
+        });
+    }
+
+    // pkg-private for integration tests
+    void startReplication(final SegmentReplicationTarget target, TimeValue timeout) {
+        final long replicationId;
+        try {
+            replicationId = onGoingReplications.startSafe(target, timeout);
+        } catch (ReplicationFailedException e) {
+            // replication already running for shard.
+            target.fail(e, false);
+            return;
+        }
+        logger.trace(() -> new ParameterizedMessage("Added new replication to collection {}", target.description()));
+        threadPool.generic().execute(new ReplicationRunner(replicationId));
+    }
+
+    private boolean isStoreCorrupt(SegmentReplicationTarget target) {
+        // ensure target is not already closed. In that case
+        // we can assume the store is not corrupt and that the replication
+        // event completed successfully.
+        if (target.refCount() > 0) {
+            final Store store = target.store();
+            if (store.tryIncRef()) {
+                try {
+                    return store.isMarkedCorrupted();
+                } catch (IOException ex) {
+                    logger.warn("Unable to determine if store is corrupt", ex);
+                    return false;
+                } finally {
+                    store.decRef();
+                }
+            }
+        }
+        // store already closed.
+        return false;
+    }
+
+    int size() {
+        return onGoingReplications.size();
+    }
+
+    void cancel(ShardId shardId, String reason) {
+        onGoingReplications.cancelForShard(shardId, reason);
+    }
+
+    SegmentReplicationTarget get(ShardId shardId) {
+        return onGoingReplications.getOngoingReplicationTarget(shardId);
+    }
+
+    ReplicationCollection.ReplicationRef<SegmentReplicationTarget> get(long id) {
+        return onGoingReplications.get(id);
+    }
+
+    SegmentReplicationState getCompleted(ShardId shardId) {
+        return completedReplications.get(shardId);
+    }
+
+    ReplicationCollection.ReplicationRef<SegmentReplicationTarget> get(long id, ShardId shardId) {
+        return onGoingReplications.getSafe(id, shardId);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
index 8f39aa194b06c..d1e2884956f5c 100644
--- a/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
+++ b/server/src/main/java/org/opensearch/indices/replication/checkpoint/PublishCheckpointAction.java
@@ -24,6 +24,7 @@
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.index.IndexNotFoundException;
@@ -113,7 +114,7 @@ final void publish(IndexShard indexShard, ReplicationCheckpoint checkpoint) {
         final ThreadContext threadContext = threadPool.getThreadContext();
         try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
             // we have to execute under the system context so that if security is enabled the sync is authorized
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             PublishCheckpointRequest request = new PublishCheckpointRequest(checkpoint);
             final ReplicationTask task = (ReplicationTask) taskManager.register("transport", "segrep_publish_checkpoint", request);
             final ReplicationTimer timer = new ReplicationTimer();
diff --git a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
index aaac8998aad37..d25b3f0110b10 100644
--- a/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
+++ b/server/src/main/java/org/opensearch/indices/replication/common/ReplicationTarget.java
@@ -91,7 +91,7 @@ public ReplicationTarget(String name, IndexShard indexShard, ReplicationLuceneIn
         // make sure the store is not released until we are done.
         this.cancellableThreads = new CancellableThreads();
         store.incRef();
-        if (indexShard.indexSettings().isRemoteStoreEnabled()) {
+        if (indexShard.indexSettings().isAssignedOnRemoteNode()) {
             indexShard.remoteStore().incRef();
         }
     }
@@ -284,7 +284,7 @@ protected void closeInternal() {
         try {
             store.decRef();
         } finally {
-            if (indexShard.indexSettings().isRemoteStoreEnabled()) {
+            if (indexShard.indexSettings().isAssignedOnRemoteNode()) {
                 indexShard.remoteStore().decRef();
             }
         }
diff --git a/server/src/main/java/org/opensearch/indices/tiering/TieringRequestValidator.java b/server/src/main/java/org/opensearch/indices/tiering/TieringRequestValidator.java
new file mode 100644
index 0000000000000..2de50f4d4295d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/tiering/TieringRequestValidator.java
@@ -0,0 +1,277 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.tiering;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.action.admin.indices.tiering.TieringValidationResult;
+import org.opensearch.cluster.ClusterInfo;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiskUsage;
+import org.opensearch.cluster.health.ClusterHealthStatus;
+import org.opensearch.cluster.health.ClusterIndexHealth;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.allocation.DiskThresholdSettings;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.IndexModule;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.opensearch.index.IndexModule.INDEX_TIERING_STATE;
+
+/**
+ * Validator class to validate the tiering requests of the index
+ * @opensearch.experimental
+ */
+public class TieringRequestValidator {
+
+    private static final Logger logger = LogManager.getLogger(TieringRequestValidator.class);
+
+    /**
+     * Validates the tiering request for indices going from hot to warm tier
+     *
+     * @param currentState current cluster state
+     * @param concreteIndices set of indices to be validated
+     * @param clusterInfo the current nodes usage info for the cluster
+     * @param diskThresholdSettings the disk threshold settings of the cluster
+     * @return result of the validation
+     */
+    public static TieringValidationResult validateHotToWarm(
+        final ClusterState currentState,
+        final Set<Index> concreteIndices,
+        final ClusterInfo clusterInfo,
+        final DiskThresholdSettings diskThresholdSettings
+    ) {
+        final String indexNames = concreteIndices.stream().map(Index::getName).collect(Collectors.joining(", "));
+        validateSearchNodes(currentState, indexNames);
+        validateDiskThresholdWaterMarkNotBreached(currentState, clusterInfo, diskThresholdSettings, indexNames);
+
+        final TieringValidationResult tieringValidationResult = new TieringValidationResult(concreteIndices);
+
+        for (Index index : concreteIndices) {
+            if (!validateHotIndex(currentState, index)) {
+                tieringValidationResult.addToRejected(index, "index is not in the HOT tier");
+                continue;
+            }
+            if (!validateRemoteStoreIndex(currentState, index)) {
+                tieringValidationResult.addToRejected(index, "index is not backed up by the remote store");
+                continue;
+            }
+            if (!validateOpenIndex(currentState, index)) {
+                tieringValidationResult.addToRejected(index, "index is closed");
+                continue;
+            }
+            if (!validateIndexHealth(currentState, index)) {
+                tieringValidationResult.addToRejected(index, "index is red");
+                continue;
+            }
+        }
+
+        validateEligibleNodesCapacity(clusterInfo, currentState, tieringValidationResult);
+        logger.info(
+            "Successfully accepted indices for tiering are [{}], rejected indices are [{}]",
+            tieringValidationResult.getAcceptedIndices(),
+            tieringValidationResult.getRejectedIndices()
+        );
+
+        return tieringValidationResult;
+    }
+
+    /**
+     * Validates that there are eligible nodes with the search role in the current cluster state.
+     * (only for the dedicated case - to be removed later)
+     *
+     * @param currentState the current cluster state
+     * @param indexNames the names of the indices being validated
+     * @throws IllegalArgumentException if there are no eligible search nodes in the cluster
+     */
+    static void validateSearchNodes(final ClusterState currentState, final String indexNames) {
+        if (getEligibleNodes(currentState).isEmpty()) {
+            final String errorMsg = "Rejecting tiering request for indices ["
+                + indexNames
+                + "] because there are no nodes found with the search role";
+            logger.warn(errorMsg);
+            throw new IllegalArgumentException(errorMsg);
+        }
+    }
+
+    /**
+     * Validates that the specified index has the remote store setting enabled.
+     *
+     * @param state the current cluster state
+     * @param index the index to be validated
+     * @return true if the remote store setting is enabled for the index, false otherwise
+     */
+    static boolean validateRemoteStoreIndex(final ClusterState state, final Index index) {
+        return IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.get(state.metadata().getIndexSafe(index).getSettings());
+    }
+
+    /**
+     * Validates that the specified index is in the "hot" tiering state.
+     *
+     * @param state the current cluster state
+     * @param index the index to be validated
+     * @return true if the index is in the "hot" tiering state, false otherwise
+     */
+    static boolean validateHotIndex(final ClusterState state, final Index index) {
+        return IndexModule.TieringState.HOT.name().equals(INDEX_TIERING_STATE.get(state.metadata().getIndexSafe(index).getSettings()));
+    }
+
+    /**
+     * Validates the health of the specified index in the current cluster state.
+     *
+     * @param currentState the current cluster state
+     * @param index the index to be validated
+     * @return true if the index health is not in the "red" state, false otherwise
+     */
+    static boolean validateIndexHealth(final ClusterState currentState, final Index index) {
+        final IndexRoutingTable indexRoutingTable = currentState.routingTable().index(index);
+        final IndexMetadata indexMetadata = currentState.metadata().index(index);
+        final ClusterIndexHealth indexHealth = new ClusterIndexHealth(indexMetadata, indexRoutingTable);
+        return !ClusterHealthStatus.RED.equals(indexHealth.getStatus());
+    }
+
+    /**
+     * Validates that the specified index is in the open state in the current cluster state.
+     *
+     * @param currentState the current cluster state
+     * @param index the index to be validated
+     * @return true if the index is in the open state, false otherwise
+     */
+    static boolean validateOpenIndex(final ClusterState currentState, final Index index) {
+        return currentState.metadata().index(index).getState() == IndexMetadata.State.OPEN;
+    }
+
+    /**
+     * Validates that the disk threshold low watermark is not breached on all the eligible nodes in the cluster.
+     *
+     * @param currentState the current cluster state
+     * @param clusterInfo the current nodes usage info for the cluster
+     * @param diskThresholdSettings the disk threshold settings of the cluster
+     * @param indexNames the names of the indices being validated
+     * @throws IllegalArgumentException if the disk threshold low watermark is breached on all eligible nodes
+     */
+    static void validateDiskThresholdWaterMarkNotBreached(
+        final ClusterState currentState,
+        final ClusterInfo clusterInfo,
+        final DiskThresholdSettings diskThresholdSettings,
+        final String indexNames
+    ) {
+        final Map<String, DiskUsage> usages = clusterInfo.getNodeLeastAvailableDiskUsages();
+        if (usages == null) {
+            logger.trace("skipping monitor as no disk usage information is available");
+            return;
+        }
+        final Set<String> nodeIds = getEligibleNodes(currentState).stream().map(DiscoveryNode::getId).collect(Collectors.toSet());
+        for (String node : nodeIds) {
+            final DiskUsage nodeUsage = usages.get(node);
+            if (nodeUsage != null && nodeUsage.getFreeBytes() > diskThresholdSettings.getFreeBytesThresholdLow().getBytes()) {
+                return;
+            }
+        }
+        throw new IllegalArgumentException(
+            "Disk threshold low watermark is breached on all the search nodes, rejecting tiering request for indices: " + indexNames
+        );
+    }
+
+    /**
+     * Validates the capacity of eligible nodes in the cluster to accommodate the specified indices
+     * and adds the rejected indices to tieringValidationResult
+     *
+     * @param clusterInfo the current nodes usage info for the cluster
+     * @param currentState the current cluster state
+     * @param tieringValidationResult contains the indices to validate
+     */
+    static void validateEligibleNodesCapacity(
+        final ClusterInfo clusterInfo,
+        final ClusterState currentState,
+        final TieringValidationResult tieringValidationResult
+    ) {
+
+        final Set<String> eligibleNodeIds = getEligibleNodes(currentState).stream().map(DiscoveryNode::getId).collect(Collectors.toSet());
+        long totalAvailableBytesInWarmTier = getTotalAvailableBytesInWarmTier(
+            clusterInfo.getNodeLeastAvailableDiskUsages(),
+            eligibleNodeIds
+        );
+
+        Map<Index, Long> indexSizes = new HashMap<>();
+        for (Index index : tieringValidationResult.getAcceptedIndices()) {
+            indexSizes.put(index, getIndexPrimaryStoreSize(currentState, clusterInfo, index.getName()));
+        }
+
+        if (indexSizes.values().stream().mapToLong(Long::longValue).sum() < totalAvailableBytesInWarmTier) {
+            return;
+        }
+        HashMap<Index, Long> sortedIndexSizes = indexSizes.entrySet()
+            .stream()
+            .sorted(Map.Entry.comparingByValue())
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, HashMap::new));
+
+        long requestIndexBytes = 0L;
+        for (Index index : sortedIndexSizes.keySet()) {
+            requestIndexBytes += sortedIndexSizes.get(index);
+            if (requestIndexBytes >= totalAvailableBytesInWarmTier) {
+                tieringValidationResult.addToRejected(index, "insufficient node capacity");
+            }
+        }
+    }
+
+    /**
+     * Calculates the total size of the specified index in the cluster.
+     * Note: This function only accounts for the primary shard size.
+     *
+     * @param clusterState the current state of the cluster
+     * @param clusterInfo  the current nodes usage info for the cluster
+     * @param index        the name of the index for which the total size is to be calculated
+     * @return the total size of the specified index in the cluster
+     */
+    static long getIndexPrimaryStoreSize(ClusterState clusterState, ClusterInfo clusterInfo, String index) {
+        long totalIndexSize = 0;
+        List<ShardRouting> shardRoutings = clusterState.routingTable().allShards(index);
+        for (ShardRouting shardRouting : shardRoutings) {
+            if (shardRouting.primary()) {
+                totalIndexSize += clusterInfo.getShardSize(shardRouting, 0);
+            }
+        }
+        return totalIndexSize;
+    }
+
+    /**
+     * Calculates the total available bytes in the warm tier of the cluster.
+     *
+     * @param usages the current disk usage of the cluster
+     * @param nodeIds the set of warm nodes ids in the cluster
+     * @return the total available bytes in the warm tier
+     */
+    static long getTotalAvailableBytesInWarmTier(final Map<String, DiskUsage> usages, final Set<String> nodeIds) {
+        long totalAvailableBytes = 0;
+        for (String node : nodeIds) {
+            totalAvailableBytes += usages.get(node).getFreeBytes();
+        }
+        return totalAvailableBytes;
+    }
+
+    /**
+     * Retrieves the set of eligible(search) nodes from the current cluster state.
+     *
+     * @param currentState the current cluster state
+     * @return the set of eligible nodes
+     */
+    static Set<DiscoveryNode> getEligibleNodes(final ClusterState currentState) {
+        final Map<String, DiscoveryNode> nodes = currentState.getNodes().getDataNodes();
+        return nodes.values().stream().filter(DiscoveryNode::isSearchNode).collect(Collectors.toSet());
+    }
+}
diff --git a/server/src/main/java/org/opensearch/indices/tiering/package-info.java b/server/src/main/java/org/opensearch/indices/tiering/package-info.java
new file mode 100644
index 0000000000000..552f87382ea15
--- /dev/null
+++ b/server/src/main/java/org/opensearch/indices/tiering/package-info.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/**
+ * Validator layer checks that OpenSearch can perform to tier the indices
+ */
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.indices.tiering;
diff --git a/server/src/main/java/org/opensearch/ingest/AbstractBatchingProcessor.java b/server/src/main/java/org/opensearch/ingest/AbstractBatchingProcessor.java
new file mode 100644
index 0000000000000..55413b9bbdad1
--- /dev/null
+++ b/server/src/main/java/org/opensearch/ingest/AbstractBatchingProcessor.java
@@ -0,0 +1,136 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.ingest;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Consumer;
+
+import static org.opensearch.ingest.ConfigurationUtils.newConfigurationException;
+
+/**
+ * Abstract base class for batch processors.
+ *
+ * @opensearch.internal
+ */
+public abstract class AbstractBatchingProcessor extends AbstractProcessor {
+
+    public static final String BATCH_SIZE_FIELD = "batch_size";
+    private static final int DEFAULT_BATCH_SIZE = 1;
+    protected final int batchSize;
+
+    protected AbstractBatchingProcessor(String tag, String description, int batchSize) {
+        super(tag, description);
+        this.batchSize = batchSize;
+    }
+
+    /**
+     * Internal logic to process batched documents, must be implemented by concrete batch processors.
+     *
+     * @param ingestDocumentWrappers {@link List} of {@link IngestDocumentWrapper} to be processed.
+     * @param handler                {@link Consumer} to be called with the results of the processing.
+     */
+    protected abstract void subBatchExecute(
+        List<IngestDocumentWrapper> ingestDocumentWrappers,
+        Consumer<List<IngestDocumentWrapper>> handler
+    );
+
+    @Override
+    public void batchExecute(List<IngestDocumentWrapper> ingestDocumentWrappers, Consumer<List<IngestDocumentWrapper>> handler) {
+        if (ingestDocumentWrappers.isEmpty()) {
+            handler.accept(Collections.emptyList());
+            return;
+        }
+
+        // if batch size is larger than document size, send one batch
+        if (this.batchSize >= ingestDocumentWrappers.size()) {
+            subBatchExecute(ingestDocumentWrappers, handler);
+            return;
+        }
+
+        // split documents into multiple batches and send each batch to batch processors
+        List<List<IngestDocumentWrapper>> batches = cutBatches(ingestDocumentWrappers);
+        int size = ingestDocumentWrappers.size();
+        AtomicInteger counter = new AtomicInteger(size);
+        List<IngestDocumentWrapper> allResults = Collections.synchronizedList(new ArrayList<>());
+        for (List<IngestDocumentWrapper> batch : batches) {
+            this.subBatchExecute(batch, batchResults -> {
+                allResults.addAll(batchResults);
+                if (counter.addAndGet(-batchResults.size()) == 0) {
+                    handler.accept(allResults);
+                }
+                assert counter.get() >= 0 : "counter is negative";
+            });
+        }
+    }
+
+    private List<List<IngestDocumentWrapper>> cutBatches(List<IngestDocumentWrapper> ingestDocumentWrappers) {
+        List<List<IngestDocumentWrapper>> batches = new ArrayList<>();
+        for (int i = 0; i < ingestDocumentWrappers.size(); i += this.batchSize) {
+            batches.add(ingestDocumentWrappers.subList(i, Math.min(i + this.batchSize, ingestDocumentWrappers.size())));
+        }
+        return batches;
+    }
+
+    /**
+     * Factory class for creating {@link AbstractBatchingProcessor} instances.
+     *
+     * @opensearch.internal
+     */
+    public abstract static class Factory implements Processor.Factory {
+        final String processorType;
+
+        protected Factory(String processorType) {
+            this.processorType = processorType;
+        }
+
+        /**
+         * Creates a new processor instance.
+         *
+         * @param processorFactories The processor factories.
+         * @param tag                 The processor tag.
+         * @param description         The processor description.
+         * @param config              The processor configuration.
+         * @return The new AbstractBatchProcessor instance.
+         * @throws Exception If the processor could not be created.
+         */
+        @Override
+        public AbstractBatchingProcessor create(
+            Map<String, Processor.Factory> processorFactories,
+            String tag,
+            String description,
+            Map<String, Object> config
+        ) throws Exception {
+            int batchSize = ConfigurationUtils.readIntProperty(this.processorType, tag, config, BATCH_SIZE_FIELD, DEFAULT_BATCH_SIZE);
+            if (batchSize < 1) {
+                throw newConfigurationException(this.processorType, tag, BATCH_SIZE_FIELD, "batch size must be a positive integer");
+            }
+            return newProcessor(tag, description, batchSize, config);
+        }
+
+        /**
+         * Returns a new processor instance.
+         *
+         * @param tag tag of the processor
+         * @param description description of the processor
+         * @param batchSize batch size of the processor
+         * @param config configuration of the processor
+         * @return a new batch processor instance
+         */
+        protected abstract AbstractBatchingProcessor newProcessor(
+            String tag,
+            String description,
+            int batchSize,
+            Map<String, Object> config
+        );
+    }
+}
diff --git a/server/src/main/java/org/opensearch/ingest/IngestDocument.java b/server/src/main/java/org/opensearch/ingest/IngestDocument.java
index d975b0014de1f..9ec59e4c275a8 100644
--- a/server/src/main/java/org/opensearch/ingest/IngestDocument.java
+++ b/server/src/main/java/org/opensearch/ingest/IngestDocument.java
@@ -776,6 +776,9 @@ public static Object deepCopy(Object value) {
             byte[] bytes = (byte[]) value;
             return Arrays.copyOf(bytes, bytes.length);
         } else if (value == null
+            || value instanceof Byte
+            || value instanceof Character
+            || value instanceof Short
             || value instanceof String
             || value instanceof Integer
             || value instanceof Long
diff --git a/server/src/main/java/org/opensearch/ingest/IngestService.java b/server/src/main/java/org/opensearch/ingest/IngestService.java
index ab8e823199447..0315a960dae92 100644
--- a/server/src/main/java/org/opensearch/ingest/IngestService.java
+++ b/server/src/main/java/org/opensearch/ingest/IngestService.java
@@ -62,6 +62,7 @@
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.metrics.OperationMetrics;
 import org.opensearch.common.regex.Regex;
+import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AbstractRunnable;
@@ -107,6 +108,18 @@ public class IngestService implements ClusterStateApplier, ReportingService<Inge
 
     public static final String INGEST_ORIGIN = "ingest";
 
+    /**
+     * Defines the limit for the number of processors which can run on a given document during ingestion.
+     */
+    public static final Setting<Integer> MAX_NUMBER_OF_INGEST_PROCESSORS = Setting.intSetting(
+        "cluster.ingest.max_number_processors",
+        Integer.MAX_VALUE,
+        1,
+        Integer.MAX_VALUE,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
     private static final Logger logger = LogManager.getLogger(IngestService.class);
 
     private final ClusterService clusterService;
@@ -123,6 +136,7 @@ public class IngestService implements ClusterStateApplier, ReportingService<Inge
     private final ClusterManagerTaskThrottler.ThrottlingKey putPipelineTaskKey;
     private final ClusterManagerTaskThrottler.ThrottlingKey deletePipelineTaskKey;
     private volatile ClusterState state;
+    private volatile int maxIngestProcessorCount;
 
     public IngestService(
         ClusterService clusterService,
@@ -156,6 +170,12 @@ public IngestService(
         // Task is onboarded for throttling, it will get retried from associated TransportClusterManagerNodeAction.
         putPipelineTaskKey = clusterService.registerClusterManagerTask(ClusterManagerTaskKeys.PUT_PIPELINE_KEY, true);
         deletePipelineTaskKey = clusterService.registerClusterManagerTask(ClusterManagerTaskKeys.DELETE_PIPELINE_KEY, true);
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(MAX_NUMBER_OF_INGEST_PROCESSORS, this::setMaxIngestProcessorCount);
+        setMaxIngestProcessorCount(clusterService.getClusterSettings().get(MAX_NUMBER_OF_INGEST_PROCESSORS));
+    }
+
+    private void setMaxIngestProcessorCount(Integer maxIngestProcessorCount) {
+        this.maxIngestProcessorCount = maxIngestProcessorCount;
     }
 
     private static Map<String, Processor.Factory> processorFactories(List<IngestPlugin> ingestPlugins, Processor.Parameters parameters) {
@@ -494,6 +514,9 @@ void validatePipeline(Map<DiscoveryNode, IngestInfo> ingestInfos, PutPipelineReq
 
         Map<String, Object> pipelineConfig = XContentHelper.convertToMap(request.getSource(), false, request.getMediaType()).v2();
         Pipeline pipeline = Pipeline.create(request.getId(), pipelineConfig, processorFactories, scriptService);
+
+        validateProcessorCountForIngestPipeline(pipeline);
+
         List<Exception> exceptions = new ArrayList<>();
         for (Processor processor : pipeline.flattenAllProcessors()) {
             for (Map.Entry<DiscoveryNode, IngestInfo> entry : ingestInfos.entrySet()) {
@@ -507,6 +530,20 @@ void validatePipeline(Map<DiscoveryNode, IngestInfo> ingestInfos, PutPipelineReq
         ExceptionsHelper.rethrowAndSuppress(exceptions);
     }
 
+    public void validateProcessorCountForIngestPipeline(Pipeline pipeline) {
+        List<Processor> processors = pipeline.flattenAllProcessors();
+
+        if (processors.size() > maxIngestProcessorCount) {
+            throw new IllegalStateException(
+                "Cannot use more than the maximum processors allowed. Number of processors being configured is ["
+                    + processors.size()
+                    + "] which exceeds the maximum allowed configuration of ["
+                    + maxIngestProcessorCount
+                    + "] processors."
+            );
+        }
+    }
+
     public void executeBulkRequest(
         int numberOfActionRequests,
         Iterable<DocWriteRequest<?>> actionRequests,
@@ -525,61 +562,7 @@ public void onFailure(Exception e) {
 
             @Override
             protected void doRun() {
-                int batchSize = originalBulkRequest.batchSize();
-                if (shouldExecuteBulkRequestInBatch(originalBulkRequest.requests().size(), batchSize)) {
-                    runBulkRequestInBatch(numberOfActionRequests, actionRequests, onFailure, onCompletion, onDropped, originalBulkRequest);
-                    return;
-                }
-
-                final Thread originalThread = Thread.currentThread();
-                final AtomicInteger counter = new AtomicInteger(numberOfActionRequests);
-                int i = 0;
-                for (DocWriteRequest<?> actionRequest : actionRequests) {
-                    IndexRequest indexRequest = TransportBulkAction.getIndexWriteRequest(actionRequest);
-                    if (indexRequest == null) {
-                        if (counter.decrementAndGet() == 0) {
-                            onCompletion.accept(originalThread, null);
-                        }
-                        assert counter.get() >= 0;
-                        i++;
-                        continue;
-                    }
-                    final String pipelineId = indexRequest.getPipeline();
-                    indexRequest.setPipeline(NOOP_PIPELINE_NAME);
-                    final String finalPipelineId = indexRequest.getFinalPipeline();
-                    indexRequest.setFinalPipeline(NOOP_PIPELINE_NAME);
-                    boolean hasFinalPipeline = true;
-                    final List<String> pipelines;
-                    if (IngestService.NOOP_PIPELINE_NAME.equals(pipelineId) == false
-                        && IngestService.NOOP_PIPELINE_NAME.equals(finalPipelineId) == false) {
-                        pipelines = Arrays.asList(pipelineId, finalPipelineId);
-                    } else if (IngestService.NOOP_PIPELINE_NAME.equals(pipelineId) == false) {
-                        pipelines = Collections.singletonList(pipelineId);
-                        hasFinalPipeline = false;
-                    } else if (IngestService.NOOP_PIPELINE_NAME.equals(finalPipelineId) == false) {
-                        pipelines = Collections.singletonList(finalPipelineId);
-                    } else {
-                        if (counter.decrementAndGet() == 0) {
-                            onCompletion.accept(originalThread, null);
-                        }
-                        assert counter.get() >= 0;
-                        i++;
-                        continue;
-                    }
-
-                    executePipelines(
-                        i,
-                        pipelines.iterator(),
-                        hasFinalPipeline,
-                        indexRequest,
-                        onDropped,
-                        onFailure,
-                        counter,
-                        onCompletion,
-                        originalThread
-                    );
-                    i++;
-                }
+                runBulkRequestInBatch(numberOfActionRequests, actionRequests, onFailure, onCompletion, onDropped, originalBulkRequest);
             }
         });
     }
@@ -635,7 +618,7 @@ private void runBulkRequestInBatch(
             i++;
         }
 
-        int batchSize = originalBulkRequest.batchSize();
+        int batchSize = Math.min(numberOfActionRequests, originalBulkRequest.batchSize());
         List<List<IndexRequestWrapper>> batches = prepareBatches(batchSize, indexRequestWrappers);
         logger.debug("batchSize: {}, batches: {}", batchSize, batches.size());
 
@@ -654,10 +637,6 @@ private void runBulkRequestInBatch(
         }
     }
 
-    private boolean shouldExecuteBulkRequestInBatch(int documentSize, int batchSize) {
-        return documentSize > 1 && batchSize > 1;
-    }
-
     /**
      * IndexRequests are grouped by unique (index + pipeline_ids) before batching.
      * Only IndexRequests in the same group could be batched. It's to ensure batched documents always
@@ -685,7 +664,7 @@ static List<List<IndexRequestWrapper>> prepareBatches(int batchSize, List<IndexR
         }
         List<List<IndexRequestWrapper>> batchedIndexRequests = new ArrayList<>();
         for (Map.Entry<Integer, List<IndexRequestWrapper>> indexRequestsPerKey : indexRequestsPerIndexAndPipelines.entrySet()) {
-            for (int i = 0; i < indexRequestsPerKey.getValue().size(); i += batchSize) {
+            for (int i = 0; i < indexRequestsPerKey.getValue().size(); i += Math.min(indexRequestsPerKey.getValue().size(), batchSize)) {
                 batchedIndexRequests.add(
                     new ArrayList<>(
                         indexRequestsPerKey.getValue().subList(i, i + Math.min(batchSize, indexRequestsPerKey.getValue().size() - i))
@@ -775,7 +754,7 @@ private void executePipelinesInBatchRequests(
                                 ),
                                 results.get(i).getException()
                             );
-                            onFailure.accept(slots.get(i), results.get(i).getException());
+                            onFailure.accept(results.get(i).getSlot(), results.get(i).getException());
                         }
                     }
 
@@ -1055,7 +1034,7 @@ private void innerBatchExecute(
         Consumer<List<IngestDocumentWrapper>> handler
     ) {
         if (pipeline.getProcessors().isEmpty()) {
-            handler.accept(null);
+            handler.accept(toIngestDocumentWrappers(slots, indexRequests));
             return;
         }
 
@@ -1092,15 +1071,15 @@ private void innerBatchExecute(
                 }
                 if (!exceptions.isEmpty()) {
                     totalMetrics.failedN(exceptions.size());
-                } else if (!dropped.isEmpty()) {
+                }
+                if (!dropped.isEmpty()) {
                     dropped.forEach(t -> itemDroppedHandler.accept(t.getSlot()));
-                } else {
-                    for (IngestDocumentWrapper ingestDocumentWrapper : succeeded) {
-                        updateIndexRequestWithIngestDocument(
-                            slotToindexRequestMap.get(ingestDocumentWrapper.getSlot()),
-                            ingestDocumentWrapper.getIngestDocument()
-                        );
-                    }
+                }
+                for (IngestDocumentWrapper ingestDocumentWrapper : succeeded) {
+                    updateIndexRequestWithIngestDocument(
+                        slotToindexRequestMap.get(ingestDocumentWrapper.getSlot()),
+                        ingestDocumentWrapper.getIngestDocument()
+                    );
                 }
                 handler.accept(allResults);
             }
@@ -1329,6 +1308,14 @@ private static IngestDocumentWrapper toIngestDocumentWrapper(int slot, IndexRequ
         return new IngestDocumentWrapper(slot, toIngestDocument(indexRequest), null);
     }
 
+    private static List<IngestDocumentWrapper> toIngestDocumentWrappers(List<Integer> slots, List<IndexRequest> indexRequests) {
+        List<IngestDocumentWrapper> ingestDocumentWrappers = new ArrayList<>();
+        for (int i = 0; i < slots.size(); ++i) {
+            ingestDocumentWrappers.add(toIngestDocumentWrapper(slots.get(i), indexRequests.get(i)));
+        }
+        return ingestDocumentWrappers;
+    }
+
     private static Map<Integer, IndexRequest> createSlotIndexRequestMap(List<Integer> slots, List<IndexRequest> indexRequests) {
         Map<Integer, IndexRequest> slotIndexRequestMap = new HashMap<>();
         for (int i = 0; i < slots.size(); ++i) {
diff --git a/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java b/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
index 0c3d412ec4218..4d85087aca6a8 100644
--- a/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
+++ b/server/src/main/java/org/opensearch/monitor/fs/FsProbe.java
@@ -81,7 +81,15 @@ public FsInfo stats(FsInfo previous) throws IOException {
             if (fileCache != null && dataLocations[i].fileCacheReservedSize != ByteSizeValue.ZERO) {
                 paths[i].fileCacheReserved = adjustForHugeFilesystems(dataLocations[i].fileCacheReservedSize.getBytes());
                 paths[i].fileCacheUtilized = adjustForHugeFilesystems(fileCache.usage().usage());
-                paths[i].available -= (paths[i].fileCacheReserved - paths[i].fileCacheUtilized);
+                // fileCacheFree will be less than zero if the cache being over-subscribed
+                long fileCacheFree = paths[i].fileCacheReserved - paths[i].fileCacheUtilized;
+                if (fileCacheFree > 0) {
+                    paths[i].available -= fileCacheFree;
+                }
+                // occurs if reserved file cache space is occupied by other files, like local indices
+                if (paths[i].available < 0) {
+                    paths[i].available = 0;
+                }
             }
         }
         FsInfo.IoStats ioStats = null;
@@ -211,4 +219,11 @@ public static FsInfo.Path getFSInfo(NodePath nodePath) throws IOException {
         return fsPath;
     }
 
+    public static long getTotalSize(NodePath nodePath) throws IOException {
+        return adjustForHugeFilesystems(nodePath.fileStore.getTotalSpace());
+    }
+
+    public static long getAvailableSize(NodePath nodePath) throws IOException {
+        return adjustForHugeFilesystems(nodePath.fileStore.getUsableSpace());
+    }
 }
diff --git a/server/src/main/java/org/opensearch/node/Node.java b/server/src/main/java/org/opensearch/node/Node.java
index 4a702ec0234ef..42b84d8e79d88 100644
--- a/server/src/main/java/org/opensearch/node/Node.java
+++ b/server/src/main/java/org/opensearch/node/Node.java
@@ -38,6 +38,7 @@
 import org.opensearch.Build;
 import org.opensearch.ExceptionsHelper;
 import org.opensearch.OpenSearchException;
+import org.opensearch.OpenSearchParseException;
 import org.opensearch.OpenSearchTimeoutException;
 import org.opensearch.Version;
 import org.opensearch.action.ActionModule;
@@ -50,6 +51,7 @@
 import org.opensearch.action.search.SearchRequestOperationsListener;
 import org.opensearch.action.search.SearchRequestSlowLog;
 import org.opensearch.action.search.SearchRequestStats;
+import org.opensearch.action.search.SearchTaskRequestOperationsListener;
 import org.opensearch.action.search.SearchTransportService;
 import org.opensearch.action.support.TransportAction;
 import org.opensearch.action.update.UpdateHelper;
@@ -58,6 +60,7 @@
 import org.opensearch.client.Client;
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.cluster.ClusterInfoService;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterModule;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
@@ -65,6 +68,8 @@
 import org.opensearch.cluster.InternalClusterInfoService;
 import org.opensearch.cluster.NodeConnectionsService;
 import org.opensearch.cluster.action.index.MappingUpdatedAction;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesPlugin;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesService;
 import org.opensearch.cluster.coordination.PersistedStateRegistry;
 import org.opensearch.cluster.metadata.AliasValidator;
 import org.opensearch.cluster.metadata.IndexTemplateMetadata;
@@ -106,6 +111,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsException;
 import org.opensearch.common.settings.SettingsModule;
+import org.opensearch.common.unit.RatioValue;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.FeatureFlags;
@@ -136,6 +142,7 @@
 import org.opensearch.gateway.MetaStateService;
 import org.opensearch.gateway.PersistedClusterStateService;
 import org.opensearch.gateway.ShardsBatchGatewayAllocator;
+import org.opensearch.gateway.remote.RemoteClusterStateCleanupManager;
 import org.opensearch.gateway.remote.RemoteClusterStateService;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.identity.IdentityService;
@@ -144,6 +151,7 @@
 import org.opensearch.index.IndexingPressureService;
 import org.opensearch.index.SegmentReplicationStatsTracker;
 import org.opensearch.index.analysis.AnalysisRegistry;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
 import org.opensearch.index.engine.EngineFactory;
 import org.opensearch.index.recovery.RemoteStoreRestoreService;
 import org.opensearch.index.remote.RemoteIndexPathUploader;
@@ -152,6 +160,7 @@
 import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.index.store.remote.filecache.FileCacheCleaner;
 import org.opensearch.index.store.remote.filecache.FileCacheFactory;
+import org.opensearch.index.store.remote.filecache.FileCacheSettings;
 import org.opensearch.indices.IndicesModule;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.RemoteStoreSettings;
@@ -168,14 +177,15 @@
 import org.opensearch.indices.replication.SegmentReplicationSourceFactory;
 import org.opensearch.indices.replication.SegmentReplicationSourceService;
 import org.opensearch.indices.replication.SegmentReplicationTargetService;
+import org.opensearch.indices.replication.SegmentReplicator;
 import org.opensearch.indices.store.IndicesStore;
 import org.opensearch.ingest.IngestService;
 import org.opensearch.monitor.MonitorService;
 import org.opensearch.monitor.fs.FsHealthService;
-import org.opensearch.monitor.fs.FsInfo;
 import org.opensearch.monitor.fs.FsProbe;
 import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
 import org.opensearch.node.resource.tracker.NodeResourceUsageTracker;
 import org.opensearch.persistent.PersistentTasksClusterService;
 import org.opensearch.persistent.PersistentTasksExecutor;
@@ -191,6 +201,7 @@
 import org.opensearch.plugins.DiscoveryPlugin;
 import org.opensearch.plugins.EnginePlugin;
 import org.opensearch.plugins.ExtensionAwarePlugin;
+import org.opensearch.plugins.IdentityAwarePlugin;
 import org.opensearch.plugins.IdentityPlugin;
 import org.opensearch.plugins.IndexStorePlugin;
 import org.opensearch.plugins.IngestPlugin;
@@ -222,6 +233,7 @@
 import org.opensearch.search.aggregations.support.AggregationUsageService;
 import org.opensearch.search.backpressure.SearchBackpressureService;
 import org.opensearch.search.backpressure.settings.SearchBackpressureSettings;
+import org.opensearch.search.deciders.ConcurrentSearchDecider;
 import org.opensearch.search.fetch.FetchPhase;
 import org.opensearch.search.pipeline.SearchPipelineService;
 import org.opensearch.search.query.QueryPhase;
@@ -254,6 +266,9 @@
 import org.opensearch.transport.TransportService;
 import org.opensearch.usage.UsageService;
 import org.opensearch.watcher.ResourceWatcherService;
+import org.opensearch.wlm.QueryGroupService;
+import org.opensearch.wlm.WorkloadManagementTransportInterceptor;
+import org.opensearch.wlm.listeners.QueryGroupRequestOperationListener;
 
 import javax.net.ssl.SNIHostName;
 
@@ -291,6 +306,8 @@
 import static org.opensearch.common.util.FeatureFlags.TELEMETRY;
 import static org.opensearch.env.NodeEnvironment.collectFileCacheDataPath;
 import static org.opensearch.index.ShardIndexingPressureSettings.SHARD_INDEXING_PRESSURE_ENABLED_ATTRIBUTE_KEY;
+import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteDataAttributePresent;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreAttributePresent;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteStoreClusterStateEnabled;
 
@@ -368,9 +385,12 @@ public class Node implements Closeable {
         }
     }, Setting.Property.NodeScope);
 
-    public static final Setting<ByteSizeValue> NODE_SEARCH_CACHE_SIZE_SETTING = Setting.byteSizeSetting(
+    private static final String ZERO = "0";
+
+    public static final Setting<String> NODE_SEARCH_CACHE_SIZE_SETTING = new Setting<>(
         "node.search.cache.size",
-        ByteSizeValue.ZERO,
+        s -> (DiscoveryNode.isDedicatedSearchNode(s)) ? "80%" : ZERO,
+        Node::validateFileCacheSize,
         Property.NodeScope
     );
 
@@ -508,19 +528,6 @@ protected Node(
                 identityPlugins.addAll(pluginsService.filterPlugins(IdentityPlugin.class));
             }
 
-            final IdentityService identityService = new IdentityService(settings, identityPlugins);
-
-            if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
-                final List<ExtensionAwarePlugin> extensionAwarePlugins = pluginsService.filterPlugins(ExtensionAwarePlugin.class);
-                Set<Setting<?>> additionalSettings = new HashSet<>();
-                for (ExtensionAwarePlugin extAwarePlugin : extensionAwarePlugins) {
-                    additionalSettings.addAll(extAwarePlugin.getExtensionSettings());
-                }
-                this.extensionsManager = new ExtensionsManager(additionalSettings, identityService);
-            } else {
-                this.extensionsManager = new NoopExtensionsManager();
-            }
-
             final Set<DiscoveryNodeRole> additionalRoles = pluginsService.filterPlugins(Plugin.class)
                 .stream()
                 .map(Plugin::getRoles)
@@ -558,6 +565,19 @@ protected Node(
             runnableTaskListener = new AtomicReference<>();
             final ThreadPool threadPool = new ThreadPool(settings, runnableTaskListener, executorBuilders.toArray(new ExecutorBuilder[0]));
 
+            final IdentityService identityService = new IdentityService(settings, threadPool, identityPlugins);
+
+            if (FeatureFlags.isEnabled(FeatureFlags.EXTENSIONS)) {
+                final List<ExtensionAwarePlugin> extensionAwarePlugins = pluginsService.filterPlugins(ExtensionAwarePlugin.class);
+                Set<Setting<?>> additionalSettings = new HashSet<>();
+                for (ExtensionAwarePlugin extAwarePlugin : extensionAwarePlugins) {
+                    additionalSettings.addAll(extAwarePlugin.getExtensionSettings());
+                }
+                this.extensionsManager = new ExtensionsManager(additionalSettings, identityService);
+            } else {
+                this.extensionsManager = new NoopExtensionsManager(identityService);
+            }
+
             final SetOnce<RepositoriesService> repositoriesServiceReference = new SetOnce<>();
             final RemoteStoreNodeService remoteStoreNodeService = new RemoteStoreNodeService(repositoriesServiceReference::get, threadPool);
             localNodeFactory = new LocalNodeFactory(settings, nodeEnvironment.nodeId(), remoteStoreNodeService);
@@ -604,21 +624,10 @@ protected Node(
                 getCustomNameResolvers(pluginsService.filterPlugins(DiscoveryPlugin.class))
             );
 
-            List<ClusterPlugin> clusterPlugins = pluginsService.filterPlugins(ClusterPlugin.class);
-            final ClusterService clusterService = new ClusterService(settings, settingsModule.getClusterSettings(), threadPool);
-            clusterService.addStateApplier(scriptService);
-            resourcesToClose.add(clusterService);
-            final Set<Setting<?>> consistentSettings = settingsModule.getConsistentSettings();
-            if (consistentSettings.isEmpty() == false) {
-                clusterService.addLocalNodeMasterListener(
-                    new ConsistentSettingsService(settings, clusterService, consistentSettings).newHashPublisher()
-                );
-            }
-
             TracerFactory tracerFactory;
             MetricsRegistryFactory metricsRegistryFactory;
             if (FeatureFlags.isEnabled(TELEMETRY)) {
-                final TelemetrySettings telemetrySettings = new TelemetrySettings(settings, clusterService.getClusterSettings());
+                final TelemetrySettings telemetrySettings = new TelemetrySettings(settings, settingsModule.getClusterSettings());
                 if (telemetrySettings.isTracingFeatureEnabled() || telemetrySettings.isMetricsFeatureEnabled()) {
                     List<TelemetryPlugin> telemetryPlugins = pluginsService.filterPlugins(TelemetryPlugin.class);
                     List<TelemetryPlugin> telemetryPluginsImplementingTelemetryAware = telemetryPlugins.stream()
@@ -658,6 +667,33 @@ protected Node(
             resourcesToClose.add(tracer::close);
             resourcesToClose.add(metricsRegistry::close);
 
+            final ClusterManagerMetrics clusterManagerMetrics = new ClusterManagerMetrics(metricsRegistry);
+
+            List<ClusterPlugin> clusterPlugins = pluginsService.filterPlugins(ClusterPlugin.class);
+            final ClusterService clusterService = new ClusterService(
+                settings,
+                settingsModule.getClusterSettings(),
+                threadPool,
+                clusterManagerMetrics
+            );
+            clusterService.addStateApplier(scriptService);
+            resourcesToClose.add(clusterService);
+            final Set<Setting<?>> consistentSettings = settingsModule.getConsistentSettings();
+            if (consistentSettings.isEmpty() == false) {
+                clusterService.addLocalNodeClusterManagerListener(
+                    new ConsistentSettingsService(settings, clusterService, consistentSettings).newHashPublisher()
+                );
+            }
+
+            SystemTemplatesService systemTemplatesService = new SystemTemplatesService(
+                pluginsService.filterPlugins(SystemTemplatesPlugin.class),
+                threadPool,
+                clusterService.getClusterSettings(),
+                settings
+            );
+            systemTemplatesService.verifyRepositories();
+            clusterService.addLocalNodeClusterManagerListener(systemTemplatesService);
+
             final ClusterInfoService clusterInfoService = newClusterInfoService(settings, clusterService, threadPool, client);
             final UsageService usageService = new UsageService();
 
@@ -679,13 +715,25 @@ protected Node(
                 repositoriesServiceReference::get,
                 rerouteServiceReference::get
             );
+            final Map<String, Collection<SystemIndexDescriptor>> systemIndexDescriptorMap = Collections.unmodifiableMap(
+                pluginsService.filterPlugins(SystemIndexPlugin.class)
+                    .stream()
+                    .collect(
+                        Collectors.toMap(
+                            plugin -> plugin.getClass().getCanonicalName(),
+                            plugin -> plugin.getSystemIndexDescriptors(settings)
+                        )
+                    )
+            );
+            final SystemIndices systemIndices = new SystemIndices(systemIndexDescriptorMap);
             final ClusterModule clusterModule = new ClusterModule(
                 settings,
                 clusterService,
                 clusterPlugins,
                 clusterInfoService,
                 snapshotsInfoService,
-                threadPool.getThreadContext()
+                threadPool.getThreadContext(),
+                clusterManagerMetrics
             );
             modules.add(clusterModule);
             IndicesModule indicesModule = new IndicesModule(pluginsService.filterPlugins(MapperPlugin.class));
@@ -740,27 +788,45 @@ protected Node(
                 clusterService.getClusterSettings(),
                 threadPool::relativeTimeInMillis
             );
+            final RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(settings, settingsModule.getClusterSettings());
             final RemoteClusterStateService remoteClusterStateService;
+            final RemoteClusterStateCleanupManager remoteClusterStateCleanupManager;
             final RemoteIndexPathUploader remoteIndexPathUploader;
             if (isRemoteStoreClusterStateEnabled(settings)) {
                 remoteIndexPathUploader = new RemoteIndexPathUploader(
                     threadPool,
                     settings,
                     repositoriesServiceReference::get,
-                    clusterService.getClusterSettings()
+                    clusterService.getClusterSettings(),
+                    remoteStoreSettings
                 );
                 remoteClusterStateService = new RemoteClusterStateService(
                     nodeEnvironment.nodeId(),
                     repositoriesServiceReference::get,
                     settings,
-                    clusterService.getClusterSettings(),
+                    clusterService,
                     threadPool::preciseRelativeTimeInNanos,
                     threadPool,
-                    List.of(remoteIndexPathUploader)
+                    List.of(remoteIndexPathUploader),
+                    namedWriteableRegistry
                 );
+                remoteClusterStateCleanupManager = remoteClusterStateService.getCleanupManager();
             } else {
                 remoteClusterStateService = null;
                 remoteIndexPathUploader = null;
+                remoteClusterStateCleanupManager = null;
+            }
+            final RemoteStorePinnedTimestampService remoteStorePinnedTimestampService;
+            if (isRemoteDataAttributePresent(settings) && CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.get(settings)) {
+                remoteStorePinnedTimestampService = new RemoteStorePinnedTimestampService(
+                    repositoriesServiceReference::get,
+                    settings,
+                    threadPool,
+                    clusterService
+                );
+                resourcesToClose.add(remoteStorePinnedTimestampService);
+            } else {
+                remoteStorePinnedTimestampService = null;
             }
 
             // collect engine factory providers from plugins
@@ -798,34 +864,36 @@ protected Node(
                 .flatMap(m -> m.entrySet().stream())
                 .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
 
-            final Map<String, Collection<SystemIndexDescriptor>> systemIndexDescriptorMap = Collections.unmodifiableMap(
-                pluginsService.filterPlugins(SystemIndexPlugin.class)
-                    .stream()
-                    .collect(
-                        Collectors.toMap(plugin -> plugin.getClass().getSimpleName(), plugin -> plugin.getSystemIndexDescriptors(settings))
-                    )
-            );
-            final SystemIndices systemIndices = new SystemIndices(systemIndexDescriptorMap);
-
             final RerouteService rerouteService = new BatchedRerouteService(clusterService, clusterModule.getAllocationService()::reroute);
             rerouteServiceReference.set(rerouteService);
             clusterService.setRerouteService(rerouteService);
 
             final RecoverySettings recoverySettings = new RecoverySettings(settings, settingsModule.getClusterSettings());
 
-            final RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(settings, settingsModule.getClusterSettings());
+            final CompositeIndexSettings compositeIndexSettings = new CompositeIndexSettings(settings, settingsModule.getClusterSettings());
 
             final IndexStorePlugin.DirectoryFactory remoteDirectoryFactory = new RemoteSegmentStoreDirectoryFactory(
                 repositoriesServiceReference::get,
+                threadPool,
+                remoteStoreSettings.getSegmentsPathFixedPrefix()
+            );
+
+            final TaskResourceTrackingService taskResourceTrackingService = new TaskResourceTrackingService(
+                settings,
+                clusterService.getClusterSettings(),
                 threadPool
             );
 
             final SearchRequestStats searchRequestStats = new SearchRequestStats(clusterService.getClusterSettings());
             final SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService);
+            final SearchTaskRequestOperationsListener searchTaskRequestOperationsListener = new SearchTaskRequestOperationsListener(
+                taskResourceTrackingService
+            );
 
             remoteStoreStatsTrackerFactory = new RemoteStoreStatsTrackerFactory(clusterService, settings);
             CacheModule cacheModule = new CacheModule(pluginsService.filterPlugins(CachePlugin.class), settings);
             CacheService cacheService = cacheModule.getCacheService();
+            final SegmentReplicator segmentReplicator = new SegmentReplicator(threadPool);
             final IndicesService indicesService = new IndicesService(
                 settings,
                 pluginsService,
@@ -853,7 +921,10 @@ protected Node(
                 remoteStoreStatsTrackerFactory,
                 recoverySettings,
                 cacheService,
-                remoteStoreSettings
+                remoteStoreSettings,
+                fileCache,
+                compositeIndexSettings,
+                segmentReplicator::startReplication
             );
 
             final IngestService ingestService = new IngestService(
@@ -945,11 +1016,26 @@ protected Node(
             // Add the telemetryAwarePlugin components to the existing pluginComponents collection.
             pluginComponents.addAll(telemetryAwarePluginComponents);
 
+            List<IdentityAwarePlugin> identityAwarePlugins = pluginsService.filterPlugins(IdentityAwarePlugin.class);
+            identityService.initializeIdentityAwarePlugins(identityAwarePlugins);
+
+            final QueryGroupService queryGroupService = new QueryGroupService(); // We will need to replace this with actual instance of the
+                                                                                 // queryGroupService
+            final QueryGroupRequestOperationListener queryGroupRequestOperationListener = new QueryGroupRequestOperationListener(
+                queryGroupService,
+                threadPool
+            );
+
             // register all standard SearchRequestOperationsCompositeListenerFactory to the SearchRequestOperationsCompositeListenerFactory
             final SearchRequestOperationsCompositeListenerFactory searchRequestOperationsCompositeListenerFactory =
                 new SearchRequestOperationsCompositeListenerFactory(
                     Stream.concat(
-                        Stream.of(searchRequestStats, searchRequestSlowLog),
+                        Stream.of(
+                            searchRequestStats,
+                            searchRequestSlowLog,
+                            searchTaskRequestOperationsListener,
+                            queryGroupRequestOperationListener
+                        ),
                         pluginComponents.stream()
                             .filter(p -> p instanceof SearchRequestOperationsListener)
                             .map(p -> (SearchRequestOperationsListener) p)
@@ -998,6 +1084,11 @@ protected Node(
                 admissionControlService
             );
 
+            WorkloadManagementTransportInterceptor workloadManagementTransportInterceptor = new WorkloadManagementTransportInterceptor(
+                threadPool,
+                new QueryGroupService() // We will need to replace this with actual implementation
+            );
+
             final Collection<SecureSettingsFactory> secureSettingsFactories = pluginsService.filterPlugins(Plugin.class)
                 .stream()
                 .map(p -> p.getSecureSettingFactory(settings))
@@ -1005,7 +1096,10 @@ protected Node(
                 .map(Optional::get)
                 .collect(Collectors.toList());
 
-            List<TransportInterceptor> transportInterceptors = List.of(admissionControlTransportInterceptor);
+            List<TransportInterceptor> transportInterceptors = List.of(
+                admissionControlTransportInterceptor,
+                workloadManagementTransportInterceptor
+            );
             final NetworkModule networkModule = new NetworkModule(
                 settings,
                 pluginsService.filterPlugins(NetworkPlugin.class),
@@ -1077,12 +1171,6 @@ protected Node(
             // development. Then we can deprecate Getter and Setter for IndexingPressureService in ClusterService (#478).
             clusterService.setIndexingPressureService(indexingPressureService);
 
-            final TaskResourceTrackingService taskResourceTrackingService = new TaskResourceTrackingService(
-                settings,
-                clusterService.getClusterSettings(),
-                threadPool
-            );
-
             final SearchBackpressureSettings searchBackpressureSettings = new SearchBackpressureSettings(
                 settings,
                 clusterService.getClusterSettings()
@@ -1118,7 +1206,9 @@ protected Node(
                 clusterModule.getIndexNameExpressionResolver(),
                 repositoryService,
                 transportService,
-                actionModule.getActionFilters()
+                actionModule.getActionFilters(),
+                remoteStorePinnedTimestampService,
+                remoteStoreSettings
             );
             SnapshotShardsService snapshotShardsService = new SnapshotShardsService(
                 settings,
@@ -1142,7 +1232,8 @@ protected Node(
                 metadataIndexUpgradeService,
                 shardLimitValidator,
                 indicesService,
-                clusterInfoService::getClusterInfo
+                clusterInfoService::getClusterInfo,
+                new FileCacheSettings(settings, clusterService.getClusterSettings())::getRemoteDataRatio
             );
 
             RemoteStoreRestoreService remoteStoreRestoreService = new RemoteStoreRestoreService(
@@ -1180,7 +1271,9 @@ protected Node(
                 rerouteService,
                 fsHealthService,
                 persistedStateRegistry,
-                remoteStoreNodeService
+                remoteStoreNodeService,
+                clusterManagerMetrics,
+                remoteClusterStateService
             );
             final SearchPipelineService searchPipelineService = new SearchPipelineService(
                 clusterService,
@@ -1241,7 +1334,9 @@ protected Node(
                 searchModule.getFetchPhase(),
                 responseCollectorService,
                 circuitBreakerService,
-                searchModule.getIndexSearcherExecutor(threadPool)
+                searchModule.getIndexSearcherExecutor(threadPool),
+                taskResourceTrackingService,
+                searchModule.getConcurrentSearchDeciders()
             );
 
             final List<PersistentTasksExecutor<?>> tasksExecutors = pluginsService.filterPlugins(PersistentTaskPlugin.class)
@@ -1316,8 +1411,8 @@ protected Node(
                 b.bind(SnapshotsInfoService.class).toInstance(snapshotsInfoService);
                 b.bind(GatewayMetaState.class).toInstance(gatewayMetaState);
                 b.bind(Discovery.class).toInstance(discoveryModule.getDiscovery());
+                b.bind(RemoteStoreSettings.class).toInstance(remoteStoreSettings);
                 {
-                    processRecoverySettings(settingsModule.getClusterSettings(), recoverySettings);
                     b.bind(PeerRecoverySourceService.class)
                         .toInstance(new PeerRecoverySourceService(transportService, indicesService, recoverySettings));
                     b.bind(PeerRecoveryTargetService.class)
@@ -1330,7 +1425,8 @@ protected Node(
                                 transportService,
                                 new SegmentReplicationSourceFactory(transportService, recoverySettings, clusterService),
                                 indicesService,
-                                clusterService
+                                clusterService,
+                                segmentReplicator
                             )
                         );
                     b.bind(SegmentReplicationSourceService.class)
@@ -1360,9 +1456,12 @@ protected Node(
                 b.bind(MetricsRegistry.class).toInstance(metricsRegistry);
                 b.bind(RemoteClusterStateService.class).toProvider(() -> remoteClusterStateService);
                 b.bind(RemoteIndexPathUploader.class).toProvider(() -> remoteIndexPathUploader);
+                b.bind(RemoteStorePinnedTimestampService.class).toProvider(() -> remoteStorePinnedTimestampService);
+                b.bind(RemoteClusterStateCleanupManager.class).toProvider(() -> remoteClusterStateCleanupManager);
                 b.bind(PersistedStateRegistry.class).toInstance(persistedStateRegistry);
                 b.bind(SegmentReplicationStatsTracker.class).toInstance(segmentReplicationStatsTracker);
                 b.bind(SearchRequestOperationsCompositeListenerFactory.class).toInstance(searchRequestOperationsCompositeListenerFactory);
+                b.bind(SegmentReplicator.class).toInstance(segmentReplicator);
             });
             injector = modules.createInjector();
 
@@ -1424,10 +1523,6 @@ protected TransportService newTransportService(
         return new TransportService(settings, transport, threadPool, interceptor, localNodeFactory, clusterSettings, taskHeaders, tracer);
     }
 
-    protected void processRecoverySettings(ClusterSettings clusterSettings, RecoverySettings recoverySettings) {
-        // Noop in production, overridden by tests
-    }
-
     /**
      * The settings that are used by this node. Contains original settings as well as additional settings provided by plugins.
      */
@@ -1516,6 +1611,12 @@ public Node start() throws NodeValidationException {
         if (remoteIndexPathUploader != null) {
             remoteIndexPathUploader.start();
         }
+        final RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = injector.getInstance(
+            RemoteStorePinnedTimestampService.class
+        );
+        if (remoteStorePinnedTimestampService != null) {
+            remoteStorePinnedTimestampService.start();
+        }
         // Load (and maybe upgrade) the metadata stored on disk
         final GatewayMetaState gatewayMetaState = injector.getInstance(GatewayMetaState.class);
         gatewayMetaState.start(
@@ -1883,7 +1984,9 @@ protected SearchService newSearchService(
         FetchPhase fetchPhase,
         ResponseCollectorService responseCollectorService,
         CircuitBreakerService circuitBreakerService,
-        Executor indexSearcherExecutor
+        Executor indexSearcherExecutor,
+        TaskResourceTrackingService taskResourceTrackingService,
+        Collection<ConcurrentSearchDecider> concurrentSearchDecidersList
     ) {
         return new SearchService(
             clusterService,
@@ -1895,7 +1998,9 @@ protected SearchService newSearchService(
             fetchPhase,
             responseCollectorService,
             circuitBreakerService,
-            indexSearcherExecutor
+            indexSearcherExecutor,
+            taskResourceTrackingService,
+            concurrentSearchDecidersList
         );
     }
 
@@ -1979,39 +2084,58 @@ DiscoveryNode getNode() {
      * Initializes the search cache with a defined capacity.
      * The capacity of the cache is based on user configuration for {@link Node#NODE_SEARCH_CACHE_SIZE_SETTING}.
      * If the user doesn't configure the cache size, it fails if the node is a data + search node.
-     * Else it configures the size to 80% of available capacity for a dedicated search node, if not explicitly defined.
+     * Else it configures the size to 80% of total capacity for a dedicated search node, if not explicitly defined.
      */
     private void initializeFileCache(Settings settings, CircuitBreaker circuitBreaker) throws IOException {
-        if (DiscoveryNode.isSearchNode(settings)) {
-            NodeEnvironment.NodePath fileCacheNodePath = nodeEnvironment.fileCacheNodePath();
-            long capacity = NODE_SEARCH_CACHE_SIZE_SETTING.get(settings).getBytes();
-            FsInfo.Path info = ExceptionsHelper.catchAsRuntimeException(() -> FsProbe.getFSInfo(fileCacheNodePath));
-            long availableCapacity = info.getAvailable().getBytes();
-
-            // Initialize default values for cache if NODE_SEARCH_CACHE_SIZE_SETTING is not set.
-            if (capacity == 0) {
-                // If node is not a dedicated search node without configuration, prevent cache initialization
-                if (DiscoveryNode.getRolesFromSettings(settings).stream().anyMatch(role -> !DiscoveryNodeRole.SEARCH_ROLE.equals(role))) {
-                    throw new SettingsException(
-                        "Unable to initialize the "
-                            + DiscoveryNodeRole.SEARCH_ROLE.roleName()
-                            + "-"
-                            + DiscoveryNodeRole.DATA_ROLE.roleName()
-                            + " node: Missing value for configuration "
-                            + NODE_SEARCH_CACHE_SIZE_SETTING.getKey()
-                    );
-                } else {
-                    capacity = 80 * availableCapacity / 100;
-                }
+        if (DiscoveryNode.isSearchNode(settings) == false) {
+            return;
+        }
+
+        String capacityRaw = NODE_SEARCH_CACHE_SIZE_SETTING.get(settings);
+        logger.info("cache size [{}]", capacityRaw);
+        if (capacityRaw.equals(ZERO)) {
+            throw new SettingsException(
+                "Unable to initialize the "
+                    + DiscoveryNodeRole.SEARCH_ROLE.roleName()
+                    + "-"
+                    + DiscoveryNodeRole.DATA_ROLE.roleName()
+                    + " node: Missing value for configuration "
+                    + NODE_SEARCH_CACHE_SIZE_SETTING.getKey()
+            );
+        }
+
+        NodeEnvironment.NodePath fileCacheNodePath = nodeEnvironment.fileCacheNodePath();
+        long totalSpace = ExceptionsHelper.catchAsRuntimeException(() -> FsProbe.getTotalSize(fileCacheNodePath));
+        long capacity = calculateFileCacheSize(capacityRaw, totalSpace);
+        if (capacity <= 0 || totalSpace <= capacity) {
+            throw new SettingsException("Cache size must be larger than zero and less than total capacity");
+        }
+
+        this.fileCache = FileCacheFactory.createConcurrentLRUFileCache(capacity, circuitBreaker);
+        fileCacheNodePath.fileCacheReservedSize = new ByteSizeValue(this.fileCache.capacity(), ByteSizeUnit.BYTES);
+        List<Path> fileCacheDataPaths = collectFileCacheDataPath(fileCacheNodePath);
+        this.fileCache.restoreFromDirectory(fileCacheDataPaths);
+    }
+
+    private static long calculateFileCacheSize(String capacityRaw, long totalSpace) {
+        try {
+            RatioValue ratioValue = RatioValue.parseRatioValue(capacityRaw);
+            return Math.round(totalSpace * ratioValue.getAsRatio());
+        } catch (OpenSearchParseException e) {
+            try {
+                return ByteSizeValue.parseBytesSizeValue(capacityRaw, NODE_SEARCH_CACHE_SIZE_SETTING.getKey()).getBytes();
+            } catch (OpenSearchParseException ex) {
+                ex.addSuppressed(e);
+                throw ex;
             }
-            capacity = Math.min(capacity, availableCapacity);
-            fileCacheNodePath.fileCacheReservedSize = new ByteSizeValue(capacity, ByteSizeUnit.BYTES);
-            this.fileCache = FileCacheFactory.createConcurrentLRUFileCache(capacity, circuitBreaker);
-            List<Path> fileCacheDataPaths = collectFileCacheDataPath(fileCacheNodePath);
-            this.fileCache.restoreFromDirectory(fileCacheDataPaths);
         }
     }
 
+    private static String validateFileCacheSize(String capacityRaw) {
+        calculateFileCacheSize(capacityRaw, 0L);
+        return capacityRaw;
+    }
+
     /**
      * Returns the {@link FileCache} instance for remote search node
      * Note: Visible for testing
diff --git a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeAttribute.java b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeAttribute.java
index b10ec0d99c3d5..55971398634c5 100644
--- a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeAttribute.java
+++ b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeAttribute.java
@@ -46,6 +46,8 @@ public class RemoteStoreNodeAttribute {
         + "."
         + CryptoMetadata.SETTINGS_KEY;
     public static final String REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX = "remote_store.repository.%s.settings.";
+    public static final String REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY = "remote_store.routing_table.repository";
+
     private final RepositoriesMetadata repositoriesMetadata;
 
     public static List<String> SUPPORTED_DATA_REPO_NAME_ATTRIBUTES = List.of(
@@ -53,6 +55,11 @@ public class RemoteStoreNodeAttribute {
         REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY
     );
 
+    public static List<String> REMOTE_CLUSTER_PUBLICATION_REPO_NAME_ATTRIBUTES = List.of(
+        REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+        REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY
+    );
+
     /**
      * Creates a new {@link RemoteStoreNodeAttribute}
      */
@@ -157,6 +164,10 @@ private Set<String> getValidatedRepositoryNames(DiscoveryNode node) {
         } else if (node.getAttributes().containsKey(REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY)) {
             repositoryNames.add(validateAttributeNonNull(node, REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY));
         }
+        if (node.getAttributes().containsKey(REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY)) {
+            repositoryNames.add(validateAttributeNonNull(node, REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY));
+        }
+
         return repositoryNames;
     }
 
@@ -187,6 +198,15 @@ public static boolean isRemoteStoreClusterStateEnabled(Settings settings) {
             && isRemoteClusterStateAttributePresent(settings);
     }
 
+    private static boolean isRemoteRoutingTableAttributePresent(Settings settings) {
+        return settings.getByPrefix(Node.NODE_ATTRIBUTES.getKey() + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY)
+            .isEmpty() == false;
+    }
+
+    public static boolean isRemoteRoutingTableEnabled(Settings settings) {
+        return isRemoteRoutingTableAttributePresent(settings);
+    }
+
     public RepositoriesMetadata getRepositoriesMetadata() {
         return this.repositoriesMetadata;
     }
@@ -231,6 +251,29 @@ public int hashCode() {
         return hashCode;
     }
 
+    /**
+     * Checks if 2 instances are equal, with option to skip check for a list of repos.
+     * *
+     * @param o other instance
+     * @param reposToSkip list of repos to skip check for equality
+     * @return {@code true} iff both instances are equal, not including the repositories in both instances if they are part of reposToSkip.
+     */
+    public boolean equalsWithRepoSkip(Object o, List<String> reposToSkip) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        RemoteStoreNodeAttribute that = (RemoteStoreNodeAttribute) o;
+        return this.getRepositoriesMetadata().equalsIgnoreGenerationsWithRepoSkip(that.getRepositoriesMetadata(), reposToSkip);
+    }
+
+    public boolean equalsForRepositories(Object otherNode, List<String> repositoryToValidate) {
+        if (this == otherNode) return true;
+        if (otherNode == null || getClass() != otherNode.getClass()) return false;
+
+        RemoteStoreNodeAttribute other = (RemoteStoreNodeAttribute) otherNode;
+        return this.getRepositoriesMetadata().equalsIgnoreGenerationsForRepo(other.repositoriesMetadata, repositoryToValidate);
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
diff --git a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeService.java b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeService.java
index 874c9408de6c5..cc5d8b0e62e90 100644
--- a/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeService.java
+++ b/server/src/main/java/org/opensearch/node/remotestore/RemoteStoreNodeService.java
@@ -42,31 +42,21 @@ public class RemoteStoreNodeService {
     private final Supplier<RepositoriesService> repositoriesService;
     private final ThreadPool threadPool;
     public static final Setting<CompatibilityMode> REMOTE_STORE_COMPATIBILITY_MODE_SETTING = new Setting<>(
-        "remote_store.compatibility_mode",
+        "cluster.remote_store.compatibility_mode",
         CompatibilityMode.STRICT.name(),
         CompatibilityMode::parseString,
-        value -> {
-            if (value == CompatibilityMode.MIXED
-                && FeatureFlags.isEnabled(FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING) == false) {
-                throw new IllegalArgumentException(
-                    " mixed mode is under an experimental feature and can be activated only by enabling "
-                        + REMOTE_STORE_MIGRATION_EXPERIMENTAL
-                        + " feature flag in the JVM options "
-                );
-            }
-        },
         Setting.Property.Dynamic,
         Setting.Property.NodeScope
     );
 
     public static final Setting<Direction> MIGRATION_DIRECTION_SETTING = new Setting<>(
-        "migration.direction",
+        "cluster.migration.direction",
         Direction.NONE.name(),
         Direction::parseString,
         value -> {
-            if (value != Direction.NONE && FeatureFlags.isEnabled(FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING) == false) {
+            if (value == Direction.DOCREP && FeatureFlags.isEnabled(FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING) == false) {
                 throw new IllegalArgumentException(
-                    " migration.direction is under an experimental feature and can be activated only by enabling "
+                    " remote store to docrep migration.direction is under an experimental feature and can be activated only by enabling "
                         + REMOTE_STORE_MIGRATION_EXPERIMENTAL
                         + " feature flag in the JVM options "
                 );
diff --git a/server/src/main/java/org/opensearch/node/remotestore/RemoteStorePinnedTimestampService.java b/server/src/main/java/org/opensearch/node/remotestore/RemoteStorePinnedTimestampService.java
new file mode 100644
index 0000000000000..3a7734fc0538f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/node/remotestore/RemoteStorePinnedTimestampService.java
@@ -0,0 +1,273 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.node.remotestore;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.message.ParameterizedMessage;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobMetadata;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.AbstractAsyncTask;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.node.Node;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.Repository;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.ByteArrayInputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+/**
+ * Service for managing pinned timestamps in a remote store.
+ * This service handles pinning and unpinning of timestamps, as well as periodic updates of the pinned timestamps set.
+ *
+ * @opensearch.internal
+ */
+@ExperimentalApi
+public class RemoteStorePinnedTimestampService implements Closeable {
+    private static final Logger logger = LogManager.getLogger(RemoteStorePinnedTimestampService.class);
+    private static Tuple<Long, Set<Long>> pinnedTimestampsSet = new Tuple<>(-1L, Set.of());
+    public static final String PINNED_TIMESTAMPS_PATH_TOKEN = "pinned_timestamps";
+    public static final String PINNED_TIMESTAMPS_FILENAME_SEPARATOR = "__";
+
+    private final Supplier<RepositoriesService> repositoriesService;
+    private final Settings settings;
+    private final ThreadPool threadPool;
+    private final ClusterService clusterService;
+    private BlobContainer blobContainer;
+    private AsyncUpdatePinnedTimestampTask asyncUpdatePinnedTimestampTask;
+
+    public RemoteStorePinnedTimestampService(
+        Supplier<RepositoriesService> repositoriesService,
+        Settings settings,
+        ThreadPool threadPool,
+        ClusterService clusterService
+    ) {
+        this.repositoriesService = repositoriesService;
+        this.settings = settings;
+        this.threadPool = threadPool;
+        this.clusterService = clusterService;
+    }
+
+    /**
+     * Starts the RemoteStorePinnedTimestampService.
+     * This method validates the remote store configuration, initializes components,
+     * and starts the asynchronous update task.
+     */
+    public void start() {
+        validateRemoteStoreConfiguration();
+        startAsyncUpdateTask(RemoteStoreSettings.getPinnedTimestampsSchedulerInterval());
+    }
+
+    private void validateRemoteStoreConfiguration() {
+        final String remoteStoreRepo = settings.get(
+            Node.NODE_ATTRIBUTES.getKey() + RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY
+        );
+        assert remoteStoreRepo != null : "Remote Segment Store repository is not configured";
+        final Repository repository = repositoriesService.get().repository(remoteStoreRepo);
+        assert repository instanceof BlobStoreRepository : "Repository should be instance of BlobStoreRepository";
+        BlobStoreRepository blobStoreRepository = (BlobStoreRepository) repository;
+        blobContainer = blobStoreRepository.blobStore().blobContainer(blobStoreRepository.basePath().add(PINNED_TIMESTAMPS_PATH_TOKEN));
+    }
+
+    private void startAsyncUpdateTask(TimeValue pinnedTimestampsSchedulerInterval) {
+        asyncUpdatePinnedTimestampTask = new AsyncUpdatePinnedTimestampTask(logger, threadPool, pinnedTimestampsSchedulerInterval, true);
+    }
+
+    /**
+     * Pins a timestamp in the remote store.
+     *
+     * @param timestamp The timestamp to be pinned
+     * @param pinningEntity The entity responsible for pinning the timestamp
+     * @param listener A listener to be notified when the pinning operation completes
+     * @throws IllegalArgumentException If the timestamp is less than the current time minus one second
+     */
+    public void pinTimestamp(long timestamp, String pinningEntity, ActionListener<Void> listener) {
+        // If a caller uses current system time to pin the timestamp, following check will almost always fail.
+        // So, we allow pinning timestamp in the past upto some buffer
+        long lookbackIntervalInMills = RemoteStoreSettings.getPinnedTimestampsLookbackInterval().millis();
+        if (timestamp < (System.currentTimeMillis() - lookbackIntervalInMills)) {
+            throw new IllegalArgumentException(
+                "Timestamp to be pinned is less than current timestamp - value of cluster.remote_store.pinned_timestamps.lookback_interval"
+            );
+        }
+        long startTime = System.nanoTime();
+        try {
+            logger.debug("Pinning timestamp = {} against entity = {}", timestamp, pinningEntity);
+            blobContainer.writeBlob(getBlobName(timestamp, pinningEntity), new ByteArrayInputStream(new byte[0]), 0, true);
+            long elapsedTime = System.nanoTime() - startTime;
+            if (elapsedTime > RemoteStoreSettings.getPinnedTimestampsLookbackInterval().nanos()) {
+                String errorMessage = String.format(
+                    Locale.ROOT,
+                    "Timestamp pinning took %s nanoseconds which is more than limit of %s nanoseconds, failing the operation",
+                    elapsedTime,
+                    RemoteStoreSettings.getPinnedTimestampsLookbackInterval().nanos()
+                );
+                logger.error(errorMessage);
+                unpinTimestamp(timestamp, pinningEntity, ActionListener.wrap(() -> listener.onFailure(new RuntimeException(errorMessage))));
+            } else {
+                listener.onResponse(null);
+            }
+        } catch (IOException e) {
+            listener.onFailure(e);
+        }
+    }
+
+    /**
+     * Clones a timestamp by creating a new pinning entity for an existing timestamp.
+     *
+     * This method attempts to create a new pinning entity for a given timestamp that is already
+     * associated with an existing pinning entity. If the timestamp exists for the existing entity,
+     * a new blob is created for the new pinning entity. If the timestamp doesn't exist for the
+     * existing entity, the operation fails with an IllegalArgumentException.
+     *
+     * @param timestamp The timestamp to be cloned.
+     * @param existingPinningEntity The name of the existing entity that has pinned the timestamp.
+     * @param newPinningEntity The name of the new entity to pin the timestamp to.
+     * @param listener An ActionListener that will be notified of the operation's success or failure.
+     *                 On success, onResponse will be called with null. On failure, onFailure will
+     *                 be called with the appropriate exception.
+     */
+    public void cloneTimestamp(long timestamp, String existingPinningEntity, String newPinningEntity, ActionListener<Void> listener) {
+        try {
+            logger.debug(
+                "cloning timestamp = {} with existing pinningEntity = {} with new pinningEntity = {}",
+                timestamp,
+                existingPinningEntity,
+                newPinningEntity
+            );
+            String blobName = getBlobName(timestamp, existingPinningEntity);
+            if (blobContainer.blobExists(blobName)) {
+                logger.debug("Pinning timestamp = {} against entity = {}", timestamp, newPinningEntity);
+                blobContainer.writeBlob(getBlobName(timestamp, newPinningEntity), new ByteArrayInputStream(new byte[0]), 0, true);
+                listener.onResponse(null);
+            } else {
+                String errorMessage = String.format(
+                    Locale.ROOT,
+                    "Timestamp: %s is not pinned by existing entity: %s",
+                    timestamp,
+                    existingPinningEntity
+                );
+                logger.error(errorMessage);
+                listener.onFailure(new IllegalArgumentException(errorMessage));
+            }
+        } catch (IOException e) {
+            listener.onFailure(e);
+        }
+    }
+
+    private String getBlobName(long timestamp, String pinningEntity) {
+        return String.join(PINNED_TIMESTAMPS_FILENAME_SEPARATOR, pinningEntity, String.valueOf(timestamp));
+    }
+
+    private long getTimestampFromBlobName(String blobName) {
+        String[] blobNameTokens = blobName.split(PINNED_TIMESTAMPS_FILENAME_SEPARATOR);
+        if (blobNameTokens.length < 2) {
+            logger.error("Pinned timestamps blob name contains invalid format: {}", blobName);
+        }
+        try {
+            return Long.parseLong(blobNameTokens[blobNameTokens.length - 1]);
+        } catch (NumberFormatException e) {
+            logger.error(() -> new ParameterizedMessage("Pinned timestamps blob name contains invalid format: {}", blobName), e);
+        }
+        return -1;
+    }
+
+    /**
+     * Unpins a timestamp from the remote store.
+     *
+     * @param timestamp The timestamp to be unpinned
+     * @param pinningEntity The entity responsible for unpinning the timestamp
+     * @param listener A listener to be notified when the unpinning operation completes
+     */
+    public void unpinTimestamp(long timestamp, String pinningEntity, ActionListener<Void> listener) {
+        try {
+            logger.debug("Unpinning timestamp = {} against entity = {}", timestamp, pinningEntity);
+            String blobName = getBlobName(timestamp, pinningEntity);
+            if (blobContainer.blobExists(blobName)) {
+                blobContainer.deleteBlobsIgnoringIfNotExists(List.of(blobName));
+                listener.onResponse(null);
+            } else {
+                String errorMessage = String.format(Locale.ROOT, "Timestamp: %s is not pinned by entity: %s", timestamp, pinningEntity);
+                logger.error(errorMessage);
+                listener.onFailure(new IllegalArgumentException(errorMessage));
+            }
+        } catch (IOException e) {
+            listener.onFailure(e);
+        }
+    }
+
+    @Override
+    public void close() throws IOException {
+        asyncUpdatePinnedTimestampTask.close();
+    }
+
+    // Used in integ tests
+    public void rescheduleAsyncUpdatePinnedTimestampTask(TimeValue pinnedTimestampsSchedulerInterval) {
+        if (pinnedTimestampsSchedulerInterval != null) {
+            pinnedTimestampsSet = new Tuple<>(-1L, Set.of());
+            asyncUpdatePinnedTimestampTask.close();
+            startAsyncUpdateTask(pinnedTimestampsSchedulerInterval);
+        }
+    }
+
+    public static Tuple<Long, Set<Long>> getPinnedTimestamps() {
+        return pinnedTimestampsSet;
+    }
+
+    /**
+     * Inner class for asynchronously updating the pinned timestamp set.
+     */
+    private final class AsyncUpdatePinnedTimestampTask extends AbstractAsyncTask {
+        private AsyncUpdatePinnedTimestampTask(Logger logger, ThreadPool threadPool, TimeValue interval, boolean autoReschedule) {
+            super(logger, threadPool, interval, autoReschedule);
+            rescheduleIfNecessary();
+        }
+
+        @Override
+        protected boolean mustReschedule() {
+            return true;
+        }
+
+        @Override
+        protected void runInternal() {
+            long triggerTimestamp = System.currentTimeMillis();
+            try {
+                Map<String, BlobMetadata> pinnedTimestampList = blobContainer.listBlobs();
+                if (pinnedTimestampList.isEmpty()) {
+                    pinnedTimestampsSet = new Tuple<>(triggerTimestamp, Set.of());
+                    return;
+                }
+                Set<Long> pinnedTimestamps = pinnedTimestampList.keySet()
+                    .stream()
+                    .map(RemoteStorePinnedTimestampService.this::getTimestampFromBlobName)
+                    .filter(timestamp -> timestamp != -1)
+                    .collect(Collectors.toSet());
+                logger.debug("Fetched pinned timestamps from remote store: {} - {}", triggerTimestamp, pinnedTimestamps);
+                pinnedTimestampsSet = new Tuple<>(triggerTimestamp, pinnedTimestamps);
+            } catch (Throwable t) {
+                logger.error("Exception while fetching pinned timestamp details", t);
+            }
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/plugins/IdentityAwarePlugin.java b/server/src/main/java/org/opensearch/plugins/IdentityAwarePlugin.java
new file mode 100644
index 0000000000000..b19dcfe5544ec
--- /dev/null
+++ b/server/src/main/java/org/opensearch/plugins/IdentityAwarePlugin.java
@@ -0,0 +1,34 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.plugins;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.identity.PluginSubject;
+import org.opensearch.identity.Subject;
+
+/**
+ * Plugin that performs transport actions with a plugin system context. IdentityAwarePlugins are initialized
+ * with a {@link Subject} that they can utilize to perform transport actions outside the default subject.
+ *
+ * When the Security plugin is installed, the default subject is the authenticated user. In particular,
+ * SystemIndexPlugins utilize the {@link Subject} to perform transport actions that interact with system indices.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface IdentityAwarePlugin {
+
+    /**
+     * Passes necessary classes for this plugin to operate as an IdentityAwarePlugin
+     *
+     * @param pluginSubject A subject for running transport actions in the plugin context for system index
+     *                      interaction
+     */
+    default void assignSubject(PluginSubject pluginSubject) {}
+}
diff --git a/server/src/main/java/org/opensearch/plugins/IdentityPlugin.java b/server/src/main/java/org/opensearch/plugins/IdentityPlugin.java
index 410535504f0dd..b40af14231fb9 100644
--- a/server/src/main/java/org/opensearch/plugins/IdentityPlugin.java
+++ b/server/src/main/java/org/opensearch/plugins/IdentityPlugin.java
@@ -8,6 +8,8 @@
 
 package org.opensearch.plugins;
 
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.identity.PluginSubject;
 import org.opensearch.identity.Subject;
 import org.opensearch.identity.tokens.TokenManager;
 
@@ -16,17 +18,28 @@
  *
  * @opensearch.experimental
  */
+@ExperimentalApi
 public interface IdentityPlugin {
 
     /**
      * Get the current subject.
+     *
      * @return Should never return null
      * */
-    public Subject getSubject();
+    Subject getCurrentSubject();
 
     /**
      * Get the Identity Plugin's token manager implementation
      * @return Should never return null.
      */
-    public TokenManager getTokenManager();
+    TokenManager getTokenManager();
+
+    /**
+     * Gets a subject corresponding to the passed plugin that can be utilized to perform transport actions
+     * in the plugin system context
+     *
+     * @param plugin The corresponding plugin
+     * @return Subject corresponding to the plugin
+     */
+    PluginSubject getPluginSubject(Plugin plugin);
 }
diff --git a/server/src/main/java/org/opensearch/plugins/PluginsService.java b/server/src/main/java/org/opensearch/plugins/PluginsService.java
index a6eefd2f4fd17..f08c9c738f1b4 100644
--- a/server/src/main/java/org/opensearch/plugins/PluginsService.java
+++ b/server/src/main/java/org/opensearch/plugins/PluginsService.java
@@ -36,6 +36,7 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.codecs.Codec;
 import org.apache.lucene.codecs.DocValuesFormat;
+import org.apache.lucene.codecs.KnnVectorsFormat;
 import org.apache.lucene.codecs.PostingsFormat;
 import org.apache.lucene.util.SPIClassIterator;
 import org.opensearch.Build;
@@ -762,6 +763,7 @@ static void reloadLuceneSPI(ClassLoader loader) {
         // Codecs:
         PostingsFormat.reloadPostingsFormats(loader);
         DocValuesFormat.reloadDocValuesFormats(loader);
+        KnnVectorsFormat.reloadKnnVectorsFormat(loader);
         Codec.reloadCodecs(loader);
     }
 
diff --git a/server/src/main/java/org/opensearch/plugins/SearchPlugin.java b/server/src/main/java/org/opensearch/plugins/SearchPlugin.java
index d14c99d9b765b..895e6ed2971d8 100644
--- a/server/src/main/java/org/opensearch/plugins/SearchPlugin.java
+++ b/server/src/main/java/org/opensearch/plugins/SearchPlugin.java
@@ -36,6 +36,7 @@
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.Sort;
 import org.opensearch.common.CheckedFunction;
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.lucene.search.function.ScoreFunction;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.ParseField;
@@ -64,6 +65,7 @@
 import org.opensearch.search.aggregations.pipeline.MovAvgPipelineAggregator;
 import org.opensearch.search.aggregations.pipeline.PipelineAggregator;
 import org.opensearch.search.aggregations.support.ValuesSourceRegistry;
+import org.opensearch.search.deciders.ConcurrentSearchDecider;
 import org.opensearch.search.fetch.FetchSubPhase;
 import org.opensearch.search.fetch.subphase.highlight.Highlighter;
 import org.opensearch.search.query.QueryPhaseSearcher;
@@ -138,6 +140,15 @@ default Map<String, Highlighter> getHighlighters() {
         return emptyMap();
     }
 
+    /**
+     * Allows plugins to register custom decider for concurrent search
+     * @return A {@link ConcurrentSearchDecider}
+     */
+    @ExperimentalApi
+    default ConcurrentSearchDecider getConcurrentSearchDecider() {
+        return null;
+    }
+
     /**
      * The new {@link Suggester}s defined by this plugin.
      */
diff --git a/server/src/main/java/org/opensearch/repositories/FilterRepository.java b/server/src/main/java/org/opensearch/repositories/FilterRepository.java
index 0c5cdf24526cb..cb1fd6a8694ab 100644
--- a/server/src/main/java/org/opensearch/repositories/FilterRepository.java
+++ b/server/src/main/java/org/opensearch/repositories/FilterRepository.java
@@ -39,6 +39,7 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.common.Priority;
 import org.opensearch.common.lifecycle.Lifecycle;
 import org.opensearch.common.lifecycle.LifecycleListener;
 import org.opensearch.core.action.ActionListener;
@@ -123,6 +124,29 @@ public void finalizeSnapshot(
         );
     }
 
+    @Override
+    public void finalizeSnapshot(
+        ShardGenerations shardGenerations,
+        long repositoryStateId,
+        Metadata clusterMetadata,
+        SnapshotInfo snapshotInfo,
+        Version repositoryMetaVersion,
+        Function<ClusterState, ClusterState> stateTransformer,
+        Priority repositoryUpdatePriority,
+        ActionListener<RepositoryData> listener
+    ) {
+        in.finalizeSnapshot(
+            shardGenerations,
+            repositoryStateId,
+            clusterMetadata,
+            snapshotInfo,
+            repositoryMetaVersion,
+            stateTransformer,
+            repositoryUpdatePriority,
+            listener
+        );
+    }
+
     @Override
     public void deleteSnapshots(
         Collection<SnapshotId> snapshotIds,
@@ -148,6 +172,11 @@ public long getRemoteUploadThrottleTimeInNanos() {
         return in.getRemoteUploadThrottleTimeInNanos();
     }
 
+    @Override
+    public long getLowPriorityRemoteUploadThrottleTimeInNanos() {
+        return in.getRemoteUploadThrottleTimeInNanos();
+    }
+
     @Override
     public long getRemoteDownloadThrottleTimeInNanos() {
         return in.getRemoteDownloadThrottleTimeInNanos();
diff --git a/server/src/main/java/org/opensearch/repositories/IndexId.java b/server/src/main/java/org/opensearch/repositories/IndexId.java
index 87a0063e8c21b..5a9a757e31cb1 100644
--- a/server/src/main/java/org/opensearch/repositories/IndexId.java
+++ b/server/src/main/java/org/opensearch/repositories/IndexId.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.repositories;
 
+import org.opensearch.Version;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
@@ -40,6 +41,7 @@
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.ToXContentObject;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.remote.RemoteStoreEnums;
 
 import java.io.IOException;
 import java.util.Objects;
@@ -51,23 +53,36 @@
  */
 @PublicApi(since = "1.0.0")
 public final class IndexId implements Writeable, ToXContentObject {
-    protected static final String NAME = "name";
-    protected static final String ID = "id";
+    static final String NAME = "name";
+    static final String ID = "id";
+    static final String SHARD_PATH_TYPE = "shard_path_type";
+    public static final int DEFAULT_SHARD_PATH_TYPE = RemoteStoreEnums.PathType.FIXED.getCode();
 
     private final String name;
     private final String id;
+    private final int shardPathType;
     private final int hashCode;
 
+    // Used for testing only
     public IndexId(final String name, final String id) {
+        this(name, id, DEFAULT_SHARD_PATH_TYPE);
+    }
+
+    public IndexId(String name, String id, int shardPathType) {
         this.name = name;
         this.id = id;
+        this.shardPathType = shardPathType;
         this.hashCode = computeHashCode();
-
     }
 
     public IndexId(final StreamInput in) throws IOException {
         this.name = in.readString();
         this.id = in.readString();
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            this.shardPathType = in.readVInt();
+        } else {
+            this.shardPathType = DEFAULT_SHARD_PATH_TYPE;
+        }
         this.hashCode = computeHashCode();
     }
 
@@ -93,9 +108,16 @@ public String getId() {
         return id;
     }
 
+    /**
+     * The storage path type in remote store for the indexes having the underlying index ids.
+     */
+    public int getShardPathType() {
+        return shardPathType;
+    }
+
     @Override
     public String toString() {
-        return "[" + name + "/" + id + "]";
+        return "[" + name + "/" + id + "/" + shardPathType + "]";
     }
 
     @Override
@@ -107,7 +129,7 @@ public boolean equals(Object o) {
             return false;
         }
         IndexId that = (IndexId) o;
-        return Objects.equals(name, that.name) && Objects.equals(id, that.id);
+        return Objects.equals(name, that.name) && Objects.equals(id, that.id) && Objects.equals(this.shardPathType, that.shardPathType);
     }
 
     @Override
@@ -116,13 +138,16 @@ public int hashCode() {
     }
 
     private int computeHashCode() {
-        return Objects.hash(name, id);
+        return Objects.hash(name, id, shardPathType);
     }
 
     @Override
     public void writeTo(final StreamOutput out) throws IOException {
         out.writeString(name);
         out.writeString(id);
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeVInt(shardPathType);
+        }
     }
 
     @Override
@@ -130,6 +155,7 @@ public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params par
         builder.startObject();
         builder.field(NAME, name);
         builder.field(ID, id);
+        builder.field(SHARD_PATH_TYPE, shardPathType);
         builder.endObject();
         return builder;
     }
diff --git a/server/src/main/java/org/opensearch/repositories/Repository.java b/server/src/main/java/org/opensearch/repositories/Repository.java
index 4956ec957b5f7..a7c44575465b0 100644
--- a/server/src/main/java/org/opensearch/repositories/Repository.java
+++ b/server/src/main/java/org/opensearch/repositories/Repository.java
@@ -41,6 +41,7 @@
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.Priority;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.lifecycle.LifecycleComponent;
 import org.opensearch.common.settings.Setting;
@@ -49,9 +50,11 @@
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.snapshots.IndexShardSnapshotStatus;
 import org.opensearch.index.snapshots.blobstore.RemoteStoreShardShallowCopySnapshot;
+import org.opensearch.index.store.RemoteSegmentStoreDirectoryFactory;
 import org.opensearch.index.store.Store;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManagerFactory;
 import org.opensearch.indices.recovery.RecoveryState;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
 import org.opensearch.snapshots.SnapshotId;
 import org.opensearch.snapshots.SnapshotInfo;
 
@@ -175,6 +178,32 @@ void finalizeSnapshot(
         ActionListener<RepositoryData> listener
     );
 
+    /**
+     * Finalizes snapshotting process
+     * <p>
+     * This method is called on cluster-manager after all shards are snapshotted.
+     *
+     * @param shardGenerations      updated shard generations
+     * @param repositoryStateId     the unique id identifying the state of the repository when the snapshot began
+     * @param clusterMetadata       cluster metadata
+     * @param snapshotInfo     SnapshotInfo instance to write for this snapshot
+     * @param repositoryMetaVersion version of the updated repository metadata to write
+     * @param stateTransformer      a function that filters the last cluster state update that the snapshot finalization will execute and
+     *                              is used to remove any state tracked for the in-progress snapshot from the cluster state
+     * @param repositoryUpdatePriority  priority for the cluster state update task
+     * @param listener              listener to be invoked with the new {@link RepositoryData} after completing the snapshot
+     */
+    void finalizeSnapshot(
+        ShardGenerations shardGenerations,
+        long repositoryStateId,
+        Metadata clusterMetadata,
+        SnapshotInfo snapshotInfo,
+        Version repositoryMetaVersion,
+        Function<ClusterState, ClusterState> stateTransformer,
+        Priority repositoryUpdatePriority,
+        ActionListener<RepositoryData> listener
+    );
+
     /**
      * Deletes snapshots
      *
@@ -193,11 +222,59 @@ void deleteSnapshots(
     /**
      * Deletes snapshots and releases respective lock files from remote store repository.
      *
-     * @param snapshotIds                   snapshot ids
-     * @param repositoryStateId             the unique id identifying the state of the repository when the snapshot deletion began
-     * @param repositoryMetaVersion         version of the updated repository metadata to write
-     * @param remoteStoreLockManagerFactory RemoteStoreLockManagerFactory to be used for cleaning up remote store lock files
-     * @param listener                      completion listener
+     * @param snapshotIds                           snapshot ids
+     * @param repositoryStateId                     the unique id identifying the state of the repository when the snapshot deletion began
+     * @param repositoryMetaVersion                 version of the updated repository metadata to write
+     * @param remoteStoreLockManagerFactory         RemoteStoreLockManagerFactory to be used for cleaning up remote store lock files
+     * @param remoteSegmentStoreDirectoryFactory    RemoteSegmentStoreDirectoryFactory to be used for cleaning up remote store segment files
+     * @param remoteStorePinnedTimestampService     service for pinning and unpinning of the timestamp
+     * @param snapshotIdsPinnedTimestampMap         map of snapshots ids and the pinned timestamp
+     * @param isShallowSnapshotV2                   true for shallow snapshots v2
+     * @param listener                              completion listener
+     */
+    default void deleteSnapshotsInternal(
+        Collection<SnapshotId> snapshotIds,
+        long repositoryStateId,
+        Version repositoryMetaVersion,
+        RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService,
+        Map<SnapshotId, Long> snapshotIdsPinnedTimestampMap,
+        boolean isShallowSnapshotV2,
+        ActionListener<RepositoryData> listener
+    ) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Deletes snapshots and unpin the snapshot timestamp using remoteStorePinnedTimestampService
+     *
+     * @param snapshotsWithPinnedTimestamp          map of snapshot ids and the pinned timestamps
+     * @param repositoryStateId                     the unique id identifying the state of the repository when the snapshot deletion began
+     * @param repositoryMetaVersion                 version of the updated repository metadata to write
+     * @param remoteSegmentStoreDirectoryFactory    RemoteSegmentStoreDirectoryFactory to be used for cleaning up remote store segment files
+     * @param remoteStorePinnedTimestampService     service for pinning and unpinning of the timestamp
+     * @param listener                              completion listener
+     */
+    default void deleteSnapshotsWithPinnedTimestamp(
+        Map<SnapshotId, Long> snapshotsWithPinnedTimestamp,
+        long repositoryStateId,
+        Version repositoryMetaVersion,
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService,
+        ActionListener<RepositoryData> listener
+    ) {
+        throw new UnsupportedOperationException();
+    }
+
+    /**
+     * Deletes snapshots and releases respective lock files from remote store repository
+     *
+     * @param snapshotIds
+     * @param repositoryStateId
+     * @param repositoryMetaVersion
+     * @param remoteStoreLockManagerFactory
+     * @param listener
      */
     default void deleteSnapshotsAndReleaseLockFiles(
         Collection<SnapshotId> snapshotIds,
@@ -220,10 +297,17 @@ default void deleteSnapshotsAndReleaseLockFiles(
     long getRestoreThrottleTimeInNanos();
 
     /**
-     * Returns restore throttle time in nanoseconds
+     * Returns upload throttle time in nanoseconds
      */
     long getRemoteUploadThrottleTimeInNanos();
 
+    /**
+     * Returns low priority upload throttle time in nanoseconds
+     */
+    default long getLowPriorityRemoteUploadThrottleTimeInNanos() {
+        return 0;
+    }
+
     /**
      * Returns restore throttle time in nanoseconds
      */
diff --git a/server/src/main/java/org/opensearch/repositories/RepositoryData.java b/server/src/main/java/org/opensearch/repositories/RepositoryData.java
index ddccc633e5d75..5328618f688f4 100644
--- a/server/src/main/java/org/opensearch/repositories/RepositoryData.java
+++ b/server/src/main/java/org/opensearch/repositories/RepositoryData.java
@@ -112,6 +112,11 @@ public final class RepositoryData {
      * The indices found in the repository across all snapshots, as a name to {@link IndexId} mapping
      */
     private final Map<String, IndexId> indices;
+
+    public Map<IndexId, List<SnapshotId>> getIndexSnapshots() {
+        return indexSnapshots;
+    }
+
     /**
      * The snapshots that each index belongs to.
      */
@@ -519,7 +524,7 @@ public List<IndexId> resolveIndices(final List<String> indices) {
      * @param indicesToResolve names of indices to resolve
      * @param inFlightIds      name to index mapping for currently in-flight snapshots not yet in the repository data to fall back to
      */
-    public List<IndexId> resolveNewIndices(List<String> indicesToResolve, Map<String, IndexId> inFlightIds) {
+    public List<IndexId> resolveNewIndices(List<String> indicesToResolve, Map<String, IndexId> inFlightIds, int pathType) {
         List<IndexId> snapshotIndices = new ArrayList<>();
         for (String index : indicesToResolve) {
             IndexId indexId = indices.get(index);
@@ -527,13 +532,17 @@ public List<IndexId> resolveNewIndices(List<String> indicesToResolve, Map<String
                 indexId = inFlightIds.get(index);
             }
             if (indexId == null) {
-                indexId = new IndexId(index, UUIDs.randomBase64UUID());
+                indexId = new IndexId(index, UUIDs.randomBase64UUID(), pathType);
             }
             snapshotIndices.add(indexId);
         }
         return snapshotIndices;
     }
 
+    public List<IndexId> resolveNewIndices(List<String> indicesToResolve, Map<String, IndexId> inFlightIds) {
+        return resolveNewIndices(indicesToResolve, inFlightIds, IndexId.DEFAULT_SHARD_PATH_TYPE);
+    }
+
     private static final String SHARD_GENERATIONS = "shard_generations";
     private static final String INDEX_METADATA_IDENTIFIERS = "index_metadata_identifiers";
     private static final String INDEX_METADATA_LOOKUP = "index_metadata_lookup";
@@ -546,10 +555,16 @@ public List<IndexId> resolveNewIndices(List<String> indicesToResolve, Map<String
     private static final String VERSION = "version";
     private static final String MIN_VERSION = "min_version";
 
+    // Visible for testing only
+    public XContentBuilder snapshotsToXContent(final XContentBuilder builder, final Version repoMetaVersion) throws IOException {
+        return snapshotsToXContent(builder, repoMetaVersion, Version.V_2_17_0);
+    }
+
     /**
      * Writes the snapshots metadata and the related indices metadata to x-content.
      */
-    public XContentBuilder snapshotsToXContent(final XContentBuilder builder, final Version repoMetaVersion) throws IOException {
+    public XContentBuilder snapshotsToXContent(final XContentBuilder builder, final Version repoMetaVersion, final Version minNodeVersion)
+        throws IOException {
         builder.startObject();
         // write the snapshots list
         builder.startArray(SNAPSHOTS);
@@ -584,6 +599,9 @@ public XContentBuilder snapshotsToXContent(final XContentBuilder builder, final
         for (final IndexId indexId : getIndices().values()) {
             builder.startObject(indexId.getName());
             builder.field(INDEX_ID, indexId.getId());
+            if (minNodeVersion.onOrAfter(Version.V_2_17_0)) {
+                builder.field(IndexId.SHARD_PATH_TYPE, indexId.getShardPathType());
+            }
             builder.startArray(SNAPSHOTS);
             List<SnapshotId> snapshotIds = indexSnapshots.get(indexId);
             assert snapshotIds != null;
@@ -791,14 +809,20 @@ private static void parseIndices(
             final List<SnapshotId> snapshotIds = new ArrayList<>();
             final List<String> gens = new ArrayList<>();
 
+            String id = null;
+            int pathType = IndexId.DEFAULT_SHARD_PATH_TYPE;
             IndexId indexId = null;
+
             XContentParserUtils.ensureExpectedToken(XContentParser.Token.START_OBJECT, parser.nextToken(), parser);
             while (parser.nextToken() != XContentParser.Token.END_OBJECT) {
                 final String indexMetaFieldName = parser.currentName();
                 final XContentParser.Token currentToken = parser.nextToken();
                 switch (indexMetaFieldName) {
                     case INDEX_ID:
-                        indexId = new IndexId(indexName, parser.text());
+                        id = parser.text();
+                        break;
+                    case IndexId.SHARD_PATH_TYPE:
+                        pathType = parser.intValue();
                         break;
                     case SNAPSHOTS:
                         XContentParserUtils.ensureExpectedToken(XContentParser.Token.START_ARRAY, currentToken, parser);
@@ -821,7 +845,7 @@ private static void parseIndices(
                                 // different versions create or delete snapshot in the same repository.
                                 throw new OpenSearchParseException(
                                     "Detected a corrupted repository, index "
-                                        + indexId
+                                        + new IndexId(indexName, id, pathType)
                                         + " references an unknown snapshot uuid ["
                                         + uuid
                                         + "]"
@@ -838,9 +862,10 @@ private static void parseIndices(
                         break;
                 }
             }
-            assert indexId != null;
+            assert id != null;
+            indexId = new IndexId(indexName, id, pathType);
             indexSnapshots.put(indexId, Collections.unmodifiableList(snapshotIds));
-            indexLookup.put(indexId.getId(), indexId);
+            indexLookup.put(id, indexId);
             for (int i = 0; i < gens.size(); i++) {
                 String parsedGen = gens.get(i);
                 if (fixBrokenShardGens) {
diff --git a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
index 6298eb15550bf..d696cf329a2a5 100644
--- a/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
+++ b/server/src/main/java/org/opensearch/repositories/blobstore/BlobStoreRepository.java
@@ -65,6 +65,8 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Numbers;
+import org.opensearch.common.Priority;
+import org.opensearch.common.Randomness;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.blobstore.BlobContainer;
@@ -108,7 +110,12 @@
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.index.remote.RemoteStorePathStrategy.BasePathInput;
+import org.opensearch.index.remote.RemoteStorePathStrategy.SnapshotShardPathInput;
+import org.opensearch.index.remote.RemoteStoreUtils;
 import org.opensearch.index.snapshots.IndexShardRestoreFailedException;
 import org.opensearch.index.snapshots.IndexShardSnapshotStatus;
 import org.opensearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshot;
@@ -125,8 +132,10 @@
 import org.opensearch.index.store.lockmanager.FileLockInfo;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManager;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManagerFactory;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.indices.recovery.RecoveryState;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
 import org.opensearch.repositories.IndexId;
 import org.opensearch.repositories.IndexMetaDataGenerations;
 import org.opensearch.repositories.Repository;
@@ -144,6 +153,8 @@
 import org.opensearch.snapshots.SnapshotId;
 import org.opensearch.snapshots.SnapshotInfo;
 import org.opensearch.snapshots.SnapshotMissingException;
+import org.opensearch.snapshots.SnapshotShardPaths;
+import org.opensearch.snapshots.SnapshotShardPaths.ShardInfo;
 import org.opensearch.snapshots.SnapshotsService;
 import org.opensearch.threadpool.ThreadPool;
 
@@ -155,9 +166,12 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.BlockingQueue;
@@ -175,8 +189,10 @@
 import java.util.stream.LongStream;
 import java.util.stream.Stream;
 
+import static org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1;
 import static org.opensearch.index.snapshots.blobstore.BlobStoreIndexShardSnapshot.FileInfo.canonicalName;
 import static org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat.SNAPSHOT_ONLY_FORMAT_PARAMS;
+import static org.opensearch.snapshots.SnapshotsService.SNAPSHOT_PINNED_TIMESTAMP_DELIMITER;
 
 /**
  * BlobStore - based implementation of Snapshot Repository
@@ -220,6 +236,8 @@ public abstract class BlobStoreRepository extends AbstractLifecycleComponent imp
 
     private static final String UPLOADED_DATA_BLOB_PREFIX = "__";
 
+    public static final String INDICES_DIR = "indices";
+
     /**
      * Prefix used for the identifiers of data blobs that were not actually written to the repository physically because their contents are
      * already stored in the metadata referencing them, i.e. in {@link BlobStoreIndexShardSnapshot} and
@@ -263,6 +281,14 @@ public abstract class BlobStoreRepository extends AbstractLifecycleComponent imp
 
     public static final Setting<Boolean> REMOTE_STORE_INDEX_SHALLOW_COPY = Setting.boolSetting("remote_store_index_shallow_copy", false);
 
+    public static final Setting<Boolean> SHALLOW_SNAPSHOT_V2 = Setting.boolSetting("shallow_snapshot_v2", false);
+
+    public static final Setting<PathType> SHARD_PATH_TYPE = new Setting<>(
+        "shard_path_type",
+        PathType.FIXED.toString(),
+        PathType::parseString
+    );
+
     /**
      * Setting to set batch size of stale snapshot shard blobs that will be deleted by snapshot workers as part of snapshot deletion.
      * For optimal performance the value of the setting should be equal to or close to repository's max # of keys that can be deleted in single operation
@@ -303,6 +329,16 @@ public abstract class BlobStoreRepository extends AbstractLifecycleComponent imp
         Setting.Property.NodeScope
     );
 
+    /**
+     * Setting to enable prefix mode verification. In this mode, a hashed string is prepended at the prefix of the base
+     * path during repository verification.
+     */
+    public static final Setting<Boolean> PREFIX_MODE_VERIFICATION_SETTING = Setting.boolSetting(
+        "prefix_mode_verification",
+        false,
+        Setting.Property.NodeScope
+    );
+
     protected volatile boolean supportURLRepo;
 
     private volatile int maxShardBlobDeleteBatch;
@@ -317,6 +353,8 @@ public abstract class BlobStoreRepository extends AbstractLifecycleComponent imp
 
     private volatile RateLimiter remoteUploadRateLimiter;
 
+    private volatile RateLimiter remoteUploadLowPriorityRateLimiter;
+
     private volatile RateLimiter remoteDownloadRateLimiter;
 
     private final CounterMetric snapshotRateLimitingTimeInNanos = new CounterMetric();
@@ -327,6 +365,8 @@ public abstract class BlobStoreRepository extends AbstractLifecycleComponent imp
 
     private final CounterMetric remoteUploadRateLimitingTimeInNanos = new CounterMetric();
 
+    private final CounterMetric remoteUploadLowPriorityRateLimitingTimeInNanos = new CounterMetric();
+
     public static final ChecksumBlobStoreFormat<Metadata> GLOBAL_METADATA_FORMAT = new ChecksumBlobStoreFormat<>(
         "metadata",
         METADATA_NAME_FORMAT,
@@ -362,26 +402,38 @@ public abstract class BlobStoreRepository extends AbstractLifecycleComponent imp
         BlobStoreIndexShardSnapshots::fromXContent
     );
 
+    public static final ConfigBlobStoreFormat<SnapshotShardPaths> SNAPSHOT_SHARD_PATHS_FORMAT = new ConfigBlobStoreFormat<>(
+        SnapshotShardPaths.FILE_NAME_FORMAT
+    );
+
     private volatile boolean readOnly;
 
     private final boolean isSystemRepository;
 
+    private final boolean prefixModeVerification;
+
     private final Object lock = new Object();
 
     private final SetOnce<BlobContainer> blobContainer = new SetOnce<>();
 
+    private final SetOnce<BlobContainer> rootBlobContainer = new SetOnce<>();
+
+    private final SetOnce<BlobContainer> snapshotShardPathBlobContainer = new SetOnce<>();
+
     private final SetOnce<BlobStore> blobStore = new SetOnce<>();
 
     protected final ClusterService clusterService;
 
     private final RecoverySettings recoverySettings;
 
+    private final RemoteStoreSettings remoteStoreSettings;
+
     private final NamedXContentRegistry namedXContentRegistry;
 
     /**
      * Flag that is set to {@code true} if this instance is started with {@link #metadata} that has a higher value for
      * {@link RepositoryMetadata#pendingGeneration()} than for {@link RepositoryMetadata#generation()} indicating a full cluster restart
-     * potentially accounting for the the last {@code index-N} write in the cluster state.
+     * potentially accounting for the last {@code index-N} write in the cluster state.
      * Note: While it is true that this value could also be set to {@code true} for an instance on a node that is just joining the cluster
      * during a new {@code index-N} write, this does not present a problem. The node will still load the correct {@link RepositoryData} in
      * all cases and simply do a redundant listing of the repository contents if it tries to load {@link RepositoryData} and falls back
@@ -426,10 +478,12 @@ protected BlobStoreRepository(
         readRepositoryMetadata(repositoryMetadata);
 
         isSystemRepository = SYSTEM_REPOSITORY_SETTING.get(metadata.settings());
+        prefixModeVerification = PREFIX_MODE_VERIFICATION_SETTING.get(metadata.settings());
         this.namedXContentRegistry = namedXContentRegistry;
         this.threadPool = clusterService.getClusterApplierService().threadPool();
         this.clusterService = clusterService;
         this.recoverySettings = recoverySettings;
+        this.remoteStoreSettings = new RemoteStoreSettings(clusterService.getSettings(), clusterService.getClusterSettings());
     }
 
     @Override
@@ -449,6 +503,11 @@ private void readRepositoryMetadata(RepositoryMetadata repositoryMetadata) {
         snapshotRateLimiter = getRateLimiter(metadata.settings(), "max_snapshot_bytes_per_sec", new ByteSizeValue(40, ByteSizeUnit.MB));
         restoreRateLimiter = getRateLimiter(metadata.settings(), "max_restore_bytes_per_sec", ByteSizeValue.ZERO);
         remoteUploadRateLimiter = getRateLimiter(metadata.settings(), "max_remote_upload_bytes_per_sec", ByteSizeValue.ZERO);
+        remoteUploadLowPriorityRateLimiter = getRateLimiter(
+            metadata.settings(),
+            "max_remote_low_priority_upload_bytes_per_sec",
+            ByteSizeValue.ZERO
+        );
         remoteDownloadRateLimiter = getRateLimiter(metadata.settings(), "max_remote_download_bytes_per_sec", ByteSizeValue.ZERO);
         readOnly = READONLY_SETTING.get(metadata.settings());
         cacheRepositoryData = CACHE_REPOSITORY_DATA.get(metadata.settings());
@@ -758,11 +817,25 @@ BlobContainer getBlobContainer() {
         return blobContainer.get();
     }
 
+    // package private, only use for testing
+    BlobContainer getRootBlobContainer() {
+        return rootBlobContainer.get();
+    }
+
+    // package private, only use for testing
+    public SetOnce<BlobContainer> getSnapshotShardPathBlobContainer() {
+        return snapshotShardPathBlobContainer;
+    }
+
     // for test purposes only
     protected BlobStore getBlobStore() {
         return blobStore.get();
     }
 
+    boolean getPrefixModeVerification() {
+        return prefixModeVerification;
+    }
+
     /**
      * maintains single lazy instance of {@link BlobContainer}
      */
@@ -779,10 +852,47 @@ protected BlobContainer blobContainer() {
                 }
             }
         }
-
         return blobContainer;
     }
 
+    /**
+     * maintains single lazy instance of {@link BlobContainer}
+     */
+    protected BlobContainer rootBlobContainer() {
+        assertSnapshotOrGenericThread();
+
+        BlobContainer rootBlobContainer = this.rootBlobContainer.get();
+        if (rootBlobContainer == null) {
+            synchronized (lock) {
+                rootBlobContainer = this.rootBlobContainer.get();
+                if (rootBlobContainer == null) {
+                    rootBlobContainer = blobStore().blobContainer(BlobPath.cleanPath());
+                    this.rootBlobContainer.set(rootBlobContainer);
+                }
+            }
+        }
+        return rootBlobContainer;
+    }
+
+    /**
+     * maintains single lazy instance of {@link BlobContainer}
+     */
+    protected BlobContainer snapshotShardPathBlobContainer() {
+        assertSnapshotOrGenericThread();
+
+        BlobContainer snapshotShardPathBlobContainer = this.snapshotShardPathBlobContainer.get();
+        if (snapshotShardPathBlobContainer == null) {
+            synchronized (lock) {
+                snapshotShardPathBlobContainer = this.snapshotShardPathBlobContainer.get();
+                if (snapshotShardPathBlobContainer == null) {
+                    snapshotShardPathBlobContainer = blobStore().blobContainer(basePath().add(SnapshotShardPaths.DIR));
+                    this.snapshotShardPathBlobContainer.set(snapshotShardPathBlobContainer);
+                }
+            }
+        }
+        return snapshotShardPathBlobContainer;
+    }
+
     /**
      * Maintains single lazy instance of {@link BlobStore}.
      * Public for testing.
@@ -887,11 +997,15 @@ public void initializeSnapshot(SnapshotId snapshotId, List<IndexId> indices, Met
         }
     }
 
-    public void deleteSnapshotsAndReleaseLockFiles(
+    public void deleteSnapshotsInternal(
         Collection<SnapshotId> snapshotIds,
         long repositoryStateId,
         Version repositoryMetaVersion,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService,
+        Map<SnapshotId, Long> snapshotIdsPinnedTimestampMap,
+        boolean isShallowSnapshotV2,
         ActionListener<RepositoryData> listener
     ) {
         if (isReadOnly()) {
@@ -913,6 +1027,10 @@ protected void doRun() throws Exception {
                         repositoryData,
                         repositoryMetaVersion,
                         remoteStoreLockManagerFactory,
+                        remoteSegmentStoreDirectoryFactory,
+                        remoteStorePinnedTimestampService,
+                        snapshotIdsPinnedTimestampMap,
+                        isShallowSnapshotV2,
                         listener
                     );
                 }
@@ -925,6 +1043,49 @@ public void onFailure(Exception e) {
         }
     }
 
+    @Override
+    public void deleteSnapshotsWithPinnedTimestamp(
+        Map<SnapshotId, Long> snapshotIdPinnedTimestampMap,
+        long repositoryStateId,
+        Version repositoryMetaVersion,
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService,
+        ActionListener<RepositoryData> listener
+    ) {
+        deleteSnapshotsInternal(
+            snapshotIdPinnedTimestampMap.keySet(),
+            repositoryStateId,
+            repositoryMetaVersion,
+            null, // Passing null since no remote store lock files need to be cleaned up.
+            remoteSegmentStoreDirectoryFactory,
+            remoteStorePinnedTimestampService,
+            snapshotIdPinnedTimestampMap,
+            true, // true only for shallow snapshot v2
+            listener
+        );
+    }
+
+    @Override
+    public void deleteSnapshotsAndReleaseLockFiles(
+        Collection<SnapshotId> snapshotIds,
+        long repositoryStateId,
+        Version repositoryMetaVersion,
+        RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
+        ActionListener<RepositoryData> listener
+    ) {
+        deleteSnapshotsInternal(
+            snapshotIds,
+            repositoryStateId,
+            repositoryMetaVersion,
+            remoteStoreLockManagerFactory,
+            null,
+            null,
+            Collections.emptyMap(),
+            false,
+            listener
+        );
+    }
+
     @Override
     public void deleteSnapshots(
         Collection<SnapshotId> snapshotIds,
@@ -932,11 +1093,15 @@ public void deleteSnapshots(
         Version repositoryMetaVersion,
         ActionListener<RepositoryData> listener
     ) {
-        deleteSnapshotsAndReleaseLockFiles(
+        deleteSnapshotsInternal(
             snapshotIds,
             repositoryStateId,
             repositoryMetaVersion,
             null, // Passing null since no remote store lock files need to be cleaned up.
+            null, // Passing null since no remote store segment files need to be cleaned up
+            null,
+            Collections.emptyMap(),
+            false,
             listener
         );
     }
@@ -1001,6 +1166,10 @@ private RepositoryData safeRepositoryData(long repositoryStateId, Map<String, Bl
      *                                      delete operation
      * @param repositoryData                RepositoryData found the in the repository before executing this delete
      * @param remoteStoreLockManagerFactory RemoteStoreLockManagerFactory to be used for cleaning up remote store lock files
+     * @param remoteSegmentStoreDirectoryFactory RemoteSegmentStoreDirectoryFactory to be used for cleaning up remote store segment files
+     * @param remoteStorePinnedTimestampService  RemoteStorePinnedTimestampService to be used for unpinning the snapshot timestamp
+     * @param snapshotIdPinnedTimestampMap       Map of snapshotId and pinned timestamp
+     * @prama isShallowSnapshotV2                true for shallow snapshot v2
      * @param listener                      Listener to invoke once finished
      */
     private void doDeleteShardSnapshots(
@@ -1011,8 +1180,24 @@ private void doDeleteShardSnapshots(
         RepositoryData repositoryData,
         Version repoMetaVersion,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService,
+        Map<SnapshotId, Long> snapshotIdPinnedTimestampMap,
+        boolean isShallowSnapshotV2,
         ActionListener<RepositoryData> listener
     ) {
+        // We can create map of indexId to ShardInfo based on the old repository data. This is later used in cleanup
+        // of stale indexes in combination with Snapshot Shard Paths file
+        Map<String, ShardInfo> idToShardInfoMap = repositoryData.getIndices()
+            .values()
+            .stream()
+            .collect(
+                Collectors.toMap(
+                    IndexId::getId,
+                    indexId -> new ShardInfo(indexId, repositoryData.shardGenerations().getGens(indexId).size())
+                )
+            );
+
         if (SnapshotsService.useShardGenerations(repoMetaVersion)) {
             // First write the new shard state metadata (with the removed snapshot) and compute deletion targets
             final StepListener<Collection<ShardSnapshotMetaDeleteResult>> writeShardMetaDataAndComputeDeletesStep = new StepListener<>();
@@ -1042,86 +1227,229 @@ private void doDeleteShardSnapshots(
                     repositoryStateId,
                     repoMetaVersion,
                     Function.identity(),
+                    Priority.NORMAL,
                     ActionListener.wrap(writeUpdatedRepoDataStep::onResponse, listener::onFailure)
                 );
             }, listener::onFailure);
             // Once we have updated the repository, run the clean-ups
+            final StepListener<RepositoryData> pinnedTimestampListener = new StepListener<>();
             writeUpdatedRepoDataStep.whenComplete(updatedRepoData -> {
+                if (snapshotIdPinnedTimestampMap == null || snapshotIdPinnedTimestampMap.isEmpty()) {
+                    pinnedTimestampListener.onResponse(updatedRepoData);
+                } else {
+                    removeSnapshotsPinnedTimestamp(
+                        snapshotIdPinnedTimestampMap,
+                        this,
+                        updatedRepoData,
+                        remoteStorePinnedTimestampService,
+                        pinnedTimestampListener
+                    );
+                }
+            }, listener::onFailure);
+
+            pinnedTimestampListener.whenComplete(updatedRepoData -> {
+
                 // Run unreferenced blobs cleanup in parallel to shard-level snapshot deletion
                 final ActionListener<Void> afterCleanupsListener = new GroupedActionListener<>(
                     ActionListener.wrap(() -> listener.onResponse(updatedRepoData)),
                     2
                 );
+
                 cleanupUnlinkedRootAndIndicesBlobs(
                     snapshotIds,
                     foundIndices,
                     rootBlobs,
                     updatedRepoData,
-                    remoteStoreLockManagerFactory,
-                    afterCleanupsListener
-                );
-                asyncCleanupUnlinkedShardLevelBlobs(
                     repositoryData,
-                    snapshotIds,
-                    writeShardMetaDataAndComputeDeletesStep.result(),
                     remoteStoreLockManagerFactory,
-                    afterCleanupsListener
+                    remoteSegmentStoreDirectoryFactory,
+                    afterCleanupsListener,
+                    idToShardInfoMap
                 );
+                if (isShallowSnapshotV2) {
+                    cleanUpRemoteStoreFilesForDeletedIndicesV2(
+                        repositoryData,
+                        snapshotIds,
+                        writeShardMetaDataAndComputeDeletesStep.result(),
+                        remoteSegmentStoreDirectoryFactory,
+                        afterCleanupsListener
+                    );
+                } else {
+                    asyncCleanupUnlinkedShardLevelBlobs(
+                        repositoryData,
+                        snapshotIds,
+                        writeShardMetaDataAndComputeDeletesStep.result(),
+                        remoteStoreLockManagerFactory,
+                        afterCleanupsListener
+                    );
+                }
             }, listener::onFailure);
+
         } else {
             // Write the new repository data first (with the removed snapshot), using no shard generations
             final RepositoryData updatedRepoData = repositoryData.removeSnapshots(snapshotIds, ShardGenerations.EMPTY);
-            writeIndexGen(updatedRepoData, repositoryStateId, repoMetaVersion, Function.identity(), ActionListener.wrap(newRepoData -> {
-                // Run unreferenced blobs cleanup in parallel to shard-level snapshot deletion
-                final ActionListener<Void> afterCleanupsListener = new GroupedActionListener<>(
-                    ActionListener.wrap(() -> listener.onResponse(newRepoData)),
-                    2
-                );
-                cleanupUnlinkedRootAndIndicesBlobs(
-                    snapshotIds,
-                    foundIndices,
-                    rootBlobs,
-                    newRepoData,
-                    remoteStoreLockManagerFactory,
-                    afterCleanupsListener
-                );
-                final StepListener<Collection<ShardSnapshotMetaDeleteResult>> writeMetaAndComputeDeletesStep = new StepListener<>();
-                writeUpdatedShardMetaDataAndComputeDeletes(
-                    snapshotIds,
-                    repositoryData,
-                    false,
-                    remoteStoreLockManagerFactory,
-                    writeMetaAndComputeDeletesStep
-                );
-                writeMetaAndComputeDeletesStep.whenComplete(
-                    deleteResults -> asyncCleanupUnlinkedShardLevelBlobs(
+            writeIndexGen(
+                updatedRepoData,
+                repositoryStateId,
+                repoMetaVersion,
+                Function.identity(),
+                Priority.NORMAL,
+                ActionListener.wrap(newRepoData -> {
+                    // Run unreferenced blobs cleanup in parallel to shard-level snapshot deletion
+                    final ActionListener<Void> afterCleanupsListener = new GroupedActionListener<>(
+                        ActionListener.wrap(() -> listener.onResponse(newRepoData)),
+                        2
+                    );
+                    cleanupUnlinkedRootAndIndicesBlobs(
+                        snapshotIds,
+                        foundIndices,
+                        rootBlobs,
+                        newRepoData,
                         repositoryData,
+                        remoteStoreLockManagerFactory,
+                        remoteSegmentStoreDirectoryFactory,
+                        afterCleanupsListener,
+                        idToShardInfoMap
+                    );
+                    final StepListener<Collection<ShardSnapshotMetaDeleteResult>> writeMetaAndComputeDeletesStep = new StepListener<>();
+                    writeUpdatedShardMetaDataAndComputeDeletes(
                         snapshotIds,
-                        deleteResults,
+                        repositoryData,
+                        false,
                         remoteStoreLockManagerFactory,
-                        afterCleanupsListener
-                    ),
-                    afterCleanupsListener::onFailure
-                );
-            }, listener::onFailure));
+                        writeMetaAndComputeDeletesStep
+                    );
+                    writeMetaAndComputeDeletesStep.whenComplete(
+                        deleteResults -> asyncCleanupUnlinkedShardLevelBlobs(
+                            repositoryData,
+                            snapshotIds,
+                            deleteResults,
+                            remoteStoreLockManagerFactory,
+                            afterCleanupsListener
+                        ),
+                        afterCleanupsListener::onFailure
+                    );
+                }, listener::onFailure)
+            );
+        }
+    }
+
+    private void cleanUpRemoteStoreFilesForDeletedIndicesV2(
+        RepositoryData repositoryData,
+        Collection<SnapshotId> snapshotIds,
+        Collection<ShardSnapshotMetaDeleteResult> result,
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        ActionListener<Void> afterCleanupsListener
+    ) {
+        try {
+            Set<String> uniqueIndexIds = new HashSet<>();
+            for (ShardSnapshotMetaDeleteResult shardSnapshotMetaDeleteResult : result) {
+                uniqueIndexIds.add(shardSnapshotMetaDeleteResult.indexId.getId());
+            }
+            // iterate through all the indices and trigger remote store directory cleanup for deleted index segments
+            for (String indexId : uniqueIndexIds) {
+                cleanRemoteStoreDirectoryIfNeeded(snapshotIds, indexId, repositoryData, remoteSegmentStoreDirectoryFactory);
+            }
+            afterCleanupsListener.onResponse(null);
+        } catch (Exception e) {
+            logger.warn("Exception during cleanup of remote directory files for snapshot v2", e);
+            afterCleanupsListener.onFailure(e);
         }
+
+    }
+
+    private void removeSnapshotsPinnedTimestamp(
+        Map<SnapshotId, Long> snapshotsWithPinnedTimestamp,
+        Repository repository,
+        RepositoryData repositoryData,
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService,
+        ActionListener<RepositoryData> pinnedTimestampListener
+    ) {
+        // Create a GroupedActionListener to aggregate the results of all unpin operations
+        GroupedActionListener<RepositoryData> groupedListener = new GroupedActionListener<>(
+            ActionListener.wrap(
+                // This is called once all operations have succeeded
+                ignored -> pinnedTimestampListener.onResponse(repositoryData),
+                // This is called if any operation fails
+                pinnedTimestampListener::onFailure
+            ),
+            snapshotsWithPinnedTimestamp.size()
+        );
+
+        snapshotsWithPinnedTimestamp.forEach((snapshotId, pinnedTimestamp) -> {
+            removeSnapshotPinnedTimestamp(
+                remoteStorePinnedTimestampService,
+                snapshotId,
+                repository.getMetadata().name(),
+                pinnedTimestamp,
+                groupedListener
+            );
+        });
     }
 
+    private void removeSnapshotPinnedTimestamp(
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService,
+        SnapshotId snapshotId,
+        String repository,
+        long timestampToUnpin,
+        ActionListener<RepositoryData> listener
+    ) {
+        remoteStorePinnedTimestampService.unpinTimestamp(
+            timestampToUnpin,
+            repository + SNAPSHOT_PINNED_TIMESTAMP_DELIMITER + snapshotId.getUUID(),
+            new ActionListener<Void>() {
+                @Override
+                public void onResponse(Void unused) {
+                    logger.debug("Timestamp {} unpinned successfully for snapshot {}", timestampToUnpin, snapshotId.getName());
+                    listener.onResponse(null);
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    logger.error(
+                        "Failed to unpin timestamp {} for snapshot {} with exception {}",
+                        timestampToUnpin,
+                        snapshotId.getName(),
+                        e
+                    );
+                    listener.onFailure(e);
+                }
+            }
+        );
+    }
+
+    /**
+     * Cleans up the indices and data corresponding to all it's shards.
+     *
+     * @param deletedSnapshots              list of snapshots being deleted
+     * @param foundIndices                  indices that are found at [base_path]/indices
+     * @param rootBlobs                     the blobs at the [base_path]
+     * @param updatedRepoData               the new repository data after the deletion
+     * @param remoteStoreLockManagerFactory remote store lock manager factory used for shallow snapshots
+     * @param listener                      listener on deletion of the stale indices
+     * @param idToShardInfoMap              map of indexId to ShardInfo
+     */
     private void cleanupUnlinkedRootAndIndicesBlobs(
         Collection<SnapshotId> deletedSnapshots,
         Map<String, BlobContainer> foundIndices,
         Map<String, BlobMetadata> rootBlobs,
         RepositoryData updatedRepoData,
+        RepositoryData oldRepoData,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
-        ActionListener<Void> listener
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        ActionListener<Void> listener,
+        Map<String, ShardInfo> idToShardInfoMap
     ) {
         cleanupStaleBlobs(
             deletedSnapshots,
             foundIndices,
             rootBlobs,
             updatedRepoData,
+            oldRepoData,
             remoteStoreLockManagerFactory,
-            ActionListener.map(listener, ignored -> null)
+            remoteSegmentStoreDirectoryFactory,
+            ActionListener.map(listener, ignored -> null),
+            idToShardInfoMap
         );
     }
 
@@ -1132,7 +1460,11 @@ private void asyncCleanupUnlinkedShardLevelBlobs(
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
         ActionListener<Void> listener
     ) {
-        final List<String> filesToDelete = resolveFilesToDelete(oldRepositoryData, snapshotIds, deleteResults);
+        final List<Tuple<BlobPath, String>> filesToDelete = resolveFilesToDelete(oldRepositoryData, snapshotIds, deleteResults);
+        long startTimeNs = System.nanoTime();
+        Randomness.shuffle(filesToDelete);
+        logger.debug("[{}] shuffled the filesToDelete with timeElapsedNs={}", metadata.name(), (System.nanoTime() - startTimeNs));
+
         if (filesToDelete.isEmpty()) {
             listener.onResponse(null);
             return;
@@ -1140,18 +1472,18 @@ private void asyncCleanupUnlinkedShardLevelBlobs(
 
         try {
             AtomicInteger counter = new AtomicInteger();
-            Collection<List<String>> subList = filesToDelete.stream()
+            Collection<List<Tuple<BlobPath, String>>> subList = filesToDelete.stream()
                 .collect(Collectors.groupingBy(it -> counter.getAndIncrement() / maxShardBlobDeleteBatch))
                 .values();
-            final BlockingQueue<List<String>> staleFilesToDeleteInBatch = new LinkedBlockingQueue<>(subList);
+            final BlockingQueue<List<Tuple<BlobPath, String>>> staleFilesToDeleteInBatch = new LinkedBlockingQueue<>(subList);
 
             final GroupedActionListener<Void> groupedListener = new GroupedActionListener<>(
                 ActionListener.wrap(r -> { listener.onResponse(null); }, listener::onFailure),
                 staleFilesToDeleteInBatch.size()
             );
 
-            // Start as many workers as fit into the snapshot pool at once at the most
-            final int workers = Math.min(threadPool.info(ThreadPool.Names.SNAPSHOT).getMax(), staleFilesToDeleteInBatch.size());
+            // Start as many workers as fit into the snapshot_deletion pool at once at the most
+            final int workers = Math.min(threadPool.info(ThreadPool.Names.SNAPSHOT_DELETION).getMax(), staleFilesToDeleteInBatch.size());
             for (int i = 0; i < workers; ++i) {
                 executeStaleShardDelete(staleFilesToDeleteInBatch, remoteStoreLockManagerFactory, groupedListener);
             }
@@ -1229,7 +1561,8 @@ protected void releaseRemoteStoreLockAndCleanup(
             // related issue: https://github.com/opensearch-project/OpenSearch/issues/8469
             RemoteSegmentStoreDirectoryFactory remoteDirectoryFactory = new RemoteSegmentStoreDirectoryFactory(
                 remoteStoreLockManagerFactory.getRepositoriesService(),
-                threadPool
+                threadPool,
+                remoteStoreSettings.getSegmentsPathFixedPrefix()
             );
             remoteDirectoryCleanupAsync(
                 remoteDirectoryFactory,
@@ -1246,57 +1579,67 @@ protected void releaseRemoteStoreLockAndCleanup(
     // When remoteStoreLockManagerFactory is non-null, while deleting the files, lock files are also released before deletion of respective
     // shallow-snap-UUID files. And if it is null, we just delete the stale shard blobs.
     private void executeStaleShardDelete(
-        BlockingQueue<List<String>> staleFilesToDeleteInBatch,
+        BlockingQueue<List<Tuple<BlobPath, String>>> staleFilesToDeleteInBatch,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
         GroupedActionListener<Void> listener
     ) throws InterruptedException {
-        List<String> filesToDelete = staleFilesToDeleteInBatch.poll(0L, TimeUnit.MILLISECONDS);
-        if (filesToDelete != null) {
-            threadPool.executor(ThreadPool.Names.SNAPSHOT).execute(ActionRunnable.wrap(listener, l -> {
-                try {
-                    // filtering files for which remote store lock release and cleanup succeeded,
-                    // remaining files for which it failed will be retried in next snapshot delete run.
-                    List<String> eligibleFilesToDelete = new ArrayList<>();
-                    for (String fileToDelete : filesToDelete) {
-                        if (fileToDelete.contains(SHALLOW_SNAPSHOT_PREFIX)) {
-                            String[] fileToDeletePath = fileToDelete.split("/");
-                            String indexId = fileToDeletePath[1];
-                            String shardId = fileToDeletePath[2];
-                            String shallowSnapBlob = fileToDeletePath[3];
-                            String snapshotUUID = extractShallowSnapshotUUID(shallowSnapBlob).orElseThrow();
-                            BlobContainer shardContainer = blobStore().blobContainer(indicesPath().add(indexId).add(shardId));
-                            try {
-                                releaseRemoteStoreLockAndCleanup(shardId, snapshotUUID, shardContainer, remoteStoreLockManagerFactory);
-                                eligibleFilesToDelete.add(fileToDelete);
-                            } catch (Exception e) {
-                                logger.error(
-                                    "Failed to release lock or cleanup shard for indexID {}, shardID {} " + "and snapshot {}",
-                                    indexId,
-                                    shardId,
-                                    snapshotUUID
-                                );
-                            }
-                        } else {
-                            eligibleFilesToDelete.add(fileToDelete);
+        List<Tuple<BlobPath, String>> filesToDelete = staleFilesToDeleteInBatch.poll(0L, TimeUnit.MILLISECONDS);
+        if (filesToDelete == null) {
+            return;
+        }
+        threadPool.executor(ThreadPool.Names.SNAPSHOT_DELETION).execute(ActionRunnable.wrap(listener, l -> {
+            try {
+                // filtering files for which remote store lock release and cleanup succeeded,
+                // remaining files for which it failed will be retried in next snapshot delete run.
+                List<String> eligibleFilesToDelete = new ArrayList<>();
+                for (Tuple<BlobPath, String> fileToDelete : filesToDelete) {
+                    BlobPath blobPath = fileToDelete.v1();
+                    String blobName = fileToDelete.v2();
+                    boolean deleteBlob = false;
+                    if (blobName.startsWith(SHALLOW_SNAPSHOT_PREFIX)) {
+                        String snapshotUUID = extractShallowSnapshotUUID(blobName).orElseThrow();
+                        String[] parts = blobPath.toArray();
+                        // For fixed, the parts would look like [<base_path>,"indices","<index-id>","<shard-id>"]
+                        // For hashed_prefix, the parts would look like ["j01010001010",<base_path>,"indices","<index-id>","<shard-id>"]
+                        // For hashed_infix, the parts would look like [<base_path>,"j01010001010","indices","<index-id>","<shard-id>"]
+                        int partLength = parts.length;
+                        String indexId = parts[partLength - 2];
+                        String shardId = parts[partLength - 1];
+                        BlobContainer shardContainer = blobStore().blobContainer(blobPath);
+                        try {
+                            releaseRemoteStoreLockAndCleanup(shardId, snapshotUUID, shardContainer, remoteStoreLockManagerFactory);
+                            deleteBlob = true;
+                        } catch (Exception e) {
+                            logger.error(
+                                "Failed to release lock or cleanup shard for indexID {}, shardID {} and snapshot {}",
+                                indexId,
+                                shardId,
+                                snapshotUUID
+                            );
                         }
+                    } else {
+                        deleteBlob = true;
+                    }
+                    if (deleteBlob) {
+                        eligibleFilesToDelete.add(blobPath.buildAsString() + blobName);
                     }
-                    // Deleting the shard blobs
-                    deleteFromContainer(blobContainer(), eligibleFilesToDelete);
-                    l.onResponse(null);
-                } catch (Exception e) {
-                    logger.warn(
-                        () -> new ParameterizedMessage(
-                            "[{}] Failed to delete following blobs during snapshot delete : {}",
-                            metadata.name(),
-                            filesToDelete
-                        ),
-                        e
-                    );
-                    l.onFailure(e);
                 }
-                executeStaleShardDelete(staleFilesToDeleteInBatch, remoteStoreLockManagerFactory, listener);
-            }));
-        }
+                // Deleting the shard blobs
+                deleteFromContainer(rootBlobContainer(), eligibleFilesToDelete);
+                l.onResponse(null);
+            } catch (Exception e) {
+                logger.warn(
+                    () -> new ParameterizedMessage(
+                        "[{}] Failed to delete following blobs during snapshot delete : {}",
+                        metadata.name(),
+                        filesToDelete
+                    ),
+                    e
+                );
+                l.onFailure(e);
+            }
+            executeStaleShardDelete(staleFilesToDeleteInBatch, remoteStoreLockManagerFactory, listener);
+        }));
     }
 
     // updates the shard state metadata for shards of a snapshot that is to be deleted. Also computes the files to be cleaned up.
@@ -1308,7 +1651,7 @@ private void writeUpdatedShardMetaDataAndComputeDeletes(
         ActionListener<Collection<ShardSnapshotMetaDeleteResult>> onAllShardsCompleted
     ) {
 
-        final Executor executor = threadPool.executor(ThreadPool.Names.SNAPSHOT);
+        final Executor executor = threadPool.executor(ThreadPool.Names.SNAPSHOT_DELETION);
         final List<IndexId> indices = oldRepositoryData.indicesToUpdateAfterRemovingSnapshot(snapshotIds);
 
         if (indices.isEmpty()) {
@@ -1438,26 +1781,30 @@ public void onFailure(Exception ex) {
         }
     }
 
-    private List<String> resolveFilesToDelete(
+    /**
+     * Resolves the list of files that should be deleted during a snapshot deletion operation.
+     * This method combines files to be deleted from shard-level metadata and index-level metadata.
+     *
+     * @param oldRepositoryData The repository data before the snapshot deletion
+     * @param snapshotIds       The IDs of the snapshots being deleted
+     * @param deleteResults     The results of removing snapshots from shard-level metadata
+     * @return A list of tuples, each containing a blob path and the name of a blob to be deleted
+     */
+    private List<Tuple<BlobPath, String>> resolveFilesToDelete(
         RepositoryData oldRepositoryData,
         Collection<SnapshotId> snapshotIds,
         Collection<ShardSnapshotMetaDeleteResult> deleteResults
     ) {
-        final String basePath = basePath().buildAsString();
-        final int basePathLen = basePath.length();
         final Map<IndexId, Collection<String>> indexMetaGenerations = oldRepositoryData.indexMetaDataToRemoveAfterRemovingSnapshots(
             snapshotIds
         );
         return Stream.concat(deleteResults.stream().flatMap(shardResult -> {
-            final String shardPath = shardContainer(shardResult.indexId, shardResult.shardId).path().buildAsString();
-            return shardResult.blobsToDelete.stream().map(blob -> shardPath + blob);
+            final BlobPath shardPath = shardPath(shardResult.indexId, shardResult.shardId);
+            return shardResult.blobsToDelete.stream().map(blob -> Tuple.tuple(shardPath, blob));
         }), indexMetaGenerations.entrySet().stream().flatMap(entry -> {
-            final String indexContainerPath = indexContainer(entry.getKey()).path().buildAsString();
-            return entry.getValue().stream().map(id -> indexContainerPath + INDEX_METADATA_FORMAT.blobName(id));
-        })).map(absolutePath -> {
-            assert absolutePath.startsWith(basePath);
-            return absolutePath.substring(basePathLen);
-        }).collect(Collectors.toList());
+            final BlobPath indexPath = indexPath(entry.getKey());
+            return entry.getValue().stream().map(id -> Tuple.tuple(indexPath, INDEX_METADATA_FORMAT.blobName(id)));
+        })).collect(Collectors.toList());
     }
 
     /**
@@ -1472,6 +1819,7 @@ private List<String> resolveFilesToDelete(
      * @param rootBlobs                     all blobs found directly under the repository root
      * @param newRepoData                   new repository data that was just written
      * @param remoteStoreLockManagerFactory RemoteStoreLockManagerFactory to be used for cleaning up remote store lock files.
+     * @param idToShardInfoMap              map of indexId to ShardInfo
      * @param listener                      listener to invoke with the combined {@link DeleteResult} of all blobs removed in this operation
      */
     private void cleanupStaleBlobs(
@@ -1479,8 +1827,11 @@ private void cleanupStaleBlobs(
         Map<String, BlobContainer> foundIndices,
         Map<String, BlobMetadata> rootBlobs,
         RepositoryData newRepoData,
+        RepositoryData oldRepoData,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
-        ActionListener<DeleteResult> listener
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        ActionListener<DeleteResult> listener,
+        Map<String, ShardInfo> idToShardInfoMap
     ) {
         final GroupedActionListener<DeleteResult> groupedListener = new GroupedActionListener<>(ActionListener.wrap(deleteResults -> {
             DeleteResult deleteResult = DeleteResult.ZERO;
@@ -1490,7 +1841,7 @@ private void cleanupStaleBlobs(
             listener.onResponse(deleteResult);
         }, listener::onFailure), 2);
 
-        final Executor executor = threadPool.executor(ThreadPool.Names.SNAPSHOT);
+        final Executor executor = threadPool.executor(ThreadPool.Names.SNAPSHOT_DELETION);
         final List<String> staleRootBlobs = staleRootBlobs(newRepoData, rootBlobs.keySet());
         if (staleRootBlobs.isEmpty()) {
             groupedListener.onResponse(DeleteResult.ZERO);
@@ -1505,8 +1856,28 @@ private void cleanupStaleBlobs(
         if (foundIndices.keySet().equals(survivingIndexIds)) {
             groupedListener.onResponse(DeleteResult.ZERO);
         } else {
-            cleanupStaleIndices(foundIndices, survivingIndexIds, remoteStoreLockManagerFactory, groupedListener);
+            Map<String, BlobMetadata> snapshotShardPaths = getSnapshotShardPaths();
+            cleanupStaleIndices(
+                deletedSnapshots,
+                foundIndices,
+                survivingIndexIds,
+                remoteStoreLockManagerFactory,
+                remoteSegmentStoreDirectoryFactory,
+                oldRepoData,
+                groupedListener,
+                snapshotShardPaths,
+                idToShardInfoMap
+            );
+        }
+    }
+
+    private Map<String, BlobMetadata> getSnapshotShardPaths() {
+        try {
+            return snapshotShardPathBlobContainer().listBlobs();
+        } catch (IOException ex) {
+            logger.warn(new ParameterizedMessage("Repository [{}] Failed to get the snapshot shard paths", metadata.name()), ex);
         }
+        return Collections.emptyMap();
     }
 
     /**
@@ -1522,12 +1893,14 @@ private void cleanupStaleBlobs(
      * @param repositoryStateId             Current repository state id
      * @param repositoryMetaVersion         version of the updated repository metadata to write
      * @param remoteStoreLockManagerFactory RemoteStoreLockManagerFactory to be used for cleaning up remote store lock files.
+     * @param remoteSegmentStoreDirectoryFactory    RemoteSegmentStoreDirectoryFactory to be used for cleaning up remote store segments.
      * @param listener                      Listener to complete when done
      */
     public void cleanup(
         long repositoryStateId,
         Version repositoryMetaVersion,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
         ActionListener<RepositoryCleanupResult> listener
     ) {
         try {
@@ -1553,14 +1926,18 @@ public void cleanup(
                     repositoryStateId,
                     repositoryMetaVersion,
                     Function.identity(),
+                    Priority.NORMAL,
                     ActionListener.wrap(
                         v -> cleanupStaleBlobs(
                             Collections.emptyList(),
                             foundIndices,
                             rootBlobs,
                             repositoryData,
+                            repositoryData,
                             remoteStoreLockManagerFactory,
-                            ActionListener.map(listener, RepositoryCleanupResult::new)
+                            remoteSegmentStoreDirectoryFactory,
+                            ActionListener.map(listener, RepositoryCleanupResult::new),
+                            Collections.emptyMap()
                         ),
                         listener::onFailure
                     )
@@ -1648,11 +2025,16 @@ private List<String> cleanupStaleRootFiles(
         return Collections.emptyList();
     }
 
-    private void cleanupStaleIndices(
+    void cleanupStaleIndices(
+        Collection<SnapshotId> deletedSnapshots,
         Map<String, BlobContainer> foundIndices,
         Set<String> survivingIndexIds,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
-        GroupedActionListener<DeleteResult> listener
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        RepositoryData oldRepoData,
+        GroupedActionListener<DeleteResult> listener,
+        Map<String, BlobMetadata> snapshotShardPaths,
+        Map<String, ShardInfo> idToShardInfoMap
     ) {
         final GroupedActionListener<DeleteResult> groupedListener = new GroupedActionListener<>(ActionListener.wrap(deleteResults -> {
             DeleteResult deleteResult = DeleteResult.ZERO;
@@ -1672,11 +2054,20 @@ private void cleanupStaleIndices(
 
             // Start as many workers as fit into the snapshot pool at once at the most
             final int workers = Math.min(
-                threadPool.info(ThreadPool.Names.SNAPSHOT).getMax(),
+                threadPool.info(ThreadPool.Names.SNAPSHOT_DELETION).getMax(),
                 foundIndices.size() - survivingIndexIds.size()
             );
             for (int i = 0; i < workers; ++i) {
-                executeOneStaleIndexDelete(staleIndicesToDelete, remoteStoreLockManagerFactory, groupedListener);
+                executeOneStaleIndexDelete(
+                    deletedSnapshots,
+                    staleIndicesToDelete,
+                    remoteStoreLockManagerFactory,
+                    remoteSegmentStoreDirectoryFactory,
+                    oldRepoData,
+                    groupedListener,
+                    snapshotShardPaths,
+                    idToShardInfoMap
+                );
             }
         } catch (Exception e) {
             // TODO: We shouldn't be blanket catching and suppressing all exceptions here and instead handle them safely upstream.
@@ -1696,58 +2087,313 @@ private static boolean isIndexPresent(ClusterService clusterService, String inde
         return false;
     }
 
+    /**
+     * Executes the deletion of a single stale index.
+     *
+     * @param staleIndicesToDelete          Queue of stale indices to delete
+     * @param remoteStoreLockManagerFactory Factory for creating remote store lock managers
+     * @param listener                      Listener for grouped delete actions
+     * @param snapshotShardPaths            Map of snapshot shard paths and their metadata
+     * @param idToShardInfoMap              Map of indexId to ShardInfo
+     * @throws InterruptedException if the thread is interrupted while waiting
+     */
     private void executeOneStaleIndexDelete(
+        Collection<SnapshotId> deletedSnapshots,
         BlockingQueue<Map.Entry<String, BlobContainer>> staleIndicesToDelete,
         RemoteStoreLockManagerFactory remoteStoreLockManagerFactory,
-        GroupedActionListener<DeleteResult> listener
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory,
+        RepositoryData oldRepoData,
+        GroupedActionListener<DeleteResult> listener,
+        Map<String, BlobMetadata> snapshotShardPaths,
+        Map<String, ShardInfo> idToShardInfoMap
     ) throws InterruptedException {
         Map.Entry<String, BlobContainer> indexEntry = staleIndicesToDelete.poll(0L, TimeUnit.MILLISECONDS);
-        if (indexEntry != null) {
-            final String indexSnId = indexEntry.getKey();
-            threadPool.executor(ThreadPool.Names.SNAPSHOT).execute(ActionRunnable.supply(listener, () -> {
-                DeleteResult deleteResult = DeleteResult.ZERO;
+        if (indexEntry == null) {
+            return;
+        }
+        final String indexSnId = indexEntry.getKey();
+        threadPool.executor(ThreadPool.Names.SNAPSHOT_DELETION).execute(ActionRunnable.supply(listener, () -> {
+            try {
+                logger.debug("[{}] Found stale index [{}]. Cleaning it up", metadata.name(), indexSnId);
+                List<String> matchingShardPaths = findMatchingShardPaths(indexSnId, snapshotShardPaths);
+                Optional<String> highestGenShardPaths = findHighestGenerationShardPaths(matchingShardPaths);
+
+                // The shardInfo can be null for 1) snapshots that pre-dates the hashed prefix snapshots.
+                // 2) Snapshot shard paths file upload failed
+                // In such cases, we fallback to fixed_path for cleanup of the data.
+                ShardInfo shardInfo = getShardInfo(highestGenShardPaths, idToShardInfoMap, indexSnId);
+
+                if (remoteStoreLockManagerFactory != null) {
+                    cleanupRemoteStoreLocks(indexEntry, shardInfo, remoteStoreLockManagerFactory);
+                }
+
+                // Deletes the shard level data for the underlying index based on the shardInfo that was obtained above.
+                DeleteResult deleteResult = deleteShardData(shardInfo);
+
+                // If there are matchingShardPaths, then we delete them after we have deleted the shard data.
+                deleteResult = deleteResult.add(cleanUpStaleSnapshotShardPathsFile(matchingShardPaths, snapshotShardPaths));
+
+                if (remoteSegmentStoreDirectoryFactory != null) {
+                    cleanRemoteStoreDirectoryIfNeeded(deletedSnapshots, indexSnId, oldRepoData, remoteSegmentStoreDirectoryFactory);
+                }
+
+                // Finally, we delete the [base_path]/indexId folder
+                deleteResult = deleteResult.add(indexEntry.getValue().delete()); // Deleting the index folder
+                logger.debug("[{}] Cleaned up stale index [{}]", metadata.name(), indexSnId);
+                return deleteResult;
+            } catch (IOException e) {
+                logger.warn(
+                    () -> new ParameterizedMessage(
+                        "[{}] index {} is no longer part of any snapshots in the repository, "
+                            + "but failed to clean up their index folders",
+                        metadata.name(),
+                        indexSnId
+                    ),
+                    e
+                );
+                return DeleteResult.ZERO;
+            } catch (Exception e) {
+                assert false : e;
+                logger.warn(new ParameterizedMessage("[{}] Exception during single stale index delete", metadata.name()), e);
+                return DeleteResult.ZERO;
+            } finally {
+                executeOneStaleIndexDelete(
+                    deletedSnapshots,
+                    staleIndicesToDelete,
+                    remoteStoreLockManagerFactory,
+                    remoteSegmentStoreDirectoryFactory,
+                    oldRepoData,
+                    listener,
+                    snapshotShardPaths,
+                    idToShardInfoMap
+                );
+            }
+        }));
+    }
+
+    /**
+     * Cleans up the remote store directory if needed.
+     * <p> This method cleans up segments in the remote store directory for deleted indices.
+     * This cleanup flow is executed only for v2 snapshots. For v1 snapshots,
+     * the cleanup is done per shard after releasing the lock files.
+     * </p>
+     *
+     * <p> Since this method requires old repository data to fetch index metadata of the deleted index,
+     * the cleanup won't happen on retries in case of failures. This is because subsequent retries may
+     * not have access to the older repository data. </p>
+     *
+     * @param indexSnId     The snapshot index id of the index to be cleaned up
+     * @param oldRepoData   The old repository metadata used to fetch the index metadata.
+     * @param remoteSegmentStoreDirectoryFactory RemoteSegmentStoreDirectoryFactory to be used for cleaning up remote
+     *                                          store segments
+     */
+    private void cleanRemoteStoreDirectoryIfNeeded(
+        Collection<SnapshotId> deletedSnapshots,
+        String indexSnId,
+        RepositoryData oldRepoData,
+        RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory
+    ) {
+        assert (indexSnId != null);
+
+        IndexId indexId = null;
+        List<SnapshotId> snapshotIds = Collections.emptyList();
+        try {
+            for (Map.Entry<IndexId, List<SnapshotId>> entry : oldRepoData.getIndexSnapshots().entrySet()) {
+                indexId = entry.getKey();
+                if (indexId != null && indexId.getId().equals(indexSnId)) {
+                    snapshotIds = entry.getValue();
+                    break;
+                }
+            }
+            if (snapshotIds.isEmpty()) {
+                logger.info("No snapshots found for indexSnId: {}", indexSnId);
+                return;
+            }
+            for (SnapshotId snapshotId : snapshotIds) {
                 try {
-                    logger.debug("[{}] Found stale index [{}]. Cleaning it up", metadata.name(), indexSnId);
-                    if (remoteStoreLockManagerFactory != null) {
-                        final Map<String, BlobContainer> shardBlobs = indexEntry.getValue().children();
-                        for (Map.Entry<String, BlobContainer> shardBlob : shardBlobs.entrySet()) {
-                            for (String blob : shardBlob.getValue().listBlobs().keySet()) {
-                                final Optional<String> snapshotUUID = extractShallowSnapshotUUID(blob);
-                                if (snapshotUUID.isPresent()) {
-                                    releaseRemoteStoreLockAndCleanup(
-                                        shardBlob.getKey(),
-                                        snapshotUUID.get(),
-                                        shardBlob.getValue(),
-                                        remoteStoreLockManagerFactory
-                                    );
-                                }
-                            }
+                    // skip cleanup for snapshot not present in deleted snapshots list
+                    if (!deletedSnapshots.contains(snapshotId)) {
+                        continue;
+                    }
+                    IndexMetadata prevIndexMetadata = this.getSnapshotIndexMetaData(oldRepoData, snapshotId, indexId);
+                    if (prevIndexMetadata != null && !isIndexPresent(clusterService, prevIndexMetadata.getIndexUUID())) {
+                        String remoteStoreRepository = IndexMetadata.INDEX_REMOTE_TRANSLOG_REPOSITORY_SETTING.get(
+                            prevIndexMetadata.getSettings()
+                        );
+                        assert (remoteStoreRepository != null);
+
+                        RemoteStorePathStrategy remoteStorePathStrategy = RemoteStoreUtils.determineRemoteStorePathStrategy(
+                            prevIndexMetadata
+                        );
+
+                        for (int shardId = 0; shardId < prevIndexMetadata.getNumberOfShards(); shardId++) {
+                            remoteDirectoryCleanupAsync(
+                                remoteSegmentStoreDirectoryFactory,
+                                threadPool,
+                                remoteStoreRepository,
+                                prevIndexMetadata.getIndexUUID(),
+                                new ShardId(Index.UNKNOWN_INDEX_NAME, prevIndexMetadata.getIndexUUID(), shardId),
+                                ThreadPool.Names.REMOTE_PURGE,
+                                remoteStorePathStrategy
+                            );
                         }
                     }
-                    // Deleting the index folder
-                    deleteResult = indexEntry.getValue().delete();
-                    logger.debug("[{}] Cleaned up stale index [{}]", metadata.name(), indexSnId);
-                } catch (IOException e) {
+                } catch (Exception e) {
                     logger.warn(
-                        () -> new ParameterizedMessage(
-                            "[{}] index {} is no longer part of any snapshots in the repository, "
-                                + "but failed to clean up their index folders",
-                            metadata.name(),
+                        new ParameterizedMessage(
+                            "Exception during cleanup of remote directory for snapshot [{}] deleted index [{}]",
+                            snapshotId,
                             indexSnId
                         ),
                         e
                     );
-                } catch (Exception e) {
-                    assert false : e;
-                    logger.warn(new ParameterizedMessage("[{}] Exception during single stale index delete", metadata.name()), e);
                 }
+            }
+        } catch (Exception e) {
+            logger.error(new ParameterizedMessage("Exception during the remote directory cleanup for indecSnId [{}]", indexSnId), e);
+        }
 
-                executeOneStaleIndexDelete(staleIndicesToDelete, remoteStoreLockManagerFactory, listener);
-                return deleteResult;
-            }));
+    }
+
+    /**
+     * Finds and returns a list of shard paths that match the given index ID.
+     *
+     * @param indexId            The ID of the index to match
+     * @param snapshotShardPaths Map of snapshot shard paths and their metadata
+     * @return List of matching shard paths
+     */
+    private List<String> findMatchingShardPaths(String indexId, Map<String, BlobMetadata> snapshotShardPaths) {
+        return snapshotShardPaths.keySet().stream().filter(s -> s.startsWith(indexId)).collect(Collectors.toList());
+    }
+
+    /**
+     * Finds the shard path with the highest generation number from the given list of matching shard paths.
+     *
+     * @param matchingShardPaths List of shard paths that match a specific criteria
+     * @return An Optional containing the shard path with the highest generation number, or empty if the list is empty
+     */
+    private Optional<String> findHighestGenerationShardPaths(List<String> matchingShardPaths) {
+        return matchingShardPaths.stream()
+            .map(s -> s.split("\\" + SnapshotShardPaths.DELIMITER))
+            .sorted((a, b) -> Integer.parseInt(b[2]) - Integer.parseInt(a[2]))
+            .map(parts -> String.join(SnapshotShardPaths.DELIMITER, parts))
+            .findFirst();
+    }
+
+    /**
+     * Cleans up remote store locks for a given index entry.
+     *
+     * @param indexEntry                    The index entry containing the blob container
+     * @param shardInfo                     ShardInfo for the IndexId being cleaned up
+     * @param remoteStoreLockManagerFactory Factory for creating remote store lock managers
+     * @throws IOException If an I/O error occurs during the cleanup process
+     */
+    private void cleanupRemoteStoreLocks(
+        Map.Entry<String, BlobContainer> indexEntry,
+        ShardInfo shardInfo,
+        RemoteStoreLockManagerFactory remoteStoreLockManagerFactory
+    ) throws IOException {
+        if (shardInfo == null) {
+            releaseRemoteStoreLocksAndCleanup(indexEntry.getValue().children(), remoteStoreLockManagerFactory);
+        } else {
+            Map<String, BlobContainer> shardContainers = new HashMap<>(shardInfo.getShardCount());
+            for (int i = 0; i < shardInfo.getShardCount(); i++) {
+                shardContainers.put(String.valueOf(i), shardContainer(shardInfo.getIndexId(), i));
+            }
+            releaseRemoteStoreLocksAndCleanup(shardContainers, remoteStoreLockManagerFactory);
+        }
+    }
+
+    /**
+     * Releases remote store locks and performs cleanup for each shard blob.
+     *
+     * @param shardBlobs                    Map of shard IDs to their corresponding BlobContainers
+     * @param remoteStoreLockManagerFactory Factory for creating remote store lock managers
+     * @throws IOException If an I/O error occurs during the release and cleanup process
+     */
+    void releaseRemoteStoreLocksAndCleanup(
+        Map<String, BlobContainer> shardBlobs,
+        RemoteStoreLockManagerFactory remoteStoreLockManagerFactory
+    ) throws IOException {
+        for (Map.Entry<String, BlobContainer> shardBlob : shardBlobs.entrySet()) {
+            for (String blob : shardBlob.getValue().listBlobs().keySet()) {
+                final Optional<String> snapshotUUID = extractShallowSnapshotUUID(blob);
+                if (snapshotUUID.isPresent()) {
+                    releaseRemoteStoreLockAndCleanup(
+                        shardBlob.getKey(),
+                        snapshotUUID.get(),
+                        shardBlob.getValue(),
+                        remoteStoreLockManagerFactory
+                    );
+                }
+            }
         }
     }
 
+    /**
+     * Deletes shard data for the provided ShardInfo object.
+     *
+     * @param shardInfo The ShardInfo object containing information about the shards to be deleted.
+     * @return A DeleteResult object representing the result of the deletion operation.
+     * @throws IOException If an I/O error occurs during the deletion process.
+     */
+    private DeleteResult deleteShardData(ShardInfo shardInfo) throws IOException {
+        // If the provided ShardInfo is null, return a zero DeleteResult
+        if (shardInfo == null) {
+            return DeleteResult.ZERO;
+        }
+
+        // Initialize the DeleteResult with zero values
+        DeleteResult deleteResult = DeleteResult.ZERO;
+
+        // Iterate over the shards and delete each shard's data
+        for (int i = 0; i < shardInfo.getShardCount(); i++) {
+            // Call the delete method on the shardContainer and accumulate the result
+            deleteResult = deleteResult.add(shardContainer(shardInfo.getIndexId(), i).delete());
+        }
+
+        // Return the accumulated DeleteResult
+        return deleteResult;
+    }
+
+    /**
+     * Retrieves the ShardInfo object based on the provided highest generation shard paths,
+     * index ID, and the mapping of index IDs to ShardInfo objects.
+     *
+     * @param highestGenShardPaths The optional highest generation shard path.
+     * @param idToShardInfoMap     A map containing index IDs and their corresponding ShardInfo objects.
+     * @param indexId              The index ID for which the ShardInfo object is needed.
+     * @return The ShardInfo object with the highest shard count, or null if no ShardInfo is available.
+     */
+    private ShardInfo getShardInfo(Optional<String> highestGenShardPaths, Map<String, ShardInfo> idToShardInfoMap, String indexId) {
+        // Extract the ShardInfo object from the highest generation shard path, if present
+        ShardInfo shardInfoFromPath = highestGenShardPaths.map(SnapshotShardPaths::parseShardPath).orElse(null);
+
+        // Retrieve the ShardInfo object from the idToShardInfoMap using the indexId
+        ShardInfo shardInfoFromMap = idToShardInfoMap.get(indexId);
+
+        // If shardInfoFromPath is null, return shardInfoFromMap (which could also be null)
+        if (shardInfoFromPath == null) {
+            return shardInfoFromMap;
+        }
+
+        // If shardInfoFromMap is null, return shardInfoFromPath (which could also be null)
+        if (shardInfoFromMap == null) {
+            return shardInfoFromPath;
+        }
+
+        // If both shardInfoFromPath and shardInfoFromMap are non-null,
+        // return the ShardInfo object with the higher shard count
+        return shardInfoFromPath.getShardCount() >= shardInfoFromMap.getShardCount() ? shardInfoFromPath : shardInfoFromMap;
+    }
+
+    private DeleteResult cleanUpStaleSnapshotShardPathsFile(List<String> matchingShardPaths, Map<String, BlobMetadata> snapshotShardPaths)
+        throws IOException {
+        deleteFromContainer(snapshotShardPathBlobContainer(), matchingShardPaths);
+        long totalBytes = matchingShardPaths.stream().mapToLong(s -> snapshotShardPaths.get(s).length()).sum();
+        return new DeleteResult(matchingShardPaths.size(), totalBytes);
+    }
+
     @Override
     public void finalizeSnapshot(
         final ShardGenerations shardGenerations,
@@ -1757,6 +2403,29 @@ public void finalizeSnapshot(
         Version repositoryMetaVersion,
         Function<ClusterState, ClusterState> stateTransformer,
         final ActionListener<RepositoryData> listener
+    ) {
+        finalizeSnapshot(
+            shardGenerations,
+            repositoryStateId,
+            clusterMetadata,
+            snapshotInfo,
+            repositoryMetaVersion,
+            stateTransformer,
+            Priority.NORMAL,
+            listener
+        );
+    }
+
+    @Override
+    public void finalizeSnapshot(
+        final ShardGenerations shardGenerations,
+        final long repositoryStateId,
+        final Metadata clusterMetadata,
+        SnapshotInfo snapshotInfo,
+        Version repositoryMetaVersion,
+        Function<ClusterState, ClusterState> stateTransformer,
+        Priority repositoryUpdatePriority,
+        final ActionListener<RepositoryData> listener
     ) {
         assert repositoryStateId > RepositoryData.UNKNOWN_REPO_GEN : "Must finalize based on a valid repository generation but received ["
             + repositoryStateId
@@ -1799,16 +2468,22 @@ public void finalizeSnapshot(
                     indexMetas,
                     indexMetaIdentifiers
                 );
+                // The snapshot shards path would be uploaded for new index ids or index ids where the shard gen count (a.k.a
+                // number_of_shards) has increased.
+                Set<String> updatedIndexIds = writeNewIndexShardPaths(existingRepositoryData, updatedRepositoryData, snapshotId);
+                cleanupRedundantSnapshotShardPaths(updatedIndexIds);
                 writeIndexGen(
                     updatedRepositoryData,
                     repositoryStateId,
                     repositoryMetaVersion,
                     stateTransformer,
+                    repositoryUpdatePriority,
                     ActionListener.wrap(newRepoData -> {
                         if (writeShardGens) {
-                            cleanupOldShardGens(existingRepositoryData, updatedRepositoryData);
+                            cleanupOldShardGens(existingRepositoryData, updatedRepositoryData, newRepoData, listener);
+                        } else {
+                            listener.onResponse(newRepoData);
                         }
-                        listener.onResponse(newRepoData);
                     }, onUpdateFailure)
                 );
             }, onUpdateFailure), 2 + indices.size());
@@ -1860,23 +2535,189 @@ public void finalizeSnapshot(
         }, onUpdateFailure);
     }
 
+    /**
+     * This method cleans up the redundant snapshot shard paths file for index ids where the number of shards has increased
+     * on account of new indexes by same index name being snapshotted that exists already in the repository's snapshots.
+     */
+    private void cleanupRedundantSnapshotShardPaths(Set<String> updatedShardPathsIndexIds) {
+        Set<String> updatedIndexIds = updatedShardPathsIndexIds.stream()
+            .map(s -> s.split("\\" + SnapshotShardPaths.DELIMITER)[0])
+            .collect(Collectors.toSet());
+        Set<String> indexIdShardPaths = getSnapshotShardPaths().keySet();
+        List<String> staleShardPaths = indexIdShardPaths.stream().filter(s -> updatedShardPathsIndexIds.contains(s) == false).filter(s -> {
+            String indexId = s.split("\\" + SnapshotShardPaths.DELIMITER)[0];
+            return updatedIndexIds.contains(indexId);
+        }).collect(Collectors.toList());
+        try {
+            deleteFromContainer(snapshotShardPathBlobContainer(), staleShardPaths);
+        } catch (IOException e) {
+            logger.warn(
+                new ParameterizedMessage(
+                    "Repository [{}] Exception during snapshot stale index deletion {}",
+                    metadata.name(),
+                    staleShardPaths
+                ),
+                e
+            );
+        }
+    }
+
+    private Set<String> writeNewIndexShardPaths(
+        RepositoryData existingRepositoryData,
+        RepositoryData updatedRepositoryData,
+        SnapshotId snapshotId
+    ) {
+        Set<String> updatedIndexIds = new HashSet<>();
+        Set<IndexId> indicesToUpdate = new HashSet<>(updatedRepositoryData.getIndices().values());
+        for (IndexId indexId : indicesToUpdate) {
+            if (indexId.getShardPathType() == PathType.FIXED.getCode()) {
+                continue;
+            }
+            int oldShardCount = existingRepositoryData.shardGenerations().getGens(indexId).size();
+            int newShardCount = updatedRepositoryData.shardGenerations().getGens(indexId).size();
+            if (newShardCount > oldShardCount) {
+                String shardPathsBlobName = writeIndexShardPaths(indexId, snapshotId, newShardCount);
+                if (Objects.nonNull(shardPathsBlobName)) {
+                    updatedIndexIds.add(shardPathsBlobName);
+                }
+            }
+        }
+        return updatedIndexIds;
+    }
+
+    String writeIndexShardPaths(IndexId indexId, SnapshotId snapshotId, int shardCount) {
+        try {
+            List<String> paths = getShardPaths(indexId, shardCount);
+            int pathType = indexId.getShardPathType();
+            int pathHashAlgorithm = FNV_1A_COMPOSITE_1.getCode();
+            String blobName = String.join(
+                SnapshotShardPaths.DELIMITER,
+                indexId.getId(),
+                indexId.getName(),
+                String.valueOf(shardCount),
+                String.valueOf(pathType),
+                String.valueOf(pathHashAlgorithm)
+            );
+            SnapshotShardPaths shardPaths = new SnapshotShardPaths(
+                paths,
+                indexId.getId(),
+                indexId.getName(),
+                shardCount,
+                PathType.fromCode(pathType),
+                PathHashAlgorithm.fromCode(pathHashAlgorithm)
+            );
+            SNAPSHOT_SHARD_PATHS_FORMAT.write(shardPaths, snapshotShardPathBlobContainer(), blobName);
+            logShardPathsOperationSuccess(indexId, snapshotId);
+            return blobName;
+        } catch (IOException e) {
+            logShardPathsOperationWarning(indexId, snapshotId, e);
+        }
+        return null;
+    }
+
+    private List<String> getShardPaths(IndexId indexId, int shardCount) {
+        List<String> paths = new ArrayList<>();
+        for (int shardId = 0; shardId < shardCount; shardId++) {
+            BlobPath shardPath = shardPath(indexId, shardId);
+            paths.add(shardPath.buildAsString());
+        }
+        return paths;
+    }
+
+    private void logShardPathsOperationSuccess(IndexId indexId, SnapshotId snapshotId) {
+        logger.trace(
+            () -> new ParameterizedMessage(
+                "Repository [{}] successfully wrote shard paths for index [{}] in snapshot [{}]",
+                metadata.name(),
+                indexId.getName(),
+                snapshotId.getName()
+            )
+        );
+    }
+
+    private void logShardPathsOperationWarning(IndexId indexId, SnapshotId snapshotId, @Nullable Exception e) {
+        logger.warn(
+            () -> new ParameterizedMessage(
+                "Repository [{}] Failed to write shard paths for index [{}] in snapshot [{}]",
+                metadata.name(),
+                indexId.getName(),
+                snapshotId.getName()
+            ),
+            e
+        );
+    }
+
     // Delete all old shard gen blobs that aren't referenced any longer as a result from moving to updated repository data
-    private void cleanupOldShardGens(RepositoryData existingRepositoryData, RepositoryData updatedRepositoryData) {
+    private void cleanupOldShardGens(
+        RepositoryData existingRepositoryData,
+        RepositoryData updatedRepositoryData,
+        RepositoryData newRepositoryData,
+        ActionListener<RepositoryData> listener
+    ) {
         final List<String> toDelete = new ArrayList<>();
-        final int prefixPathLen = basePath().buildAsString().length();
         updatedRepositoryData.shardGenerations()
             .obsoleteShardGenerations(existingRepositoryData.shardGenerations())
             .forEach(
                 (indexId, gens) -> gens.forEach(
-                    (shardId, oldGen) -> toDelete.add(
-                        shardContainer(indexId, shardId).path().buildAsString().substring(prefixPathLen) + INDEX_FILE_PREFIX + oldGen
-                    )
+                    (shardId, oldGen) -> toDelete.add(shardPath(indexId, shardId).buildAsString() + INDEX_FILE_PREFIX + oldGen)
                 )
             );
+        if (toDelete.isEmpty()) {
+            listener.onResponse(newRepositoryData);
+            return;
+        }
         try {
-            deleteFromContainer(blobContainer(), toDelete);
+            AtomicInteger counter = new AtomicInteger();
+            Collection<List<String>> subList = toDelete.stream()
+                .collect(Collectors.groupingBy(it -> counter.getAndIncrement() / maxShardBlobDeleteBatch))
+                .values();
+            final BlockingQueue<List<String>> staleFilesToDeleteInBatch = new LinkedBlockingQueue<>(subList);
+            logger.info(
+                "[{}] cleanupOldShardGens toDeleteSize={} groupSize={}",
+                metadata.name(),
+                toDelete.size(),
+                staleFilesToDeleteInBatch.size()
+            );
+            final GroupedActionListener<Void> groupedListener = new GroupedActionListener<>(ActionListener.wrap(r -> {
+                logger.info("[{}] completed cleanupOldShardGens", metadata.name());
+                listener.onResponse(newRepositoryData);
+            }, ex -> {
+                logger.error(new ParameterizedMessage("[{}] exception in cleanupOldShardGens", metadata.name()), ex);
+                listener.onResponse(newRepositoryData);
+            }), staleFilesToDeleteInBatch.size());
+
+            // Start as many workers as fit into the snapshot pool at once at the most
+            final int workers = Math.min(threadPool.info(ThreadPool.Names.SNAPSHOT_DELETION).getMax(), staleFilesToDeleteInBatch.size());
+            for (int i = 0; i < workers; ++i) {
+                executeOldShardGensCleanup(staleFilesToDeleteInBatch, groupedListener);
+            }
         } catch (Exception e) {
-            logger.warn("Failed to clean up old shard generation blobs", e);
+            logger.warn(new ParameterizedMessage(" [{}] Failed to clean up old shard generation blobs", metadata.name()), e);
+            listener.onResponse(newRepositoryData);
+        }
+    }
+
+    private void executeOldShardGensCleanup(BlockingQueue<List<String>> staleFilesToDeleteInBatch, GroupedActionListener<Void> listener)
+        throws InterruptedException {
+        List<String> filesToDelete = staleFilesToDeleteInBatch.poll(0L, TimeUnit.MILLISECONDS);
+        if (filesToDelete != null) {
+            threadPool.executor(ThreadPool.Names.SNAPSHOT_DELETION).execute(ActionRunnable.wrap(listener, l -> {
+                try {
+                    deleteFromContainer(rootBlobContainer(), filesToDelete);
+                    l.onResponse(null);
+                } catch (Exception e) {
+                    logger.warn(
+                        () -> new ParameterizedMessage(
+                            "[{}] Failed to delete following blobs during cleanupOldFiles : {}",
+                            metadata.name(),
+                            filesToDelete
+                        ),
+                        e
+                    );
+                    l.onFailure(e);
+                }
+                executeOldShardGensCleanup(staleFilesToDeleteInBatch, listener);
+            }));
         }
     }
 
@@ -1921,11 +2762,15 @@ private void deleteFromContainer(BlobContainer container, List<String> blobs) th
     }
 
     private BlobPath indicesPath() {
-        return basePath().add("indices");
+        return basePath().add(INDICES_DIR);
     }
 
     private BlobContainer indexContainer(IndexId indexId) {
-        return blobStore().blobContainer(indicesPath().add(indexId.getId()));
+        return blobStore().blobContainer(indexPath(indexId));
+    }
+
+    private BlobPath indexPath(IndexId indexId) {
+        return indicesPath().add(indexId.getId());
     }
 
     private BlobContainer shardContainer(IndexId indexId, ShardId shardId) {
@@ -1933,7 +2778,17 @@ private BlobContainer shardContainer(IndexId indexId, ShardId shardId) {
     }
 
     public BlobContainer shardContainer(IndexId indexId, int shardId) {
-        return blobStore().blobContainer(indicesPath().add(indexId.getId()).add(Integer.toString(shardId)));
+        return blobStore().blobContainer(shardPath(indexId, shardId));
+    }
+
+    private BlobPath shardPath(IndexId indexId, int shardId) {
+        PathType pathType = PathType.fromCode(indexId.getShardPathType());
+        SnapshotShardPathInput shardPathInput = new SnapshotShardPathInput.Builder().basePath(basePath())
+            .indexUUID(indexId.getId())
+            .shardId(String.valueOf(shardId))
+            .build();
+        PathHashAlgorithm pathHashAlgorithm = pathType != PathType.FIXED ? FNV_1A_COMPOSITE_1 : null;
+        return pathType.path(shardPathInput, pathHashAlgorithm);
     }
 
     /**
@@ -1968,16 +2823,22 @@ public long getRemoteUploadThrottleTimeInNanos() {
         return remoteUploadRateLimitingTimeInNanos.count();
     }
 
+    @Override
+    public long getLowPriorityRemoteUploadThrottleTimeInNanos() {
+        return remoteUploadLowPriorityRateLimitingTimeInNanos.count();
+    }
+
     @Override
     public long getRemoteDownloadThrottleTimeInNanos() {
         return remoteDownloadRateLimitingTimeInNanos.count();
     }
 
     protected void assertSnapshotOrGenericThread() {
-        assert Thread.currentThread().getName().contains('[' + ThreadPool.Names.SNAPSHOT + ']')
+        assert Thread.currentThread().getName().contains('[' + ThreadPool.Names.SNAPSHOT_DELETION + ']')
+            || Thread.currentThread().getName().contains('[' + ThreadPool.Names.SNAPSHOT + ']')
             || Thread.currentThread().getName().contains('[' + ThreadPool.Names.GENERIC + ']') : "Expected current thread ["
                 + Thread.currentThread()
-                + "] to be the snapshot or generic thread.";
+                + "] to be the snapshot_deletion or snapshot or generic thread.";
     }
 
     @Override
@@ -1990,7 +2851,7 @@ public String startVerification() {
             } else {
                 String seed = UUIDs.randomBase64UUID();
                 byte[] testBytes = Strings.toUTF8Bytes(seed);
-                BlobContainer testContainer = blobStore().blobContainer(basePath().add(testBlobPrefix(seed)));
+                BlobContainer testContainer = testContainer(seed);
                 BytesArray bytes = new BytesArray(testBytes);
                 if (isSystemRepository == false) {
                     try (InputStream stream = bytes.streamInput()) {
@@ -2008,12 +2869,26 @@ public String startVerification() {
         }
     }
 
+    /**
+     * Returns the blobContainer depending on the seed and {@code prefixModeVerification}.
+     */
+    private BlobContainer testContainer(String seed) {
+        BlobPath testBlobPath;
+        if (prefixModeVerification == true) {
+            BasePathInput pathInput = BasePathInput.builder().basePath(basePath()).indexUUID(seed).build();
+            testBlobPath = PathType.HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
+        } else {
+            testBlobPath = basePath();
+        }
+        assert Objects.nonNull(testBlobPath);
+        return blobStore().blobContainer(testBlobPath.add(testBlobPrefix(seed)));
+    }
+
     @Override
     public void endVerification(String seed) {
         if (isReadOnly() == false) {
             try {
-                final String testPrefix = testBlobPrefix(seed);
-                blobStore().blobContainer(basePath().add(testPrefix)).delete();
+                testContainer(seed).delete();
             } catch (Exception exp) {
                 throw new RepositoryVerificationException(metadata.name(), "cannot delete test data at " + basePath(), exp);
             }
@@ -2089,11 +2964,12 @@ private void doGetRepositoryData(ActionListener<RepositoryData> listener) {
                     loaded = repositoryDataFromCachedEntry(cached);
                 } else {
                     loaded = getRepositoryData(genToLoad);
+                    Version minNodeVersion = clusterService.state().nodes().getMinNodeVersion();
                     // We can cache serialized in the most recent version here without regard to the actual repository metadata version
                     // since we're only caching the information that we just wrote and thus won't accidentally cache any information that
                     // isn't safe
                     cacheRepositoryData(
-                        BytesReference.bytes(loaded.snapshotsToXContent(XContentFactory.jsonBuilder(), Version.CURRENT)),
+                        BytesReference.bytes(loaded.snapshotsToXContent(XContentFactory.jsonBuilder(), Version.CURRENT, minNodeVersion)),
                         genToLoad
                     );
                 }
@@ -2318,10 +3194,11 @@ public boolean isSystemRepository() {
      * Lastly, the {@link RepositoryMetadata} entry for this repository is updated to the new generation {@code P + 1} and thus
      * pending and safe generation are set to the same value marking the end of the update of the repository data.
      *
-     * @param repositoryData RepositoryData to write
-     * @param expectedGen    expected repository generation at the start of the operation
-     * @param version        version of the repository metadata to write
-     * @param stateFilter    filter for the last cluster state update executed by this method
+     * @param repositoryData            RepositoryData to write
+     * @param expectedGen               expected repository generation at the start of the operation
+     * @param version                   version of the repository metadata to write
+     * @param stateFilter               filter for the last cluster state update executed by this method
+     * @param repositoryUpdatePriority  priority for the cluster state update task
      * @param listener       completion listener
      */
     protected void writeIndexGen(
@@ -2329,6 +3206,7 @@ protected void writeIndexGen(
         long expectedGen,
         Version version,
         Function<ClusterState, ClusterState> stateFilter,
+        Priority repositoryUpdatePriority,
         ActionListener<RepositoryData> listener
     ) {
         assert isReadOnly() == false; // can not write to a read only repository
@@ -2353,7 +3231,7 @@ protected void writeIndexGen(
         final StepListener<Long> setPendingStep = new StepListener<>();
         clusterService.submitStateUpdateTask(
             "set pending repository generation [" + metadata.name() + "][" + expectedGen + "]",
-            new ClusterStateUpdateTask() {
+            new ClusterStateUpdateTask(repositoryUpdatePriority) {
 
                 private long newGen;
 
@@ -2482,8 +3360,9 @@ public void onFailure(Exception e) {
             }
             final String indexBlob = INDEX_FILE_PREFIX + Long.toString(newGen);
             logger.debug("Repository [{}] writing new index generational blob [{}]", metadata.name(), indexBlob);
+            Version minNodeVersion = clusterService.state().nodes().getMinNodeVersion();
             final BytesReference serializedRepoData = BytesReference.bytes(
-                newRepositoryData.snapshotsToXContent(XContentFactory.jsonBuilder(), version)
+                newRepositoryData.snapshotsToXContent(XContentFactory.jsonBuilder(), version, minNodeVersion)
             );
             writeAtomic(blobContainer(), indexBlob, serializedRepoData, true);
             maybeWriteIndexLatest(newGen);
@@ -2491,7 +3370,7 @@ public void onFailure(Exception e) {
             // Step 3: Update CS to reflect new repository generation.
             clusterService.submitStateUpdateTask(
                 "set safe repository generation [" + metadata.name() + "][" + newGen + "]",
-                new ClusterStateUpdateTask() {
+                new ClusterStateUpdateTask(repositoryUpdatePriority) {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         final RepositoryMetadata meta = getRepoMetadata(currentState);
@@ -2751,7 +3630,7 @@ public void snapshotRemoteStoreIndexShard(
         final ShardId shardId = store.shardId();
         try {
             final String generation = snapshotStatus.generation();
-            logger.info("[{}] [{}] snapshot to [{}] [{}] ...", shardId, snapshotId, metadata.name(), generation);
+            logger.info("[{}] [{}] shallow copy snapshot to [{}] [{}] ...", shardId, snapshotId, metadata.name(), generation);
             final BlobContainer shardContainer = shardContainer(indexId, shardId);
 
             long indexTotalFileSize = 0;
@@ -2874,9 +3753,12 @@ public void snapshotShard(
             long indexIncrementalSize = 0;
             long indexTotalFileSize = 0;
             final BlockingQueue<BlobStoreIndexShardSnapshot.FileInfo> filesToSnapshot = new LinkedBlockingQueue<>();
-            // If we did not find a set of files that is equal to the current commit we determine the files to upload by comparing files
-            // in the commit with files already in the repository
-            if (filesFromSegmentInfos == null) {
+            if (store.indexSettings().isRemoteSnapshot()) {
+                // If the source of the data is another remote snapshot (i.e. searchable snapshot) then no need to snapshot the shard
+                indexCommitPointFiles = List.of();
+            } else if (filesFromSegmentInfos == null) {
+                // If we did not find a set of files that is equal to the current commit we determine the files to upload by comparing files
+                // in the commit with files already in the repository
                 indexCommitPointFiles = new ArrayList<>();
                 final Collection<String> fileNames;
                 final Store.MetadataSnapshot metadataFromStore;
@@ -3315,6 +4197,20 @@ public OffsetRangeInputStream maybeRateLimitRemoteUploadTransfers(OffsetRangeInp
         );
     }
 
+    public OffsetRangeInputStream maybeRateLimitLowPriorityRemoteUploadTransfers(OffsetRangeInputStream offsetRangeInputStream) {
+        return maybeRateLimitRemoteTransfers(
+            maybeRateLimitRemoteTransfers(
+                offsetRangeInputStream,
+                () -> remoteUploadRateLimiter,
+                remoteUploadRateLimitingTimeInNanos,
+                BlobStoreTransferContext.REMOTE_UPLOAD
+            ),
+            () -> remoteUploadLowPriorityRateLimiter,
+            remoteUploadLowPriorityRateLimitingTimeInNanos,
+            BlobStoreTransferContext.REMOTE_UPLOAD
+        );
+    }
+
     public InputStream maybeRateLimitRemoteDownloadTransfers(InputStream inputStream) {
         return maybeRateLimit(
             maybeRateLimit(
@@ -3373,7 +4269,7 @@ public void verify(String seed, DiscoveryNode localNode) {
                 );
             }
         } else {
-            BlobContainer testBlobContainer = blobStore().blobContainer(basePath().add(testBlobPrefix(seed)));
+            BlobContainer testBlobContainer = testContainer(seed);
             try {
                 BytesArray bytes = new BytesArray(seed);
                 try (InputStream stream = bytes.streamInput()) {
diff --git a/server/src/main/java/org/opensearch/repositories/blobstore/ChecksumBlobStoreFormat.java b/server/src/main/java/org/opensearch/repositories/blobstore/ChecksumBlobStoreFormat.java
index e567e1b626c5a..3a49fed4be282 100644
--- a/server/src/main/java/org/opensearch/repositories/blobstore/ChecksumBlobStoreFormat.java
+++ b/server/src/main/java/org/opensearch/repositories/blobstore/ChecksumBlobStoreFormat.java
@@ -223,10 +223,11 @@ private void writeAsyncWithPriority(
             return;
         }
         final String blobName = blobName(name);
-        final BytesReference bytes = serialize(obj, blobName, compressor, params);
+        final BytesReference bytesReference = serialize(obj, blobName, compressor, params);
         final String resourceDescription = "ChecksumBlobStoreFormat.writeAsyncWithPriority(blob=\"" + blobName + "\")";
-        try (IndexInput input = new ByteArrayIndexInput(resourceDescription, BytesReference.toBytes(bytes))) {
-            long expectedChecksum;
+        byte[] bytes = BytesReference.toBytes(bytesReference);
+        long expectedChecksum;
+        try (IndexInput input = new ByteArrayIndexInput(resourceDescription, bytes)) {
             try {
                 expectedChecksum = checksumOfChecksum(input.clone(), 8);
             } catch (Exception e) {
@@ -237,21 +238,21 @@ private void writeAsyncWithPriority(
                     e
                 );
             }
+        }
 
-            try (
-                RemoteTransferContainer remoteTransferContainer = new RemoteTransferContainer(
-                    blobName,
-                    blobName,
-                    bytes.length(),
-                    true,
-                    priority,
-                    (size, position) -> new OffsetRangeIndexInputStream(input, size, position),
-                    expectedChecksum,
-                    ((AsyncMultiStreamBlobContainer) blobContainer).remoteIntegrityCheckSupported()
-                )
-            ) {
-                ((AsyncMultiStreamBlobContainer) blobContainer).asyncBlobUpload(remoteTransferContainer.createWriteContext(), listener);
-            }
+        try (
+            RemoteTransferContainer remoteTransferContainer = new RemoteTransferContainer(
+                blobName,
+                blobName,
+                bytes.length,
+                true,
+                priority,
+                (size, position) -> new OffsetRangeIndexInputStream(new ByteArrayIndexInput(resourceDescription, bytes), size, position),
+                expectedChecksum,
+                ((AsyncMultiStreamBlobContainer) blobContainer).remoteIntegrityCheckSupported()
+            )
+        ) {
+            ((AsyncMultiStreamBlobContainer) blobContainer).asyncBlobUpload(remoteTransferContainer.createWriteContext(), listener);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/repositories/blobstore/ChecksumWritableBlobStoreFormat.java b/server/src/main/java/org/opensearch/repositories/blobstore/ChecksumWritableBlobStoreFormat.java
new file mode 100644
index 0000000000000..88672995f4fd6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/repositories/blobstore/ChecksumWritableBlobStoreFormat.java
@@ -0,0 +1,113 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.repositories.blobstore;
+
+import org.apache.lucene.codecs.CodecUtil;
+import org.apache.lucene.index.CorruptIndexException;
+import org.apache.lucene.index.IndexFormatTooNewException;
+import org.apache.lucene.index.IndexFormatTooOldException;
+import org.apache.lucene.store.ByteBuffersDataInput;
+import org.apache.lucene.store.ByteBuffersIndexInput;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.OutputStreamIndexOutput;
+import org.apache.lucene.util.BytesRef;
+import org.opensearch.Version;
+import org.opensearch.common.CheckedFunction;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.lucene.store.ByteArrayIndexInput;
+import org.opensearch.common.lucene.store.IndexOutputOutputStream;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.common.io.stream.InputStreamStreamInput;
+import org.opensearch.core.common.io.stream.OutputStreamStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.common.io.stream.Writeable.Writer;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.CompressorRegistry;
+import org.opensearch.gateway.CorruptStateException;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+/**
+ * Checksum File format used to serialize/deserialize {@link Writeable} objects
+ *
+ * @opensearch.internal
+ */
+public class ChecksumWritableBlobStoreFormat<T extends Writeable> {
+
+    public static final int VERSION = 1;
+
+    private static final int BUFFER_SIZE = 4096;
+
+    private final String codec;
+    private final CheckedFunction<StreamInput, T, IOException> reader;
+
+    public ChecksumWritableBlobStoreFormat(String codec, CheckedFunction<StreamInput, T, IOException> reader) {
+        this.codec = codec;
+        this.reader = reader;
+    }
+
+    public BytesReference serialize(final T obj, final String blobName, final Compressor compressor) throws IOException {
+        return serialize((out, unSerializedObj) -> unSerializedObj.writeTo(out), obj, blobName, compressor);
+    }
+
+    public BytesReference serialize(final Writer<T> writer, T obj, final String blobName, final Compressor compressor) throws IOException {
+        try (BytesStreamOutput outputStream = new BytesStreamOutput()) {
+            try (
+                OutputStreamIndexOutput indexOutput = new OutputStreamIndexOutput(
+                    "ChecksumBlobStoreFormat.writeBlob(blob=\"" + blobName + "\")",
+                    blobName,
+                    outputStream,
+                    BUFFER_SIZE
+                )
+            ) {
+                CodecUtil.writeHeader(indexOutput, codec, VERSION);
+
+                try (OutputStream indexOutputOutputStream = new IndexOutputOutputStream(indexOutput) {
+                    @Override
+                    public void close() throws IOException {
+                        // this is important since some of the XContentBuilders write bytes on close.
+                        // in order to write the footer we need to prevent closing the actual index input.
+                    }
+                }; StreamOutput stream = new OutputStreamStreamOutput(compressor.threadLocalOutputStream(indexOutputOutputStream));) {
+                    // TODO The stream version should be configurable
+                    stream.setVersion(Version.CURRENT);
+                    writer.write(stream, obj);
+                }
+                CodecUtil.writeFooter(indexOutput);
+            }
+            return outputStream.bytes();
+        }
+    }
+
+    public T deserialize(String blobName, BytesReference bytes) throws IOException {
+        final String resourceDesc = "ChecksumBlobStoreFormat.readBlob(blob=\"" + blobName + "\")";
+        try {
+            final IndexInput indexInput = bytes.length() > 0
+                ? new ByteBuffersIndexInput(new ByteBuffersDataInput(Arrays.asList(BytesReference.toByteBuffers(bytes))), resourceDesc)
+                : new ByteArrayIndexInput(resourceDesc, BytesRef.EMPTY_BYTES);
+            CodecUtil.checksumEntireFile(indexInput);
+            CodecUtil.checkHeader(indexInput, codec, VERSION, VERSION);
+            long filePointer = indexInput.getFilePointer();
+            long contentSize = indexInput.length() - CodecUtil.footerLength() - filePointer;
+            BytesReference bytesReference = bytes.slice((int) filePointer, (int) contentSize);
+            Compressor compressor = CompressorRegistry.compressorForWritable(bytesReference);
+            try (StreamInput in = new InputStreamStreamInput(compressor.threadLocalInputStream(bytesReference.streamInput()))) {
+                return reader.apply(in);
+            }
+        } catch (CorruptIndexException | IndexFormatTooOldException | IndexFormatTooNewException ex) {
+            // we trick this into a dedicated exception with the original stacktrace
+            throw new CorruptStateException(ex);
+        }
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/repositories/blobstore/ConfigBlobStoreFormat.java b/server/src/main/java/org/opensearch/repositories/blobstore/ConfigBlobStoreFormat.java
index 18c718ca2110e..630048c61785d 100644
--- a/server/src/main/java/org/opensearch/repositories/blobstore/ConfigBlobStoreFormat.java
+++ b/server/src/main/java/org/opensearch/repositories/blobstore/ConfigBlobStoreFormat.java
@@ -8,7 +8,6 @@
 
 package org.opensearch.repositories.blobstore;
 
-import org.apache.lucene.store.IndexInput;
 import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
 import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.common.blobstore.stream.write.WritePriority;
@@ -51,23 +50,34 @@ public void writeAsyncWithUrgentPriority(T obj, BlobContainer blobContainer, Str
             return;
         }
         String blobName = blobName(name);
-        BytesReference bytes = serialize(obj, blobName, new NoneCompressor(), ToXContent.EMPTY_PARAMS, XContentType.JSON, null, null);
+        BytesReference bytesReference = serialize(
+            obj,
+            blobName,
+            new NoneCompressor(),
+            ToXContent.EMPTY_PARAMS,
+            XContentType.JSON,
+            null,
+            null
+        );
         String resourceDescription = "BlobStoreFormat.writeAsyncWithPriority(blob=\"" + blobName + "\")";
-        try (IndexInput input = new ByteArrayIndexInput(resourceDescription, BytesReference.toBytes(bytes))) {
-            try (
-                RemoteTransferContainer remoteTransferContainer = new RemoteTransferContainer(
-                    blobName,
-                    blobName,
-                    bytes.length(),
-                    true,
-                    WritePriority.URGENT,
-                    (size, position) -> new OffsetRangeIndexInputStream(input, size, position),
-                    null,
-                    false
-                )
-            ) {
-                ((AsyncMultiStreamBlobContainer) blobContainer).asyncBlobUpload(remoteTransferContainer.createWriteContext(), listener);
-            }
+        byte[] bytes = BytesReference.toBytes(bytesReference);
+        try (
+            RemoteTransferContainer remoteTransferContainer = new RemoteTransferContainer(
+                blobName,
+                blobName,
+                bytes.length,
+                true,
+                WritePriority.URGENT,
+                (size, position) -> new OffsetRangeIndexInputStream(new ByteArrayIndexInput(resourceDescription, bytes), size, position),
+                null,
+                false
+            )
+        ) {
+            ((AsyncMultiStreamBlobContainer) blobContainer).asyncBlobUpload(remoteTransferContainer.createWriteContext(), listener);
         }
     }
+
+    public void write(T obj, BlobContainer blobContainer, String name) throws IOException {
+        write(obj, blobContainer, name, new NoneCompressor(), ToXContent.EMPTY_PARAMS, XContentType.JSON, null, null);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
index e3272dec322d3..520061e3fb159 100644
--- a/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/BaseRestHandler.java
@@ -40,6 +40,7 @@
 import org.opensearch.action.support.clustermanager.ClusterManagerNodeRequest;
 import org.opensearch.client.node.NodeClient;
 import org.opensearch.common.CheckedConsumer;
+import org.opensearch.common.annotation.ExperimentalApi;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Setting;
@@ -199,6 +200,16 @@ protected final String unrecognized(
     @PublicApi(since = "1.0.0")
     protected interface RestChannelConsumer extends CheckedConsumer<RestChannel, Exception> {}
 
+    /**
+     * Streaming REST requests are handled by preparing a streaming channel consumer that represents the execution of
+     * the request against a channel.
+     *
+     * @opensearch.experimental
+     */
+    @FunctionalInterface
+    @ExperimentalApi
+    protected interface StreamingRestChannelConsumer extends CheckedConsumer<StreamingRestChannel, Exception> {}
+
     /**
      * Prepare the request for execution. Implementations should consume all request params before
      * returning the runnable for actual execution. Unconsumed params will immediately terminate
@@ -308,6 +319,11 @@ public boolean allowsUnsafeBuffers() {
         public boolean allowSystemIndexAccessByDefault() {
             return delegate.allowSystemIndexAccessByDefault();
         }
+
+        @Override
+        public boolean supportsStreaming() {
+            return delegate.supportsStreaming();
+        }
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/rest/RestController.java b/server/src/main/java/org/opensearch/rest/RestController.java
index 95abb9b3daeca..0d6f965c7033f 100644
--- a/server/src/main/java/org/opensearch/rest/RestController.java
+++ b/server/src/main/java/org/opensearch/rest/RestController.java
@@ -54,9 +54,11 @@
 import org.opensearch.core.xcontent.MediaType;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.http.HttpChunk;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.identity.IdentityService;
 import org.opensearch.identity.Subject;
+import org.opensearch.identity.UserSubject;
 import org.opensearch.identity.tokens.AuthToken;
 import org.opensearch.identity.tokens.RestTokenExtractor;
 import org.opensearch.usage.UsageService;
@@ -71,12 +73,16 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
+import org.reactivestreams.Subscriber;
+import reactor.core.publisher.Mono;
+
 import static org.opensearch.cluster.metadata.IndexNameExpressionResolver.SYSTEM_INDEX_ACCESS_CONTROL_HEADER_KEY;
 import static org.opensearch.core.rest.RestStatus.BAD_REQUEST;
 import static org.opensearch.core.rest.RestStatus.INTERNAL_SERVER_ERROR;
@@ -257,6 +263,32 @@ public void registerHandler(final RestHandler restHandler) {
             );
     }
 
+    @Override
+    public Optional<RestHandler> dispatchHandler(String uri, String rawPath, RestRequest.Method method, Map<String, String> params) {
+        // Loop through all possible handlers, attempting to dispatch the request
+        final Iterator<RestMethodHandlers> allHandlers = getAllRestMethodHandlers(params, rawPath);
+
+        while (allHandlers.hasNext()) {
+            final RestHandler handler;
+            final RestMethodHandlers handlers = allHandlers.next();
+            if (handlers == null) {
+                handler = null;
+            } else {
+                handler = handlers.getHandler(method);
+            }
+            if (handler == null) {
+                final Set<RestRequest.Method> validMethodSet = getValidHandlerMethodSet(rawPath);
+                if (validMethodSet.contains(method) == false) {
+                    return Optional.empty();
+                }
+            } else {
+                return Optional.of(handler);
+            }
+        }
+
+        return Optional.empty();
+    }
+
     @Override
     public void dispatchRequest(RestRequest request, RestChannel channel, ThreadContext threadContext) {
         try {
@@ -294,8 +326,8 @@ public void dispatchBadRequest(final RestChannel channel, final ThreadContext th
 
     private void dispatchRequest(RestRequest request, RestChannel channel, RestHandler handler) throws Exception {
         final int contentLength = request.content().length();
+        final MediaType mediaType = request.getMediaType();
         if (contentLength > 0) {
-            final MediaType mediaType = request.getMediaType();
             if (mediaType == null) {
                 sendContentTypeErrorMessage(request.getAllHeaderValues("Content-Type"), channel);
                 return;
@@ -311,6 +343,7 @@ private void dispatchRequest(RestRequest request, RestChannel channel, RestHandl
                 return;
             }
         }
+
         RestChannel responseChannel = channel;
         try {
             if (handler.canTripCircuitBreaker()) {
@@ -318,8 +351,30 @@ private void dispatchRequest(RestRequest request, RestChannel channel, RestHandl
             } else {
                 inFlightRequestsBreaker(circuitBreakerService).addWithoutBreaking(contentLength);
             }
-            // iff we could reserve bytes for the request we need to send the response also over this channel
-            responseChannel = new ResourceHandlingHttpChannel(channel, circuitBreakerService, contentLength);
+
+            if (handler.supportsStreaming()) {
+                // The handler may support streaming but not the engine, in this case we fail with the bad request
+                if (channel instanceof StreamingRestChannel) {
+                    responseChannel = new StreamHandlingHttpChannel((StreamingRestChannel) channel, circuitBreakerService, contentLength);
+                } else {
+                    throw new IllegalStateException(
+                        "The engine does not support HTTP streaming, unable to serve uri ["
+                            + request.getHttpRequest().uri()
+                            + "] and method ["
+                            + request.getHttpRequest().method()
+                            + "]"
+                    );
+                }
+
+                if (mediaType == null) {
+                    sendContentTypeErrorMessage(request.getAllHeaderValues("Content-Type"), responseChannel);
+                    return;
+                }
+            } else {
+                // if we could reserve bytes for the request we need to send the response also over this channel
+                responseChannel = new ResourceHandlingHttpChannel(channel, circuitBreakerService, contentLength);
+            }
+
             // TODO: Count requests double in the circuit breaker if they need copying?
             if (handler.allowsUnsafeBuffers() == false) {
                 request.ensureSafeBuffers();
@@ -545,9 +600,11 @@ private boolean handleAuthenticateUser(final RestRequest request, final RestChan
                 // Authentication did not fail so return true. Authorization is handled at the action level.
                 return true;
             }
-            final Subject currentSubject = identityService.getSubject();
-            currentSubject.authenticate(token);
-            logger.debug("Logged in as user " + currentSubject);
+            final Subject currentSubject = identityService.getCurrentSubject();
+            if (currentSubject instanceof UserSubject) {
+                ((UserSubject) currentSubject).authenticate(token);
+                logger.debug("Logged in as user " + currentSubject);
+            }
         } catch (final Exception e) {
             try {
                 final BytesRestResponse bytesRestResponse = BytesRestResponse.createSimpleErrorResponse(
@@ -642,7 +699,102 @@ private void close() {
             }
             inFlightRequestsBreaker(circuitBreakerService).addWithoutBreaking(-contentLength);
         }
+    }
+
+    private static final class StreamHandlingHttpChannel implements StreamingRestChannel {
+        private final StreamingRestChannel delegate;
+        private final CircuitBreakerService circuitBreakerService;
+        private final int contentLength;
+        private final AtomicBoolean closed = new AtomicBoolean();
+        private final AtomicBoolean subscribed = new AtomicBoolean();
+
+        StreamHandlingHttpChannel(StreamingRestChannel delegate, CircuitBreakerService circuitBreakerService, int contentLength) {
+            this.delegate = delegate;
+            this.circuitBreakerService = circuitBreakerService;
+            this.contentLength = contentLength;
+        }
+
+        @Override
+        public XContentBuilder newBuilder() throws IOException {
+            return delegate.newBuilder();
+        }
+
+        @Override
+        public XContentBuilder newErrorBuilder() throws IOException {
+            return delegate.newErrorBuilder();
+        }
+
+        @Override
+        public XContentBuilder newBuilder(@Nullable MediaType mediaType, boolean useFiltering) throws IOException {
+            return delegate.newBuilder(mediaType, useFiltering);
+        }
+
+        @Override
+        public XContentBuilder newBuilder(MediaType mediaType, MediaType responseContentType, boolean useFiltering) throws IOException {
+            return delegate.newBuilder(mediaType, responseContentType, useFiltering);
+        }
+
+        @Override
+        public BytesStreamOutput bytesOutput() {
+            return delegate.bytesOutput();
+        }
+
+        @Override
+        public RestRequest request() {
+            return delegate.request();
+        }
+
+        @Override
+        public boolean detailedErrorsEnabled() {
+            return delegate.detailedErrorsEnabled();
+        }
+
+        @Override
+        public void sendResponse(RestResponse response) {
+            close();
+
+            // Check if subscribe() is already called, the headers and status are going to be sent
+            // over so we need to populate those **before** that, if possible.
+            if (subscribed.get() == false) {
+                prepareResponse(response.status(), Map.of("Content-Type", List.of(response.contentType())));
+            }
+
+            Mono.ignoreElements(this).then(Mono.just(response)).subscribe(delegate::sendResponse);
+        }
+
+        @Override
+        public void sendChunk(HttpChunk chunk) {
+            delegate.sendChunk(chunk);
+        }
+
+        @Override
+        public void prepareResponse(RestStatus status, Map<String, List<String>> headers) {
+            delegate.prepareResponse(status, headers);
+        }
+
+        @Override
+        public void subscribe(Subscriber<? super HttpChunk> subscriber) {
+            subscribed.set(true);
+            delegate.subscribe(subscriber);
+        }
+
+        private void close() {
+            // attempt to close once atomically
+            if (closed.compareAndSet(false, true) == false) {
+                throw new IllegalStateException("Channel is already closed");
+            }
+            inFlightRequestsBreaker(circuitBreakerService).addWithoutBreaking(-contentLength);
+        }
+
+        @Override
+        public boolean isReadable() {
+            return delegate.isReadable();
+        }
 
+        @Override
+        public boolean isWritable() {
+            return delegate.isWritable();
+        }
     }
 
     private static CircuitBreaker inFlightRequestsBreaker(CircuitBreakerService circuitBreakerService) {
diff --git a/server/src/main/java/org/opensearch/rest/RestHandler.java b/server/src/main/java/org/opensearch/rest/RestHandler.java
index 877afdd951088..1139e5fc65f31 100644
--- a/server/src/main/java/org/opensearch/rest/RestHandler.java
+++ b/server/src/main/java/org/opensearch/rest/RestHandler.java
@@ -72,6 +72,14 @@ default boolean supportsContentStream() {
         return false;
     }
 
+    /**
+     * Indicates if the RestHandler supports request / response streaming. Please note that the transport engine has to support
+     * streaming as well.
+     */
+    default boolean supportsStreaming() {
+        return false;
+    }
+
     /**
      * Indicates if the RestHandler supports working with pooled buffers. If the request handler will not escape the return
      * {@link RestRequest#content()} or any buffers extracted from it then there is no need to make a copies of any pooled buffers in the
diff --git a/server/src/main/java/org/opensearch/rest/StreamingRestChannel.java b/server/src/main/java/org/opensearch/rest/StreamingRestChannel.java
new file mode 100644
index 0000000000000..9460fa5a226c2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/StreamingRestChannel.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.http.HttpChunk;
+
+import java.util.List;
+import java.util.Map;
+
+import org.reactivestreams.Publisher;
+
+/**
+ * A streaming channel used to prepare response and sending the response in chunks.
+ *
+ * @opensearch.experimental
+ */
+@ExperimentalApi
+public interface StreamingRestChannel extends RestChannel, Publisher<HttpChunk> {
+    /**
+     * Sends the next {@link HttpChunk} to the response stream
+     * @param chunk response chunk
+     */
+    void sendChunk(HttpChunk chunk);
+
+    /**
+     * Prepares response before kicking of content streaming
+     * @param status response status
+     * @param headers response headers
+     */
+    void prepareResponse(RestStatus status, Map<String, List<String>> headers);
+
+    /**
+     * Returns {@code true} is this channel is ready for streaming request data, {@code false} otherwise
+     * @return {@code true} is this channel is ready for streaming request data, {@code false} otherwise
+     */
+    boolean isReadable();
+
+    /**
+     * Returns {@code true} is this channel is ready for streaming response data, {@code false} otherwise
+     * @return {@code true} is this channel is ready for streaming response data, {@code false} otherwise
+     */
+    boolean isWritable();
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/cluster/ClusterAdminTask.java b/server/src/main/java/org/opensearch/rest/action/admin/cluster/ClusterAdminTask.java
new file mode 100644
index 0000000000000..5361b05ebecc3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/admin/cluster/ClusterAdminTask.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.action.admin.cluster;
+
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.tasks.TaskId;
+import org.opensearch.tasks.CancellableTask;
+
+import java.util.Map;
+
+import static org.opensearch.search.SearchService.NO_TIMEOUT;
+
+/**
+ * Task storing information about a currently running ClusterRequest.
+ *
+ * @opensearch.api
+ */
+@PublicApi(since = "2.17.0")
+public class ClusterAdminTask extends CancellableTask {
+
+    public ClusterAdminTask(long id, String type, String action, TaskId parentTaskId, Map<String, String> headers) {
+        this(id, type, action, parentTaskId, headers, NO_TIMEOUT);
+    }
+
+    public ClusterAdminTask(
+        long id,
+        String type,
+        String action,
+        TaskId parentTaskId,
+        Map<String, String> headers,
+        TimeValue cancelAfterTimeInterval
+    ) {
+        super(id, type, action, null, parentTaskId, headers, cancelAfterTimeInterval);
+    }
+
+    @Override
+    public boolean shouldCancelChildrenOnCancellation() {
+        return true;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestClusterStatsAction.java b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestClusterStatsAction.java
index 0766e838210fa..d4426a004af8e 100644
--- a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestClusterStatsAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestClusterStatsAction.java
@@ -66,6 +66,8 @@ public String getName() {
     public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
         ClusterStatsRequest clusterStatsRequest = new ClusterStatsRequest().nodesIds(request.paramAsStringArray("nodeId", null));
         clusterStatsRequest.timeout(request.param("timeout"));
+        clusterStatsRequest.setIncludeDiscoveryNodes(false);
+        clusterStatsRequest.useAggregatedNodeLevelResponses(true);
         return channel -> client.admin().cluster().clusterStats(clusterStatsRequest, new NodesResponseRestListener<>(channel));
     }
 
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesInfoAction.java b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesInfoAction.java
index 3b83bf9d6f68c..4ac51933ea382 100644
--- a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesInfoAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesInfoAction.java
@@ -88,7 +88,7 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         final NodesInfoRequest nodesInfoRequest = prepareRequest(request);
         nodesInfoRequest.timeout(request.param("timeout"));
         settingsFilter.addFilterSettingParams(request);
-
+        nodesInfoRequest.setIncludeDiscoveryNodes(false);
         return channel -> client.admin().cluster().nodesInfo(nodesInfoRequest, new NodesResponseRestListener<>(channel));
     }
 
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesStatsAction.java b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesStatsAction.java
index 267bfde576dec..0119731e4a0d7 100644
--- a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesStatsAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestNodesStatsAction.java
@@ -232,6 +232,8 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         // If no levels are passed in this results in an empty array.
         String[] levels = Strings.splitStringByCommaToArray(request.param("level"));
         nodesStatsRequest.indices().setLevels(levels);
+        nodesStatsRequest.setIncludeDiscoveryNodes(false);
+        nodesStatsRequest.indices().setIncludeIndicesStatsByLevel(true);
 
         return channel -> client.admin().cluster().nodesStats(nodesStatsRequest, new NodesResponseRestListener<>(channel));
     }
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestSnapshotsStatusAction.java b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestSnapshotsStatusAction.java
index b2d4fff14a7f1..154ff5b0aaec1 100644
--- a/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestSnapshotsStatusAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/admin/cluster/RestSnapshotsStatusAction.java
@@ -61,6 +61,7 @@ public class RestSnapshotsStatusAction extends BaseRestHandler {
     public List<Route> routes() {
         return unmodifiableList(
             asList(
+                new Route(GET, "/_snapshot/{repository}/{snapshot}/{index}/_status"),
                 new Route(GET, "/_snapshot/{repository}/{snapshot}/_status"),
                 new Route(GET, "/_snapshot/{repository}/_status"),
                 new Route(GET, "/_snapshot/_status")
@@ -80,7 +81,8 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         if (snapshots.length == 1 && "_all".equalsIgnoreCase(snapshots[0])) {
             snapshots = Strings.EMPTY_ARRAY;
         }
-        SnapshotsStatusRequest snapshotsStatusRequest = snapshotsStatusRequest(repository).snapshots(snapshots);
+        String[] indices = request.paramAsStringArray("index", Strings.EMPTY_ARRAY);
+        SnapshotsStatusRequest snapshotsStatusRequest = snapshotsStatusRequest(repository).snapshots(snapshots).indices(indices);
         snapshotsStatusRequest.ignoreUnavailable(request.paramAsBoolean("ignore_unavailable", snapshotsStatusRequest.ignoreUnavailable()));
 
         snapshotsStatusRequest.clusterManagerNodeTimeout(
diff --git a/server/src/main/java/org/opensearch/rest/action/admin/indices/RestIndexPutAliasAction.java b/server/src/main/java/org/opensearch/rest/action/admin/indices/RestIndexPutAliasAction.java
index 9253763c53fb8..ac91b9fa17c42 100644
--- a/server/src/main/java/org/opensearch/rest/action/admin/indices/RestIndexPutAliasAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/admin/indices/RestIndexPutAliasAction.java
@@ -92,6 +92,7 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         String indexRouting = null;
         String searchRouting = null;
         Boolean writeIndex = null;
+        Boolean isHidden = null;
 
         if (request.hasContent()) {
             try (XContentParser parser = request.contentParser()) {
@@ -120,10 +121,16 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
                                     searchRouting = parser.textOrNull();
                                 } else if ("is_write_index".equals(currentFieldName)) {
                                     writeIndex = parser.booleanValue();
+                                } else if ("is_hidden".equals(currentFieldName)) {
+                                    isHidden = parser.booleanValue();
+                                } else {
+                                    throw new IllegalArgumentException("unknown field [" + currentFieldName + "]");
                                 }
                     } else if (token == XContentParser.Token.START_OBJECT) {
                         if ("filter".equals(currentFieldName)) {
                             filter = parser.mapOrdered();
+                        } else {
+                            throw new IllegalArgumentException("unknown field [" + currentFieldName + "]");
                         }
                     }
                 }
@@ -153,6 +160,9 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         if (writeIndex != null) {
             aliasAction.writeIndex(writeIndex);
         }
+        if (isHidden != null) {
+            aliasAction.isHidden(isHidden);
+        }
         indicesAliasesRequest.addAliasAction(aliasAction);
         return channel -> client.admin().indices().aliases(indicesAliasesRequest, new RestToXContentListener<>(channel));
     }
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
index 2b0042c0e6fcd..8b4f37c3d36ff 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestNodesAction.java
@@ -125,6 +125,7 @@ public RestChannelConsumer doCatRequest(final RestRequest request, final NodeCli
             public void processResponse(final ClusterStateResponse clusterStateResponse) {
                 NodesInfoRequest nodesInfoRequest = new NodesInfoRequest();
                 nodesInfoRequest.timeout(request.param("timeout"));
+                nodesInfoRequest.setIncludeDiscoveryNodes(false);
                 nodesInfoRequest.clear()
                     .addMetrics(
                         NodesInfoRequest.Metric.JVM.metricName(),
@@ -137,6 +138,7 @@ public void processResponse(final ClusterStateResponse clusterStateResponse) {
                     public void processResponse(final NodesInfoResponse nodesInfoResponse) {
                         NodesStatsRequest nodesStatsRequest = new NodesStatsRequest();
                         nodesStatsRequest.timeout(request.param("timeout"));
+                        nodesStatsRequest.setIncludeDiscoveryNodes(false);
                         nodesStatsRequest.clear()
                             .indices(true)
                             .addMetrics(
@@ -146,6 +148,7 @@ public void processResponse(final NodesInfoResponse nodesInfoResponse) {
                                 NodesStatsRequest.Metric.PROCESS.metricName(),
                                 NodesStatsRequest.Metric.SCRIPT.metricName()
                             );
+                        nodesStatsRequest.indices().setIncludeIndicesStatsByLevel(true);
                         client.admin().cluster().nodesStats(nodesStatsRequest, new RestResponseListener<NodesStatsResponse>(channel) {
                             @Override
                             public RestResponse buildResponse(NodesStatsResponse nodesStatsResponse) throws Exception {
@@ -171,9 +174,9 @@ protected Table getTableWithHeader(final RestRequest request) {
         table.addCell("port", "default:false;alias:po;desc:bound transport port");
         table.addCell("http_address", "default:false;alias:http;desc:bound http address");
 
-        table.addCell("version", "default:false;alias:v;desc:es version");
-        table.addCell("type", "default:false;alias:t;desc:es distribution type");
-        table.addCell("build", "default:false;alias:b;desc:es build hash");
+        table.addCell("version", "default:false;alias:v;desc:os version");
+        table.addCell("type", "default:false;alias:t;desc:os distribution type");
+        table.addCell("build", "default:false;alias:b;desc:os build hash");
         table.addCell("jdk", "default:false;alias:j;desc:jdk version");
         table.addCell("disk.total", "default:false;alias:dt,diskTotal;text-align:right;desc:total disk space");
         table.addCell("disk.used", "default:false;alias:du,diskUsed;text-align:right;desc:used disk space");
diff --git a/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java b/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
index 0205c610e6b1a..1bdd6f4921b7a 100644
--- a/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/cat/RestShardsAction.java
@@ -32,10 +32,11 @@
 
 package org.opensearch.rest.action.cat;
 
-import org.opensearch.action.admin.cluster.state.ClusterStateRequest;
+import org.opensearch.action.admin.cluster.shards.CatShardsAction;
+import org.opensearch.action.admin.cluster.shards.CatShardsRequest;
+import org.opensearch.action.admin.cluster.shards.CatShardsResponse;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
 import org.opensearch.action.admin.indices.stats.CommonStats;
-import org.opensearch.action.admin.indices.stats.IndicesStatsRequest;
 import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
 import org.opensearch.action.admin.indices.stats.ShardStats;
 import org.opensearch.client.node.NodeClient;
@@ -61,7 +62,6 @@
 import org.opensearch.index.warmer.WarmerStats;
 import org.opensearch.rest.RestRequest;
 import org.opensearch.rest.RestResponse;
-import org.opensearch.rest.action.RestActionListener;
 import org.opensearch.rest.action.RestResponseListener;
 import org.opensearch.search.suggest.completion.CompletionStats;
 
@@ -73,6 +73,7 @@
 import static java.util.Arrays.asList;
 import static java.util.Collections.unmodifiableList;
 import static org.opensearch.rest.RestRequest.Method.GET;
+import static org.opensearch.search.SearchService.NO_TIMEOUT;
 
 /**
  * _cat API action to get shard information
@@ -107,25 +108,18 @@ protected void documentation(StringBuilder sb) {
     @Override
     public RestChannelConsumer doCatRequest(final RestRequest request, final NodeClient client) {
         final String[] indices = Strings.splitStringByCommaToArray(request.param("index"));
-        final ClusterStateRequest clusterStateRequest = new ClusterStateRequest();
-        clusterStateRequest.local(request.paramAsBoolean("local", clusterStateRequest.local()));
-        clusterStateRequest.clusterManagerNodeTimeout(
-            request.paramAsTime("cluster_manager_timeout", clusterStateRequest.clusterManagerNodeTimeout())
-        );
-        parseDeprecatedMasterTimeoutParameter(clusterStateRequest, request);
-        clusterStateRequest.clear().nodes(true).routingTable(true).indices(indices);
-        return channel -> client.admin().cluster().state(clusterStateRequest, new RestActionListener<ClusterStateResponse>(channel) {
+        final CatShardsRequest shardsRequest = new CatShardsRequest();
+        shardsRequest.local(request.paramAsBoolean("local", shardsRequest.local()));
+        shardsRequest.clusterManagerNodeTimeout(request.paramAsTime("cluster_manager_timeout", shardsRequest.clusterManagerNodeTimeout()));
+        shardsRequest.setCancelAfterTimeInterval(request.paramAsTime("cancel_after_time_interval", NO_TIMEOUT));
+        shardsRequest.setIndices(indices);
+        parseDeprecatedMasterTimeoutParameter(shardsRequest, request);
+        return channel -> client.execute(CatShardsAction.INSTANCE, shardsRequest, new RestResponseListener<CatShardsResponse>(channel) {
             @Override
-            public void processResponse(final ClusterStateResponse clusterStateResponse) {
-                IndicesStatsRequest indicesStatsRequest = new IndicesStatsRequest();
-                indicesStatsRequest.all();
-                indicesStatsRequest.indices(indices);
-                client.admin().indices().stats(indicesStatsRequest, new RestResponseListener<IndicesStatsResponse>(channel) {
-                    @Override
-                    public RestResponse buildResponse(IndicesStatsResponse indicesStatsResponse) throws Exception {
-                        return RestTable.buildResponse(buildTable(request, clusterStateResponse, indicesStatsResponse), channel);
-                    }
-                });
+            public RestResponse buildResponse(CatShardsResponse catShardsResponse) throws Exception {
+                ClusterStateResponse clusterStateResponse = catShardsResponse.getClusterStateResponse();
+                IndicesStatsResponse indicesStatsResponse = catShardsResponse.getIndicesStatsResponse();
+                return RestTable.buildResponse(buildTable(request, clusterStateResponse, indicesStatsResponse), channel);
             }
         });
     }
@@ -321,7 +315,11 @@ Table buildTable(RestRequest request, ClusterStateResponse state, IndicesStatsRe
             if (shard.primary()) {
                 table.addCell("p");
             } else {
-                table.addCell("r");
+                if (shard.isSearchOnly()) {
+                    table.addCell("s");
+                } else {
+                    table.addCell("r");
+                }
             }
             table.addCell(shard.state());
             table.addCell(getOrNull(commonStats, CommonStats::getDocs, DocsStats::getCount));
diff --git a/server/src/main/java/org/opensearch/rest/action/document/RestBulkAction.java b/server/src/main/java/org/opensearch/rest/action/document/RestBulkAction.java
index 0bc4234c9b8b8..ce52c5620b968 100644
--- a/server/src/main/java/org/opensearch/rest/action/document/RestBulkAction.java
+++ b/server/src/main/java/org/opensearch/rest/action/document/RestBulkAction.java
@@ -38,6 +38,7 @@
 import org.opensearch.action.support.ActiveShardCount;
 import org.opensearch.client.Requests;
 import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.logging.DeprecationLogger;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.rest.BaseRestHandler;
 import org.opensearch.rest.RestRequest;
@@ -66,6 +67,8 @@
 public class RestBulkAction extends BaseRestHandler {
 
     private final boolean allowExplicitIndex;
+    private static final DeprecationLogger deprecationLogger = DeprecationLogger.getLogger(RestBulkAction.class);
+    static final String BATCH_SIZE_DEPRECATED_MESSAGE = "The batch size option in bulk API is deprecated and will be removed in 3.0.";
 
     public RestBulkAction(Settings settings) {
         this.allowExplicitIndex = MULTI_ALLOW_EXPLICIT_INDEX.get(settings);
@@ -97,7 +100,10 @@ public RestChannelConsumer prepareRequest(final RestRequest request, final NodeC
         Boolean defaultRequireAlias = request.paramAsBoolean(DocWriteRequest.REQUIRE_ALIAS, null);
         bulkRequest.timeout(request.paramAsTime("timeout", BulkShardRequest.DEFAULT_TIMEOUT));
         bulkRequest.setRefreshPolicy(request.param("refresh"));
-        bulkRequest.batchSize(request.paramAsInt("batch_size", 1));
+        if (request.hasParam("batch_size")) {
+            deprecationLogger.deprecate("batch_size_deprecation", BATCH_SIZE_DEPRECATED_MESSAGE);
+        }
+        bulkRequest.batchSize(request.paramAsInt("batch_size", Integer.MAX_VALUE));
         bulkRequest.add(
             request.requiredContent(),
             defaultIndex,
diff --git a/server/src/main/java/org/opensearch/rest/action/document/RestBulkStreamingAction.java b/server/src/main/java/org/opensearch/rest/action/document/RestBulkStreamingAction.java
new file mode 100644
index 0000000000000..2e0d1b8ead814
--- /dev/null
+++ b/server/src/main/java/org/opensearch/rest/action/document/RestBulkStreamingAction.java
@@ -0,0 +1,254 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.action.document;
+
+import com.google.protobuf.ExperimentalApi;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.DocWriteRequest;
+import org.opensearch.action.bulk.BulkItemResponse;
+import org.opensearch.action.bulk.BulkRequest;
+import org.opensearch.action.bulk.BulkResponse;
+import org.opensearch.action.bulk.BulkShardRequest;
+import org.opensearch.action.support.ActiveShardCount;
+import org.opensearch.client.Requests;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.xcontent.support.XContentHttpChunk;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.MediaType;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.http.HttpChunk;
+import org.opensearch.rest.BaseRestHandler;
+import org.opensearch.rest.BytesRestResponse;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.StreamingRestChannel;
+import org.opensearch.search.fetch.subphase.FetchSourceContext;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.unmodifiableList;
+import static org.opensearch.rest.RestRequest.Method.POST;
+import static org.opensearch.rest.RestRequest.Method.PUT;
+
+/**
+ * <pre>
+ * { "index" : { "_index" : "test", "_id" : "1" }
+ * { "type1" : { "field1" : "value1" } }
+ * { "delete" : { "_index" : "test", "_id" : "2" } }
+ * { "create" : { "_index" : "test", "_id" : "1" }
+ * { "type1" : { "field1" : "value1" } }
+ * </pre>
+ *
+ * @opensearch.api
+ */
+@ExperimentalApi
+public class RestBulkStreamingAction extends BaseRestHandler {
+    private static final BulkResponse EMPTY = new BulkResponse(new BulkItemResponse[0], 0L);
+    private final boolean allowExplicitIndex;
+
+    public RestBulkStreamingAction(Settings settings) {
+        this.allowExplicitIndex = MULTI_ALLOW_EXPLICIT_INDEX.get(settings);
+    }
+
+    @Override
+    public List<Route> routes() {
+        return unmodifiableList(
+            asList(
+                new Route(POST, "/_bulk/stream"),
+                new Route(PUT, "/_bulk/stream"),
+                new Route(POST, "/{index}/_bulk/stream"),
+                new Route(PUT, "/{index}/_bulk/stream")
+            )
+        );
+    }
+
+    @Override
+    public String getName() {
+        return "streaming_bulk_action";
+    }
+
+    @Override
+    public RestChannelConsumer prepareRequest(final RestRequest request, final NodeClient client) throws IOException {
+        final String defaultIndex = request.param("index");
+        final String defaultRouting = request.param("routing");
+        final String defaultPipeline = request.param("pipeline");
+        final String waitForActiveShards = request.param("wait_for_active_shards");
+        final Boolean defaultRequireAlias = request.paramAsBoolean(DocWriteRequest.REQUIRE_ALIAS, null);
+        final TimeValue timeout = request.paramAsTime("timeout", BulkShardRequest.DEFAULT_TIMEOUT);
+        final String refresh = request.param("refresh");
+        final TimeValue batchInterval = request.paramAsTime("batch_interval", null);
+        final int batchSize = request.paramAsInt("batch_size", 1); /* by default, batch size of 1 */
+        final boolean hasBatchSize = request.hasParam("batch_size"); /* is batch_size explicitly specified or default is used */
+
+        if (batchInterval != null && batchInterval.duration() <= 0) {
+            throw new IllegalArgumentException("The batch_interval value should be non-negative [" + batchInterval.millis() + "ms].");
+        }
+
+        if (batchSize <= 0) {
+            throw new IllegalArgumentException("The batch_size value should be non-negative [" + batchSize + "].");
+        }
+
+        final StreamingRestChannelConsumer consumer = (channel) -> {
+            final MediaType mediaType = request.getMediaType();
+
+            // We prepare (and more importantly, validate) the templated BulkRequest instance: in case the parameters
+            // are incorrect, we are going to fail the request immediately, instead of producing a possibly large amount
+            // of failed chunks.
+            FetchSourceContext defaultFetchSourceContext = FetchSourceContext.parseFromRestRequest(request);
+            BulkRequest prepareBulkRequest = Requests.bulkRequest();
+            if (waitForActiveShards != null) {
+                prepareBulkRequest.waitForActiveShards(ActiveShardCount.parseString(waitForActiveShards));
+            }
+
+            prepareBulkRequest.timeout(timeout);
+            prepareBulkRequest.setRefreshPolicy(refresh);
+
+            // Set the content type and the status code before sending the response stream over
+            channel.prepareResponse(RestStatus.OK, Map.of("Content-Type", List.of(mediaType.mediaTypeWithoutParameters())));
+
+            // TODOs:
+            // - eliminate serialization inefficiencies
+            createBufferedFlux(batchInterval, batchSize, hasBatchSize, channel).zipWith(Flux.fromStream(Stream.generate(() -> {
+                BulkRequest bulkRequest = Requests.bulkRequest();
+                bulkRequest.waitForActiveShards(prepareBulkRequest.waitForActiveShards());
+                bulkRequest.timeout(prepareBulkRequest.timeout());
+                bulkRequest.setRefreshPolicy(prepareBulkRequest.getRefreshPolicy());
+                return bulkRequest;
+            }))).map(t -> {
+                boolean isLast = false;
+                final List<HttpChunk> chunks = t.getT1();
+                final BulkRequest bulkRequest = t.getT2();
+
+                for (final HttpChunk chunk : chunks) {
+                    isLast |= chunk.isLast();
+                    try (chunk) {
+                        bulkRequest.add(
+                            chunk.content(),
+                            defaultIndex,
+                            defaultRouting,
+                            defaultFetchSourceContext,
+                            defaultPipeline,
+                            defaultRequireAlias,
+                            allowExplicitIndex,
+                            request.getMediaType()
+                        );
+                    } catch (final IOException ex) {
+                        throw new UncheckedIOException(ex);
+                    }
+                }
+
+                return Tuple.tuple(isLast, bulkRequest);
+            }).flatMap(tuple -> {
+                final CompletableFuture<BulkResponse> f = new CompletableFuture<>();
+
+                if (tuple.v2().requests().isEmpty()) {
+                    // this is the last request with no items
+                    f.complete(EMPTY);
+                } else {
+                    client.bulk(tuple.v2(), new ActionListener<BulkResponse>() {
+                        @Override
+                        public void onResponse(BulkResponse response) {
+                            f.complete(response);
+                        }
+
+                        @Override
+                        public void onFailure(Exception ex) {
+                            f.completeExceptionally(ex);
+                        }
+                    });
+
+                    if (tuple.v1() == true /* last chunk */ ) {
+                        return Flux.just(f, CompletableFuture.completedFuture(EMPTY));
+                    }
+                }
+
+                return Mono.just(f);
+            }).concatMap(f -> Mono.fromFuture(f).doOnNext(r -> {
+                try {
+                    if (r == EMPTY) {
+                        channel.sendChunk(XContentHttpChunk.last());
+                    } else {
+                        try (XContentBuilder builder = channel.newBuilder(mediaType, true)) {
+                            channel.sendChunk(XContentHttpChunk.from(r.toXContent(builder, ToXContent.EMPTY_PARAMS)));
+                        }
+                    }
+                } catch (IOException ex) {
+                    throw new UncheckedIOException(ex);
+                }
+            })).onErrorComplete(ex -> {
+                if (ex instanceof Error) {
+                    return false;
+                }
+                try {
+                    channel.sendResponse(new BytesRestResponse(channel, (Exception) ex));
+                    return true;
+                } catch (final IOException e) {
+                    throw new UncheckedIOException(e);
+                }
+            }).subscribe();
+        };
+
+        return channel -> {
+            if (channel instanceof StreamingRestChannel) {
+                consumer.accept((StreamingRestChannel) channel);
+            } else {
+                final ActionRequestValidationException validationError = new ActionRequestValidationException();
+                validationError.addValidationError("Unable to initiate request / response streaming over non-streaming channel");
+                channel.sendResponse(new BytesRestResponse(channel, validationError));
+            }
+        };
+    }
+
+    @Override
+    public boolean supportsContentStream() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsStreaming() {
+        return true;
+    }
+
+    @Override
+    public boolean allowsUnsafeBuffers() {
+        return true;
+    }
+
+    private Flux<List<HttpChunk>> createBufferedFlux(
+        final TimeValue batchInterval,
+        final int batchSize,
+        final boolean hasBatchSize,
+        StreamingRestChannel channel
+    ) {
+        if (batchInterval != null) {
+            // If non-default batch size is specified, buffer by interval and batch
+            if (hasBatchSize) {
+                return Flux.from(channel).bufferTimeout(batchSize, Duration.ofMillis(batchInterval.millis()));
+            } else {
+                return Flux.from(channel).buffer(Duration.ofMillis(batchInterval.millis()));
+            }
+        } else {
+            return Flux.from(channel).buffer(batchSize);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/script/DerivedFieldScript.java b/server/src/main/java/org/opensearch/script/DerivedFieldScript.java
index 0a2b7cf691283..5329e8e6a1f30 100644
--- a/server/src/main/java/org/opensearch/script/DerivedFieldScript.java
+++ b/server/src/main/java/org/opensearch/script/DerivedFieldScript.java
@@ -124,8 +124,10 @@ private int getObjectByteSize(Object obj) {
         } else if (obj instanceof Tuple) {
             // Assuming each element in the tuple is a double for GeoPoint case
             return Double.BYTES * 2;
+        } else if (obj == null) {
+            return 0;
         } else {
-            throw new IllegalArgumentException("Unsupported object type passed in emit()");
+            throw new IllegalArgumentException("Unsupported object type passed in emit() - " + obj);
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/script/Script.java b/server/src/main/java/org/opensearch/script/Script.java
index 9e74314c281cd..f18bd992cb00d 100644
--- a/server/src/main/java/org/opensearch/script/Script.java
+++ b/server/src/main/java/org/opensearch/script/Script.java
@@ -589,7 +589,7 @@ public Script(StreamInput in) throws IOException {
         @SuppressWarnings("unchecked")
         Map<String, String> options = (Map<String, String>) (Map) in.readMap();
         this.options = options;
-        this.params = in.readMap();
+        this.params = Collections.unmodifiableMap(in.readMap());
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/script/UpdateScript.java b/server/src/main/java/org/opensearch/script/UpdateScript.java
index 86697e9ae550e..f6355fe24817b 100644
--- a/server/src/main/java/org/opensearch/script/UpdateScript.java
+++ b/server/src/main/java/org/opensearch/script/UpdateScript.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.script;
 
+import java.util.Collections;
 import java.util.Map;
 
 /**
@@ -53,7 +54,7 @@ public abstract class UpdateScript {
     private final Map<String, Object> ctx;
 
     public UpdateScript(Map<String, Object> params, Map<String, Object> ctx) {
-        this.params = params;
+        this.params = Collections.unmodifiableMap(params);
         this.ctx = ctx;
     }
 
diff --git a/server/src/main/java/org/opensearch/search/DefaultSearchContext.java b/server/src/main/java/org/opensearch/search/DefaultSearchContext.java
index 518bf0704d021..4576921b8426e 100644
--- a/server/src/main/java/org/opensearch/search/DefaultSearchContext.java
+++ b/server/src/main/java/org/opensearch/search/DefaultSearchContext.java
@@ -32,6 +32,8 @@
 
 package org.opensearch.search;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.apache.lucene.search.BooleanClause.Occur;
 import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.BoostQuery;
@@ -70,6 +72,9 @@
 import org.opensearch.search.aggregations.SearchContextAggregations;
 import org.opensearch.search.builder.SearchSourceBuilder;
 import org.opensearch.search.collapse.CollapseContext;
+import org.opensearch.search.deciders.ConcurrentSearchDecider;
+import org.opensearch.search.deciders.ConcurrentSearchDecision;
+import org.opensearch.search.deciders.ConcurrentSearchVisitor;
 import org.opensearch.search.dfs.DfsSearchResult;
 import org.opensearch.search.fetch.FetchPhase;
 import org.opensearch.search.fetch.FetchSearchResult;
@@ -98,15 +103,23 @@
 import java.io.IOException;
 import java.io.UncheckedIOException;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.Executor;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
+import java.util.stream.Collectors;
 
+import static org.opensearch.search.SearchService.CARDINALITY_AGGREGATION_PRUNING_THRESHOLD;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
 import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
 import static org.opensearch.search.SearchService.MAX_AGGREGATION_REWRITE_FILTERS;
 
 /**
@@ -116,11 +129,14 @@
  */
 final class DefaultSearchContext extends SearchContext {
 
+    private static final Logger logger = LogManager.getLogger(DefaultSearchContext.class);
+
     private final ReaderContext readerContext;
     private final Engine.Searcher engineSearcher;
     private final ShardSearchRequest request;
     private final SearchShardTarget shardTarget;
     private final LongSupplier relativeTimeSupplier;
+    private final Collection<ConcurrentSearchDecider> concurrentSearchDeciders;
     private SearchType searchType;
     private final BigArrays bigArrays;
     private final IndexShard indexShard;
@@ -186,9 +202,10 @@ final class DefaultSearchContext extends SearchContext {
     private final QueryShardContext queryShardContext;
     private final FetchPhase fetchPhase;
     private final Function<SearchSourceBuilder, InternalAggregation.ReduceContextBuilder> requestToAggReduceContextBuilder;
-    private final boolean concurrentSearchSettingsEnabled;
+    private final String concurrentSearchMode;
     private final SetOnce<Boolean> requestShouldUseConcurrentSearch = new SetOnce<>();
     private final int maxAggRewriteFilters;
+    private final int cardinalityAggregationPruningThreshold;
 
     DefaultSearchContext(
         ReaderContext readerContext,
@@ -203,7 +220,8 @@ final class DefaultSearchContext extends SearchContext {
         Version minNodeVersion,
         boolean validate,
         Executor executor,
-        Function<SearchSourceBuilder, InternalAggregation.ReduceContextBuilder> requestToAggReduceContextBuilder
+        Function<SearchSourceBuilder, InternalAggregation.ReduceContextBuilder> requestToAggReduceContextBuilder,
+        Collection<ConcurrentSearchDecider> concurrentSearchDeciders
     ) throws IOException {
         this.readerContext = readerContext;
         this.request = request;
@@ -219,14 +237,15 @@ final class DefaultSearchContext extends SearchContext {
         this.indexShard = readerContext.indexShard();
         this.clusterService = clusterService;
         this.engineSearcher = readerContext.acquireSearcher("search");
-        this.concurrentSearchSettingsEnabled = evaluateConcurrentSegmentSearchSettings(executor);
+        this.concurrentSearchMode = evaluateConcurrentSearchMode(executor);
         this.searcher = new ContextIndexSearcher(
             engineSearcher.getIndexReader(),
             engineSearcher.getSimilarity(),
             engineSearcher.getQueryCache(),
             engineSearcher.getQueryCachingPolicy(),
             lowLevelCancellation,
-            concurrentSearchSettingsEnabled ? executor : null,
+            concurrentSearchMode.equals(CONCURRENT_SEGMENT_SEARCH_MODE_AUTO)
+                || concurrentSearchMode.equals(CONCURRENT_SEGMENT_SEARCH_MODE_ALL) ? executor : null,
             this
         );
         this.relativeTimeSupplier = relativeTimeSupplier;
@@ -244,6 +263,8 @@ final class DefaultSearchContext extends SearchContext {
         this.requestToAggReduceContextBuilder = requestToAggReduceContextBuilder;
 
         this.maxAggRewriteFilters = evaluateFilterRewriteSetting();
+        this.cardinalityAggregationPruningThreshold = evaluateCardinalityAggregationPruningThreshold();
+        this.concurrentSearchDeciders = concurrentSearchDeciders;
     }
 
     @Override
@@ -899,11 +920,68 @@ public Profilers getProfilers() {
     @Override
     public boolean shouldUseConcurrentSearch() {
         assert requestShouldUseConcurrentSearch.get() != null : "requestShouldUseConcurrentSearch must be set";
-        return concurrentSearchSettingsEnabled && Boolean.TRUE.equals(requestShouldUseConcurrentSearch.get());
+        assert concurrentSearchMode != null : "concurrentSearchMode must be set";
+        return (concurrentSearchMode.equals(CONCURRENT_SEGMENT_SEARCH_MODE_AUTO)
+            || concurrentSearchMode.equals(CONCURRENT_SEGMENT_SEARCH_MODE_ALL))
+            && Boolean.TRUE.equals(requestShouldUseConcurrentSearch.get());
+    }
+
+    private boolean evaluateAutoMode() {
+
+        // filter out deciders that want to opt-out of decision-making
+        final Set<ConcurrentSearchDecider> filteredDeciders = concurrentSearchDeciders.stream()
+            .filter(concurrentSearchDecider -> concurrentSearchDecider.canEvaluateForIndex(indexService.getIndexSettings()))
+            .collect(Collectors.toSet());
+        // evaluate based on concurrent search query visitor
+        if (filteredDeciders.size() > 0) {
+            ConcurrentSearchVisitor concurrentSearchVisitor = new ConcurrentSearchVisitor(
+                filteredDeciders,
+                indexService.getIndexSettings()
+            );
+            if (request().source() != null && request().source().query() != null) {
+                QueryBuilder queryBuilder = request().source().query();
+                queryBuilder.visit(concurrentSearchVisitor);
+            }
+        }
+
+        final List<ConcurrentSearchDecision> decisions = new ArrayList<>();
+        for (ConcurrentSearchDecider decider : filteredDeciders) {
+            ConcurrentSearchDecision decision = decider.getConcurrentSearchDecision();
+            if (decision != null) {
+                if (logger.isDebugEnabled()) {
+                    logger.debug("concurrent search decision from plugin decider [{}]", decision.toString());
+                }
+                decisions.add(decision);
+            }
+        }
+
+        final ConcurrentSearchDecision pluginDecision = ConcurrentSearchDecision.getCompositeDecision(decisions);
+        if (pluginDecision.getDecisionStatus().equals(ConcurrentSearchDecision.DecisionStatus.NO_OP)) {
+            // plugins don't have preference, decide based on whether request has aggregations or not.
+            if (aggregations() != null) {
+                if (logger.isDebugEnabled()) {
+                    logger.debug("request has supported aggregations, using concurrent search");
+                }
+                return true;
+
+            } else {
+                if (logger.isDebugEnabled()) {
+                    logger.debug("request does not have aggregations, not using concurrent search");
+                }
+                return false;
+            }
+
+        } else {
+            if (logger.isDebugEnabled()) {
+                logger.debug("concurrent search decision from plugins [{}]", pluginDecision.toString());
+            }
+            return pluginDecision.getDecisionStatus() == ConcurrentSearchDecision.DecisionStatus.YES;
+        }
+
     }
 
     /**
-     * Evaluate if parsed request supports concurrent segment search
+     * Evaluate if request should use concurrent search based on request and concurrent search deciders
      */
     public void evaluateRequestShouldUseConcurrentSearch() {
         if (sort != null && sort.isSortOnTimeSeriesField()) {
@@ -914,6 +992,8 @@ && aggregations().factories() != null
                 requestShouldUseConcurrentSearch.set(false);
             } else if (terminateAfter != DEFAULT_TERMINATE_AFTER) {
                 requestShouldUseConcurrentSearch.set(false);
+            } else if (concurrentSearchMode.equals(CONCURRENT_SEGMENT_SEARCH_MODE_AUTO)) {
+                requestShouldUseConcurrentSearch.set(evaluateAutoMode());
             } else {
                 requestShouldUseConcurrentSearch.set(true);
             }
@@ -961,26 +1041,40 @@ public BucketCollectorProcessor bucketCollectorProcessor() {
     }
 
     /**
-     * Evaluate based on cluster and index settings if concurrent segment search should be used for this request context
-     * @return true: use concurrent search
-     *         false: otherwise
+     * Evaluate the concurrentSearchMode based on cluster and index settings if concurrent segment search
+     * should be used for this request context
+     * If the cluster.search.concurrent_segment_search.mode setting
+     * is not explicitly set, the evaluation falls back to the
+     * cluster.search.concurrent_segment_search.enabled boolean setting
+     * which will evaluate to true or false. This is then evaluated to "all" or "none" respectively
+     * @return one of "none", "auto", "all"
      */
-    private boolean evaluateConcurrentSegmentSearchSettings(Executor concurrentSearchExecutor) {
+    private String evaluateConcurrentSearchMode(Executor concurrentSearchExecutor) {
         // Do not use concurrent segment search for system indices or throttled requests. See:
         // https://github.com/opensearch-project/OpenSearch/issues/12951
         if (indexShard.isSystem() || indexShard.indexSettings().isSearchThrottled()) {
-            return false;
+            return CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
         }
+        if ((clusterService != null) && concurrentSearchExecutor != null) {
+            String concurrentSearchMode = indexService.getIndexSettings()
+                .getSettings()
+                .get(
+                    IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(),
+                    clusterService.getClusterSettings().getOrNull(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE)
+                );
+            if (concurrentSearchMode != null) {
+                return concurrentSearchMode;
+            }
 
-        if ((clusterService != null) && (concurrentSearchExecutor != null)) {
+            // mode setting not set, fallback to concurrent_segment_search.enabled setting
             return indexService.getIndexSettings()
                 .getSettings()
                 .getAsBoolean(
                     IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(),
                     clusterService.getClusterSettings().get(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING)
-                );
+                ) ? CONCURRENT_SEGMENT_SEARCH_MODE_ALL : CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
         }
-        return false;
+        return CONCURRENT_SEGMENT_SEARCH_MODE_NONE;
     }
 
     @Override
@@ -996,7 +1090,14 @@ public int getTargetMaxSliceCount() {
         if (shouldUseConcurrentSearch() == false) {
             throw new IllegalStateException("Target slice count should not be used when concurrent search is disabled");
         }
-        return clusterService.getClusterSettings().get(SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING);
+
+        return indexService.getIndexSettings()
+            .getSettings()
+            .getAsInt(
+                IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MAX_SLICE_COUNT.getKey(),
+                clusterService.getClusterSettings().get(SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING)
+            );
+
     }
 
     @Override
@@ -1010,4 +1111,16 @@ private int evaluateFilterRewriteSetting() {
         }
         return 0;
     }
+
+    @Override
+    public int cardinalityAggregationPruningThreshold() {
+        return cardinalityAggregationPruningThreshold;
+    }
+
+    private int evaluateCardinalityAggregationPruningThreshold() {
+        if (clusterService != null) {
+            return clusterService.getClusterSettings().get(CARDINALITY_AGGREGATION_PRUNING_THRESHOLD);
+        }
+        return 0;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/search/ResourceType.java b/server/src/main/java/org/opensearch/search/ResourceType.java
new file mode 100644
index 0000000000000..6517e278f2700
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/ResourceType.java
@@ -0,0 +1,70 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search;
+
+import org.opensearch.common.annotation.DeprecatedApi;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.tasks.resourcetracker.ResourceStats;
+import org.opensearch.tasks.Task;
+
+import java.io.IOException;
+import java.util.function.Function;
+
+/**
+ * Enum to hold the resource type
+ *
+ * @opensearch.api
+ *
+ */
+@DeprecatedApi(since = "2.17.0")
+@Deprecated(forRemoval = true)
+public enum ResourceType {
+    CPU("cpu", task -> task.getTotalResourceUtilization(ResourceStats.CPU)),
+    MEMORY("memory", task -> task.getTotalResourceUtilization(ResourceStats.MEMORY));
+
+    private final String name;
+    private final Function<Task, Long> getResourceUsage;
+
+    ResourceType(String name, Function<Task, Long> getResourceUsage) {
+        this.name = name;
+        this.getResourceUsage = getResourceUsage;
+    }
+
+    /**
+     * The string match here is case-sensitive
+     * @param s name matching the resource type name
+     * @return a {@link ResourceType}
+     */
+    public static ResourceType fromName(String s) {
+        for (ResourceType resourceType : values()) {
+            if (resourceType.getName().equals(s)) {
+                return resourceType;
+            }
+        }
+        throw new IllegalArgumentException("Unknown resource type: [" + s + "]");
+    }
+
+    public static void writeTo(StreamOutput out, ResourceType resourceType) throws IOException {
+        out.writeString(resourceType.getName());
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Gets the resource usage for a given resource type and task.
+     *
+     * @param task the task for which to calculate resource usage
+     * @return the resource usage
+     */
+    public long getResourceUsage(Task task) {
+        return getResourceUsage.apply(task);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/SearchModule.java b/server/src/main/java/org/opensearch/search/SearchModule.java
index 29a9d5c525c76..e9ed02828b971 100644
--- a/server/src/main/java/org/opensearch/search/SearchModule.java
+++ b/server/src/main/java/org/opensearch/search/SearchModule.java
@@ -37,7 +37,6 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.geo.GeoShapeType;
 import org.opensearch.common.geo.ShapesAvailability;
-import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.ParseFieldRegistry;
 import org.opensearch.core.ParseField;
@@ -256,6 +255,7 @@
 import org.opensearch.search.aggregations.pipeline.SumBucketPipelineAggregationBuilder;
 import org.opensearch.search.aggregations.pipeline.SumBucketPipelineAggregator;
 import org.opensearch.search.aggregations.support.ValuesSourceRegistry;
+import org.opensearch.search.deciders.ConcurrentSearchDecider;
 import org.opensearch.search.fetch.FetchPhase;
 import org.opensearch.search.fetch.FetchSubPhase;
 import org.opensearch.search.fetch.subphase.ExplainPhase;
@@ -299,6 +299,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -318,13 +319,6 @@
  * @opensearch.internal
  */
 public class SearchModule {
-    public static final Setting<Integer> INDICES_MAX_CLAUSE_COUNT_SETTING = Setting.intSetting(
-        "indices.query.bool.max_clause_count",
-        1024,
-        1,
-        Integer.MAX_VALUE,
-        Setting.Property.NodeScope
-    );
 
     private final Map<String, Highlighter> highlighters;
     private final ParseFieldRegistry<MovAvgModel.AbstractModelParser> movingAverageModelParserRegistry = new ParseFieldRegistry<>(
@@ -340,6 +334,8 @@ public class SearchModule {
     private final QueryPhaseSearcher queryPhaseSearcher;
     private final SearchPlugin.ExecutorServiceProvider indexSearcherExecutorProvider;
 
+    private final Collection<ConcurrentSearchDecider> concurrentSearchDeciders;
+
     /**
      * Constructs a new SearchModule object
      * <p>
@@ -368,6 +364,25 @@ public SearchModule(Settings settings, List<SearchPlugin> plugins) {
         queryPhaseSearcher = registerQueryPhaseSearcher(plugins);
         indexSearcherExecutorProvider = registerIndexSearcherExecutorProvider(plugins);
         namedWriteables.addAll(SortValue.namedWriteables());
+        concurrentSearchDeciders = registerConcurrentSearchDeciders(plugins);
+    }
+
+    private Collection<ConcurrentSearchDecider> registerConcurrentSearchDeciders(List<SearchPlugin> plugins) {
+        List<ConcurrentSearchDecider> concurrentSearchDeciders = new ArrayList<>();
+        for (SearchPlugin plugin : plugins) {
+            ConcurrentSearchDecider decider = plugin.getConcurrentSearchDecider();
+            if (decider != null) {
+                concurrentSearchDeciders.add(decider);
+            }
+        }
+        return concurrentSearchDeciders;
+    }
+
+    /**
+     * Returns the concurrent search deciders that the plugins have registered
+     */
+    public Collection<ConcurrentSearchDecider> getConcurrentSearchDeciders() {
+        return concurrentSearchDeciders;
     }
 
     public List<NamedWriteableRegistry.Entry> getNamedWriteables() {
@@ -1130,7 +1145,6 @@ private void registerQueryParsers(List<SearchPlugin> plugins) {
         registerQuery(new QuerySpec<>(MatchAllQueryBuilder.NAME, MatchAllQueryBuilder::new, MatchAllQueryBuilder::fromXContent));
         registerQuery(new QuerySpec<>(QueryStringQueryBuilder.NAME, QueryStringQueryBuilder::new, QueryStringQueryBuilder::fromXContent));
         registerQuery(new QuerySpec<>(BoostingQueryBuilder.NAME, BoostingQueryBuilder::new, BoostingQueryBuilder::fromXContent));
-        BooleanQuery.setMaxClauseCount(INDICES_MAX_CLAUSE_COUNT_SETTING.get(settings));
         registerQuery(new QuerySpec<>(BoolQueryBuilder.NAME, BoolQueryBuilder::new, BoolQueryBuilder::fromXContent));
         registerQuery(new QuerySpec<>(TermQueryBuilder.NAME, TermQueryBuilder::new, TermQueryBuilder::fromXContent));
         registerQuery(new QuerySpec<>(TermsQueryBuilder.NAME, TermsQueryBuilder::new, TermsQueryBuilder::fromXContent));
diff --git a/server/src/main/java/org/opensearch/search/SearchService.java b/server/src/main/java/org/opensearch/search/SearchService.java
index b27f9f6bf65b2..e33a47fe8e178 100644
--- a/server/src/main/java/org/opensearch/search/SearchService.java
+++ b/server/src/main/java/org/opensearch/search/SearchService.java
@@ -35,6 +35,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.apache.lucene.search.FieldDoc;
+import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.TopDocs;
 import org.opensearch.LegacyESVersion;
 import org.opensearch.OpenSearchException;
@@ -78,9 +79,8 @@
 import org.opensearch.index.IndexService;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.engine.Engine;
-import org.opensearch.index.mapper.DerivedField;
-import org.opensearch.index.mapper.DerivedFieldMapper;
-import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.index.mapper.DerivedFieldResolver;
+import org.opensearch.index.mapper.DerivedFieldResolverFactory;
 import org.opensearch.index.query.InnerHitContextBuilder;
 import org.opensearch.index.query.MatchAllQueryBuilder;
 import org.opensearch.index.query.MatchNoneQueryBuilder;
@@ -105,6 +105,7 @@
 import org.opensearch.search.aggregations.pipeline.PipelineAggregator.PipelineTree;
 import org.opensearch.search.builder.SearchSourceBuilder;
 import org.opensearch.search.collapse.CollapseContext;
+import org.opensearch.search.deciders.ConcurrentSearchDecider;
 import org.opensearch.search.dfs.DfsPhase;
 import org.opensearch.search.dfs.DfsSearchResult;
 import org.opensearch.search.fetch.FetchPhase;
@@ -139,6 +140,7 @@
 import org.opensearch.search.sort.SortOrder;
 import org.opensearch.search.suggest.Suggest;
 import org.opensearch.search.suggest.completion.CompletionSuggestion;
+import org.opensearch.tasks.TaskResourceTrackingService;
 import org.opensearch.threadpool.Scheduler.Cancellable;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
@@ -146,6 +148,7 @@
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -256,6 +259,34 @@ public class SearchService extends AbstractLifecycleComponent implements IndexEv
         "search.concurrent_segment_search.enabled",
         false,
         Property.Dynamic,
+        Property.NodeScope,
+        Property.Deprecated
+    );
+
+    // Allow concurrent segment search for all requests
+    public static final String CONCURRENT_SEGMENT_SEARCH_MODE_ALL = "all";
+
+    // Disallow concurrent search for all requests
+    public static final String CONCURRENT_SEGMENT_SEARCH_MODE_NONE = "none";
+
+    // Make decision for concurrent search based on concurrent search deciders
+    public static final String CONCURRENT_SEGMENT_SEARCH_MODE_AUTO = "auto";
+
+    public static final Setting<String> CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE = Setting.simpleString(
+        "search.concurrent_segment_search.mode",
+        CONCURRENT_SEGMENT_SEARCH_MODE_NONE,
+        value -> {
+            switch (value) {
+                case CONCURRENT_SEGMENT_SEARCH_MODE_ALL:
+                case CONCURRENT_SEGMENT_SEARCH_MODE_NONE:
+                case CONCURRENT_SEGMENT_SEARCH_MODE_AUTO:
+                    // valid setting
+                    break;
+                default:
+                    throw new IllegalArgumentException("Setting value must be one of [all, none, auto]");
+            }
+        },
+        Property.Dynamic,
         Property.NodeScope
     );
 
@@ -282,6 +313,31 @@ public class SearchService extends AbstractLifecycleComponent implements IndexEv
         Property.NodeScope
     );
 
+    public static final Setting<Integer> INDICES_MAX_CLAUSE_COUNT_SETTING = Setting.intSetting(
+        "indices.query.bool.max_clause_count",
+        1024,
+        1,
+        Integer.MAX_VALUE,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
+    public static final Setting<Boolean> CLUSTER_ALLOW_DERIVED_FIELD_SETTING = Setting.boolSetting(
+        "search.derived_field.enabled",
+        true,
+        Property.Dynamic,
+        Property.NodeScope
+    );
+
+    // value 0 can disable dynamic pruning optimization in cardinality aggregation
+    public static final Setting<Integer> CARDINALITY_AGGREGATION_PRUNING_THRESHOLD = Setting.intSetting(
+        "search.dynamic_pruning.cardinality_aggregation.max_allowed_cardinality",
+        100,
+        0,
+        Property.Dynamic,
+        Property.NodeScope
+    );
+
     public static final int DEFAULT_SIZE = 10;
     public static final int DEFAULT_FROM = 0;
 
@@ -302,6 +358,7 @@ public class SearchService extends AbstractLifecycleComponent implements IndexEv
     private final QueryPhase queryPhase;
 
     private final FetchPhase fetchPhase;
+    private final Collection<ConcurrentSearchDecider> concurrentSearchDeciders;
 
     private volatile long defaultKeepAlive;
 
@@ -319,6 +376,8 @@ public class SearchService extends AbstractLifecycleComponent implements IndexEv
 
     private volatile int maxOpenPitContext;
 
+    private volatile boolean allowDerivedField;
+
     private final Cancellable keepAliveReaper;
 
     private final AtomicLong idGenerator = new AtomicLong();
@@ -331,6 +390,7 @@ public class SearchService extends AbstractLifecycleComponent implements IndexEv
     private final AtomicInteger openPitContexts = new AtomicInteger();
     private final String sessionId = UUIDs.randomBase64UUID();
     private final Executor indexSearcherExecutor;
+    private final TaskResourceTrackingService taskResourceTrackingService;
 
     public SearchService(
         ClusterService clusterService,
@@ -342,7 +402,9 @@ public SearchService(
         FetchPhase fetchPhase,
         ResponseCollectorService responseCollectorService,
         CircuitBreakerService circuitBreakerService,
-        Executor indexSearcherExecutor
+        Executor indexSearcherExecutor,
+        TaskResourceTrackingService taskResourceTrackingService,
+        Collection<ConcurrentSearchDecider> concurrentSearchDeciders
     ) {
         Settings settings = clusterService.getSettings();
         this.threadPool = threadPool;
@@ -359,6 +421,7 @@ public SearchService(
             circuitBreakerService.getBreaker(CircuitBreaker.REQUEST)
         );
         this.indexSearcherExecutor = indexSearcherExecutor;
+        this.taskResourceTrackingService = taskResourceTrackingService;
         TimeValue keepAliveInterval = KEEPALIVE_INTERVAL_SETTING.get(settings);
         setKeepAlives(DEFAULT_KEEPALIVE_SETTING.get(settings), MAX_KEEPALIVE_SETTING.get(settings));
         setPitKeepAlives(DEFAULT_KEEPALIVE_SETTING.get(settings), MAX_PIT_KEEPALIVE_SETTING.get(settings));
@@ -390,6 +453,14 @@ public SearchService(
 
         lowLevelCancellation = LOW_LEVEL_CANCELLATION_SETTING.get(settings);
         clusterService.getClusterSettings().addSettingsUpdateConsumer(LOW_LEVEL_CANCELLATION_SETTING, this::setLowLevelCancellation);
+
+        IndexSearcher.setMaxClauseCount(INDICES_MAX_CLAUSE_COUNT_SETTING.get(settings));
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(INDICES_MAX_CLAUSE_COUNT_SETTING, IndexSearcher::setMaxClauseCount);
+
+        allowDerivedField = CLUSTER_ALLOW_DERIVED_FIELD_SETTING.get(settings);
+        clusterService.getClusterSettings().addSettingsUpdateConsumer(CLUSTER_ALLOW_DERIVED_FIELD_SETTING, this::setAllowDerivedField);
+
+        this.concurrentSearchDeciders = concurrentSearchDeciders;
     }
 
     private void validateKeepAlives(TimeValue defaultKeepAlive, TimeValue maxKeepAlive) {
@@ -458,6 +529,10 @@ private void setMaxOpenScrollContext(int maxOpenScrollContext) {
         this.maxOpenScrollContext = maxOpenScrollContext;
     }
 
+    private void setAllowDerivedField(boolean allowDerivedField) {
+        this.allowDerivedField = allowDerivedField;
+    }
+
     private void setMaxOpenPitContext(int maxOpenPitContext) {
         this.maxOpenPitContext = maxOpenPitContext;
     }
@@ -544,6 +619,8 @@ private DfsSearchResult executeDfsPhase(ShardSearchRequest request, SearchShardT
             logger.trace("Dfs phase failed", e);
             processFailure(readerContext, e);
             throw e;
+        } finally {
+            taskResourceTrackingService.writeTaskResourceUsage(task, clusterService.localNode().getId());
         }
     }
 
@@ -646,6 +723,8 @@ private SearchPhaseResult executeQueryPhase(ShardSearchRequest request, SearchSh
             logger.trace("Query phase failed", e);
             processFailure(readerContext, e);
             throw e;
+        } finally {
+            taskResourceTrackingService.writeTaskResourceUsage(task, clusterService.localNode().getId());
         }
     }
 
@@ -691,6 +770,8 @@ public void executeQueryPhase(
                 logger.trace("Query phase failed", e);
                 // we handle the failure in the failure listener below
                 throw e;
+            } finally {
+                taskResourceTrackingService.writeTaskResourceUsage(task, clusterService.localNode().getId());
             }
         }, wrapFailureListener(listener, readerContext, markAsUsed));
     }
@@ -723,6 +804,8 @@ public void executeQueryPhase(QuerySearchRequest request, SearchShardTask task,
                 logger.trace("Query phase failed", e);
                 // we handle the failure in the failure listener below
                 throw e;
+            } finally {
+                taskResourceTrackingService.writeTaskResourceUsage(task, clusterService.localNode().getId());
             }
         }, wrapFailureListener(listener, readerContext, markAsUsed));
     }
@@ -772,6 +855,8 @@ public void executeFetchPhase(
                 logger.trace("Fetch phase failed", e);
                 // we handle the failure in the failure listener below
                 throw e;
+            } finally {
+                taskResourceTrackingService.writeTaskResourceUsage(task, clusterService.localNode().getId());
             }
         }, wrapFailureListener(listener, readerContext, markAsUsed));
     }
@@ -802,6 +887,8 @@ public void executeFetchPhase(ShardFetchRequest request, SearchShardTask task, A
                 assert TransportActions.isShardNotAvailableException(e) == false : new AssertionError(e);
                 // we handle the failure in the failure listener below
                 throw e;
+            } finally {
+                taskResourceTrackingService.writeTaskResourceUsage(task, clusterService.localNode().getId());
             }
         }, wrapFailureListener(listener, readerContext, markAsUsed));
     }
@@ -1073,34 +1160,21 @@ private DefaultSearchContext createSearchContext(ReaderContext reader, ShardSear
                 clusterService.state().nodes().getMinNodeVersion(),
                 validate,
                 indexSearcherExecutor,
-                this::aggReduceContextBuilder
+                this::aggReduceContextBuilder,
+                concurrentSearchDeciders
             );
             // we clone the query shard context here just for rewriting otherwise we
             // might end up with incorrect state since we are using now() or script services
             // during rewrite and normalized / evaluate templates etc.
             QueryShardContext context = new QueryShardContext(searchContext.getQueryShardContext());
-            if (request.source() != null
-                && request.source().size() != 0
-                && (request.source().getDerivedFieldsObject() != null || request.source().getDerivedFields() != null)) {
-                Map<String, MappedFieldType> derivedFieldTypeMap = new HashMap<>();
-                if (request.source().getDerivedFieldsObject() != null) {
-                    Map<String, Object> derivedFieldObject = new HashMap<>();
-                    derivedFieldObject.put(DerivedFieldMapper.CONTENT_TYPE, request.source().getDerivedFieldsObject());
-                    derivedFieldTypeMap.putAll(
-                        DerivedFieldMapper.getAllDerivedFieldTypeFromObject(derivedFieldObject, searchContext.mapperService())
-                    );
-                }
-                if (request.source().getDerivedFields() != null) {
-                    for (DerivedField derivedField : request.source().getDerivedFields()) {
-                        derivedFieldTypeMap.put(
-                            derivedField.getName(),
-                            DerivedFieldMapper.getDerivedFieldType(derivedField, searchContext.mapperService())
-                        );
-                    }
-                }
-                context.setDerivedFieldTypes(derivedFieldTypeMap);
-                searchContext.getQueryShardContext().setDerivedFieldTypes(derivedFieldTypeMap);
-            }
+            DerivedFieldResolver derivedFieldResolver = DerivedFieldResolverFactory.createResolver(
+                searchContext.getQueryShardContext(),
+                Optional.ofNullable(request.source()).map(SearchSourceBuilder::getDerivedFieldsObject).orElse(Collections.emptyMap()),
+                Optional.ofNullable(request.source()).map(SearchSourceBuilder::getDerivedFields).orElse(Collections.emptyList()),
+                context.getIndexSettings().isDerivedFieldAllowed() && allowDerivedField
+            );
+            context.setDerivedFieldResolver(derivedFieldResolver);
+            searchContext.getQueryShardContext().setDerivedFieldResolver(derivedFieldResolver);
             Rewriteable.rewrite(request.getRewriteable(), context, true);
             assert searchContext.getQueryShardContext().isCacheable();
             success = true;
@@ -1753,6 +1827,7 @@ public CanMatchResponse(boolean canMatch, MinAndMax<?> estimatedMinAndMax) {
 
         @Override
         public void writeTo(StreamOutput out) throws IOException {
+            super.writeTo(out);
             out.writeBoolean(canMatch);
             if (out.getVersion().onOrAfter(LegacyESVersion.V_7_6_0)) {
                 out.writeOptionalWriteable(estimatedMinAndMax);
diff --git a/server/src/main/java/org/opensearch/search/aggregations/BucketCollectorProcessor.java b/server/src/main/java/org/opensearch/search/aggregations/BucketCollectorProcessor.java
index df05ce3f5c049..32c243cc12aa6 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/BucketCollectorProcessor.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/BucketCollectorProcessor.java
@@ -71,10 +71,10 @@ public void processPostCollection(Collector collectorTree) throws IOException {
                     collectors.offer(innerCollector);
                 }
             } else if (currentCollector instanceof BucketCollector) {
-                ((BucketCollector) currentCollector).postCollection();
-
                 // Perform build aggregation during post collection
                 if (currentCollector instanceof Aggregator) {
+                    // Do not perform postCollection for MultiBucketCollector as we are unwrapping that below
+                    ((BucketCollector) currentCollector).postCollection();
                     ((Aggregator) currentCollector).buildTopLevel();
                 } else if (currentCollector instanceof MultiBucketCollector) {
                     for (Collector innerCollector : ((MultiBucketCollector) currentCollector).getCollectors()) {
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/BestBucketsDeferringCollector.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/BestBucketsDeferringCollector.java
index 223be3ba2d1ae..69d0fcd6c96f2 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/BestBucketsDeferringCollector.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/BestBucketsDeferringCollector.java
@@ -124,6 +124,7 @@ private void finishLeaf() {
         if (context != null) {
             assert docDeltasBuilder != null && bucketsBuilder != null;
             entries.add(new Entry(context, docDeltasBuilder.build(), bucketsBuilder.build()));
+            context = null;
         }
     }
 
@@ -161,6 +162,7 @@ public void preCollection() throws IOException {
 
     @Override
     public void postCollection() throws IOException {
+        assert searchContext.searcher().getLeafContexts().isEmpty() || finished != true;
         finishLeaf();
         finished = true;
     }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/FastFilterRewriteHelper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/FastFilterRewriteHelper.java
deleted file mode 100644
index c8ce39a52f869..0000000000000
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/FastFilterRewriteHelper.java
+++ /dev/null
@@ -1,731 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.search.aggregations.bucket;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.apache.lucene.index.DocValues;
-import org.apache.lucene.index.LeafReaderContext;
-import org.apache.lucene.index.NumericDocValues;
-import org.apache.lucene.index.PointValues;
-import org.apache.lucene.search.CollectionTerminatedException;
-import org.apache.lucene.search.ConstantScoreQuery;
-import org.apache.lucene.search.DocIdSetIterator;
-import org.apache.lucene.search.FieldExistsQuery;
-import org.apache.lucene.search.IndexOrDocValuesQuery;
-import org.apache.lucene.search.MatchAllDocsQuery;
-import org.apache.lucene.search.PointRangeQuery;
-import org.apache.lucene.search.Query;
-import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Weight;
-import org.apache.lucene.util.ArrayUtil;
-import org.apache.lucene.util.NumericUtils;
-import org.opensearch.common.CheckedRunnable;
-import org.opensearch.common.Rounding;
-import org.opensearch.common.lucene.search.function.FunctionScoreQuery;
-import org.opensearch.index.mapper.DateFieldMapper;
-import org.opensearch.index.mapper.DocCountFieldMapper;
-import org.opensearch.index.mapper.MappedFieldType;
-import org.opensearch.index.query.DateRangeIncludingNowQuery;
-import org.opensearch.search.aggregations.bucket.composite.CompositeAggregator;
-import org.opensearch.search.aggregations.bucket.composite.CompositeValuesSourceConfig;
-import org.opensearch.search.aggregations.bucket.composite.RoundingValuesSource;
-import org.opensearch.search.aggregations.bucket.histogram.LongBounds;
-import org.opensearch.search.internal.SearchContext;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.OptionalLong;
-import java.util.function.BiConsumer;
-import java.util.function.BiFunction;
-import java.util.function.Function;
-
-import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;
-
-/**
- * Utility class to help rewrite aggregations into filters.
- * Instead of aggregation collects documents one by one, filter may count all documents that match in one pass.
- * <p>
- * Currently supported rewrite:
- * <ul>
- *  <li> date histogram : date range filter.
- *   Applied: DateHistogramAggregator, AutoDateHistogramAggregator, CompositeAggregator </li>
- * </ul>
- *
- * @opensearch.internal
- */
-public final class FastFilterRewriteHelper {
-
-    private FastFilterRewriteHelper() {}
-
-    private static final Logger logger = LogManager.getLogger(FastFilterRewriteHelper.class);
-
-    private static final Map<Class<?>, Function<Query, Query>> queryWrappers;
-
-    // Initialize the wrapper map for unwrapping the query
-    static {
-        queryWrappers = new HashMap<>();
-        queryWrappers.put(ConstantScoreQuery.class, q -> ((ConstantScoreQuery) q).getQuery());
-        queryWrappers.put(FunctionScoreQuery.class, q -> ((FunctionScoreQuery) q).getSubQuery());
-        queryWrappers.put(DateRangeIncludingNowQuery.class, q -> ((DateRangeIncludingNowQuery) q).getQuery());
-        queryWrappers.put(IndexOrDocValuesQuery.class, q -> ((IndexOrDocValuesQuery) q).getIndexQuery());
-    }
-
-    /**
-     * Recursively unwraps query into the concrete form
-     * for applying the optimization
-     */
-    private static Query unwrapIntoConcreteQuery(Query query) {
-        while (queryWrappers.containsKey(query.getClass())) {
-            query = queryWrappers.get(query.getClass()).apply(query);
-        }
-
-        return query;
-    }
-
-    /**
-     * Finds the global min and max bounds of the field for the shard across all segments
-     *
-     * @return null if the field is empty or not indexed
-     */
-    private static long[] getShardBounds(final SearchContext context, final String fieldName) throws IOException {
-        final List<LeafReaderContext> leaves = context.searcher().getIndexReader().leaves();
-        long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
-        for (LeafReaderContext leaf : leaves) {
-            final PointValues values = leaf.reader().getPointValues(fieldName);
-            if (values != null) {
-                min = Math.min(min, NumericUtils.sortableBytesToLong(values.getMinPackedValue(), 0));
-                max = Math.max(max, NumericUtils.sortableBytesToLong(values.getMaxPackedValue(), 0));
-            }
-        }
-
-        if (min == Long.MAX_VALUE || max == Long.MIN_VALUE) {
-            return null;
-        }
-        return new long[] { min, max };
-    }
-
-    /**
-     * Finds the min and max bounds of the field for the segment
-     *
-     * @return null if the field is empty or not indexed
-     */
-    private static long[] getSegmentBounds(final LeafReaderContext context, final String fieldName) throws IOException {
-        long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
-        final PointValues values = context.reader().getPointValues(fieldName);
-        if (values != null) {
-            min = Math.min(min, NumericUtils.sortableBytesToLong(values.getMinPackedValue(), 0));
-            max = Math.max(max, NumericUtils.sortableBytesToLong(values.getMaxPackedValue(), 0));
-        }
-
-        if (min == Long.MAX_VALUE || max == Long.MIN_VALUE) {
-            return null;
-        }
-        return new long[] { min, max };
-    }
-
-    /**
-     * Gets the min and max bounds of the field for the shard search
-     * Depending on the query part, the bounds are computed differently
-     *
-     * @return null if the processed query not supported by the optimization
-     */
-    public static long[] getDateHistoAggBounds(final SearchContext context, final String fieldName) throws IOException {
-        final Query cq = unwrapIntoConcreteQuery(context.query());
-        if (cq instanceof PointRangeQuery) {
-            final PointRangeQuery prq = (PointRangeQuery) cq;
-            final long[] indexBounds = getShardBounds(context, fieldName);
-            if (indexBounds == null) return null;
-            return getBoundsWithRangeQuery(prq, fieldName, indexBounds);
-        } else if (cq instanceof MatchAllDocsQuery) {
-            return getShardBounds(context, fieldName);
-        } else if (cq instanceof FieldExistsQuery) {
-            // when a range query covers all values of a shard, it will be rewrite field exists query
-            if (((FieldExistsQuery) cq).getField().equals(fieldName)) {
-                return getShardBounds(context, fieldName);
-            }
-        }
-
-        return null;
-    }
-
-    private static long[] getBoundsWithRangeQuery(PointRangeQuery prq, String fieldName, long[] indexBounds) {
-        // Ensure that the query and aggregation are on the same field
-        if (prq.getField().equals(fieldName)) {
-            // Minimum bound for aggregation is the max between query and global
-            long lower = Math.max(NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0), indexBounds[0]);
-            // Maximum bound for aggregation is the min between query and global
-            long upper = Math.min(NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0), indexBounds[1]);
-            if (lower > upper) {
-                return null;
-            }
-            return new long[] { lower, upper };
-        }
-
-        return null;
-    }
-
-    /**
-     * Context object for fast filter optimization
-     * <p>
-     * Usage: first set aggregation type, then check isRewriteable, then buildFastFilter
-     */
-    public static class FastFilterContext {
-        private boolean rewriteable = false;
-        private boolean rangesBuiltAtShardLevel = false;
-
-        private AggregationType aggregationType;
-        private final SearchContext context;
-
-        private String fieldName;
-        private long[][] ranges;
-
-        // debug info related fields
-        public int leaf;
-        public int inner;
-        public int segments;
-        public int optimizedSegments;
-
-        public void setFieldName(String fieldName) {
-            this.fieldName = fieldName;
-        }
-
-        public FastFilterContext(SearchContext context) {
-            this.context = context;
-        }
-
-        public AggregationType getAggregationType() {
-            return aggregationType;
-        }
-
-        public void setAggregationType(AggregationType aggregationType) {
-            this.aggregationType = aggregationType;
-        }
-
-        public boolean isRewriteable(final Object parent, final int subAggLength) {
-            if (context.maxAggRewriteFilters() == 0) return false;
-
-            boolean rewriteable = aggregationType.isRewriteable(parent, subAggLength);
-            logger.debug("Fast filter rewriteable: {} for shard {}", rewriteable, context.indexShard().shardId());
-            this.rewriteable = rewriteable;
-            return rewriteable;
-        }
-
-        public void buildRanges() throws IOException {
-            assert ranges == null : "Ranges should only be built once at shard level, but they are already built";
-            this.ranges = this.aggregationType.buildRanges(context);
-            if (ranges != null) {
-                logger.debug("Ranges built for shard {}", context.indexShard().shardId());
-                rangesBuiltAtShardLevel = true;
-            }
-        }
-
-        public long[][] buildRanges(LeafReaderContext leaf) throws IOException {
-            long[][] ranges = this.aggregationType.buildRanges(leaf, context);
-            if (ranges != null) {
-                logger.debug("Ranges built for shard {} segment {}", context.indexShard().shardId(), leaf.ord);
-            }
-            return ranges;
-        }
-
-        private void consumeDebugInfo(DebugInfo debug) {
-            leaf += debug.leaf;
-            inner += debug.inner;
-        }
-    }
-
-    /**
-     * Different types have different pre-conditions, filter building logic, etc.
-     */
-    interface AggregationType {
-        boolean isRewriteable(Object parent, int subAggLength);
-
-        long[][] buildRanges(SearchContext ctx) throws IOException;
-
-        long[][] buildRanges(LeafReaderContext leaf, SearchContext ctx) throws IOException;
-    }
-
-    /**
-     * For date histogram aggregation
-     */
-    public static abstract class AbstractDateHistogramAggregationType implements AggregationType {
-        private final MappedFieldType fieldType;
-        private final boolean missing;
-        private final boolean hasScript;
-        private LongBounds hardBounds;
-
-        public AbstractDateHistogramAggregationType(MappedFieldType fieldType, boolean missing, boolean hasScript) {
-            this.fieldType = fieldType;
-            this.missing = missing;
-            this.hasScript = hasScript;
-        }
-
-        public AbstractDateHistogramAggregationType(MappedFieldType fieldType, boolean missing, boolean hasScript, LongBounds hardBounds) {
-            this(fieldType, missing, hasScript);
-            this.hardBounds = hardBounds;
-        }
-
-        @Override
-        public boolean isRewriteable(Object parent, int subAggLength) {
-            if (parent == null && subAggLength == 0 && !missing && !hasScript) {
-                if (fieldType != null && fieldType instanceof DateFieldMapper.DateFieldType) {
-                    return fieldType.isSearchable();
-                }
-            }
-            return false;
-        }
-
-        @Override
-        public long[][] buildRanges(SearchContext context) throws IOException {
-            long[] bounds = getDateHistoAggBounds(context, fieldType.name());
-            logger.debug("Bounds are {} for shard {}", bounds, context.indexShard().shardId());
-            return buildRanges(context, bounds);
-        }
-
-        private long[][] buildRanges(SearchContext context, long[] bounds) throws IOException {
-            bounds = processHardBounds(bounds);
-            if (bounds == null) {
-                return null;
-            }
-            assert bounds[0] <= bounds[1] : "Low bound should be less than high bound";
-
-            final Rounding rounding = getRounding(bounds[0], bounds[1]);
-            final OptionalLong intervalOpt = Rounding.getInterval(rounding);
-            if (intervalOpt.isEmpty()) {
-                return null;
-            }
-            final long interval = intervalOpt.getAsLong();
-
-            // process the after key of composite agg
-            processAfterKey(bounds, interval);
-
-            return FastFilterRewriteHelper.createRangesFromAgg(
-                context,
-                (DateFieldMapper.DateFieldType) fieldType,
-                interval,
-                getRoundingPrepared(),
-                bounds[0],
-                bounds[1]
-            );
-        }
-
-        @Override
-        public long[][] buildRanges(LeafReaderContext leaf, SearchContext context) throws IOException {
-            long[] bounds = getSegmentBounds(leaf, fieldType.name());
-            logger.debug("Bounds are {} for shard {} segment {}", bounds, context.indexShard().shardId(), leaf.ord);
-            return buildRanges(context, bounds);
-        }
-
-        protected abstract Rounding getRounding(final long low, final long high);
-
-        protected abstract Rounding.Prepared getRoundingPrepared();
-
-        protected void processAfterKey(long[] bound, long interval) {}
-
-        protected long[] processHardBounds(long[] bounds) {
-            if (bounds != null) {
-                // Update min/max limit if user specified any hard bounds
-                if (hardBounds != null) {
-                    if (hardBounds.getMin() > bounds[0]) {
-                        bounds[0] = hardBounds.getMin();
-                    }
-                    if (hardBounds.getMax() - 1 < bounds[1]) {
-                        bounds[1] = hardBounds.getMax() - 1; // hard bounds max is exclusive
-                    }
-                    if (bounds[0] > bounds[1]) {
-                        return null;
-                    }
-                }
-            }
-            return bounds;
-        }
-
-        public DateFieldMapper.DateFieldType getFieldType() {
-            assert fieldType instanceof DateFieldMapper.DateFieldType;
-            return (DateFieldMapper.DateFieldType) fieldType;
-        }
-    }
-
-    public static boolean isCompositeAggRewriteable(CompositeValuesSourceConfig[] sourceConfigs) {
-        return sourceConfigs.length == 1 && sourceConfigs[0].valuesSource() instanceof RoundingValuesSource;
-    }
-
-    public static long getBucketOrd(long bucketOrd) {
-        if (bucketOrd < 0) { // already seen
-            bucketOrd = -1 - bucketOrd;
-        }
-
-        return bucketOrd;
-    }
-
-    /**
-     * Try to get the bucket doc counts for the date histogram aggregation
-     * <p>
-     * Usage: invoked at segment level — in getLeafCollector of aggregator
-     *
-     * @param incrementDocCount takes in the bucket key value and the bucket count
-     */
-    public static boolean tryFastFilterAggregation(
-        final LeafReaderContext ctx,
-        FastFilterContext fastFilterContext,
-        final BiConsumer<Long, Integer> incrementDocCount
-    ) throws IOException {
-        fastFilterContext.segments++;
-        if (!fastFilterContext.rewriteable) {
-            return false;
-        }
-
-        if (ctx.reader().hasDeletions()) return false;
-
-        PointValues values = ctx.reader().getPointValues(fastFilterContext.fieldName);
-        if (values == null) return false;
-        // only proceed if every document corresponds to exactly one point
-        if (values.getDocCount() != values.size()) return false;
-
-        NumericDocValues docCountValues = DocValues.getNumeric(ctx.reader(), DocCountFieldMapper.NAME);
-        if (docCountValues.nextDoc() != NO_MORE_DOCS) {
-            logger.debug(
-                "Shard {} segment {} has at least one document with _doc_count field, skip fast filter optimization",
-                fastFilterContext.context.indexShard().shardId(),
-                ctx.ord
-            );
-            return false;
-        }
-
-        // even if no ranges built at shard level, we can still perform the optimization
-        // when functionally match-all at segment level
-        if (!fastFilterContext.rangesBuiltAtShardLevel && !segmentMatchAll(fastFilterContext.context, ctx)) {
-            return false;
-        }
-        long[][] ranges = fastFilterContext.ranges;
-        if (ranges == null) {
-            logger.debug(
-                "Shard {} segment {} functionally match all documents. Build the fast filter",
-                fastFilterContext.context.indexShard().shardId(),
-                ctx.ord
-            );
-            ranges = fastFilterContext.buildRanges(ctx);
-            if (ranges == null) {
-                return false;
-            }
-        }
-
-        final AggregationType aggregationType = fastFilterContext.aggregationType;
-        assert aggregationType instanceof AbstractDateHistogramAggregationType;
-        final DateFieldMapper.DateFieldType fieldType = ((AbstractDateHistogramAggregationType) aggregationType).getFieldType();
-        int size = Integer.MAX_VALUE;
-        if (aggregationType instanceof CompositeAggregator.CompositeAggregationType) {
-            size = ((CompositeAggregator.CompositeAggregationType) aggregationType).getSize();
-        }
-        DebugInfo debugInfo = multiRangesTraverse(values.getPointTree(), ranges, incrementDocCount, fieldType, size);
-        fastFilterContext.consumeDebugInfo(debugInfo);
-
-        fastFilterContext.optimizedSegments++;
-        logger.debug("Fast filter optimization applied to shard {} segment {}", fastFilterContext.context.indexShard().shardId(), ctx.ord);
-        logger.debug("crossed leaf nodes: {}, inner nodes: {}", fastFilterContext.leaf, fastFilterContext.inner);
-        return true;
-    }
-
-    private static boolean segmentMatchAll(SearchContext ctx, LeafReaderContext leafCtx) throws IOException {
-        Weight weight = ctx.searcher().createWeight(ctx.query(), ScoreMode.COMPLETE_NO_SCORES, 1f);
-        return weight != null && weight.count(leafCtx) == leafCtx.reader().numDocs();
-    }
-
-    /**
-     * Creates the date ranges from date histo aggregations using its interval,
-     * and min/max boundaries
-     */
-    private static long[][] createRangesFromAgg(
-        final SearchContext context,
-        final DateFieldMapper.DateFieldType fieldType,
-        final long interval,
-        final Rounding.Prepared preparedRounding,
-        long low,
-        final long high
-    ) {
-        // Calculate the number of buckets using range and interval
-        long roundedLow = preparedRounding.round(fieldType.convertNanosToMillis(low));
-        long prevRounded = roundedLow;
-        int bucketCount = 0;
-        while (roundedLow <= fieldType.convertNanosToMillis(high)) {
-            bucketCount++;
-            int maxNumFilterBuckets = context.maxAggRewriteFilters();
-            if (bucketCount > maxNumFilterBuckets) {
-                logger.debug("Max number of filters reached [{}], skip the fast filter optimization", maxNumFilterBuckets);
-                return null;
-            }
-            // Below rounding is needed as the interval could return in
-            // non-rounded values for something like calendar month
-            roundedLow = preparedRounding.round(roundedLow + interval);
-            if (prevRounded == roundedLow) break; // prevents getting into an infinite loop
-            prevRounded = roundedLow;
-        }
-
-        long[][] ranges = new long[bucketCount][2];
-        if (bucketCount > 0) {
-            roundedLow = preparedRounding.round(fieldType.convertNanosToMillis(low));
-
-            int i = 0;
-            while (i < bucketCount) {
-                // Calculate the lower bucket bound
-                long lower = i == 0 ? low : fieldType.convertRoundedMillisToNanos(roundedLow);
-                roundedLow = preparedRounding.round(roundedLow + interval);
-
-                // Subtract -1 if the minimum is roundedLow as roundedLow itself
-                // is included in the next bucket
-                long upper = i + 1 == bucketCount ? high : fieldType.convertRoundedMillisToNanos(roundedLow) - 1;
-
-                ranges[i][0] = lower;
-                ranges[i][1] = upper;
-                i++;
-            }
-        }
-
-        return ranges;
-    }
-
-    /**
-     * @param maxNumNonZeroRanges the number of non-zero ranges to collect
-     */
-    private static DebugInfo multiRangesTraverse(
-        final PointValues.PointTree tree,
-        final long[][] ranges,
-        final BiConsumer<Long, Integer> incrementDocCount,
-        final DateFieldMapper.DateFieldType fieldType,
-        final int maxNumNonZeroRanges
-    ) throws IOException {
-        // ranges are connected and in ascending order
-        Iterator<long[]> rangeIter = Arrays.stream(ranges).iterator();
-        long[] activeRange = rangeIter.next();
-
-        // make sure the first range at least crosses the min value of the tree
-        DebugInfo debugInfo = new DebugInfo();
-        if (activeRange[0] > NumericUtils.sortableBytesToLong(tree.getMaxPackedValue(), 0)) {
-            logger.debug("No ranges match the query, skip the fast filter optimization");
-            return debugInfo;
-        }
-        while (activeRange[1] < NumericUtils.sortableBytesToLong(tree.getMinPackedValue(), 0)) {
-            if (!rangeIter.hasNext()) {
-                logger.debug("No ranges match the query, skip the fast filter optimization");
-                return debugInfo;
-            }
-            activeRange = rangeIter.next();
-        }
-
-        RangeCollectorForPointTree collector = new RangeCollectorForPointTree(
-            incrementDocCount,
-            fieldType,
-            rangeIter,
-            maxNumNonZeroRanges,
-            activeRange
-        );
-
-        final ArrayUtil.ByteArrayComparator comparator = ArrayUtil.getUnsignedComparator(8);
-        PointValues.IntersectVisitor visitor = getIntersectVisitor(collector, comparator);
-        try {
-            intersectWithRanges(visitor, tree, collector, debugInfo);
-        } catch (CollectionTerminatedException e) {
-            logger.debug("Early terminate since no more range to collect");
-        }
-        collector.finalizePreviousRange();
-
-        return debugInfo;
-    }
-
-    private static void intersectWithRanges(
-        PointValues.IntersectVisitor visitor,
-        PointValues.PointTree pointTree,
-        RangeCollectorForPointTree collector,
-        DebugInfo debug
-    ) throws IOException {
-        PointValues.Relation r = visitor.compare(pointTree.getMinPackedValue(), pointTree.getMaxPackedValue());
-
-        switch (r) {
-            case CELL_INSIDE_QUERY:
-                collector.countNode((int) pointTree.size());
-                debug.visitInner();
-                break;
-            case CELL_CROSSES_QUERY:
-                if (pointTree.moveToChild()) {
-                    do {
-                        intersectWithRanges(visitor, pointTree, collector, debug);
-                    } while (pointTree.moveToSibling());
-                    pointTree.moveToParent();
-                } else {
-                    pointTree.visitDocValues(visitor);
-                    debug.visitLeaf();
-                }
-                break;
-            case CELL_OUTSIDE_QUERY:
-        }
-    }
-
-    private static PointValues.IntersectVisitor getIntersectVisitor(
-        RangeCollectorForPointTree collector,
-        ArrayUtil.ByteArrayComparator comparator
-    ) {
-        return new PointValues.IntersectVisitor() {
-            @Override
-            public void visit(int docID) throws IOException {
-                // this branch should be unreachable
-                throw new UnsupportedOperationException(
-                    "This IntersectVisitor does not perform any actions on a " + "docID=" + docID + " node being visited"
-                );
-            }
-
-            @Override
-            public void visit(int docID, byte[] packedValue) throws IOException {
-                visitPoints(packedValue, collector::count);
-            }
-
-            @Override
-            public void visit(DocIdSetIterator iterator, byte[] packedValue) throws IOException {
-                visitPoints(packedValue, () -> {
-                    for (int doc = iterator.nextDoc(); doc != DocIdSetIterator.NO_MORE_DOCS; doc = iterator.nextDoc()) {
-                        collector.count();
-                    }
-                });
-            }
-
-            private void visitPoints(byte[] packedValue, CheckedRunnable<IOException> collect) throws IOException {
-                if (comparator.compare(packedValue, 0, collector.activeRangeAsByteArray[1], 0) > 0) {
-                    // need to move to next range
-                    collector.finalizePreviousRange();
-                    if (collector.iterateRangeEnd(packedValue, this::compareByteValue)) {
-                        throw new CollectionTerminatedException();
-                    }
-                }
-
-                if (pointCompare(collector.activeRangeAsByteArray[0], collector.activeRangeAsByteArray[1], packedValue)) {
-                    collect.run();
-                }
-            }
-
-            private boolean pointCompare(byte[] lower, byte[] upper, byte[] packedValue) {
-                if (compareByteValue(packedValue, lower) < 0) {
-                    return false;
-                }
-                return compareByteValue(packedValue, upper) <= 0;
-            }
-
-            private int compareByteValue(byte[] value1, byte[] value2) {
-                return comparator.compare(value1, 0, value2, 0);
-            }
-
-            @Override
-            public PointValues.Relation compare(byte[] minPackedValue, byte[] maxPackedValue) {
-                byte[] rangeMin = collector.activeRangeAsByteArray[0];
-                byte[] rangeMax = collector.activeRangeAsByteArray[1];
-
-                if (compareByteValue(rangeMax, minPackedValue) < 0) {
-                    collector.finalizePreviousRange();
-                    if (collector.iterateRangeEnd(minPackedValue, this::compareByteValue)) {
-                        throw new CollectionTerminatedException();
-                    }
-                    // compare the next range with this node's min max again
-                    // new rangeMin = previous rangeMax + 1 <= min
-                    rangeMax = collector.activeRangeAsByteArray[1];
-                }
-
-                if (compareByteValue(rangeMin, minPackedValue) > 0 || compareByteValue(rangeMax, maxPackedValue) < 0) {
-                    return PointValues.Relation.CELL_CROSSES_QUERY;
-                } else {
-                    return PointValues.Relation.CELL_INSIDE_QUERY;
-                }
-            }
-        };
-    }
-
-    private static class RangeCollectorForPointTree {
-        private final BiConsumer<Long, Integer> incrementDocCount;
-        private final DateFieldMapper.DateFieldType fieldType;
-        private int counter = 0;
-
-        private long[] activeRange;
-        private byte[][] activeRangeAsByteArray;
-        private final Iterator<long[]> rangeIter;
-
-        private int visitedRange = 0;
-        private final int maxNumNonZeroRange;
-
-        public RangeCollectorForPointTree(
-            BiConsumer<Long, Integer> incrementDocCount,
-            DateFieldMapper.DateFieldType fieldType,
-            Iterator<long[]> rangeIter,
-            int maxNumNonZeroRange,
-            long[] activeRange
-        ) {
-            this.incrementDocCount = incrementDocCount;
-            this.fieldType = fieldType;
-            this.rangeIter = rangeIter;
-            this.maxNumNonZeroRange = maxNumNonZeroRange;
-            this.activeRange = activeRange;
-            this.activeRangeAsByteArray = activeRangeAsByteArray();
-        }
-
-        private void count() {
-            counter++;
-        }
-
-        private void countNode(int count) {
-            counter += count;
-        }
-
-        private void finalizePreviousRange() {
-            if (counter > 0) {
-                logger.debug("finalize previous range: {}", activeRange[0]);
-                logger.debug("counter: {}", counter);
-                incrementDocCount.accept(fieldType.convertNanosToMillis(activeRange[0]), counter);
-                counter = 0;
-            }
-        }
-
-        /**
-         * @return true when iterator exhausted or collect enough non-zero ranges
-         */
-        private boolean iterateRangeEnd(byte[] value, BiFunction<byte[], byte[], Integer> comparator) {
-            // the new value may not be contiguous to the previous one
-            // so try to find the first next range that cross the new value
-            while (comparator.apply(activeRangeAsByteArray[1], value) < 0) {
-                if (!rangeIter.hasNext()) {
-                    return true;
-                }
-                activeRange = rangeIter.next();
-                activeRangeAsByteArray = activeRangeAsByteArray();
-            }
-            visitedRange++;
-            return visitedRange > maxNumNonZeroRange;
-        }
-
-        private byte[][] activeRangeAsByteArray() {
-            byte[] lower = new byte[8];
-            byte[] upper = new byte[8];
-            NumericUtils.longToSortableBytes(activeRange[0], lower, 0);
-            NumericUtils.longToSortableBytes(activeRange[1], upper, 0);
-            return new byte[][] { lower, upper };
-        }
-    }
-
-    private static class DebugInfo {
-        private int leaf = 0; // leaf node visited
-        private int inner = 0; // inner node visited
-
-        private void visitLeaf() {
-            leaf++;
-        }
-
-        private void visitInner() {
-            inner++;
-        }
-    }
-}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/composite/CompositeAggregationFactory.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/composite/CompositeAggregationFactory.java
index 6c5619a843fae..2ff79fb623def 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/composite/CompositeAggregationFactory.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/composite/CompositeAggregationFactory.java
@@ -40,7 +40,6 @@
 import org.opensearch.search.internal.SearchContext;
 
 import java.io.IOException;
-import java.util.Arrays;
 import java.util.Map;
 
 /**
@@ -81,7 +80,6 @@ protected Aggregator createInternal(
 
     @Override
     protected boolean supportsConcurrentSegmentSearch() {
-        // Disable concurrent search if any scripting is used. See https://github.com/opensearch-project/OpenSearch/issues/12331 for details
-        return Arrays.stream(sources).noneMatch(CompositeValuesSourceConfig::hasScript);
+        return true;
     }
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/composite/CompositeAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/composite/CompositeAggregator.java
index 3713d8f83990d..cfe716eb57ca8 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/composite/CompositeAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/composite/CompositeAggregator.java
@@ -73,7 +73,8 @@
 import org.opensearch.search.aggregations.MultiBucketCollector;
 import org.opensearch.search.aggregations.MultiBucketConsumerService;
 import org.opensearch.search.aggregations.bucket.BucketsAggregator;
-import org.opensearch.search.aggregations.bucket.FastFilterRewriteHelper;
+import org.opensearch.search.aggregations.bucket.filterrewrite.CompositeAggregatorBridge;
+import org.opensearch.search.aggregations.bucket.filterrewrite.FilterRewriteOptimizationContext;
 import org.opensearch.search.aggregations.bucket.missing.MissingOrder;
 import org.opensearch.search.aggregations.bucket.terms.LongKeyedBucketOrds;
 import org.opensearch.search.internal.SearchContext;
@@ -88,13 +89,15 @@
 import java.util.List;
 import java.util.Map;
 import java.util.function.BiConsumer;
+import java.util.function.Function;
 import java.util.function.LongUnaryOperator;
 import java.util.stream.Collectors;
 
 import static org.opensearch.search.aggregations.MultiBucketConsumerService.MAX_BUCKET_SETTING;
+import static org.opensearch.search.aggregations.bucket.filterrewrite.DateHistogramAggregatorBridge.segmentMatchAll;
 
 /**
- * Main aggregator that aggregates docs from mulitple aggregations
+ * Main aggregator that aggregates docs from multiple aggregations
  *
  * @opensearch.internal
  */
@@ -117,9 +120,8 @@ public final class CompositeAggregator extends BucketsAggregator {
 
     private boolean earlyTerminated;
 
-    private final FastFilterRewriteHelper.FastFilterContext fastFilterContext;
-    private LongKeyedBucketOrds bucketOrds = null;
-    private Rounding.Prepared preparedRounding = null;
+    private final FilterRewriteOptimizationContext filterRewriteOptimizationContext;
+    private LongKeyedBucketOrds bucketOrds;
 
     CompositeAggregator(
         String name,
@@ -165,56 +167,62 @@ public final class CompositeAggregator extends BucketsAggregator {
         this.queue = new CompositeValuesCollectorQueue(context.bigArrays(), sources, size, rawAfterKey);
         this.rawAfterKey = rawAfterKey;
 
-        fastFilterContext = new FastFilterRewriteHelper.FastFilterContext(context);
-        if (!FastFilterRewriteHelper.isCompositeAggRewriteable(sourceConfigs)) return;
-        fastFilterContext.setAggregationType(new CompositeAggregationType());
-        if (fastFilterContext.isRewriteable(parent, subAggregators.length)) {
-            // bucketOrds is used for saving date histogram results
-            bucketOrds = LongKeyedBucketOrds.build(context.bigArrays(), CardinalityUpperBound.ONE);
-            preparedRounding = ((CompositeAggregationType) fastFilterContext.getAggregationType()).getRoundingPrepared();
-            fastFilterContext.setFieldName(sourceConfigs[0].fieldType().name());
-            fastFilterContext.buildRanges();
-        }
-    }
+        CompositeAggregatorBridge bridge = new CompositeAggregatorBridge() {
+            private RoundingValuesSource valuesSource;
+            private long afterKey = -1L;
 
-    /**
-     * Currently the filter rewrite is only supported for date histograms
-     */
-    public class CompositeAggregationType extends FastFilterRewriteHelper.AbstractDateHistogramAggregationType {
-        private final RoundingValuesSource valuesSource;
-        private long afterKey = -1L;
-
-        public CompositeAggregationType() {
-            super(sourceConfigs[0].fieldType(), sourceConfigs[0].missingBucket(), sourceConfigs[0].hasScript());
-            this.valuesSource = (RoundingValuesSource) sourceConfigs[0].valuesSource();
-            if (rawAfterKey != null) {
-                assert rawAfterKey.size() == 1 && formats.size() == 1;
-                this.afterKey = formats.get(0).parseLong(rawAfterKey.get(0).toString(), false, () -> {
-                    throw new IllegalArgumentException("now() is not supported in [after] key");
-                });
+            @Override
+            protected boolean canOptimize() {
+                if (canOptimize(sourceConfigs)) {
+                    this.valuesSource = (RoundingValuesSource) sourceConfigs[0].valuesSource();
+                    if (rawAfterKey != null) {
+                        assert rawAfterKey.size() == 1 && formats.size() == 1;
+                        this.afterKey = formats.get(0).parseLong(rawAfterKey.get(0).toString(), false, () -> {
+                            throw new IllegalArgumentException("now() is not supported in [after] key");
+                        });
+                    }
+
+                    // bucketOrds is used for saving the date histogram results got from the optimization path
+                    bucketOrds = LongKeyedBucketOrds.build(context.bigArrays(), CardinalityUpperBound.ONE);
+                    return true;
+                }
+                return false;
             }
-        }
 
-        public Rounding getRounding(final long low, final long high) {
-            return valuesSource.getRounding();
-        }
+            @Override
+            protected void prepare() throws IOException {
+                buildRanges(context);
+            }
 
-        public Rounding.Prepared getRoundingPrepared() {
-            return valuesSource.getPreparedRounding();
-        }
+            protected Rounding getRounding(final long low, final long high) {
+                return valuesSource.getRounding();
+            }
 
-        @Override
-        protected void processAfterKey(long[] bound, long interval) {
-            // afterKey is the last bucket key in previous response, and the bucket key
-            // is the minimum of all values in the bucket, so need to add the interval
-            if (afterKey != -1L) {
-                bound[0] = afterKey + interval;
+            protected Rounding.Prepared getRoundingPrepared() {
+                return valuesSource.getPreparedRounding();
             }
-        }
 
-        public int getSize() {
-            return size;
-        }
+            @Override
+            protected long[] processAfterKey(long[] bounds, long interval) {
+                // afterKey is the last bucket key in previous response, and the bucket key
+                // is the minimum of all values in the bucket, so need to add the interval
+                if (afterKey != -1L) {
+                    bounds[0] = afterKey + interval;
+                }
+                return bounds;
+            }
+
+            @Override
+            protected int getSize() {
+                return size;
+            }
+
+            @Override
+            protected Function<Long, Long> bucketOrdProducer() {
+                return (key) -> bucketOrds.add(0, getRoundingPrepared().round((long) key));
+            }
+        };
+        filterRewriteOptimizationContext = new FilterRewriteOptimizationContext(bridge, parent, subAggregators.length, context);
     }
 
     @Override
@@ -366,7 +374,7 @@ private boolean isMaybeMultivalued(LeafReaderContext context, SortField sortFiel
                 return v2 != null && DocValues.unwrapSingleton(v2) == null;
 
             default:
-                // we have no clue whether the field is multi-valued or not so we assume it is.
+                // we have no clue whether the field is multivalued or not so we assume it is.
                 return true;
         }
     }
@@ -549,14 +557,7 @@ private void processLeafFromQuery(LeafReaderContext ctx, Sort indexSortPrefix) t
 
     @Override
     protected LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException {
-        boolean optimized = FastFilterRewriteHelper.tryFastFilterAggregation(
-            ctx,
-            fastFilterContext,
-            (key, count) -> incrementBucketDocCount(
-                FastFilterRewriteHelper.getBucketOrd(bucketOrds.add(0, preparedRounding.round(key))),
-                count
-            )
-        );
+        boolean optimized = filterRewriteOptimizationContext.tryOptimize(ctx, this::incrementBucketDocCount, segmentMatchAll(context, ctx));
         if (optimized) throw new CollectionTerminatedException();
 
         finishLeaf();
@@ -710,11 +711,6 @@ private static class Entry {
 
     @Override
     public void collectDebugInfo(BiConsumer<String, Object> add) {
-        if (fastFilterContext.optimizedSegments > 0) {
-            add.accept("optimized_segments", fastFilterContext.optimizedSegments);
-            add.accept("unoptimized_segments", fastFilterContext.segments - fastFilterContext.optimizedSegments);
-            add.accept("leaf_visited", fastFilterContext.leaf);
-            add.accept("inner_visited", fastFilterContext.inner);
-        }
+        filterRewriteOptimizationContext.populateDebugInfo(add);
     }
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/AggregatorBridge.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/AggregatorBridge.java
new file mode 100644
index 0000000000000..6b34582b259ea
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/AggregatorBridge.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.filterrewrite;
+
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.PointValues;
+import org.opensearch.index.mapper.MappedFieldType;
+
+import java.io.IOException;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+/**
+ * This interface provides a bridge between an aggregator and the optimization context, allowing
+ * the aggregator to provide data and optimize the aggregation process.
+ *
+ * <p>The main purpose of this interface is to encapsulate the aggregator-specific optimization
+ * logic and provide access to the data in Aggregator that is required for optimization, while keeping the optimization
+ * business logic separate from the aggregator implementation.
+ *
+ * <p>To use this interface to optimize an aggregator, you should subclass this interface in this package
+ * and put any specific optimization business logic in it. Then implement this subclass in the aggregator
+ * to provide data that is needed for doing the optimization
+ *
+ * @opensearch.internal
+ */
+public abstract class AggregatorBridge {
+
+    /**
+     * The field type associated with this aggregator bridge.
+     */
+    MappedFieldType fieldType;
+
+    Consumer<Ranges> setRanges;
+
+    void setRangesConsumer(Consumer<Ranges> setRanges) {
+        this.setRanges = setRanges;
+    }
+
+    /**
+     * Checks whether the aggregator can be optimized.
+     * <p>
+     * This method is supposed to be implemented in a specific aggregator to take in fields from there
+     *
+     * @return {@code true} if the aggregator can be optimized, {@code false} otherwise.
+     * The result will be saved in the optimization context.
+     */
+    protected abstract boolean canOptimize();
+
+    /**
+     * Prepares the optimization at shard level after checking aggregator is optimizable.
+     * <p>
+     * For example, figure out what are the ranges from the aggregation to do the optimization later
+     * <p>
+     * This method is supposed to be implemented in a specific aggregator to take in fields from there
+     */
+    protected abstract void prepare() throws IOException;
+
+    /**
+     * Prepares the optimization for a specific segment when the segment is functionally matching all docs
+     *
+     * @param leaf the leaf reader context for the segment
+     */
+    abstract Ranges tryBuildRangesFromSegment(LeafReaderContext leaf) throws IOException;
+
+    /**
+     * Attempts to build aggregation results for a segment
+     *
+     * @param values            the point values (index structure for numeric values) for a segment
+     * @param incrementDocCount a consumer to increment the document count for a range bucket. The First parameter is document count, the second is the key of the bucket
+     * @param ranges
+     */
+    abstract FilterRewriteOptimizationContext.DebugInfo tryOptimize(
+        PointValues values,
+        BiConsumer<Long, Long> incrementDocCount,
+        Ranges ranges
+    ) throws IOException;
+}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/CompositeAggregatorBridge.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/CompositeAggregatorBridge.java
new file mode 100644
index 0000000000000..e122e7bda0b6a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/CompositeAggregatorBridge.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.filterrewrite;
+
+import org.opensearch.index.mapper.DateFieldMapper;
+import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.search.aggregations.bucket.composite.CompositeValuesSourceConfig;
+import org.opensearch.search.aggregations.bucket.composite.RoundingValuesSource;
+
+/**
+ * For composite aggregation to do optimization when it only has a single date histogram source
+ */
+public abstract class CompositeAggregatorBridge extends DateHistogramAggregatorBridge {
+    protected boolean canOptimize(CompositeValuesSourceConfig[] sourceConfigs) {
+        if (sourceConfigs.length != 1 || !(sourceConfigs[0].valuesSource() instanceof RoundingValuesSource)) return false;
+        return canOptimize(sourceConfigs[0].missingBucket(), sourceConfigs[0].hasScript(), sourceConfigs[0].fieldType());
+    }
+
+    private boolean canOptimize(boolean missing, boolean hasScript, MappedFieldType fieldType) {
+        if (!missing && !hasScript) {
+            if (fieldType instanceof DateFieldMapper.DateFieldType) {
+                if (fieldType.isSearchable()) {
+                    this.fieldType = fieldType;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/DateHistogramAggregatorBridge.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/DateHistogramAggregatorBridge.java
new file mode 100644
index 0000000000000..8bff3fdc5fefb
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/DateHistogramAggregatorBridge.java
@@ -0,0 +1,174 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.filterrewrite;
+
+import org.apache.lucene.document.LongPoint;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.PointValues;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Weight;
+import org.opensearch.common.Rounding;
+import org.opensearch.index.mapper.DateFieldMapper;
+import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.search.aggregations.bucket.histogram.LongBounds;
+import org.opensearch.search.aggregations.support.ValuesSourceConfig;
+import org.opensearch.search.internal.SearchContext;
+
+import java.io.IOException;
+import java.util.OptionalLong;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+import static org.opensearch.search.aggregations.bucket.filterrewrite.PointTreeTraversal.multiRangesTraverse;
+
+/**
+ * For date histogram aggregation
+ */
+public abstract class DateHistogramAggregatorBridge extends AggregatorBridge {
+
+    int maxRewriteFilters;
+
+    protected boolean canOptimize(ValuesSourceConfig config) {
+        if (config.script() == null && config.missing() == null) {
+            MappedFieldType fieldType = config.fieldType();
+            if (fieldType instanceof DateFieldMapper.DateFieldType) {
+                if (fieldType.isSearchable()) {
+                    this.fieldType = fieldType;
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    protected void buildRanges(SearchContext context) throws IOException {
+        long[] bounds = Helper.getDateHistoAggBounds(context, fieldType.name());
+        this.maxRewriteFilters = context.maxAggRewriteFilters();
+        setRanges.accept(buildRanges(bounds, maxRewriteFilters));
+    }
+
+    @Override
+    final Ranges tryBuildRangesFromSegment(LeafReaderContext leaf) throws IOException {
+        long[] bounds = Helper.getSegmentBounds(leaf, fieldType.name());
+        return buildRanges(bounds, maxRewriteFilters);
+    }
+
+    private Ranges buildRanges(long[] bounds, int maxRewriteFilters) {
+        bounds = processHardBounds(bounds);
+        if (bounds == null) {
+            return null;
+        }
+        assert bounds[0] <= bounds[1] : "Low bound should be less than high bound";
+
+        final Rounding rounding = getRounding(bounds[0], bounds[1]);
+        final OptionalLong intervalOpt = Rounding.getInterval(rounding);
+        if (intervalOpt.isEmpty()) {
+            return null;
+        }
+        final long interval = intervalOpt.getAsLong();
+
+        // process the after key of composite agg
+        bounds = processAfterKey(bounds, interval);
+
+        return Helper.createRangesFromAgg(
+            (DateFieldMapper.DateFieldType) fieldType,
+            interval,
+            getRoundingPrepared(),
+            bounds[0],
+            bounds[1],
+            maxRewriteFilters
+        );
+    }
+
+    protected abstract Rounding getRounding(final long low, final long high);
+
+    protected abstract Rounding.Prepared getRoundingPrepared();
+
+    protected long[] processAfterKey(long[] bounds, long interval) {
+        return bounds;
+    }
+
+    protected long[] processHardBounds(long[] bounds) {
+        return processHardBounds(bounds, null);
+    }
+
+    protected long[] processHardBounds(long[] bounds, LongBounds hardBounds) {
+        if (bounds != null) {
+            // Update min/max limit if user specified any hard bounds
+            if (hardBounds != null) {
+                if (hardBounds.getMin() > bounds[0]) {
+                    bounds[0] = hardBounds.getMin();
+                }
+                if (hardBounds.getMax() - 1 < bounds[1]) {
+                    bounds[1] = hardBounds.getMax() - 1; // hard bounds max is exclusive
+                }
+                if (bounds[0] > bounds[1]) {
+                    return null;
+                }
+            }
+        }
+        return bounds;
+    }
+
+    private DateFieldMapper.DateFieldType getFieldType() {
+        assert fieldType instanceof DateFieldMapper.DateFieldType;
+        return (DateFieldMapper.DateFieldType) fieldType;
+    }
+
+    protected int getSize() {
+        return Integer.MAX_VALUE;
+    }
+
+    @Override
+    final FilterRewriteOptimizationContext.DebugInfo tryOptimize(
+        PointValues values,
+        BiConsumer<Long, Long> incrementDocCount,
+        Ranges ranges
+    ) throws IOException {
+        int size = getSize();
+
+        DateFieldMapper.DateFieldType fieldType = getFieldType();
+        BiConsumer<Integer, Integer> incrementFunc = (activeIndex, docCount) -> {
+            long rangeStart = LongPoint.decodeDimension(ranges.lowers[activeIndex], 0);
+            rangeStart = fieldType.convertNanosToMillis(rangeStart);
+            long bucketOrd = getBucketOrd(bucketOrdProducer().apply(rangeStart));
+            incrementDocCount.accept(bucketOrd, (long) docCount);
+        };
+
+        return multiRangesTraverse(values.getPointTree(), ranges, incrementFunc, size);
+    }
+
+    private static long getBucketOrd(long bucketOrd) {
+        if (bucketOrd < 0) { // already seen
+            bucketOrd = -1 - bucketOrd;
+        }
+
+        return bucketOrd;
+    }
+
+    /**
+    * Provides a function to produce bucket ordinals from the lower bound of the range
+    */
+    protected abstract Function<Long, Long> bucketOrdProducer();
+
+    /**
+     * Checks whether the top level query matches all documents on the segment
+     *
+     * <p>This method creates a weight from the search context's query and checks whether the weight's
+     * document count matches the total number of documents in the leaf reader context.
+     *
+     * @param ctx      the search context
+     * @param leafCtx  the leaf reader context for the segment
+     * @return {@code true} if the segment matches all documents, {@code false} otherwise
+     */
+    public static boolean segmentMatchAll(SearchContext ctx, LeafReaderContext leafCtx) throws IOException {
+        Weight weight = ctx.query().rewrite(ctx.searcher()).createWeight(ctx.searcher(), ScoreMode.COMPLETE_NO_SCORES, 1f);
+        return weight != null && weight.count(leafCtx) == leafCtx.reader().numDocs();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/FilterRewriteOptimizationContext.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/FilterRewriteOptimizationContext.java
new file mode 100644
index 0000000000000..87faafe4526de
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/FilterRewriteOptimizationContext.java
@@ -0,0 +1,189 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.filterrewrite;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.NumericDocValues;
+import org.apache.lucene.index.PointValues;
+import org.opensearch.index.mapper.DocCountFieldMapper;
+import org.opensearch.search.internal.SearchContext;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.BiConsumer;
+
+import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;
+
+/**
+ * Context object for doing the filter rewrite optimization in ranges type aggregation
+ * <p>
+ * This holds the common business logic and delegate aggregator-specific logic to {@link AggregatorBridge}
+ *
+ * @opensearch.internal
+ */
+public final class FilterRewriteOptimizationContext {
+
+    private static final Logger logger = LogManager.getLogger(Helper.loggerName);
+
+    private final boolean canOptimize;
+    private boolean preparedAtShardLevel = false;
+
+    private final AggregatorBridge aggregatorBridge;
+    private String shardId;
+
+    private Ranges ranges; // built at shard level
+
+    // debug info related fields
+    private final AtomicInteger leafNodeVisited = new AtomicInteger();
+    private final AtomicInteger innerNodeVisited = new AtomicInteger();
+    private final AtomicInteger segments = new AtomicInteger();
+    private final AtomicInteger optimizedSegments = new AtomicInteger();
+
+    public FilterRewriteOptimizationContext(
+        AggregatorBridge aggregatorBridge,
+        final Object parent,
+        final int subAggLength,
+        SearchContext context
+    ) throws IOException {
+        this.aggregatorBridge = aggregatorBridge;
+        this.canOptimize = this.canOptimize(parent, subAggLength, context);
+    }
+
+    /**
+     * common logic for checking whether the optimization can be applied and prepare at shard level
+     * if the aggregation has any special logic, it should be done using {@link AggregatorBridge}
+     */
+    private boolean canOptimize(final Object parent, final int subAggLength, SearchContext context) throws IOException {
+        if (context.maxAggRewriteFilters() == 0) return false;
+
+        if (parent != null || subAggLength != 0) return false;
+
+        boolean canOptimize = aggregatorBridge.canOptimize();
+        if (canOptimize) {
+            aggregatorBridge.setRangesConsumer(this::setRanges);
+
+            this.shardId = context.indexShard().shardId().toString();
+
+            assert ranges == null : "Ranges should only be built once at shard level, but they are already built";
+            aggregatorBridge.prepare();
+            if (ranges != null) {
+                preparedAtShardLevel = true;
+            }
+        }
+        logger.debug("Fast filter rewriteable: {} for shard {}", canOptimize, shardId);
+
+        return canOptimize;
+    }
+
+    void setRanges(Ranges ranges) {
+        this.ranges = ranges;
+    }
+
+    /**
+     * Try to populate the bucket doc counts for aggregation
+     * <p>
+     * Usage: invoked at segment level — in getLeafCollector of aggregator
+     *
+     * @param incrementDocCount consume the doc_count results for certain ordinal
+     * @param segmentMatchAll if your optimization can prepareFromSegment, you should pass in this flag to decide whether to prepareFromSegment
+     */
+    public boolean tryOptimize(final LeafReaderContext leafCtx, final BiConsumer<Long, Long> incrementDocCount, boolean segmentMatchAll)
+        throws IOException {
+        segments.incrementAndGet();
+        if (!canOptimize) {
+            return false;
+        }
+
+        if (leafCtx.reader().hasDeletions()) return false;
+
+        PointValues values = leafCtx.reader().getPointValues(aggregatorBridge.fieldType.name());
+        if (values == null) return false;
+        // only proceed if every document corresponds to exactly one point
+        if (values.getDocCount() != values.size()) return false;
+
+        NumericDocValues docCountValues = DocValues.getNumeric(leafCtx.reader(), DocCountFieldMapper.NAME);
+        if (docCountValues.nextDoc() != NO_MORE_DOCS) {
+            logger.debug(
+                "Shard {} segment {} has at least one document with _doc_count field, skip fast filter optimization",
+                shardId,
+                leafCtx.ord
+            );
+            return false;
+        }
+
+        Ranges ranges = getRanges(leafCtx, segmentMatchAll);
+        if (ranges == null) return false;
+
+        consumeDebugInfo(aggregatorBridge.tryOptimize(values, incrementDocCount, ranges));
+
+        optimizedSegments.incrementAndGet();
+        logger.debug("Fast filter optimization applied to shard {} segment {}", shardId, leafCtx.ord);
+        logger.debug("Crossed leaf nodes: {}, inner nodes: {}", leafNodeVisited, innerNodeVisited);
+
+        return true;
+    }
+
+    Ranges getRanges(LeafReaderContext leafCtx, boolean segmentMatchAll) {
+        if (!preparedAtShardLevel) {
+            try {
+                return getRangesFromSegment(leafCtx, segmentMatchAll);
+            } catch (IOException e) {
+                logger.warn("Failed to build ranges from segment.", e);
+                return null;
+            }
+        }
+        return ranges;
+    }
+
+    /**
+     * Even when ranges cannot be built at shard level, we can still build ranges
+     * at segment level when it's functionally match-all at segment level
+     */
+    private Ranges getRangesFromSegment(LeafReaderContext leafCtx, boolean segmentMatchAll) throws IOException {
+        if (!segmentMatchAll) {
+            return null;
+        }
+
+        logger.debug("Shard {} segment {} functionally match all documents. Build the fast filter", shardId, leafCtx.ord);
+        return aggregatorBridge.tryBuildRangesFromSegment(leafCtx);
+    }
+
+    /**
+     * Contains debug info of BKD traversal to show in profile
+     */
+    static class DebugInfo {
+        private final AtomicInteger leafNodeVisited = new AtomicInteger(); // leaf node visited
+        private final AtomicInteger innerNodeVisited = new AtomicInteger(); // inner node visited
+
+        void visitLeaf() {
+            leafNodeVisited.incrementAndGet();
+        }
+
+        void visitInner() {
+            innerNodeVisited.incrementAndGet();
+        }
+    }
+
+    void consumeDebugInfo(DebugInfo debug) {
+        leafNodeVisited.addAndGet(debug.leafNodeVisited.get());
+        innerNodeVisited.addAndGet(debug.innerNodeVisited.get());
+    }
+
+    public void populateDebugInfo(BiConsumer<String, Object> add) {
+        if (optimizedSegments.get() > 0) {
+            add.accept("optimized_segments", optimizedSegments.get());
+            add.accept("unoptimized_segments", segments.get() - optimizedSegments.get());
+            add.accept("leaf_visited", leafNodeVisited.get());
+            add.accept("inner_visited", innerNodeVisited.get());
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/Helper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/Helper.java
new file mode 100644
index 0000000000000..17da7e5712be8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/Helper.java
@@ -0,0 +1,215 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.filterrewrite;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.PointValues;
+import org.apache.lucene.search.ConstantScoreQuery;
+import org.apache.lucene.search.FieldExistsQuery;
+import org.apache.lucene.search.IndexOrDocValuesQuery;
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.apache.lucene.search.PointRangeQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.common.Rounding;
+import org.opensearch.common.lucene.search.function.FunctionScoreQuery;
+import org.opensearch.index.mapper.DateFieldMapper;
+import org.opensearch.index.query.DateRangeIncludingNowQuery;
+import org.opensearch.search.approximate.ApproximateIndexOrDocValuesQuery;
+import org.opensearch.search.internal.SearchContext;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+import static org.opensearch.index.mapper.NumberFieldMapper.NumberType.LONG;
+
+/**
+ * Utility class to help range filters rewrite optimization
+ *
+ * @opensearch.internal
+ */
+final class Helper {
+
+    private Helper() {}
+
+    static final String loggerName = Helper.class.getPackageName();
+    private static final Logger logger = LogManager.getLogger(loggerName);
+
+    private static final Map<Class<?>, Function<Query, Query>> queryWrappers;
+
+    // Initialize the wrapper map for unwrapping the query
+    static {
+        queryWrappers = new HashMap<>();
+        queryWrappers.put(ConstantScoreQuery.class, q -> ((ConstantScoreQuery) q).getQuery());
+        queryWrappers.put(FunctionScoreQuery.class, q -> ((FunctionScoreQuery) q).getSubQuery());
+        queryWrappers.put(DateRangeIncludingNowQuery.class, q -> ((DateRangeIncludingNowQuery) q).getQuery());
+        queryWrappers.put(IndexOrDocValuesQuery.class, q -> ((IndexOrDocValuesQuery) q).getIndexQuery());
+        queryWrappers.put(ApproximateIndexOrDocValuesQuery.class, q -> ((ApproximateIndexOrDocValuesQuery) q).getOriginalQuery());
+    }
+
+    /**
+     * Recursively unwraps query into the concrete form
+     * for applying the optimization
+     */
+    private static Query unwrapIntoConcreteQuery(Query query) {
+        while (queryWrappers.containsKey(query.getClass())) {
+            query = queryWrappers.get(query.getClass()).apply(query);
+        }
+
+        return query;
+    }
+
+    /**
+     * Finds the global min and max bounds of the field for the shard across all segments
+     *
+     * @return null if the field is empty or not indexed
+     */
+    private static long[] getShardBounds(final List<LeafReaderContext> leaves, final String fieldName) throws IOException {
+        long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+        for (LeafReaderContext leaf : leaves) {
+            final PointValues values = leaf.reader().getPointValues(fieldName);
+            if (values != null) {
+                min = Math.min(min, NumericUtils.sortableBytesToLong(values.getMinPackedValue(), 0));
+                max = Math.max(max, NumericUtils.sortableBytesToLong(values.getMaxPackedValue(), 0));
+            }
+        }
+
+        if (min == Long.MAX_VALUE || max == Long.MIN_VALUE) {
+            return null;
+        }
+        return new long[] { min, max };
+    }
+
+    /**
+     * Finds the min and max bounds of the field for the segment
+     *
+     * @return null if the field is empty or not indexed
+     */
+    static long[] getSegmentBounds(final LeafReaderContext context, final String fieldName) throws IOException {
+        long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+        final PointValues values = context.reader().getPointValues(fieldName);
+        if (values != null) {
+            min = Math.min(min, NumericUtils.sortableBytesToLong(values.getMinPackedValue(), 0));
+            max = Math.max(max, NumericUtils.sortableBytesToLong(values.getMaxPackedValue(), 0));
+        }
+
+        if (min == Long.MAX_VALUE || max == Long.MIN_VALUE) {
+            return null;
+        }
+        return new long[] { min, max };
+    }
+
+    /**
+     * Gets the min and max bounds of the field for the shard search
+     * Depending on the query part, the bounds are computed differently
+     *
+     * @return null if the processed query not supported by the optimization
+     */
+    public static long[] getDateHistoAggBounds(final SearchContext context, final String fieldName) throws IOException {
+        final Query cq = unwrapIntoConcreteQuery(context.query());
+        final List<LeafReaderContext> leaves = context.searcher().getIndexReader().leaves();
+
+        if (cq instanceof PointRangeQuery) {
+            final PointRangeQuery prq = (PointRangeQuery) cq;
+            final long[] indexBounds = getShardBounds(leaves, fieldName);
+            if (indexBounds == null) return null;
+            return getBoundsWithRangeQuery(prq, fieldName, indexBounds);
+        } else if (cq instanceof MatchAllDocsQuery) {
+            return getShardBounds(leaves, fieldName);
+        } else if (cq instanceof FieldExistsQuery) {
+            // when a range query covers all values of a shard, it will be rewrite field exists query
+            if (((FieldExistsQuery) cq).getField().equals(fieldName)) {
+                return getShardBounds(leaves, fieldName);
+            }
+        }
+
+        return null;
+    }
+
+    private static long[] getBoundsWithRangeQuery(PointRangeQuery prq, String fieldName, long[] indexBounds) {
+        // Ensure that the query and aggregation are on the same field
+        if (prq.getField().equals(fieldName)) {
+            // Minimum bound for aggregation is the max between query and global
+            long lower = Math.max(NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0), indexBounds[0]);
+            // Maximum bound for aggregation is the min between query and global
+            long upper = Math.min(NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0), indexBounds[1]);
+            if (lower > upper) {
+                return null;
+            }
+            return new long[] { lower, upper };
+        }
+
+        return null;
+    }
+
+    /**
+     * Creates the date ranges from date histo aggregations using its interval,
+     * and min/max boundaries
+     */
+    static Ranges createRangesFromAgg(
+        final DateFieldMapper.DateFieldType fieldType,
+        final long interval,
+        final Rounding.Prepared preparedRounding,
+        long low,
+        final long high,
+        final int maxAggRewriteFilters
+    ) {
+        // Calculate the number of buckets using range and interval
+        long roundedLow = preparedRounding.round(fieldType.convertNanosToMillis(low));
+        long prevRounded = roundedLow;
+        int bucketCount = 0;
+        while (roundedLow <= fieldType.convertNanosToMillis(high)) {
+            bucketCount++;
+            if (bucketCount > maxAggRewriteFilters) {
+                logger.debug("Max number of range filters reached [{}], skip the optimization", maxAggRewriteFilters);
+                return null;
+            }
+            // Below rounding is needed as the interval could return in
+            // non-rounded values for something like calendar month
+            roundedLow = preparedRounding.round(roundedLow + interval);
+            if (prevRounded == roundedLow) break; // prevents getting into an infinite loop
+            prevRounded = roundedLow;
+        }
+
+        long[][] ranges = new long[bucketCount][2];
+        if (bucketCount > 0) {
+            roundedLow = preparedRounding.round(fieldType.convertNanosToMillis(low));
+
+            int i = 0;
+            while (i < bucketCount) {
+                // Calculate the lower bucket bound
+                long lower = i == 0 ? low : fieldType.convertRoundedMillisToNanos(roundedLow);
+                roundedLow = preparedRounding.round(roundedLow + interval);
+
+                // plus one on high value because upper bound is exclusive, but high value exists
+                long upper = i + 1 == bucketCount ? high + 1 : fieldType.convertRoundedMillisToNanos(roundedLow);
+
+                ranges[i][0] = lower;
+                ranges[i][1] = upper;
+                i++;
+            }
+        }
+
+        byte[][] lowers = new byte[ranges.length][];
+        byte[][] uppers = new byte[ranges.length][];
+        for (int i = 0; i < ranges.length; i++) {
+            byte[] lower = LONG.encodePoint(ranges[i][0]);
+            byte[] max = LONG.encodePoint(ranges[i][1]);
+            lowers[i] = lower;
+            uppers[i] = max;
+        }
+
+        return new Ranges(lowers, uppers);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/PointTreeTraversal.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/PointTreeTraversal.java
new file mode 100644
index 0000000000000..581ecc416f486
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/PointTreeTraversal.java
@@ -0,0 +1,223 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.filterrewrite;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.index.PointValues;
+import org.apache.lucene.search.CollectionTerminatedException;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.opensearch.common.CheckedRunnable;
+
+import java.io.IOException;
+import java.util.function.BiConsumer;
+
+import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;
+
+/**
+ * Utility class for traversing a {@link PointValues.PointTree} and collecting document counts for the ranges.
+ *
+ * <p>The main entry point is the {@link #multiRangesTraverse(PointValues.PointTree, Ranges,
+ * BiConsumer, int)} method
+ *
+ * <p>The class uses a {@link RangeCollectorForPointTree} to keep track of the active ranges and
+ * determine which parts of the tree to visit. The {@link
+ * PointValues.IntersectVisitor} implementation is responsible for the actual visitation and
+ * document count collection.
+ */
+final class PointTreeTraversal {
+    private PointTreeTraversal() {}
+
+    private static final Logger logger = LogManager.getLogger(Helper.loggerName);
+
+    /**
+     * Traverses the given {@link PointValues.PointTree} and collects document counts for the intersecting ranges.
+     *
+     * @param tree                 the point tree to traverse
+     * @param ranges               the set of ranges to intersect with
+     * @param incrementDocCount    a callback to increment the document count for a range bucket
+     * @param maxNumNonZeroRanges  the maximum number of non-zero ranges to collect
+     * @return a {@link FilterRewriteOptimizationContext.DebugInfo} object containing debug information about the traversal
+     */
+    static FilterRewriteOptimizationContext.DebugInfo multiRangesTraverse(
+        final PointValues.PointTree tree,
+        final Ranges ranges,
+        final BiConsumer<Integer, Integer> incrementDocCount,
+        final int maxNumNonZeroRanges
+    ) throws IOException {
+        FilterRewriteOptimizationContext.DebugInfo debugInfo = new FilterRewriteOptimizationContext.DebugInfo();
+        int activeIndex = ranges.firstRangeIndex(tree.getMinPackedValue(), tree.getMaxPackedValue());
+        if (activeIndex < 0) {
+            logger.debug("No ranges match the query, skip the fast filter optimization");
+            return debugInfo;
+        }
+        RangeCollectorForPointTree collector = new RangeCollectorForPointTree(incrementDocCount, maxNumNonZeroRanges, ranges, activeIndex);
+        PointValues.IntersectVisitor visitor = getIntersectVisitor(collector);
+        try {
+            intersectWithRanges(visitor, tree, collector, debugInfo);
+        } catch (CollectionTerminatedException e) {
+            logger.debug("Early terminate since no more range to collect");
+        }
+        collector.finalizePreviousRange();
+
+        return debugInfo;
+    }
+
+    private static void intersectWithRanges(
+        PointValues.IntersectVisitor visitor,
+        PointValues.PointTree pointTree,
+        RangeCollectorForPointTree collector,
+        FilterRewriteOptimizationContext.DebugInfo debug
+    ) throws IOException {
+        PointValues.Relation r = visitor.compare(pointTree.getMinPackedValue(), pointTree.getMaxPackedValue());
+
+        switch (r) {
+            case CELL_INSIDE_QUERY:
+                collector.countNode((int) pointTree.size());
+                debug.visitInner();
+                break;
+            case CELL_CROSSES_QUERY:
+                if (pointTree.moveToChild()) {
+                    do {
+                        intersectWithRanges(visitor, pointTree, collector, debug);
+                    } while (pointTree.moveToSibling());
+                    pointTree.moveToParent();
+                } else {
+                    pointTree.visitDocValues(visitor);
+                    debug.visitLeaf();
+                }
+                break;
+            case CELL_OUTSIDE_QUERY:
+        }
+    }
+
+    private static PointValues.IntersectVisitor getIntersectVisitor(RangeCollectorForPointTree collector) {
+        return new PointValues.IntersectVisitor() {
+            @Override
+            public void visit(int docID) {
+                // this branch should be unreachable
+                throw new UnsupportedOperationException(
+                    "This IntersectVisitor does not perform any actions on a " + "docID=" + docID + " node being visited"
+                );
+            }
+
+            @Override
+            public void visit(int docID, byte[] packedValue) throws IOException {
+                visitPoints(packedValue, collector::count);
+            }
+
+            @Override
+            public void visit(DocIdSetIterator iterator, byte[] packedValue) throws IOException {
+                visitPoints(packedValue, () -> {
+                    for (int doc = iterator.nextDoc(); doc != NO_MORE_DOCS; doc = iterator.nextDoc()) {
+                        collector.count();
+                    }
+                });
+            }
+
+            private void visitPoints(byte[] packedValue, CheckedRunnable<IOException> collect) throws IOException {
+                if (!collector.withinUpperBound(packedValue)) {
+                    collector.finalizePreviousRange();
+                    if (collector.iterateRangeEnd(packedValue)) {
+                        throw new CollectionTerminatedException();
+                    }
+                }
+
+                if (collector.withinRange(packedValue)) {
+                    collect.run();
+                }
+            }
+
+            @Override
+            public PointValues.Relation compare(byte[] minPackedValue, byte[] maxPackedValue) {
+                // try to find the first range that may collect values from this cell
+                if (!collector.withinUpperBound(minPackedValue)) {
+                    collector.finalizePreviousRange();
+                    if (collector.iterateRangeEnd(minPackedValue)) {
+                        throw new CollectionTerminatedException();
+                    }
+                }
+                // after the loop, min < upper
+                // cell could be outside [min max] lower
+                if (!collector.withinLowerBound(maxPackedValue)) {
+                    return PointValues.Relation.CELL_OUTSIDE_QUERY;
+                }
+                if (collector.withinRange(minPackedValue) && collector.withinRange(maxPackedValue)) {
+                    return PointValues.Relation.CELL_INSIDE_QUERY;
+                }
+                return PointValues.Relation.CELL_CROSSES_QUERY;
+            }
+        };
+    }
+
+    private static class RangeCollectorForPointTree {
+        private final BiConsumer<Integer, Integer> incrementRangeDocCount;
+        private int counter = 0;
+
+        private final Ranges ranges;
+        private int activeIndex;
+
+        private int visitedRange = 0;
+        private final int maxNumNonZeroRange;
+
+        public RangeCollectorForPointTree(
+            BiConsumer<Integer, Integer> incrementRangeDocCount,
+            int maxNumNonZeroRange,
+            Ranges ranges,
+            int activeIndex
+        ) {
+            this.incrementRangeDocCount = incrementRangeDocCount;
+            this.maxNumNonZeroRange = maxNumNonZeroRange;
+            this.ranges = ranges;
+            this.activeIndex = activeIndex;
+        }
+
+        private void count() {
+            counter++;
+        }
+
+        private void countNode(int count) {
+            counter += count;
+        }
+
+        private void finalizePreviousRange() {
+            if (counter > 0) {
+                incrementRangeDocCount.accept(activeIndex, counter);
+                counter = 0;
+            }
+        }
+
+        /**
+         * @return true when iterator exhausted or collect enough non-zero ranges
+         */
+        private boolean iterateRangeEnd(byte[] value) {
+            // the new value may not be contiguous to the previous one
+            // so try to find the first next range that cross the new value
+            while (!withinUpperBound(value)) {
+                if (++activeIndex >= ranges.size) {
+                    return true;
+                }
+            }
+            visitedRange++;
+            return visitedRange > maxNumNonZeroRange;
+        }
+
+        private boolean withinLowerBound(byte[] value) {
+            return Ranges.withinLowerBound(value, ranges.lowers[activeIndex]);
+        }
+
+        private boolean withinUpperBound(byte[] value) {
+            return Ranges.withinUpperBound(value, ranges.uppers[activeIndex]);
+        }
+
+        private boolean withinRange(byte[] value) {
+            return withinLowerBound(value) && withinUpperBound(value);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/RangeAggregatorBridge.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/RangeAggregatorBridge.java
new file mode 100644
index 0000000000000..b590a444c8b04
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/RangeAggregatorBridge.java
@@ -0,0 +1,96 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.filterrewrite;
+
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.PointValues;
+import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.index.mapper.NumericPointEncoder;
+import org.opensearch.search.aggregations.bucket.range.RangeAggregator;
+import org.opensearch.search.aggregations.support.ValuesSource;
+import org.opensearch.search.aggregations.support.ValuesSourceConfig;
+
+import java.io.IOException;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+import static org.opensearch.search.aggregations.bucket.filterrewrite.PointTreeTraversal.multiRangesTraverse;
+
+/**
+ * For range aggregation
+ */
+public abstract class RangeAggregatorBridge extends AggregatorBridge {
+
+    protected boolean canOptimize(ValuesSourceConfig config, RangeAggregator.Range[] ranges) {
+        if (config.fieldType() == null) return false;
+        MappedFieldType fieldType = config.fieldType();
+        assert fieldType != null;
+        if (fieldType.isSearchable() == false || !(fieldType instanceof NumericPointEncoder)) return false;
+
+        if (config.script() == null && config.missing() == null) {
+            if (config.getValuesSource() instanceof ValuesSource.Numeric.FieldData) {
+                // ranges are already sorted by from and then to
+                // we want ranges not overlapping with each other
+                double prevTo = ranges[0].getTo();
+                for (int i = 1; i < ranges.length; i++) {
+                    if (prevTo > ranges[i].getFrom()) {
+                        return false;
+                    }
+                    prevTo = ranges[i].getTo();
+                }
+                this.fieldType = config.fieldType();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected void buildRanges(RangeAggregator.Range[] ranges) {
+        assert fieldType instanceof NumericPointEncoder;
+        NumericPointEncoder numericPointEncoder = (NumericPointEncoder) fieldType;
+        byte[][] lowers = new byte[ranges.length][];
+        byte[][] uppers = new byte[ranges.length][];
+        for (int i = 0; i < ranges.length; i++) {
+            double rangeMin = ranges[i].getFrom();
+            double rangeMax = ranges[i].getTo();
+            byte[] lower = numericPointEncoder.encodePoint(rangeMin);
+            byte[] upper = numericPointEncoder.encodePoint(rangeMax);
+            lowers[i] = lower;
+            uppers[i] = upper;
+        }
+
+        setRanges.accept(new Ranges(lowers, uppers));
+    }
+
+    @Override
+    final Ranges tryBuildRangesFromSegment(LeafReaderContext leaf) {
+        throw new UnsupportedOperationException("Range aggregation should not build ranges at segment level");
+    }
+
+    @Override
+    final FilterRewriteOptimizationContext.DebugInfo tryOptimize(
+        PointValues values,
+        BiConsumer<Long, Long> incrementDocCount,
+        Ranges ranges
+    ) throws IOException {
+        int size = Integer.MAX_VALUE;
+
+        BiConsumer<Integer, Integer> incrementFunc = (activeIndex, docCount) -> {
+            long bucketOrd = bucketOrdProducer().apply(activeIndex);
+            incrementDocCount.accept(bucketOrd, (long) docCount);
+        };
+
+        return multiRangesTraverse(values.getPointTree(), ranges, incrementFunc, size);
+    }
+
+    /**
+     * Provides a function to produce bucket ordinals from index of the corresponding range in the range array
+     */
+    protected abstract Function<Object, Long> bucketOrdProducer();
+}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/Ranges.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/Ranges.java
new file mode 100644
index 0000000000000..2819778ce215b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/Ranges.java
@@ -0,0 +1,57 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.filterrewrite;
+
+import org.apache.lucene.util.ArrayUtil;
+
+/**
+ * Internal ranges representation for the filter rewrite optimization
+ */
+final class Ranges {
+    byte[][] lowers; // inclusive
+    byte[][] uppers; // exclusive
+    int size;
+    int byteLen;
+    static ArrayUtil.ByteArrayComparator comparator;
+
+    Ranges(byte[][] lowers, byte[][] uppers) {
+        this.lowers = lowers;
+        this.uppers = uppers;
+        assert lowers.length == uppers.length;
+        this.size = lowers.length;
+        this.byteLen = lowers[0].length;
+        comparator = ArrayUtil.getUnsignedComparator(byteLen);
+    }
+
+    public int firstRangeIndex(byte[] globalMin, byte[] globalMax) {
+        if (compareByteValue(lowers[0], globalMax) > 0) {
+            return -1;
+        }
+        int i = 0;
+        while (compareByteValue(uppers[i], globalMin) <= 0) {
+            i++;
+            if (i >= size) {
+                return -1;
+            }
+        }
+        return i;
+    }
+
+    public static int compareByteValue(byte[] value1, byte[] value2) {
+        return comparator.compare(value1, 0, value2, 0);
+    }
+
+    public static boolean withinLowerBound(byte[] value, byte[] lowerBound) {
+        return compareByteValue(value, lowerBound) >= 0;
+    }
+
+    public static boolean withinUpperBound(byte[] value, byte[] upperBound) {
+        return compareByteValue(value, upperBound) < 0;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/package-info.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/package-info.java
new file mode 100644
index 0000000000000..bbd0a8db6cbb6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/filterrewrite/package-info.java
@@ -0,0 +1,19 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * This package contains filter rewrite optimization for range-type aggregations
+ * <p>
+ * The idea is to
+ * <ul>
+ * <li> figure out the "ranges" from the aggregation </li>
+ * <li> leverage the ranges and bkd index to get the result of each range bucket quickly </li>
+ * </ul>
+ * More details in https://github.com/opensearch-project/OpenSearch/pull/14464
+ */
+package org.opensearch.search.aggregations.bucket.filterrewrite;
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
index f326426800909..f3a36b4882d19 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
@@ -42,7 +42,6 @@
 import org.opensearch.common.util.IntArray;
 import org.opensearch.common.util.LongArray;
 import org.opensearch.core.common.util.ByteArray;
-import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -53,8 +52,9 @@
 import org.opensearch.search.aggregations.LeafBucketCollectorBase;
 import org.opensearch.search.aggregations.bucket.DeferableBucketAggregator;
 import org.opensearch.search.aggregations.bucket.DeferringBucketCollector;
-import org.opensearch.search.aggregations.bucket.FastFilterRewriteHelper;
 import org.opensearch.search.aggregations.bucket.MergingBucketsDeferringCollector;
+import org.opensearch.search.aggregations.bucket.filterrewrite.DateHistogramAggregatorBridge;
+import org.opensearch.search.aggregations.bucket.filterrewrite.FilterRewriteOptimizationContext;
 import org.opensearch.search.aggregations.bucket.histogram.AutoDateHistogramAggregationBuilder.RoundingInfo;
 import org.opensearch.search.aggregations.bucket.terms.LongKeyedBucketOrds;
 import org.opensearch.search.aggregations.support.ValuesSource;
@@ -68,6 +68,8 @@
 import java.util.function.Function;
 import java.util.function.LongToIntFunction;
 
+import static org.opensearch.search.aggregations.bucket.filterrewrite.DateHistogramAggregatorBridge.segmentMatchAll;
+
 /**
  * An aggregator for date values that attempts to return a specific number of
  * buckets, reconfiguring how it rounds dates to buckets on the fly as new
@@ -134,7 +136,7 @@ static AutoDateHistogramAggregator build(
     protected int roundingIdx;
     protected Rounding.Prepared preparedRounding;
 
-    private final FastFilterRewriteHelper.FastFilterContext fastFilterContext;
+    private final FilterRewriteOptimizationContext filterRewriteOptimizationContext;
 
     private AutoDateHistogramAggregator(
         String name,
@@ -157,54 +159,52 @@ private AutoDateHistogramAggregator(
         this.roundingPreparer = roundingPreparer;
         this.preparedRounding = prepareRounding(0);
 
-        fastFilterContext = new FastFilterRewriteHelper.FastFilterContext(context);
-        fastFilterContext.setAggregationType(
-            new AutoHistogramAggregationType(
-                valuesSourceConfig.fieldType(),
-                valuesSourceConfig.missing() != null,
-                valuesSourceConfig.script() != null
-            )
-        );
-        if (fastFilterContext.isRewriteable(parent, subAggregators.length)) {
-            fastFilterContext.setFieldName(valuesSourceConfig.fieldType().name());
-            fastFilterContext.buildRanges();
-        }
-    }
-
-    private class AutoHistogramAggregationType extends FastFilterRewriteHelper.AbstractDateHistogramAggregationType {
+        DateHistogramAggregatorBridge bridge = new DateHistogramAggregatorBridge() {
+            @Override
+            protected boolean canOptimize() {
+                return canOptimize(valuesSourceConfig);
+            }
 
-        public AutoHistogramAggregationType(MappedFieldType fieldType, boolean missing, boolean hasScript) {
-            super(fieldType, missing, hasScript);
-        }
+            @Override
+            protected void prepare() throws IOException {
+                buildRanges(context);
+            }
 
-        @Override
-        protected Rounding getRounding(final long low, final long high) {
-            // max - min / targetBuckets = bestDuration
-            // find the right innerInterval this bestDuration belongs to
-            // since we cannot exceed targetBuckets, bestDuration should go up,
-            // so the right innerInterval should be an upper bound
-            long bestDuration = (high - low) / targetBuckets;
-            // reset so this function is idempotent
-            roundingIdx = 0;
-            while (roundingIdx < roundingInfos.length - 1) {
-                final RoundingInfo curRoundingInfo = roundingInfos[roundingIdx];
-                final int temp = curRoundingInfo.innerIntervals[curRoundingInfo.innerIntervals.length - 1];
-                // If the interval duration is covered by the maximum inner interval,
-                // we can start with this outer interval for creating the buckets
-                if (bestDuration <= temp * curRoundingInfo.roughEstimateDurationMillis) {
-                    break;
+            @Override
+            protected Rounding getRounding(final long low, final long high) {
+                // max - min / targetBuckets = bestDuration
+                // find the right innerInterval this bestDuration belongs to
+                // since we cannot exceed targetBuckets, bestDuration should go up,
+                // so the right innerInterval should be an upper bound
+                long bestDuration = (high - low) / targetBuckets;
+                // reset so this function is idempotent
+                roundingIdx = 0;
+                while (roundingIdx < roundingInfos.length - 1) {
+                    final RoundingInfo curRoundingInfo = roundingInfos[roundingIdx];
+                    final int temp = curRoundingInfo.innerIntervals[curRoundingInfo.innerIntervals.length - 1];
+                    // If the interval duration is covered by the maximum inner interval,
+                    // we can start with this outer interval for creating the buckets
+                    if (bestDuration <= temp * curRoundingInfo.roughEstimateDurationMillis) {
+                        break;
+                    }
+                    roundingIdx++;
                 }
-                roundingIdx++;
+
+                preparedRounding = prepareRounding(roundingIdx);
+                return roundingInfos[roundingIdx].rounding;
             }
 
-            preparedRounding = prepareRounding(roundingIdx);
-            return roundingInfos[roundingIdx].rounding;
-        }
+            @Override
+            protected Prepared getRoundingPrepared() {
+                return preparedRounding;
+            }
 
-        @Override
-        protected Prepared getRoundingPrepared() {
-            return preparedRounding;
-        }
+            @Override
+            protected Function<Long, Long> bucketOrdProducer() {
+                return (key) -> getBucketOrds().add(0, preparedRounding.round((long) key));
+            }
+        };
+        filterRewriteOptimizationContext = new FilterRewriteOptimizationContext(bridge, parent, subAggregators.length, context);
     }
 
     protected abstract LongKeyedBucketOrds getBucketOrds();
@@ -236,14 +236,7 @@ public final LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBuc
             return LeafBucketCollector.NO_OP_COLLECTOR;
         }
 
-        boolean optimized = FastFilterRewriteHelper.tryFastFilterAggregation(
-            ctx,
-            fastFilterContext,
-            (key, count) -> incrementBucketDocCount(
-                FastFilterRewriteHelper.getBucketOrd(getBucketOrds().add(0, preparedRounding.round(key))),
-                count
-            )
-        );
+        boolean optimized = filterRewriteOptimizationContext.tryOptimize(ctx, this::incrementBucketDocCount, segmentMatchAll(context, ctx));
         if (optimized) throw new CollectionTerminatedException();
 
         final SortedNumericDocValues values = valuesSource.longValues(ctx);
@@ -311,12 +304,7 @@ protected final void merge(long[] mergeMap, long newNumBuckets) {
     @Override
     public void collectDebugInfo(BiConsumer<String, Object> add) {
         super.collectDebugInfo(add);
-        if (fastFilterContext.optimizedSegments > 0) {
-            add.accept("optimized_segments", fastFilterContext.optimizedSegments);
-            add.accept("unoptimized_segments", fastFilterContext.segments - fastFilterContext.optimizedSegments);
-            add.accept("leaf_visited", fastFilterContext.leaf);
-            add.accept("inner_visited", fastFilterContext.inner);
-        }
+        filterRewriteOptimizationContext.populateDebugInfo(add);
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index dd4ee9196fd62..96a49bc3fd5f6 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -39,7 +39,6 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.lease.Releasables;
-import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -49,7 +48,8 @@
 import org.opensearch.search.aggregations.LeafBucketCollector;
 import org.opensearch.search.aggregations.LeafBucketCollectorBase;
 import org.opensearch.search.aggregations.bucket.BucketsAggregator;
-import org.opensearch.search.aggregations.bucket.FastFilterRewriteHelper;
+import org.opensearch.search.aggregations.bucket.filterrewrite.DateHistogramAggregatorBridge;
+import org.opensearch.search.aggregations.bucket.filterrewrite.FilterRewriteOptimizationContext;
 import org.opensearch.search.aggregations.bucket.terms.LongKeyedBucketOrds;
 import org.opensearch.search.aggregations.support.ValuesSource;
 import org.opensearch.search.aggregations.support.ValuesSourceConfig;
@@ -59,6 +59,9 @@
 import java.util.Collections;
 import java.util.Map;
 import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+import static org.opensearch.search.aggregations.bucket.filterrewrite.DateHistogramAggregatorBridge.segmentMatchAll;
 
 /**
  * An aggregator for date values. Every date is rounded down using a configured
@@ -83,7 +86,7 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
     private final LongBounds hardBounds;
     private final LongKeyedBucketOrds bucketOrds;
 
-    private final FastFilterRewriteHelper.FastFilterContext fastFilterContext;
+    private final FilterRewriteOptimizationContext filterRewriteOptimizationContext;
 
     DateHistogramAggregator(
         String name,
@@ -116,36 +119,38 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
 
         bucketOrds = LongKeyedBucketOrds.build(context.bigArrays(), cardinality);
 
-        fastFilterContext = new FastFilterRewriteHelper.FastFilterContext(context);
-        fastFilterContext.setAggregationType(
-            new DateHistogramAggregationType(
-                valuesSourceConfig.fieldType(),
-                valuesSourceConfig.missing() != null,
-                valuesSourceConfig.script() != null,
-                hardBounds
-            )
-        );
-        if (fastFilterContext.isRewriteable(parent, subAggregators.length)) {
-            fastFilterContext.setFieldName(valuesSourceConfig.fieldType().name());
-            fastFilterContext.buildRanges();
-        }
-    }
+        DateHistogramAggregatorBridge bridge = new DateHistogramAggregatorBridge() {
+            @Override
+            protected boolean canOptimize() {
+                return canOptimize(valuesSourceConfig);
+            }
 
-    private class DateHistogramAggregationType extends FastFilterRewriteHelper.AbstractDateHistogramAggregationType {
+            @Override
+            protected void prepare() throws IOException {
+                buildRanges(context);
+            }
 
-        public DateHistogramAggregationType(MappedFieldType fieldType, boolean missing, boolean hasScript, LongBounds hardBounds) {
-            super(fieldType, missing, hasScript, hardBounds);
-        }
+            @Override
+            protected Rounding getRounding(long low, long high) {
+                return rounding;
+            }
 
-        @Override
-        protected Rounding getRounding(long low, long high) {
-            return rounding;
-        }
+            @Override
+            protected Rounding.Prepared getRoundingPrepared() {
+                return preparedRounding;
+            }
 
-        @Override
-        protected Rounding.Prepared getRoundingPrepared() {
-            return preparedRounding;
-        }
+            @Override
+            protected long[] processHardBounds(long[] bounds) {
+                return super.processHardBounds(bounds, hardBounds);
+            }
+
+            @Override
+            protected Function<Long, Long> bucketOrdProducer() {
+                return (key) -> bucketOrds.add(0, preparedRounding.round((long) key));
+            }
+        };
+        filterRewriteOptimizationContext = new FilterRewriteOptimizationContext(bridge, parent, subAggregators.length, context);
     }
 
     @Override
@@ -162,14 +167,7 @@ public LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBucketCol
             return LeafBucketCollector.NO_OP_COLLECTOR;
         }
 
-        boolean optimized = FastFilterRewriteHelper.tryFastFilterAggregation(
-            ctx,
-            fastFilterContext,
-            (key, count) -> incrementBucketDocCount(
-                FastFilterRewriteHelper.getBucketOrd(bucketOrds.add(0, preparedRounding.round(key))),
-                count
-            )
-        );
+        boolean optimized = filterRewriteOptimizationContext.tryOptimize(ctx, this::incrementBucketDocCount, segmentMatchAll(context, ctx));
         if (optimized) throw new CollectionTerminatedException();
 
         SortedNumericDocValues values = valuesSource.longValues(ctx);
@@ -256,12 +254,7 @@ public void doClose() {
     @Override
     public void collectDebugInfo(BiConsumer<String, Object> add) {
         add.accept("total_buckets", bucketOrds.size());
-        if (fastFilterContext.optimizedSegments > 0) {
-            add.accept("optimized_segments", fastFilterContext.optimizedSegments);
-            add.accept("unoptimized_segments", fastFilterContext.segments - fastFilterContext.optimizedSegments);
-            add.accept("leaf_visited", fastFilterContext.leaf);
-            add.accept("inner_visited", fastFilterContext.inner);
-        }
+        filterRewriteOptimizationContext.populateDebugInfo(add);
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogram.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogram.java
index a27c689127ac9..a988b911de5a3 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogram.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogram.java
@@ -395,6 +395,7 @@ private void addEmptyBuckets(List<Bucket> list, ReduceContext reduceContext) {
             // fill with empty buckets
             for (double key = round(emptyBucketInfo.minBound); key <= emptyBucketInfo.maxBound; key = nextKey(key)) {
                 iter.add(new Bucket(key, 0, keyed, format, reducedEmptySubAggs));
+                reduceContext.consumeBucketsAndMaybeBreak(0);
             }
         } else {
             Bucket first = list.get(iter.nextIndex());
@@ -402,11 +403,12 @@ private void addEmptyBuckets(List<Bucket> list, ReduceContext reduceContext) {
                 // fill with empty buckets until the first key
                 for (double key = round(emptyBucketInfo.minBound); key < first.key; key = nextKey(key)) {
                     iter.add(new Bucket(key, 0, keyed, format, reducedEmptySubAggs));
+                    reduceContext.consumeBucketsAndMaybeBreak(0);
                 }
             }
 
             // now adding the empty buckets within the actual data,
-            // e.g. if the data series is [1,2,3,7] there're 3 empty buckets that will be created for 4,5,6
+            // e.g. if the data series is [1,2,3,7] there are 3 empty buckets that will be created for 4,5,6
             Bucket lastBucket = null;
             do {
                 Bucket nextBucket = list.get(iter.nextIndex());
@@ -414,6 +416,7 @@ private void addEmptyBuckets(List<Bucket> list, ReduceContext reduceContext) {
                     double key = nextKey(lastBucket.key);
                     while (key < nextBucket.key) {
                         iter.add(new Bucket(key, 0, keyed, format, reducedEmptySubAggs));
+                        reduceContext.consumeBucketsAndMaybeBreak(0);
                         key = nextKey(key);
                     }
                     assert key == nextBucket.key || Double.isNaN(nextBucket.key) : "key: " + key + ", nextBucket.key: " + nextBucket.key;
@@ -424,6 +427,7 @@ private void addEmptyBuckets(List<Bucket> list, ReduceContext reduceContext) {
             // finally, adding the empty buckets *after* the actual data (based on the extended_bounds.max requested by the user)
             for (double key = nextKey(lastBucket.key); key <= emptyBucketInfo.maxBound; key = nextKey(key)) {
                 iter.add(new Bucket(key, 0, keyed, format, reducedEmptySubAggs));
+                reduceContext.consumeBucketsAndMaybeBreak(0);
             }
         }
     }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/nested/NestedAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/nested/NestedAggregator.java
index cfa1d32a52501..150efa878f866 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/nested/NestedAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/nested/NestedAggregator.java
@@ -43,8 +43,10 @@
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.search.join.BitSetProducer;
 import org.apache.lucene.util.BitSet;
+import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.lucene.search.Queries;
 import org.opensearch.core.ParseField;
+import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.mapper.ObjectMapper;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -88,12 +90,25 @@ public class NestedAggregator extends BucketsAggregator implements SingleBucketA
     ) throws IOException {
         super(name, factories, context, parent, cardinality, metadata);
 
-        Query parentFilter = parentObjectMapper != null ? parentObjectMapper.nestedTypeFilter() : Queries.newNonNestedFilter();
+        Query parentFilter = isParent(parentObjectMapper, childObjectMapper, context.mapperService())
+            ? parentObjectMapper.nestedTypeFilter()
+            : Queries.newNonNestedFilter();
         this.parentFilter = context.bitsetFilterCache().getBitSetProducer(parentFilter);
         this.childFilter = childObjectMapper.nestedTypeFilter();
         this.collectsFromSingleBucket = cardinality.map(estimate -> estimate < 2);
     }
 
+    private boolean isParent(ObjectMapper parentObjectMapper, ObjectMapper childObjectMapper, MapperService mapperService) {
+        if (parentObjectMapper == null) {
+            return false;
+        }
+        ObjectMapper parent;
+        do {
+            parent = childObjectMapper.getParentObjectMapper(mapperService);
+        } while (parent != null && parent != parentObjectMapper);
+        return parentObjectMapper == parent;
+    }
+
     @Override
     public LeafBucketCollector getLeafCollector(final LeafReaderContext ctx, final LeafBucketCollector sub) throws IOException {
         IndexReaderContext topLevelContext = ReaderUtil.getTopLevelContext(ctx);
@@ -107,20 +122,17 @@ public LeafBucketCollector getLeafCollector(final LeafReaderContext ctx, final L
         if (collectsFromSingleBucket) {
             return new LeafBucketCollectorBase(sub, null) {
                 @Override
-                public void collect(int parentDoc, long bucket) throws IOException {
-                    // if parentDoc is 0 then this means that this parent doesn't have child docs (b/c these appear always before the parent
-                    // doc), so we can skip:
-                    if (parentDoc == 0 || parentDocs == null || childDocs == null) {
+                public void collect(int parentAggDoc, long bucket) throws IOException {
+                    // parentAggDoc can be 0 when aggregation:
+                    if (parentDocs == null || childDocs == null) {
                         return;
                     }
 
-                    final int prevParentDoc = parentDocs.prevSetBit(parentDoc - 1);
-                    int childDocId = childDocs.docID();
-                    if (childDocId <= prevParentDoc) {
-                        childDocId = childDocs.advance(prevParentDoc + 1);
-                    }
+                    Tuple<Integer, Integer> res = getParentAndChildId(parentDocs, childDocs, parentAggDoc);
+                    int currentParentDoc = res.v1();
+                    int childDocId = res.v2();
 
-                    for (; childDocId < parentDoc; childDocId = childDocs.nextDoc()) {
+                    for (; childDocId < currentParentDoc; childDocId = childDocs.nextDoc()) {
                         collectBucket(sub, childDocId, bucket);
                     }
                 }
@@ -130,6 +142,43 @@ public void collect(int parentDoc, long bucket) throws IOException {
         }
     }
 
+    /**
+     * In one case, it's talking about the parent doc (from the Lucene block-join standpoint),
+     * while in the other case, it's talking about a child doc ID (from the block-join standpoint)
+     * from the parent aggregation, where we're trying to aggregate over a sibling of that child.
+     * So, we need to map from that document to its parent, then join to the appropriate sibling.
+     *
+     * @param parentAggDoc the parent aggregation's current doc
+     *                    (which may or may not be a block-level parent doc)
+     * @return a tuple consisting of the current block-level parent doc (the parent of the
+     *         parameter doc), and the next matching child doc (hopefully under this parent)
+     *         for the aggregation (according to the child doc iterator).
+     */
+    static Tuple<Integer, Integer> getParentAndChildId(BitSet parentDocs, DocIdSetIterator childDocs, int parentAggDoc) throws IOException {
+        int currentParentAggDoc;
+        int prevParentDoc = parentDocs.prevSetBit(parentAggDoc);
+        if (prevParentDoc == -1) {
+            currentParentAggDoc = parentDocs.nextSetBit(0);
+        } else if (prevParentDoc == parentAggDoc) {
+            // parentAggDoc is the parent of that child, and is belongs to parentDocs
+            currentParentAggDoc = parentAggDoc;
+            if (currentParentAggDoc == 0) {
+                prevParentDoc = -1;
+            } else {
+                prevParentDoc = parentDocs.prevSetBit(currentParentAggDoc - 1);
+            }
+        } else {
+            // parentAggDoc is the sibling of that child, and it means the block-join parent
+            currentParentAggDoc = parentDocs.nextSetBit(prevParentDoc + 1);
+        }
+
+        int childDocId = childDocs.docID();
+        if (childDocId <= prevParentDoc) {
+            childDocId = childDocs.advance(prevParentDoc + 1);
+        }
+        return Tuple.tuple(currentParentAggDoc, childDocId);
+    }
+
     @Override
     protected void preGetSubLeafCollectors(LeafReaderContext ctx) throws IOException {
         super.preGetSubLeafCollectors(ctx);
@@ -191,9 +240,8 @@ public void setScorer(Scorable scorer) throws IOException {
 
         @Override
         public void collect(int parentDoc, long bucket) throws IOException {
-            // if parentDoc is 0 then this means that this parent doesn't have child docs (b/c these appear always before the parent
-            // doc), so we can skip:
-            if (parentDoc == 0 || parentDocs == null || childDocs == null) {
+            // parentAggDoc can be 0 when aggregation:
+            if (parentDocs == null || childDocs == null) {
                 return;
             }
 
@@ -214,11 +262,9 @@ void processBufferedChildBuckets() throws IOException {
                 return;
             }
 
-            final int prevParentDoc = parentDocs.prevSetBit(currentParentDoc - 1);
-            int childDocId = childDocs.docID();
-            if (childDocId <= prevParentDoc) {
-                childDocId = childDocs.advance(prevParentDoc + 1);
-            }
+            Tuple<Integer, Integer> res = getParentAndChildId(parentDocs, childDocs, currentParentDoc);
+            int currentParentDoc = res.v1();
+            int childDocId = res.v2();
 
             for (; childDocId < currentParentDoc; childDocId = childDocs.nextDoc()) {
                 cachedScorer.doc = childDocId;
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/AbstractRangeAggregatorFactory.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/AbstractRangeAggregatorFactory.java
index 41f2768eb7544..fd334638a0c1f 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/AbstractRangeAggregatorFactory.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/AbstractRangeAggregatorFactory.java
@@ -119,7 +119,8 @@ protected Aggregator doCreateInternal(
                 searchContext,
                 parent,
                 cardinality,
-                metadata
+                metadata,
+                config
             );
     }
 
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/GeoDistanceAggregatorSupplier.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/GeoDistanceAggregatorSupplier.java
index c4a9efda18bda..d72c817c4515b 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/GeoDistanceAggregatorSupplier.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/GeoDistanceAggregatorSupplier.java
@@ -39,6 +39,7 @@
 import org.opensearch.search.aggregations.AggregatorFactories;
 import org.opensearch.search.aggregations.CardinalityUpperBound;
 import org.opensearch.search.aggregations.support.ValuesSource;
+import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
 
 import java.io.IOException;
@@ -64,6 +65,7 @@ Aggregator build(
         SearchContext context,
         Aggregator parent,
         CardinalityUpperBound cardinality,
-        Map<String, Object> metadata
+        Map<String, Object> metadata,
+        ValuesSourceConfig valuesSourceConfig
     ) throws IOException;
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/GeoDistanceRangeAggregatorFactory.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/GeoDistanceRangeAggregatorFactory.java
index 728f43094cf7e..f9e966deb3cc9 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/GeoDistanceRangeAggregatorFactory.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/GeoDistanceRangeAggregatorFactory.java
@@ -82,7 +82,8 @@ public static void registerAggregators(ValuesSourceRegistry.Builder builder) {
                 context,
                 parent,
                 cardinality,
-                metadata) -> {
+                metadata,
+                config) -> {
                 DistanceSource distanceSource = new DistanceSource((ValuesSource.GeoPoint) valuesSource, distanceType, origin, units);
                 return new RangeAggregator(
                     name,
@@ -95,7 +96,8 @@ public static void registerAggregators(ValuesSourceRegistry.Builder builder) {
                     context,
                     parent,
                     cardinality,
-                    metadata
+                    metadata,
+                    config
                 );
             },
             true
@@ -168,7 +170,8 @@ protected Aggregator doCreateInternal(
                 searchContext,
                 parent,
                 cardinality,
-                metadata
+                metadata,
+                config
             );
     }
 
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/RangeAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/RangeAggregator.java
index b56b817b8177b..39dc1c36e8895 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/RangeAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/RangeAggregator.java
@@ -32,6 +32,7 @@
 package org.opensearch.search.aggregations.bucket.range;
 
 import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.CollectionTerminatedException;
 import org.apache.lucene.search.ScoreMode;
 import org.opensearch.core.ParseField;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -54,7 +55,10 @@
 import org.opensearch.search.aggregations.LeafBucketCollectorBase;
 import org.opensearch.search.aggregations.NonCollectingAggregator;
 import org.opensearch.search.aggregations.bucket.BucketsAggregator;
+import org.opensearch.search.aggregations.bucket.filterrewrite.FilterRewriteOptimizationContext;
+import org.opensearch.search.aggregations.bucket.filterrewrite.RangeAggregatorBridge;
 import org.opensearch.search.aggregations.support.ValuesSource;
+import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
 
 import java.io.IOException;
@@ -62,8 +66,11 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 import static org.opensearch.core.xcontent.ConstructingObjectParser.optionalConstructorArg;
+import static org.opensearch.search.aggregations.bucket.filterrewrite.DateHistogramAggregatorBridge.segmentMatchAll;
 
 /**
  * Aggregate all docs that match given ranges.
@@ -245,6 +252,8 @@ public boolean equals(Object obj) {
 
     final double[] maxTo;
 
+    private final FilterRewriteOptimizationContext filterRewriteOptimizationContext;
+
     public RangeAggregator(
         String name,
         AggregatorFactories factories,
@@ -256,17 +265,16 @@ public RangeAggregator(
         SearchContext context,
         Aggregator parent,
         CardinalityUpperBound cardinality,
-        Map<String, Object> metadata
+        Map<String, Object> metadata,
+        ValuesSourceConfig config
     ) throws IOException {
-
         super(name, factories, context, parent, cardinality.multiply(ranges.length), metadata);
         assert valuesSource != null;
         this.valuesSource = valuesSource;
         this.format = format;
         this.keyed = keyed;
         this.rangeFactory = rangeFactory;
-
-        this.ranges = ranges;
+        this.ranges = ranges; // already sorted by the range.from and range.to
 
         maxTo = new double[this.ranges.length];
         maxTo[0] = this.ranges[0].to;
@@ -274,6 +282,23 @@ public RangeAggregator(
             maxTo[i] = Math.max(this.ranges[i].to, maxTo[i - 1]);
         }
 
+        RangeAggregatorBridge bridge = new RangeAggregatorBridge() {
+            @Override
+            protected boolean canOptimize() {
+                return canOptimize(config, ranges);
+            }
+
+            @Override
+            protected void prepare() {
+                buildRanges(ranges);
+            }
+
+            @Override
+            protected Function<Object, Long> bucketOrdProducer() {
+                return (activeIndex) -> subBucketOrdinal(0, (int) activeIndex);
+            }
+        };
+        filterRewriteOptimizationContext = new FilterRewriteOptimizationContext(bridge, parent, subAggregators.length, context);
     }
 
     @Override
@@ -286,6 +311,10 @@ public ScoreMode scoreMode() {
 
     @Override
     public LeafBucketCollector getLeafCollector(LeafReaderContext ctx, final LeafBucketCollector sub) throws IOException {
+        if (segmentMatchAll(context, ctx) && filterRewriteOptimizationContext.tryOptimize(ctx, this::incrementBucketDocCount, false)) {
+            throw new CollectionTerminatedException();
+        }
+
         final SortedNumericDoubleValues values = valuesSource.doubleValues(ctx);
         return new LeafBucketCollectorBase(sub, values) {
             @Override
@@ -430,4 +459,9 @@ public InternalAggregation buildEmptyAggregation() {
         }
     }
 
+    @Override
+    public void collectDebugInfo(BiConsumer<String, Object> add) {
+        super.collectDebugInfo(add);
+        filterRewriteOptimizationContext.populateDebugInfo(add);
+    }
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/RangeAggregatorSupplier.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/RangeAggregatorSupplier.java
index de9b979a56107..02b0c2e612d57 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/range/RangeAggregatorSupplier.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/range/RangeAggregatorSupplier.java
@@ -36,6 +36,7 @@
 import org.opensearch.search.aggregations.AggregatorFactories;
 import org.opensearch.search.aggregations.CardinalityUpperBound;
 import org.opensearch.search.aggregations.support.ValuesSource;
+import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
 
 import java.io.IOException;
@@ -58,6 +59,7 @@ Aggregator build(
         SearchContext context,
         Aggregator parent,
         CardinalityUpperBound cardinality,
-        Map<String, Object> metadata
+        Map<String, Object> metadata,
+        ValuesSourceConfig config
     ) throws IOException;
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/terms/IncludeExclude.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/terms/IncludeExclude.java
index f8061bcaca50f..20f294bc7199b 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/terms/IncludeExclude.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/terms/IncludeExclude.java
@@ -57,7 +57,11 @@
 import org.opensearch.search.DocValueFormat;
 
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 import java.util.SortedSet;
@@ -86,6 +90,10 @@ public class IncludeExclude implements Writeable, ToXContentFragment {
      * https://github.com/opensearch-project/OpenSearch/issues/2858
      */
     private static final int DEFAULT_MAX_REGEX_LENGTH = 1000;
+    /**
+     * The maximum number of prefixes to extract from a regex in tryCreatePrefixOrdinalsFilter
+     */
+    private static final int MAX_PREFIXES = 1000;
 
     // for parsing purposes only
     // TODO: move all aggs to the same package so that this stuff could be pkg-private
@@ -393,6 +401,92 @@ public LongBitSet acceptedGlobalOrdinals(SortedSetDocValues globalOrdinals) thro
 
     }
 
+    /**
+     * An ordinals filter that includes/excludes all ordinals corresponding to terms starting with the given prefixes
+     */
+    static class PrefixBackedOrdinalsFilter extends OrdinalsFilter {
+
+        private final SortedSet<BytesRef> includePrefixes, excludePrefixes;
+
+        private PrefixBackedOrdinalsFilter(SortedSet<BytesRef> includePrefixes, SortedSet<BytesRef> excludePrefixes) {
+            this.includePrefixes = includePrefixes;
+            this.excludePrefixes = excludePrefixes;
+        }
+
+        private static BytesRef nextBytesRef(BytesRef bytesRef) {
+            BytesRef next = BytesRef.deepCopyOf(bytesRef);
+            int pos = next.offset + next.length - 1;
+            while (pos >= next.offset && next.bytes[pos] == -1) {
+                next.bytes[pos] = 0;
+                pos--;
+            }
+            if (pos >= next.offset) {
+                next.bytes[pos]++;
+            } else {
+                // Every byte in our prefix had value 0xFF. We must match all subsequent ordinals.
+                return null;
+            }
+            return next;
+        }
+
+        private interface LongBiConsumer {
+            void accept(long a, long b);
+        }
+
+        private static void process(SortedSetDocValues globalOrdinals, long length, SortedSet<BytesRef> prefixes, LongBiConsumer consumer)
+            throws IOException {
+            for (BytesRef prefix : prefixes) {
+                long startOrd = globalOrdinals.lookupTerm(prefix);
+                if (startOrd < 0) {
+                    // The prefix is not an exact match in the ordinals (can skip equal length below)
+                    startOrd = -1 - startOrd;
+                    // Make sure that the term at startOrd starts with prefix
+                    BytesRef startTerm = globalOrdinals.lookupOrd(startOrd);
+                    if (startTerm.length <= prefix.length
+                        || !Arrays.equals(
+                            startTerm.bytes,
+                            startTerm.offset,
+                            startTerm.offset + prefix.length,
+                            prefix.bytes,
+                            prefix.offset,
+                            prefix.offset + prefix.length
+                        )) {
+                        continue;
+                    }
+                }
+                if (startOrd >= length) {
+                    continue;
+                }
+                BytesRef next = nextBytesRef(prefix);
+                if (next == null) {
+                    consumer.accept(startOrd, length);
+                } else {
+                    long endOrd = globalOrdinals.lookupTerm(next);
+                    if (endOrd < 0) {
+                        endOrd = -1 - endOrd;
+                    }
+                    if (startOrd < endOrd) {
+                        consumer.accept(startOrd, endOrd);
+                    }
+                }
+            }
+
+        }
+
+        @Override
+        public LongBitSet acceptedGlobalOrdinals(SortedSetDocValues globalOrdinals) throws IOException {
+            LongBitSet accept = new LongBitSet(globalOrdinals.getValueCount());
+            if (!includePrefixes.isEmpty()) {
+                process(globalOrdinals, accept.length(), includePrefixes, accept::set);
+            } else if (accept.length() > 0) {
+                // Exclude-only
+                accept.set(0, accept.length());
+            }
+            process(globalOrdinals, accept.length(), excludePrefixes, accept::clear);
+            return accept;
+        }
+    }
+
     private final String include, exclude;
     private final SortedSet<BytesRef> includeValues, excludeValues;
     private final int incZeroBasedPartition;
@@ -709,8 +803,13 @@ public OrdinalsFilter convertToOrdinalsFilter(DocValueFormat format) {
     }
 
     public OrdinalsFilter convertToOrdinalsFilter(DocValueFormat format, int maxRegexLength) {
-
         if (isRegexBased()) {
+            if ((include == null || include.endsWith(".*")) && (exclude == null || exclude.endsWith(".*"))) {
+                PrefixBackedOrdinalsFilter prefixBackedOrdinalsFilter = tryCreatePrefixOrdinalsFilter(maxRegexLength);
+                if (prefixBackedOrdinalsFilter != null) {
+                    return prefixBackedOrdinalsFilter;
+                }
+            }
             return new AutomatonBackedOrdinalsFilter(toAutomaton(maxRegexLength));
         }
         if (isPartitionBased()) {
@@ -720,6 +819,94 @@ public OrdinalsFilter convertToOrdinalsFilter(DocValueFormat format, int maxRege
         return new TermListBackedOrdinalsFilter(parseForDocValues(includeValues, format), parseForDocValues(excludeValues, format));
     }
 
+    private static List<String> expandRegexp(RegExp regExp, int maxPrefixes) {
+        switch (regExp.kind) {
+            case REGEXP_UNION:
+                List<RegExp> alternatives = new ArrayList<>();
+                while (regExp.exp1.kind == RegExp.Kind.REGEXP_UNION) {
+                    alternatives.add(regExp.exp2);
+                    regExp = regExp.exp1;
+                }
+                alternatives.add(regExp.exp2);
+                alternatives.add(regExp.exp1);
+                List<String> output = new ArrayList<>();
+                for (RegExp leaf : alternatives) {
+                    List<String> leafExpansions = expandRegexp(leaf, maxPrefixes);
+                    if (leafExpansions == null) {
+                        return null;
+                    } else {
+                        if (output.size() + leafExpansions.size() > maxPrefixes) {
+                            return null;
+                        }
+                        output.addAll(leafExpansions);
+                    }
+                }
+                return output;
+            case REGEXP_CONCATENATION:
+                List<String> prefixes = expandRegexp(regExp.exp1, maxPrefixes);
+                if (prefixes == null) {
+                    return null;
+                }
+                List<String> suffixes = expandRegexp(regExp.exp2, maxPrefixes);
+                if (suffixes == null) {
+                    return null;
+                }
+                if (prefixes.size() * suffixes.size() > maxPrefixes) {
+                    return null;
+                }
+                List<String> out = new ArrayList<>();
+                StringBuilder stringBuilder = new StringBuilder();
+                for (String prefix : prefixes) {
+                    for (String suffix : suffixes) {
+                        stringBuilder.setLength(0);
+                        stringBuilder.append(prefix).append(suffix);
+                        out.add(stringBuilder.toString());
+                    }
+                }
+                return out;
+            case REGEXP_CHAR:
+                return List.of(Character.toString(regExp.c));
+            case REGEXP_STRING:
+                return List.of(regExp.s);
+            default:
+                return null;
+        }
+    }
+
+    static SortedSet<BytesRef> extractPrefixes(String pattern, int maxRegexLength) {
+        if (pattern == null) {
+            return Collections.emptySortedSet();
+        }
+        SortedSet<BytesRef> prefixSet = null;
+        validateRegExpStringLength(pattern, maxRegexLength);
+        RegExp regExp = new RegExp(pattern);
+        if (regExp.kind == RegExp.Kind.REGEXP_CONCATENATION && regExp.exp2.kind == RegExp.Kind.REGEXP_REPEAT) {
+            RegExp tail = regExp.exp2.exp1;
+            if (tail.kind == RegExp.Kind.REGEXP_ANYCHAR || tail.kind == RegExp.Kind.REGEXP_ANYSTRING) {
+                List<String> prefixes = expandRegexp(regExp.exp1, MAX_PREFIXES);
+                if (prefixes != null) {
+                    prefixSet = new TreeSet<>();
+                    for (String prefix : prefixes) {
+                        prefixSet.add(new BytesRef(prefix));
+                    }
+                }
+            }
+        }
+        return prefixSet;
+    }
+
+    private PrefixBackedOrdinalsFilter tryCreatePrefixOrdinalsFilter(int maxRegexLength) {
+        SortedSet<BytesRef> includeSet = extractPrefixes(include, maxRegexLength);
+        if (includeSet == null) {
+            return null;
+        }
+        SortedSet<BytesRef> excludeSet = extractPrefixes(exclude, maxRegexLength);
+        if (excludeSet == null) {
+            return null;
+        }
+        return new PrefixBackedOrdinalsFilter(includeSet, excludeSet);
+    }
+
     public LongFilter convertToLongFilter(DocValueFormat format) {
 
         if (isPartitionBased()) {
diff --git a/server/src/main/java/org/opensearch/search/aggregations/metrics/CardinalityAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/metrics/CardinalityAggregator.java
index 99c4eaac4b777..0f3d975960364 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/metrics/CardinalityAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/metrics/CardinalityAggregator.java
@@ -32,13 +32,28 @@
 
 package org.opensearch.search.aggregations.metrics;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.index.SortedSetDocValues;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.index.Terms;
+import org.apache.lucene.index.TermsEnum;
+import org.apache.lucene.search.BulkScorer;
+import org.apache.lucene.search.CollectionTerminatedException;
+import org.apache.lucene.search.DisiPriorityQueue;
+import org.apache.lucene.search.DisiWrapper;
+import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.Weight;
+import org.apache.lucene.util.Bits;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.FixedBitSet;
 import org.apache.lucene.util.RamUsageEstimator;
+import org.opensearch.OpenSearchStatusException;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.hash.MurmurHash3;
 import org.opensearch.common.lease.Releasable;
@@ -48,6 +63,7 @@
 import org.opensearch.common.util.BitMixer;
 import org.opensearch.common.util.LongArray;
 import org.opensearch.common.util.ObjectArray;
+import org.opensearch.core.rest.RestStatus;
 import org.opensearch.index.fielddata.SortedBinaryDocValues;
 import org.opensearch.index.fielddata.SortedNumericDoubleValues;
 import org.opensearch.search.aggregations.Aggregator;
@@ -58,9 +74,12 @@
 import org.opensearch.search.internal.SearchContext;
 
 import java.io.IOException;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.function.BiConsumer;
 
+import static org.opensearch.search.SearchService.CARDINALITY_AGGREGATION_PRUNING_THRESHOLD;
+
 /**
  * An aggregator that computes approximate counts of unique values.
  *
@@ -68,9 +87,13 @@
  */
 public class CardinalityAggregator extends NumericMetricsAggregator.SingleValue {
 
+    private static final Logger logger = LogManager.getLogger(CardinalityAggregator.class);
+
     private final int precision;
     private final ValuesSource valuesSource;
 
+    private final ValuesSourceConfig valuesSourceConfig;
+
     // Expensive to initialize, so we only initialize it when we have an actual value source
     @Nullable
     private HyperLogLogPlusPlus counts;
@@ -82,6 +105,7 @@ public class CardinalityAggregator extends NumericMetricsAggregator.SingleValue
     private int ordinalsCollectorsUsed;
     private int ordinalsCollectorsOverheadTooHigh;
     private int stringHashingCollectorsUsed;
+    private int dynamicPrunedSegments;
 
     public CardinalityAggregator(
         String name,
@@ -96,6 +120,7 @@ public CardinalityAggregator(
         this.valuesSource = valuesSourceConfig.hasValues() ? valuesSourceConfig.getValuesSource() : null;
         this.precision = precision;
         this.counts = valuesSource == null ? null : new HyperLogLogPlusPlus(precision, context.bigArrays(), 1);
+        this.valuesSourceConfig = valuesSourceConfig;
     }
 
     @Override
@@ -118,6 +143,7 @@ private Collector pickCollector(LeafReaderContext ctx) throws IOException {
             return new DirectCollector(counts, hashValues);
         }
 
+        Collector collector = null;
         if (valuesSource instanceof ValuesSource.Bytes.WithOrdinals) {
             ValuesSource.Bytes.WithOrdinals source = (ValuesSource.Bytes.WithOrdinals) valuesSource;
             final SortedSetDocValues ordinalValues = source.ordinalsValues(ctx);
@@ -125,20 +151,109 @@ private Collector pickCollector(LeafReaderContext ctx) throws IOException {
             if (maxOrd == 0) {
                 emptyCollectorsUsed++;
                 return new EmptyCollector();
+            } else {
+                final long ordinalsMemoryUsage = OrdinalsCollector.memoryOverhead(maxOrd);
+                final long countsMemoryUsage = HyperLogLogPlusPlus.memoryUsage(precision);
+                // only use ordinals if they don't increase memory usage by more than 25%
+                if (ordinalsMemoryUsage < countsMemoryUsage / 4) {
+                    ordinalsCollectorsUsed++;
+                    collector = new OrdinalsCollector(counts, ordinalValues, context.bigArrays());
+                } else {
+                    ordinalsCollectorsOverheadTooHigh++;
+                }
+            }
+        }
+
+        if (collector == null) { // not able to build an OrdinalsCollector
+            stringHashingCollectorsUsed++;
+            collector = new DirectCollector(counts, MurmurHash3Values.hash(valuesSource.bytesValues(ctx)));
+        }
+
+        if (canPrune(parent, subAggregators, valuesSourceConfig)) {
+            Terms terms = ctx.reader().terms(valuesSourceConfig.fieldContext().field());
+            if (terms == null) return collector;
+            if (exceedMaxThreshold(terms)) {
+                return collector;
+            }
+
+            Collector pruningCollector = tryWrapWithPruningCollector(collector, terms, ctx);
+            if (pruningCollector == null) {
+                return collector;
             }
 
-            final long ordinalsMemoryUsage = OrdinalsCollector.memoryOverhead(maxOrd);
-            final long countsMemoryUsage = HyperLogLogPlusPlus.memoryUsage(precision);
-            // only use ordinals if they don't increase memory usage by more than 25%
-            if (ordinalsMemoryUsage < countsMemoryUsage / 4) {
-                ordinalsCollectorsUsed++;
-                return new OrdinalsCollector(counts, ordinalValues, context.bigArrays());
+            if (!tryScoreWithPruningCollector(ctx, pruningCollector)) {
+                return collector;
+            }
+            logger.debug("Dynamic pruned segment {} of shard {}", ctx.ord, context.indexShard().shardId());
+            dynamicPrunedSegments++;
+
+            return getNoOpCollector();
+        }
+
+        return collector;
+    }
+
+    private boolean canPrune(Aggregator parent, Aggregator[] subAggregators, ValuesSourceConfig valuesSourceConfig) {
+        return parent == null && subAggregators.length == 0 && valuesSourceConfig.missing() == null && valuesSourceConfig.script() == null;
+    }
+
+    private boolean exceedMaxThreshold(Terms terms) throws IOException {
+        if (terms.size() > context.cardinalityAggregationPruningThreshold()) {
+            logger.debug(
+                "Cannot prune because terms size {} is greater than the threshold {}",
+                terms.size(),
+                context.cardinalityAggregationPruningThreshold()
+            );
+            return true;
+        }
+        return false;
+    }
+
+    private Collector tryWrapWithPruningCollector(Collector collector, Terms terms, LeafReaderContext ctx) {
+        try {
+            return new PruningCollector(collector, terms.iterator(), ctx, context, valuesSourceConfig.fieldContext().field());
+        } catch (Exception e) {
+            logger.warn("Failed to build collector for dynamic pruning.", e);
+            return null;
+        }
+    }
+
+    private boolean tryScoreWithPruningCollector(LeafReaderContext ctx, Collector pruningCollector) throws IOException {
+        try {
+            Weight weight = context.query().rewrite(context.searcher()).createWeight(context.searcher(), ScoreMode.TOP_DOCS, 1f);
+            BulkScorer scorer = weight.bulkScorer(ctx);
+            if (scorer == null) {
+                return false;
             }
-            ordinalsCollectorsOverheadTooHigh++;
+            Bits liveDocs = ctx.reader().getLiveDocs();
+            scorer.score(pruningCollector, liveDocs);
+            pruningCollector.postCollect();
+            Releasables.close(pruningCollector);
+        } catch (Exception e) {
+            throw new OpenSearchStatusException(
+                "Failed when performing dynamic pruning in cardinality aggregation. You can set cluster setting ["
+                    + CARDINALITY_AGGREGATION_PRUNING_THRESHOLD.getKey()
+                    + "] to 0 to disable.",
+                RestStatus.INTERNAL_SERVER_ERROR,
+                e
+            );
         }
+        return true;
+    }
 
-        stringHashingCollectorsUsed++;
-        return new DirectCollector(counts, MurmurHash3Values.hash(valuesSource.bytesValues(ctx)));
+    private Collector getNoOpCollector() {
+        return new Collector() {
+            @Override
+            public void close() {}
+
+            @Override
+            public void postCollect() throws IOException {}
+
+            @Override
+            public void collect(int doc, long owningBucketOrd) throws IOException {
+                throw new CollectionTerminatedException();
+            }
+        };
     }
 
     @Override
@@ -175,7 +290,7 @@ public InternalAggregation buildAggregation(long owningBucketOrdinal) {
         if (counts == null || owningBucketOrdinal >= counts.maxOrd() || counts.cardinality(owningBucketOrdinal) == 0) {
             return buildEmptyAggregation();
         }
-        // We need to build a copy because the returned Aggregation needs remain usable after
+        // We need to build a copy because the returned Aggregation needs to remain usable after
         // this Aggregator (and its HLL++ counters) is released.
         AbstractHyperLogLogPlusPlus copy = counts.clone(owningBucketOrdinal, BigArrays.NON_RECYCLING_INSTANCE);
         return new InternalCardinality(name, copy, metadata());
@@ -199,6 +314,7 @@ public void collectDebugInfo(BiConsumer<String, Object> add) {
         add.accept("ordinals_collectors_used", ordinalsCollectorsUsed);
         add.accept("ordinals_collectors_overhead_too_high", ordinalsCollectorsOverheadTooHigh);
         add.accept("string_hashing_collectors_used", stringHashingCollectorsUsed);
+        add.accept("dynamic_pruned_segments", dynamicPrunedSegments);
     }
 
     /**
@@ -212,6 +328,130 @@ private abstract static class Collector extends LeafBucketCollector implements R
 
     }
 
+    /**
+     * This collector enhance the delegate collector with pruning ability on term field
+     * The iterators of term field values are wrapped into a priority queue, and able to
+     * pop/prune the values after being collected
+     */
+    private static class PruningCollector extends Collector {
+
+        private final Collector delegate;
+        private final DisiPriorityQueue queue;
+        private final DocIdSetIterator competitiveIterator;
+
+        PruningCollector(Collector delegate, TermsEnum terms, LeafReaderContext ctx, SearchContext context, String field)
+            throws IOException {
+            this.delegate = delegate;
+
+            Map<BytesRef, Scorer> postingMap = new HashMap<>();
+            while (terms.next() != null) {
+                BytesRef term = terms.term();
+                TermQuery termQuery = new TermQuery(new Term(field, term));
+                Weight subWeight = termQuery.createWeight(context.searcher(), ScoreMode.COMPLETE_NO_SCORES, 1f);
+                Scorer scorer = subWeight.scorer(ctx);
+                postingMap.put(term, scorer);
+            }
+
+            this.queue = new DisiPriorityQueue(postingMap.size());
+            for (Scorer scorer : postingMap.values()) {
+                queue.add(new DisiWrapper(scorer));
+            }
+
+            competitiveIterator = new DisjunctionDISI(queue);
+        }
+
+        @Override
+        public void close() {
+            delegate.close();
+        }
+
+        @Override
+        public void collect(int doc, long owningBucketOrd) throws IOException {
+            delegate.collect(doc, owningBucketOrd);
+            prune(doc);
+        }
+
+        /**
+         * Note: the queue may be empty or the queue top may be null after pruning
+         */
+        private void prune(int doc) {
+            DisiWrapper top = queue.top();
+            int curTopDoc = top.doc;
+            if (curTopDoc == doc) {
+                do {
+                    queue.pop();
+                    top = queue.updateTop();
+                } while (queue.size() > 1 && top.doc == curTopDoc);
+            }
+        }
+
+        @Override
+        public DocIdSetIterator competitiveIterator() {
+            return competitiveIterator;
+        }
+
+        @Override
+        public void postCollect() throws IOException {
+            delegate.postCollect();
+        }
+    }
+
+    /**
+     * This DISI is a disjunction of all terms in a segment
+     * And it will be the competitive iterator of the leaf pruning collector
+     * After pruning done after collect, queue top doc may exceed the next doc of (lead) iterator
+     * To still providing a docID slower than the lead iterator for the next iteration
+     * We keep track of a slowDocId that will be updated later during advance
+     */
+    private static class DisjunctionDISI extends DocIdSetIterator {
+        private final DisiPriorityQueue queue;
+        private int slowDocId = -1;
+
+        public DisjunctionDISI(DisiPriorityQueue queue) {
+            this.queue = queue;
+        }
+
+        @Override
+        public int docID() {
+            return slowDocId;
+        }
+
+        @Override
+        public int advance(int target) throws IOException {
+            DisiWrapper top = queue.top();
+            if (top == null) {
+                return slowDocId = NO_MORE_DOCS;
+            }
+
+            // This would be the outcome of last pruning
+            // this DISI's docID is already making to the target
+            if (top.doc >= target) {
+                slowDocId = top.doc;
+                return top.doc;
+            }
+
+            do {
+                top.doc = top.approximation.advance(target);
+                top = queue.updateTop();
+            } while (top.doc < target);
+            slowDocId = queue.size() == 0 ? NO_MORE_DOCS : queue.top().doc;
+
+            return slowDocId;
+        }
+
+        @Override
+        public int nextDoc() {
+            // don't expect this to be called based on its usage in DefaultBulkScorer
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public long cost() {
+            // don't expect this to be called based on its usage in DefaultBulkScorer
+            throw new UnsupportedOperationException();
+        }
+    }
+
     /**
      * Empty Collector for the Cardinality agg
      *
diff --git a/server/src/main/java/org/opensearch/search/aggregations/metrics/InternalCardinality.java b/server/src/main/java/org/opensearch/search/aggregations/metrics/InternalCardinality.java
index 7e9511ffdd379..9f9ad63220fea 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/metrics/InternalCardinality.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/metrics/InternalCardinality.java
@@ -117,7 +117,6 @@ public InternalAggregation reduce(List<InternalAggregation> aggregations, Reduce
             return aggregations.get(0);
         } else {
             return new InternalCardinality(name, reduced, getMetadata());
-
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSourceConfig.java b/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSourceConfig.java
index d006b15df327c..b6c8fe5d4802c 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSourceConfig.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSourceConfig.java
@@ -36,6 +36,7 @@
 import org.opensearch.index.fielddata.IndexFieldData;
 import org.opensearch.index.fielddata.IndexGeoPointFieldData;
 import org.opensearch.index.fielddata.IndexNumericFieldData;
+import org.opensearch.index.mapper.DerivedFieldType;
 import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.index.mapper.RangeFieldMapper;
 import org.opensearch.index.query.QueryShardContext;
@@ -183,6 +184,12 @@ private static ValuesSourceConfig internalResolve(
             valuesSourceType = defaultValueSourceType;
         }
         DocValueFormat docValueFormat = resolveFormat(format, valuesSourceType, timeZone, fieldType);
+
+        // If we are aggregating on derived field set the agg script.
+        if (fieldType instanceof DerivedFieldType) {
+            aggregationScript = ((DerivedFieldType) fieldType).getAggregationScript(context);
+        }
+
         config = new ValuesSourceConfig(
             valuesSourceType,
             fieldContext,
@@ -336,7 +343,7 @@ private ValuesSource ConstructValuesSource(Object missing, DocValueFormat format
         if (this.unmapped) {
             vs = valueSourceType().getEmpty();
         } else {
-            if (fieldContext() == null) {
+            if (fieldContext() == null || fieldType() instanceof DerivedFieldType) {
                 // Script case
                 vs = valueSourceType().getScript(script(), scriptValueType());
             } else {
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/values/ScriptBytesValues.java b/server/src/main/java/org/opensearch/search/aggregations/support/values/ScriptBytesValues.java
index 349bd8e14edf6..30f7494ea2d18 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/values/ScriptBytesValues.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/values/ScriptBytesValues.java
@@ -32,6 +32,7 @@
 package org.opensearch.search.aggregations.support.values;
 
 import org.apache.lucene.search.Scorable;
+import org.apache.lucene.util.BytesRef;
 import org.opensearch.common.lucene.ScorerAware;
 import org.opensearch.core.common.util.CollectionUtils;
 import org.opensearch.index.fielddata.SortedBinaryDocValues;
@@ -61,7 +62,11 @@ private void set(int i, Object o) {
             values[i].clear();
         } else {
             CollectionUtils.ensureNoSelfReferences(o, "ScriptBytesValues value");
-            values[i].copyChars(o.toString());
+            if (o instanceof BytesRef) {
+                values[i].copyBytes((BytesRef) o);
+            } else {
+                values[i].copyChars(o.toString());
+            }
         }
     }
 
diff --git a/server/src/main/java/org/opensearch/search/approximate/ApproximateIndexOrDocValuesQuery.java b/server/src/main/java/org/opensearch/search/approximate/ApproximateIndexOrDocValuesQuery.java
new file mode 100644
index 0000000000000..b99e0a0cbf808
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/approximate/ApproximateIndexOrDocValuesQuery.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.approximate;
+
+import org.apache.lucene.search.IndexOrDocValuesQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.QueryVisitor;
+
+/**
+ * A wrapper around {@link IndexOrDocValuesQuery} that can be used to run approximate queries.
+ * It delegates to either {@link ApproximateQuery} or {@link IndexOrDocValuesQuery} based on whether the query can be approximated or not.
+ * @see ApproximateQuery
+ */
+public final class ApproximateIndexOrDocValuesQuery extends ApproximateScoreQuery {
+
+    private final ApproximateQuery approximateIndexQuery;
+    private final IndexOrDocValuesQuery indexOrDocValuesQuery;
+
+    public ApproximateIndexOrDocValuesQuery(Query indexQuery, ApproximateQuery approximateIndexQuery, Query dvQuery) {
+        super(new IndexOrDocValuesQuery(indexQuery, dvQuery), approximateIndexQuery);
+        this.approximateIndexQuery = approximateIndexQuery;
+        this.indexOrDocValuesQuery = new IndexOrDocValuesQuery(indexQuery, dvQuery);
+    }
+
+    @Override
+    public String toString(String field) {
+        return "ApproximateIndexOrDocValuesQuery(indexQuery="
+            + indexOrDocValuesQuery.getIndexQuery().toString(field)
+            + ", approximateIndexQuery="
+            + approximateIndexQuery.toString(field)
+            + ", dvQuery="
+            + indexOrDocValuesQuery.getRandomAccessQuery().toString(field)
+            + ")";
+    }
+
+    @Override
+    public void visit(QueryVisitor visitor) {
+        indexOrDocValuesQuery.visit(visitor);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (sameClassAs(obj) == false) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int h = classHash();
+        h = 31 * h + indexOrDocValuesQuery.getIndexQuery().hashCode();
+        h = 31 * h + indexOrDocValuesQuery.getRandomAccessQuery().hashCode();
+        return h;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/approximate/ApproximatePointRangeQuery.java b/server/src/main/java/org/opensearch/search/approximate/ApproximatePointRangeQuery.java
new file mode 100644
index 0000000000000..8076da6ab970b
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/approximate/ApproximatePointRangeQuery.java
@@ -0,0 +1,520 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.approximate;
+
+import org.apache.lucene.index.LeafReader;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.PointValues;
+import org.apache.lucene.search.ConstantScoreScorer;
+import org.apache.lucene.search.ConstantScoreWeight;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.PointRangeQuery;
+import org.apache.lucene.search.QueryVisitor;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.ScorerSupplier;
+import org.apache.lucene.search.Weight;
+import org.apache.lucene.util.ArrayUtil;
+import org.apache.lucene.util.DocIdSetBuilder;
+import org.apache.lucene.util.IntsRef;
+import org.opensearch.index.query.RangeQueryBuilder;
+import org.opensearch.search.internal.SearchContext;
+import org.opensearch.search.sort.FieldSortBuilder;
+import org.opensearch.search.sort.SortOrder;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Objects;
+
+/**
+ * An approximate-able version of {@link PointRangeQuery}. It creates an instance of {@link PointRangeQuery} but short-circuits the intersect logic
+ * after {@code size} is hit
+ */
+public abstract class ApproximatePointRangeQuery extends ApproximateQuery {
+    private int size;
+
+    private SortOrder sortOrder;
+
+    public final PointRangeQuery pointRangeQuery;
+
+    protected ApproximatePointRangeQuery(String field, byte[] lowerPoint, byte[] upperPoint, int numDims) {
+        this(field, lowerPoint, upperPoint, numDims, 10_000, null);
+    }
+
+    protected ApproximatePointRangeQuery(String field, byte[] lowerPoint, byte[] upperPoint, int numDims, int size) {
+        this(field, lowerPoint, upperPoint, numDims, size, null);
+    }
+
+    protected ApproximatePointRangeQuery(String field, byte[] lowerPoint, byte[] upperPoint, int numDims, int size, SortOrder sortOrder) {
+        this.size = size;
+        this.sortOrder = sortOrder;
+        this.pointRangeQuery = new PointRangeQuery(field, lowerPoint, upperPoint, numDims) {
+            @Override
+            protected String toString(int dimension, byte[] value) {
+                return super.toString(field);
+            }
+        };
+    }
+
+    public int getSize() {
+        return this.size;
+    }
+
+    public void setSize(int size) {
+        this.size = size;
+    }
+
+    public SortOrder getSortOrder() {
+        return this.sortOrder;
+    }
+
+    public void setSortOrder(SortOrder sortOrder) {
+        this.sortOrder = sortOrder;
+    }
+
+    @Override
+    public void visit(QueryVisitor visitor) {
+        pointRangeQuery.visit(visitor);
+    }
+
+    @Override
+    public final ConstantScoreWeight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
+        Weight pointRangeQueryWeight = pointRangeQuery.createWeight(searcher, scoreMode, boost);
+
+        return new ConstantScoreWeight(this, boost) {
+
+            private final ArrayUtil.ByteArrayComparator comparator = ArrayUtil.getUnsignedComparator(pointRangeQuery.getBytesPerDim());
+
+            // we pull this from PointRangeQuery since it is final
+            private boolean matches(byte[] packedValue) {
+                for (int dim = 0; dim < pointRangeQuery.getNumDims(); dim++) {
+                    int offset = dim * pointRangeQuery.getBytesPerDim();
+                    if (comparator.compare(packedValue, offset, pointRangeQuery.getLowerPoint(), offset) < 0) {
+                        // Doc's value is too low, in this dimension
+                        return false;
+                    }
+                    if (comparator.compare(packedValue, offset, pointRangeQuery.getUpperPoint(), offset) > 0) {
+                        // Doc's value is too high, in this dimension
+                        return false;
+                    }
+                }
+                return true;
+            }
+
+            // we pull this from PointRangeQuery since it is final
+            private PointValues.Relation relate(byte[] minPackedValue, byte[] maxPackedValue) {
+
+                boolean crosses = false;
+
+                for (int dim = 0; dim < pointRangeQuery.getNumDims(); dim++) {
+                    int offset = dim * pointRangeQuery.getBytesPerDim();
+
+                    if (comparator.compare(minPackedValue, offset, pointRangeQuery.getUpperPoint(), offset) > 0
+                        || comparator.compare(maxPackedValue, offset, pointRangeQuery.getLowerPoint(), offset) < 0) {
+                        return PointValues.Relation.CELL_OUTSIDE_QUERY;
+                    }
+
+                    crosses |= comparator.compare(minPackedValue, offset, pointRangeQuery.getLowerPoint(), offset) < 0
+                        || comparator.compare(maxPackedValue, offset, pointRangeQuery.getUpperPoint(), offset) > 0;
+                }
+
+                if (crosses) {
+                    return PointValues.Relation.CELL_CROSSES_QUERY;
+                } else {
+                    return PointValues.Relation.CELL_INSIDE_QUERY;
+                }
+            }
+
+            public PointValues.IntersectVisitor getIntersectVisitor(DocIdSetBuilder result, long[] docCount) {
+                return new PointValues.IntersectVisitor() {
+
+                    DocIdSetBuilder.BulkAdder adder;
+
+                    @Override
+                    public void grow(int count) {
+                        adder = result.grow(count);
+                    }
+
+                    @Override
+                    public void visit(int docID) {
+                        // it is possible that size < 1024 and docCount < size but we will continue to count through all the 1024 docs
+                        // and collect less, but it won't hurt performance
+                        if (docCount[0] >= size) {
+                            return;
+                        }
+                        adder.add(docID);
+                        docCount[0]++;
+                    }
+
+                    @Override
+                    public void visit(DocIdSetIterator iterator) throws IOException {
+                        adder.add(iterator);
+                    }
+
+                    @Override
+                    public void visit(IntsRef ref) {
+                        for (int i = 0; i < ref.length; i++) {
+                            adder.add(ref.ints[ref.offset + i]);
+                        }
+                    }
+
+                    @Override
+                    public void visit(int docID, byte[] packedValue) {
+                        if (matches(packedValue)) {
+                            visit(docID);
+                        }
+                    }
+
+                    @Override
+                    public void visit(DocIdSetIterator iterator, byte[] packedValue) throws IOException {
+                        if (matches(packedValue)) {
+                            adder.add(iterator);
+                        }
+                    }
+
+                    @Override
+                    public PointValues.Relation compare(byte[] minPackedValue, byte[] maxPackedValue) {
+                        return relate(minPackedValue, maxPackedValue);
+                    }
+                };
+            }
+
+            // we pull this from PointRangeQuery since it is final
+            private boolean checkValidPointValues(PointValues values) throws IOException {
+                if (values == null) {
+                    // No docs in this segment/field indexed any points
+                    return false;
+                }
+
+                if (values.getNumIndexDimensions() != pointRangeQuery.getNumDims()) {
+                    throw new IllegalArgumentException(
+                        "field=\""
+                            + pointRangeQuery.getField()
+                            + "\" was indexed with numIndexDimensions="
+                            + values.getNumIndexDimensions()
+                            + " but this query has numDims="
+                            + pointRangeQuery.getNumDims()
+                    );
+                }
+                if (pointRangeQuery.getBytesPerDim() != values.getBytesPerDimension()) {
+                    throw new IllegalArgumentException(
+                        "field=\""
+                            + pointRangeQuery.getField()
+                            + "\" was indexed with bytesPerDim="
+                            + values.getBytesPerDimension()
+                            + " but this query has bytesPerDim="
+                            + pointRangeQuery.getBytesPerDim()
+                    );
+                }
+                return true;
+            }
+
+            private void intersectLeft(PointValues.PointTree pointTree, PointValues.IntersectVisitor visitor, long[] docCount)
+                throws IOException {
+                intersectLeft(visitor, pointTree, docCount);
+                assert pointTree.moveToParent() == false;
+            }
+
+            private void intersectRight(PointValues.PointTree pointTree, PointValues.IntersectVisitor visitor, long[] docCount)
+                throws IOException {
+                intersectRight(visitor, pointTree, docCount);
+                assert pointTree.moveToParent() == false;
+            }
+
+            // custom intersect visitor to walk the left of the tree
+            public void intersectLeft(PointValues.IntersectVisitor visitor, PointValues.PointTree pointTree, long[] docCount)
+                throws IOException {
+                PointValues.Relation r = visitor.compare(pointTree.getMinPackedValue(), pointTree.getMaxPackedValue());
+                if (docCount[0] >= size) {
+                    return;
+                }
+                switch (r) {
+                    case CELL_OUTSIDE_QUERY:
+                        // This cell is fully outside the query shape: stop recursing
+                        break;
+                    case CELL_INSIDE_QUERY:
+                        // If the cell is fully inside, we keep moving to child until we reach a point where we can no longer move or when
+                        // we have sufficient doc count. We first move down and then move to the left child
+                        if (pointTree.moveToChild() && docCount[0] < size) {
+                            do {
+                                intersectLeft(visitor, pointTree, docCount);
+                            } while (pointTree.moveToSibling() && docCount[0] < size);
+                            pointTree.moveToParent();
+                        } else {
+                            // we're at the leaf node, if we're under the size, visit all the docIds in this node.
+                            if (docCount[0] < size) {
+                                pointTree.visitDocIDs(visitor);
+                            }
+                        }
+                        break;
+                    case CELL_CROSSES_QUERY:
+                        // The cell crosses the shape boundary, or the cell fully contains the query, so we fall
+                        // through and do full filtering:
+                        if (pointTree.moveToChild() && docCount[0] < size) {
+                            do {
+                                intersectLeft(visitor, pointTree, docCount);
+                            } while (pointTree.moveToSibling() && docCount[0] < size);
+                            pointTree.moveToParent();
+                        } else {
+                            // TODO: we can assert that the first value here in fact matches what the pointTree
+                            // claimed?
+                            // Leaf node; scan and filter all points in this block:
+                            if (docCount[0] < size) {
+                                pointTree.visitDocValues(visitor);
+                            }
+                        }
+                        break;
+                    default:
+                        throw new IllegalArgumentException("Unreachable code");
+                }
+            }
+
+            // custom intersect visitor to walk the right of tree
+            public void intersectRight(PointValues.IntersectVisitor visitor, PointValues.PointTree pointTree, long[] docCount)
+                throws IOException {
+                PointValues.Relation r = visitor.compare(pointTree.getMinPackedValue(), pointTree.getMaxPackedValue());
+                if (docCount[0] >= size) {
+                    return;
+                }
+                switch (r) {
+                    case CELL_OUTSIDE_QUERY:
+                        // This cell is fully outside the query shape: stop recursing
+                        break;
+
+                    case CELL_INSIDE_QUERY:
+                        // If the cell is fully inside, we keep moving right as long as the point tree size is over our size requirement
+                        if (pointTree.size() > size && docCount[0] < size && moveRight(pointTree)) {
+                            intersectRight(visitor, pointTree, docCount);
+                            pointTree.moveToParent();
+                        }
+                        // if point tree size is no longer over, we have to go back one level where it still was over and the intersect left
+                        else if (pointTree.size() <= size && docCount[0] < size) {
+                            pointTree.moveToParent();
+                            intersectLeft(visitor, pointTree, docCount);
+                        }
+                        // if we've reached leaf, it means out size is under the size of the leaf, we can just collect all docIDs
+                        else {
+                            // Leaf node; scan and filter all points in this block:
+                            if (docCount[0] < size) {
+                                pointTree.visitDocIDs(visitor);
+                            }
+                        }
+                        break;
+                    case CELL_CROSSES_QUERY:
+                        // If the cell is fully inside, we keep moving right as long as the point tree size is over our size requirement
+                        if (pointTree.size() > size && docCount[0] < size && moveRight(pointTree)) {
+                            intersectRight(visitor, pointTree, docCount);
+                            pointTree.moveToParent();
+                        }
+                        // if point tree size is no longer over, we have to go back one level where it still was over and the intersect left
+                        else if (pointTree.size() <= size && docCount[0] < size) {
+                            pointTree.moveToParent();
+                            intersectLeft(visitor, pointTree, docCount);
+                        }
+                        // if we've reached leaf, it means out size is under the size of the leaf, we can just collect all doc values
+                        else {
+                            // Leaf node; scan and filter all points in this block:
+                            if (docCount[0] < size) {
+                                pointTree.visitDocValues(visitor);
+                            }
+                        }
+                        break;
+                    default:
+                        throw new IllegalArgumentException("Unreachable code");
+                }
+            }
+
+            public boolean moveRight(PointValues.PointTree pointTree) throws IOException {
+                return pointTree.moveToChild() && pointTree.moveToSibling();
+            }
+
+            @Override
+            public ScorerSupplier scorerSupplier(LeafReaderContext context) throws IOException {
+                LeafReader reader = context.reader();
+                long[] docCount = { 0 };
+
+                PointValues values = reader.getPointValues(pointRangeQuery.getField());
+                if (checkValidPointValues(values) == false) {
+                    return null;
+                }
+                final Weight weight = this;
+                if (size > values.size()) {
+                    return pointRangeQueryWeight.scorerSupplier(context);
+                } else {
+                    if (sortOrder == null || sortOrder.equals(SortOrder.ASC)) {
+                        return new ScorerSupplier() {
+
+                            final DocIdSetBuilder result = new DocIdSetBuilder(reader.maxDoc(), values, pointRangeQuery.getField());
+                            final PointValues.IntersectVisitor visitor = getIntersectVisitor(result, docCount);
+                            long cost = -1;
+
+                            @Override
+                            public Scorer get(long leadCost) throws IOException {
+                                intersectLeft(values.getPointTree(), visitor, docCount);
+                                DocIdSetIterator iterator = result.build().iterator();
+                                return new ConstantScoreScorer(weight, score(), scoreMode, iterator);
+                            }
+
+                            @Override
+                            public long cost() {
+                                if (cost == -1) {
+                                    // Computing the cost may be expensive, so only do it if necessary
+                                    cost = values.estimateDocCount(visitor);
+                                    assert cost >= 0;
+                                }
+                                return cost;
+                            }
+                        };
+                    } else {
+                        // we need to fetch size + deleted docs since the collector will prune away deleted docs resulting in fewer results
+                        // than expected
+                        final int deletedDocs = reader.numDeletedDocs();
+                        size += deletedDocs;
+                        return new ScorerSupplier() {
+
+                            final DocIdSetBuilder result = new DocIdSetBuilder(reader.maxDoc(), values, pointRangeQuery.getField());
+                            final PointValues.IntersectVisitor visitor = getIntersectVisitor(result, docCount);
+                            long cost = -1;
+
+                            @Override
+                            public Scorer get(long leadCost) throws IOException {
+                                intersectRight(values.getPointTree(), visitor, docCount);
+                                DocIdSetIterator iterator = result.build().iterator();
+                                return new ConstantScoreScorer(weight, score(), scoreMode, iterator);
+                            }
+
+                            @Override
+                            public long cost() {
+                                if (cost == -1) {
+                                    // Computing the cost may be expensive, so only do it if necessary
+                                    cost = values.estimateDocCount(visitor);
+                                    assert cost >= 0;
+                                }
+                                return cost;
+                            }
+                        };
+                    }
+                }
+            }
+
+            @Override
+            public Scorer scorer(LeafReaderContext context) throws IOException {
+                ScorerSupplier scorerSupplier = scorerSupplier(context);
+                if (scorerSupplier == null) {
+                    return null;
+                }
+                return scorerSupplier.get(Long.MAX_VALUE);
+            }
+
+            @Override
+            public int count(LeafReaderContext context) throws IOException {
+                return pointRangeQueryWeight.count(context);
+            }
+
+            @Override
+            public boolean isCacheable(LeafReaderContext ctx) {
+                return false;
+            }
+        };
+    }
+
+    @Override
+    public boolean canApproximate(SearchContext context) {
+        if (context == null) {
+            return false;
+        }
+        if (context.aggregations() != null) {
+            return false;
+        }
+        if (!(context.query() instanceof ApproximateIndexOrDocValuesQuery)) {
+            return false;
+        }
+        // size 0 could be set for caching
+        if (context.from() + context.size() == 0) {
+            this.setSize(10_000);
+        }
+        this.setSize(Math.max(context.from() + context.size(), context.trackTotalHitsUpTo()));
+        if (context.request() != null && context.request().source() != null) {
+            FieldSortBuilder primarySortField = FieldSortBuilder.getPrimaryFieldSortOrNull(context.request().source());
+            if (primarySortField != null
+                && primarySortField.missing() == null
+                && primarySortField.getFieldName().equals(((RangeQueryBuilder) context.request().source().query()).fieldName())) {
+                if (primarySortField.order() == SortOrder.DESC) {
+                    this.setSortOrder(SortOrder.DESC);
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public final int hashCode() {
+        return pointRangeQuery.hashCode();
+    }
+
+    @Override
+    public final boolean equals(Object o) {
+        return sameClassAs(o) && equalsTo(getClass().cast(o));
+    }
+
+    private boolean equalsTo(ApproximatePointRangeQuery other) {
+        return Objects.equals(pointRangeQuery.getField(), other.pointRangeQuery.getField())
+            && pointRangeQuery.getNumDims() == other.pointRangeQuery.getNumDims()
+            && pointRangeQuery.getBytesPerDim() == other.pointRangeQuery.getBytesPerDim()
+            && Arrays.equals(pointRangeQuery.getLowerPoint(), other.pointRangeQuery.getLowerPoint())
+            && Arrays.equals(pointRangeQuery.getUpperPoint(), other.pointRangeQuery.getUpperPoint());
+    }
+
+    @Override
+    public final String toString(String field) {
+        final StringBuilder sb = new StringBuilder();
+        if (pointRangeQuery.getField().equals(field) == false) {
+            sb.append(pointRangeQuery.getField());
+            sb.append(':');
+        }
+
+        // print ourselves as "range per dimension"
+        for (int i = 0; i < pointRangeQuery.getNumDims(); i++) {
+            if (i > 0) {
+                sb.append(',');
+            }
+
+            int startOffset = pointRangeQuery.getBytesPerDim() * i;
+
+            sb.append('[');
+            sb.append(
+                toString(
+                    i,
+                    ArrayUtil.copyOfSubArray(pointRangeQuery.getLowerPoint(), startOffset, startOffset + pointRangeQuery.getBytesPerDim())
+                )
+            );
+            sb.append(" TO ");
+            sb.append(
+                toString(
+                    i,
+                    ArrayUtil.copyOfSubArray(pointRangeQuery.getUpperPoint(), startOffset, startOffset + pointRangeQuery.getBytesPerDim())
+                )
+            );
+            sb.append(']');
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Returns a string of a single value in a human-readable format for debugging. This is used by
+     * {@link #toString()}.
+     *
+     * @param dimension dimension of the particular value
+     * @param value     single value, never null
+     * @return human readable value for debugging
+     */
+    protected abstract String toString(int dimension, byte[] value);
+}
diff --git a/server/src/main/java/org/opensearch/search/approximate/ApproximateQuery.java b/server/src/main/java/org/opensearch/search/approximate/ApproximateQuery.java
new file mode 100644
index 0000000000000..0e6faf396b671
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/approximate/ApproximateQuery.java
@@ -0,0 +1,21 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.approximate;
+
+import org.apache.lucene.search.Query;
+import org.opensearch.search.internal.SearchContext;
+
+/**
+ * Abstract class that can be inherited by queries that can be approximated. Queries should implement {@link #canApproximate(SearchContext)} to specify conditions on when they can be approximated
+*/
+public abstract class ApproximateQuery extends Query {
+
+    protected abstract boolean canApproximate(SearchContext context);
+
+}
diff --git a/server/src/main/java/org/opensearch/search/approximate/ApproximateScoreQuery.java b/server/src/main/java/org/opensearch/search/approximate/ApproximateScoreQuery.java
new file mode 100644
index 0000000000000..d1dd32b239f28
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/approximate/ApproximateScoreQuery.java
@@ -0,0 +1,90 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.approximate;
+
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.QueryVisitor;
+import org.apache.lucene.search.Weight;
+import org.opensearch.search.internal.SearchContext;
+
+import java.io.IOException;
+
+/**
+ * Entry-point for the approximation framework.
+ * This class is heavily inspired by {@link org.apache.lucene.search.IndexOrDocValuesQuery}. It acts as a wrapper that consumer two queries, a regular query and an approximate version of the same. By default, it executes the regular query and returns {@link Weight#scorer} for the original query. At run-time, depending on certain constraints, we can re-write the {@code Weight} to use the approximate weight instead.
+ */
+public class ApproximateScoreQuery extends Query {
+
+    private final Query originalQuery;
+    private final ApproximateQuery approximationQuery;
+
+    protected Query resolvedQuery;
+
+    public ApproximateScoreQuery(Query originalQuery, ApproximateQuery approximationQuery) {
+        this.originalQuery = originalQuery;
+        this.approximationQuery = approximationQuery;
+    }
+
+    public Query getOriginalQuery() {
+        return originalQuery;
+    }
+
+    public ApproximateQuery getApproximationQuery() {
+        return approximationQuery;
+    }
+
+    @Override
+    public final Query rewrite(IndexSearcher indexSearcher) throws IOException {
+        if (resolvedQuery == null) {
+            throw new IllegalStateException("Cannot rewrite resolved query without setContext being called");
+        }
+        return resolvedQuery.rewrite(indexSearcher);
+    }
+
+    public void setContext(SearchContext context) {
+        if (resolvedQuery != null) {
+            throw new IllegalStateException("Query already resolved, duplicate call to setContext");
+        }
+        resolvedQuery = approximationQuery.canApproximate(context) ? approximationQuery : originalQuery;
+    };
+
+    @Override
+    public String toString(String s) {
+        return "ApproximateScoreQuery(originalQuery="
+            + originalQuery.toString()
+            + ", approximationQuery="
+            + approximationQuery.toString()
+            + ")";
+    }
+
+    @Override
+    public void visit(QueryVisitor queryVisitor) {
+        QueryVisitor v = queryVisitor.getSubVisitor(BooleanClause.Occur.MUST, this);
+        originalQuery.visit(v);
+        approximationQuery.visit(v);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (!sameClassAs(o)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int h = classHash();
+        h = 31 * h + originalQuery.hashCode();
+        h = 31 * h + approximationQuery.hashCode();
+        return h;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/approximate/package-info.java b/server/src/main/java/org/opensearch/search/approximate/package-info.java
new file mode 100644
index 0000000000000..1a09183c7d9fa
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/approximate/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Approximation query framework to approximate commonly used queries
+ */
+package org.opensearch.search.approximate;
diff --git a/server/src/main/java/org/opensearch/search/backpressure/SearchBackpressureService.java b/server/src/main/java/org/opensearch/search/backpressure/SearchBackpressureService.java
index fac1ac319087e..e04a56ad4c84f 100644
--- a/server/src/main/java/org/opensearch/search/backpressure/SearchBackpressureService.java
+++ b/server/src/main/java/org/opensearch/search/backpressure/SearchBackpressureService.java
@@ -28,9 +28,11 @@
 import org.opensearch.search.backpressure.trackers.CpuUsageTracker;
 import org.opensearch.search.backpressure.trackers.ElapsedTimeTracker;
 import org.opensearch.search.backpressure.trackers.HeapUsageTracker;
-import org.opensearch.search.backpressure.trackers.NodeDuressTracker;
-import org.opensearch.search.backpressure.trackers.TaskResourceUsageTracker;
+import org.opensearch.search.backpressure.trackers.NodeDuressTrackers;
+import org.opensearch.search.backpressure.trackers.NodeDuressTrackers.NodeDuressTracker;
 import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackerType;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 import org.opensearch.tasks.CancellableTask;
 import org.opensearch.tasks.SearchBackpressureTask;
 import org.opensearch.tasks.Task;
@@ -40,15 +42,18 @@
 import org.opensearch.tasks.TaskResourceTrackingService.TaskCompletionListener;
 import org.opensearch.threadpool.Scheduler;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.wlm.ResourceType;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.Comparator;
+import java.util.EnumMap;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.DoubleSupplier;
+import java.util.function.Function;
 import java.util.function.LongSupplier;
 import java.util.stream.Collectors;
 
@@ -62,16 +67,22 @@
  */
 public class SearchBackpressureService extends AbstractLifecycleComponent implements TaskCompletionListener {
     private static final Logger logger = LogManager.getLogger(SearchBackpressureService.class);
-
+    private static final Map<TaskResourceUsageTrackerType, Function<NodeDuressTrackers, Boolean>> trackerApplyConditions = Map.of(
+        TaskResourceUsageTrackerType.CPU_USAGE_TRACKER,
+        (nodeDuressTrackers) -> nodeDuressTrackers.isResourceInDuress(ResourceType.CPU),
+        TaskResourceUsageTrackerType.HEAP_USAGE_TRACKER,
+        (nodeDuressTrackers) -> isHeapTrackingSupported() && nodeDuressTrackers.isResourceInDuress(ResourceType.MEMORY),
+        TaskResourceUsageTrackerType.ELAPSED_TIME_TRACKER,
+        (nodeDuressTrackers) -> true
+    );
     private volatile Scheduler.Cancellable scheduledFuture;
 
     private final SearchBackpressureSettings settings;
     private final TaskResourceTrackingService taskResourceTrackingService;
     private final ThreadPool threadPool;
-    private final LongSupplier timeNanosSupplier;
 
-    private final List<NodeDuressTracker> nodeDuressTrackers;
-    private final Map<Class<? extends SearchBackpressureTask>, List<TaskResourceUsageTracker>> taskTrackers;
+    private final NodeDuressTrackers nodeDuressTrackers;
+    private final Map<Class<? extends SearchBackpressureTask>, TaskResourceUsageTrackers> taskTrackers;
 
     private final Map<Class<? extends SearchBackpressureTask>, SearchBackpressureState> searchBackpressureStates;
     private final TaskManager taskManager;
@@ -82,19 +93,26 @@ public SearchBackpressureService(
         ThreadPool threadPool,
         TaskManager taskManager
     ) {
-        this(
-            settings,
-            taskResourceTrackingService,
-            threadPool,
-            System::nanoTime,
-            List.of(
-                new NodeDuressTracker(
-                    () -> ProcessProbe.getInstance().getProcessCpuPercent() / 100.0 >= settings.getNodeDuressSettings().getCpuThreshold()
-                ),
-                new NodeDuressTracker(
-                    () -> JvmStats.jvmStats().getMem().getHeapUsedPercent() / 100.0 >= settings.getNodeDuressSettings().getHeapThreshold()
-                )
-            ),
+        this(settings, taskResourceTrackingService, threadPool, System::nanoTime, new NodeDuressTrackers(new EnumMap<>(ResourceType.class) {
+            {
+                put(
+                    ResourceType.CPU,
+                    new NodeDuressTracker(
+                        () -> ProcessProbe.getInstance().getProcessCpuPercent() / 100.0 >= settings.getNodeDuressSettings()
+                            .getCpuThreshold(),
+                        () -> settings.getNodeDuressSettings().getNumSuccessiveBreaches()
+                    )
+                );
+                put(
+                    ResourceType.MEMORY,
+                    new NodeDuressTracker(
+                        () -> JvmStats.jvmStats().getMem().getHeapUsedPercent() / 100.0 >= settings.getNodeDuressSettings()
+                            .getHeapThreshold(),
+                        () -> settings.getNodeDuressSettings().getNumSuccessiveBreaches()
+                    )
+                );
+            }
+        }),
             getTrackers(
                 settings.getSearchTaskSettings()::getCpuTimeNanosThreshold,
                 settings.getSearchTaskSettings()::getHeapVarianceThreshold,
@@ -117,21 +135,20 @@ public SearchBackpressureService(
         );
     }
 
-    public SearchBackpressureService(
+    SearchBackpressureService(
         SearchBackpressureSettings settings,
         TaskResourceTrackingService taskResourceTrackingService,
         ThreadPool threadPool,
         LongSupplier timeNanosSupplier,
-        List<NodeDuressTracker> nodeDuressTrackers,
-        List<TaskResourceUsageTracker> searchTaskTrackers,
-        List<TaskResourceUsageTracker> searchShardTaskTrackers,
+        NodeDuressTrackers nodeDuressTrackers,
+        TaskResourceUsageTrackers searchTaskTrackers,
+        TaskResourceUsageTrackers searchShardTaskTrackers,
         TaskManager taskManager
     ) {
         this.settings = settings;
         this.taskResourceTrackingService = taskResourceTrackingService;
         this.taskResourceTrackingService.addTaskCompletionListener(this);
         this.threadPool = threadPool;
-        this.timeNanosSupplier = timeNanosSupplier;
         this.nodeDuressTrackers = nodeDuressTrackers;
         this.taskManager = taskManager;
 
@@ -163,40 +180,48 @@ void doRun() {
             return;
         }
 
-        if (isNodeInDuress() == false) {
+        if (nodeDuressTrackers.isNodeInDuress() == false) {
             return;
         }
 
         List<CancellableTask> searchTasks = getTaskByType(SearchTask.class);
         List<CancellableTask> searchShardTasks = getTaskByType(SearchShardTask.class);
-        List<CancellableTask> cancellableTasks = new ArrayList<>();
+
+        boolean isHeapUsageDominatedBySearchTasks = isHeapUsageDominatedBySearch(
+            searchTasks,
+            getSettings().getSearchTaskSettings().getTotalHeapPercentThreshold()
+        );
+        boolean isHeapUsageDominatedBySearchShardTasks = isHeapUsageDominatedBySearch(
+            searchShardTasks,
+            getSettings().getSearchShardTaskSettings().getTotalHeapPercentThreshold()
+        );
+        final Map<Class<? extends SearchBackpressureTask>, List<CancellableTask>> cancellableTasks = Map.of(
+            SearchTask.class,
+            isHeapUsageDominatedBySearchTasks ? searchTasks : Collections.emptyList(),
+            SearchShardTask.class,
+            isHeapUsageDominatedBySearchShardTasks ? searchShardTasks : Collections.emptyList()
+        );
 
         // Force-refresh usage stats of these tasks before making a cancellation decision.
         taskResourceTrackingService.refreshResourceStats(searchTasks.toArray(new Task[0]));
         taskResourceTrackingService.refreshResourceStats(searchShardTasks.toArray(new Task[0]));
 
-        // Check if increase in heap usage is due to SearchTasks
-        if (HeapUsageTracker.isHeapUsageDominatedBySearch(
-            searchTasks,
-            getSettings().getSearchTaskSettings().getTotalHeapPercentThreshold()
-        )) {
-            cancellableTasks.addAll(searchTasks);
-        }
+        List<TaskCancellation> taskCancellations = new ArrayList<>();
 
-        // Check if increase in heap usage is due to SearchShardTasks
-        if (HeapUsageTracker.isHeapUsageDominatedBySearch(
-            searchShardTasks,
-            getSettings().getSearchShardTaskSettings().getTotalHeapPercentThreshold()
-        )) {
-            cancellableTasks.addAll(searchShardTasks);
+        for (TaskResourceUsageTrackerType trackerType : TaskResourceUsageTrackerType.values()) {
+            if (shouldApply(trackerType)) {
+                addResourceTrackerBasedCancellations(trackerType, taskCancellations, cancellableTasks);
+            }
         }
 
-        // none of the task type is breaching the heap usage thresholds and hence we do not cancel any tasks
-        if (cancellableTasks.isEmpty()) {
-            return;
-        }
+        // Since these cancellations might be duplicate due to multiple trackers causing cancellation for same task
+        // We need to merge them
+        taskCancellations = mergeTaskCancellations(taskCancellations).stream()
+            .map(this::addSBPStateUpdateCallback)
+            .filter(TaskCancellation::isEligibleForCancellation)
+            .collect(Collectors.toList());
 
-        for (TaskCancellation taskCancellation : getTaskCancellations(cancellableTasks)) {
+        for (TaskCancellation taskCancellation : taskCancellations) {
             logger.warn(
                 "[{} mode] cancelling task [{}] due to high resource consumption [{}]",
                 mode.getName(),
@@ -226,6 +251,66 @@ void doRun() {
         }
     }
 
+    /**
+     * Had to define this method to help mock this static method to test the scenario where SearchTraffic should not be
+     * penalised when not breaching the threshold
+     * @param searchTasks inFlight co-ordinator requests
+     * @param threshold   miniumum  jvm allocated bytes ratio w.r.t. available heap
+     * @return a boolean value based on whether the threshold is breached
+     */
+    boolean isHeapUsageDominatedBySearch(List<CancellableTask> searchTasks, double threshold) {
+        return HeapUsageTracker.isHeapUsageDominatedBySearch(searchTasks, threshold);
+    }
+
+    private TaskCancellation addSBPStateUpdateCallback(TaskCancellation taskCancellation) {
+        CancellableTask task = taskCancellation.getTask();
+        Runnable toAddCancellationCallbackForSBPState = searchBackpressureStates.get(SearchShardTask.class)::incrementCancellationCount;
+        if (task instanceof SearchTask) {
+            toAddCancellationCallbackForSBPState = searchBackpressureStates.get(SearchTask.class)::incrementCancellationCount;
+        }
+        List<Runnable> newOnCancelCallbacks = new ArrayList<>(taskCancellation.getOnCancelCallbacks());
+        newOnCancelCallbacks.add(toAddCancellationCallbackForSBPState);
+        return new TaskCancellation(task, taskCancellation.getReasons(), newOnCancelCallbacks);
+    }
+
+    private boolean shouldApply(TaskResourceUsageTrackerType trackerType) {
+        return trackerApplyConditions.get(trackerType).apply(nodeDuressTrackers);
+    }
+
+    private List<TaskCancellation> addResourceTrackerBasedCancellations(
+        TaskResourceUsageTrackerType type,
+        List<TaskCancellation> taskCancellations,
+        Map<Class<? extends SearchBackpressureTask>, List<CancellableTask>> cancellableTasks
+    ) {
+        for (Map.Entry<Class<? extends SearchBackpressureTask>, TaskResourceUsageTrackers> taskResourceUsageTrackers : taskTrackers
+            .entrySet()) {
+            final Optional<TaskResourceUsageTracker> taskResourceUsageTracker = taskResourceUsageTrackers.getValue().getTracker(type);
+            final Class<? extends SearchBackpressureTask> taskType = taskResourceUsageTrackers.getKey();
+
+            taskResourceUsageTracker.ifPresent(
+                tracker -> taskCancellations.addAll(tracker.getTaskCancellations(cancellableTasks.get(taskType)))
+            );
+        }
+
+        return taskCancellations;
+    }
+
+    /**
+     * Method to reduce the taskCancellations into unique bunch
+     * @param taskCancellations all task cancellations
+     * @return unique task cancellations
+     */
+    private List<TaskCancellation> mergeTaskCancellations(final List<TaskCancellation> taskCancellations) {
+        final Map<Long, TaskCancellation> uniqueTaskCancellations = new HashMap<>();
+
+        for (TaskCancellation taskCancellation : taskCancellations) {
+            final long taskId = taskCancellation.getTask().getId();
+            uniqueTaskCancellations.put(taskId, uniqueTaskCancellations.getOrDefault(taskId, taskCancellation).merge(taskCancellation));
+        }
+
+        return new ArrayList<>(uniqueTaskCancellations.values());
+    }
+
     /**
      * Given a task, returns the type of the task
      */
@@ -243,16 +328,7 @@ Class<? extends SearchBackpressureTask> getTaskType(Task task) {
      * Returns true if the node is in duress consecutively for the past 'n' observations.
      */
     boolean isNodeInDuress() {
-        boolean isNodeInDuress = false;
-        int numSuccessiveBreaches = getSettings().getNodeDuressSettings().getNumSuccessiveBreaches();
-
-        for (NodeDuressTracker tracker : nodeDuressTrackers) {
-            if (tracker.check() >= numSuccessiveBreaches) {
-                isNodeInDuress = true;  // not breaking the loop so that each tracker's streak gets updated.
-            }
-        }
-
-        return isNodeInDuress;
+        return nodeDuressTrackers.isNodeInDuress();
     }
 
     /*
@@ -271,39 +347,6 @@ <T extends CancellableTask & SearchBackpressureTask> List<CancellableTask> getTa
             .collect(Collectors.toUnmodifiableList());
     }
 
-    /**
-     * Returns a TaskCancellation wrapper containing the list of reasons (possibly zero), along with an overall
-     * cancellation score for the given task. Cancelling a task with a higher score has better chance of recovering the
-     * node from duress.
-     */
-    TaskCancellation getTaskCancellation(CancellableTask task) {
-        List<TaskCancellation.Reason> reasons = new ArrayList<>();
-        List<Runnable> callbacks = new ArrayList<>();
-        Class<? extends SearchBackpressureTask> taskType = getTaskType(task);
-        List<TaskResourceUsageTracker> trackers = taskTrackers.get(taskType);
-        for (TaskResourceUsageTracker tracker : trackers) {
-            Optional<TaskCancellation.Reason> reason = tracker.checkAndMaybeGetCancellationReason(task);
-            if (reason.isPresent()) {
-                callbacks.add(tracker::incrementCancellations);
-                reasons.add(reason.get());
-            }
-        }
-        callbacks.add(searchBackpressureStates.get(taskType)::incrementCancellationCount);
-
-        return new TaskCancellation(task, reasons, callbacks);
-    }
-
-    /**
-     * Returns a list of TaskCancellations sorted by descending order of their cancellation scores.
-     */
-    List<TaskCancellation> getTaskCancellations(List<? extends CancellableTask> tasks) {
-        return tasks.stream()
-            .map(this::getTaskCancellation)
-            .filter(TaskCancellation::isEligibleForCancellation)
-            .sorted(Comparator.reverseOrder())
-            .collect(Collectors.toUnmodifiableList());
-    }
-
     SearchBackpressureSettings getSettings() {
         return settings;
     }
@@ -315,7 +358,7 @@ SearchBackpressureState getSearchBackpressureState(Class<? extends SearchBackpre
     /**
      * Given the threshold suppliers, returns the list of applicable trackers
      */
-    public static List<TaskResourceUsageTracker> getTrackers(
+    public static TaskResourceUsageTrackers getTrackers(
         LongSupplier cpuThresholdSupplier,
         DoubleSupplier heapVarianceSupplier,
         DoubleSupplier heapPercentThresholdSupplier,
@@ -324,23 +367,27 @@ public static List<TaskResourceUsageTracker> getTrackers(
         ClusterSettings clusterSettings,
         Setting<Integer> windowSizeSetting
     ) {
-        List<TaskResourceUsageTracker> trackers = new ArrayList<>();
-        trackers.add(new CpuUsageTracker(cpuThresholdSupplier));
+        TaskResourceUsageTrackers trackers = new TaskResourceUsageTrackers();
+        trackers.addTracker(new CpuUsageTracker(cpuThresholdSupplier), TaskResourceUsageTrackerType.CPU_USAGE_TRACKER);
         if (isHeapTrackingSupported()) {
-            trackers.add(
+            trackers.addTracker(
                 new HeapUsageTracker(
                     heapVarianceSupplier,
                     heapPercentThresholdSupplier,
                     heapMovingAverageWindowSize,
                     clusterSettings,
                     windowSizeSetting
-                )
+                ),
+                TaskResourceUsageTrackerType.HEAP_USAGE_TRACKER
             );
         } else {
             logger.warn("heap size couldn't be determined");
         }
-        trackers.add(new ElapsedTimeTracker(ElapsedTimeNanosSupplier, System::nanoTime));
-        return Collections.unmodifiableList(trackers);
+        trackers.addTracker(
+            new ElapsedTimeTracker(ElapsedTimeNanosSupplier, System::nanoTime),
+            TaskResourceUsageTrackerType.ELAPSED_TIME_TRACKER
+        );
+        return trackers;
     }
 
     @Override
@@ -360,8 +407,8 @@ public void onTaskCompleted(Task task) {
         }
 
         List<Exception> exceptions = new ArrayList<>();
-        List<TaskResourceUsageTracker> trackers = taskTrackers.get(taskType);
-        for (TaskResourceUsageTracker tracker : trackers) {
+        TaskResourceUsageTrackers trackers = taskTrackers.get(taskType);
+        for (TaskResourceUsageTracker tracker : trackers.all()) {
             try {
                 tracker.update(task);
             } catch (Exception e) {
@@ -400,6 +447,7 @@ public SearchBackpressureStats nodeStats() {
             searchBackpressureStates.get(SearchTask.class).getCancellationCount(),
             searchBackpressureStates.get(SearchTask.class).getLimitReachedCount(),
             taskTrackers.get(SearchTask.class)
+                .all()
                 .stream()
                 .collect(Collectors.toUnmodifiableMap(t -> TaskResourceUsageTrackerType.fromName(t.name()), t -> t.stats(searchTasks)))
         );
@@ -408,6 +456,7 @@ public SearchBackpressureStats nodeStats() {
             searchBackpressureStates.get(SearchShardTask.class).getCancellationCount(),
             searchBackpressureStates.get(SearchShardTask.class).getLimitReachedCount(),
             taskTrackers.get(SearchShardTask.class)
+                .all()
                 .stream()
                 .collect(Collectors.toUnmodifiableMap(t -> TaskResourceUsageTrackerType.fromName(t.name()), t -> t.stats(searchShardTasks)))
         );
diff --git a/server/src/main/java/org/opensearch/search/backpressure/settings/SearchShardTaskSettings.java b/server/src/main/java/org/opensearch/search/backpressure/settings/SearchShardTaskSettings.java
index 105023a20173f..6d016c7466362 100644
--- a/server/src/main/java/org/opensearch/search/backpressure/settings/SearchShardTaskSettings.java
+++ b/server/src/main/java/org/opensearch/search/backpressure/settings/SearchShardTaskSettings.java
@@ -26,12 +26,8 @@
  */
 public class SearchShardTaskSettings {
     private final List<CancellationSettingsListener> listeners = new ArrayList<>();
-    private final ClusterSettings clusterSettings;
 
     private static class Defaults {
-        private static final double CANCELLATION_RATIO = 0.1;
-        private static final double CANCELLATION_RATE = 0.003;
-        private static final double CANCELLATION_BURST = 10.0;
         private static final double TOTAL_HEAP_PERCENT_THRESHOLD = 0.05;
         private static final long CPU_TIME_MILLIS_THRESHOLD = 15000;
         private static final long ELAPSED_TIME_MILLIS_THRESHOLD = 30000;
@@ -165,7 +161,6 @@ public SearchShardTaskSettings(Settings settings, ClusterSettings clusterSetting
         this.cancellationRatio = SETTING_CANCELLATION_RATIO.get(settings);
         this.cancellationRate = SETTING_CANCELLATION_RATE.get(settings);
         this.cancellationBurst = SETTING_CANCELLATION_BURST.get(settings);
-        this.clusterSettings = clusterSettings;
 
         clusterSettings.addSettingsUpdateConsumer(SETTING_TOTAL_HEAP_PERCENT_THRESHOLD, this::setTotalHeapPercentThreshold);
         clusterSettings.addSettingsUpdateConsumer(SETTING_CPU_TIME_MILLIS_THRESHOLD, this::setCpuTimeMillisThreshold);
diff --git a/server/src/main/java/org/opensearch/search/backpressure/settings/SearchTaskSettings.java b/server/src/main/java/org/opensearch/search/backpressure/settings/SearchTaskSettings.java
index 4b12eda9fb59d..4b34323b1ddc6 100644
--- a/server/src/main/java/org/opensearch/search/backpressure/settings/SearchTaskSettings.java
+++ b/server/src/main/java/org/opensearch/search/backpressure/settings/SearchTaskSettings.java
@@ -27,7 +27,6 @@
 
 public class SearchTaskSettings {
     private final List<CancellationSettingsListener> listeners = new ArrayList<>();
-    private final ClusterSettings clusterSettings;
 
     private static class Defaults {
         private static final double CANCELLATION_RATIO = 0.1;
@@ -166,7 +165,6 @@ public SearchTaskSettings(Settings settings, ClusterSettings clusterSettings) {
         this.cancellationRatio = SETTING_CANCELLATION_RATIO.get(settings);
         this.cancellationRate = SETTING_CANCELLATION_RATE.get(settings);
         this.cancellationBurst = SETTING_CANCELLATION_BURST.get(settings);
-        this.clusterSettings = clusterSettings;
 
         clusterSettings.addSettingsUpdateConsumer(SETTING_TOTAL_HEAP_PERCENT_THRESHOLD, this::setTotalHeapPercentThreshold);
         clusterSettings.addSettingsUpdateConsumer(SETTING_CPU_TIME_MILLIS_THRESHOLD, this::setCpuTimeMillisThreshold);
diff --git a/server/src/main/java/org/opensearch/search/backpressure/stats/SearchShardTaskStats.java b/server/src/main/java/org/opensearch/search/backpressure/stats/SearchShardTaskStats.java
index 678c19d83fb96..6c76f94f5c940 100644
--- a/server/src/main/java/org/opensearch/search/backpressure/stats/SearchShardTaskStats.java
+++ b/server/src/main/java/org/opensearch/search/backpressure/stats/SearchShardTaskStats.java
@@ -17,8 +17,8 @@
 import org.opensearch.search.backpressure.trackers.CpuUsageTracker;
 import org.opensearch.search.backpressure.trackers.ElapsedTimeTracker;
 import org.opensearch.search.backpressure.trackers.HeapUsageTracker;
-import org.opensearch.search.backpressure.trackers.TaskResourceUsageTracker;
 import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackerType;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 
 import java.io.IOException;
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/search/backpressure/stats/SearchTaskStats.java b/server/src/main/java/org/opensearch/search/backpressure/stats/SearchTaskStats.java
index 302350104bd3a..279f239703f3c 100644
--- a/server/src/main/java/org/opensearch/search/backpressure/stats/SearchTaskStats.java
+++ b/server/src/main/java/org/opensearch/search/backpressure/stats/SearchTaskStats.java
@@ -17,8 +17,8 @@
 import org.opensearch.search.backpressure.trackers.CpuUsageTracker;
 import org.opensearch.search.backpressure.trackers.ElapsedTimeTracker;
 import org.opensearch.search.backpressure.trackers.HeapUsageTracker;
-import org.opensearch.search.backpressure.trackers.TaskResourceUsageTracker;
 import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackerType;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 
 import java.io.IOException;
 import java.util.Map;
diff --git a/server/src/main/java/org/opensearch/search/backpressure/trackers/CpuUsageTracker.java b/server/src/main/java/org/opensearch/search/backpressure/trackers/CpuUsageTracker.java
index 507953cb4a20e..a303b625f4b59 100644
--- a/server/src/main/java/org/opensearch/search/backpressure/trackers/CpuUsageTracker.java
+++ b/server/src/main/java/org/opensearch/search/backpressure/trackers/CpuUsageTracker.java
@@ -12,6 +12,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskCancellation;
 
@@ -34,7 +35,30 @@ public class CpuUsageTracker extends TaskResourceUsageTracker {
     private final LongSupplier thresholdSupplier;
 
     public CpuUsageTracker(LongSupplier thresholdSupplier) {
+        this(thresholdSupplier, (task) -> {
+            long usage = task.getTotalResourceStats().getCpuTimeInNanos();
+            long threshold = thresholdSupplier.getAsLong();
+
+            if (usage < threshold) {
+                return Optional.empty();
+            }
+
+            return Optional.of(
+                new TaskCancellation.Reason(
+                    "cpu usage exceeded ["
+                        + new TimeValue(usage, TimeUnit.NANOSECONDS)
+                        + " >= "
+                        + new TimeValue(threshold, TimeUnit.NANOSECONDS)
+                        + "]",
+                    1  // TODO: fine-tune the cancellation score/weight
+                )
+            );
+        });
+    }
+
+    public CpuUsageTracker(LongSupplier thresholdSupplier, ResourceUsageBreachEvaluator resourceUsageBreachEvaluator) {
         this.thresholdSupplier = thresholdSupplier;
+        this.resourceUsageBreachEvaluator = resourceUsageBreachEvaluator;
     }
 
     @Override
@@ -42,27 +66,6 @@ public String name() {
         return CPU_USAGE_TRACKER.getName();
     }
 
-    @Override
-    public Optional<TaskCancellation.Reason> checkAndMaybeGetCancellationReason(Task task) {
-        long usage = task.getTotalResourceStats().getCpuTimeInNanos();
-        long threshold = thresholdSupplier.getAsLong();
-
-        if (usage < threshold) {
-            return Optional.empty();
-        }
-
-        return Optional.of(
-            new TaskCancellation.Reason(
-                "cpu usage exceeded ["
-                    + new TimeValue(usage, TimeUnit.NANOSECONDS)
-                    + " >= "
-                    + new TimeValue(threshold, TimeUnit.NANOSECONDS)
-                    + "]",
-                1  // TODO: fine-tune the cancellation score/weight
-            )
-        );
-    }
-
     @Override
     public TaskResourceUsageTracker.Stats stats(List<? extends Task> activeTasks) {
         long currentMax = activeTasks.stream().mapToLong(t -> t.getTotalResourceStats().getCpuTimeInNanos()).max().orElse(0);
diff --git a/server/src/main/java/org/opensearch/search/backpressure/trackers/ElapsedTimeTracker.java b/server/src/main/java/org/opensearch/search/backpressure/trackers/ElapsedTimeTracker.java
index f1e8abe7e3230..216947315cd2d 100644
--- a/server/src/main/java/org/opensearch/search/backpressure/trackers/ElapsedTimeTracker.java
+++ b/server/src/main/java/org/opensearch/search/backpressure/trackers/ElapsedTimeTracker.java
@@ -12,6 +12,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskCancellation;
 
@@ -34,8 +35,35 @@ public class ElapsedTimeTracker extends TaskResourceUsageTracker {
     private final LongSupplier timeNanosSupplier;
 
     public ElapsedTimeTracker(LongSupplier thresholdSupplier, LongSupplier timeNanosSupplier) {
+        this(thresholdSupplier, timeNanosSupplier, (Task task) -> {
+            long usage = timeNanosSupplier.getAsLong() - task.getStartTimeNanos();
+            long threshold = thresholdSupplier.getAsLong();
+
+            if (usage < threshold) {
+                return Optional.empty();
+            }
+
+            return Optional.of(
+                new TaskCancellation.Reason(
+                    "elapsed time exceeded ["
+                        + new TimeValue(usage, TimeUnit.NANOSECONDS)
+                        + " >= "
+                        + new TimeValue(threshold, TimeUnit.NANOSECONDS)
+                        + "]",
+                    1  // TODO: fine-tune the cancellation score/weight
+                )
+            );
+        });
+    }
+
+    public ElapsedTimeTracker(
+        LongSupplier thresholdSupplier,
+        LongSupplier timeNanosSupplier,
+        ResourceUsageBreachEvaluator resourceUsageBreachEvaluator
+    ) {
         this.thresholdSupplier = thresholdSupplier;
         this.timeNanosSupplier = timeNanosSupplier;
+        this.resourceUsageBreachEvaluator = resourceUsageBreachEvaluator;
     }
 
     @Override
@@ -43,27 +71,6 @@ public String name() {
         return ELAPSED_TIME_TRACKER.getName();
     }
 
-    @Override
-    public Optional<TaskCancellation.Reason> checkAndMaybeGetCancellationReason(Task task) {
-        long usage = timeNanosSupplier.getAsLong() - task.getStartTimeNanos();
-        long threshold = thresholdSupplier.getAsLong();
-
-        if (usage < threshold) {
-            return Optional.empty();
-        }
-
-        return Optional.of(
-            new TaskCancellation.Reason(
-                "elapsed time exceeded ["
-                    + new TimeValue(usage, TimeUnit.NANOSECONDS)
-                    + " >= "
-                    + new TimeValue(threshold, TimeUnit.NANOSECONDS)
-                    + "]",
-                1  // TODO: fine-tune the cancellation score/weight
-            )
-        );
-    }
-
     @Override
     public TaskResourceUsageTracker.Stats stats(List<? extends Task> activeTasks) {
         long now = timeNanosSupplier.getAsLong();
diff --git a/server/src/main/java/org/opensearch/search/backpressure/trackers/HeapUsageTracker.java b/server/src/main/java/org/opensearch/search/backpressure/trackers/HeapUsageTracker.java
index 56b9f947f6e37..c69de8ce21f89 100644
--- a/server/src/main/java/org/opensearch/search/backpressure/trackers/HeapUsageTracker.java
+++ b/server/src/main/java/org/opensearch/search/backpressure/trackers/HeapUsageTracker.java
@@ -18,6 +18,7 @@
 import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.monitor.jvm.JvmStats;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 import org.opensearch.tasks.CancellableTask;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskCancellation;
@@ -55,6 +56,43 @@ public HeapUsageTracker(
         this.heapPercentThresholdSupplier = heapPercentThresholdSupplier;
         this.movingAverageReference = new AtomicReference<>(new MovingAverage(heapMovingAverageWindowSize));
         clusterSettings.addSettingsUpdateConsumer(windowSizeSetting, this::updateWindowSize);
+        setDefaultResourceUsageBreachEvaluator();
+    }
+
+    /**
+     * Had to refactor this method out of the constructor as we can't pass a lambda which references a member variable in constructor
+     * error: cannot reference movingAverageReference before supertype constructor has been called
+     */
+    private void setDefaultResourceUsageBreachEvaluator() {
+        this.resourceUsageBreachEvaluator = (task) -> {
+            MovingAverage movingAverage = movingAverageReference.get();
+
+            // There haven't been enough measurements.
+            if (movingAverage.isReady() == false) {
+                return Optional.empty();
+            }
+
+            double currentUsage = task.getTotalResourceStats().getMemoryInBytes();
+            double averageUsage = movingAverage.getAverage();
+            double variance = heapVarianceSupplier.getAsDouble();
+            double allowedUsage = averageUsage * variance;
+            double threshold = heapPercentThresholdSupplier.getAsDouble() * HEAP_SIZE_BYTES;
+
+            if (isHeapTrackingSupported() == false || currentUsage < threshold || currentUsage < allowedUsage) {
+                return Optional.empty();
+            }
+
+            return Optional.of(
+                new TaskCancellation.Reason(
+                    "heap usage exceeded ["
+                        + new ByteSizeValue((long) currentUsage)
+                        + " >= "
+                        + new ByteSizeValue((long) allowedUsage)
+                        + "]",
+                    (int) (currentUsage / averageUsage)  // TODO: fine-tune the cancellation score/weight
+                )
+            );
+        };
     }
 
     @Override
@@ -67,33 +105,6 @@ public void update(Task task) {
         movingAverageReference.get().record(task.getTotalResourceStats().getMemoryInBytes());
     }
 
-    @Override
-    public Optional<TaskCancellation.Reason> checkAndMaybeGetCancellationReason(Task task) {
-        MovingAverage movingAverage = movingAverageReference.get();
-
-        // There haven't been enough measurements.
-        if (movingAverage.isReady() == false) {
-            return Optional.empty();
-        }
-
-        double currentUsage = task.getTotalResourceStats().getMemoryInBytes();
-        double averageUsage = movingAverage.getAverage();
-        double variance = heapVarianceSupplier.getAsDouble();
-        double allowedUsage = averageUsage * variance;
-        double threshold = heapPercentThresholdSupplier.getAsDouble() * HEAP_SIZE_BYTES;
-
-        if (isHeapTrackingSupported() == false || currentUsage < threshold || currentUsage < allowedUsage) {
-            return Optional.empty();
-        }
-
-        return Optional.of(
-            new TaskCancellation.Reason(
-                "heap usage exceeded [" + new ByteSizeValue((long) currentUsage) + " >= " + new ByteSizeValue((long) allowedUsage) + "]",
-                (int) (currentUsage / averageUsage)  // TODO: fine-tune the cancellation score/weight
-            )
-        );
-    }
-
     private void updateWindowSize(int heapMovingAverageWindowSize) {
         this.movingAverageReference.set(new MovingAverage(heapMovingAverageWindowSize));
     }
diff --git a/server/src/main/java/org/opensearch/search/backpressure/trackers/NodeDuressTracker.java b/server/src/main/java/org/opensearch/search/backpressure/trackers/NodeDuressTracker.java
deleted file mode 100644
index 8e35c724a8fef..0000000000000
--- a/server/src/main/java/org/opensearch/search/backpressure/trackers/NodeDuressTracker.java
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.search.backpressure.trackers;
-
-import org.opensearch.common.util.Streak;
-
-import java.util.function.BooleanSupplier;
-
-/**
- * NodeDuressTracker is used to check if the node is in duress.
- *
- * @opensearch.internal
- */
-public class NodeDuressTracker {
-    /**
-     * Tracks the number of consecutive breaches.
-     */
-    private final Streak breaches = new Streak();
-
-    /**
-     * Predicate that returns true when the node is in duress.
-     */
-    private final BooleanSupplier isNodeInDuress;
-
-    public NodeDuressTracker(BooleanSupplier isNodeInDuress) {
-        this.isNodeInDuress = isNodeInDuress;
-    }
-
-    /**
-     * Evaluates the predicate and returns the number of consecutive breaches.
-     */
-    public int check() {
-        return breaches.record(isNodeInDuress.getAsBoolean());
-    }
-}
diff --git a/server/src/main/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackers.java b/server/src/main/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackers.java
new file mode 100644
index 0000000000000..c27c50ac12c0f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackers.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.backpressure.trackers;
+
+import org.opensearch.common.util.Streak;
+import org.opensearch.wlm.ResourceType;
+
+import java.util.Map;
+import java.util.function.BooleanSupplier;
+import java.util.function.IntSupplier;
+
+/**
+ * NodeDuressTrackers is used to check if the node is in duress based on various resources.
+ *
+ * @opensearch.internal
+ */
+public class NodeDuressTrackers {
+    private final Map<ResourceType, NodeDuressTracker> duressTrackers;
+
+    public NodeDuressTrackers(Map<ResourceType, NodeDuressTracker> duressTrackers) {
+        this.duressTrackers = duressTrackers;
+    }
+
+    /**
+     * Method to check the {@link ResourceType} in duress
+     * @return Boolean
+     */
+    public boolean isResourceInDuress(ResourceType resourceType) {
+        return duressTrackers.get(resourceType).test();
+    }
+
+    /**
+     * Method to evaluate whether the node is in duress or not
+     * @return true if node is in duress because of either system resource
+     */
+    public boolean isNodeInDuress() {
+        for (ResourceType resourceType : ResourceType.values()) {
+            if (isResourceInDuress(resourceType)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * NodeDuressTracker is used to check if the node is in duress
+     * @opensearch.internal
+     */
+    public static class NodeDuressTracker {
+        /**
+         * Tracks the number of consecutive breaches.
+         */
+        private final Streak breaches = new Streak();
+
+        /**
+         * Predicate that returns true when the node is in duress.
+         */
+        private final BooleanSupplier isNodeInDuress;
+
+        /**
+         * Predicate that returns the max number of breaches allowed for this resource before we mark it as in duress
+         */
+        private final IntSupplier maxBreachAllowedSupplier;
+
+        public NodeDuressTracker(BooleanSupplier isNodeInDuress, IntSupplier maxBreachAllowedSupplier) {
+            this.isNodeInDuress = isNodeInDuress;
+            this.maxBreachAllowedSupplier = maxBreachAllowedSupplier;
+        }
+
+        /**
+         * Returns true if the node is in duress consecutively for the past 'n' observations.
+         */
+        public boolean test() {
+            return breaches.record(isNodeInDuress.getAsBoolean()) >= maxBreachAllowedSupplier.getAsInt();
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/backpressure/trackers/TaskResourceUsageTracker.java b/server/src/main/java/org/opensearch/search/backpressure/trackers/TaskResourceUsageTracker.java
deleted file mode 100644
index ce15e9e9b6622..0000000000000
--- a/server/src/main/java/org/opensearch/search/backpressure/trackers/TaskResourceUsageTracker.java
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.search.backpressure.trackers;
-
-import org.opensearch.core.common.io.stream.Writeable;
-import org.opensearch.core.xcontent.ToXContentObject;
-import org.opensearch.tasks.Task;
-import org.opensearch.tasks.TaskCancellation;
-
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.atomic.AtomicLong;
-
-/**
- * TaskResourceUsageTracker is used to track completions and cancellations of search related tasks.
- *
- * @opensearch.internal
- */
-public abstract class TaskResourceUsageTracker {
-    /**
-     * Counts the number of cancellations made due to this tracker.
-     */
-    private final AtomicLong cancellations = new AtomicLong();
-
-    public long incrementCancellations() {
-        return cancellations.incrementAndGet();
-    }
-
-    public long getCancellations() {
-        return cancellations.get();
-    }
-
-    /**
-     * Returns a unique name for this tracker.
-     */
-    public abstract String name();
-
-    /**
-     * Notifies the tracker to update its state when a task execution completes.
-     */
-    public void update(Task task) {}
-
-    /**
-     * Returns the cancellation reason for the given task, if it's eligible for cancellation.
-     */
-    public abstract Optional<TaskCancellation.Reason> checkAndMaybeGetCancellationReason(Task task);
-
-    /**
-     * Returns the tracker's state for tasks as seen in the stats API.
-     */
-    public abstract Stats stats(List<? extends Task> activeTasks);
-
-    /**
-     * Represents the tracker's state as seen in the stats API.
-     */
-    public interface Stats extends ToXContentObject, Writeable {}
-}
diff --git a/server/src/main/java/org/opensearch/search/backpressure/trackers/TaskResourceUsageTrackers.java b/server/src/main/java/org/opensearch/search/backpressure/trackers/TaskResourceUsageTrackers.java
new file mode 100644
index 0000000000000..3b0072288681c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/backpressure/trackers/TaskResourceUsageTrackers.java
@@ -0,0 +1,148 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.backpressure.trackers;
+
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.tasks.CancellableTask;
+import org.opensearch.tasks.Task;
+import org.opensearch.tasks.TaskCancellation;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Collectors;
+
+/**
+ * TaskResourceUsageTrackers is used to hold all the {@link TaskResourceUsageTracker} objects.
+ *
+ * @opensearch.internal
+ */
+public class TaskResourceUsageTrackers {
+    private final EnumMap<TaskResourceUsageTrackerType, TaskResourceUsageTracker> all;
+
+    public TaskResourceUsageTrackers() {
+        all = new EnumMap<>(TaskResourceUsageTrackerType.class);
+    }
+
+    /**
+     * adds the tracker for the TrackerType
+     * @param tracker is {@link TaskResourceUsageTracker} implementation which will be added
+     * @param trackerType is {@link TaskResourceUsageTrackerType} which depicts the implementation type
+     */
+    public void addTracker(final TaskResourceUsageTracker tracker, final TaskResourceUsageTrackerType trackerType) {
+        all.put(trackerType, tracker);
+    }
+
+    /**
+     * getter for tracker for a {@link TaskResourceUsageTrackerType}
+     * @param type for which the implementation is returned
+     * @return the {@link TaskResourceUsageTrackerType}
+     */
+    public Optional<TaskResourceUsageTracker> getTracker(TaskResourceUsageTrackerType type) {
+        return Optional.ofNullable(all.get(type));
+    }
+
+    /**
+     * Method to access all available {@link TaskResourceUsageTracker}
+     * @return all enabled and available {@link TaskResourceUsageTracker}s
+     */
+    public List<TaskResourceUsageTracker> all() {
+        return new ArrayList<>(all.values());
+    }
+
+    /**
+     * TaskResourceUsageTracker is used to track completions and cancellations of search related tasks.
+     * @opensearch.internal
+     */
+    public static abstract class TaskResourceUsageTracker {
+        /**
+         * Counts the number of cancellations made due to this tracker.
+         */
+        private final AtomicLong cancellations = new AtomicLong();
+        protected ResourceUsageBreachEvaluator resourceUsageBreachEvaluator;
+
+        /**
+         * for test purposes only
+         * @param resourceUsageBreachEvaluator which suggests whether a task should be cancelled or not
+         */
+        public void setResourceUsageBreachEvaluator(final ResourceUsageBreachEvaluator resourceUsageBreachEvaluator) {
+            this.resourceUsageBreachEvaluator = resourceUsageBreachEvaluator;
+        }
+
+        public long incrementCancellations() {
+            return cancellations.incrementAndGet();
+        }
+
+        public long getCancellations() {
+            return cancellations.get();
+        }
+
+        /**
+         * Returns a unique name for this tracker.
+         */
+        public abstract String name();
+
+        /**
+         * Notifies the tracker to update its state when a task execution completes.
+         */
+        public void update(Task task) {}
+
+        /**
+         * Returns the cancellation reason for the given task, if it's eligible for cancellation.
+         */
+        public Optional<TaskCancellation.Reason> checkAndMaybeGetCancellationReason(Task task) {
+            return resourceUsageBreachEvaluator.evaluate(task);
+        }
+
+        /**
+         * Returns the tracker's state for tasks as seen in the stats API.
+         */
+        public abstract Stats stats(List<? extends Task> activeTasks);
+
+        /**
+         * Method to get taskCancellations due to this tracker for the given {@link CancellableTask} tasks
+         * @param tasks cancellation eligible tasks due to node duress and search traffic threshold breach
+         * @return the list of tasks which are breaching task level thresholds for this {@link TaskResourceUsageTracker}
+         */
+        public List<TaskCancellation> getTaskCancellations(List<CancellableTask> tasks) {
+            return tasks.stream()
+                .map(task -> this.getTaskCancellation(task, List.of(this::incrementCancellations)))
+                .filter(TaskCancellation::isEligibleForCancellation)
+                .collect(Collectors.toList());
+        }
+
+        private TaskCancellation getTaskCancellation(final CancellableTask task, final List<Runnable> cancellationCallback) {
+            Optional<TaskCancellation.Reason> reason = checkAndMaybeGetCancellationReason(task);
+            List<TaskCancellation.Reason> reasons = new ArrayList<>();
+            reason.ifPresent(reasons::add);
+
+            return new TaskCancellation(task, reasons, cancellationCallback);
+        }
+
+        /**
+         * Represents the tracker's state as seen in the stats API.
+         */
+        public interface Stats extends ToXContentObject, Writeable {}
+
+        /**
+         * This interface carries the logic to decide whether a task should be cancelled or not
+         */
+        public interface ResourceUsageBreachEvaluator {
+            /**
+             * evaluates whether the task is eligible for cancellation based on {@link TaskResourceUsageTracker} implementation
+             * @param task is input to this method on which the cancellation evaluation is performed
+             * @return a {@link TaskCancellation.Reason} why this task should be cancelled otherwise empty
+             */
+            public Optional<TaskCancellation.Reason> evaluate(final Task task);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java b/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
index f65baa7df5cd7..d962b8cbc88a5 100644
--- a/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
+++ b/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
@@ -1021,6 +1021,37 @@ public SearchSourceBuilder derivedField(String name, String type, Script script)
         return this;
     }
 
+    /**
+     * Adds a derived field with the given name with provided type, script and other parameters
+     * @param name name of the derived field
+     * @param type type of the derived field
+     * @param script script associated with derived field
+     * @param properties map of field name and type of field for nested fields within object derived field
+     * @param prefilterField source text field which is indexed to filter documents for better performance
+     * @param format date format
+     * @param ignoreMalformed ignores malformed fields instead of failing search request
+     */
+    public SearchSourceBuilder derivedField(
+        String name,
+        String type,
+        Script script,
+        Map<String, Object> properties,
+        String prefilterField,
+        String format,
+        Boolean ignoreMalformed
+    ) {
+        if (derivedFields == null) {
+            derivedFields = new ArrayList<>();
+        }
+        DerivedField derivedField = new DerivedField(name, type, script);
+        derivedField.setProperties(properties);
+        derivedField.setPrefilterField(prefilterField);
+        derivedField.setFormat(format);
+        derivedField.setIgnoreMalformed(ignoreMalformed);
+        derivedFields.add(derivedField);
+        return this;
+    }
+
     /**
      * Sets the boost a specific index or alias will receive when the query is executed
      * against it.
diff --git a/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchDecider.java b/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchDecider.java
new file mode 100644
index 0000000000000..9c588bb45b4ec
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchDecider.java
@@ -0,0 +1,50 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.deciders;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.query.QueryBuilder;
+
+/**
+ * {@link ConcurrentSearchDecider} allows pluggable way to evaluate if a query in the search request
+ * can use concurrent segment search using the passed in queryBuilders from query tree and index settings
+ * on a per shard request basis.
+ * Implementations can also opt out of the evaluation process for certain indices based on the index settings.
+ * For all the deciders which can evaluate query tree for an index, its evaluateForQuery method
+ * will be called for each node in the query tree. After traversing of the query tree is completed, the final
+ * decision from the deciders will be obtained using {@link ConcurrentSearchDecider#getConcurrentSearchDecision}
+ */
+@ExperimentalApi
+public abstract class ConcurrentSearchDecider {
+
+    /**
+     * Evaluate for the passed in queryBuilder node in the query tree of the search request
+     * if concurrent segment search can be used.
+     * This method will be called for each of the query builder node in the query tree of the request.
+     */
+    public abstract void evaluateForQuery(QueryBuilder queryBuilder, IndexSettings indexSettings);
+
+    /**
+     * Provides a way for deciders to opt out of decision-making process for certain requests based on
+     * index settings.
+     * Return true if interested in decision making for index,
+     * false, otherwise
+     */
+    public abstract boolean canEvaluateForIndex(IndexSettings indexSettings);
+
+    /**
+     * Provide the final decision for concurrent search based on all evaluations
+     * Plugins may need to maintain internal state of evaluations to provide a final decision
+     * If decision is null, then it is ignored
+     * @return ConcurrentSearchDecision
+     */
+    public abstract ConcurrentSearchDecision getConcurrentSearchDecision();
+
+}
diff --git a/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchDecision.java b/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchDecision.java
new file mode 100644
index 0000000000000..2a30413eff9c8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchDecision.java
@@ -0,0 +1,88 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.deciders;
+
+import org.opensearch.common.annotation.ExperimentalApi;
+
+import java.util.Collection;
+
+/**
+ * This Class defines the decisions that a {@link ConcurrentSearchDecider#getConcurrentSearchDecision} can return.
+ *
+ */
+@ExperimentalApi
+public class ConcurrentSearchDecision {
+
+    final private DecisionStatus decisionStatus;
+    final private String decisionReason;
+
+    public ConcurrentSearchDecision(DecisionStatus decisionStatus, String decisionReason) {
+        this.decisionStatus = decisionStatus;
+        this.decisionReason = decisionReason;
+    }
+
+    public DecisionStatus getDecisionStatus() {
+        return decisionStatus;
+    }
+
+    public String getDecisionReason() {
+        return decisionReason;
+    }
+
+    /**
+     * This enum contains the decision status for concurrent search.
+     */
+    @ExperimentalApi
+    public enum DecisionStatus {
+        YES(0), // use concurrent search
+        NO(1),  // don't use concurrent search
+        NO_OP(2); // no preference
+
+        private final int id;
+
+        DecisionStatus(int id) {
+            this.id = id;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "ConcurrentSearchDecision{" + "decisionStatus=" + decisionStatus + ", decisionReason='" + decisionReason + '\'' + '}';
+    }
+
+    /**
+     * Combine a collection of {@link ConcurrentSearchDecision} to return final {@link ConcurrentSearchDecision}
+     * The decisions are combined as:
+     * NO_OP AND NO_OP results in NO_OP
+     * NO_OP AND YES results in YES
+     * NO_OP AND NO results in NO
+     */
+    public static ConcurrentSearchDecision getCompositeDecision(Collection<ConcurrentSearchDecision> allDecisions) {
+
+        DecisionStatus finalDecisionStatus = DecisionStatus.NO_OP;
+        for (ConcurrentSearchDecision decision : allDecisions) {
+            switch (decision.decisionStatus) {
+                case YES:
+                    finalDecisionStatus = DecisionStatus.YES;
+                    break;
+                case NO:
+                    finalDecisionStatus = DecisionStatus.NO;
+                    return new ConcurrentSearchDecision(
+                        finalDecisionStatus,
+                        "composite decision evaluated to false due to " + decision.decisionReason
+                    );
+                case NO_OP:
+                    // NOOP doesn't change the final decision
+                    break;
+            }
+        }
+        return new ConcurrentSearchDecision(finalDecisionStatus, "composite decision result");
+    }
+
+}
diff --git a/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchVisitor.java b/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchVisitor.java
new file mode 100644
index 0000000000000..12ba1b2a9cc5f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/deciders/ConcurrentSearchVisitor.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.deciders;
+
+import org.apache.lucene.search.BooleanClause;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.query.QueryBuilder;
+import org.opensearch.index.query.QueryBuilderVisitor;
+
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Class to traverse the QueryBuilder tree and invoke the
+ * {@link ConcurrentSearchDecider#evaluateForQuery} at each node of the query tree
+ */
+@ExperimentalApi
+public class ConcurrentSearchVisitor implements QueryBuilderVisitor {
+
+    private final Set<ConcurrentSearchDecider> deciders;
+    private final IndexSettings indexSettings;
+
+    public ConcurrentSearchVisitor(Set<ConcurrentSearchDecider> concurrentSearchVisitorDeciders, IndexSettings idxSettings) {
+        Objects.requireNonNull(concurrentSearchVisitorDeciders, "Concurrent search deciders cannot be null");
+        deciders = concurrentSearchVisitorDeciders;
+        indexSettings = idxSettings;
+    }
+
+    @Override
+    public void accept(QueryBuilder qb) {
+        // for each of the deciders, invoke evaluateForQuery using the current query builder and index settings.
+        deciders.forEach(concurrentSearchDecider -> { concurrentSearchDecider.evaluateForQuery(qb, indexSettings); });
+    }
+
+    @Override
+    public QueryBuilderVisitor getChildVisitor(BooleanClause.Occur occur) {
+        return this;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/deciders/package-info.java b/server/src/main/java/org/opensearch/search/deciders/package-info.java
new file mode 100644
index 0000000000000..4ef26f7be9cfc
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/deciders/package-info.java
@@ -0,0 +1,14 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * This package contains classes assist in deciding
+ * whether to run a search request using concurrent search or not.
+ */
+
+package org.opensearch.search.deciders;
diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/FastVectorHighlighter.java b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/FastVectorHighlighter.java
index 69f86bb91cc6e..6ae90b0ef8434 100644
--- a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/FastVectorHighlighter.java
+++ b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/FastVectorHighlighter.java
@@ -304,7 +304,7 @@ private static BoundaryScanner getBoundaryScanner(Field field) {
                 return DEFAULT_WORD_BOUNDARY_SCANNER;
             case CHARS:
                 if (fieldOptions.boundaryMaxScan() != SimpleBoundaryScanner.DEFAULT_MAX_SCAN
-                    || fieldOptions.boundaryChars() != SimpleBoundaryScanner.DEFAULT_BOUNDARY_CHARS) {
+                    || fieldOptions.boundaryChars() != HighlightBuilder.DEFAULT_BOUNDARY_CHARS) {
                     return new SimpleBoundaryScanner(fieldOptions.boundaryMaxScan(), fieldOptions.boundaryChars());
                 }
                 return DEFAULT_SIMPLE_BOUNDARY_SCANNER;
diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightBuilder.java b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightBuilder.java
index 0e7c3cf30ccec..44ef3a90395b8 100644
--- a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightBuilder.java
+++ b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightBuilder.java
@@ -111,6 +111,8 @@ public class HighlightBuilder extends AbstractHighlighterBuilder<HighlightBuilde
     /** the default closing tags when {@code tag_schema = "styled"}  */
     public static final String[] DEFAULT_STYLED_POST_TAGS = { "</em>" };
 
+    static final Character[] DEFAULT_BOUNDARY_CHARS = HighlightBuilder.convertCharArray(SimpleBoundaryScanner.DEFAULT_BOUNDARY_CHARS);
+
     /**
      * a {@link FieldOptions} with default settings
      */
@@ -124,7 +126,7 @@ public class HighlightBuilder extends AbstractHighlighterBuilder<HighlightBuilde
         .numberOfFragments(DEFAULT_NUMBER_OF_FRAGMENTS)
         .encoder(DEFAULT_ENCODER)
         .boundaryMaxScan(SimpleBoundaryScanner.DEFAULT_MAX_SCAN)
-        .boundaryChars(SimpleBoundaryScanner.DEFAULT_BOUNDARY_CHARS)
+        .boundaryChars(DEFAULT_BOUNDARY_CHARS)
         .boundaryScannerLocale(Locale.ROOT)
         .noMatchSize(DEFAULT_NO_MATCH_SIZE)
         .phraseLimit(DEFAULT_PHRASE_LIMIT)
diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightPhase.java b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightPhase.java
index b16f06e7e3989..41a7e9934fc4d 100644
--- a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightPhase.java
+++ b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightPhase.java
@@ -145,8 +145,8 @@ private Map<String, Function<HitContext, FieldHighlightContext>> contextBuilders
             boolean fieldNameContainsWildcards = field.field().contains("*");
             for (String fieldName : fieldNamesToHighlight) {
                 MappedFieldType fieldType = context.mapperService().fieldType(fieldName);
-                if (fieldType == null && context.getQueryShardContext().getDerivedFieldType(fieldName) != null) {
-                    fieldType = context.getQueryShardContext().getDerivedFieldType(fieldName);
+                if (fieldType == null) {
+                    fieldType = context.getQueryShardContext().resolveDerivedFieldType(fieldName);
                 }
                 if (fieldType == null) {
                     continue;
diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/UnifiedHighlighter.java b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/UnifiedHighlighter.java
index c791c8bc05054..510773c8bb2b6 100644
--- a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/UnifiedHighlighter.java
+++ b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/UnifiedHighlighter.java
@@ -160,9 +160,9 @@ CustomUnifiedHighlighter buildHighlighter(FieldHighlightContext fieldContext) th
         Integer fieldMaxAnalyzedOffset = fieldContext.field.fieldOptions().maxAnalyzerOffset();
         int numberOfFragments = fieldContext.field.fieldOptions().numberOfFragments();
         Analyzer analyzer = getAnalyzer(fieldContext.context.mapperService().documentMapper());
-        if (fieldContext.context.getQueryShardContext().getDerivedFieldType(fieldContext.fieldName) != null) {
-            analyzer = ((DerivedFieldType) fieldContext.context.getQueryShardContext().getDerivedFieldType(fieldContext.fieldName))
-                .getIndexAnalyzer();
+        MappedFieldType derivedFieldType = fieldContext.context.getQueryShardContext().resolveDerivedFieldType(fieldContext.fieldName);
+        if (derivedFieldType != null) {
+            analyzer = ((DerivedFieldType) derivedFieldType).getIndexAnalyzer();
         }
         if (fieldMaxAnalyzedOffset != null) {
             analyzer = getLimitedOffsetAnalyzer(analyzer, fieldMaxAnalyzedOffset);
diff --git a/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java b/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java
index ec3ed2332d0b8..f118e4106db83 100644
--- a/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java
+++ b/server/src/main/java/org/opensearch/search/internal/ContextIndexSearcher.java
@@ -69,6 +69,7 @@
 import org.opensearch.common.lucene.search.TopDocsAndMaxScore;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.SearchService;
+import org.opensearch.search.approximate.ApproximateScoreQuery;
 import org.opensearch.search.dfs.AggregatedDfs;
 import org.opensearch.search.profile.ContextualProfileBreakdown;
 import org.opensearch.search.profile.Timer;
@@ -218,6 +219,9 @@ public Weight createWeight(Query query, ScoreMode scoreMode, float boost) throws
                 profiler.pollLastElement();
             }
             return new ProfileWeight(query, weight, profile);
+        } else if (query instanceof ApproximateScoreQuery) {
+            ((ApproximateScoreQuery) query).setContext(searchContext);
+            return super.createWeight(query, scoreMode, boost);
         } else {
             return super.createWeight(query, scoreMode, boost);
         }
@@ -270,20 +274,27 @@ public void search(
 
     @Override
     protected void search(List<LeafReaderContext> leaves, Weight weight, Collector collector) throws IOException {
-        // Time series based workload by default traverses segments in desc order i.e. latest to the oldest order.
-        // This is actually beneficial for search queries to start search on latest segments first for time series workload.
-        // That can slow down ASC order queries on timestamp workload. So to avoid that slowdown, we will reverse leaf
-        // reader order here.
-        if (searchContext.shouldUseTimeSeriesDescSortOptimization()) {
-            for (int i = leaves.size() - 1; i >= 0; i--) {
-                searchLeaf(leaves.get(i), weight, collector);
-            }
-        } else {
-            for (int i = 0; i < leaves.size(); i++) {
-                searchLeaf(leaves.get(i), weight, collector);
+        searchContext.indexShard().getSearchOperationListener().onPreSliceExecution(searchContext);
+        try {
+            // Time series based workload by default traverses segments in desc order i.e. latest to the oldest order.
+            // This is actually beneficial for search queries to start search on latest segments first for time series workload.
+            // That can slow down ASC order queries on timestamp workload. So to avoid that slowdown, we will reverse leaf
+            // reader order here.
+            if (searchContext.shouldUseTimeSeriesDescSortOptimization()) {
+                for (int i = leaves.size() - 1; i >= 0; i--) {
+                    searchLeaf(leaves.get(i), weight, collector);
+                }
+            } else {
+                for (int i = 0; i < leaves.size(); i++) {
+                    searchLeaf(leaves.get(i), weight, collector);
+                }
             }
+            searchContext.bucketCollectorProcessor().processPostCollection(collector);
+        } catch (Throwable t) {
+            searchContext.indexShard().getSearchOperationListener().onFailedSliceExecution(searchContext);
+            throw t;
         }
-        searchContext.bucketCollectorProcessor().processPostCollection(collector);
+        searchContext.indexShard().getSearchOperationListener().onSliceExecution(searchContext);
     }
 
     /**
diff --git a/server/src/main/java/org/opensearch/search/internal/SearchContext.java b/server/src/main/java/org/opensearch/search/internal/SearchContext.java
index 5f052f80ec917..fb822bcf39619 100644
--- a/server/src/main/java/org/opensearch/search/internal/SearchContext.java
+++ b/server/src/main/java/org/opensearch/search/internal/SearchContext.java
@@ -526,4 +526,8 @@ public String toString() {
     public int maxAggRewriteFilters() {
         return 0;
     }
+
+    public int cardinalityAggregationPruningThreshold() {
+        return 0;
+    }
 }
diff --git a/server/src/main/java/org/opensearch/search/lookup/SearchLookup.java b/server/src/main/java/org/opensearch/search/lookup/SearchLookup.java
index 906616eb9ba5f..dff8fae1a9ad1 100644
--- a/server/src/main/java/org/opensearch/search/lookup/SearchLookup.java
+++ b/server/src/main/java/org/opensearch/search/lookup/SearchLookup.java
@@ -153,14 +153,25 @@ public final SearchLookup forkAndTrackFieldReferences(String field) {
         return new SearchLookup(this, newFieldChain);
     }
 
+    /**
+     * SourceLookup is not thread safe, so we create a new instance for each leaf to support concurrent segment search
+     */
     public LeafSearchLookup getLeafSearchLookup(LeafReaderContext context) {
-        return new LeafSearchLookup(context, docMap.getLeafDocLookup(context), sourceLookup, fieldsLookup.getLeafFieldsLookup(context));
+        return new LeafSearchLookup(
+            context,
+            docMap.getLeafDocLookup(context),
+            new SourceLookup(),
+            fieldsLookup.getLeafFieldsLookup(context)
+        );
     }
 
     public DocLookup doc() {
         return docMap;
     }
 
+    /**
+     * Returned SourceLookup will be unrelated to any created LeafSearchLookups. Instead, use {@link LeafSearchLookup#source()} to access the related {@link SearchLookup}.
+     */
     public SourceLookup source() {
         return sourceLookup;
     }
diff --git a/server/src/main/java/org/opensearch/search/lookup/SourceLookup.java b/server/src/main/java/org/opensearch/search/lookup/SourceLookup.java
index cbac29fde7932..4644bcb3d9b92 100644
--- a/server/src/main/java/org/opensearch/search/lookup/SourceLookup.java
+++ b/server/src/main/java/org/opensearch/search/lookup/SourceLookup.java
@@ -57,7 +57,7 @@
 import static java.util.Collections.emptyMap;
 
 /**
- * Orchestrator class for source lookups
+ * Orchestrator class for source lookups. Not thread safe.
  *
  * @opensearch.api
  */
diff --git a/server/src/main/java/org/opensearch/search/query/BitmapDocValuesQuery.java b/server/src/main/java/org/opensearch/search/query/BitmapDocValuesQuery.java
new file mode 100644
index 0000000000000..dfa5fc4567f80
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/query/BitmapDocValuesQuery.java
@@ -0,0 +1,152 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.query;
+
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.NumericDocValues;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.ConstantScoreScorer;
+import org.apache.lucene.search.ConstantScoreWeight;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.MatchNoDocsQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.QueryVisitor;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.TwoPhaseIterator;
+import org.apache.lucene.search.Weight;
+import org.apache.lucene.util.Accountable;
+import org.apache.lucene.util.RamUsageEstimator;
+
+import java.io.IOException;
+import java.util.Objects;
+
+import org.roaringbitmap.RoaringBitmap;
+
+/**
+ * Filter with bitmap
+ * <p>
+ * Similar to Lucene SortedNumericDocValuesSetQuery
+ */
+public class BitmapDocValuesQuery extends Query implements Accountable {
+
+    final String field;
+    final RoaringBitmap bitmap;
+    final long min;
+    final long max;
+
+    public BitmapDocValuesQuery(String field, RoaringBitmap bitmap) {
+        this.field = field;
+        this.bitmap = bitmap;
+        if (!bitmap.isEmpty()) {
+            min = bitmap.first();
+            max = bitmap.last();
+        } else {
+            min = 0; // final field
+            max = 0;
+        }
+    }
+
+    @Override
+    public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
+        return new ConstantScoreWeight(this, boost) {
+            @Override
+            public Scorer scorer(LeafReaderContext context) throws IOException {
+                SortedNumericDocValues values = DocValues.getSortedNumeric(context.reader(), field);
+                final NumericDocValues singleton = DocValues.unwrapSingleton(values);
+                final TwoPhaseIterator iterator;
+                if (singleton != null) {
+                    iterator = new TwoPhaseIterator(singleton) {
+                        @Override
+                        public boolean matches() throws IOException {
+                            long value = singleton.longValue();
+                            return value >= min && value <= max && bitmap.contains((int) value);
+                        }
+
+                        @Override
+                        public float matchCost() {
+                            return 5; // 2 comparisons, possible lookup in the bitmap
+                        }
+                    };
+                } else {
+                    iterator = new TwoPhaseIterator(values) {
+                        @Override
+                        public boolean matches() throws IOException {
+                            int count = values.docValueCount();
+                            for (int i = 0; i < count; i++) {
+                                final long value = values.nextValue();
+                                if (value < min) {
+                                    continue;
+                                } else if (value > max) {
+                                    return false; // values are sorted, terminate
+                                } else if (bitmap.contains((int) value)) {
+                                    return true;
+                                }
+                            }
+                            return false;
+                        }
+
+                        @Override
+                        public float matchCost() {
+                            return 5; // 2 comparisons, possible lookup in the bitmap
+                        }
+                    };
+                }
+                return new ConstantScoreScorer(this, score(), scoreMode, iterator);
+            }
+
+            @Override
+            public boolean isCacheable(LeafReaderContext ctx) {
+                return DocValues.isCacheable(ctx, field);
+            }
+        };
+    }
+
+    @Override
+    public String toString(String field) {
+        // bitmap may contain high cardinality, so choose to not show the actual values in it
+        return field + " cardinality: " + bitmap.getLongCardinality();
+    }
+
+    @Override
+    public Query rewrite(IndexSearcher indexSearcher) throws IOException {
+        if (bitmap.isEmpty()) {
+            return new MatchNoDocsQuery();
+        }
+        return super.rewrite(indexSearcher);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (sameClassAs(other) == false) {
+            return false;
+        }
+        BitmapDocValuesQuery that = (BitmapDocValuesQuery) other;
+        return field.equals(that.field) && bitmap.equals(that.bitmap);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(classHash(), field, bitmap);
+    }
+
+    @Override
+    public long ramBytesUsed() {
+        return RamUsageEstimator.shallowSizeOfInstance(BitmapDocValuesQuery.class) + RamUsageEstimator.sizeOfObject(field)
+            + RamUsageEstimator.sizeOfObject(bitmap);
+    }
+
+    @Override
+    public void visit(QueryVisitor visitor) {
+        if (visitor.acceptField(field)) {
+            visitor.visitLeaf(this);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/search/query/QueryPhase.java b/server/src/main/java/org/opensearch/search/query/QueryPhase.java
index dc32cd447d856..42b19f9bc0618 100644
--- a/server/src/main/java/org/opensearch/search/query/QueryPhase.java
+++ b/server/src/main/java/org/opensearch/search/query/QueryPhase.java
@@ -354,6 +354,9 @@ private static boolean searchWithCollector(
         try {
             searcher.search(query, queryCollector);
         } catch (EarlyTerminatingCollector.EarlyTerminationException e) {
+            // EarlyTerminationException is not caught in ContextIndexSearcher to allow force termination of collection. Postcollection
+            // still needs to be processed for Aggregations when early termination takes place.
+            searchContext.bucketCollectorProcessor().processPostCollection(queryCollector);
             queryResult.terminatedEarly(true);
         }
         if (searchContext.isSearchTimedOut()) {
diff --git a/server/src/main/java/org/opensearch/snapshots/RestoreService.java b/server/src/main/java/org/opensearch/snapshots/RestoreService.java
index 6884cbdf753ae..08c30ea503a6d 100644
--- a/server/src/main/java/org/opensearch/snapshots/RestoreService.java
+++ b/server/src/main/java/org/opensearch/snapshots/RestoreService.java
@@ -87,6 +87,7 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.IndexSettings;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.snapshots.IndexShardSnapshotStatus;
 import org.opensearch.index.store.remote.filecache.FileCacheStats;
@@ -130,7 +131,6 @@
 import static org.opensearch.common.util.set.Sets.newHashSet;
 import static org.opensearch.index.IndexModule.INDEX_STORE_TYPE_SETTING;
 import static org.opensearch.index.store.remote.directory.RemoteSnapshotDirectory.SEARCHABLE_SNAPSHOT_EXTENDED_COMPATIBILITY_MINIMUM_VERSION;
-import static org.opensearch.index.store.remote.filecache.FileCache.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING;
 import static org.opensearch.node.Node.NODE_SEARCH_CACHE_SIZE_SETTING;
 
 /**
@@ -205,6 +205,8 @@ public class RestoreService implements ClusterStateApplier {
 
     private final ClusterManagerTaskThrottler.ThrottlingKey restoreSnapshotTaskKey;
 
+    private final Supplier<Double> dataToFileCacheSizeRatioSupplier;
+
     private static final CleanRestoreStateTaskExecutor cleanRestoreStateTaskExecutor = new CleanRestoreStateTaskExecutor();
 
     public RestoreService(
@@ -215,7 +217,8 @@ public RestoreService(
         MetadataIndexUpgradeService metadataIndexUpgradeService,
         ShardLimitValidator shardLimitValidator,
         IndicesService indicesService,
-        Supplier<ClusterInfo> clusterInfoSupplier
+        Supplier<ClusterInfo> clusterInfoSupplier,
+        Supplier<Double> dataToFileCacheSizeRatioSupplier
     ) {
         this.clusterService = clusterService;
         this.repositoriesService = repositoriesService;
@@ -229,6 +232,7 @@ public RestoreService(
         this.shardLimitValidator = shardLimitValidator;
         this.indicesService = indicesService;
         this.clusterInfoSupplier = clusterInfoSupplier;
+        this.dataToFileCacheSizeRatioSupplier = dataToFileCacheSizeRatioSupplier;
 
         // Task is onboarded for throttling, it will get retried from associated TransportClusterManagerNodeAction.
         restoreSnapshotTaskKey = clusterService.registerClusterManagerTask(ClusterManagerTaskKeys.RESTORE_SNAPSHOT_KEY, true);
@@ -411,9 +415,7 @@ public ClusterState execute(ClusterState currentState) {
                                 if (isRemoteSnapshot) {
                                     snapshotIndexMetadata = addSnapshotToIndexSettings(snapshotIndexMetadata, snapshot, snapshotIndexId);
                                 }
-                                final boolean isSearchableSnapshot = IndexModule.Type.REMOTE_SNAPSHOT.match(
-                                    snapshotIndexMetadata.getSettings().get(IndexModule.INDEX_STORE_TYPE_SETTING.getKey())
-                                );
+                                final boolean isSearchableSnapshot = snapshotIndexMetadata.isRemoteSnapshot();
                                 final boolean isRemoteStoreShallowCopy = Boolean.TRUE.equals(
                                     snapshotInfo.isRemoteStoreIndexShallowCopyEnabled()
                                 ) && metadata.index(index).getSettings().getAsBoolean(SETTING_REMOTE_STORE_ENABLED, false);
@@ -715,7 +717,7 @@ private Settings getOverrideSettingsInternal() {
                             clusterService.state(),
                             clusterSettings,
                             clusterService.getSettings(),
-                            request.getDescription()
+                            String.join(",", request.indices())
                         );
                         return settingsBuilder.build();
                     }
@@ -872,7 +874,7 @@ private IndexMetadata updateIndexSettings(
 
                     private void validateSearchableSnapshotRestorable(long totalRestorableRemoteIndexesSize) {
                         ClusterInfo clusterInfo = clusterInfoSupplier.get();
-                        double remoteDataToFileCacheRatio = DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.get(clusterService.getSettings());
+                        final double remoteDataToFileCacheRatio = dataToFileCacheSizeRatioSupplier.get();
                         Map<String, FileCacheStats> nodeFileCacheStats = clusterInfo.getNodeFileCacheStats();
                         if (nodeFileCacheStats.isEmpty() || remoteDataToFileCacheRatio <= 0.01f) {
                             return;
@@ -886,7 +888,7 @@ private void validateSearchableSnapshotRestorable(long totalRestorableRemoteInde
                             .sum();
 
                         Predicate<ShardRouting> isRemoteSnapshotShard = shardRouting -> shardRouting.primary()
-                            && indicesService.indexService(shardRouting.index()).getIndexSettings().isRemoteSnapshot();
+                            && clusterService.state().getMetadata().getIndexSafe(shardRouting.index()).isRemoteSnapshot();
 
                         ShardsIterator shardsIterator = clusterService.state()
                             .routingTable()
@@ -1344,6 +1346,7 @@ private static IndexMetadata addSnapshotToIndexSettings(IndexMetadata metadata,
             .put(IndexSettings.SEARCHABLE_SNAPSHOT_ID_UUID.getKey(), snapshot.getSnapshotId().getUUID())
             .put(IndexSettings.SEARCHABLE_SNAPSHOT_ID_NAME.getKey(), snapshot.getSnapshotId().getName())
             .put(IndexSettings.SEARCHABLE_SNAPSHOT_INDEX_ID.getKey(), indexId.getId())
+            .put(IndexSettings.SEARCHABLE_SNAPSHOT_SHARD_PATH_TYPE.getKey(), PathType.fromCode(indexId.getShardPathType()))
             .build();
         return IndexMetadata.builder(metadata).settings(newSettings).build();
     }
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotInfo.java b/server/src/main/java/org/opensearch/snapshots/SnapshotInfo.java
index ba4e53fc43f8a..15c75db67551d 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotInfo.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotInfo.java
@@ -102,6 +102,9 @@ public final class SnapshotInfo implements Comparable<SnapshotInfo>, ToXContent,
     private static final String INCLUDE_GLOBAL_STATE = "include_global_state";
 
     private static final String REMOTE_STORE_INDEX_SHALLOW_COPY = "remote_store_index_shallow_copy";
+
+    private static final String PINNED_TIMESTAMP = "pinned_timestamp";
+
     private static final String USER_METADATA = "metadata";
 
     private static final Comparator<SnapshotInfo> COMPARATOR = Comparator.comparing(SnapshotInfo::startTime)
@@ -125,6 +128,7 @@ public static final class SnapshotInfoBuilder {
         private Boolean includeGlobalState = null;
 
         private Boolean remoteStoreIndexShallowCopy = null;
+        private long pinnedTimestamp = 0L;
         private Map<String, Object> userMetadata = null;
         private int version = -1;
         private List<SnapshotShardFailure> shardFailures = null;
@@ -181,6 +185,10 @@ private void setRemoteStoreIndexShallowCopy(Boolean remoteStoreIndexShallowCopy)
             this.remoteStoreIndexShallowCopy = remoteStoreIndexShallowCopy;
         }
 
+        private void setPinnedTimestamp(long pinnedTimestamp) {
+            this.pinnedTimestamp = pinnedTimestamp;
+        }
+
         private void setShardFailures(List<SnapshotShardFailure> shardFailures) {
             this.shardFailures = shardFailures;
         }
@@ -220,7 +228,8 @@ public SnapshotInfo build() {
                 shardFailures,
                 includeGlobalState,
                 userMetadata,
-                remoteStoreIndexShallowCopy
+                remoteStoreIndexShallowCopy,
+                pinnedTimestamp
             );
         }
     }
@@ -275,6 +284,7 @@ int getSuccessfulShards() {
             SnapshotInfoBuilder::setRemoteStoreIndexShallowCopy,
             new ParseField(REMOTE_STORE_INDEX_SHALLOW_COPY)
         );
+        SNAPSHOT_INFO_PARSER.declareLong(SnapshotInfoBuilder::setPinnedTimestamp, new ParseField(PINNED_TIMESTAMP));
         SNAPSHOT_INFO_PARSER.declareObjectArray(
             SnapshotInfoBuilder::setShardFailures,
             SnapshotShardFailure.SNAPSHOT_SHARD_FAILURE_PARSER,
@@ -311,6 +321,7 @@ int getSuccessfulShards() {
     @Nullable
     private Boolean remoteStoreIndexShallowCopy;
 
+    private long pinnedTimestamp;
     @Nullable
     private final Map<String, Object> userMetadata;
 
@@ -320,11 +331,11 @@ int getSuccessfulShards() {
     private final List<SnapshotShardFailure> shardFailures;
 
     public SnapshotInfo(SnapshotId snapshotId, List<String> indices, List<String> dataStreams, SnapshotState state) {
-        this(snapshotId, indices, dataStreams, state, null, null, 0L, 0L, 0, 0, Collections.emptyList(), null, null, null);
+        this(snapshotId, indices, dataStreams, state, null, null, 0L, 0L, 0, 0, Collections.emptyList(), null, null, null, 0);
     }
 
     public SnapshotInfo(SnapshotId snapshotId, List<String> indices, List<String> dataStreams, SnapshotState state, Version version) {
-        this(snapshotId, indices, dataStreams, state, null, version, 0L, 0L, 0, 0, Collections.emptyList(), null, null, null);
+        this(snapshotId, indices, dataStreams, state, null, version, 0L, 0L, 0, 0, Collections.emptyList(), null, null, null, 0);
     }
 
     public SnapshotInfo(SnapshotsInProgress.Entry entry) {
@@ -342,7 +353,8 @@ public SnapshotInfo(SnapshotsInProgress.Entry entry) {
             Collections.emptyList(),
             entry.includeGlobalState(),
             entry.userMetadata(),
-            entry.remoteStoreIndexShallowCopy()
+            entry.remoteStoreIndexShallowCopy(),
+            0L
         );
     }
 
@@ -373,7 +385,41 @@ public SnapshotInfo(
             shardFailures,
             includeGlobalState,
             userMetadata,
-            remoteStoreIndexShallowCopy
+            remoteStoreIndexShallowCopy,
+            0
+        );
+    }
+
+    public SnapshotInfo(
+        SnapshotId snapshotId,
+        List<String> indices,
+        List<String> dataStreams,
+        long startTime,
+        String reason,
+        long endTime,
+        int totalShards,
+        List<SnapshotShardFailure> shardFailures,
+        Boolean includeGlobalState,
+        Map<String, Object> userMetadata,
+        Boolean remoteStoreIndexShallowCopy,
+        long pinnedTimestamp
+    ) {
+        this(
+            snapshotId,
+            indices,
+            dataStreams,
+            snapshotState(reason, shardFailures),
+            reason,
+            Version.CURRENT,
+            startTime,
+            endTime,
+            totalShards,
+            totalShards - shardFailures.size(),
+            shardFailures,
+            includeGlobalState,
+            userMetadata,
+            remoteStoreIndexShallowCopy,
+            pinnedTimestamp
         );
     }
 
@@ -391,7 +437,8 @@ public SnapshotInfo(
         List<SnapshotShardFailure> shardFailures,
         Boolean includeGlobalState,
         Map<String, Object> userMetadata,
-        Boolean remoteStoreIndexShallowCopy
+        Boolean remoteStoreIndexShallowCopy,
+        long pinnedTimestamp
     ) {
         this.snapshotId = Objects.requireNonNull(snapshotId);
         this.indices = Collections.unmodifiableList(Objects.requireNonNull(indices));
@@ -407,6 +454,7 @@ public SnapshotInfo(
         this.includeGlobalState = includeGlobalState;
         this.userMetadata = userMetadata;
         this.remoteStoreIndexShallowCopy = remoteStoreIndexShallowCopy;
+        this.pinnedTimestamp = pinnedTimestamp;
     }
 
     /**
@@ -437,6 +485,9 @@ public SnapshotInfo(final StreamInput in) throws IOException {
         if (in.getVersion().onOrAfter(Version.V_2_9_0)) {
             remoteStoreIndexShallowCopy = in.readOptionalBoolean();
         }
+        if (in.getVersion().onOrAfter(Version.V_2_17_0)) {
+            pinnedTimestamp = in.readVLong();
+        }
     }
 
     /**
@@ -551,6 +602,10 @@ public Boolean isRemoteStoreIndexShallowCopyEnabled() {
         return remoteStoreIndexShallowCopy;
     }
 
+    public long getPinnedTimestamp() {
+        return pinnedTimestamp;
+    }
+
     /**
      * Returns shard failures; an empty list will be returned if there were no shard
      * failures, or if {@link #state()} returns {@code null}.
@@ -618,6 +673,8 @@ public String toString() {
             + shardFailures
             + ", isRemoteStoreInteropEnabled="
             + remoteStoreIndexShallowCopy
+            + ", pinnedTimestamp="
+            + pinnedTimestamp
             + '}';
     }
 
@@ -657,6 +714,10 @@ public XContentBuilder toXContent(final XContentBuilder builder, final Params pa
         if (remoteStoreIndexShallowCopy != null) {
             builder.field(REMOTE_STORE_INDEX_SHALLOW_COPY, remoteStoreIndexShallowCopy);
         }
+        if (pinnedTimestamp != 0) {
+            builder.field(PINNED_TIMESTAMP, pinnedTimestamp);
+        }
+
         builder.startArray(INDICES);
         for (String index : indices) {
             builder.value(index);
@@ -715,6 +776,9 @@ private XContentBuilder toXContentInternal(final XContentBuilder builder, final
         if (remoteStoreIndexShallowCopy != null) {
             builder.field(REMOTE_STORE_INDEX_SHALLOW_COPY, remoteStoreIndexShallowCopy);
         }
+        if (pinnedTimestamp != 0) {
+            builder.field(PINNED_TIMESTAMP, pinnedTimestamp);
+        }
         builder.startArray(INDICES);
         for (String index : indices) {
             builder.value(index);
@@ -763,6 +827,7 @@ public static SnapshotInfo fromXContentInternal(final XContentParser parser) thr
         long endTime = 0;
         int totalShards = 0;
         int successfulShards = 0;
+        long pinnedTimestamp = 0;
         Boolean includeGlobalState = null;
         Boolean remoteStoreIndexShallowCopy = null;
         Map<String, Object> userMetadata = null;
@@ -804,6 +869,8 @@ public static SnapshotInfo fromXContentInternal(final XContentParser parser) thr
                             includeGlobalState = parser.booleanValue();
                         } else if (REMOTE_STORE_INDEX_SHALLOW_COPY.equals(currentFieldName)) {
                             remoteStoreIndexShallowCopy = parser.booleanValue();
+                        } else if (PINNED_TIMESTAMP.equals(currentFieldName)) {
+                            pinnedTimestamp = parser.longValue();
                         }
                     } else if (token == XContentParser.Token.START_ARRAY) {
                         if (DATA_STREAMS.equals(currentFieldName)) {
@@ -856,7 +923,8 @@ public static SnapshotInfo fromXContentInternal(final XContentParser parser) thr
             shardFailures,
             includeGlobalState,
             userMetadata,
-            remoteStoreIndexShallowCopy
+            remoteStoreIndexShallowCopy,
+            pinnedTimestamp
         );
     }
 
@@ -892,6 +960,9 @@ public void writeTo(final StreamOutput out) throws IOException {
         if (out.getVersion().onOrAfter(Version.V_2_9_0)) {
             out.writeOptionalBoolean(remoteStoreIndexShallowCopy);
         }
+        if (out.getVersion().onOrAfter(Version.V_2_17_0)) {
+            out.writeVLong(pinnedTimestamp);
+        }
     }
 
     private static SnapshotState snapshotState(final String reason, final List<SnapshotShardFailure> shardFailures) {
@@ -924,7 +995,8 @@ public boolean equals(Object o) {
             && Objects.equals(version, that.version)
             && Objects.equals(shardFailures, that.shardFailures)
             && Objects.equals(userMetadata, that.userMetadata)
-            && Objects.equals(remoteStoreIndexShallowCopy, that.remoteStoreIndexShallowCopy);
+            && Objects.equals(remoteStoreIndexShallowCopy, that.remoteStoreIndexShallowCopy)
+            && Objects.equals(pinnedTimestamp, that.pinnedTimestamp);
     }
 
     @Override
@@ -944,7 +1016,8 @@ public int hashCode() {
             version,
             shardFailures,
             userMetadata,
-            remoteStoreIndexShallowCopy
+            remoteStoreIndexShallowCopy,
+            pinnedTimestamp
         );
     }
 }
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotShardPaths.java b/server/src/main/java/org/opensearch/snapshots/SnapshotShardPaths.java
new file mode 100644
index 0000000000000..88af14e2232f9
--- /dev/null
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotShardPaths.java
@@ -0,0 +1,142 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.snapshots;
+
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.repositories.IndexId;
+
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * Snapshot Shard path information.
+ *
+ * @opensearch.internal
+ */
+public class SnapshotShardPaths implements ToXContent {
+
+    public static final String DIR = "snapshot_shard_paths";
+
+    public static final String DELIMITER = ".";
+
+    public static final String FILE_NAME_FORMAT = "%s";
+
+    private static final String PATHS_FIELD = "paths";
+    private static final String INDEX_ID_FIELD = "indexId";
+    private static final String INDEX_NAME_FIELD = "indexName";
+    private static final String NUMBER_OF_SHARDS_FIELD = "number_of_shards";
+    private static final String SHARD_PATH_TYPE_FIELD = "shard_path_type";
+    private static final String SHARD_PATH_HASH_ALGORITHM_FIELD = "shard_path_hash_algorithm";
+
+    private final List<String> paths;
+    private final String indexId;
+    private final String indexName;
+    private final int numberOfShards;
+    private final PathType shardPathType;
+    private final PathHashAlgorithm shardPathHashAlgorithm;
+
+    public SnapshotShardPaths(
+        List<String> paths,
+        String indexId,
+        String indexName,
+        int numberOfShards,
+        PathType shardPathType,
+        PathHashAlgorithm shardPathHashAlgorithm
+    ) {
+        assert !paths.isEmpty() : "paths must not be empty";
+        assert indexId != null && !indexId.isEmpty() : "indexId must not be empty";
+        assert indexName != null && !indexName.isEmpty() : "indexName must not be empty";
+        assert numberOfShards > 0 : "numberOfShards must be > 0";
+        assert shardPathType != null : "shardPathType must not be null";
+        assert shardPathHashAlgorithm != null : "shardPathHashAlgorithm must not be null";
+
+        this.paths = paths;
+        this.indexId = indexId;
+        this.indexName = indexName;
+        this.numberOfShards = numberOfShards;
+        this.shardPathType = shardPathType;
+        this.shardPathHashAlgorithm = shardPathHashAlgorithm;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.field(INDEX_ID_FIELD, indexId);
+        builder.field(INDEX_NAME_FIELD, indexName);
+        builder.field(NUMBER_OF_SHARDS_FIELD, numberOfShards);
+        builder.field(SHARD_PATH_TYPE_FIELD, shardPathType.getCode());
+        builder.field(SHARD_PATH_HASH_ALGORITHM_FIELD, shardPathHashAlgorithm.getCode());
+        builder.startArray(PATHS_FIELD);
+        for (String path : paths) {
+            builder.value(path);
+        }
+        builder.endArray();
+        return builder;
+    }
+
+    public static SnapshotShardPaths fromXContent(XContentParser ignored) {
+        throw new UnsupportedOperationException("SnapshotShardPaths.fromXContent() is not supported");
+    }
+
+    /**
+     * Parses a shard path string and extracts relevant shard information.
+     *
+     * @param shardPath The shard path string to parse. Expected format is:
+     *                  [index_id]#[index_name]#[shard_count]#[path_type_code]#[path_hash_algorithm_code]
+     * @return A {@link ShardInfo} object containing the parsed index ID and shard count.
+     * @throws IllegalArgumentException if the shard path format is invalid or cannot be parsed.
+     */
+    public static ShardInfo parseShardPath(String shardPath) {
+        String[] parts = shardPath.split("\\" + SnapshotShardPaths.DELIMITER);
+        if (parts.length != 5) {
+            throw new IllegalArgumentException("Invalid shard path format: " + shardPath);
+        }
+        try {
+            IndexId indexId = new IndexId(parts[1], parts[0], Integer.parseInt(parts[3]));
+            int shardCount = Integer.parseInt(parts[2]);
+            return new ShardInfo(indexId, shardCount);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Invalid shard path format: " + shardPath, e);
+        }
+    }
+
+    /**
+     * Represents parsed information from a shard path.
+     * This class encapsulates the index ID and shard count extracted from a shard path string.
+     */
+    public static class ShardInfo {
+        /** The ID of the index associated with this shard. */
+        private final IndexId indexId;
+
+        /** The total number of shards for this index. */
+        private final int shardCount;
+
+        /**
+         * Constructs a new ShardInfo instance.
+         *
+         * @param indexId    The ID of the index associated with this shard.
+         * @param shardCount The total number of shards for this index.
+         */
+        public ShardInfo(IndexId indexId, int shardCount) {
+            this.indexId = indexId;
+            this.shardCount = shardCount;
+        }
+
+        public IndexId getIndexId() {
+            return indexId;
+        }
+
+        public int getShardCount() {
+            return shardCount;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
index 6b11d03774e33..1b189da13e92e 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotShardsService.java
@@ -277,58 +277,52 @@ private void startNewShards(SnapshotsInProgress.Entry entry, Map<ShardId, IndexS
                 final IndexShardSnapshotStatus snapshotStatus = shardEntry.getValue();
                 final IndexId indexId = indicesMap.get(shardId.getIndexName());
                 assert indexId != null;
-                if (isRemoteSnapshot(shardId)) {
-                    // If the source of the data is another remote snapshot (i.e. searchable snapshot)
-                    // then no need to snapshot the shard and can immediately notify success.
-                    notifySuccessfulSnapshotShard(snapshot, shardId, snapshotStatus.generation());
-                } else {
-                    assert SnapshotsService.useShardGenerations(entry.version())
-                        || ShardGenerations.fixShardGeneration(snapshotStatus.generation()) == null
-                        : "Found non-null, non-numeric shard generation ["
-                            + snapshotStatus.generation()
-                            + "] for snapshot with old-format compatibility";
-                    snapshot(
-                        shardId,
-                        snapshot,
-                        indexId,
-                        entry.userMetadata(),
-                        snapshotStatus,
-                        entry.version(),
-                        entry.remoteStoreIndexShallowCopy(),
-                        new ActionListener<>() {
-                            @Override
-                            public void onResponse(String newGeneration) {
-                                assert newGeneration != null;
-                                assert newGeneration.equals(snapshotStatus.generation());
-                                if (logger.isDebugEnabled()) {
-                                    final IndexShardSnapshotStatus.Copy lastSnapshotStatus = snapshotStatus.asCopy();
-                                    logger.debug(
-                                        "snapshot [{}] completed to [{}] with [{}] at generation [{}]",
-                                        snapshot,
-                                        snapshot.getRepository(),
-                                        lastSnapshotStatus,
-                                        snapshotStatus.generation()
-                                    );
-                                }
-                                notifySuccessfulSnapshotShard(snapshot, shardId, newGeneration);
+                assert SnapshotsService.useShardGenerations(entry.version())
+                    || ShardGenerations.fixShardGeneration(snapshotStatus.generation()) == null
+                    : "Found non-null, non-numeric shard generation ["
+                        + snapshotStatus.generation()
+                        + "] for snapshot with old-format compatibility";
+                snapshot(
+                    shardId,
+                    snapshot,
+                    indexId,
+                    entry.userMetadata(),
+                    snapshotStatus,
+                    entry.version(),
+                    entry.remoteStoreIndexShallowCopy(),
+                    new ActionListener<>() {
+                        @Override
+                        public void onResponse(String newGeneration) {
+                            assert newGeneration != null;
+                            assert newGeneration.equals(snapshotStatus.generation());
+                            if (logger.isDebugEnabled()) {
+                                final IndexShardSnapshotStatus.Copy lastSnapshotStatus = snapshotStatus.asCopy();
+                                logger.debug(
+                                    "snapshot [{}] completed to [{}] with [{}] at generation [{}]",
+                                    snapshot,
+                                    snapshot.getRepository(),
+                                    lastSnapshotStatus,
+                                    snapshotStatus.generation()
+                                );
                             }
+                            notifySuccessfulSnapshotShard(snapshot, shardId, newGeneration);
+                        }
 
-                            @Override
-                            public void onFailure(Exception e) {
-                                final String failure;
-                                if (e instanceof AbortedSnapshotException) {
-                                    failure = "aborted";
-                                    logger.debug(() -> new ParameterizedMessage("[{}][{}] aborted shard snapshot", shardId, snapshot), e);
-                                } else {
-                                    failure = summarizeFailure(e);
-                                    logger.warn(() -> new ParameterizedMessage("[{}][{}] failed to snapshot shard", shardId, snapshot), e);
-                                }
-                                snapshotStatus.moveToFailed(threadPool.absoluteTimeInMillis(), failure);
-                                notifyFailedSnapshotShard(snapshot, shardId, failure);
+                        @Override
+                        public void onFailure(Exception e) {
+                            final String failure;
+                            if (e instanceof AbortedSnapshotException) {
+                                failure = "aborted";
+                                logger.debug(() -> new ParameterizedMessage("[{}][{}] aborted shard snapshot", shardId, snapshot), e);
+                            } else {
+                                failure = summarizeFailure(e);
+                                logger.warn(() -> new ParameterizedMessage("[{}][{}] failed to snapshot shard", shardId, snapshot), e);
                             }
+                            snapshotStatus.moveToFailed(threadPool.absoluteTimeInMillis(), failure);
+                            notifyFailedSnapshotShard(snapshot, shardId, failure);
                         }
-                    );
-                }
+                    }
+                );
             }
         });
     }
diff --git a/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java b/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
index 02819678d39bc..2265fe519fc78 100644
--- a/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
+++ b/server/src/main/java/org/opensearch/snapshots/SnapshotsService.java
@@ -92,7 +92,10 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.store.RemoteSegmentStoreDirectoryFactory;
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManagerFactory;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
 import org.opensearch.repositories.IndexId;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.Repository;
@@ -123,6 +126,7 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executor;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -136,6 +140,8 @@
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.CompatibilityMode;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
 import static org.opensearch.repositories.blobstore.BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY;
+import static org.opensearch.repositories.blobstore.BlobStoreRepository.SHALLOW_SNAPSHOT_V2;
+import static org.opensearch.repositories.blobstore.BlobStoreRepository.SHARD_PATH_TYPE;
 import static org.opensearch.snapshots.SnapshotUtils.validateSnapshotsBackingAnyIndex;
 
 /**
@@ -177,6 +183,8 @@ public class SnapshotsService extends AbstractLifecycleComponent implements Clus
 
     private final RemoteStoreLockManagerFactory remoteStoreLockManagerFactory;
 
+    private final RemoteSegmentStoreDirectoryFactory remoteSegmentStoreDirectoryFactory;
+
     private final ThreadPool threadPool;
 
     private final Map<Snapshot, List<ActionListener<Tuple<RepositoryData, SnapshotInfo>>>> snapshotCompletionListeners =
@@ -202,6 +210,7 @@ public class SnapshotsService extends AbstractLifecycleComponent implements Clus
     private final UpdateSnapshotStatusAction updateSnapshotStatusHandler;
 
     private final TransportService transportService;
+    private final RemoteStorePinnedTimestampService remoteStorePinnedTimestampService;
 
     private final OngoingRepositoryOperations repositoryOperations = new OngoingRepositoryOperations();
 
@@ -222,6 +231,20 @@ public class SnapshotsService extends AbstractLifecycleComponent implements Clus
         Setting.Property.Dynamic
     );
 
+    public static final String SNAPSHOT_PINNED_TIMESTAMP_DELIMITER = "__";
+
+    /**
+     * Setting to specify the maximum number of shards that can be included in the result for the snapshot status
+     * API call. Note that it does not apply to V2-shallow snapshots.
+     */
+    public static final Setting<Integer> MAX_SHARDS_ALLOWED_IN_STATUS_API = Setting.intSetting(
+        "snapshot.max_shards_allowed_in_status_api",
+        200000,
+        1,
+        Setting.Property.NodeScope,
+        Setting.Property.Dynamic
+    );
+
     private volatile int maxConcurrentOperations;
 
     public SnapshotsService(
@@ -230,14 +253,25 @@ public SnapshotsService(
         IndexNameExpressionResolver indexNameExpressionResolver,
         RepositoriesService repositoriesService,
         TransportService transportService,
-        ActionFilters actionFilters
+        ActionFilters actionFilters,
+        @Nullable RemoteStorePinnedTimestampService remoteStorePinnedTimestampService,
+        RemoteStoreSettings remoteStoreSettings
     ) {
         this.clusterService = clusterService;
         this.indexNameExpressionResolver = indexNameExpressionResolver;
         this.repositoriesService = repositoriesService;
-        this.remoteStoreLockManagerFactory = new RemoteStoreLockManagerFactory(() -> repositoriesService);
+        this.remoteStoreLockManagerFactory = new RemoteStoreLockManagerFactory(
+            () -> repositoriesService,
+            remoteStoreSettings.getSegmentsPathFixedPrefix()
+        );
         this.threadPool = transportService.getThreadPool();
+        this.remoteSegmentStoreDirectoryFactory = new RemoteSegmentStoreDirectoryFactory(
+            () -> repositoriesService,
+            threadPool,
+            remoteStoreSettings.getSegmentsPathFixedPrefix()
+        );
         this.transportService = transportService;
+        this.remoteStorePinnedTimestampService = remoteStorePinnedTimestampService;
 
         // The constructor of UpdateSnapshotStatusAction will register itself to the TransportService.
         this.updateSnapshotStatusHandler = new UpdateSnapshotStatusAction(
@@ -409,10 +443,36 @@ public TimeValue timeout() {
      * @param listener snapshot completion listener
      */
     public void executeSnapshot(final CreateSnapshotRequest request, final ActionListener<SnapshotInfo> listener) {
-        createSnapshot(
-            request,
-            ActionListener.wrap(snapshot -> addListener(snapshot, ActionListener.map(listener, Tuple::v2)), listener::onFailure)
-        );
+        Repository repository = repositoriesService.repository(request.repository());
+
+        boolean isSnapshotV2 = SHALLOW_SNAPSHOT_V2.get(repository.getMetadata().settings());
+        logger.debug("shallow_snapshot_v2 is set as [{}]", isSnapshotV2);
+
+        boolean remoteStoreIndexShallowCopy = remoteStoreShallowCopyEnabled(repository);
+        if (remoteStoreIndexShallowCopy
+            && isSnapshotV2
+            && request.indices().length == 0
+            && clusterService.state().nodes().getMinNodeVersion().onOrAfter(Version.CURRENT)) {
+            createSnapshotV2(request, listener);
+        } else {
+            createSnapshot(
+                request,
+                ActionListener.wrap(snapshot -> addListener(snapshot, ActionListener.map(listener, Tuple::v2)), listener::onFailure)
+            );
+        }
+    }
+
+    private boolean remoteStoreShallowCopyEnabled(Repository repository) {
+        boolean remoteStoreIndexShallowCopy = REMOTE_STORE_INDEX_SHALLOW_COPY.get(repository.getMetadata().settings());
+        logger.debug("remote_store_index_shallow_copy setting is set as [{}]", remoteStoreIndexShallowCopy);
+        if (remoteStoreIndexShallowCopy
+            && clusterService.getClusterSettings().get(REMOTE_STORE_COMPATIBILITY_MODE_SETTING).equals(CompatibilityMode.MIXED)) {
+            // don't allow shallow snapshots if compatibility mode is not strict
+            logger.warn("Shallow snapshots are not supported during migration. Falling back to full snapshot.");
+            remoteStoreIndexShallowCopy = false;
+        }
+        return remoteStoreIndexShallowCopy;
+
     }
 
     /**
@@ -420,6 +480,7 @@ public void executeSnapshot(final CreateSnapshotRequest request, final ActionLis
      * <p>
      * This method is used by clients to start snapshot. It makes sure that there is no snapshots are currently running and
      * creates a snapshot record in cluster state metadata.
+     * </p>
      *
      * @param request  snapshot request
      * @param listener snapshot creation listener
@@ -445,12 +506,11 @@ public void createSnapshot(final CreateSnapshotRequest request, final ActionList
 
             @Override
             public ClusterState execute(ClusterState currentState) {
-                ensureSnapshotNameAvailableInRepo(repositoryData, snapshotName, repository);
+                createSnapshotPreValidations(currentState, repositoryData, repositoryName, snapshotName);
                 final SnapshotsInProgress snapshots = currentState.custom(SnapshotsInProgress.TYPE, SnapshotsInProgress.EMPTY);
                 final List<SnapshotsInProgress.Entry> runningSnapshots = snapshots.entries();
-                ensureSnapshotNameNotRunning(runningSnapshots, repositoryName, snapshotName);
-                validate(repositoryName, snapshotName, currentState);
                 final boolean concurrentOperationsAllowed = currentState.nodes().getMinNodeVersion().onOrAfter(FULL_CONCURRENCY_VERSION);
+
                 final SnapshotDeletionsInProgress deletionsInProgress = currentState.custom(
                     SnapshotDeletionsInProgress.TYPE,
                     SnapshotDeletionsInProgress.EMPTY
@@ -462,17 +522,7 @@ public ClusterState execute(ClusterState currentState) {
                         "cannot snapshot while a snapshot deletion is in-progress in [" + deletionsInProgress + "]"
                     );
                 }
-                final RepositoryCleanupInProgress repositoryCleanupInProgress = currentState.custom(
-                    RepositoryCleanupInProgress.TYPE,
-                    RepositoryCleanupInProgress.EMPTY
-                );
-                if (repositoryCleanupInProgress.hasCleanupInProgress()) {
-                    throw new ConcurrentSnapshotExecutionException(
-                        repositoryName,
-                        snapshotName,
-                        "cannot snapshot while a repository cleanup is in-progress in [" + repositoryCleanupInProgress + "]"
-                    );
-                }
+
                 // Fail if there are any concurrently running snapshots. The only exception to this being a snapshot in INIT state from a
                 // previous cluster-manager that we can simply ignore and remove from the cluster state because we would clean it up from
                 // the
@@ -480,7 +530,7 @@ public ClusterState execute(ClusterState currentState) {
                 if (concurrentOperationsAllowed == false && runningSnapshots.stream().anyMatch(entry -> entry.state() != State.INIT)) {
                     throw new ConcurrentSnapshotExecutionException(repositoryName, snapshotName, " a snapshot is already running");
                 }
-                ensureNoCleanupInProgress(currentState, repositoryName, snapshotName);
+
                 ensureBelowConcurrencyLimit(repositoryName, snapshotName, snapshots, deletionsInProgress);
                 // Store newSnapshot here to be processed in clusterStateProcessed
                 List<String> indices = Arrays.asList(indexNameExpressionResolver.concreteIndexNames(currentState, request));
@@ -493,9 +543,13 @@ public ClusterState execute(ClusterState currentState) {
 
                 logger.trace("[{}][{}] creating snapshot for indices [{}]", repositoryName, snapshotName, indices);
 
+                int pathType = clusterService.state().nodes().getMinNodeVersion().onOrAfter(Version.V_2_17_0)
+                    ? SHARD_PATH_TYPE.get(repository.getMetadata().settings()).getCode()
+                    : IndexId.DEFAULT_SHARD_PATH_TYPE;
                 final List<IndexId> indexIds = repositoryData.resolveNewIndices(
                     indices,
-                    getInFlightIndexIds(runningSnapshots, repositoryName)
+                    getInFlightIndexIds(runningSnapshots, repositoryName),
+                    pathType
                 );
                 final Version version = minCompatibleVersion(currentState.nodes().getMinNodeVersion(), repositoryData, null);
                 final Map<ShardId, ShardSnapshotStatus> shards = shards(
@@ -581,6 +635,185 @@ public TimeValue timeout() {
         }, "create_snapshot [" + snapshotName + ']', listener::onFailure);
     }
 
+    /**
+     * Initializes the snapshotting process for clients when Snapshot v2 is enabled. This method is responsible for taking
+     * a shallow snapshot and pinning the snapshot timestamp.The entire process is executed on the cluster manager node.
+     *
+     * Unlike traditional snapshot operations, this method performs a synchronous snapshot execution and doesn't
+     * upload any shard metadata to the snapshot repository.
+     * The pinned timestamp is later reconciled with remote store segment and translog metadata files during the restore
+     * operation.
+     *
+     * @param request  snapshot request
+     * @param listener snapshot creation listener
+     */
+    public void createSnapshotV2(final CreateSnapshotRequest request, final ActionListener<SnapshotInfo> listener) {
+        long pinnedTimestamp = System.currentTimeMillis();
+        final String repositoryName = request.repository();
+        final String snapshotName = indexNameExpressionResolver.resolveDateMathExpression(request.snapshot());
+        validate(repositoryName, snapshotName);
+
+        final SnapshotId snapshotId = new SnapshotId(snapshotName, UUIDs.randomBase64UUID()); // new UUID for the snapshot
+        Repository repository = repositoriesService.repository(repositoryName);
+
+        if (repository.isReadOnly()) {
+            listener.onFailure(
+                new RepositoryException(repository.getMetadata().name(), "cannot create snapshot-v2 in a readonly repository")
+            );
+            return;
+        }
+
+        final Snapshot snapshot = new Snapshot(repositoryName, snapshotId);
+        ClusterState currentState = clusterService.state();
+        final Map<String, Object> userMeta = repository.adaptUserMetadata(request.userMetadata());
+        try {
+            final StepListener<RepositoryData> repositoryDataListener = new StepListener<>();
+            repositoriesService.getRepositoryData(repositoryName, repositoryDataListener);
+
+            repositoryDataListener.whenComplete(repositoryData -> {
+                createSnapshotPreValidations(currentState, repositoryData, repositoryName, snapshotName);
+
+                List<String> indices = new ArrayList<>(currentState.metadata().indices().keySet());
+
+                final List<String> dataStreams = indexNameExpressionResolver.dataStreamNames(
+                    currentState,
+                    request.indicesOptions(),
+                    request.indices()
+                );
+
+                logger.trace("[{}][{}] creating snapshot-v2 for indices [{}]", repositoryName, snapshotName, indices);
+
+                final SnapshotsInProgress snapshots = currentState.custom(SnapshotsInProgress.TYPE, SnapshotsInProgress.EMPTY);
+                final List<SnapshotsInProgress.Entry> runningSnapshots = snapshots.entries();
+
+                final List<IndexId> indexIds = repositoryData.resolveNewIndices(
+                    indices,
+                    getInFlightIndexIds(runningSnapshots, repositoryName),
+                    IndexId.DEFAULT_SHARD_PATH_TYPE
+                );
+                final Version version = minCompatibleVersion(currentState.nodes().getMinNodeVersion(), repositoryData, null);
+                final ShardGenerations shardGenerations = buildShardsGenerationFromRepositoryData(
+                    currentState.metadata(),
+                    currentState.routingTable(),
+                    indexIds,
+                    repositoryData
+                );
+
+                if (repositoryData.getGenId() == RepositoryData.UNKNOWN_REPO_GEN) {
+                    logger.debug("[{}] was aborted before starting", snapshot);
+                    throw new SnapshotException(snapshot, "Aborted on initialization");
+                }
+                final SnapshotInfo snapshotInfo = new SnapshotInfo(
+                    snapshot.getSnapshotId(),
+                    shardGenerations.indices().stream().map(IndexId::getName).collect(Collectors.toList()),
+                    dataStreams,
+                    pinnedTimestamp,
+                    null,
+                    System.currentTimeMillis(),
+                    shardGenerations.totalShards(),
+                    Collections.emptyList(),
+                    request.includeGlobalState(),
+                    userMeta,
+                    true,
+                    pinnedTimestamp
+                );
+                if (!clusterService.state().nodes().isLocalNodeElectedClusterManager()) {
+                    throw new SnapshotException(repositoryName, snapshotName, "Aborting snapshot-v2, no longer cluster manager");
+                }
+                final StepListener<RepositoryData> pinnedTimestampListener = new StepListener<>();
+                pinnedTimestampListener.whenComplete(repoData -> { listener.onResponse(snapshotInfo); }, listener::onFailure);
+                repository.finalizeSnapshot(
+                    shardGenerations,
+                    repositoryData.getGenId(),
+                    metadataForSnapshot(currentState.metadata(), request.includeGlobalState(), false, dataStreams, indexIds),
+                    snapshotInfo,
+                    version,
+                    state -> state,
+                    Priority.IMMEDIATE,
+                    new ActionListener<RepositoryData>() {
+                        @Override
+                        public void onResponse(RepositoryData repositoryData) {
+                            if (!clusterService.state().nodes().isLocalNodeElectedClusterManager()) {
+                                failSnapshotCompletionListeners(
+                                    snapshot,
+                                    new SnapshotException(snapshot, "Aborting snapshot-v2, no longer cluster manager")
+                                );
+                                listener.onFailure(
+                                    new SnapshotException(repositoryName, snapshotName, "Aborting snapshot-v2, no longer cluster manager")
+                                );
+                                return;
+                            }
+                            updateSnapshotPinnedTimestamp(repositoryData, snapshot, pinnedTimestamp, pinnedTimestampListener);
+                        }
+
+                        @Override
+                        public void onFailure(Exception e) {
+                            logger.error("Failed to upload files to snapshot repo {} for snapshot-v2 {} ", repositoryName, snapshotName);
+                            listener.onFailure(e);
+                        }
+                    }
+                );
+
+            }, listener::onFailure);
+        } catch (Exception e) {
+            assert false : new AssertionError(e);
+            logger.error("Snapshot-v2 {} creation failed with exception {}", snapshot.getSnapshotId().getName(), e);
+            listener.onFailure(e);
+        }
+    }
+
+    private void createSnapshotPreValidations(
+        ClusterState currentState,
+        RepositoryData repositoryData,
+        String repositoryName,
+        String snapshotName
+    ) {
+        Repository repository = repositoriesService.repository(repositoryName);
+        ensureSnapshotNameAvailableInRepo(repositoryData, snapshotName, repository);
+        final SnapshotsInProgress snapshots = currentState.custom(SnapshotsInProgress.TYPE, SnapshotsInProgress.EMPTY);
+        final List<SnapshotsInProgress.Entry> runningSnapshots = snapshots.entries();
+        ensureSnapshotNameNotRunning(runningSnapshots, repositoryName, snapshotName);
+        validate(repositoryName, snapshotName, currentState);
+        final RepositoryCleanupInProgress repositoryCleanupInProgress = currentState.custom(
+            RepositoryCleanupInProgress.TYPE,
+            RepositoryCleanupInProgress.EMPTY
+        );
+        if (repositoryCleanupInProgress.hasCleanupInProgress()) {
+            throw new ConcurrentSnapshotExecutionException(
+                repositoryName,
+                snapshotName,
+                "cannot snapshot-v2 while a repository cleanup is in-progress in [" + repositoryCleanupInProgress + "]"
+            );
+        }
+        ensureNoCleanupInProgress(currentState, repositoryName, snapshotName);
+    }
+
+    private void updateSnapshotPinnedTimestamp(
+        RepositoryData repositoryData,
+        Snapshot snapshot,
+        long timestampToPin,
+        ActionListener<RepositoryData> listener
+    ) {
+        remoteStorePinnedTimestampService.pinTimestamp(
+            timestampToPin,
+            snapshot.getRepository() + SNAPSHOT_PINNED_TIMESTAMP_DELIMITER + snapshot.getSnapshotId().getUUID(),
+            new ActionListener<Void>() {
+                @Override
+                public void onResponse(Void unused) {
+                    logger.debug("Timestamp pinned successfully for snapshot {}", snapshot.getSnapshotId().getName());
+                    listener.onResponse(repositoryData);
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    logger.error("Failed to pin timestamp for snapshot {} with exception {}", snapshot.getSnapshotId().getName(), e);
+                    listener.onFailure(e);
+
+                }
+            }
+        );
+    }
+
     private static void ensureSnapshotNameNotRunning(
         List<SnapshotsInProgress.Entry> runningSnapshots,
         String repositoryName,
@@ -1085,7 +1318,13 @@ protected void doRun() {
                         repository.initializeSnapshot(
                             snapshot.snapshot().getSnapshotId(),
                             snapshot.indices(),
-                            metadataForSnapshot(snapshot, clusterState.metadata())
+                            metadataForSnapshot(
+                                clusterState.metadata(),
+                                snapshot.includeGlobalState(),
+                                snapshot.partial(),
+                                snapshot.dataStreams(),
+                                snapshot.indices()
+                            )
                         );
                     }
 
@@ -1130,7 +1369,14 @@ public ClusterState execute(ClusterState currentState) {
                                     assert entry.shards().isEmpty();
                                     hadAbortedInitializations = true;
                                 } else {
-                                    final List<IndexId> indexIds = repositoryData.resolveNewIndices(indices, Collections.emptyMap());
+                                    int pathType = clusterService.state().nodes().getMinNodeVersion().onOrAfter(Version.V_2_17_0)
+                                        ? SHARD_PATH_TYPE.get(repository.getMetadata().settings()).getCode()
+                                        : IndexId.DEFAULT_SHARD_PATH_TYPE;
+                                    final List<IndexId> indexIds = repositoryData.resolveNewIndices(
+                                        indices,
+                                        Collections.emptyMap(),
+                                        pathType
+                                    );
                                     // Replace the snapshot that was just initialized
                                     final Map<ShardId, ShardSnapshotStatus> shards = shards(
                                         snapshots,
@@ -1299,15 +1545,21 @@ private static ShardGenerations buildGenerations(SnapshotsInProgress.Entry snaps
         return builder.build();
     }
 
-    private static Metadata metadataForSnapshot(SnapshotsInProgress.Entry snapshot, Metadata metadata) {
+    private static Metadata metadataForSnapshot(
+        Metadata metadata,
+        boolean includeGlobalState,
+        boolean isPartial,
+        List<String> dataStreamsList,
+        List<IndexId> indices
+    ) {
         final Metadata.Builder builder;
-        if (snapshot.includeGlobalState() == false) {
+        if (includeGlobalState == false) {
             // Remove global state from the cluster state
             builder = Metadata.builder();
-            for (IndexId index : snapshot.indices()) {
+            for (IndexId index : indices) {
                 final IndexMetadata indexMetadata = metadata.index(index.getName());
                 if (indexMetadata == null) {
-                    assert snapshot.partial() : "Index [" + index + "] was deleted during a snapshot but snapshot was not partial.";
+                    assert isPartial : "Index [" + index + "] was deleted during a snapshot but snapshot was not partial.";
                 } else {
                     builder.put(indexMetadata, false);
                 }
@@ -1317,12 +1569,10 @@ private static Metadata metadataForSnapshot(SnapshotsInProgress.Entry snapshot,
         }
         // Only keep those data streams in the metadata that were actually requested by the initial snapshot create operation
         Map<String, DataStream> dataStreams = new HashMap<>();
-        for (String dataStreamName : snapshot.dataStreams()) {
+        for (String dataStreamName : dataStreamsList) {
             DataStream dataStream = metadata.dataStreams().get(dataStreamName);
             if (dataStream == null) {
-                assert snapshot.partial() : "Data stream ["
-                    + dataStreamName
-                    + "] was deleted during a snapshot but snapshot was not partial.";
+                assert isPartial : "Data stream [" + dataStreamName + "] was deleted during a snapshot but snapshot was not partial.";
             } else {
                 dataStreams.put(dataStreamName, dataStream);
             }
@@ -1910,7 +2160,8 @@ private void finalizeSnapshotEntry(SnapshotsInProgress.Entry entry, Metadata met
                 shardFailures,
                 entry.includeGlobalState(),
                 entry.userMetadata(),
-                entry.remoteStoreIndexShallowCopy()
+                entry.remoteStoreIndexShallowCopy(),
+                0
             );
             final StepListener<Metadata> metadataListener = new StepListener<>();
             final Repository repo = repositoriesService.repository(snapshot.getRepository());
@@ -1929,10 +2180,11 @@ private void finalizeSnapshotEntry(SnapshotsInProgress.Entry entry, Metadata met
                 meta -> repo.finalizeSnapshot(
                     shardGenerations,
                     repositoryData.getGenId(),
-                    metadataForSnapshot(entry, meta),
+                    metadataForSnapshot(meta, entry.includeGlobalState(), entry.partial(), entry.dataStreams(), entry.indices()),
                     snapshotInfo,
                     entry.version(),
                     state -> stateWithoutSnapshot(state, snapshot),
+                    Priority.NORMAL,
                     ActionListener.wrap(newRepoData -> {
                         completeListenersIgnoringException(endAndGetListenersToResolve(snapshot), Tuple.tuple(newRepoData, snapshotInfo));
                         logger.info("snapshot [{}] completed with state [{}]", snapshot, snapshotInfo.state());
@@ -2811,18 +3063,67 @@ private void deleteSnapshotsFromRepository(
             // the flag. This can be improved by having the info whether there ever were any shallow snapshot present in this repository
             // or not in RepositoryData.
             // SEE https://github.com/opensearch-project/OpenSearch/issues/8610
-            final boolean cleanupRemoteStoreLockFiles = REMOTE_STORE_INDEX_SHALLOW_COPY.get(repository.getMetadata().settings());
-            if (cleanupRemoteStoreLockFiles) {
-                repository.deleteSnapshotsAndReleaseLockFiles(
-                    snapshotIds,
-                    repositoryData.getGenId(),
-                    minCompatibleVersion(minNodeVersion, repositoryData, snapshotIds),
-                    remoteStoreLockManagerFactory,
-                    ActionListener.wrap(updatedRepoData -> {
-                        logger.info("snapshots {} deleted", snapshotIds);
-                        removeSnapshotDeletionFromClusterState(deleteEntry, null, updatedRepoData);
-                    }, ex -> removeSnapshotDeletionFromClusterState(deleteEntry, ex, repositoryData))
-                );
+            final boolean remoteStoreShallowCopyEnabled = REMOTE_STORE_INDEX_SHALLOW_COPY.get(repository.getMetadata().settings());
+            if (remoteStoreShallowCopyEnabled) {
+                Map<SnapshotId, Long> snapshotsWithPinnedTimestamp = new ConcurrentHashMap<>();
+                List<SnapshotId> snapshotsWithLockFiles = Collections.synchronizedList(new ArrayList<>());
+
+                CountDownLatch latch = new CountDownLatch(1);
+
+                threadPool.executor(ThreadPool.Names.SNAPSHOT).execute(() -> {
+                    try {
+                        for (SnapshotId snapshotId : snapshotIds) {
+                            try {
+                                SnapshotInfo snapshotInfo = repository.getSnapshotInfo(snapshotId);
+                                if (snapshotInfo.getPinnedTimestamp() > 0) {
+                                    snapshotsWithPinnedTimestamp.put(snapshotId, snapshotInfo.getPinnedTimestamp());
+                                } else {
+                                    snapshotsWithLockFiles.add(snapshotId);
+                                }
+                            } catch (Exception e) {
+                                logger.warn("Failed to get snapshot info for {} with exception {}", snapshotId, e);
+                                removeSnapshotDeletionFromClusterState(deleteEntry, e, repositoryData);
+                            }
+                        }
+                    } finally {
+                        latch.countDown();
+                    }
+                });
+                try {
+                    latch.await();
+                    if (snapshotsWithLockFiles.size() > 0) {
+                        repository.deleteSnapshotsAndReleaseLockFiles(
+                            snapshotsWithLockFiles,
+                            repositoryData.getGenId(),
+                            minCompatibleVersion(minNodeVersion, repositoryData, snapshotsWithLockFiles),
+                            remoteStoreLockManagerFactory,
+                            ActionListener.wrap(updatedRepoData -> {
+                                logger.info("snapshots {} deleted", snapshotsWithLockFiles);
+                                removeSnapshotDeletionFromClusterState(deleteEntry, null, updatedRepoData);
+                            }, ex -> removeSnapshotDeletionFromClusterState(deleteEntry, ex, repositoryData))
+                        );
+                    }
+                    if (snapshotsWithPinnedTimestamp.size() > 0) {
+
+                        repository.deleteSnapshotsWithPinnedTimestamp(
+                            snapshotsWithPinnedTimestamp,
+                            repositoryData.getGenId(),
+                            minCompatibleVersion(minNodeVersion, repositoryData, snapshotsWithPinnedTimestamp.keySet()),
+                            remoteSegmentStoreDirectoryFactory,
+                            remoteStorePinnedTimestampService,
+                            ActionListener.wrap(updatedRepoData -> {
+                                logger.info("snapshots {} deleted", snapshotsWithPinnedTimestamp);
+                                removeSnapshotDeletionFromClusterState(deleteEntry, null, updatedRepoData);
+                            }, ex -> removeSnapshotDeletionFromClusterState(deleteEntry, ex, repositoryData))
+                        );
+                    }
+
+                } catch (InterruptedException e) {
+                    logger.error("Interrupted while waiting for snapshot info processing", e);
+                    Thread.currentThread().interrupt();
+                    removeSnapshotDeletionFromClusterState(deleteEntry, e, repositoryData);
+                }
+
             } else {
                 repository.deleteSnapshots(
                     snapshotIds,
@@ -3243,6 +3544,42 @@ private static Map<ShardId, SnapshotsInProgress.ShardSnapshotStatus> shards(
         return Collections.unmodifiableMap(builder);
     }
 
+    private static ShardGenerations buildShardsGenerationFromRepositoryData(
+        Metadata metadata,
+        RoutingTable routingTable,
+        List<IndexId> indices,
+        RepositoryData repositoryData
+    ) {
+        ShardGenerations.Builder builder = ShardGenerations.builder();
+        final ShardGenerations shardGenerations = repositoryData.shardGenerations();
+
+        for (IndexId index : indices) {
+            final String indexName = index.getName();
+            final boolean isNewIndex = repositoryData.getIndices().containsKey(indexName) == false;
+            IndexMetadata indexMetadata = metadata.index(indexName);
+
+            final IndexRoutingTable indexRoutingTable = routingTable.index(indexName);
+            for (int i = 0; i < indexMetadata.getNumberOfShards(); i++) {
+                final ShardId shardId = indexRoutingTable.shard(i).shardId();
+                final String shardRepoGeneration;
+
+                if (isNewIndex) {
+                    assert shardGenerations.getShardGen(index, shardId.getId()) == null : "Found shard generation for new index ["
+                        + index
+                        + "]";
+                    shardRepoGeneration = ShardGenerations.NEW_SHARD_GEN;
+                } else {
+                    shardRepoGeneration = shardGenerations.getShardGen(index, shardId.id());
+                }
+                builder.put(index, shardId.id(), shardRepoGeneration);
+
+            }
+
+        }
+
+        return builder.build();
+    }
+
     /**
      * Returns the data streams that are currently being snapshotted (with partial == false) and that are contained in the
      * indices-to-check set.
diff --git a/server/src/main/java/org/opensearch/snapshots/TooManyShardsInSnapshotsStatusException.java b/server/src/main/java/org/opensearch/snapshots/TooManyShardsInSnapshotsStatusException.java
new file mode 100644
index 0000000000000..1689b3e4941ec
--- /dev/null
+++ b/server/src/main/java/org/opensearch/snapshots/TooManyShardsInSnapshotsStatusException.java
@@ -0,0 +1,69 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.snapshots;
+
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.rest.RestStatus;
+
+import java.io.IOException;
+
+/**
+ * Thrown if the number of shards across the requested resources (snapshot(s) or the index/indices of a particular snapshot)
+ * breaches the limit of snapshot.max_shards_allowed_in_status_api cluster setting
+ *
+ * @opensearch.internal
+ */
+public class TooManyShardsInSnapshotsStatusException extends SnapshotException {
+
+    public TooManyShardsInSnapshotsStatusException(
+        final String repositoryName,
+        final SnapshotId snapshotId,
+        final String message,
+        final Throwable cause
+    ) {
+        super(repositoryName, snapshotId, message, cause);
+    }
+
+    public TooManyShardsInSnapshotsStatusException(final String repositoryName, final String message, String... snapshotName) {
+        super(repositoryName, String.join(", ", snapshotName), message);
+    }
+
+    public TooManyShardsInSnapshotsStatusException(StreamInput in) throws IOException {
+        super(in);
+    }
+
+    @Override
+    public RestStatus status() {
+        return RestStatus.REQUEST_ENTITY_TOO_LARGE;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/snapshots/package-info.java b/server/src/main/java/org/opensearch/snapshots/package-info.java
index a573d7a136620..02fbf737dbf62 100644
--- a/server/src/main/java/org/opensearch/snapshots/package-info.java
+++ b/server/src/main/java/org/opensearch/snapshots/package-info.java
@@ -131,7 +131,7 @@
  *     snapshots, we load the {@link org.opensearch.snapshots.SnapshotInfo} for the source snapshot and check for shard snapshot
  *     failures of the relevant indices.</li>
  *     <li>Once all shard counts are known and the health of all source indices data has been verified, we populate the
- *     {@code SnapshotsInProgress.Entry#clones} map for the clone operation with the the relevant shard clone tasks.</li>
+ *     {@code SnapshotsInProgress.Entry#clones} map for the clone operation with the relevant shard clone tasks.</li>
  *     <li>After the clone tasks have been added to the {@code SnapshotsInProgress.Entry}, cluster-manager executes them on its snapshot thread-pool
  *     by invoking {@link org.opensearch.repositories.Repository#cloneShardSnapshot} for each shard that is to be cloned. Each completed
  *     shard snapshot triggers a call to the {@link org.opensearch.snapshots.SnapshotsService#SHARD_STATE_EXECUTOR} which updates the
diff --git a/server/src/main/java/org/opensearch/tasks/Task.java b/server/src/main/java/org/opensearch/tasks/Task.java
index 785abc679ed1d..a366c8b920316 100644
--- a/server/src/main/java/org/opensearch/tasks/Task.java
+++ b/server/src/main/java/org/opensearch/tasks/Task.java
@@ -476,6 +476,18 @@ public void stopThreadResourceTracking(long threadId, ResourceStatsType statsTyp
         throw new IllegalStateException("cannot update final values if active thread resource entry is not present");
     }
 
+    public ThreadResourceInfo getActiveThreadResourceInfo(long threadId, ResourceStatsType statsType) {
+        final List<ThreadResourceInfo> threadResourceInfoList = resourceStats.get(threadId);
+        if (threadResourceInfoList != null) {
+            for (ThreadResourceInfo threadResourceInfo : threadResourceInfoList) {
+                if (threadResourceInfo.getStatsType() == statsType && threadResourceInfo.isActive()) {
+                    return threadResourceInfo;
+                }
+            }
+        }
+        return null;
+    }
+
     /**
      * Individual tasks can override this if they want to support task resource tracking. We just need to make sure that
      * the ThreadPool on which the task runs on have runnable wrapper similar to
diff --git a/server/src/main/java/org/opensearch/tasks/TaskCancellation.java b/server/src/main/java/org/opensearch/tasks/TaskCancellation.java
index 2d152e513f197..872f5b79bb205 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskCancellation.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskCancellation.java
@@ -42,10 +42,25 @@ public List<Reason> getReasons() {
         return reasons;
     }
 
+    public List<Runnable> getOnCancelCallbacks() {
+        return onCancelCallbacks;
+    }
+
     public String getReasonString() {
         return reasons.stream().map(Reason::getMessage).collect(Collectors.joining(", "));
     }
 
+    public TaskCancellation merge(final TaskCancellation other) {
+        if (other == this) {
+            return this;
+        }
+        final List<Reason> newReasons = new ArrayList<>(reasons);
+        newReasons.addAll(other.getReasons());
+        final List<Runnable> newOnCancelCallbacks = new ArrayList<>(onCancelCallbacks);
+        newOnCancelCallbacks.addAll(other.onCancelCallbacks);
+        return new TaskCancellation(task, newReasons, newOnCancelCallbacks);
+    }
+
     /**
      * Cancels the task and invokes all onCancelCallbacks.
      */
diff --git a/server/src/main/java/org/opensearch/tasks/TaskCancellationService.java b/server/src/main/java/org/opensearch/tasks/TaskCancellationService.java
index 4a97513d8f81a..f2dd15b32a7b2 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskCancellationService.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskCancellationService.java
@@ -93,7 +93,7 @@ void cancelTaskAndDescendants(CancellableTask task, String reason, boolean waitF
             Collection<DiscoveryNode> childrenNodes = taskManager.startBanOnChildrenNodes(task.getId(), () -> {
                 logger.trace("child tasks of parent [{}] are completed", taskId);
                 groupedListener.onResponse(null);
-            });
+            }, reason);
             taskManager.cancel(task, reason, () -> {
                 logger.trace("task [{}] is cancelled", taskId);
                 groupedListener.onResponse(null);
diff --git a/server/src/main/java/org/opensearch/tasks/TaskManager.java b/server/src/main/java/org/opensearch/tasks/TaskManager.java
index a49968ab85e89..6ad06da9d2fa2 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskManager.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskManager.java
@@ -510,17 +510,22 @@ public Set<TaskId> getBannedTaskIds() {
         return Collections.unmodifiableSet(banedParents.keySet());
     }
 
+    public Collection<DiscoveryNode> startBanOnChildrenNodes(long taskId, Runnable onChildTasksCompleted) {
+        return startBanOnChildrenNodes(taskId, onChildTasksCompleted, "unknown");
+    }
+
     /**
      * Start rejecting new child requests as the parent task was cancelled.
      *
      * @param taskId                the parent task id
      * @param onChildTasksCompleted called when all child tasks are completed or failed
+     * @param reason                the ban reason
      * @return the set of current nodes that have outstanding child tasks
      */
-    public Collection<DiscoveryNode> startBanOnChildrenNodes(long taskId, Runnable onChildTasksCompleted) {
+    public Collection<DiscoveryNode> startBanOnChildrenNodes(long taskId, Runnable onChildTasksCompleted, String reason) {
         final CancellableTaskHolder holder = cancellableTasks.get(taskId);
         if (holder != null) {
-            return holder.startBan(onChildTasksCompleted);
+            return holder.startBan(onChildTasksCompleted, reason);
         } else {
             onChildTasksCompleted.run();
             return Collections.emptySet();
@@ -585,6 +590,7 @@ private static class CancellableTaskHolder {
         private List<Runnable> cancellationListeners = null;
         private Map<DiscoveryNode, Integer> childTasksPerNode = null;
         private boolean banChildren = false;
+        private String banReason;
         private List<Runnable> childTaskCompletedListeners = null;
 
         CancellableTaskHolder(CancellableTask task) {
@@ -662,7 +668,7 @@ public CancellableTask getTask() {
 
         synchronized void registerChildNode(DiscoveryNode node) {
             if (banChildren) {
-                throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks");
+                throw new TaskCancelledException("The parent task was cancelled, shouldn't start any child tasks, " + banReason);
             }
             if (childTasksPerNode == null) {
                 childTasksPerNode = new HashMap<>();
@@ -686,11 +692,13 @@ void unregisterChildNode(DiscoveryNode node) {
             notifyListeners(listeners);
         }
 
-        Set<DiscoveryNode> startBan(Runnable onChildTasksCompleted) {
+        Set<DiscoveryNode> startBan(Runnable onChildTasksCompleted, String reason) {
             final Set<DiscoveryNode> pendingChildNodes;
             final Runnable toRun;
             synchronized (this) {
                 banChildren = true;
+                assert reason != null;
+                banReason = reason;
                 if (childTasksPerNode == null) {
                     pendingChildNodes = Collections.emptySet();
                 } else {
diff --git a/server/src/main/java/org/opensearch/tasks/TaskResourceTrackingService.java b/server/src/main/java/org/opensearch/tasks/TaskResourceTrackingService.java
index f32559f6314c0..ca1957cdb1633 100644
--- a/server/src/main/java/org/opensearch/tasks/TaskResourceTrackingService.java
+++ b/server/src/main/java/org/opensearch/tasks/TaskResourceTrackingService.java
@@ -14,6 +14,7 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.ExceptionsHelper;
+import org.opensearch.action.search.SearchShardTask;
 import org.opensearch.common.SuppressForbidden;
 import org.opensearch.common.inject.Inject;
 import org.opensearch.common.settings.ClusterSettings;
@@ -22,12 +23,23 @@
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.concurrent.ConcurrentMapLong;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.tasks.resourcetracker.ResourceStats;
+import org.opensearch.core.tasks.resourcetracker.ResourceStatsType;
+import org.opensearch.core.tasks.resourcetracker.ResourceUsageInfo;
 import org.opensearch.core.tasks.resourcetracker.ResourceUsageMetric;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceInfo;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceUsage;
 import org.opensearch.core.tasks.resourcetracker.ThreadResourceInfo;
+import org.opensearch.core.xcontent.DeprecationHandler;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.threadpool.RunnableTaskExecutionListener;
 import org.opensearch.threadpool.ThreadPool;
 
+import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -51,6 +63,7 @@ public class TaskResourceTrackingService implements RunnableTaskExecutionListene
         Setting.Property.NodeScope
     );
     public static final String TASK_ID = "TASK_ID";
+    public static final String TASK_RESOURCE_USAGE = "TASK_RESOURCE_USAGE";
 
     private static final ThreadMXBean threadMXBean = (ThreadMXBean) ManagementFactory.getThreadMXBean();
 
@@ -261,6 +274,86 @@ private ThreadContext.StoredContext addTaskIdToThreadContext(Task task) {
         return storedContext;
     }
 
+    /**
+     * Get the current task level resource usage.
+     *
+     * @param task {@link SearchShardTask}
+     * @param nodeId the local nodeId
+     */
+    public void writeTaskResourceUsage(SearchShardTask task, String nodeId) {
+        try {
+            // Get resource usages from when the task started
+            ThreadResourceInfo threadResourceInfo = task.getActiveThreadResourceInfo(
+                Thread.currentThread().getId(),
+                ResourceStatsType.WORKER_STATS
+            );
+            if (threadResourceInfo == null) {
+                return;
+            }
+            Map<ResourceStats, ResourceUsageInfo.ResourceStatsInfo> startValues = threadResourceInfo.getResourceUsageInfo().getStatsInfo();
+            if (!(startValues.containsKey(ResourceStats.CPU) && startValues.containsKey(ResourceStats.MEMORY))) {
+                return;
+            }
+            // Get current resource usages
+            ResourceUsageMetric[] endValues = getResourceUsageMetricsForThread(Thread.currentThread().getId());
+            long cpu = -1, mem = -1;
+            for (ResourceUsageMetric endValue : endValues) {
+                if (endValue.getStats() == ResourceStats.MEMORY) {
+                    mem = endValue.getValue();
+                } else if (endValue.getStats() == ResourceStats.CPU) {
+                    cpu = endValue.getValue();
+                }
+            }
+            if (cpu == -1 || mem == -1) {
+                logger.debug("Invalid resource usage value, cpu [{}], memory [{}]: ", cpu, mem);
+                return;
+            }
+
+            // Build task resource usage info
+            TaskResourceInfo taskResourceInfo = new TaskResourceInfo.Builder().setAction(task.getAction())
+                .setTaskId(task.getId())
+                .setParentTaskId(task.getParentTaskId().getId())
+                .setNodeId(nodeId)
+                .setTaskResourceUsage(
+                    new TaskResourceUsage(
+                        cpu - startValues.get(ResourceStats.CPU).getStartValue(),
+                        mem - startValues.get(ResourceStats.MEMORY).getStartValue()
+                    )
+                )
+                .build();
+            // Remove the existing TASK_RESOURCE_USAGE header since it would have come from an earlier phase in the same request.
+            threadPool.getThreadContext().updateResponseHeader(TASK_RESOURCE_USAGE, taskResourceInfo.toString());
+        } catch (Exception e) {
+            logger.debug("Error during writing task resource usage: ", e);
+        }
+    }
+
+    /**
+     * Get the task resource usages from {@link ThreadContext}
+     *
+     * @return {@link TaskResourceInfo}
+     */
+    public TaskResourceInfo getTaskResourceUsageFromThreadContext() {
+        List<String> taskResourceUsages = threadPool.getThreadContext().getResponseHeaders().get(TASK_RESOURCE_USAGE);
+        if (taskResourceUsages != null && taskResourceUsages.size() > 0) {
+            String usage = taskResourceUsages.get(0);
+            try {
+                if (usage != null && !usage.isEmpty()) {
+                    XContentParser parser = XContentHelper.createParser(
+                        NamedXContentRegistry.EMPTY,
+                        DeprecationHandler.THROW_UNSUPPORTED_OPERATION,
+                        new BytesArray(usage),
+                        MediaTypeRegistry.JSON
+                    );
+                    return TaskResourceInfo.PARSER.apply(parser, null);
+                }
+            } catch (IOException e) {
+                logger.debug("fail to parse phase resource usages: ", e);
+            }
+        }
+        return null;
+    }
+
     /**
      * Listener that gets invoked when a task execution completes.
      */
diff --git a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
index 6fad8d6c7824b..6176f2e76d760 100644
--- a/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
+++ b/server/src/main/java/org/opensearch/threadpool/ThreadPool.java
@@ -104,6 +104,7 @@ public static class Names {
         public static final String REFRESH = "refresh";
         public static final String WARMER = "warmer";
         public static final String SNAPSHOT = "snapshot";
+        public static final String SNAPSHOT_DELETION = "snapshot_deletion";
         public static final String FORCE_MERGE = "force_merge";
         public static final String FETCH_SHARD_STARTED = "fetch_shard_started";
         public static final String FETCH_SHARD_STORE = "fetch_shard_store";
@@ -114,6 +115,7 @@ public static class Names {
         public static final String REMOTE_PURGE = "remote_purge";
         public static final String REMOTE_REFRESH_RETRY = "remote_refresh_retry";
         public static final String REMOTE_RECOVERY = "remote_recovery";
+        public static final String REMOTE_STATE_READ = "remote_state_read";
         public static final String INDEX_SEARCHER = "index_searcher";
     }
 
@@ -174,6 +176,7 @@ public static ThreadPoolType fromType(String type) {
         map.put(Names.REFRESH, ThreadPoolType.SCALING);
         map.put(Names.WARMER, ThreadPoolType.SCALING);
         map.put(Names.SNAPSHOT, ThreadPoolType.SCALING);
+        map.put(Names.SNAPSHOT_DELETION, ThreadPoolType.SCALING);
         map.put(Names.FORCE_MERGE, ThreadPoolType.FIXED);
         map.put(Names.FETCH_SHARD_STARTED, ThreadPoolType.SCALING);
         map.put(Names.FETCH_SHARD_STORE, ThreadPoolType.SCALING);
@@ -186,6 +189,7 @@ public static ThreadPoolType fromType(String type) {
         map.put(Names.REMOTE_REFRESH_RETRY, ThreadPoolType.SCALING);
         map.put(Names.REMOTE_RECOVERY, ThreadPoolType.SCALING);
         map.put(Names.INDEX_SEARCHER, ThreadPoolType.FIXED_AUTO_QUEUE_SIZE);
+        map.put(Names.REMOTE_STATE_READ, ThreadPoolType.SCALING);
         THREAD_POOL_TYPES = Collections.unmodifiableMap(map);
     }
 
@@ -231,6 +235,7 @@ public ThreadPool(
         final int halfProcMaxAt5 = halfAllocatedProcessorsMaxFive(allocatedProcessors);
         final int halfProcMaxAt10 = halfAllocatedProcessorsMaxTen(allocatedProcessors);
         final int genericThreadPoolMax = boundedBy(4 * allocatedProcessors, 128, 512);
+        final int snapshotDeletionPoolMax = boundedBy(4 * allocatedProcessors, 64, 256);
         builders.put(Names.GENERIC, new ScalingExecutorBuilder(Names.GENERIC, 4, genericThreadPoolMax, TimeValue.timeValueSeconds(30)));
         builders.put(Names.WRITE, new FixedExecutorBuilder(settings, Names.WRITE, allocatedProcessors, 10000));
         builders.put(Names.GET, new FixedExecutorBuilder(settings, Names.GET, allocatedProcessors, 1000));
@@ -260,6 +265,10 @@ public ThreadPool(
         builders.put(Names.REFRESH, new ScalingExecutorBuilder(Names.REFRESH, 1, halfProcMaxAt10, TimeValue.timeValueMinutes(5)));
         builders.put(Names.WARMER, new ScalingExecutorBuilder(Names.WARMER, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
         builders.put(Names.SNAPSHOT, new ScalingExecutorBuilder(Names.SNAPSHOT, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
+        builders.put(
+            Names.SNAPSHOT_DELETION,
+            new ScalingExecutorBuilder(Names.SNAPSHOT_DELETION, 1, snapshotDeletionPoolMax, TimeValue.timeValueMinutes(5))
+        );
         builders.put(
             Names.FETCH_SHARD_STARTED,
             new ScalingExecutorBuilder(Names.FETCH_SHARD_STARTED, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5))
@@ -290,6 +299,15 @@ public ThreadPool(
                 TimeValue.timeValueMinutes(5)
             )
         );
+        builders.put(
+            Names.REMOTE_STATE_READ,
+            new ScalingExecutorBuilder(
+                Names.REMOTE_STATE_READ,
+                1,
+                twiceAllocatedProcessors(allocatedProcessors),
+                TimeValue.timeValueMinutes(5)
+            )
+        );
         builders.put(
             Names.INDEX_SEARCHER,
             new AutoQueueAdjustingExecutorBuilder(
diff --git a/server/src/main/java/org/opensearch/transport/Header.java b/server/src/main/java/org/opensearch/transport/Header.java
index ac30df8dda02c..fcfeb9c632075 100644
--- a/server/src/main/java/org/opensearch/transport/Header.java
+++ b/server/src/main/java/org/opensearch/transport/Header.java
@@ -55,6 +55,7 @@ public class Header {
 
     private static final String RESPONSE_NAME = "NO_ACTION_NAME_FOR_RESPONSES";
 
+    private final TransportProtocol protocol;
     private final int networkMessageSize;
     private final Version version;
     private final long requestId;
@@ -64,13 +65,18 @@ public class Header {
     Tuple<Map<String, String>, Map<String, Set<String>>> headers;
     Set<String> features;
 
-    Header(int networkMessageSize, long requestId, byte status, Version version) {
+    Header(TransportProtocol protocol, int networkMessageSize, long requestId, byte status, Version version) {
+        this.protocol = protocol;
         this.networkMessageSize = networkMessageSize;
         this.version = version;
         this.requestId = requestId;
         this.status = status;
     }
 
+    TransportProtocol getTransportProtocol() {
+        return protocol;
+    }
+
     public int getNetworkMessageSize() {
         return networkMessageSize;
     }
@@ -142,6 +148,8 @@ void finishParsingHeader(StreamInput input) throws IOException {
     @Override
     public String toString() {
         return "Header{"
+            + protocol
+            + "}{"
             + networkMessageSize
             + "}{"
             + version
diff --git a/server/src/main/java/org/opensearch/transport/InboundBytesHandler.java b/server/src/main/java/org/opensearch/transport/InboundBytesHandler.java
index 276891212e43f..ad839bc990018 100644
--- a/server/src/main/java/org/opensearch/transport/InboundBytesHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundBytesHandler.java
@@ -9,24 +9,139 @@
 package org.opensearch.transport;
 
 import org.opensearch.common.bytes.ReleasableBytesReference;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.core.common.bytes.CompositeBytesReference;
 
-import java.io.Closeable;
 import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
 import java.util.function.BiConsumer;
 
 /**
- * Interface for handling inbound bytes. Can be implemented by different transport protocols.
+ * Handler for inbound bytes, using {@link InboundDecoder} to decode headers
+ * and {@link InboundAggregator} to assemble complete messages to forward to
+ * the given message handler to parse the message payload.
  */
-public interface InboundBytesHandler extends Closeable {
+class InboundBytesHandler {
 
-    public void doHandleBytes(
-        TcpChannel channel,
-        ReleasableBytesReference reference,
-        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
-    ) throws IOException;
+    private static final ThreadLocal<ArrayList<Object>> fragmentList = ThreadLocal.withInitial(ArrayList::new);
 
-    public boolean canHandleBytes(ReleasableBytesReference reference);
+    private final ArrayDeque<ReleasableBytesReference> pending;
+    private final InboundDecoder decoder;
+    private final InboundAggregator aggregator;
+    private final StatsTracker statsTracker;
+    private boolean isClosed = false;
+
+    InboundBytesHandler(
+        ArrayDeque<ReleasableBytesReference> pending,
+        InboundDecoder decoder,
+        InboundAggregator aggregator,
+        StatsTracker statsTracker
+    ) {
+        this.pending = pending;
+        this.decoder = decoder;
+        this.aggregator = aggregator;
+        this.statsTracker = statsTracker;
+    }
+
+    public void close() {
+        isClosed = true;
+    }
+
+    public void doHandleBytes(TcpChannel channel, ReleasableBytesReference reference, BiConsumer<TcpChannel, InboundMessage> messageHandler)
+        throws IOException {
+        final ArrayList<Object> fragments = fragmentList.get();
+        boolean continueHandling = true;
+
+        while (continueHandling && isClosed == false) {
+            boolean continueDecoding = true;
+            while (continueDecoding && pending.isEmpty() == false) {
+                try (ReleasableBytesReference toDecode = getPendingBytes()) {
+                    final int bytesDecoded = decoder.decode(toDecode, fragments::add);
+                    if (bytesDecoded != 0) {
+                        releasePendingBytes(bytesDecoded);
+                        if (fragments.isEmpty() == false && endOfMessage(fragments.get(fragments.size() - 1))) {
+                            continueDecoding = false;
+                        }
+                    } else {
+                        continueDecoding = false;
+                    }
+                }
+            }
+
+            if (fragments.isEmpty()) {
+                continueHandling = false;
+            } else {
+                try {
+                    forwardFragments(channel, fragments, messageHandler);
+                } finally {
+                    for (Object fragment : fragments) {
+                        if (fragment instanceof ReleasableBytesReference) {
+                            ((ReleasableBytesReference) fragment).close();
+                        }
+                    }
+                    fragments.clear();
+                }
+            }
+        }
+    }
+
+    private ReleasableBytesReference getPendingBytes() {
+        if (pending.size() == 1) {
+            return pending.peekFirst().retain();
+        } else {
+            final ReleasableBytesReference[] bytesReferences = new ReleasableBytesReference[pending.size()];
+            int index = 0;
+            for (ReleasableBytesReference pendingReference : pending) {
+                bytesReferences[index] = pendingReference.retain();
+                ++index;
+            }
+            final Releasable releasable = () -> Releasables.closeWhileHandlingException(bytesReferences);
+            return new ReleasableBytesReference(CompositeBytesReference.of(bytesReferences), releasable);
+        }
+    }
+
+    private void releasePendingBytes(int bytesConsumed) {
+        int bytesToRelease = bytesConsumed;
+        while (bytesToRelease != 0) {
+            try (ReleasableBytesReference reference = pending.pollFirst()) {
+                assert reference != null;
+                if (bytesToRelease < reference.length()) {
+                    pending.addFirst(reference.retainedSlice(bytesToRelease, reference.length() - bytesToRelease));
+                    bytesToRelease -= bytesToRelease;
+                } else {
+                    bytesToRelease -= reference.length();
+                }
+            }
+        }
+    }
+
+    private boolean endOfMessage(Object fragment) {
+        return fragment == InboundDecoder.PING || fragment == InboundDecoder.END_CONTENT || fragment instanceof Exception;
+    }
+
+    private void forwardFragments(TcpChannel channel, ArrayList<Object> fragments, BiConsumer<TcpChannel, InboundMessage> messageHandler)
+        throws IOException {
+        for (Object fragment : fragments) {
+            if (fragment instanceof Header) {
+                assert aggregator.isAggregating() == false;
+                aggregator.headerReceived((Header) fragment);
+            } else if (fragment == InboundDecoder.PING) {
+                assert aggregator.isAggregating() == false;
+                messageHandler.accept(channel, InboundMessage.PING);
+            } else if (fragment == InboundDecoder.END_CONTENT) {
+                assert aggregator.isAggregating();
+                try (InboundMessage aggregated = aggregator.finishAggregation()) {
+                    statsTracker.markMessageReceived();
+                    messageHandler.accept(channel, aggregated);
+                }
+            } else {
+                assert aggregator.isAggregating();
+                assert fragment instanceof ReleasableBytesReference;
+                aggregator.aggregate((ReleasableBytesReference) fragment);
+            }
+        }
+    }
 
-    @Override
-    void close();
 }
diff --git a/server/src/main/java/org/opensearch/transport/InboundDecoder.java b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
index ec2c4b180ef08..0b93256a9817f 100644
--- a/server/src/main/java/org/opensearch/transport/InboundDecoder.java
+++ b/server/src/main/java/org/opensearch/transport/InboundDecoder.java
@@ -187,11 +187,12 @@ private int headerBytesToRead(BytesReference reference) {
     // exposed for use in tests
     static Header readHeader(Version version, int networkMessageSize, BytesReference bytesReference) throws IOException {
         try (StreamInput streamInput = bytesReference.streamInput()) {
-            streamInput.skip(TcpHeader.BYTES_REQUIRED_FOR_MESSAGE_SIZE);
+            TransportProtocol protocol = TransportProtocol.fromBytes(streamInput.readByte(), streamInput.readByte());
+            streamInput.skip(TcpHeader.MESSAGE_LENGTH_SIZE);
             long requestId = streamInput.readLong();
             byte status = streamInput.readByte();
             Version remoteVersion = Version.fromId(streamInput.readInt());
-            Header header = new Header(networkMessageSize, requestId, status, remoteVersion);
+            Header header = new Header(protocol, networkMessageSize, requestId, status, remoteVersion);
             final IllegalStateException invalidVersion = ensureVersionCompatibility(remoteVersion, version, header.isHandshake());
             if (invalidVersion != null) {
                 throw invalidVersion;
diff --git a/server/src/main/java/org/opensearch/transport/InboundHandler.java b/server/src/main/java/org/opensearch/transport/InboundHandler.java
index f77c44ea362cf..76a44832b08dc 100644
--- a/server/src/main/java/org/opensearch/transport/InboundHandler.java
+++ b/server/src/main/java/org/opensearch/transport/InboundHandler.java
@@ -38,7 +38,6 @@
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.telemetry.tracing.Tracer;
 import org.opensearch.threadpool.ThreadPool;
-import org.opensearch.transport.nativeprotocol.NativeInboundMessage;
 
 import java.io.IOException;
 import java.util.Map;
@@ -56,7 +55,7 @@ public class InboundHandler {
 
     private volatile long slowLogThresholdMs = Long.MAX_VALUE;
 
-    private final Map<String, ProtocolMessageHandler> protocolMessageHandlers;
+    private final Map<TransportProtocol, ProtocolMessageHandler> protocolMessageHandlers;
 
     InboundHandler(
         String nodeName,
@@ -75,7 +74,7 @@ public class InboundHandler {
     ) {
         this.threadPool = threadPool;
         this.protocolMessageHandlers = Map.of(
-            NativeInboundMessage.NATIVE_PROTOCOL,
+            TransportProtocol.NATIVE,
             new NativeMessageHandler(
                 nodeName,
                 version,
@@ -107,16 +106,16 @@ void setSlowLogThreshold(TimeValue slowLogThreshold) {
         this.slowLogThresholdMs = slowLogThreshold.getMillis();
     }
 
-    void inboundMessage(TcpChannel channel, ProtocolInboundMessage message) throws Exception {
+    void inboundMessage(TcpChannel channel, InboundMessage message) throws Exception {
         final long startTime = threadPool.relativeTimeInMillis();
         channel.getChannelStats().markAccessed(startTime);
         messageReceivedFromPipeline(channel, message, startTime);
     }
 
-    private void messageReceivedFromPipeline(TcpChannel channel, ProtocolInboundMessage message, long startTime) throws IOException {
-        ProtocolMessageHandler protocolMessageHandler = protocolMessageHandlers.get(message.getProtocol());
+    private void messageReceivedFromPipeline(TcpChannel channel, InboundMessage message, long startTime) throws IOException {
+        ProtocolMessageHandler protocolMessageHandler = protocolMessageHandlers.get(message.getTransportProtocol());
         if (protocolMessageHandler == null) {
-            throw new IllegalStateException("No protocol message handler found for protocol: " + message.getProtocol());
+            throw new IllegalStateException("No protocol message handler found for protocol: " + message.getTransportProtocol());
         }
         protocolMessageHandler.messageReceived(channel, message, startTime, slowLogThresholdMs, messageListener);
     }
diff --git a/server/src/main/java/org/opensearch/transport/InboundMessage.java b/server/src/main/java/org/opensearch/transport/InboundMessage.java
index 5c68257557061..576ab73ce9c98 100644
--- a/server/src/main/java/org/opensearch/transport/InboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/InboundMessage.java
@@ -32,77 +32,118 @@
 
 package org.opensearch.transport;
 
-import org.opensearch.common.annotation.DeprecatedApi;
+import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.common.io.stream.StreamInput;
-import org.opensearch.transport.nativeprotocol.NativeInboundMessage;
 
 import java.io.IOException;
 
 /**
  * Inbound data as a message
- * This api is deprecated, please use {@link org.opensearch.transport.nativeprotocol.NativeInboundMessage} instead.
- * @opensearch.api
  */
-@DeprecatedApi(since = "2.14.0")
+@PublicApi(since = "1.0.0")
 public class InboundMessage implements Releasable, ProtocolInboundMessage {
 
-    private final NativeInboundMessage nativeInboundMessage;
+    static final InboundMessage PING = new InboundMessage(null, null, null, true, null);
+
+    protected final Header header;
+    protected final ReleasableBytesReference content;
+    protected final Exception exception;
+    protected final boolean isPing;
+    private Releasable breakerRelease;
+    private StreamInput streamInput;
 
     public InboundMessage(Header header, ReleasableBytesReference content, Releasable breakerRelease) {
-        this.nativeInboundMessage = new NativeInboundMessage(header, content, breakerRelease);
+        this(header, content, null, false, breakerRelease);
     }
 
     public InboundMessage(Header header, Exception exception) {
-        this.nativeInboundMessage = new NativeInboundMessage(header, exception);
+        this(header, null, exception, false, null);
     }
 
     public InboundMessage(Header header, boolean isPing) {
-        this.nativeInboundMessage = new NativeInboundMessage(header, isPing);
+        this(header, null, null, isPing, null);
+    }
+
+    private InboundMessage(
+        Header header,
+        ReleasableBytesReference content,
+        Exception exception,
+        boolean isPing,
+        Releasable breakerRelease
+    ) {
+        this.header = header;
+        this.content = content;
+        this.exception = exception;
+        this.isPing = isPing;
+        this.breakerRelease = breakerRelease;
+    }
+
+    TransportProtocol getTransportProtocol() {
+        if (isPing) {
+            return TransportProtocol.NATIVE;
+        }
+        return header.getTransportProtocol();
+    }
+
+    public String getProtocol() {
+        return header.getTransportProtocol().toString();
     }
 
     public Header getHeader() {
-        return this.nativeInboundMessage.getHeader();
+        return header;
     }
 
     public int getContentLength() {
-        return this.nativeInboundMessage.getContentLength();
+        if (content == null) {
+            return 0;
+        } else {
+            return content.length();
+        }
     }
 
     public Exception getException() {
-        return this.nativeInboundMessage.getException();
+        return exception;
     }
 
     public boolean isPing() {
-        return this.nativeInboundMessage.isPing();
+        return isPing;
     }
 
     public boolean isShortCircuit() {
-        return this.nativeInboundMessage.getException() != null;
+        return exception != null;
     }
 
     public Releasable takeBreakerReleaseControl() {
-        return this.nativeInboundMessage.takeBreakerReleaseControl();
+        final Releasable toReturn = breakerRelease;
+        breakerRelease = null;
+        if (toReturn != null) {
+            return toReturn;
+        } else {
+            return () -> {};
+        }
     }
 
     public StreamInput openOrGetStreamInput() throws IOException {
-        return this.nativeInboundMessage.openOrGetStreamInput();
+        assert isPing == false && content != null;
+        if (streamInput == null) {
+            streamInput = content.streamInput();
+            streamInput.setVersion(header.getVersion());
+        }
+        return streamInput;
     }
 
     @Override
     public void close() {
-        this.nativeInboundMessage.close();
+        IOUtils.closeWhileHandlingException(streamInput);
+        Releasables.closeWhileHandlingException(content, breakerRelease);
     }
 
     @Override
     public String toString() {
-        return this.nativeInboundMessage.toString();
-    }
-
-    @Override
-    public String getProtocol() {
-        return this.nativeInboundMessage.getProtocol();
+        return "InboundMessage{" + header + "}";
     }
-
 }
diff --git a/server/src/main/java/org/opensearch/transport/InboundPipeline.java b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
index 5cee3bb975223..3acb43f58b443 100644
--- a/server/src/main/java/org/opensearch/transport/InboundPipeline.java
+++ b/server/src/main/java/org/opensearch/transport/InboundPipeline.java
@@ -38,11 +38,9 @@
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.util.PageCacheRecycler;
 import org.opensearch.core.common.breaker.CircuitBreaker;
-import org.opensearch.transport.nativeprotocol.NativeInboundBytesHandler;
 
 import java.io.IOException;
 import java.util.ArrayDeque;
-import java.util.List;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 import java.util.function.LongSupplier;
@@ -62,9 +60,8 @@ public class InboundPipeline implements Releasable {
     private Exception uncaughtException;
     private final ArrayDeque<ReleasableBytesReference> pending = new ArrayDeque<>(2);
     private boolean isClosed = false;
-    private final BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler;
-    private final List<InboundBytesHandler> protocolBytesHandlers;
-    private InboundBytesHandler currentHandler;
+    private final BiConsumer<TcpChannel, InboundMessage> messageHandler;
+    private final InboundBytesHandler bytesHandler;
 
     public InboundPipeline(
         Version version,
@@ -73,7 +70,7 @@ public InboundPipeline(
         LongSupplier relativeTimeInMillis,
         Supplier<CircuitBreaker> circuitBreaker,
         Function<String, RequestHandlerRegistry<TransportRequest>> registryFunction,
-        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
+        BiConsumer<TcpChannel, InboundMessage> messageHandler
     ) {
         this(
             statsTracker,
@@ -89,23 +86,20 @@ public InboundPipeline(
         LongSupplier relativeTimeInMillis,
         InboundDecoder decoder,
         InboundAggregator aggregator,
-        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
+        BiConsumer<TcpChannel, InboundMessage> messageHandler
     ) {
         this.relativeTimeInMillis = relativeTimeInMillis;
         this.statsTracker = statsTracker;
         this.decoder = decoder;
         this.aggregator = aggregator;
-        this.protocolBytesHandlers = List.of(new NativeInboundBytesHandler(pending, decoder, aggregator, statsTracker));
+        this.bytesHandler = new InboundBytesHandler(pending, decoder, aggregator, statsTracker);
         this.messageHandler = messageHandler;
     }
 
     @Override
     public void close() {
         isClosed = true;
-        if (currentHandler != null) {
-            currentHandler.close();
-            currentHandler = null;
-        }
+        bytesHandler.close();
         Releasables.closeWhileHandlingException(decoder, aggregator);
         Releasables.closeWhileHandlingException(pending);
         pending.clear();
@@ -127,22 +121,6 @@ public void doHandleBytes(TcpChannel channel, ReleasableBytesReference reference
         channel.getChannelStats().markAccessed(relativeTimeInMillis.getAsLong());
         statsTracker.markBytesRead(reference.length());
         pending.add(reference.retain());
-
-        // If we don't have a current handler, we should try to find one based on the protocol of the incoming bytes.
-        if (currentHandler == null) {
-            for (InboundBytesHandler handler : protocolBytesHandlers) {
-                if (handler.canHandleBytes(reference)) {
-                    currentHandler = handler;
-                    break;
-                }
-            }
-        }
-
-        // If we have a current handler determined based on protocol, we should continue to use it for the fragmented bytes.
-        if (currentHandler != null) {
-            currentHandler.doHandleBytes(channel, reference, messageHandler);
-        } else {
-            throw new IllegalStateException("No bytes handler found for the incoming transport protocol");
-        }
+        bytesHandler.doHandleBytes(channel, reference, messageHandler);
     }
 }
diff --git a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
index 8a5f6dfffb036..8f0ee52ac3acd 100644
--- a/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
+++ b/server/src/main/java/org/opensearch/transport/RemoteClusterConnection.java
@@ -40,6 +40,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamInput;
@@ -136,7 +137,7 @@ void collectNodes(ActionListener<Function<String, DiscoveryNode>> listener) {
                 new ContextPreservingActionListener<>(threadContext.newRestorableContext(false), listener);
             try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
                 // we stash any context here since this is an internal execution and should not leak any existing context information
-                threadContext.markAsSystemContext();
+                ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
 
                 final ClusterStateRequest request = new ClusterStateRequest();
                 request.clear();
diff --git a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
index 07ba96b135189..1d94228218fd0 100644
--- a/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
+++ b/server/src/main/java/org/opensearch/transport/SniffConnectionStrategy.java
@@ -47,6 +47,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.Strings;
@@ -349,7 +350,7 @@ private void collectRemoteNodes(Iterator<Supplier<DiscoveryNode>> seedNodes, Act
                 try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
                     // we stash any context here since this is an internal execution and should not leak any
                     // existing context information.
-                    threadContext.markAsSystemContext();
+                    ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
                     transportService.sendRequest(
                         connection,
                         ClusterStateAction.NAME,
diff --git a/server/src/main/java/org/opensearch/transport/TcpChannel.java b/server/src/main/java/org/opensearch/transport/TcpChannel.java
index 7d4515de85d80..75a6d8b2cff5f 100644
--- a/server/src/main/java/org/opensearch/transport/TcpChannel.java
+++ b/server/src/main/java/org/opensearch/transport/TcpChannel.java
@@ -101,7 +101,7 @@ public interface TcpChannel extends CloseableChannel {
 
     /**
      * Returns the contextual property associated with this specific TCP channel (the
-     * implementation of how such properties are managed depends on the the particular
+     * implementation of how such properties are managed depends on the particular
      * transport engine).
      *
      * @param name the name of the property
diff --git a/server/src/main/java/org/opensearch/transport/TcpTransport.java b/server/src/main/java/org/opensearch/transport/TcpTransport.java
index 78452a25a58d6..f56cd146ce953 100644
--- a/server/src/main/java/org/opensearch/transport/TcpTransport.java
+++ b/server/src/main/java/org/opensearch/transport/TcpTransport.java
@@ -778,15 +778,11 @@ protected void serverAcceptedChannel(TcpChannel channel) {
     protected abstract void stopInternal();
 
     /**
-     * @deprecated use {@link #inboundMessage(TcpChannel, ProtocolInboundMessage)}
-     * Handles inbound message that has been decoded.
-     *
-     * @param channel the channel the message is from
-     * @param message the message
+     * @deprecated Use {{@link #inboundMessage(TcpChannel, InboundMessage)}} instead
      */
-    @Deprecated(since = "2.14.0", forRemoval = true)
-    public void inboundMessage(TcpChannel channel, InboundMessage message) {
-        inboundMessage(channel, (ProtocolInboundMessage) message);
+    @Deprecated
+    public void inboundMessage(TcpChannel channel, ProtocolInboundMessage message) {
+        inboundMessage(channel, (InboundMessage) message);
     }
 
     /**
@@ -795,7 +791,7 @@ public void inboundMessage(TcpChannel channel, InboundMessage message) {
      * @param channel the channel the message is from
      * @param message the message
      */
-    public void inboundMessage(TcpChannel channel, ProtocolInboundMessage message) {
+    public void inboundMessage(TcpChannel channel, InboundMessage message) {
         try {
             inboundHandler.inboundMessage(channel, message);
         } catch (Exception e) {
diff --git a/server/src/main/java/org/opensearch/transport/TransportProtocol.java b/server/src/main/java/org/opensearch/transport/TransportProtocol.java
new file mode 100644
index 0000000000000..4a11520d38d56
--- /dev/null
+++ b/server/src/main/java/org/opensearch/transport/TransportProtocol.java
@@ -0,0 +1,29 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.transport;
+
+/**
+ * Enumeration of transport protocols.
+ */
+enum TransportProtocol {
+    /**
+     * The original, hand-rolled binary protocol used for node-to-node
+     * communication. Message schemas are defined implicitly in code using the
+     * StreamInput and StreamOutput classes to parse and generate binary data.
+     */
+    NATIVE;
+
+    public static TransportProtocol fromBytes(byte b1, byte b2) {
+        if (b1 == 'E' && b2 == 'S') {
+            return NATIVE;
+        }
+
+        throw new IllegalArgumentException("Unknown transport protocol: [" + b1 + ", " + b2 + "]");
+    }
+}
diff --git a/server/src/main/java/org/opensearch/transport/TransportService.java b/server/src/main/java/org/opensearch/transport/TransportService.java
index 59130ec637a52..8792f56ea8da0 100644
--- a/server/src/main/java/org/opensearch/transport/TransportService.java
+++ b/server/src/main/java/org/opensearch/transport/TransportService.java
@@ -759,7 +759,7 @@ public HandshakeResponse(StreamInput in) throws IOException {
 
         @Override
         public void writeTo(StreamOutput out) throws IOException {
-            out.writeOptionalWriteable(discoveryNode);
+            out.writeOptionalWriteable((stream, node) -> node.writeToWithAttribute(stream), discoveryNode);
             clusterName.writeTo(out);
             if (out.getVersion().before(Version.V_1_0_0)) {
                 out.writeVersion(LegacyESVersion.V_7_10_2);
diff --git a/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundBytesHandler.java b/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundBytesHandler.java
deleted file mode 100644
index a8a4c0da7ec0f..0000000000000
--- a/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundBytesHandler.java
+++ /dev/null
@@ -1,167 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.transport.nativeprotocol;
-
-import org.opensearch.common.bytes.ReleasableBytesReference;
-import org.opensearch.common.lease.Releasable;
-import org.opensearch.common.lease.Releasables;
-import org.opensearch.core.common.bytes.CompositeBytesReference;
-import org.opensearch.transport.Header;
-import org.opensearch.transport.InboundAggregator;
-import org.opensearch.transport.InboundBytesHandler;
-import org.opensearch.transport.InboundDecoder;
-import org.opensearch.transport.InboundMessage;
-import org.opensearch.transport.ProtocolInboundMessage;
-import org.opensearch.transport.StatsTracker;
-import org.opensearch.transport.TcpChannel;
-
-import java.io.IOException;
-import java.util.ArrayDeque;
-import java.util.ArrayList;
-import java.util.function.BiConsumer;
-
-/**
- * Handler for inbound bytes for the native protocol.
- */
-public class NativeInboundBytesHandler implements InboundBytesHandler {
-
-    private static final ThreadLocal<ArrayList<Object>> fragmentList = ThreadLocal.withInitial(ArrayList::new);
-    private static final InboundMessage PING_MESSAGE = new InboundMessage(null, true);
-
-    private final ArrayDeque<ReleasableBytesReference> pending;
-    private final InboundDecoder decoder;
-    private final InboundAggregator aggregator;
-    private final StatsTracker statsTracker;
-    private boolean isClosed = false;
-
-    public NativeInboundBytesHandler(
-        ArrayDeque<ReleasableBytesReference> pending,
-        InboundDecoder decoder,
-        InboundAggregator aggregator,
-        StatsTracker statsTracker
-    ) {
-        this.pending = pending;
-        this.decoder = decoder;
-        this.aggregator = aggregator;
-        this.statsTracker = statsTracker;
-    }
-
-    @Override
-    public void close() {
-        isClosed = true;
-    }
-
-    @Override
-    public boolean canHandleBytes(ReleasableBytesReference reference) {
-        return true;
-    }
-
-    @Override
-    public void doHandleBytes(
-        TcpChannel channel,
-        ReleasableBytesReference reference,
-        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
-    ) throws IOException {
-        final ArrayList<Object> fragments = fragmentList.get();
-        boolean continueHandling = true;
-
-        while (continueHandling && isClosed == false) {
-            boolean continueDecoding = true;
-            while (continueDecoding && pending.isEmpty() == false) {
-                try (ReleasableBytesReference toDecode = getPendingBytes()) {
-                    final int bytesDecoded = decoder.decode(toDecode, fragments::add);
-                    if (bytesDecoded != 0) {
-                        releasePendingBytes(bytesDecoded);
-                        if (fragments.isEmpty() == false && endOfMessage(fragments.get(fragments.size() - 1))) {
-                            continueDecoding = false;
-                        }
-                    } else {
-                        continueDecoding = false;
-                    }
-                }
-            }
-
-            if (fragments.isEmpty()) {
-                continueHandling = false;
-            } else {
-                try {
-                    forwardFragments(channel, fragments, messageHandler);
-                } finally {
-                    for (Object fragment : fragments) {
-                        if (fragment instanceof ReleasableBytesReference) {
-                            ((ReleasableBytesReference) fragment).close();
-                        }
-                    }
-                    fragments.clear();
-                }
-            }
-        }
-    }
-
-    private ReleasableBytesReference getPendingBytes() {
-        if (pending.size() == 1) {
-            return pending.peekFirst().retain();
-        } else {
-            final ReleasableBytesReference[] bytesReferences = new ReleasableBytesReference[pending.size()];
-            int index = 0;
-            for (ReleasableBytesReference pendingReference : pending) {
-                bytesReferences[index] = pendingReference.retain();
-                ++index;
-            }
-            final Releasable releasable = () -> Releasables.closeWhileHandlingException(bytesReferences);
-            return new ReleasableBytesReference(CompositeBytesReference.of(bytesReferences), releasable);
-        }
-    }
-
-    private void releasePendingBytes(int bytesConsumed) {
-        int bytesToRelease = bytesConsumed;
-        while (bytesToRelease != 0) {
-            try (ReleasableBytesReference reference = pending.pollFirst()) {
-                assert reference != null;
-                if (bytesToRelease < reference.length()) {
-                    pending.addFirst(reference.retainedSlice(bytesToRelease, reference.length() - bytesToRelease));
-                    bytesToRelease -= bytesToRelease;
-                } else {
-                    bytesToRelease -= reference.length();
-                }
-            }
-        }
-    }
-
-    private boolean endOfMessage(Object fragment) {
-        return fragment == InboundDecoder.PING || fragment == InboundDecoder.END_CONTENT || fragment instanceof Exception;
-    }
-
-    private void forwardFragments(
-        TcpChannel channel,
-        ArrayList<Object> fragments,
-        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler
-    ) throws IOException {
-        for (Object fragment : fragments) {
-            if (fragment instanceof Header) {
-                assert aggregator.isAggregating() == false;
-                aggregator.headerReceived((Header) fragment);
-            } else if (fragment == InboundDecoder.PING) {
-                assert aggregator.isAggregating() == false;
-                messageHandler.accept(channel, PING_MESSAGE);
-            } else if (fragment == InboundDecoder.END_CONTENT) {
-                assert aggregator.isAggregating();
-                try (InboundMessage aggregated = aggregator.finishAggregation()) {
-                    statsTracker.markMessageReceived();
-                    messageHandler.accept(channel, aggregated);
-                }
-            } else {
-                assert aggregator.isAggregating();
-                assert fragment instanceof ReleasableBytesReference;
-                aggregator.aggregate((ReleasableBytesReference) fragment);
-            }
-        }
-    }
-
-}
diff --git a/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundMessage.java b/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundMessage.java
index 1143f129b6319..47dcb87e5a386 100644
--- a/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundMessage.java
+++ b/server/src/main/java/org/opensearch/transport/nativeprotocol/NativeInboundMessage.java
@@ -32,118 +32,34 @@
 
 package org.opensearch.transport.nativeprotocol;
 
-import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.annotation.DeprecatedApi;
 import org.opensearch.common.bytes.ReleasableBytesReference;
 import org.opensearch.common.lease.Releasable;
-import org.opensearch.common.lease.Releasables;
-import org.opensearch.common.util.io.IOUtils;
-import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.transport.Header;
-import org.opensearch.transport.ProtocolInboundMessage;
-
-import java.io.IOException;
+import org.opensearch.transport.InboundMessage;
 
 /**
  * Inbound data as a message
  *
- * @opensearch.api
+ * This class is deprecated in favor of {@link InboundMessage}.
  */
-@PublicApi(since = "2.14.0")
-public class NativeInboundMessage implements Releasable, ProtocolInboundMessage {
+@DeprecatedApi(since = "2.17.0")
+public class NativeInboundMessage extends InboundMessage {
 
     /**
      * The protocol used to encode this message
      */
     public static String NATIVE_PROTOCOL = "native";
 
-    private final Header header;
-    private final ReleasableBytesReference content;
-    private final Exception exception;
-    private final boolean isPing;
-    private Releasable breakerRelease;
-    private StreamInput streamInput;
-
     public NativeInboundMessage(Header header, ReleasableBytesReference content, Releasable breakerRelease) {
-        this.header = header;
-        this.content = content;
-        this.breakerRelease = breakerRelease;
-        this.exception = null;
-        this.isPing = false;
+        super(header, content, breakerRelease);
     }
 
     public NativeInboundMessage(Header header, Exception exception) {
-        this.header = header;
-        this.content = null;
-        this.breakerRelease = null;
-        this.exception = exception;
-        this.isPing = false;
+        super(header, exception);
     }
 
     public NativeInboundMessage(Header header, boolean isPing) {
-        this.header = header;
-        this.content = null;
-        this.breakerRelease = null;
-        this.exception = null;
-        this.isPing = isPing;
-    }
-
-    @Override
-    public String getProtocol() {
-        return NATIVE_PROTOCOL;
-    }
-
-    public Header getHeader() {
-        return header;
-    }
-
-    public int getContentLength() {
-        if (content == null) {
-            return 0;
-        } else {
-            return content.length();
-        }
-    }
-
-    public Exception getException() {
-        return exception;
-    }
-
-    public boolean isPing() {
-        return isPing;
+        super(header, isPing);
     }
-
-    public boolean isShortCircuit() {
-        return exception != null;
-    }
-
-    public Releasable takeBreakerReleaseControl() {
-        final Releasable toReturn = breakerRelease;
-        breakerRelease = null;
-        if (toReturn != null) {
-            return toReturn;
-        } else {
-            return () -> {};
-        }
-    }
-
-    public StreamInput openOrGetStreamInput() throws IOException {
-        assert isPing == false && content != null;
-        if (streamInput == null) {
-            streamInput = content.streamInput();
-            streamInput.setVersion(header.getVersion());
-        }
-        return streamInput;
-    }
-
-    @Override
-    public void close() {
-        IOUtils.closeWhileHandlingException(streamInput);
-        Releasables.closeWhileHandlingException(content, breakerRelease);
-    }
-
-    @Override
-    public String toString() {
-        return "InboundMessage{" + header + "}";
-    }
-
 }
diff --git a/server/src/main/java/org/opensearch/wlm/MutableQueryGroupFragment.java b/server/src/main/java/org/opensearch/wlm/MutableQueryGroupFragment.java
new file mode 100644
index 0000000000000..8ea240132fea2
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/MutableQueryGroupFragment.java
@@ -0,0 +1,225 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.cluster.AbstractDiffable;
+import org.opensearch.common.annotation.ExperimentalApi;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Function;
+
+/**
+ * Class to hold the fields that can be updated in a QueryGroup.
+ */
+@ExperimentalApi
+public class MutableQueryGroupFragment extends AbstractDiffable<MutableQueryGroupFragment> {
+
+    public static final String RESILIENCY_MODE_STRING = "resiliency_mode";
+    public static final String RESOURCE_LIMITS_STRING = "resource_limits";
+    private ResiliencyMode resiliencyMode;
+    private Map<ResourceType, Double> resourceLimits;
+
+    public static final List<String> acceptedFieldNames = List.of(RESILIENCY_MODE_STRING, RESOURCE_LIMITS_STRING);
+
+    public MutableQueryGroupFragment() {}
+
+    public MutableQueryGroupFragment(ResiliencyMode resiliencyMode, Map<ResourceType, Double> resourceLimits) {
+        validateResourceLimits(resourceLimits);
+        this.resiliencyMode = resiliencyMode;
+        this.resourceLimits = resourceLimits;
+    }
+
+    public MutableQueryGroupFragment(StreamInput in) throws IOException {
+        if (in.readBoolean()) {
+            resourceLimits = in.readMap((i) -> ResourceType.fromName(i.readString()), StreamInput::readDouble);
+        } else {
+            resourceLimits = new HashMap<>();
+        }
+        String updatedResiliencyMode = in.readOptionalString();
+        resiliencyMode = updatedResiliencyMode == null ? null : ResiliencyMode.fromName(updatedResiliencyMode);
+    }
+
+    interface FieldParser<T> {
+        T parseField(XContentParser parser) throws IOException;
+    }
+
+    static class ResiliencyModeParser implements FieldParser<ResiliencyMode> {
+        public ResiliencyMode parseField(XContentParser parser) throws IOException {
+            return ResiliencyMode.fromName(parser.text());
+        }
+    }
+
+    static class ResourceLimitsParser implements FieldParser<Map<ResourceType, Double>> {
+        public Map<ResourceType, Double> parseField(XContentParser parser) throws IOException {
+            String fieldName = "";
+            XContentParser.Token token;
+            final Map<ResourceType, Double> resourceLimits = new HashMap<>();
+            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
+                if (token == XContentParser.Token.FIELD_NAME) {
+                    fieldName = parser.currentName();
+                } else {
+                    resourceLimits.put(ResourceType.fromName(fieldName), parser.doubleValue());
+                }
+            }
+            return resourceLimits;
+        }
+    }
+
+    static class FieldParserFactory {
+        static Optional<FieldParser<?>> fieldParserFor(String fieldName) {
+            if (fieldName.equals(RESOURCE_LIMITS_STRING)) {
+                return Optional.of(new ResourceLimitsParser());
+            } else if (fieldName.equals(RESILIENCY_MODE_STRING)) {
+                return Optional.of(new ResiliencyModeParser());
+            }
+            return Optional.empty();
+        }
+    }
+
+    private final Map<String, Function<XContentBuilder, Void>> toXContentMap = Map.of(RESILIENCY_MODE_STRING, (builder) -> {
+        try {
+            builder.field(RESILIENCY_MODE_STRING, resiliencyMode.getName());
+            return null;
+        } catch (IOException e) {
+            throw new IllegalStateException("writing error encountered for the field " + RESILIENCY_MODE_STRING);
+        }
+    }, RESOURCE_LIMITS_STRING, (builder) -> {
+        try {
+            builder.startObject(RESOURCE_LIMITS_STRING);
+            for (ResourceType resourceType : ResourceType.values()) {
+                if (resourceLimits.containsKey(resourceType)) {
+                    builder.field(resourceType.getName(), resourceLimits.get(resourceType));
+                }
+            }
+            builder.endObject();
+            return null;
+        } catch (IOException e) {
+            throw new IllegalStateException("writing error encountered for the field " + RESOURCE_LIMITS_STRING);
+        }
+    });
+
+    public static boolean shouldParse(String field) {
+        return FieldParserFactory.fieldParserFor(field).isPresent();
+    }
+
+    public void parseField(XContentParser parser, String field) {
+        FieldParserFactory.fieldParserFor(field).ifPresent(fieldParser -> {
+            try {
+                Object value = fieldParser.parseField(parser);
+                if (field.equals(RESILIENCY_MODE_STRING)) {
+                    setResiliencyMode((ResiliencyMode) value);
+                } else if (field.equals(RESOURCE_LIMITS_STRING)) {
+                    setResourceLimits((Map<ResourceType, Double>) value);
+                }
+            } catch (IOException e) {
+                throw new IllegalArgumentException("parsing error encountered for the field " + field);
+            }
+        });
+    }
+
+    public void writeField(XContentBuilder builder, String field) {
+        toXContentMap.get(field).apply(builder);
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        if (resourceLimits == null || resourceLimits.isEmpty()) {
+            out.writeBoolean(false);
+        } else {
+            out.writeBoolean(true);
+            out.writeMap(resourceLimits, ResourceType::writeTo, StreamOutput::writeDouble);
+        }
+        out.writeOptionalString(resiliencyMode == null ? null : resiliencyMode.getName());
+    }
+
+    public static void validateResourceLimits(Map<ResourceType, Double> resourceLimits) {
+        if (resourceLimits == null) {
+            return;
+        }
+        for (Map.Entry<ResourceType, Double> resource : resourceLimits.entrySet()) {
+            Double threshold = resource.getValue();
+            Objects.requireNonNull(resource.getKey(), "resourceName can't be null");
+            Objects.requireNonNull(threshold, "resource limit threshold for" + resource.getKey().getName() + " : can't be null");
+
+            if (Double.compare(threshold, 0.0) <= 0 || Double.compare(threshold, 1.0) > 0) {
+                throw new IllegalArgumentException("resource value should be greater than 0 and less or equal to 1.0");
+            }
+        }
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        MutableQueryGroupFragment that = (MutableQueryGroupFragment) o;
+        return Objects.equals(resiliencyMode, that.resiliencyMode) && Objects.equals(resourceLimits, that.resourceLimits);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(resiliencyMode, resourceLimits);
+    }
+
+    public ResiliencyMode getResiliencyMode() {
+        return resiliencyMode;
+    }
+
+    public Map<ResourceType, Double> getResourceLimits() {
+        return resourceLimits;
+    }
+
+    /**
+     * This enum models the different QueryGroup resiliency modes
+     * SOFT - means that this query group can consume more than query group resource limits if node is not in duress
+     * ENFORCED - means that it will never breach the assigned limits and will cancel as soon as the limits are breached
+     * MONITOR - it will not cause any cancellation but just log the eligible task cancellations
+     */
+    @ExperimentalApi
+    public enum ResiliencyMode {
+        SOFT("soft"),
+        ENFORCED("enforced"),
+        MONITOR("monitor");
+
+        private final String name;
+
+        ResiliencyMode(String mode) {
+            this.name = mode;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public static ResiliencyMode fromName(String s) {
+            for (ResiliencyMode mode : values()) {
+                if (mode.getName().equalsIgnoreCase(s)) return mode;
+
+            }
+            throw new IllegalArgumentException("Invalid value for QueryGroupMode: " + s);
+        }
+    }
+
+    public void setResiliencyMode(ResiliencyMode resiliencyMode) {
+        this.resiliencyMode = resiliencyMode;
+    }
+
+    public void setResourceLimits(Map<ResourceType, Double> resourceLimits) {
+        validateResourceLimits(resourceLimits);
+        this.resourceLimits = resourceLimits;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/QueryGroupLevelResourceUsageView.java b/server/src/main/java/org/opensearch/wlm/QueryGroupLevelResourceUsageView.java
new file mode 100644
index 0000000000000..7577c8573ec10
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/QueryGroupLevelResourceUsageView.java
@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.tasks.Task;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Represents the point in time view of resource usage of a QueryGroup and
+ * has a 1:1 relation with a QueryGroup.
+ * This class holds the resource usage data and the list of active tasks.
+ */
+public class QueryGroupLevelResourceUsageView {
+    // resourceUsage holds the resource usage data for a QueryGroup at a point in time
+    private final Map<ResourceType, Long> resourceUsage;
+    // activeTasks holds the list of active tasks for a QueryGroup at a point in time
+    private final List<Task> activeTasks;
+
+    public QueryGroupLevelResourceUsageView(Map<ResourceType, Long> resourceUsage, List<Task> activeTasks) {
+        this.resourceUsage = resourceUsage;
+        this.activeTasks = activeTasks;
+    }
+
+    /**
+     * Returns the resource usage data.
+     *
+     * @return The map of resource usage data
+     */
+    public Map<ResourceType, Long> getResourceUsageData() {
+        return resourceUsage;
+    }
+
+    /**
+     * Returns the list of active tasks.
+     *
+     * @return The list of active tasks
+     */
+    public List<Task> getActiveTasks() {
+        return activeTasks;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/QueryGroupService.java b/server/src/main/java/org/opensearch/wlm/QueryGroupService.java
new file mode 100644
index 0000000000000..6545598dd9951
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/QueryGroupService.java
@@ -0,0 +1,80 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+import org.opensearch.wlm.stats.QueryGroupState;
+import org.opensearch.wlm.stats.QueryGroupStats;
+import org.opensearch.wlm.stats.QueryGroupStats.QueryGroupStatsHolder;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * As of now this is a stub and main implementation PR will be raised soon.Coming PR will collate these changes with core QueryGroupService changes
+ */
+public class QueryGroupService {
+    // This map does not need to be concurrent since we will process the cluster state change serially and update
+    // this map with new additions and deletions of entries. QueryGroupState is thread safe
+    private final Map<String, QueryGroupState> queryGroupStateMap;
+
+    public QueryGroupService() {
+        this(new HashMap<>());
+    }
+
+    public QueryGroupService(Map<String, QueryGroupState> queryGroupStateMap) {
+        this.queryGroupStateMap = queryGroupStateMap;
+    }
+
+    /**
+     * updates the failure stats for the query group
+     * @param queryGroupId query group identifier
+     */
+    public void incrementFailuresFor(final String queryGroupId) {
+        QueryGroupState queryGroupState = queryGroupStateMap.get(queryGroupId);
+        // This can happen if the request failed for a deleted query group
+        // or new queryGroup is being created and has not been acknowledged yet
+        if (queryGroupState == null) {
+            return;
+        }
+        queryGroupState.failures.inc();
+    }
+
+    /**
+     *
+     * @return node level query group stats
+     */
+    public QueryGroupStats nodeStats() {
+        final Map<String, QueryGroupStatsHolder> statsHolderMap = new HashMap<>();
+        for (Map.Entry<String, QueryGroupState> queryGroupsState : queryGroupStateMap.entrySet()) {
+            final String queryGroupId = queryGroupsState.getKey();
+            final QueryGroupState currentState = queryGroupsState.getValue();
+
+            statsHolderMap.put(queryGroupId, QueryGroupStatsHolder.from(currentState));
+        }
+
+        return new QueryGroupStats(statsHolderMap);
+    }
+
+    /**
+     *
+     * @param queryGroupId query group identifier
+     */
+    public void rejectIfNeeded(String queryGroupId) {
+        if (queryGroupId == null) return;
+        boolean reject = false;
+        final StringBuilder reason = new StringBuilder();
+        // TODO: At this point this is dummy and we need to decide whether to cancel the request based on last
+        // reported resource usage for the queryGroup. We also need to increment the rejection count here for the
+        // query group
+        if (reject) {
+            throw new OpenSearchRejectedExecutionException("QueryGroup " + queryGroupId + " is already contended." + reason.toString());
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/QueryGroupTask.java b/server/src/main/java/org/opensearch/wlm/QueryGroupTask.java
new file mode 100644
index 0000000000000..4eb413be61b72
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/QueryGroupTask.java
@@ -0,0 +1,76 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.tasks.TaskId;
+import org.opensearch.tasks.CancellableTask;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+import static org.opensearch.search.SearchService.NO_TIMEOUT;
+
+/**
+ * Base class to define QueryGroup tasks
+ */
+public class QueryGroupTask extends CancellableTask {
+
+    private static final Logger logger = LogManager.getLogger(QueryGroupTask.class);
+    public static final String QUERY_GROUP_ID_HEADER = "queryGroupId";
+    public static final Supplier<String> DEFAULT_QUERY_GROUP_ID_SUPPLIER = () -> "DEFAULT_QUERY_GROUP";
+    private String queryGroupId;
+
+    public QueryGroupTask(long id, String type, String action, String description, TaskId parentTaskId, Map<String, String> headers) {
+        this(id, type, action, description, parentTaskId, headers, NO_TIMEOUT);
+    }
+
+    public QueryGroupTask(
+        long id,
+        String type,
+        String action,
+        String description,
+        TaskId parentTaskId,
+        Map<String, String> headers,
+        TimeValue cancelAfterTimeInterval
+    ) {
+        super(id, type, action, description, parentTaskId, headers, cancelAfterTimeInterval);
+    }
+
+    /**
+     * This method should always be called after calling setQueryGroupId at least once on this object
+     * @return task queryGroupId
+     */
+    public final String getQueryGroupId() {
+        if (queryGroupId == null) {
+            logger.warn("QueryGroup _id can't be null, It should be set before accessing it. This is abnormal behaviour ");
+        }
+        return queryGroupId;
+    }
+
+    /**
+     * sets the queryGroupId from threadContext into the task itself,
+     * This method was defined since the queryGroupId can only be evaluated after task creation
+     * @param threadContext current threadContext
+     */
+    public final void setQueryGroupId(final ThreadContext threadContext) {
+        this.queryGroupId = Optional.ofNullable(threadContext)
+            .map(threadContext1 -> threadContext1.getHeader(QUERY_GROUP_ID_HEADER))
+            .orElse(DEFAULT_QUERY_GROUP_ID_SUPPLIER.get());
+    }
+
+    @Override
+    public boolean shouldCancelChildrenOnCancellation() {
+        return false;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/QueryGroupThreadContextStatePropagator.java b/server/src/main/java/org/opensearch/wlm/QueryGroupThreadContextStatePropagator.java
new file mode 100644
index 0000000000000..06d223907082e
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/QueryGroupThreadContextStatePropagator.java
@@ -0,0 +1,53 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.common.util.concurrent.ThreadContextStatePropagator;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This class is used to propagate QueryGroup related headers to request and nodes
+ */
+public class QueryGroupThreadContextStatePropagator implements ThreadContextStatePropagator {
+    // TODO: move this constant to QueryGroupService class once the QueryGroup monitoring framework PR is ready
+    public static List<String> PROPAGATED_HEADERS = List.of("queryGroupId");
+
+    /**
+     * @param source current context transient headers
+     * @return the map of header and their values to be propagated across request threadContexts
+     */
+    @Override
+    @SuppressWarnings("removal")
+    public Map<String, Object> transients(Map<String, Object> source) {
+        final Map<String, Object> transientHeaders = new HashMap<>();
+
+        for (String headerName : PROPAGATED_HEADERS) {
+            transientHeaders.compute(headerName, (k, v) -> source.get(headerName));
+        }
+        return transientHeaders;
+    }
+
+    /**
+     * @param source current context headers
+     * @return map of header and their values to be propagated across nodes
+     */
+    @Override
+    @SuppressWarnings("removal")
+    public Map<String, String> headers(Map<String, Object> source) {
+        final Map<String, String> propagatedHeaders = new HashMap<>();
+
+        for (String headerName : PROPAGATED_HEADERS) {
+            propagatedHeaders.compute(headerName, (k, v) -> (String) source.get(headerName));
+        }
+        return propagatedHeaders;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/ResourceType.java b/server/src/main/java/org/opensearch/wlm/ResourceType.java
new file mode 100644
index 0000000000000..b2485988c6ef6
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/ResourceType.java
@@ -0,0 +1,82 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.tasks.resourcetracker.ResourceStats;
+import org.opensearch.tasks.Task;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.function.Function;
+
+/**
+ * Enum to hold the resource type
+ *
+ * @opensearch.api
+ *
+ */
+@PublicApi(since = "2.17.0")
+public enum ResourceType {
+    CPU("cpu", task -> task.getTotalResourceUtilization(ResourceStats.CPU), true),
+    MEMORY("memory", task -> task.getTotalResourceUtilization(ResourceStats.MEMORY), true);
+
+    private final String name;
+    private final Function<Task, Long> getResourceUsage;
+    private final boolean statsEnabled;
+
+    private static List<ResourceType> sortedValues = List.of(CPU, MEMORY);
+
+    ResourceType(String name, Function<Task, Long> getResourceUsage, boolean statsEnabled) {
+        this.name = name;
+        this.getResourceUsage = getResourceUsage;
+        this.statsEnabled = statsEnabled;
+    }
+
+    /**
+     * The string match here is case-sensitive
+     * @param s name matching the resource type name
+     * @return a {@link ResourceType}
+     */
+    public static ResourceType fromName(String s) {
+        for (ResourceType resourceType : values()) {
+            if (resourceType.getName().equals(s)) {
+                return resourceType;
+            }
+        }
+        throw new IllegalArgumentException("Unknown resource type: [" + s + "]");
+    }
+
+    public static void writeTo(StreamOutput out, ResourceType resourceType) throws IOException {
+        out.writeString(resourceType.getName());
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Gets the resource usage for a given resource type and task.
+     *
+     * @param task the task for which to calculate resource usage
+     * @return the resource usage
+     */
+    public long getResourceUsage(Task task) {
+        return getResourceUsage.apply(task);
+    }
+
+    public boolean hasStatsEnabled() {
+        return statsEnabled;
+    }
+
+    public static List<ResourceType> getSortedValues() {
+        return sortedValues;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/WorkloadManagementSettings.java b/server/src/main/java/org/opensearch/wlm/WorkloadManagementSettings.java
new file mode 100644
index 0000000000000..b104925df77b3
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/WorkloadManagementSettings.java
@@ -0,0 +1,256 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+
+/**
+ * Main class to declare Workload Management related settings
+ */
+public class WorkloadManagementSettings {
+    private static final Double DEFAULT_NODE_LEVEL_MEMORY_REJECTION_THRESHOLD = 0.8;
+    private static final Double DEFAULT_NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD = 0.9;
+    private static final Double DEFAULT_NODE_LEVEL_CPU_REJECTION_THRESHOLD = 0.8;
+    private static final Double DEFAULT_NODE_LEVEL_CPU_CANCELLATION_THRESHOLD = 0.9;
+    public static final double NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD_MAX_VALUE = 0.95;
+    public static final double NODE_LEVEL_MEMORY_REJECTION_THRESHOLD_MAX_VALUE = 0.9;
+    public static final double NODE_LEVEL_CPU_CANCELLATION_THRESHOLD_MAX_VALUE = 0.95;
+    public static final double NODE_LEVEL_CPU_REJECTION_THRESHOLD_MAX_VALUE = 0.9;
+
+    private Double nodeLevelMemoryCancellationThreshold;
+    private Double nodeLevelMemoryRejectionThreshold;
+    private Double nodeLevelCpuCancellationThreshold;
+    private Double nodeLevelCpuRejectionThreshold;
+
+    /**
+     * Setting name for node level memory based rejection threshold for QueryGroup service
+     */
+    public static final String NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME = "wlm.query_group.node.memory_rejection_threshold";
+    /**
+     * Setting to control the memory based rejection threshold
+     */
+    public static final Setting<Double> NODE_LEVEL_MEMORY_REJECTION_THRESHOLD = Setting.doubleSetting(
+        NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME,
+        DEFAULT_NODE_LEVEL_MEMORY_REJECTION_THRESHOLD,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+    /**
+     * Setting name for node level cpu based rejection threshold for QueryGroup service
+     */
+    public static final String NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME = "wlm.query_group.node.cpu_rejection_threshold";
+    /**
+     * Setting to control the cpu based rejection threshold
+     */
+    public static final Setting<Double> NODE_LEVEL_CPU_REJECTION_THRESHOLD = Setting.doubleSetting(
+        NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME,
+        DEFAULT_NODE_LEVEL_CPU_REJECTION_THRESHOLD,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+    /**
+     * Setting name for node level memory based cancellation threshold for QueryGroup service
+     */
+    public static final String NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME = "wlm.query_group.node.memory_cancellation_threshold";
+    /**
+     * Setting to control the memory based cancellation threshold
+     */
+    public static final Setting<Double> NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD = Setting.doubleSetting(
+        NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME,
+        DEFAULT_NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+    /**
+     * Setting name for node level cpu based cancellation threshold for QueryGroup service
+     */
+    public static final String NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME = "wlm.query_group.node.cpu_cancellation_threshold";
+    /**
+     * Setting to control the cpu based cancellation threshold
+     */
+    public static final Setting<Double> NODE_LEVEL_CPU_CANCELLATION_THRESHOLD = Setting.doubleSetting(
+        NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME,
+        DEFAULT_NODE_LEVEL_CPU_CANCELLATION_THRESHOLD,
+        Setting.Property.Dynamic,
+        Setting.Property.NodeScope
+    );
+
+    /**
+     * QueryGroup service settings constructor
+     * @param settings - QueryGroup service settings
+     * @param clusterSettings - QueryGroup cluster settings
+     */
+    public WorkloadManagementSettings(Settings settings, ClusterSettings clusterSettings) {
+        nodeLevelMemoryCancellationThreshold = NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD.get(settings);
+        nodeLevelMemoryRejectionThreshold = NODE_LEVEL_MEMORY_REJECTION_THRESHOLD.get(settings);
+        nodeLevelCpuCancellationThreshold = NODE_LEVEL_CPU_CANCELLATION_THRESHOLD.get(settings);
+        nodeLevelCpuRejectionThreshold = NODE_LEVEL_CPU_REJECTION_THRESHOLD.get(settings);
+
+        ensureRejectionThresholdIsLessThanCancellation(
+            nodeLevelMemoryRejectionThreshold,
+            nodeLevelMemoryCancellationThreshold,
+            NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME,
+            NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME
+        );
+        ensureRejectionThresholdIsLessThanCancellation(
+            nodeLevelCpuRejectionThreshold,
+            nodeLevelCpuCancellationThreshold,
+            NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME,
+            NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME
+        );
+
+        clusterSettings.addSettingsUpdateConsumer(NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD, this::setNodeLevelMemoryCancellationThreshold);
+        clusterSettings.addSettingsUpdateConsumer(NODE_LEVEL_MEMORY_REJECTION_THRESHOLD, this::setNodeLevelMemoryRejectionThreshold);
+        clusterSettings.addSettingsUpdateConsumer(NODE_LEVEL_CPU_CANCELLATION_THRESHOLD, this::setNodeLevelCpuCancellationThreshold);
+        clusterSettings.addSettingsUpdateConsumer(NODE_LEVEL_CPU_REJECTION_THRESHOLD, this::setNodeLevelCpuRejectionThreshold);
+    }
+
+    /**
+     * Method to get the node level memory based cancellation threshold
+     * @return current node level memory based cancellation threshold
+     */
+    public Double getNodeLevelMemoryCancellationThreshold() {
+        return nodeLevelMemoryCancellationThreshold;
+    }
+
+    /**
+     * Method to set the node level memory based cancellation threshold
+     * @param nodeLevelMemoryCancellationThreshold sets the new node level memory based cancellation threshold
+     * @throws IllegalArgumentException if the value is &gt; 0.95 and cancellation &lt; rejection threshold
+     */
+    public void setNodeLevelMemoryCancellationThreshold(Double nodeLevelMemoryCancellationThreshold) {
+        if (Double.compare(nodeLevelMemoryCancellationThreshold, NODE_LEVEL_MEMORY_CANCELLATION_THRESHOLD_MAX_VALUE) > 0) {
+            throw new IllegalArgumentException(
+                NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME + " value cannot be greater than 0.95 as it can result in a node drop"
+            );
+        }
+
+        ensureRejectionThresholdIsLessThanCancellation(
+            nodeLevelMemoryRejectionThreshold,
+            nodeLevelMemoryCancellationThreshold,
+            NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME,
+            NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME
+        );
+
+        this.nodeLevelMemoryCancellationThreshold = nodeLevelMemoryCancellationThreshold;
+    }
+
+    /**
+     * Method to get the node level cpu based cancellation threshold
+     * @return current node level cpu based cancellation threshold
+     */
+    public Double getNodeLevelCpuCancellationThreshold() {
+        return nodeLevelCpuCancellationThreshold;
+    }
+
+    /**
+     * Method to set the node level cpu based cancellation threshold
+     * @param nodeLevelCpuCancellationThreshold sets the new node level cpu based cancellation threshold
+     * @throws IllegalArgumentException if the value is &gt; 0.95 and cancellation &lt; rejection threshold
+     */
+    public void setNodeLevelCpuCancellationThreshold(Double nodeLevelCpuCancellationThreshold) {
+        if (Double.compare(nodeLevelCpuCancellationThreshold, NODE_LEVEL_CPU_CANCELLATION_THRESHOLD_MAX_VALUE) > 0) {
+            throw new IllegalArgumentException(
+                NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME + " value cannot be greater than 0.95 as it can result in a node drop"
+            );
+        }
+
+        ensureRejectionThresholdIsLessThanCancellation(
+            nodeLevelCpuRejectionThreshold,
+            nodeLevelCpuCancellationThreshold,
+            NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME,
+            NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME
+        );
+
+        this.nodeLevelCpuCancellationThreshold = nodeLevelCpuCancellationThreshold;
+    }
+
+    /**
+     * Method to get the memory based node level rejection threshold
+     * @return the current memory based node level rejection threshold
+     */
+    public Double getNodeLevelMemoryRejectionThreshold() {
+        return nodeLevelMemoryRejectionThreshold;
+    }
+
+    /**
+     * Method to set the node level memory based rejection threshold
+     * @param nodeLevelMemoryRejectionThreshold sets the new memory based rejection threshold
+     * @throws IllegalArgumentException if rejection &gt; 0.90 and rejection &lt; cancellation threshold
+     */
+    public void setNodeLevelMemoryRejectionThreshold(Double nodeLevelMemoryRejectionThreshold) {
+        if (Double.compare(nodeLevelMemoryRejectionThreshold, NODE_LEVEL_MEMORY_REJECTION_THRESHOLD_MAX_VALUE) > 0) {
+            throw new IllegalArgumentException(
+                NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME + " value cannot be greater than 0.90 as it can result in a node drop"
+            );
+        }
+
+        ensureRejectionThresholdIsLessThanCancellation(
+            nodeLevelMemoryRejectionThreshold,
+            nodeLevelMemoryCancellationThreshold,
+            NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME,
+            NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME
+        );
+
+        this.nodeLevelMemoryRejectionThreshold = nodeLevelMemoryRejectionThreshold;
+    }
+
+    /**
+     * Method to get the cpu based node level rejection threshold
+     * @return the current cpu based node level rejection threshold
+     */
+    public Double getNodeLevelCpuRejectionThreshold() {
+        return nodeLevelCpuRejectionThreshold;
+    }
+
+    /**
+     * Method to set the node level cpu based rejection threshold
+     * @param nodeLevelCpuRejectionThreshold sets the new cpu based rejection threshold
+     * @throws IllegalArgumentException if rejection &gt; 0.90 and rejection &lt; cancellation threshold
+     */
+    public void setNodeLevelCpuRejectionThreshold(Double nodeLevelCpuRejectionThreshold) {
+        if (Double.compare(nodeLevelCpuRejectionThreshold, NODE_LEVEL_CPU_REJECTION_THRESHOLD_MAX_VALUE) > 0) {
+            throw new IllegalArgumentException(
+                NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME + " value cannot be greater than 0.90 as it can result in a node drop"
+            );
+        }
+
+        ensureRejectionThresholdIsLessThanCancellation(
+            nodeLevelCpuRejectionThreshold,
+            nodeLevelCpuCancellationThreshold,
+            NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME,
+            NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME
+        );
+
+        this.nodeLevelCpuRejectionThreshold = nodeLevelCpuRejectionThreshold;
+    }
+
+    /**
+     * Method to validate that the cancellation threshold is greater than or equal to rejection threshold
+     * @param nodeLevelRejectionThreshold rejection threshold to be compared
+     * @param nodeLevelCancellationThreshold cancellation threshold to be compared
+     * @param rejectionThresholdSettingName name of the rejection threshold setting
+     * @param cancellationThresholdSettingName name of the cancellation threshold setting
+     * @throws IllegalArgumentException if cancellation threshold is less than rejection threshold
+     */
+    private void ensureRejectionThresholdIsLessThanCancellation(
+        Double nodeLevelRejectionThreshold,
+        Double nodeLevelCancellationThreshold,
+        String rejectionThresholdSettingName,
+        String cancellationThresholdSettingName
+    ) {
+        if (Double.compare(nodeLevelCancellationThreshold, nodeLevelRejectionThreshold) < 0) {
+            throw new IllegalArgumentException(
+                cancellationThresholdSettingName + " value should not be less than " + rejectionThresholdSettingName
+            );
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/WorkloadManagementTransportInterceptor.java b/server/src/main/java/org/opensearch/wlm/WorkloadManagementTransportInterceptor.java
new file mode 100644
index 0000000000000..d382b4c729a38
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/WorkloadManagementTransportInterceptor.java
@@ -0,0 +1,70 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.tasks.Task;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportChannel;
+import org.opensearch.transport.TransportInterceptor;
+import org.opensearch.transport.TransportRequest;
+import org.opensearch.transport.TransportRequestHandler;
+
+/**
+ * This class is used to intercept search traffic requests and populate the queryGroupId header in task headers
+ */
+public class WorkloadManagementTransportInterceptor implements TransportInterceptor {
+    private final ThreadPool threadPool;
+    private final QueryGroupService queryGroupService;
+
+    public WorkloadManagementTransportInterceptor(final ThreadPool threadPool, final QueryGroupService queryGroupService) {
+        this.threadPool = threadPool;
+        this.queryGroupService = queryGroupService;
+    }
+
+    @Override
+    public <T extends TransportRequest> TransportRequestHandler<T> interceptHandler(
+        String action,
+        String executor,
+        boolean forceExecution,
+        TransportRequestHandler<T> actualHandler
+    ) {
+        return new RequestHandler<T>(threadPool, actualHandler, queryGroupService);
+    }
+
+    /**
+     * This class is mainly used to populate the queryGroupId header
+     * @param <T> T is Search related request
+     */
+    public static class RequestHandler<T extends TransportRequest> implements TransportRequestHandler<T> {
+
+        private final ThreadPool threadPool;
+        TransportRequestHandler<T> actualHandler;
+        private final QueryGroupService queryGroupService;
+
+        public RequestHandler(ThreadPool threadPool, TransportRequestHandler<T> actualHandler, QueryGroupService queryGroupService) {
+            this.threadPool = threadPool;
+            this.actualHandler = actualHandler;
+            this.queryGroupService = queryGroupService;
+        }
+
+        @Override
+        public void messageReceived(T request, TransportChannel channel, Task task) throws Exception {
+            if (isSearchWorkloadRequest(task)) {
+                ((QueryGroupTask) task).setQueryGroupId(threadPool.getThreadContext());
+                final String queryGroupId = ((QueryGroupTask) (task)).getQueryGroupId();
+                queryGroupService.rejectIfNeeded(queryGroupId);
+            }
+            actualHandler.messageReceived(request, channel, task);
+        }
+
+        boolean isSearchWorkloadRequest(Task task) {
+            return task instanceof QueryGroupTask;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/listeners/QueryGroupRequestOperationListener.java b/server/src/main/java/org/opensearch/wlm/listeners/QueryGroupRequestOperationListener.java
new file mode 100644
index 0000000000000..a2ce2b57bfe0f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/listeners/QueryGroupRequestOperationListener.java
@@ -0,0 +1,46 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm.listeners;
+
+import org.opensearch.action.search.SearchPhaseContext;
+import org.opensearch.action.search.SearchRequestContext;
+import org.opensearch.action.search.SearchRequestOperationsListener;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.wlm.QueryGroupService;
+import org.opensearch.wlm.QueryGroupTask;
+
+/**
+ * This listener is used to listen for request lifecycle events for a queryGroup
+ */
+public class QueryGroupRequestOperationListener extends SearchRequestOperationsListener {
+
+    private final QueryGroupService queryGroupService;
+    private final ThreadPool threadPool;
+
+    public QueryGroupRequestOperationListener(QueryGroupService queryGroupService, ThreadPool threadPool) {
+        this.queryGroupService = queryGroupService;
+        this.threadPool = threadPool;
+    }
+
+    /**
+     * This method assumes that the queryGroupId is already populated in the thread context
+     * @param searchRequestContext SearchRequestContext instance
+     */
+    @Override
+    protected void onRequestStart(SearchRequestContext searchRequestContext) {
+        final String queryGroupId = threadPool.getThreadContext().getHeader(QueryGroupTask.QUERY_GROUP_ID_HEADER);
+        queryGroupService.rejectIfNeeded(queryGroupId);
+    }
+
+    @Override
+    protected void onRequestFailure(SearchPhaseContext context, SearchRequestContext searchRequestContext) {
+        final String queryGroupId = threadPool.getThreadContext().getHeader(QueryGroupTask.QUERY_GROUP_ID_HEADER);
+        queryGroupService.incrementFailuresFor(queryGroupId);
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/listeners/package-info.java b/server/src/main/java/org/opensearch/wlm/listeners/package-info.java
new file mode 100644
index 0000000000000..e900acf657085
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/listeners/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * WLM related listener constructs
+ */
+package org.opensearch.wlm.listeners;
diff --git a/server/src/main/java/org/opensearch/wlm/package-info.java b/server/src/main/java/org/opensearch/wlm/package-info.java
new file mode 100644
index 0000000000000..fa4731d95cc34
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/package-info.java
@@ -0,0 +1,13 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * This package contains workload management constructs
+ */
+
+package org.opensearch.wlm;
diff --git a/server/src/main/java/org/opensearch/wlm/stats/QueryGroupState.java b/server/src/main/java/org/opensearch/wlm/stats/QueryGroupState.java
new file mode 100644
index 0000000000000..376d34dd7c8ca
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/stats/QueryGroupState.java
@@ -0,0 +1,112 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm.stats;
+
+import org.opensearch.common.metrics.CounterMetric;
+import org.opensearch.wlm.ResourceType;
+
+import java.util.EnumMap;
+import java.util.Map;
+
+/**
+ * This class will keep the point in time view of the query group stats
+ */
+public class QueryGroupState {
+    /**
+     * completions at the query group level, this is a cumulative counter since the Opensearch start time
+     */
+    final CounterMetric completions = new CounterMetric();
+
+    /**
+     * rejections at the query group level, this is a cumulative counter since the OpenSearch start time
+     */
+    final CounterMetric totalRejections = new CounterMetric();
+
+    /**
+     * this will track the cumulative failures in a query group
+     */
+    public final CounterMetric failures = new CounterMetric();
+
+    /**
+     * This will track total number of cancellations in the query group due to all resource type breaches
+     */
+    final CounterMetric totalCancellations = new CounterMetric();
+
+    /**
+     * This is used to store the resource type state both for CPU and MEMORY
+     */
+    private final Map<ResourceType, ResourceTypeState> resourceState;
+
+    public QueryGroupState() {
+        resourceState = new EnumMap<>(ResourceType.class);
+        for (ResourceType resourceType : ResourceType.values()) {
+            if (resourceType.hasStatsEnabled()) {
+                resourceState.put(resourceType, new ResourceTypeState(resourceType));
+            }
+        }
+    }
+
+    /**
+     *
+     * @return completions in the query group
+     */
+    public long getCompletions() {
+        return completions.count();
+    }
+
+    /**
+     *
+     * @return rejections in the query group
+     */
+    public long getTotalRejections() {
+        return totalRejections.count();
+    }
+
+    /**
+     *
+     * @return failures in the query group
+     */
+    public long getFailures() {
+        return failures.count();
+    }
+
+    public long getTotalCancellations() {
+        return totalCancellations.count();
+    }
+
+    /**
+     * getter for query group resource state
+     * @return the query group resource state
+     */
+    public Map<ResourceType, ResourceTypeState> getResourceState() {
+        return resourceState;
+    }
+
+    /**
+     * This class holds the resource level stats for the query group
+     */
+    public static class ResourceTypeState {
+        final ResourceType resourceType;
+        final CounterMetric cancellations = new CounterMetric();
+        final CounterMetric rejections = new CounterMetric();
+        private double lastRecordedUsage = 0;
+
+        public ResourceTypeState(ResourceType resourceType) {
+            this.resourceType = resourceType;
+        }
+
+        public void setLastRecordedUsage(double recordedUsage) {
+            lastRecordedUsage = recordedUsage;
+        }
+
+        public double getLastRecordedUsage() {
+            return lastRecordedUsage;
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/stats/QueryGroupStats.java b/server/src/main/java/org/opensearch/wlm/stats/QueryGroupStats.java
new file mode 100644
index 0000000000000..2b389c2167778
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/stats/QueryGroupStats.java
@@ -0,0 +1,275 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm.stats;
+
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContentObject;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.wlm.ResourceType;
+import org.opensearch.wlm.stats.QueryGroupState.ResourceTypeState;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * {
+ *     "queryGroupID": {
+ *          "completions": 1233234234,
+ *          "rejections": 12,
+ *          "failures": 97,
+ *          "total_cancellations": 474,
+ *          "CPU": { "current_usage": 49.6, "cancellation": 432, "rejections": 8 },
+ *          "MEMORY": { "current_usage": 39.6, "cancellation": 42, "rejections": 4 }
+ *     },
+ *     ...
+ *     ...
+ * }
+ */
+public class QueryGroupStats implements ToXContentObject, Writeable {
+    private final Map<String, QueryGroupStatsHolder> stats;
+
+    public QueryGroupStats(Map<String, QueryGroupStatsHolder> stats) {
+        this.stats = stats;
+    }
+
+    public QueryGroupStats(StreamInput in) throws IOException {
+        stats = in.readMap(StreamInput::readString, QueryGroupStatsHolder::new);
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeMap(stats, StreamOutput::writeString, QueryGroupStatsHolder::writeTo);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject("query_groups");
+        // to keep the toXContent consistent
+        List<Map.Entry<String, QueryGroupStatsHolder>> entryList = new ArrayList<>(stats.entrySet());
+        entryList.sort((k1, k2) -> k1.getKey().compareTo(k2.getKey()));
+
+        for (Map.Entry<String, QueryGroupStatsHolder> queryGroupStats : entryList) {
+            builder.startObject(queryGroupStats.getKey());
+            queryGroupStats.getValue().toXContent(builder, params);
+            builder.endObject();
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        QueryGroupStats that = (QueryGroupStats) o;
+        return Objects.equals(stats, that.stats);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(stats);
+    }
+
+    /**
+     * This is a stats holder object which will hold the data for a query group at a point in time
+     * the instance will only be created on demand through stats api
+     */
+    public static class QueryGroupStatsHolder implements ToXContentObject, Writeable {
+        public static final String COMPLETIONS = "completions";
+        public static final String REJECTIONS = "rejections";
+        public static final String TOTAL_CANCELLATIONS = "total_cancellations";
+        public static final String FAILURES = "failures";
+        private long completions;
+        private long rejections;
+        private long failures;
+        private long totalCancellations;
+        private Map<ResourceType, ResourceStats> resourceStats;
+
+        // this is needed to support the factory method
+        public QueryGroupStatsHolder() {}
+
+        public QueryGroupStatsHolder(
+            long completions,
+            long rejections,
+            long failures,
+            long totalCancellations,
+            Map<ResourceType, ResourceStats> resourceStats
+        ) {
+            this.completions = completions;
+            this.rejections = rejections;
+            this.failures = failures;
+            this.totalCancellations = totalCancellations;
+            this.resourceStats = resourceStats;
+        }
+
+        public QueryGroupStatsHolder(StreamInput in) throws IOException {
+            this.completions = in.readVLong();
+            this.rejections = in.readVLong();
+            this.failures = in.readVLong();
+            this.totalCancellations = in.readVLong();
+            this.resourceStats = in.readMap((i) -> ResourceType.fromName(i.readString()), ResourceStats::new);
+        }
+
+        /**
+         * static factory method to convert {@link QueryGroupState} into {@link QueryGroupStatsHolder}
+         * @param queryGroupState which needs to be converted
+         * @return QueryGroupStatsHolder object
+         */
+        public static QueryGroupStatsHolder from(QueryGroupState queryGroupState) {
+            final QueryGroupStatsHolder statsHolder = new QueryGroupStatsHolder();
+
+            Map<ResourceType, ResourceStats> resourceStatsMap = new HashMap<>();
+
+            for (Map.Entry<ResourceType, ResourceTypeState> resourceTypeStateEntry : queryGroupState.getResourceState().entrySet()) {
+                resourceStatsMap.put(resourceTypeStateEntry.getKey(), ResourceStats.from(resourceTypeStateEntry.getValue()));
+            }
+
+            statsHolder.completions = queryGroupState.getCompletions();
+            statsHolder.rejections = queryGroupState.getTotalRejections();
+            statsHolder.failures = queryGroupState.getFailures();
+            statsHolder.totalCancellations = queryGroupState.getTotalCancellations();
+            statsHolder.resourceStats = resourceStatsMap;
+            return statsHolder;
+        }
+
+        /**
+         * Writes the @param {statsHolder} to @param {out}
+         * @param out StreamOutput
+         * @param statsHolder QueryGroupStatsHolder
+         * @throws IOException exception
+         */
+        public static void writeTo(StreamOutput out, QueryGroupStatsHolder statsHolder) throws IOException {
+            out.writeVLong(statsHolder.completions);
+            out.writeVLong(statsHolder.rejections);
+            out.writeVLong(statsHolder.failures);
+            out.writeVLong(statsHolder.totalCancellations);
+            out.writeMap(statsHolder.resourceStats, (o, val) -> o.writeString(val.getName()), ResourceStats::writeTo);
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            QueryGroupStatsHolder.writeTo(out, this);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.field(COMPLETIONS, completions);
+            builder.field(REJECTIONS, rejections);
+            builder.field(FAILURES, failures);
+            builder.field(TOTAL_CANCELLATIONS, totalCancellations);
+
+            for (ResourceType resourceType : ResourceType.getSortedValues()) {
+                ResourceStats resourceStats1 = resourceStats.get(resourceType);
+                if (resourceStats1 == null) continue;
+                builder.startObject(resourceType.getName());
+                resourceStats1.toXContent(builder, params);
+                builder.endObject();
+            }
+            return builder;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            QueryGroupStatsHolder that = (QueryGroupStatsHolder) o;
+            return completions == that.completions
+                && rejections == that.rejections
+                && Objects.equals(resourceStats, that.resourceStats)
+                && failures == that.failures
+                && totalCancellations == that.totalCancellations;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(completions, rejections, totalCancellations, failures, resourceStats);
+        }
+    }
+
+    /**
+     * point in time resource level stats holder
+     */
+    public static class ResourceStats implements ToXContentObject, Writeable {
+        public static final String CURRENT_USAGE = "current_usage";
+        public static final String CANCELLATIONS = "cancellations";
+        public static final double PRECISION = 1e-9;
+        private final double currentUsage;
+        private final long cancellations;
+        private final long rejections;
+
+        public ResourceStats(double currentUsage, long cancellations, long rejections) {
+            this.currentUsage = currentUsage;
+            this.cancellations = cancellations;
+            this.rejections = rejections;
+        }
+
+        public ResourceStats(StreamInput in) throws IOException {
+            this.currentUsage = in.readDouble();
+            this.cancellations = in.readVLong();
+            this.rejections = in.readVLong();
+        }
+
+        /**
+         * static factory method to convert {@link ResourceTypeState} into {@link ResourceStats}
+         * @param resourceTypeState which needs to be converted
+         * @return QueryGroupStatsHolder object
+         */
+        public static ResourceStats from(ResourceTypeState resourceTypeState) {
+            return new ResourceStats(
+                resourceTypeState.getLastRecordedUsage(),
+                resourceTypeState.cancellations.count(),
+                resourceTypeState.rejections.count()
+            );
+        }
+
+        /**
+         * Writes the @param {stats} to @param {out}
+         * @param out StreamOutput
+         * @param stats QueryGroupStatsHolder
+         * @throws IOException exception
+         */
+        public static void writeTo(StreamOutput out, ResourceStats stats) throws IOException {
+            out.writeDouble(stats.currentUsage);
+            out.writeVLong(stats.cancellations);
+            out.writeVLong(stats.rejections);
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            ResourceStats.writeTo(out, this);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            builder.field(CURRENT_USAGE, currentUsage);
+            builder.field(CANCELLATIONS, cancellations);
+            builder.field(QueryGroupStatsHolder.REJECTIONS, rejections);
+            return builder;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            ResourceStats that = (ResourceStats) o;
+            return (currentUsage - that.currentUsage) < PRECISION && cancellations == that.cancellations && rejections == that.rejections;
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(currentUsage, cancellations, rejections);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/stats/package-info.java b/server/src/main/java/org/opensearch/wlm/stats/package-info.java
new file mode 100644
index 0000000000000..2facf8d16df22
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/stats/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * Query group stats related artifacts
+ */
+package org.opensearch.wlm.stats;
diff --git a/server/src/main/java/org/opensearch/wlm/tracker/QueryGroupResourceUsageTrackerService.java b/server/src/main/java/org/opensearch/wlm/tracker/QueryGroupResourceUsageTrackerService.java
new file mode 100644
index 0000000000000..15852b5bbe6a8
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/tracker/QueryGroupResourceUsageTrackerService.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm.tracker;
+
+import org.opensearch.tasks.Task;
+import org.opensearch.tasks.TaskResourceTrackingService;
+import org.opensearch.wlm.QueryGroupLevelResourceUsageView;
+import org.opensearch.wlm.QueryGroupTask;
+import org.opensearch.wlm.ResourceType;
+
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * This class tracks resource usage per QueryGroup
+ */
+public class QueryGroupResourceUsageTrackerService {
+
+    public static final EnumSet<ResourceType> TRACKED_RESOURCES = EnumSet.allOf(ResourceType.class);
+    private final TaskResourceTrackingService taskResourceTrackingService;
+
+    /**
+     * QueryGroupResourceTrackerService constructor
+     *
+     * @param taskResourceTrackingService Service that helps track resource usage of tasks running on a node.
+     */
+    public QueryGroupResourceUsageTrackerService(TaskResourceTrackingService taskResourceTrackingService) {
+        this.taskResourceTrackingService = taskResourceTrackingService;
+    }
+
+    /**
+     * Constructs a map of QueryGroupLevelResourceUsageView instances for each QueryGroup.
+     *
+     * @return Map of QueryGroup views
+     */
+    public Map<String, QueryGroupLevelResourceUsageView> constructQueryGroupLevelUsageViews() {
+        final Map<String, List<Task>> tasksByQueryGroup = getTasksGroupedByQueryGroup();
+        final Map<String, QueryGroupLevelResourceUsageView> queryGroupViews = new HashMap<>();
+
+        // Iterate over each QueryGroup entry
+        for (Map.Entry<String, List<Task>> queryGroupEntry : tasksByQueryGroup.entrySet()) {
+            // Compute the QueryGroup usage
+            final EnumMap<ResourceType, Long> queryGroupUsage = new EnumMap<>(ResourceType.class);
+            for (ResourceType resourceType : TRACKED_RESOURCES) {
+                long queryGroupResourceUsage = 0;
+                for (Task task : queryGroupEntry.getValue()) {
+                    queryGroupResourceUsage += resourceType.getResourceUsage(task);
+                }
+                queryGroupUsage.put(resourceType, queryGroupResourceUsage);
+            }
+
+            // Add to the QueryGroup View
+            queryGroupViews.put(
+                queryGroupEntry.getKey(),
+                new QueryGroupLevelResourceUsageView(queryGroupUsage, queryGroupEntry.getValue())
+            );
+        }
+        return queryGroupViews;
+    }
+
+    /**
+     * Groups tasks by their associated QueryGroup.
+     *
+     * @return Map of tasks grouped by QueryGroup
+     */
+    private Map<String, List<Task>> getTasksGroupedByQueryGroup() {
+        return taskResourceTrackingService.getResourceAwareTasks()
+            .values()
+            .stream()
+            .filter(QueryGroupTask.class::isInstance)
+            .map(QueryGroupTask.class::cast)
+            .collect(Collectors.groupingBy(QueryGroupTask::getQueryGroupId, Collectors.mapping(task -> (Task) task, Collectors.toList())));
+    }
+}
diff --git a/server/src/main/java/org/opensearch/wlm/tracker/package-info.java b/server/src/main/java/org/opensearch/wlm/tracker/package-info.java
new file mode 100644
index 0000000000000..86efc99355d3d
--- /dev/null
+++ b/server/src/main/java/org/opensearch/wlm/tracker/package-info.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/**
+ * QueryGroup resource tracking artifacts
+ */
+package org.opensearch.wlm.tracker;
diff --git a/server/src/main/resources/META-INF/services/org.apache.lucene.codecs.Codec b/server/src/main/resources/META-INF/services/org.apache.lucene.codecs.Codec
new file mode 100644
index 0000000000000..f51452c57f975
--- /dev/null
+++ b/server/src/main/resources/META-INF/services/org.apache.lucene.codecs.Codec
@@ -0,0 +1 @@
+org.opensearch.index.codec.composite.composite99.Composite99Codec
diff --git a/server/src/main/resources/org/opensearch/bootstrap/security.policy b/server/src/main/resources/org/opensearch/bootstrap/security.policy
index 55e8db0d9c6a3..22e445f7d9022 100644
--- a/server/src/main/resources/org/opensearch/bootstrap/security.policy
+++ b/server/src/main/resources/org/opensearch/bootstrap/security.policy
@@ -48,6 +48,8 @@ grant codeBase "${codebase.opensearch}" {
   permission java.lang.RuntimePermission "setContextClassLoader";
   // needed for SPI class loading
   permission java.lang.RuntimePermission "accessDeclaredMembers";
+  permission org.opensearch.secure_sm.ThreadContextPermission "markAsSystemContext";
+  permission org.opensearch.secure_sm.ThreadContextPermission "stashWithOrigin";
 };
 
 //// Very special jar permissions:
diff --git a/server/src/main/resources/org/opensearch/bootstrap/test-framework.policy b/server/src/main/resources/org/opensearch/bootstrap/test-framework.policy
index 52205ee498eb3..56f106a7f977b 100644
--- a/server/src/main/resources/org/opensearch/bootstrap/test-framework.policy
+++ b/server/src/main/resources/org/opensearch/bootstrap/test-framework.policy
@@ -147,4 +147,7 @@ grant {
   permission java.lang.RuntimePermission "reflectionFactoryAccess";
   permission java.lang.RuntimePermission "accessClassInPackage.sun.reflect";
   permission java.lang.reflect.ReflectPermission "suppressAccessChecks";
+  permission org.opensearch.secure_sm.ThreadContextPermission "markAsSystemContext";
+  permission org.opensearch.secure_sm.ThreadContextPermission "stashAndMergeHeaders";
+  permission org.opensearch.secure_sm.ThreadContextPermission "stashWithOrigin";
 };
diff --git a/server/src/test/java/org/opensearch/ExceptionSerializationTests.java b/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
index 9ec2bbc4d027f..ba7edd3198436 100644
--- a/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
+++ b/server/src/test/java/org/opensearch/ExceptionSerializationTests.java
@@ -97,6 +97,7 @@
 import org.opensearch.index.shard.PrimaryShardClosedException;
 import org.opensearch.index.shard.ShardNotInPrimaryModeException;
 import org.opensearch.indices.IndexTemplateMissingException;
+import org.opensearch.indices.InvalidIndexContextException;
 import org.opensearch.indices.InvalidIndexTemplateException;
 import org.opensearch.indices.recovery.PeerRecoveryNotFound;
 import org.opensearch.indices.recovery.RecoverFilesRecoveryException;
@@ -116,6 +117,7 @@
 import org.opensearch.snapshots.SnapshotId;
 import org.opensearch.snapshots.SnapshotInProgressException;
 import org.opensearch.snapshots.SnapshotInUseDeletionException;
+import org.opensearch.snapshots.TooManyShardsInSnapshotsStatusException;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.VersionUtils;
 import org.opensearch.transport.ActionNotFoundTransportException;
@@ -896,6 +898,8 @@ public void testIds() {
         ids.put(169, NodeWeighedAwayException.class);
         ids.put(170, SearchPipelineProcessingException.class);
         ids.put(171, CryptoRegistryException.class);
+        ids.put(174, InvalidIndexContextException.class);
+        ids.put(175, TooManyShardsInSnapshotsStatusException.class);
         ids.put(10001, IndexCreateBlockException.class);
 
         Map<Class<? extends OpenSearchException>, Integer> reverse = new HashMap<>();
diff --git a/server/src/test/java/org/opensearch/action/ActionModuleTests.java b/server/src/test/java/org/opensearch/action/ActionModuleTests.java
index 8479f011adf48..6b8951dd43d11 100644
--- a/server/src/test/java/org/opensearch/action/ActionModuleTests.java
+++ b/server/src/test/java/org/opensearch/action/ActionModuleTests.java
@@ -74,6 +74,7 @@
 import static java.util.Collections.singletonList;
 import static org.hamcrest.Matchers.hasEntry;
 import static org.hamcrest.Matchers.startsWith;
+import static org.mockito.Mockito.mock;
 
 public class ActionModuleTests extends OpenSearchTestCase {
     public void testSetupActionsContainsKnownBuiltin() {
@@ -142,8 +143,8 @@ public void testSetupRestHandlerContainsKnownBuiltin() throws IOException {
             null,
             usageService,
             null,
-            new IdentityService(Settings.EMPTY, new ArrayList<>()),
-            new ExtensionsManager(Set.of(), new IdentityService(Settings.EMPTY, List.of()))
+            new IdentityService(Settings.EMPTY, mock(ThreadPool.class), new ArrayList<>()),
+            new ExtensionsManager(Set.of(), new IdentityService(Settings.EMPTY, mock(ThreadPool.class), List.of()))
         );
         actionModule.initRestHandlers(null);
         // At this point the easiest way to confirm that a handler is loaded is to try to register another one on top of it and to fail
diff --git a/server/src/test/java/org/opensearch/action/DynamicActionRegistryTests.java b/server/src/test/java/org/opensearch/action/DynamicActionRegistryTests.java
index 20c2b1f17124c..1e2b29287acb3 100644
--- a/server/src/test/java/org/opensearch/action/DynamicActionRegistryTests.java
+++ b/server/src/test/java/org/opensearch/action/DynamicActionRegistryTests.java
@@ -20,6 +20,7 @@
 import org.opensearch.extensions.action.ExtensionTransportAction;
 import org.opensearch.extensions.rest.RestSendToExtensionAction;
 import org.opensearch.rest.NamedRoute;
+import org.opensearch.rest.RestHandler;
 import org.opensearch.rest.RestRequest;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskManager;
@@ -85,13 +86,17 @@ public void testDynamicActionRegistryWithNamedRoutes() {
         RestSendToExtensionAction action2 = mock(RestSendToExtensionAction.class);
         NamedRoute r1 = new NamedRoute.Builder().method(RestRequest.Method.GET).path("/foo").uniqueName("foo").build();
         NamedRoute r2 = new NamedRoute.Builder().method(RestRequest.Method.PUT).path("/bar").uniqueName("bar").build();
+        RestHandler.Route r3 = new RestHandler.Route(RestRequest.Method.DELETE, "/foo");
 
         DynamicActionRegistry registry = new DynamicActionRegistry();
         registry.registerDynamicRoute(r1, action);
         registry.registerDynamicRoute(r2, action2);
 
         assertTrue(registry.isActionRegistered("foo"));
+        assertEquals(action, registry.get(r1));
         assertTrue(registry.isActionRegistered("bar"));
+        assertEquals(action2, registry.get(r2));
+        assertNull(registry.get(r3));
 
         registry.unregisterDynamicRoute(r2);
 
diff --git a/server/src/test/java/org/opensearch/action/RestStatsActionTests.java b/server/src/test/java/org/opensearch/action/RestStatsActionTests.java
new file mode 100644
index 0000000000000..9b8a0640ee343
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/RestStatsActionTests.java
@@ -0,0 +1,59 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action;
+
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsFilter;
+import org.opensearch.rest.action.admin.cluster.RestClusterStatsAction;
+import org.opensearch.rest.action.admin.cluster.RestNodesInfoAction;
+import org.opensearch.rest.action.admin.cluster.RestNodesStatsAction;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.rest.FakeRestRequest;
+import org.opensearch.threadpool.TestThreadPool;
+import org.junit.After;
+
+import java.util.Collections;
+
+public class RestStatsActionTests extends OpenSearchTestCase {
+    private final TestThreadPool threadPool = new TestThreadPool(RestStatsActionTests.class.getName());
+    private final NodeClient client = new NodeClient(Settings.EMPTY, threadPool);
+
+    @After
+    public void terminateThreadPool() {
+        terminate(threadPool);
+    }
+
+    public void testClusterStatsActionPrepareRequestNoError() {
+        RestClusterStatsAction action = new RestClusterStatsAction();
+        try {
+            action.prepareRequest(new FakeRestRequest(), client);
+        } catch (Throwable t) {
+            fail(t.getMessage());
+        }
+    }
+
+    public void testNodesStatsActionPrepareRequestNoError() {
+        RestNodesStatsAction action = new RestNodesStatsAction();
+        try {
+            action.prepareRequest(new FakeRestRequest(), client);
+        } catch (Throwable t) {
+            fail(t.getMessage());
+        }
+    }
+
+    public void testNodesInfoActionPrepareRequestNoError() {
+        RestNodesInfoAction action = new RestNodesInfoAction(new SettingsFilter(Collections.singleton("foo.filtered")));
+        try {
+            action.prepareRequest(new FakeRestRequest(), client);
+        } catch (Throwable t) {
+            fail(t.getMessage());
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/node/info/NodeInfoTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/node/info/NodeInfoTests.java
index cfd6fcec4bdc6..b372e9c4dac5b 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/node/info/NodeInfoTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/node/info/NodeInfoTests.java
@@ -52,7 +52,7 @@
 public class NodeInfoTests extends OpenSearchTestCase {
 
     /**
-     * Check that the the {@link NodeInfo#getInfo(Class)} method returns null
+     * Check that the {@link NodeInfo#getInfo(Class)} method returns null
      * for absent info objects, and returns the right thing for present info
      * objects.
      */
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/node/stats/NodeStatsTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/node/stats/NodeStatsTests.java
index e6dd2c7671c33..6e22664eb84d6 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/node/stats/NodeStatsTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/node/stats/NodeStatsTests.java
@@ -32,13 +32,19 @@
 
 package org.opensearch.action.admin.cluster.node.stats;
 
+import org.opensearch.Version;
 import org.opensearch.action.admin.indices.stats.CommonStats;
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
+import org.opensearch.action.admin.indices.stats.IndexShardStats;
+import org.opensearch.action.admin.indices.stats.ShardStats;
 import org.opensearch.action.search.SearchRequestStats;
 import org.opensearch.cluster.coordination.PendingClusterStateStats;
 import org.opensearch.cluster.coordination.PersistedStateStats;
 import org.opensearch.cluster.coordination.PublishClusterStateStats;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
 import org.opensearch.cluster.routing.WeightedRoutingStats;
 import org.opensearch.cluster.service.ClusterManagerThrottlingStats;
 import org.opensearch.cluster.service.ClusterStateStats;
@@ -52,17 +58,31 @@
 import org.opensearch.common.metrics.OperationStats;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.core.indices.breaker.AllCircuitBreakerStats;
 import org.opensearch.core.indices.breaker.CircuitBreakerStats;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.discovery.DiscoveryStats;
 import org.opensearch.gateway.remote.RemotePersistenceStats;
 import org.opensearch.http.HttpStats;
 import org.opensearch.index.ReplicationStats;
 import org.opensearch.index.SegmentReplicationRejectionStats;
+import org.opensearch.index.cache.query.QueryCacheStats;
+import org.opensearch.index.engine.SegmentsStats;
+import org.opensearch.index.fielddata.FieldDataStats;
+import org.opensearch.index.flush.FlushStats;
 import org.opensearch.index.remote.RemoteSegmentStats;
 import org.opensearch.index.remote.RemoteTranslogTransferTracker;
+import org.opensearch.index.shard.DocsStats;
+import org.opensearch.index.shard.IndexingStats;
+import org.opensearch.index.shard.ShardPath;
+import org.opensearch.index.store.StoreStats;
 import org.opensearch.index.translog.RemoteTranslogStats;
 import org.opensearch.indices.NodeIndicesStats;
 import org.opensearch.ingest.IngestStats;
@@ -82,17 +102,20 @@
 import org.opensearch.ratelimitting.admissioncontrol.stats.AdmissionControllerStats;
 import org.opensearch.script.ScriptCacheStats;
 import org.opensearch.script.ScriptStats;
+import org.opensearch.search.suggest.completion.CompletionStats;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.VersionUtils;
 import org.opensearch.threadpool.ThreadPoolStats;
 import org.opensearch.transport.TransportStats;
 
 import java.io.IOException;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
@@ -682,24 +705,22 @@ public static NodeStats createNodeStats(boolean remoteStoreStats) throws IOExcep
                 );
             }
             JvmStats.Classes classes = new JvmStats.Classes(randomNonNegativeLong(), randomNonNegativeLong(), randomNonNegativeLong());
-            jvmStats = frequently()
-                ? new JvmStats(
+            jvmStats = new JvmStats(
+                randomNonNegativeLong(),
+                randomNonNegativeLong(),
+                new JvmStats.Mem(
                     randomNonNegativeLong(),
                     randomNonNegativeLong(),
-                    new JvmStats.Mem(
-                        randomNonNegativeLong(),
-                        randomNonNegativeLong(),
-                        randomNonNegativeLong(),
-                        randomNonNegativeLong(),
-                        randomNonNegativeLong(),
-                        memoryPools
-                    ),
-                    threads,
-                    garbageCollectors,
-                    randomBoolean() ? Collections.emptyList() : bufferPoolList,
-                    classes
-                )
-                : null;
+                    randomNonNegativeLong(),
+                    randomNonNegativeLong(),
+                    randomNonNegativeLong(),
+                    memoryPools
+                ),
+                threads,
+                garbageCollectors,
+                randomBoolean() ? Collections.emptyList() : bufferPoolList,
+                classes
+            );
         }
         ThreadPoolStats threadPoolStats = null;
         if (frequently()) {
@@ -802,7 +823,7 @@ public static NodeStats createNodeStats(boolean remoteStoreStats) throws IOExcep
             : null;
         ClusterStateStats stateStats = new ClusterStateStats();
         RemotePersistenceStats remoteStateStats = new RemotePersistenceStats();
-        stateStats.setPersistenceStats(Arrays.asList(remoteStateStats));
+        stateStats.setPersistenceStats(Arrays.asList(remoteStateStats.getUploadStats()));
         DiscoveryStats discoveryStats = frequently()
             ? new DiscoveryStats(
                 randomBoolean() ? new PendingClusterStateStats(randomInt(), randomInt(), randomInt()) : null,
@@ -1066,4 +1087,381 @@ private static RemoteTranslogTransferTracker.Stats getRandomRemoteTranslogTransf
     private OperationStats getPipelineStats(List<IngestStats.PipelineStat> pipelineStats, String id) {
         return pipelineStats.stream().filter(p1 -> p1.getPipelineId().equals(id)).findFirst().map(p2 -> p2.getStats()).orElse(null);
     }
+
+    public static class MockNodeIndicesStats extends NodeIndicesStats {
+
+        public MockNodeIndicesStats(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        public MockNodeIndicesStats(
+            CommonStats oldStats,
+            Map<Index, List<IndexShardStats>> statsByShard,
+            SearchRequestStats searchRequestStats
+        ) {
+            super(oldStats, statsByShard, searchRequestStats);
+        }
+
+        public MockNodeIndicesStats(
+            CommonStats oldStats,
+            Map<Index, List<IndexShardStats>> statsByShard,
+            SearchRequestStats searchRequestStats,
+            StatsLevel level
+        ) {
+            super(oldStats, statsByShard, searchRequestStats, level);
+        }
+
+        public CommonStats getStats() {
+            return this.stats;
+        }
+
+        public Map<Index, CommonStats> getStatsByIndex() {
+            return this.statsByIndex;
+        }
+
+        public Map<Index, List<IndexShardStats>> getStatsByShard() {
+            return this.statsByShard;
+        }
+    }
+
+    public void testOldVersionNodes() throws IOException {
+        long numDocs = randomLongBetween(0, 10000);
+        long numDeletedDocs = randomLongBetween(0, 100);
+        CommonStats commonStats = new CommonStats(CommonStatsFlags.NONE);
+
+        commonStats.docs = new DocsStats(numDocs, numDeletedDocs, 0);
+        commonStats.store = new StoreStats(100, 0L);
+        commonStats.indexing = new IndexingStats();
+        DocsStats hostDocStats = new DocsStats(numDocs, numDeletedDocs, 0);
+
+        CommonStatsFlags commonStatsFlags = new CommonStatsFlags();
+        commonStatsFlags.clear();
+        commonStatsFlags.set(CommonStatsFlags.Flag.Docs, true);
+        commonStatsFlags.set(CommonStatsFlags.Flag.Store, true);
+        commonStatsFlags.set(CommonStatsFlags.Flag.Indexing, true);
+
+        Index newIndex = new Index("index", "_na_");
+
+        MockNodeIndicesStats mockNodeIndicesStats = generateMockNodeIndicesStats(commonStats, newIndex, commonStatsFlags, null);
+
+        // To test out scenario when the incoming node stats response is from a node with an older ES Version.
+        try (BytesStreamOutput out = new BytesStreamOutput()) {
+            out.setVersion(Version.V_2_13_0);
+            mockNodeIndicesStats.writeTo(out);
+            try (StreamInput in = out.bytes().streamInput()) {
+                in.setVersion(Version.V_2_13_0);
+                MockNodeIndicesStats newNodeIndicesStats = new MockNodeIndicesStats(in);
+
+                List<IndexShardStats> incomingIndexStats = newNodeIndicesStats.getStatsByShard().get(newIndex);
+                incomingIndexStats.forEach(indexShardStats -> {
+                    ShardStats shardStats = Arrays.stream(indexShardStats.getShards()).findFirst().get();
+                    DocsStats incomingDocStats = shardStats.getStats().docs;
+
+                    assertEquals(incomingDocStats.getCount(), hostDocStats.getCount());
+                    assertEquals(incomingDocStats.getTotalSizeInBytes(), hostDocStats.getTotalSizeInBytes());
+                    assertEquals(incomingDocStats.getAverageSizeInBytes(), hostDocStats.getAverageSizeInBytes());
+                    assertEquals(incomingDocStats.getDeleted(), hostDocStats.getDeleted());
+                });
+            }
+        }
+    }
+
+    public void testNodeIndicesStatsSerialization() throws IOException {
+        long numDocs = randomLongBetween(0, 10000);
+        long numDeletedDocs = randomLongBetween(0, 100);
+        List<NodeIndicesStats.StatsLevel> levelParams = new ArrayList<>();
+        levelParams.add(NodeIndicesStats.StatsLevel.INDICES);
+        levelParams.add(NodeIndicesStats.StatsLevel.SHARDS);
+        levelParams.add(NodeIndicesStats.StatsLevel.NODE);
+        CommonStats commonStats = new CommonStats(CommonStatsFlags.NONE);
+
+        commonStats.docs = new DocsStats(numDocs, numDeletedDocs, 0);
+        commonStats.store = new StoreStats(100, 0L);
+        commonStats.indexing = new IndexingStats();
+
+        CommonStatsFlags commonStatsFlags = new CommonStatsFlags();
+        commonStatsFlags.clear();
+        commonStatsFlags.set(CommonStatsFlags.Flag.Docs, true);
+        commonStatsFlags.set(CommonStatsFlags.Flag.Store, true);
+        commonStatsFlags.set(CommonStatsFlags.Flag.Indexing, true);
+        commonStatsFlags.setIncludeIndicesStatsByLevel(true);
+
+        levelParams.forEach(level -> {
+            Index newIndex = new Index("index", "_na_");
+
+            MockNodeIndicesStats mockNodeIndicesStats = generateMockNodeIndicesStats(commonStats, newIndex, commonStatsFlags, level);
+
+            // To test out scenario when the incoming node stats response is from a node with an older ES Version.
+            try (BytesStreamOutput out = new BytesStreamOutput()) {
+                mockNodeIndicesStats.writeTo(out);
+                try (StreamInput in = out.bytes().streamInput()) {
+                    MockNodeIndicesStats newNodeIndicesStats = new MockNodeIndicesStats(in);
+                    switch (level) {
+                        case NODE:
+                            assertNull(newNodeIndicesStats.getStatsByIndex());
+                            assertNull(newNodeIndicesStats.getStatsByShard());
+                            break;
+                        case INDICES:
+                            assertNull(newNodeIndicesStats.getStatsByShard());
+                            assertNotNull(newNodeIndicesStats.getStatsByIndex());
+                            break;
+                        case SHARDS:
+                            assertNull(newNodeIndicesStats.getStatsByIndex());
+                            assertNotNull(newNodeIndicesStats.getStatsByShard());
+                            break;
+                    }
+                }
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    public void testNodeIndicesStatsToXContent() {
+        long numDocs = randomLongBetween(0, 10000);
+        long numDeletedDocs = randomLongBetween(0, 100);
+        List<NodeIndicesStats.StatsLevel> levelParams = new ArrayList<>();
+        levelParams.add(NodeIndicesStats.StatsLevel.INDICES);
+        levelParams.add(NodeIndicesStats.StatsLevel.SHARDS);
+        levelParams.add(NodeIndicesStats.StatsLevel.NODE);
+        CommonStats commonStats = new CommonStats(CommonStatsFlags.NONE);
+
+        commonStats.docs = new DocsStats(numDocs, numDeletedDocs, 0);
+        commonStats.store = new StoreStats(100, 0L);
+        commonStats.indexing = new IndexingStats();
+
+        CommonStatsFlags commonStatsFlags = new CommonStatsFlags();
+        commonStatsFlags.clear();
+        commonStatsFlags.set(CommonStatsFlags.Flag.Docs, true);
+        commonStatsFlags.set(CommonStatsFlags.Flag.Store, true);
+        commonStatsFlags.set(CommonStatsFlags.Flag.Indexing, true);
+        commonStatsFlags.setIncludeIndicesStatsByLevel(true);
+
+        levelParams.forEach(level -> {
+
+            Index newIndex = new Index("index", "_na_");
+
+            MockNodeIndicesStats mockNodeIndicesStats = generateMockNodeIndicesStats(commonStats, newIndex, commonStatsFlags, level);
+
+            XContentBuilder builder = null;
+            try {
+                builder = XContentFactory.jsonBuilder();
+                builder.startObject();
+                builder = mockNodeIndicesStats.toXContent(
+                    builder,
+                    new ToXContent.MapParams(Collections.singletonMap("level", level.getRestName()))
+                );
+                builder.endObject();
+
+                Map<String, Object> xContentMap = xContentBuilderToMap(builder);
+                LinkedHashMap indicesStatsMap = (LinkedHashMap) xContentMap.get(NodeIndicesStats.StatsLevel.INDICES.getRestName());
+
+                switch (level) {
+                    case NODE:
+                        assertFalse(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.INDICES.getRestName()));
+                        assertFalse(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.SHARDS.getRestName()));
+                        break;
+                    case INDICES:
+                        assertTrue(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.INDICES.getRestName()));
+                        assertFalse(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.SHARDS.getRestName()));
+                        break;
+                    case SHARDS:
+                        assertFalse(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.INDICES.getRestName()));
+                        assertTrue(indicesStatsMap.containsKey(NodeIndicesStats.StatsLevel.SHARDS.getRestName()));
+                        break;
+                }
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+
+        });
+    }
+
+    public void testNodeIndicesStatsWithAndWithoutAggregations() throws IOException {
+
+        CommonStatsFlags commonStatsFlags = new CommonStatsFlags(
+            CommonStatsFlags.Flag.Docs,
+            CommonStatsFlags.Flag.Store,
+            CommonStatsFlags.Flag.Indexing,
+            CommonStatsFlags.Flag.Completion,
+            CommonStatsFlags.Flag.Flush,
+            CommonStatsFlags.Flag.FieldData,
+            CommonStatsFlags.Flag.QueryCache,
+            CommonStatsFlags.Flag.Segments
+        );
+
+        int numberOfIndexes = randomIntBetween(1, 3);
+        List<Index> indexList = new ArrayList<>();
+        for (int i = 0; i < numberOfIndexes; i++) {
+            Index index = new Index("test-index-" + i, "_na_");
+            indexList.add(index);
+        }
+
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        HashMap<Index, List<IndexShardStats>> statsByShards = createRandomShardByStats(indexList);
+
+        final MockNodeIndicesStats nonAggregatedNodeIndicesStats = new MockNodeIndicesStats(
+            new CommonStats(commonStatsFlags),
+            statsByShards,
+            new SearchRequestStats(clusterSettings)
+        );
+
+        commonStatsFlags.setIncludeIndicesStatsByLevel(true);
+
+        Arrays.stream(NodeIndicesStats.StatsLevel.values()).forEach(level -> {
+            MockNodeIndicesStats aggregatedNodeIndicesStats = new MockNodeIndicesStats(
+                new CommonStats(commonStatsFlags),
+                statsByShards,
+                new SearchRequestStats(clusterSettings),
+                level
+            );
+
+            XContentBuilder nonAggregatedBuilder = null;
+            XContentBuilder aggregatedBuilder = null;
+            try {
+                nonAggregatedBuilder = XContentFactory.jsonBuilder();
+                nonAggregatedBuilder.startObject();
+                nonAggregatedBuilder = nonAggregatedNodeIndicesStats.toXContent(
+                    nonAggregatedBuilder,
+                    new ToXContent.MapParams(Collections.singletonMap("level", level.getRestName()))
+                );
+                nonAggregatedBuilder.endObject();
+                Map<String, Object> nonAggregatedContentMap = xContentBuilderToMap(nonAggregatedBuilder);
+
+                aggregatedBuilder = XContentFactory.jsonBuilder();
+                aggregatedBuilder.startObject();
+                aggregatedBuilder = aggregatedNodeIndicesStats.toXContent(
+                    aggregatedBuilder,
+                    new ToXContent.MapParams(Collections.singletonMap("level", level.getRestName()))
+                );
+                aggregatedBuilder.endObject();
+                Map<String, Object> aggregatedContentMap = xContentBuilderToMap(aggregatedBuilder);
+
+                assertEquals(aggregatedContentMap, nonAggregatedContentMap);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    private CommonStats createRandomCommonStats() {
+        CommonStats commonStats = new CommonStats(CommonStatsFlags.NONE);
+        commonStats.docs = new DocsStats(randomLongBetween(0, 10000), randomLongBetween(0, 100), randomLongBetween(0, 1000));
+        commonStats.store = new StoreStats(randomLongBetween(0, 100), randomLongBetween(0, 1000));
+        commonStats.indexing = new IndexingStats();
+        commonStats.completion = new CompletionStats();
+        commonStats.flush = new FlushStats(randomLongBetween(0, 100), randomLongBetween(0, 100), randomLongBetween(0, 100));
+        commonStats.fieldData = new FieldDataStats(randomLongBetween(0, 100), randomLongBetween(0, 100), null);
+        commonStats.queryCache = new QueryCacheStats(
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100)
+        );
+        commonStats.segments = new SegmentsStats();
+
+        return commonStats;
+    }
+
+    private HashMap<Index, List<IndexShardStats>> createRandomShardByStats(List<Index> indexes) {
+        DiscoveryNode localNode = new DiscoveryNode("node", buildNewFakeTransportAddress(), Version.CURRENT);
+        HashMap<Index, List<IndexShardStats>> statsByShards = new HashMap<>();
+        indexes.forEach(index -> {
+            List<IndexShardStats> indexShardStatsList = new ArrayList<>();
+
+            int numberOfShards = randomIntBetween(1, 4);
+            for (int i = 0; i < numberOfShards; i++) {
+                ShardRoutingState shardRoutingState = ShardRoutingState.fromValue((byte) randomIntBetween(2, 3));
+
+                ShardRouting shardRouting = TestShardRouting.newShardRouting(
+                    index.getName(),
+                    i,
+                    localNode.getId(),
+                    randomBoolean(),
+                    shardRoutingState
+                );
+
+                Path path = createTempDir().resolve("indices")
+                    .resolve(shardRouting.shardId().getIndex().getUUID())
+                    .resolve(String.valueOf(shardRouting.shardId().id()));
+
+                ShardStats shardStats = new ShardStats(
+                    shardRouting,
+                    new ShardPath(false, path, path, shardRouting.shardId()),
+                    createRandomCommonStats(),
+                    null,
+                    null,
+                    null
+                );
+                List<ShardStats> shardStatsList = new ArrayList<>();
+                shardStatsList.add(shardStats);
+                IndexShardStats indexShardStats = new IndexShardStats(shardRouting.shardId(), shardStatsList.toArray(new ShardStats[0]));
+                indexShardStatsList.add(indexShardStats);
+            }
+            statsByShards.put(index, indexShardStatsList);
+        });
+
+        return statsByShards;
+    }
+
+    private Map<String, Object> xContentBuilderToMap(XContentBuilder xContentBuilder) {
+        return XContentHelper.convertToMap(BytesReference.bytes(xContentBuilder), true, xContentBuilder.contentType()).v2();
+    }
+
+    public MockNodeIndicesStats generateMockNodeIndicesStats(
+        CommonStats commonStats,
+        Index index,
+        CommonStatsFlags commonStatsFlags,
+        NodeIndicesStats.StatsLevel level
+    ) {
+        DiscoveryNode localNode = new DiscoveryNode("local", buildNewFakeTransportAddress(), Version.CURRENT);
+        Map<Index, List<IndexShardStats>> statsByShard = new HashMap<>();
+        List<IndexShardStats> indexShardStatsList = new ArrayList<>();
+        Index statsIndex = null;
+        for (int i = 0; i < 2; i++) {
+            ShardRoutingState shardRoutingState = ShardRoutingState.fromValue((byte) randomIntBetween(2, 3));
+            ShardRouting shardRouting = TestShardRouting.newShardRouting(
+                index.getName(),
+                i,
+                localNode.getId(),
+                randomBoolean(),
+                shardRoutingState
+            );
+
+            if (statsIndex == null) {
+                statsIndex = shardRouting.shardId().getIndex();
+            }
+
+            Path path = createTempDir().resolve("indices")
+                .resolve(shardRouting.shardId().getIndex().getUUID())
+                .resolve(String.valueOf(shardRouting.shardId().id()));
+
+            ShardStats shardStats = new ShardStats(
+                shardRouting,
+                new ShardPath(false, path, path, shardRouting.shardId()),
+                commonStats,
+                null,
+                null,
+                null
+            );
+            IndexShardStats indexShardStats = new IndexShardStats(shardRouting.shardId(), new ShardStats[] { shardStats });
+            indexShardStatsList.add(indexShardStats);
+        }
+
+        statsByShard.put(statsIndex, indexShardStatsList);
+
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+
+        if (commonStatsFlags.getIncludeIndicesStatsByLevel()) {
+            return new MockNodeIndicesStats(
+                new CommonStats(commonStatsFlags),
+                statsByShard,
+                new SearchRequestStats(clusterSettings),
+                level
+            );
+        } else {
+            return new MockNodeIndicesStats(new CommonStats(commonStatsFlags), statsByShard, new SearchRequestStats(clusterSettings));
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksTests.java
index 6bedcc5ec6feb..1f222f7d0627e 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/node/tasks/CancellableTasksTests.java
@@ -428,7 +428,7 @@ public void testRegisterAndExecuteChildTaskWhileParentTaskIsBeingCanceled() thro
         );
         assertThat(cancelledException.getMessage(), startsWith("Task cancelled before it started:"));
         CountDownLatch latch = new CountDownLatch(1);
-        taskManager.startBanOnChildrenNodes(parentTaskId.getId(), latch::countDown);
+        taskManager.startBanOnChildrenNodes(parentTaskId.getId(), latch::countDown, cancelledException.getMessage());
         assertTrue("onChildTasksCompleted() is not invoked", latch.await(1, TimeUnit.SECONDS));
     }
 
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/snapshots/create/CreateSnapshotResponseTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/snapshots/create/CreateSnapshotResponseTests.java
index 274a548fd98ab..2feb0d3ba9405 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/snapshots/create/CreateSnapshotResponseTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/snapshots/create/CreateSnapshotResponseTests.java
@@ -95,7 +95,8 @@ protected CreateSnapshotResponse createTestInstance() {
                 shardFailures,
                 globalState,
                 SnapshotInfoTests.randomUserMetadata(),
-                false
+                false,
+                0
             )
         );
     }
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/snapshots/get/GetSnapshotsResponseTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/snapshots/get/GetSnapshotsResponseTests.java
index 3ef143e36dab9..58af390d194d3 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/snapshots/get/GetSnapshotsResponseTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/snapshots/get/GetSnapshotsResponseTests.java
@@ -77,7 +77,8 @@ protected GetSnapshotsResponse createTestInstance() {
                     shardFailures,
                     randomBoolean(),
                     SnapshotInfoTests.randomUserMetadata(),
-                    false
+                    false,
+                    0
                 )
             );
         }
diff --git a/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java b/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
index 40a30342b86b9..1c4a77905d73f 100644
--- a/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/cluster/stats/ClusterStatsNodesTests.java
@@ -32,16 +32,38 @@
 
 package org.opensearch.action.admin.cluster.stats;
 
+import org.opensearch.Build;
+import org.opensearch.Version;
 import org.opensearch.action.admin.cluster.node.info.NodeInfo;
 import org.opensearch.action.admin.cluster.node.stats.NodeStats;
 import org.opensearch.action.admin.cluster.node.stats.NodeStatsTests;
+import org.opensearch.action.admin.indices.stats.CommonStats;
+import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
+import org.opensearch.action.admin.indices.stats.ShardStats;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
+import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.network.NetworkModule;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.index.cache.query.QueryCacheStats;
+import org.opensearch.index.engine.SegmentsStats;
+import org.opensearch.index.fielddata.FieldDataStats;
+import org.opensearch.index.flush.FlushStats;
+import org.opensearch.index.shard.DocsStats;
+import org.opensearch.index.shard.IndexingStats;
+import org.opensearch.index.shard.ShardPath;
+import org.opensearch.index.store.StoreStats;
+import org.opensearch.search.suggest.completion.CompletionStats;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
+import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Iterator;
@@ -158,6 +180,253 @@ public void testIngestStats() throws Exception {
         );
     }
 
+    public void testMultiVersionScenarioWithAggregatedNodeLevelStats() {
+        // Assuming the default behavior will be the type of response expected from a node of version prior to version containing
+        // aggregated node level information
+        int numberOfNodes = randomIntBetween(1, 4);
+        Index testIndex = new Index("test-index", "_na_");
+
+        List<ClusterStatsNodeResponse> defaultClusterStatsNodeResponses = new ArrayList<>();
+        List<ClusterStatsNodeResponse> aggregatedNodeLevelClusterStatsNodeResponses = new ArrayList<>();
+
+        for (int i = 0; i < numberOfNodes; i++) {
+            DiscoveryNode node = new DiscoveryNode("node-" + i, buildNewFakeTransportAddress(), Version.CURRENT);
+            CommonStats commonStats = createRandomCommonStats();
+            ShardStats[] shardStats = createshardStats(node, testIndex, commonStats);
+            ClusterStatsNodeResponse customClusterStatsResponse = createClusterStatsNodeResponse(node, shardStats, testIndex, true, false);
+            ClusterStatsNodeResponse customNodeLevelAggregatedClusterStatsResponse = createClusterStatsNodeResponse(
+                node,
+                shardStats,
+                testIndex,
+                false,
+                true
+            );
+            defaultClusterStatsNodeResponses.add(customClusterStatsResponse);
+            aggregatedNodeLevelClusterStatsNodeResponses.add(customNodeLevelAggregatedClusterStatsResponse);
+        }
+
+        ClusterStatsIndices defaultClusterStatsIndices = new ClusterStatsIndices(defaultClusterStatsNodeResponses, null, null);
+        ClusterStatsIndices aggregatedNodeLevelClusterStatsIndices = new ClusterStatsIndices(
+            aggregatedNodeLevelClusterStatsNodeResponses,
+            null,
+            null
+        );
+
+        assertClusterStatsIndicesEqual(defaultClusterStatsIndices, aggregatedNodeLevelClusterStatsIndices);
+    }
+
+    public void assertClusterStatsIndicesEqual(ClusterStatsIndices first, ClusterStatsIndices second) {
+        assertEquals(first.getIndexCount(), second.getIndexCount());
+
+        assertEquals(first.getShards().getIndices(), second.getShards().getIndices());
+        assertEquals(first.getShards().getTotal(), second.getShards().getTotal());
+        assertEquals(first.getShards().getPrimaries(), second.getShards().getPrimaries());
+        assertEquals(first.getShards().getMinIndexShards(), second.getShards().getMaxIndexShards());
+        assertEquals(first.getShards().getMinIndexPrimaryShards(), second.getShards().getMinIndexPrimaryShards());
+
+        // As AssertEquals with double is deprecated and can only be used to compare floating-point numbers
+        assertTrue(first.getShards().getReplication() == second.getShards().getReplication());
+        assertTrue(first.getShards().getAvgIndexShards() == second.getShards().getAvgIndexShards());
+        assertTrue(first.getShards().getMaxIndexPrimaryShards() == second.getShards().getMaxIndexPrimaryShards());
+        assertTrue(first.getShards().getAvgIndexPrimaryShards() == second.getShards().getAvgIndexPrimaryShards());
+        assertTrue(first.getShards().getMinIndexReplication() == second.getShards().getMinIndexReplication());
+        assertTrue(first.getShards().getAvgIndexReplication() == second.getShards().getAvgIndexReplication());
+        assertTrue(first.getShards().getMaxIndexReplication() == second.getShards().getMaxIndexReplication());
+
+        // Docs stats
+        assertEquals(first.getDocs().getAverageSizeInBytes(), second.getDocs().getAverageSizeInBytes());
+        assertEquals(first.getDocs().getDeleted(), second.getDocs().getDeleted());
+        assertEquals(first.getDocs().getCount(), second.getDocs().getCount());
+        assertEquals(first.getDocs().getTotalSizeInBytes(), second.getDocs().getTotalSizeInBytes());
+
+        // Store Stats
+        assertEquals(first.getStore().getSizeInBytes(), second.getStore().getSizeInBytes());
+        assertEquals(first.getStore().getSize(), second.getStore().getSize());
+        assertEquals(first.getStore().getReservedSize(), second.getStore().getReservedSize());
+
+        // Query Cache
+        assertEquals(first.getQueryCache().getCacheCount(), second.getQueryCache().getCacheCount());
+        assertEquals(first.getQueryCache().getCacheSize(), second.getQueryCache().getCacheSize());
+        assertEquals(first.getQueryCache().getEvictions(), second.getQueryCache().getEvictions());
+        assertEquals(first.getQueryCache().getHitCount(), second.getQueryCache().getHitCount());
+        assertEquals(first.getQueryCache().getTotalCount(), second.getQueryCache().getTotalCount());
+        assertEquals(first.getQueryCache().getMissCount(), second.getQueryCache().getMissCount());
+        assertEquals(first.getQueryCache().getMemorySize(), second.getQueryCache().getMemorySize());
+        assertEquals(first.getQueryCache().getMemorySizeInBytes(), second.getQueryCache().getMemorySizeInBytes());
+
+        // Completion Stats
+        assertEquals(first.getCompletion().getSizeInBytes(), second.getCompletion().getSizeInBytes());
+        assertEquals(first.getCompletion().getSize(), second.getCompletion().getSize());
+
+        // Segment Stats
+        assertEquals(first.getSegments().getBitsetMemory(), second.getSegments().getBitsetMemory());
+        assertEquals(first.getSegments().getCount(), second.getSegments().getCount());
+        assertEquals(first.getSegments().getBitsetMemoryInBytes(), second.getSegments().getBitsetMemoryInBytes());
+        assertEquals(first.getSegments().getFileSizes(), second.getSegments().getFileSizes());
+        assertEquals(first.getSegments().getIndexWriterMemoryInBytes(), second.getSegments().getIndexWriterMemoryInBytes());
+        assertEquals(first.getSegments().getVersionMapMemory(), second.getSegments().getVersionMapMemory());
+        assertEquals(first.getSegments().getVersionMapMemoryInBytes(), second.getSegments().getVersionMapMemoryInBytes());
+    }
+
+    public void testNodeIndexShardStatsSuccessfulSerializationDeserialization() throws IOException {
+        Index testIndex = new Index("test-index", "_na_");
+
+        DiscoveryNode node = new DiscoveryNode("node", buildNewFakeTransportAddress(), Version.CURRENT);
+        CommonStats commonStats = createRandomCommonStats();
+        ShardStats[] shardStats = createshardStats(node, testIndex, commonStats);
+        ClusterStatsNodeResponse aggregatedNodeLevelClusterStatsNodeResponse = createClusterStatsNodeResponse(
+            node,
+            shardStats,
+            testIndex,
+            false,
+            true
+        );
+
+        BytesStreamOutput out = new BytesStreamOutput();
+        aggregatedNodeLevelClusterStatsNodeResponse.writeTo(out);
+        StreamInput in = out.bytes().streamInput();
+
+        ClusterStatsNodeResponse newClusterStatsNodeRequest = new ClusterStatsNodeResponse(in);
+
+        ClusterStatsIndices beforeSerialization = new ClusterStatsIndices(List.of(aggregatedNodeLevelClusterStatsNodeResponse), null, null);
+        ClusterStatsIndices afterSerialization = new ClusterStatsIndices(List.of(newClusterStatsNodeRequest), null, null);
+
+        assertClusterStatsIndicesEqual(beforeSerialization, afterSerialization);
+
+    }
+
+    private ClusterStatsNodeResponse createClusterStatsNodeResponse(
+        DiscoveryNode node,
+        ShardStats[] shardStats,
+        Index index,
+        boolean defaultBehavior,
+        boolean aggregateNodeLevelStats
+    ) {
+        NodeInfo nodeInfo = new NodeInfo(
+            Version.CURRENT,
+            Build.CURRENT,
+            node,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null
+        );
+
+        NodeStats nodeStats = new NodeStats(
+            node,
+            randomNonNegativeLong(),
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null
+        );
+        if (defaultBehavior) {
+            return new ClusterStatsNodeResponse(node, null, nodeInfo, nodeStats, shardStats);
+        } else {
+            return new ClusterStatsNodeResponse(node, null, nodeInfo, nodeStats, shardStats, aggregateNodeLevelStats);
+        }
+
+    }
+
+    private CommonStats createRandomCommonStats() {
+        CommonStats commonStats = new CommonStats(CommonStatsFlags.NONE);
+        commonStats.docs = new DocsStats(randomLongBetween(0, 10000), randomLongBetween(0, 100), randomLongBetween(0, 1000));
+        commonStats.store = new StoreStats(randomLongBetween(0, 100), randomLongBetween(0, 1000));
+        commonStats.indexing = new IndexingStats();
+        commonStats.completion = new CompletionStats();
+        commonStats.flush = new FlushStats(randomLongBetween(0, 100), randomLongBetween(0, 100), randomLongBetween(0, 100));
+        commonStats.fieldData = new FieldDataStats(randomLongBetween(0, 100), randomLongBetween(0, 100), null);
+        commonStats.queryCache = new QueryCacheStats(
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100),
+            randomLongBetween(0, 100)
+        );
+        commonStats.segments = new SegmentsStats();
+
+        return commonStats;
+    }
+
+    private ShardStats[] createshardStats(DiscoveryNode localNode, Index index, CommonStats commonStats) {
+        List<ShardStats> shardStatsList = new ArrayList<>();
+        for (int i = 0; i < 2; i++) {
+            ShardRoutingState shardRoutingState = ShardRoutingState.fromValue((byte) randomIntBetween(2, 3));
+            ShardRouting shardRouting = TestShardRouting.newShardRouting(
+                index.getName(),
+                i,
+                localNode.getId(),
+                randomBoolean(),
+                shardRoutingState
+            );
+
+            Path path = createTempDir().resolve("indices")
+                .resolve(shardRouting.shardId().getIndex().getUUID())
+                .resolve(String.valueOf(shardRouting.shardId().id()));
+
+            ShardStats shardStats = new ShardStats(
+                shardRouting,
+                new ShardPath(false, path, path, shardRouting.shardId()),
+                commonStats,
+                null,
+                null,
+                null
+            );
+            shardStatsList.add(shardStats);
+        }
+
+        return shardStatsList.toArray(new ShardStats[0]);
+    }
+
+    private class MockShardStats extends ClusterStatsIndices.ShardStats {
+        public boolean equals(ClusterStatsIndices.ShardStats shardStats) {
+            return this.getIndices() == shardStats.getIndices()
+                && this.getTotal() == shardStats.getTotal()
+                && this.getPrimaries() == shardStats.getPrimaries()
+                && this.getReplication() == shardStats.getReplication()
+                && this.getMaxIndexShards() == shardStats.getMaxIndexShards()
+                && this.getMinIndexShards() == shardStats.getMinIndexShards()
+                && this.getAvgIndexShards() == shardStats.getAvgIndexShards()
+                && this.getMaxIndexPrimaryShards() == shardStats.getMaxIndexPrimaryShards()
+                && this.getMinIndexPrimaryShards() == shardStats.getMinIndexPrimaryShards()
+                && this.getAvgIndexPrimaryShards() == shardStats.getAvgIndexPrimaryShards()
+                && this.getMinIndexReplication() == shardStats.getMinIndexReplication()
+                && this.getAvgIndexReplication() == shardStats.getAvgIndexReplication()
+                && this.getMaxIndexReplication() == shardStats.getMaxIndexReplication();
+        }
+    }
+
     private static NodeInfo createNodeInfo(String nodeId, String transportType, String httpType) {
         Settings.Builder settings = Settings.builder();
         if (transportType != null) {
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/create/CreateIndexRequestTests.java b/server/src/test/java/org/opensearch/action/admin/indices/create/CreateIndexRequestTests.java
index 89e072d783747..ee150c7b2bb71 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/create/CreateIndexRequestTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/create/CreateIndexRequestTests.java
@@ -165,6 +165,27 @@ public void testToString() throws IOException {
         assertThat(request.toString(), containsString("mappings='{\"_doc\":{}}'"));
     }
 
+    public void testContext() throws IOException {
+        String contextName = "Test";
+        String contextVersion = "1";
+        Map<String, Object> paramsMap = Map.of("foo", "bar");
+        try (XContentBuilder builder = MediaTypeRegistry.contentBuilder(randomFrom(XContentType.values()))) {
+            builder.startObject()
+                .startObject("context")
+                .field("name", contextName)
+                .field("version", contextVersion)
+                .field("params", paramsMap)
+                .endObject()
+                .endObject();
+
+            CreateIndexRequest parsedCreateIndexRequest = new CreateIndexRequest();
+            parsedCreateIndexRequest.source(builder);
+            assertEquals(contextName, parsedCreateIndexRequest.context().name());
+            assertEquals(contextVersion, parsedCreateIndexRequest.context().version());
+            assertEquals(paramsMap, parsedCreateIndexRequest.context().params());
+        }
+    }
+
     public static void assertMappingsEqual(Map<String, String> expected, Map<String, String> actual) throws IOException {
         assertEquals(expected.keySet(), actual.keySet());
 
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexActionTests.java
index 2d9ec2b6d3c02..67d2163affd28 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexActionTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexActionTests.java
@@ -36,6 +36,7 @@
 import org.opensearch.action.support.ActionFilters;
 import org.opensearch.action.support.replication.ClusterStateCreationUtils;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.IndexScopedSettings;
@@ -68,7 +69,7 @@ public class GetIndexActionTests extends OpenSearchSingleNodeTestCase {
     private ThreadPool threadPool;
     private SettingsFilter settingsFilter;
     private final String indexName = "test_index";
-
+    private Context context;
     private TestTransportGetIndexAction getIndexAction;
 
     @Before
@@ -91,6 +92,7 @@ public void setUp() throws Exception {
         );
         transportService.start();
         transportService.acceptIncomingRequests();
+        context = new Context(randomAlphaOfLength(5));
         getIndexAction = new GetIndexActionTests.TestTransportGetIndexAction();
     }
 
@@ -135,6 +137,23 @@ public void testDoNotIncludeDefaults() {
         );
     }
 
+    public void testContextInResponse() {
+        GetIndexRequest contextIndexRequest = new GetIndexRequest().indices(indexName);
+        getIndexAction.execute(
+            null,
+            contextIndexRequest,
+            ActionListener.wrap(
+                resp -> assertTrue(
+                    "index context should be present as it was set",
+                    resp.contexts().get(indexName) != null && resp.contexts().get(indexName).equals(context)
+                ),
+                exception -> {
+                    throw new AssertionError(exception);
+                }
+            )
+        );
+    }
+
     class TestTransportGetIndexAction extends TransportGetIndexAction {
 
         TestTransportGetIndexAction() {
@@ -157,7 +176,7 @@ protected void doClusterManagerOperation(
             ClusterState state,
             ActionListener<GetIndexResponse> listener
         ) {
-            ClusterState stateWithIndex = ClusterStateCreationUtils.state(indexName, 1, 1);
+            ClusterState stateWithIndex = ClusterStateCreationUtils.stateWithContext(indexName, 1, 1, context);
             super.doClusterManagerOperation(request, concreteIndices, stateWithIndex, listener);
         }
     }
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexRequestTests.java b/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexRequestTests.java
index f0d3db71c27b7..704d8a0fca409 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexRequestTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexRequestTests.java
@@ -8,9 +8,15 @@
 
 package org.opensearch.action.admin.indices.get;
 
+import org.opensearch.Version;
 import org.opensearch.action.support.master.info.ClusterInfoRequest;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.test.OpenSearchTestCase;
 
+import java.io.IOException;
+import java.util.Arrays;
+
 import static org.hamcrest.Matchers.is;
 
 public class GetIndexRequestTests extends OpenSearchTestCase {
@@ -18,4 +24,31 @@ public void testGetIndexRequestExtendsClusterInfoRequestOfDeprecatedClassPath()
         GetIndexRequest getIndexRequest = new GetIndexRequest().indices("test");
         assertThat(getIndexRequest instanceof ClusterInfoRequest, is(true));
     }
+
+    public void testGetIndexRequestWriteableWithLatestNode() throws IOException {
+        // Write to 2.17 stream
+        try (BytesStreamOutput output = new BytesStreamOutput()) {
+            GetIndexRequest getIndexRequest = new GetIndexRequest().indices("test").addFeatures(GetIndexRequest.Feature.values());
+            output.setVersion(Version.V_2_17_0);
+            getIndexRequest.writeTo(output);
+            try (StreamInput in = output.bytes().streamInput()) {
+                GetIndexRequest getIndexRequestRead = new GetIndexRequest(in);
+                assertArrayEquals(getIndexRequestRead.features(), getIndexRequest.features());
+            }
+        }
+    }
+
+    public void testGetIndexRequestWriteableWithOldNode() throws IOException {
+        // Write to 2.1 stream
+        try (BytesStreamOutput output = new BytesStreamOutput()) {
+            GetIndexRequest getIndexRequest = new GetIndexRequest().indices("test").addFeatures(GetIndexRequest.Feature.values());
+            output.setVersion(Version.V_2_16_0);
+            getIndexRequest.writeTo(output);
+            try (StreamInput in = output.bytes().streamInput()) {
+                GetIndexRequest getIndexRequestRead = new GetIndexRequest(in);
+                assertTrue(Arrays.stream(getIndexRequestRead.features()).noneMatch(f -> f == GetIndexRequest.Feature.CONTEXT));
+                assertEquals(3, getIndexRequestRead.features().length);
+            }
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexResponseTests.java b/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexResponseTests.java
index 89d47328a08ed..c9b7858ed24ca 100644
--- a/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexResponseTests.java
+++ b/server/src/test/java/org/opensearch/action/admin/indices/get/GetIndexResponseTests.java
@@ -36,6 +36,7 @@
 import org.opensearch.action.admin.indices.alias.get.GetAliasesResponseTests;
 import org.opensearch.action.admin.indices.mapping.get.GetMappingsResponseTests;
 import org.opensearch.cluster.metadata.AliasMetadata;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.MappingMetadata;
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Settings;
@@ -66,6 +67,7 @@ protected GetIndexResponse createTestInstance() {
         Map<String, Settings> settings = new HashMap<>();
         Map<String, Settings> defaultSettings = new HashMap<>();
         Map<String, String> dataStreams = new HashMap<>();
+        Map<String, Context> contexts = new HashMap<>();
         IndexScopedSettings indexScopedSettings = IndexScopedSettings.DEFAULT_SCOPED_SETTINGS;
         boolean includeDefaults = randomBoolean();
         for (String index : indices) {
@@ -90,7 +92,10 @@ protected GetIndexResponse createTestInstance() {
             if (randomBoolean()) {
                 dataStreams.put(index, randomAlphaOfLength(5).toLowerCase(Locale.ROOT));
             }
+            if (randomBoolean()) {
+                contexts.put(index, new Context(randomAlphaOfLength(5).toLowerCase(Locale.ROOT)));
+            }
         }
-        return new GetIndexResponse(indices, mappings, aliases, settings, defaultSettings, dataStreams);
+        return new GetIndexResponse(indices, mappings, aliases, settings, defaultSettings, dataStreams, contexts);
     }
 }
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/mapping/get/GetMappingsActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/mapping/get/GetMappingsActionTests.java
new file mode 100644
index 0000000000000..87f218760038e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/mapping/get/GetMappingsActionTests.java
@@ -0,0 +1,227 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.action.admin.indices.mapping.get;
+
+import org.opensearch.Version;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.clustermanager.term.GetTermVersionResponse;
+import org.opensearch.action.support.replication.ClusterStateCreationUtils;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlock;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.cluster.coordination.ClusterStateTermVersion;
+import org.opensearch.cluster.metadata.IndexNameExpressionResolver;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsFilter;
+import org.opensearch.common.settings.SettingsModule;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.telemetry.tracing.noop.NoopTracer;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.concurrent.TimeUnit;
+
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptySet;
+import static org.opensearch.test.ClusterServiceUtils.createClusterService;
+import static org.opensearch.test.ClusterServiceUtils.setState;
+import static org.hamcrest.Matchers.equalTo;
+import static org.mockito.Mockito.mock;
+
+public class GetMappingsActionTests extends OpenSearchTestCase {
+    private TransportService transportService;
+    private ClusterService clusterService;
+    private ThreadPool threadPool;
+    private SettingsFilter settingsFilter;
+    private final String indexName = "test_index";
+    CapturingTransport capturingTransport = new CapturingTransport();
+    private DiscoveryNode localNode;
+    private DiscoveryNode remoteNode;
+    private DiscoveryNode[] allNodes;
+    private TransportGetMappingsAction transportAction = null;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+
+        settingsFilter = new SettingsModule(Settings.EMPTY, emptyList(), emptyList(), emptySet()).getSettingsFilter();
+        threadPool = new TestThreadPool("GetIndexActionTests");
+        clusterService = createClusterService(threadPool);
+
+        transportService = capturingTransport.createTransportService(
+            clusterService.getSettings(),
+            threadPool,
+            TransportService.NOOP_TRANSPORT_INTERCEPTOR,
+            boundAddress -> clusterService.localNode(),
+            null,
+            emptySet(),
+            NoopTracer.INSTANCE
+        );
+        transportService.start();
+        transportService.acceptIncomingRequests();
+
+        localNode = new DiscoveryNode(
+            "local_node",
+            buildNewFakeTransportAddress(),
+            Collections.emptyMap(),
+            Collections.singleton(DiscoveryNodeRole.DATA_ROLE),
+            Version.CURRENT
+        );
+        remoteNode = new DiscoveryNode(
+            "remote_node",
+            buildNewFakeTransportAddress(),
+            Collections.emptyMap(),
+            Collections.singleton(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE),
+            Version.CURRENT
+        );
+        allNodes = new DiscoveryNode[] { localNode, remoteNode };
+        setState(clusterService, ClusterStateCreationUtils.state(localNode, remoteNode, allNodes));
+        transportAction = new TransportGetMappingsAction(
+            GetMappingsActionTests.this.transportService,
+            GetMappingsActionTests.this.clusterService,
+            GetMappingsActionTests.this.threadPool,
+            new ActionFilters(emptySet()),
+            new IndexNameExpressionResolver(new ThreadContext(Settings.EMPTY)),
+            mock(IndicesService.class)
+        );
+
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        clusterService.close();
+        transportService.close();
+        ThreadPool.terminate(threadPool, 30, TimeUnit.SECONDS);
+    }
+
+    public void testGetTransportWithoutMatchingTerm() {
+        transportAction.execute(null, new GetMappingsRequest(), ActionListener.wrap(Assert::assertNotNull, exception -> {
+            throw new AssertionError(exception);
+        }));
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+        CapturingTransport.CapturedRequest capturedRequest = capturingTransport.capturedRequests()[0];
+        // mismatch term and version
+        GetTermVersionResponse termResp = new GetTermVersionResponse(
+            new ClusterStateTermVersion(
+                clusterService.state().getClusterName(),
+                clusterService.state().metadata().clusterUUID(),
+                clusterService.state().term() - 1,
+                clusterService.state().version() - 1
+            )
+        );
+        capturingTransport.handleResponse(capturedRequest.requestId, termResp);
+
+        assertThat(capturingTransport.capturedRequests().length, equalTo(2));
+        CapturingTransport.CapturedRequest capturedRequest1 = capturingTransport.capturedRequests()[1];
+
+        capturingTransport.handleResponse(capturedRequest1.requestId, new GetMappingsResponse(new HashMap<>()));
+    }
+
+    public void testGetTransportWithMatchingTerm() {
+        transportAction.execute(null, new GetMappingsRequest(), ActionListener.wrap(Assert::assertNotNull, exception -> {
+            throw new AssertionError(exception);
+        }));
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+        CapturingTransport.CapturedRequest capturedRequest = capturingTransport.capturedRequests()[0];
+        GetTermVersionResponse termResp = new GetTermVersionResponse(
+            new ClusterStateTermVersion(
+                clusterService.state().getClusterName(),
+                clusterService.state().metadata().clusterUUID(),
+                clusterService.state().term(),
+                clusterService.state().version()
+            )
+        );
+        capturingTransport.handleResponse(capturedRequest.requestId, termResp);
+
+        // no more transport calls
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+    }
+
+    public void testGetTransportClusterBlockWithMatchingTerm() {
+        ClusterBlock readClusterBlock = new ClusterBlock(
+            1,
+            "uuid",
+            "",
+            false,
+            true,
+            true,
+            RestStatus.OK,
+            EnumSet.of(ClusterBlockLevel.METADATA_READ)
+        );
+        ClusterBlocks.Builder builder = ClusterBlocks.builder();
+        builder.addGlobalBlock(readClusterBlock);
+        ClusterState metadataReadBlockedState = ClusterState.builder(ClusterStateCreationUtils.state(localNode, remoteNode, allNodes))
+            .blocks(builder)
+            .build();
+        setState(clusterService, metadataReadBlockedState);
+
+        transportAction.execute(
+            null,
+            new GetMappingsRequest(),
+            ActionListener.wrap(response -> { throw new AssertionError(response); }, exception -> {
+                Assert.assertTrue(exception instanceof ClusterBlockException);
+            })
+        );
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+        CapturingTransport.CapturedRequest capturedRequest = capturingTransport.capturedRequests()[0];
+        GetTermVersionResponse termResp = new GetTermVersionResponse(
+            new ClusterStateTermVersion(
+                clusterService.state().getClusterName(),
+                clusterService.state().metadata().clusterUUID(),
+                clusterService.state().term(),
+                clusterService.state().version()
+            )
+        );
+        capturingTransport.handleResponse(capturedRequest.requestId, termResp);
+
+        // no more transport calls
+        assertThat(capturingTransport.capturedRequests().length, equalTo(1));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/shards/CatShardsResponseTests.java b/server/src/test/java/org/opensearch/action/admin/indices/shards/CatShardsResponseTests.java
new file mode 100644
index 0000000000000..d0b98f4d286ae
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/shards/CatShardsResponseTests.java
@@ -0,0 +1,61 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*
+ * Modifications Copyright OpenSearch Contributors. See
+ * GitHub history for details.
+ */
+
+package org.opensearch.action.admin.indices.shards;
+
+import org.opensearch.action.admin.cluster.shards.CatShardsResponse;
+import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
+import org.opensearch.action.admin.indices.stats.IndicesStatsResponse;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.junit.Assert.assertEquals;
+
+public class CatShardsResponseTests extends OpenSearchTestCase {
+
+    private final CatShardsResponse catShardsResponse = new CatShardsResponse();
+
+    public void testGetAndSetClusterStateResponse() {
+        ClusterName clusterName = new ClusterName("1");
+        ClusterStateResponse clusterStateResponse = new ClusterStateResponse(clusterName, null, false);
+        catShardsResponse.setClusterStateResponse(clusterStateResponse);
+
+        assertEquals(clusterStateResponse, catShardsResponse.getClusterStateResponse());
+    }
+
+    public void testGetAndSetIndicesStatsResponse() {
+        final IndicesStatsResponse indicesStatsResponse = new IndicesStatsResponse(null, 0, 0, 0, null);
+        catShardsResponse.setIndicesStatsResponse(indicesStatsResponse);
+
+        assertEquals(indicesStatsResponse, catShardsResponse.getIndicesStatsResponse());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponseTests.java b/server/src/test/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponseTests.java
new file mode 100644
index 0000000000000..85cabe0fa1491
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/tiering/HotToWarmTieringResponseTests.java
@@ -0,0 +1,101 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.test.AbstractWireSerializingTestCase;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class HotToWarmTieringResponseTests extends AbstractWireSerializingTestCase<HotToWarmTieringResponse> {
+
+    @Override
+    protected Writeable.Reader<HotToWarmTieringResponse> instanceReader() {
+        return HotToWarmTieringResponse::new;
+    }
+
+    @Override
+    protected HotToWarmTieringResponse createTestInstance() {
+        return randomHotToWarmTieringResponse();
+    }
+
+    @Override
+    protected void assertEqualInstances(HotToWarmTieringResponse expected, HotToWarmTieringResponse actual) {
+        assertNotSame(expected, actual);
+        assertEquals(actual.isAcknowledged(), expected.isAcknowledged());
+
+        for (int i = 0; i < expected.getFailedIndices().size(); i++) {
+            HotToWarmTieringResponse.IndexResult expectedIndexResult = expected.getFailedIndices().get(i);
+            HotToWarmTieringResponse.IndexResult actualIndexResult = actual.getFailedIndices().get(i);
+            assertNotSame(expectedIndexResult, actualIndexResult);
+            assertEquals(actualIndexResult.getIndex(), expectedIndexResult.getIndex());
+            assertEquals(actualIndexResult.getFailureReason(), expectedIndexResult.getFailureReason());
+        }
+    }
+
+    /**
+     * Verifies that ToXContent works with any random {@link HotToWarmTieringResponse} object
+     * @throws Exception - in case of error
+     */
+    public void testToXContentWorksForRandomResponse() throws Exception {
+        HotToWarmTieringResponse testResponse = randomHotToWarmTieringResponse();
+        XContentType xContentType = randomFrom(XContentType.values());
+        try (XContentBuilder builder = XContentBuilder.builder(xContentType.xContent())) {
+            testResponse.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        }
+    }
+
+    /**
+     * Verify the XContent output of the response object
+     * @throws Exception - in case of error
+     */
+    public void testToXContentOutput() throws Exception {
+        String[] indices = new String[] { "index2", "index1" };
+        String[] errorReasons = new String[] { "reason2", "reason1" };
+        List<HotToWarmTieringResponse.IndexResult> results = new LinkedList<>();
+        for (int i = 0; i < indices.length; ++i) {
+            results.add(new HotToWarmTieringResponse.IndexResult(indices[i], errorReasons[i]));
+        }
+        HotToWarmTieringResponse testResponse = new HotToWarmTieringResponse(true, results);
+
+        // generate a corresponding expected xcontent
+        XContentBuilder content = XContentFactory.jsonBuilder().startObject().field("acknowledged", true).startArray("failed_indices");
+        // expected result should be in the sorted order
+        content.startObject().field("index", "index1").field("error", "reason1").endObject();
+        content.startObject().field("index", "index2").field("error", "reason2").endObject();
+        content.endArray().endObject();
+        assertEquals(content.toString(), testResponse.toString());
+    }
+
+    /**
+     * @return - randomly generated object of type {@link HotToWarmTieringResponse.IndexResult}
+     */
+    private HotToWarmTieringResponse.IndexResult randomIndexResult() {
+        String indexName = randomAlphaOfLengthBetween(1, 50);
+        String failureReason = randomAlphaOfLengthBetween(1, 200);
+        return new HotToWarmTieringResponse.IndexResult(indexName, failureReason);
+    }
+
+    /**
+     * @return - randomly generated object of type {@link HotToWarmTieringResponse}
+     */
+    private HotToWarmTieringResponse randomHotToWarmTieringResponse() {
+        int numIndexResult = randomIntBetween(0, 10);
+        List<HotToWarmTieringResponse.IndexResult> indexResults = new LinkedList<>();
+        for (int i = 0; i < numIndexResult; ++i) {
+            indexResults.add(randomIndexResult());
+        }
+        return new HotToWarmTieringResponse(randomBoolean(), indexResults);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequestTests.java b/server/src/test/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequestTests.java
new file mode 100644
index 0000000000000..e33d10268a617
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/tiering/TieringIndexRequestTests.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+
+public class TieringIndexRequestTests extends OpenSearchTestCase {
+
+    public void testTieringRequestWithListOfIndices() {
+        TieringIndexRequest request = new TieringIndexRequest(
+            TieringIndexRequest.Tier.WARM,
+            IndicesOptions.fromOptions(randomBoolean(), randomBoolean(), randomBoolean(), randomBoolean()),
+            false,
+            "foo",
+            "bar",
+            "baz"
+        );
+        ActionRequestValidationException validationException = request.validate();
+        assertNull(validationException);
+    }
+
+    public void testTieringRequestWithIndexPattern() {
+        TieringIndexRequest request = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), "foo-*");
+        ActionRequestValidationException validationException = request.validate();
+        assertNull(validationException);
+    }
+
+    public void testTieringRequestWithNullOrEmptyIndices() {
+        TieringIndexRequest request = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), null, "");
+        ActionRequestValidationException validationException = request.validate();
+        assertNotNull(validationException);
+    }
+
+    public void testTieringRequestWithNotSupportedTier() {
+        TieringIndexRequest request = new TieringIndexRequest(TieringIndexRequest.Tier.HOT.name(), "test");
+        ActionRequestValidationException validationException = request.validate();
+        assertNotNull(validationException);
+    }
+
+    public void testTieringTypeFromString() {
+        expectThrows(IllegalArgumentException.class, () -> TieringIndexRequest.Tier.fromString("tier"));
+        expectThrows(IllegalArgumentException.class, () -> TieringIndexRequest.Tier.fromString(null));
+    }
+
+    public void testSerDeOfTieringRequest() throws IOException {
+        TieringIndexRequest request = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), "test");
+        try (BytesStreamOutput out = new BytesStreamOutput()) {
+            request.writeTo(out);
+            try (StreamInput in = out.bytes().streamInput()) {
+                final TieringIndexRequest deserializedRequest = new TieringIndexRequest(in);
+                assertEquals(request, deserializedRequest);
+            }
+        }
+    }
+
+    public void testTieringRequestEquals() {
+        final TieringIndexRequest original = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), "test");
+        original.indicesOptions(IndicesOptions.fromOptions(randomBoolean(), randomBoolean(), randomBoolean(), randomBoolean()));
+        final TieringIndexRequest expected = new TieringIndexRequest(TieringIndexRequest.Tier.WARM.name(), original.indices());
+        expected.indicesOptions(original.indicesOptions());
+        assertThat(expected, equalTo(original));
+        assertThat(expected.indices(), equalTo(original.indices()));
+        assertThat(expected.indicesOptions(), equalTo(original.indicesOptions()));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringActionTests.java b/server/src/test/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringActionTests.java
new file mode 100644
index 0000000000000..10273366af804
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/admin/indices/tiering/TransportHotToWarmTieringActionTests.java
@@ -0,0 +1,118 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.admin.indices.tiering;
+
+import com.carrotsearch.randomizedtesting.annotations.ThreadLeakFilters;
+
+import org.opensearch.action.support.IndicesOptions;
+import org.opensearch.cluster.ClusterInfoService;
+import org.opensearch.cluster.MockInternalClusterInfoService;
+import org.opensearch.cluster.block.ClusterBlockException;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.index.IndexNotFoundException;
+import org.opensearch.index.store.remote.file.CleanerDaemonThreadLeakFilter;
+import org.opensearch.monitor.fs.FsInfo;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.test.OpenSearchIntegTestCase;
+import org.junit.After;
+import org.junit.Before;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_READ_ONLY_ALLOW_DELETE;
+import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
+
+@ThreadLeakFilters(filters = CleanerDaemonThreadLeakFilter.class)
+@OpenSearchIntegTestCase.ClusterScope(scope = OpenSearchIntegTestCase.Scope.TEST, numDataNodes = 0, supportsDedicatedMasters = false)
+public class TransportHotToWarmTieringActionTests extends OpenSearchIntegTestCase {
+    protected static final String TEST_IDX_1 = "test-idx-1";
+    protected static final String TEST_IDX_2 = "idx-2";
+    protected static final String TARGET_TIER = "warm";
+    private String[] indices;
+
+    @Override
+    protected Settings featureFlagSettings() {
+        Settings.Builder featureSettings = Settings.builder();
+        featureSettings.put(FeatureFlags.TIERED_REMOTE_INDEX, true);
+        return featureSettings.build();
+    }
+
+    @Override
+    protected Collection<Class<? extends Plugin>> nodePlugins() {
+        return Collections.singletonList(MockInternalClusterInfoService.TestPlugin.class);
+    }
+
+    @Before
+    public void setup() {
+        internalCluster().startClusterManagerOnlyNode();
+        internalCluster().ensureAtLeastNumSearchAndDataNodes(1);
+        long bytes = new ByteSizeValue(1000, ByteSizeUnit.KB).getBytes();
+        final MockInternalClusterInfoService clusterInfoService = getMockInternalClusterInfoService();
+        clusterInfoService.setDiskUsageFunctionAndRefresh((discoveryNode, fsInfoPath) -> setDiskUsage(fsInfoPath, bytes, bytes - 1));
+
+        final int numReplicasIndex = 0;
+        final Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, numReplicasIndex)
+            .build();
+
+        indices = new String[] { TEST_IDX_1, TEST_IDX_2 };
+        for (String index : indices) {
+            assertAcked(client().admin().indices().prepareCreate(index).setSettings(settings).get());
+            ensureGreen(index);
+        }
+    }
+
+    @After
+    public void cleanup() {
+        client().admin().indices().prepareDelete(indices).get();
+    }
+
+    MockInternalClusterInfoService getMockInternalClusterInfoService() {
+        return (MockInternalClusterInfoService) internalCluster().getCurrentClusterManagerNodeInstance(ClusterInfoService.class);
+    }
+
+    static FsInfo.Path setDiskUsage(FsInfo.Path original, long totalBytes, long freeBytes) {
+        return new FsInfo.Path(original.getPath(), original.getMount(), totalBytes, freeBytes, freeBytes);
+    }
+
+    public void testIndexLevelBlocks() {
+        enableIndexBlock(TEST_IDX_1, SETTING_READ_ONLY_ALLOW_DELETE);
+        TieringIndexRequest request = new TieringIndexRequest(TARGET_TIER, TEST_IDX_1);
+        expectThrows(ClusterBlockException.class, () -> client().execute(HotToWarmTieringAction.INSTANCE, request).actionGet());
+    }
+
+    public void testIndexNotFound() {
+        TieringIndexRequest request = new TieringIndexRequest(TARGET_TIER, "foo");
+        expectThrows(IndexNotFoundException.class, () -> client().execute(HotToWarmTieringAction.INSTANCE, request).actionGet());
+    }
+
+    public void testNoConcreteIndices() {
+        TieringIndexRequest request = new TieringIndexRequest(TARGET_TIER, "foo");
+        request.indicesOptions(IndicesOptions.fromOptions(true, true, true, false));
+        HotToWarmTieringResponse response = client().admin().indices().execute(HotToWarmTieringAction.INSTANCE, request).actionGet();
+        assertTrue(response.isAcknowledged());
+        assertTrue(response.getFailedIndices().isEmpty());
+    }
+
+    public void testNoAcceptedIndices() {
+        TieringIndexRequest request = new TieringIndexRequest(TARGET_TIER, "test-idx-*", "idx-*");
+        HotToWarmTieringResponse response = client().admin().indices().execute(HotToWarmTieringAction.INSTANCE, request).actionGet();
+        assertFalse(response.isAcknowledged());
+        assertEquals(2, response.getFailedIndices().size());
+        for (HotToWarmTieringResponse.IndexResult result : response.getFailedIndices()) {
+            assertEquals("index is not backed up by the remote store", result.getFailureReason());
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/bulk/TransportBulkActionIndicesThatCannotBeCreatedTests.java b/server/src/test/java/org/opensearch/action/bulk/TransportBulkActionIndicesThatCannotBeCreatedTests.java
index cf7080ab2fc06..ff9e41ee7c784 100644
--- a/server/src/test/java/org/opensearch/action/bulk/TransportBulkActionIndicesThatCannotBeCreatedTests.java
+++ b/server/src/test/java/org/opensearch/action/bulk/TransportBulkActionIndicesThatCannotBeCreatedTests.java
@@ -55,6 +55,7 @@
 import org.opensearch.indices.SystemIndices;
 import org.opensearch.tasks.Task;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.VersionUtils;
 import org.opensearch.threadpool.ThreadPool;
@@ -153,7 +154,11 @@ private void indicesThatCannotBeCreatedTestCase(
             null,
             new IndexingPressureService(
                 Settings.EMPTY,
-                new ClusterService(Settings.EMPTY, new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS), null)
+                ClusterServiceUtils.createClusterService(
+                    Settings.EMPTY,
+                    new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                    null
+                )
             ),
             null,
             new SystemIndices(emptyMap()),
diff --git a/server/src/test/java/org/opensearch/action/bulk/TransportBulkActionIngestTests.java b/server/src/test/java/org/opensearch/action/bulk/TransportBulkActionIngestTests.java
index da9156ccdb71a..a94a5d60b3f5a 100644
--- a/server/src/test/java/org/opensearch/action/bulk/TransportBulkActionIngestTests.java
+++ b/server/src/test/java/org/opensearch/action/bulk/TransportBulkActionIngestTests.java
@@ -71,6 +71,7 @@
 import org.opensearch.ingest.IngestService;
 import org.opensearch.tasks.Task;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.VersionUtils;
 import org.opensearch.threadpool.ThreadPool;
@@ -170,7 +171,11 @@ class TestTransportBulkAction extends TransportBulkAction {
                 ),
                 new IndexingPressureService(
                     SETTINGS,
-                    new ClusterService(SETTINGS, new ClusterSettings(SETTINGS, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS), null)
+                    ClusterServiceUtils.createClusterService(
+                        SETTINGS,
+                        new ClusterSettings(SETTINGS, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                        null
+                    )
                 ),
                 null,
                 new SystemIndices(emptyMap()),
diff --git a/server/src/test/java/org/opensearch/action/ingest/SimulateExecutionServiceTests.java b/server/src/test/java/org/opensearch/action/ingest/SimulateExecutionServiceTests.java
index a5a082286f123..a26afeee0f912 100644
--- a/server/src/test/java/org/opensearch/action/ingest/SimulateExecutionServiceTests.java
+++ b/server/src/test/java/org/opensearch/action/ingest/SimulateExecutionServiceTests.java
@@ -39,6 +39,7 @@
 import org.opensearch.ingest.DropProcessor;
 import org.opensearch.ingest.IngestDocument;
 import org.opensearch.ingest.IngestProcessorException;
+import org.opensearch.ingest.IngestService;
 import org.opensearch.ingest.Pipeline;
 import org.opensearch.ingest.Processor;
 import org.opensearch.ingest.RandomDocumentPicks;
@@ -67,6 +68,8 @@
 import static org.hamcrest.Matchers.notNullValue;
 import static org.hamcrest.Matchers.nullValue;
 import static org.hamcrest.Matchers.sameInstance;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
 
 public class SimulateExecutionServiceTests extends OpenSearchTestCase {
 
@@ -75,11 +78,13 @@ public class SimulateExecutionServiceTests extends OpenSearchTestCase {
     private TestThreadPool threadPool;
     private SimulateExecutionService executionService;
     private IngestDocument ingestDocument;
+    private IngestService ingestService;
 
     @Before
     public void setup() {
+        ingestService = mock(IngestService.class);
         threadPool = new TestThreadPool(SimulateExecutionServiceTests.class.getSimpleName());
-        executionService = new SimulateExecutionService(threadPool);
+        executionService = new SimulateExecutionService(threadPool, ingestService);
         ingestDocument = RandomDocumentPicks.randomIngestDocument(random());
     }
 
@@ -400,6 +405,22 @@ public String getType() {
         }
     }
 
+    public void testValidateProcessorCountForIngestPipelineThrowsException() {
+
+        int numDocs = randomIntBetween(1, 64);
+        List<IngestDocument> documents = new ArrayList<>(numDocs);
+        for (int id = 0; id < numDocs; id++) {
+            documents.add(new IngestDocument("_index", Integer.toString(id), null, 0L, VersionType.INTERNAL, new HashMap<>()));
+        }
+
+        Pipeline pipeline = new Pipeline("_id", "_description", version, new CompoundProcessor());
+        SimulatePipelineRequest.Parsed request = new SimulatePipelineRequest.Parsed(pipeline, documents, false);
+
+        doThrow(new IllegalStateException()).when(ingestService).validateProcessorCountForIngestPipeline(pipeline);
+
+        expectThrows(IllegalStateException.class, () -> executionService.execute(request, ActionListener.wrap(response -> {}, e -> {})));
+    }
+
     private static void assertVerboseResult(
         SimulateProcessorResult result,
         String expectedPipelineId,
diff --git a/server/src/test/java/org/opensearch/action/search/AbstractSearchAsyncActionTests.java b/server/src/test/java/org/opensearch/action/search/AbstractSearchAsyncActionTests.java
index 7dcbf213d6c9d..27336e86e52b0 100644
--- a/server/src/test/java/org/opensearch/action/search/AbstractSearchAsyncActionTests.java
+++ b/server/src/test/java/org/opensearch/action/search/AbstractSearchAsyncActionTests.java
@@ -49,6 +49,8 @@
 import org.opensearch.core.common.breaker.NoopCircuitBreaker;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceInfo;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceUsage;
 import org.opensearch.index.query.MatchAllQueryBuilder;
 import org.opensearch.index.shard.ShardNotFoundException;
 import org.opensearch.search.SearchPhaseResult;
@@ -87,6 +89,7 @@
 import java.util.function.BiFunction;
 import java.util.stream.IntStream;
 
+import static org.opensearch.tasks.TaskResourceTrackingService.TASK_RESOURCE_USAGE;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
 import static org.hamcrest.Matchers.instanceOf;
@@ -123,7 +126,8 @@ private AbstractSearchAsyncAction<SearchPhaseResult> createAction(
         ArraySearchPhaseResults<SearchPhaseResult> results,
         ActionListener<SearchResponse> listener,
         final boolean controlled,
-        final AtomicLong expected
+        final AtomicLong expected,
+        final TaskResourceUsage resourceUsage
     ) {
         return createAction(
             request,
@@ -133,6 +137,7 @@ private AbstractSearchAsyncAction<SearchPhaseResult> createAction(
             false,
             false,
             expected,
+            resourceUsage,
             new SearchShardIterator(null, null, Collections.emptyList(), null)
         );
     }
@@ -145,6 +150,7 @@ private AbstractSearchAsyncAction<SearchPhaseResult> createAction(
         final boolean failExecutePhaseOnShard,
         final boolean catchExceptionWhenExecutePhaseOnShard,
         final AtomicLong expected,
+        final TaskResourceUsage resourceUsage,
         final SearchShardIterator... shards
     ) {
 
@@ -166,6 +172,14 @@ private AbstractSearchAsyncAction<SearchPhaseResult> createAction(
             return null;
         };
 
+        TaskResourceInfo taskResourceInfo = new TaskResourceInfo.Builder().setTaskResourceUsage(resourceUsage)
+            .setTaskId(randomLong())
+            .setParentTaskId(randomLong())
+            .setAction(randomAlphaOfLengthBetween(1, 5))
+            .setNodeId(randomAlphaOfLengthBetween(1, 5))
+            .build();
+        threadPool.getThreadContext().addResponseHeader(TASK_RESOURCE_USAGE, taskResourceInfo.toString());
+
         return new AbstractSearchAsyncAction<SearchPhaseResult>(
             "test",
             logger,
@@ -186,7 +200,8 @@ private AbstractSearchAsyncAction<SearchPhaseResult> createAction(
             SearchResponse.Clusters.EMPTY,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(assertingListener), LogManager.getLogger()),
-                request
+                request,
+                () -> null
             ),
             NoopTracer.INSTANCE
         ) {
@@ -248,7 +263,8 @@ private void runTestTook(final boolean controlled) {
             new ArraySearchPhaseResults<>(10),
             null,
             controlled,
-            expected
+            expected,
+            new TaskResourceUsage(0, 0)
         );
         final long actual = action.buildTookInMillis();
         if (controlled) {
@@ -268,7 +284,8 @@ public void testBuildShardSearchTransportRequest() {
             new ArraySearchPhaseResults<>(10),
             null,
             false,
-            expected
+            expected,
+            new TaskResourceUsage(randomLong(), randomLong())
         );
         String clusterAlias = randomBoolean() ? null : randomAlphaOfLengthBetween(5, 10);
         SearchShardIterator iterator = new SearchShardIterator(
@@ -291,19 +308,39 @@ public void testBuildShardSearchTransportRequest() {
     public void testBuildSearchResponse() {
         SearchRequest searchRequest = new SearchRequest().allowPartialSearchResults(randomBoolean());
         ArraySearchPhaseResults<SearchPhaseResult> phaseResults = new ArraySearchPhaseResults<>(10);
-        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(searchRequest, phaseResults, null, false, new AtomicLong());
+        TaskResourceUsage taskResourceUsage = new TaskResourceUsage(randomLong(), randomLong());
+        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(
+            searchRequest,
+            phaseResults,
+            null,
+            false,
+            new AtomicLong(),
+            taskResourceUsage
+        );
         InternalSearchResponse internalSearchResponse = InternalSearchResponse.empty();
         SearchResponse searchResponse = action.buildSearchResponse(internalSearchResponse, action.buildShardFailures(), null, null);
         assertSame(searchResponse.getAggregations(), internalSearchResponse.aggregations());
         assertSame(searchResponse.getSuggest(), internalSearchResponse.suggest());
         assertSame(searchResponse.getProfileResults(), internalSearchResponse.profile());
         assertSame(searchResponse.getHits(), internalSearchResponse.hits());
+        List<String> resourceUsages = threadPool.getThreadContext().getResponseHeaders().get(TASK_RESOURCE_USAGE);
+        assertNotNull(resourceUsages);
+        assertEquals(1, resourceUsages.size());
+        assertTrue(resourceUsages.get(0).contains(Long.toString(taskResourceUsage.getCpuTimeInNanos())));
+        assertTrue(resourceUsages.get(0).contains(Long.toString(taskResourceUsage.getMemoryInBytes())));
     }
 
     public void testBuildSearchResponseAllowPartialFailures() {
         SearchRequest searchRequest = new SearchRequest().allowPartialSearchResults(true);
         final ArraySearchPhaseResults<SearchPhaseResult> queryResult = new ArraySearchPhaseResults<>(10);
-        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(searchRequest, queryResult, null, false, new AtomicLong());
+        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(
+            searchRequest,
+            queryResult,
+            null,
+            false,
+            new AtomicLong(),
+            new TaskResourceUsage(randomLong(), randomLong())
+        );
         action.onShardFailure(
             0,
             new SearchShardTarget("node", new ShardId("index", "index-uuid", 0), null, OriginalIndices.NONE),
@@ -325,7 +362,14 @@ public void testSendSearchResponseDisallowPartialFailures() {
         List<Tuple<String, String>> nodeLookups = new ArrayList<>();
         int numFailures = randomIntBetween(1, 5);
         ArraySearchPhaseResults<SearchPhaseResult> phaseResults = phaseResults(requestIds, nodeLookups, numFailures);
-        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(searchRequest, phaseResults, listener, false, new AtomicLong());
+        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(
+            searchRequest,
+            phaseResults,
+            listener,
+            false,
+            new AtomicLong(),
+            new TaskResourceUsage(randomLong(), randomLong())
+        );
         for (int i = 0; i < numFailures; i++) {
             ShardId failureShardId = new ShardId("index", "index-uuid", i);
             String failureClusterAlias = randomBoolean() ? null : randomAlphaOfLengthBetween(5, 10);
@@ -404,7 +448,14 @@ public void testOnPhaseFailure() {
         Set<ShardSearchContextId> requestIds = new HashSet<>();
         List<Tuple<String, String>> nodeLookups = new ArrayList<>();
         ArraySearchPhaseResults<SearchPhaseResult> phaseResults = phaseResults(requestIds, nodeLookups, 0);
-        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(searchRequest, phaseResults, listener, false, new AtomicLong());
+        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(
+            searchRequest,
+            phaseResults,
+            listener,
+            false,
+            new AtomicLong(),
+            new TaskResourceUsage(randomLong(), randomLong())
+        );
 
         action.onPhaseFailure(new SearchPhase("test") {
             @Override
@@ -428,7 +479,14 @@ public void testShardNotAvailableWithDisallowPartialFailures() {
         ActionListener<SearchResponse> listener = ActionListener.wrap(response -> fail("onResponse should not be called"), exception::set);
         int numShards = randomIntBetween(2, 10);
         ArraySearchPhaseResults<SearchPhaseResult> phaseResults = new ArraySearchPhaseResults<>(numShards);
-        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(searchRequest, phaseResults, listener, false, new AtomicLong());
+        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(
+            searchRequest,
+            phaseResults,
+            listener,
+            false,
+            new AtomicLong(),
+            new TaskResourceUsage(randomLong(), randomLong())
+        );
         // skip one to avoid the "all shards failed" failure.
         SearchShardIterator skipIterator = new SearchShardIterator(null, null, Collections.emptyList(), null);
         skipIterator.resetAndSkip();
@@ -450,7 +508,14 @@ public void testShardNotAvailableWithIgnoreUnavailable() {
         ActionListener<SearchResponse> listener = ActionListener.wrap(response -> {}, exception::set);
         int numShards = randomIntBetween(2, 10);
         ArraySearchPhaseResults<SearchPhaseResult> phaseResults = new ArraySearchPhaseResults<>(numShards);
-        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(searchRequest, phaseResults, listener, false, new AtomicLong());
+        AbstractSearchAsyncAction<SearchPhaseResult> action = createAction(
+            searchRequest,
+            phaseResults,
+            listener,
+            false,
+            new AtomicLong(),
+            new TaskResourceUsage(randomLong(), randomLong())
+        );
         // skip one to avoid the "all shards failed" failure.
         SearchShardIterator skipIterator = new SearchShardIterator(null, null, Collections.emptyList(), null);
         skipIterator.resetAndSkip();
@@ -521,6 +586,7 @@ public void onFailure(Exception e) {
             true,
             false,
             new AtomicLong(),
+            new TaskResourceUsage(randomLong(), randomLong()),
             shards
         );
         action.run();
@@ -568,6 +634,7 @@ public void onFailure(Exception e) {
             false,
             false,
             new AtomicLong(),
+            new TaskResourceUsage(randomLong(), randomLong()),
             shards
         );
         action.run();
@@ -620,6 +687,7 @@ public void onFailure(Exception e) {
             false,
             catchExceptionWhenExecutePhaseOnShard,
             new AtomicLong(),
+            new TaskResourceUsage(randomLong(), randomLong()),
             shards
         );
         action.run();
@@ -771,7 +839,8 @@ private SearchDfsQueryThenFetchAsyncAction createSearchDfsQueryThenFetchAsyncAct
             SearchResponse.Clusters.EMPTY,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(searchRequestOperationsListeners, logger),
-                searchRequest
+                searchRequest,
+                () -> null
             ),
             NoopTracer.INSTANCE
         );
@@ -825,7 +894,8 @@ private SearchQueryThenFetchAsyncAction createSearchQueryThenFetchAsyncAction(
             SearchResponse.Clusters.EMPTY,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(searchRequestOperationsListeners, logger),
-                searchRequest
+                searchRequest,
+                () -> null
             ),
             NoopTracer.INSTANCE
         ) {
diff --git a/server/src/test/java/org/opensearch/action/search/CanMatchPreFilterSearchPhaseTests.java b/server/src/test/java/org/opensearch/action/search/CanMatchPreFilterSearchPhaseTests.java
index 1881c705fe6b3..bb51aeaeee9dd 100644
--- a/server/src/test/java/org/opensearch/action/search/CanMatchPreFilterSearchPhaseTests.java
+++ b/server/src/test/java/org/opensearch/action/search/CanMatchPreFilterSearchPhaseTests.java
@@ -170,7 +170,7 @@ public void run() throws IOException {
                 }
             },
             SearchResponse.Clusters.EMPTY,
-            new SearchRequestContext(searchRequestOperationsListener, searchRequest),
+            new SearchRequestContext(searchRequestOperationsListener, searchRequest, () -> null),
             NoopTracer.INSTANCE
         );
 
@@ -268,7 +268,7 @@ public void run() throws IOException {
                 }
             },
             SearchResponse.Clusters.EMPTY,
-            new SearchRequestContext(searchRequestOperationsListener, searchRequest),
+            new SearchRequestContext(searchRequestOperationsListener, searchRequest, () -> null),
             NoopTracer.INSTANCE
         );
 
@@ -366,7 +366,7 @@ public void sendCanMatch(
                         new ArraySearchPhaseResults<>(iter.size()),
                         randomIntBetween(1, 32),
                         SearchResponse.Clusters.EMPTY,
-                        new SearchRequestContext(searchRequestOperationsListener, searchRequest),
+                        new SearchRequestContext(searchRequestOperationsListener, searchRequest, () -> null),
                         NoopTracer.INSTANCE
                     ) {
                         @Override
@@ -396,7 +396,7 @@ protected void executePhaseOnShard(
                 );
             },
             SearchResponse.Clusters.EMPTY,
-            new SearchRequestContext(searchRequestOperationsListener, searchRequest),
+            new SearchRequestContext(searchRequestOperationsListener, searchRequest, () -> null),
             NoopTracer.INSTANCE
         );
 
@@ -488,7 +488,7 @@ public void run() {
                     }
                 },
                 SearchResponse.Clusters.EMPTY,
-                new SearchRequestContext(searchRequestOperationsListener, searchRequest),
+                new SearchRequestContext(searchRequestOperationsListener, searchRequest, () -> null),
                 NoopTracer.INSTANCE
             );
 
@@ -595,7 +595,7 @@ public void run() {
                     }
                 },
                 SearchResponse.Clusters.EMPTY,
-                new SearchRequestContext(searchRequestOperationsListener, searchRequest),
+                new SearchRequestContext(searchRequestOperationsListener, searchRequest, () -> null),
                 NoopTracer.INSTANCE
             );
 
@@ -658,7 +658,8 @@ public void sendCanMatch(
         ExecutorService executor = OpenSearchExecutors.newDirectExecutorService();
         SearchRequestContext searchRequestContext = new SearchRequestContext(
             new SearchRequestOperationsListener.CompositeListener(List.of(assertingListener), LogManager.getLogger()),
-            searchRequest
+            searchRequest,
+            () -> null
         );
 
         SearchPhaseController controller = new SearchPhaseController(
diff --git a/server/src/test/java/org/opensearch/action/search/MockSearchPhaseContext.java b/server/src/test/java/org/opensearch/action/search/MockSearchPhaseContext.java
index cc10da8fc1f12..2f3e462f741b8 100644
--- a/server/src/test/java/org/opensearch/action/search/MockSearchPhaseContext.java
+++ b/server/src/test/java/org/opensearch/action/search/MockSearchPhaseContext.java
@@ -182,6 +182,14 @@ public void addReleasable(Releasable releasable) {
         // Noop
     }
 
+    /**
+     * Set the resource usage info for this phase
+     */
+    @Override
+    public void setPhaseResourceUsages() {
+        // Noop
+    }
+
     @Override
     public void execute(Runnable command) {
         command.run();
diff --git a/server/src/test/java/org/opensearch/action/search/PitTestsUtil.java b/server/src/test/java/org/opensearch/action/search/PitTestsUtil.java
index d80e011c04332..6571bdd8a3431 100644
--- a/server/src/test/java/org/opensearch/action/search/PitTestsUtil.java
+++ b/server/src/test/java/org/opensearch/action/search/PitTestsUtil.java
@@ -17,6 +17,7 @@
 import org.opensearch.client.Client;
 import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.common.action.ActionFuture;
+import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.AtomicArray;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.query.IdsQueryBuilder;
@@ -97,7 +98,8 @@ public static String getPitId() {
         return SearchContextId.encode(array.asList(), aliasFilters, version);
     }
 
-    public static void assertUsingGetAllPits(Client client, String id, long creationTime) throws ExecutionException, InterruptedException {
+    public static void assertUsingGetAllPits(Client client, String id, long creationTime, TimeValue keepAlive) throws ExecutionException,
+        InterruptedException {
         final ClusterStateRequest clusterStateRequest = new ClusterStateRequest();
         clusterStateRequest.local(false);
         clusterStateRequest.clear().nodes(true).routingTable(true).indices("*");
@@ -113,6 +115,7 @@ public static void assertUsingGetAllPits(Client client, String id, long creation
         GetAllPitNodesResponse getPitResponse = execute1.get();
         assertTrue(getPitResponse.getPitInfos().get(0).getPitId().contains(id));
         Assert.assertEquals(getPitResponse.getPitInfos().get(0).getCreationTime(), creationTime);
+        Assert.assertEquals(getPitResponse.getPitInfos().get(0).getKeepAlive(), keepAlive.getMillis());
     }
 
     public static void assertGetAllPitsEmpty(Client client) throws ExecutionException, InterruptedException {
diff --git a/server/src/test/java/org/opensearch/action/search/SearchAsyncActionTests.java b/server/src/test/java/org/opensearch/action/search/SearchAsyncActionTests.java
index 35e90ff662b19..8fe2d9af217d5 100644
--- a/server/src/test/java/org/opensearch/action/search/SearchAsyncActionTests.java
+++ b/server/src/test/java/org/opensearch/action/search/SearchAsyncActionTests.java
@@ -162,7 +162,7 @@ public void testSkipSearchShards() throws InterruptedException {
             new ArraySearchPhaseResults<>(shardsIter.size()),
             request.getMaxConcurrentShardRequests(),
             SearchResponse.Clusters.EMPTY,
-            new SearchRequestContext(searchRequestOperationsListener, request),
+            new SearchRequestContext(searchRequestOperationsListener, request, () -> null),
             NoopTracer.INSTANCE
         ) {
 
@@ -287,7 +287,7 @@ public void testLimitConcurrentShardRequests() throws InterruptedException {
             new ArraySearchPhaseResults<>(shardsIter.size()),
             request.getMaxConcurrentShardRequests(),
             SearchResponse.Clusters.EMPTY,
-            new SearchRequestContext(searchRequestOperationsListener, request),
+            new SearchRequestContext(searchRequestOperationsListener, request, () -> null),
             NoopTracer.INSTANCE
         ) {
 
@@ -409,7 +409,8 @@ public void sendFreeContext(Transport.Connection connection, ShardSearchContextI
             SearchResponse.Clusters.EMPTY,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(assertingListener), LogManager.getLogger()),
-                request
+                request,
+                () -> null
             ),
             NoopTracer.INSTANCE
         ) {
@@ -537,7 +538,8 @@ public void sendFreeContext(Transport.Connection connection, ShardSearchContextI
             SearchResponse.Clusters.EMPTY,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(assertingListener), LogManager.getLogger()),
-                request
+                request,
+                () -> null
             ),
             NoopTracer.INSTANCE
         ) {
@@ -657,7 +659,7 @@ public void testAllowPartialResults() throws InterruptedException {
             new ArraySearchPhaseResults<>(shardsIter.size()),
             request.getMaxConcurrentShardRequests(),
             SearchResponse.Clusters.EMPTY,
-            new SearchRequestContext(searchRequestOperationsListener, request),
+            new SearchRequestContext(searchRequestOperationsListener, request, () -> null),
             NoopTracer.INSTANCE
         ) {
             @Override
diff --git a/server/src/test/java/org/opensearch/action/search/SearchQueryCategorizerTests.java b/server/src/test/java/org/opensearch/action/search/SearchQueryCategorizerTests.java
deleted file mode 100644
index 4878a463729f9..0000000000000
--- a/server/src/test/java/org/opensearch/action/search/SearchQueryCategorizerTests.java
+++ /dev/null
@@ -1,245 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.action.search;
-
-import org.opensearch.index.query.BoolQueryBuilder;
-import org.opensearch.index.query.BoostingQueryBuilder;
-import org.opensearch.index.query.MatchNoneQueryBuilder;
-import org.opensearch.index.query.MatchQueryBuilder;
-import org.opensearch.index.query.MultiMatchQueryBuilder;
-import org.opensearch.index.query.QueryBuilders;
-import org.opensearch.index.query.QueryStringQueryBuilder;
-import org.opensearch.index.query.RangeQueryBuilder;
-import org.opensearch.index.query.RegexpQueryBuilder;
-import org.opensearch.index.query.TermQueryBuilder;
-import org.opensearch.index.query.WildcardQueryBuilder;
-import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder;
-import org.opensearch.search.aggregations.bucket.range.RangeAggregationBuilder;
-import org.opensearch.search.aggregations.bucket.terms.MultiTermsAggregationBuilder;
-import org.opensearch.search.aggregations.support.MultiTermsValuesSourceConfig;
-import org.opensearch.search.builder.SearchSourceBuilder;
-import org.opensearch.search.sort.ScoreSortBuilder;
-import org.opensearch.search.sort.SortOrder;
-import org.opensearch.telemetry.metrics.Counter;
-import org.opensearch.telemetry.metrics.MetricsRegistry;
-import org.opensearch.telemetry.metrics.tags.Tags;
-import org.opensearch.test.OpenSearchTestCase;
-import org.junit.Before;
-
-import java.util.Arrays;
-
-import org.mockito.ArgumentCaptor;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-public final class SearchQueryCategorizerTests extends OpenSearchTestCase {
-
-    private static final String MULTI_TERMS_AGGREGATION = "multi_terms";
-
-    private MetricsRegistry metricsRegistry;
-
-    private SearchQueryCategorizer searchQueryCategorizer;
-
-    @Before
-    public void setup() {
-        metricsRegistry = mock(MetricsRegistry.class);
-        when(metricsRegistry.createCounter(any(String.class), any(String.class), any(String.class))).thenAnswer(
-            invocation -> mock(Counter.class)
-        );
-        searchQueryCategorizer = new SearchQueryCategorizer(metricsRegistry);
-    }
-
-    public void testAggregationsQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.aggregation(
-            new MultiTermsAggregationBuilder("agg1").terms(
-                Arrays.asList(
-                    new MultiTermsValuesSourceConfig.Builder().setFieldName("username").build(),
-                    new MultiTermsValuesSourceConfig.Builder().setFieldName("rating").build()
-                )
-            )
-        );
-        sourceBuilder.size(0);
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.aggCounter).add(eq(1.0d), any(Tags.class));
-
-        // capture the arguments passed to the aggCounter.add method
-        ArgumentCaptor<Double> valueCaptor = ArgumentCaptor.forClass(Double.class);
-        ArgumentCaptor<Tags> tagsCaptor = ArgumentCaptor.forClass(Tags.class);
-
-        // Verify that aggCounter.add was called with the expected arguments
-        verify(searchQueryCategorizer.searchQueryCounters.aggCounter).add(valueCaptor.capture(), tagsCaptor.capture());
-
-        double actualValue = valueCaptor.getValue();
-        String actualTag = (String) tagsCaptor.getValue().getTagsMap().get("type");
-
-        assertEquals(1.0d, actualValue, 0.0001);
-        assertEquals(MULTI_TERMS_AGGREGATION, actualTag);
-    }
-
-    public void testBoolQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        sourceBuilder.query(new BoolQueryBuilder().must(new MatchQueryBuilder("searchText", "fox")));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("bool")).add(eq(1.0d), any(Tags.class));
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("match")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testFunctionScoreQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        sourceBuilder.query(new FunctionScoreQueryBuilder(QueryBuilders.prefixQuery("text", "bro")));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("function_score")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testMatchQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        sourceBuilder.query(QueryBuilders.matchQuery("tags", "php"));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("match")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testMatchPhraseQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        sourceBuilder.query(QueryBuilders.matchPhraseQuery("tags", "php"));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("match_phrase")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testMultiMatchQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        sourceBuilder.query(new MultiMatchQueryBuilder("foo bar", "myField"));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("multi_match")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testOtherQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        BoostingQueryBuilder queryBuilder = new BoostingQueryBuilder(
-            new TermQueryBuilder("unmapped_field", "foo"),
-            new MatchNoneQueryBuilder()
-        );
-        sourceBuilder.query(queryBuilder);
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("boosting")).add(eq(1.0d), any(Tags.class));
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("match_none")).add(eq(1.0d), any(Tags.class));
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("term")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testQueryStringQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        QueryStringQueryBuilder queryBuilder = new QueryStringQueryBuilder("foo:*");
-        sourceBuilder.query(queryBuilder);
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("query_string")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testRangeQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        RangeQueryBuilder rangeQuery = new RangeQueryBuilder("date");
-        rangeQuery.gte("1970-01-01");
-        rangeQuery.lt("1982-01-01");
-        sourceBuilder.query(rangeQuery);
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("range")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testRegexQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.query(new RegexpQueryBuilder("field", "text"));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("regexp")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testSortQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.query(QueryBuilders.matchQuery("tags", "ruby"));
-        sourceBuilder.sort("creationDate", SortOrder.DESC);
-        sourceBuilder.sort(new ScoreSortBuilder());
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("match")).add(eq(1.0d), any(Tags.class));
-        verify(searchQueryCategorizer.searchQueryCounters.sortCounter, times(2)).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testTermQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        sourceBuilder.query(QueryBuilders.termQuery("field", "value2"));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("term")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testWildcardQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-        sourceBuilder.query(new WildcardQueryBuilder("field", "text"));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("wildcard")).add(eq(1.0d), any(Tags.class));
-    }
-
-    public void testComplexQuery() {
-        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
-        sourceBuilder.size(50);
-
-        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("field", "value2");
-        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("tags", "php");
-        RegexpQueryBuilder regexpQueryBuilder = new RegexpQueryBuilder("field", "text");
-        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder().must(termQueryBuilder)
-            .filter(matchQueryBuilder)
-            .should(regexpQueryBuilder);
-        sourceBuilder.query(boolQueryBuilder);
-        sourceBuilder.aggregation(new RangeAggregationBuilder("agg1").field("num"));
-
-        searchQueryCategorizer.categorize(sourceBuilder);
-
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("term")).add(eq(1.0d), any(Tags.class));
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("match")).add(eq(1.0d), any(Tags.class));
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("regexp")).add(eq(1.0d), any(Tags.class));
-        verify(searchQueryCategorizer.searchQueryCounters.nameToQueryTypeCounters.get("bool")).add(eq(1.0d), any(Tags.class));
-        verify(searchQueryCategorizer.searchQueryCounters.aggCounter).add(eq(1.0d), any(Tags.class));
-    }
-}
diff --git a/server/src/test/java/org/opensearch/action/search/SearchQueryThenFetchAsyncActionTests.java b/server/src/test/java/org/opensearch/action/search/SearchQueryThenFetchAsyncActionTests.java
index aefbbe80d5fa1..f6a06a51c7b43 100644
--- a/server/src/test/java/org/opensearch/action/search/SearchQueryThenFetchAsyncActionTests.java
+++ b/server/src/test/java/org/opensearch/action/search/SearchQueryThenFetchAsyncActionTests.java
@@ -240,7 +240,8 @@ public void sendExecuteQuery(
             SearchResponse.Clusters.EMPTY,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(assertingListener), LogManager.getLogger()),
-                searchRequest
+                searchRequest,
+                () -> null
             ),
             NoopTracer.INSTANCE
         ) {
diff --git a/server/src/test/java/org/opensearch/action/search/SearchRequestOperationsListenerSupport.java b/server/src/test/java/org/opensearch/action/search/SearchRequestOperationsListenerSupport.java
index 0f737e00478cb..fdac91a0e3124 100644
--- a/server/src/test/java/org/opensearch/action/search/SearchRequestOperationsListenerSupport.java
+++ b/server/src/test/java/org/opensearch/action/search/SearchRequestOperationsListenerSupport.java
@@ -25,7 +25,8 @@ default void onPhaseEnd(SearchRequestOperationsListener listener, SearchPhaseCon
             context,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
     }
diff --git a/server/src/test/java/org/opensearch/action/search/SearchRequestSlowLogTests.java b/server/src/test/java/org/opensearch/action/search/SearchRequestSlowLogTests.java
index f009988ffae17..453fc6cd8a74c 100644
--- a/server/src/test/java/org/opensearch/action/search/SearchRequestSlowLogTests.java
+++ b/server/src/test/java/org/opensearch/action/search/SearchRequestSlowLogTests.java
@@ -45,6 +45,7 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.search.builder.SearchSourceBuilder;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
@@ -90,7 +91,7 @@ public void testMultipleSlowLoggersUseSingleLog4jLogger() {
         LoggerContext context = (LoggerContext) LogManager.getContext(false);
 
         SearchPhaseContext searchPhaseContext1 = new MockSearchPhaseContext(1);
-        ClusterService clusterService1 = new ClusterService(
+        ClusterService clusterService1 = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             null
@@ -99,7 +100,7 @@ public void testMultipleSlowLoggersUseSingleLog4jLogger() {
         int numberOfLoggersBefore = context.getLoggers().size();
 
         SearchPhaseContext searchPhaseContext2 = new MockSearchPhaseContext(1);
-        ClusterService clusterService2 = new ClusterService(
+        ClusterService clusterService2 = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             null
@@ -124,7 +125,7 @@ public void testOnRequestEnd() throws InterruptedException {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_THRESHOLD_TRACE_SETTING.getKey(), "0ms");
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
         SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService, logger);
         final List<SearchRequestOperationsListener> searchListenersList = new ArrayList<>(List.of(searchRequestSlowLog));
 
@@ -157,7 +158,7 @@ public void testConcurrentOnRequestEnd() throws InterruptedException {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_THRESHOLD_TRACE_SETTING.getKey(), "-1");
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
         SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService, logger);
         final List<SearchRequestOperationsListener> searchListenersList = new ArrayList<>(List.of(searchRequestSlowLog));
 
@@ -177,7 +178,8 @@ public void testConcurrentOnRequestEnd() throws InterruptedException {
         for (int i = 0; i < numRequests; i++) {
             SearchRequestContext searchRequestContext = new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(searchListenersList, logger),
-                searchRequest
+                searchRequest,
+                () -> null
             );
             searchRequestContext.setAbsoluteStartNanos((i < numRequestsLogged) ? 0 : System.nanoTime());
             searchRequestContexts.add(searchRequestContext);
@@ -208,7 +210,8 @@ public void testSearchRequestSlowLogHasJsonFields_EmptySearchRequestContext() th
         SearchPhaseContext searchPhaseContext = new MockSearchPhaseContext(1, searchRequest);
         SearchRequestContext searchRequestContext = new SearchRequestContext(
             new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-            searchRequest
+            searchRequest,
+            () -> null
         );
         SearchRequestSlowLog.SearchRequestSlowLogMessage p = new SearchRequestSlowLog.SearchRequestSlowLogMessage(
             searchPhaseContext,
@@ -232,7 +235,8 @@ public void testSearchRequestSlowLogHasJsonFields_NotEmptySearchRequestContext()
         SearchPhaseContext searchPhaseContext = new MockSearchPhaseContext(1, searchRequest);
         SearchRequestContext searchRequestContext = new SearchRequestContext(
             new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-            searchRequest
+            searchRequest,
+            () -> null
         );
         searchRequestContext.updatePhaseTookMap(SearchPhaseName.FETCH.getName(), 10L);
         searchRequestContext.updatePhaseTookMap(SearchPhaseName.QUERY.getName(), 50L);
@@ -261,7 +265,8 @@ public void testSearchRequestSlowLogHasJsonFields_PartialContext() throws IOExce
         SearchPhaseContext searchPhaseContext = new MockSearchPhaseContext(1, searchRequest);
         SearchRequestContext searchRequestContext = new SearchRequestContext(
             new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-            searchRequest
+            searchRequest,
+            () -> null
         );
         searchRequestContext.updatePhaseTookMap(SearchPhaseName.FETCH.getName(), 10L);
         searchRequestContext.updatePhaseTookMap(SearchPhaseName.QUERY.getName(), 50L);
@@ -290,7 +295,8 @@ public void testSearchRequestSlowLogSearchContextPrinterToLog() throws IOExcepti
         SearchPhaseContext searchPhaseContext = new MockSearchPhaseContext(1, searchRequest);
         SearchRequestContext searchRequestContext = new SearchRequestContext(
             new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-            searchRequest
+            searchRequest,
+            () -> null
         );
         searchRequestContext.updatePhaseTookMap(SearchPhaseName.FETCH.getName(), 10L);
         searchRequestContext.updatePhaseTookMap(SearchPhaseName.QUERY.getName(), 50L);
@@ -321,7 +327,7 @@ public void testLevelSettingWarn() {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_LEVEL.getKey(), level);
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
         SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService);
         assertEquals(level, searchRequestSlowLog.getLevel());
     }
@@ -332,7 +338,7 @@ public void testLevelSettingDebug() {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_LEVEL.getKey(), level);
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
         SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService);
         assertEquals(level, searchRequestSlowLog.getLevel().toString());
     }
@@ -343,7 +349,7 @@ public void testLevelSettingFail() {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_LEVEL.getKey(), level);
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
 
         try {
             new SearchRequestSlowLog(clusterService);
@@ -363,7 +369,7 @@ public void testSetThresholds() {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_THRESHOLD_TRACE_SETTING.getKey(), "100ms");
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
         SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService);
         assertEquals(TimeValue.timeValueMillis(400).nanos(), searchRequestSlowLog.getWarnThreshold());
         assertEquals(TimeValue.timeValueMillis(300).nanos(), searchRequestSlowLog.getInfoThreshold());
@@ -380,7 +386,7 @@ public void testSetThresholdsUnits() {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_THRESHOLD_TRACE_SETTING.getKey(), "100nanos");
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
         SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService);
         assertEquals(TimeValue.timeValueSeconds(400).nanos(), searchRequestSlowLog.getWarnThreshold());
         assertEquals(TimeValue.timeValueMillis(300).nanos(), searchRequestSlowLog.getInfoThreshold());
@@ -395,7 +401,7 @@ public void testSetThresholdsDefaults() {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_THRESHOLD_DEBUG_SETTING.getKey(), "200ms");
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
         SearchRequestSlowLog searchRequestSlowLog = new SearchRequestSlowLog(clusterService);
         assertEquals(TimeValue.timeValueMillis(400).nanos(), searchRequestSlowLog.getWarnThreshold());
         assertEquals(TimeValue.timeValueMillis(-1).nanos(), searchRequestSlowLog.getInfoThreshold());
@@ -409,7 +415,7 @@ public void testSetThresholdsError() {
         settingsBuilder.put(SearchRequestSlowLog.CLUSTER_SEARCH_REQUEST_SLOWLOG_THRESHOLD_WARN_SETTING.getKey(), "NOT A TIME VALUE");
         Settings settings = settingsBuilder.build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
 
         try {
             new SearchRequestSlowLog(clusterService);
diff --git a/server/src/test/java/org/opensearch/action/search/SearchRequestStatsTests.java b/server/src/test/java/org/opensearch/action/search/SearchRequestStatsTests.java
index fb9b26e3f3ad1..3bad3ec3e7d21 100644
--- a/server/src/test/java/org/opensearch/action/search/SearchRequestStatsTests.java
+++ b/server/src/test/java/org/opensearch/action/search/SearchRequestStatsTests.java
@@ -25,6 +25,41 @@
 import static org.mockito.Mockito.when;
 
 public class SearchRequestStatsTests extends OpenSearchTestCase {
+    public void testSearchRequestStats_OnRequestFailure() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        SearchRequestStats testRequestStats = new SearchRequestStats(clusterSettings);
+        SearchPhaseContext mockSearchPhaseContext = mock(SearchPhaseContext.class);
+        SearchRequestContext mockSearchRequestContext = mock(SearchRequestContext.class);
+
+        testRequestStats.onRequestStart(mockSearchRequestContext);
+        assertEquals(1, testRequestStats.getTookCurrent());
+        testRequestStats.onRequestFailure(mockSearchPhaseContext, mockSearchRequestContext);
+        assertEquals(0, testRequestStats.getTookCurrent());
+        assertEquals(0, testRequestStats.getTookTotal());
+    }
+
+    public void testSearchRequestStats_OnRequestEnd() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        SearchRequestStats testRequestStats = new SearchRequestStats(clusterSettings);
+        SearchPhaseContext mockSearchPhaseContext = mock(SearchPhaseContext.class);
+        SearchRequestContext mockSearchRequestContext = mock(SearchRequestContext.class);
+
+        // Start request
+        testRequestStats.onRequestStart(mockSearchRequestContext);
+        assertEquals(1, testRequestStats.getTookCurrent());
+
+        // Mock start time
+        long tookTimeInMillis = randomIntBetween(1, 10);
+        long startTimeInNanos = System.nanoTime() - TimeUnit.MILLISECONDS.toNanos(tookTimeInMillis);
+        when(mockSearchRequestContext.getAbsoluteStartNanos()).thenReturn(startTimeInNanos);
+
+        // End request
+        testRequestStats.onRequestEnd(mockSearchPhaseContext, mockSearchRequestContext);
+        assertEquals(0, testRequestStats.getTookCurrent());
+        assertEquals(1, testRequestStats.getTookTotal());
+        assertThat(testRequestStats.getTookMetric(), greaterThanOrEqualTo(tookTimeInMillis));
+    }
+
     public void testSearchRequestPhaseFailure() {
         ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
         SearchRequestStats testRequestStats = new SearchRequestStats(clusterSettings);
@@ -60,7 +95,8 @@ public void testSearchRequestStats() {
                 ctx,
                 new SearchRequestContext(
                     new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                    new SearchRequest()
+                    new SearchRequest(),
+                    () -> null
                 )
             );
             assertEquals(0, testRequestStats.getPhaseCurrent(searchPhaseName));
@@ -120,7 +156,8 @@ public void testSearchRequestStatsOnPhaseEndConcurrently() throws InterruptedExc
                         ctx,
                         new SearchRequestContext(
                             new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                            new SearchRequest()
+                            new SearchRequest(),
+                            () -> null
                         )
                     );
                     countDownLatch.countDown();
diff --git a/server/src/test/java/org/opensearch/action/search/SearchResponseMergerTests.java b/server/src/test/java/org/opensearch/action/search/SearchResponseMergerTests.java
index ce4d5ca4f7091..0eefa413c1864 100644
--- a/server/src/test/java/org/opensearch/action/search/SearchResponseMergerTests.java
+++ b/server/src/test/java/org/opensearch/action/search/SearchResponseMergerTests.java
@@ -137,7 +137,8 @@ public void testMergeTookInMillis() throws InterruptedException {
             SearchResponse.Clusters.EMPTY,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertEquals(TimeUnit.NANOSECONDS.toMillis(currentRelativeTime), searchResponse.getTook().millis());
@@ -195,7 +196,8 @@ public void testMergeShardFailures() throws InterruptedException {
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertSame(clusters, mergedResponse.getClusters());
@@ -252,7 +254,8 @@ public void testMergeShardFailuresNullShardTarget() throws InterruptedException
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertSame(clusters, mergedResponse.getClusters());
@@ -304,7 +307,8 @@ public void testMergeShardFailuresNullShardId() throws InterruptedException {
             SearchResponse.Clusters.EMPTY,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         ).getShardFailures();
         assertThat(Arrays.asList(shardFailures), containsInAnyOrder(expectedFailures.toArray(ShardSearchFailure.EMPTY_ARRAY)));
@@ -344,7 +348,8 @@ public void testMergeProfileResults() throws InterruptedException {
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertSame(clusters, mergedResponse.getClusters());
@@ -412,7 +417,8 @@ public void testMergeCompletionSuggestions() throws InterruptedException {
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertSame(clusters, mergedResponse.getClusters());
@@ -490,7 +496,8 @@ public void testMergeCompletionSuggestionsTieBreak() throws InterruptedException
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertSame(clusters, mergedResponse.getClusters());
@@ -570,7 +577,8 @@ public void testMergeAggs() throws InterruptedException {
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertSame(clusters, mergedResponse.getClusters());
@@ -733,7 +741,8 @@ public void testMergeSearchHits() throws InterruptedException {
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
 
@@ -799,7 +808,8 @@ public void testMergeNoResponsesAdded() {
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertSame(clusters, response.getClusters());
@@ -878,7 +888,8 @@ public void testMergeEmptySearchHitsWithNonEmpty() {
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertEquals(10, mergedResponse.getHits().getTotalHits().value);
@@ -926,7 +937,8 @@ public void testMergeOnlyEmptyHits() {
             clusters,
             new SearchRequestContext(
                 new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                new SearchRequest()
+                new SearchRequest(),
+                () -> null
             )
         );
         assertEquals(expectedTotalHits, mergedResponse.getHits().getTotalHits());
diff --git a/server/src/test/java/org/opensearch/action/search/TransportSearchActionTests.java b/server/src/test/java/org/opensearch/action/search/TransportSearchActionTests.java
index da19c839f3826..84955d01a59ce 100644
--- a/server/src/test/java/org/opensearch/action/search/TransportSearchActionTests.java
+++ b/server/src/test/java/org/opensearch/action/search/TransportSearchActionTests.java
@@ -487,7 +487,8 @@ public void testCCSRemoteReduceMergeFails() throws Exception {
                 (r, l) -> setOnce.set(Tuple.tuple(r, l)),
                 new SearchRequestContext(
                     new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                    searchRequest
+                    searchRequest,
+                    () -> null
                 )
             );
             if (localIndices == null) {
@@ -549,7 +550,8 @@ public void testCCSRemoteReduce() throws Exception {
                     (r, l) -> setOnce.set(Tuple.tuple(r, l)),
                     new SearchRequestContext(
                         new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                        searchRequest
+                        searchRequest,
+                        () -> null
                     )
                 );
                 if (localIndices == null) {
@@ -590,7 +592,8 @@ public void testCCSRemoteReduce() throws Exception {
                     (r, l) -> setOnce.set(Tuple.tuple(r, l)),
                     new SearchRequestContext(
                         new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                        searchRequest
+                        searchRequest,
+                        () -> null
                     )
                 );
                 if (localIndices == null) {
@@ -652,7 +655,8 @@ public void onNodeDisconnected(DiscoveryNode node, Transport.Connection connecti
                     (r, l) -> setOnce.set(Tuple.tuple(r, l)),
                     new SearchRequestContext(
                         new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                        searchRequest
+                        searchRequest,
+                        () -> null
                     )
                 );
                 if (localIndices == null) {
@@ -696,7 +700,8 @@ public void onNodeDisconnected(DiscoveryNode node, Transport.Connection connecti
                     (r, l) -> setOnce.set(Tuple.tuple(r, l)),
                     new SearchRequestContext(
                         new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                        searchRequest
+                        searchRequest,
+                        () -> null
                     )
                 );
                 if (localIndices == null) {
@@ -751,7 +756,8 @@ public void onNodeDisconnected(DiscoveryNode node, Transport.Connection connecti
                     (r, l) -> setOnce.set(Tuple.tuple(r, l)),
                     new SearchRequestContext(
                         new SearchRequestOperationsListener.CompositeListener(List.of(), LogManager.getLogger()),
-                        searchRequest
+                        searchRequest,
+                        () -> null
                     )
                 );
                 if (localIndices == null) {
diff --git a/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java b/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
index 35c5c5e605b4d..3c1c84653b384 100644
--- a/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/clustermanager/TransportClusterManagerNodeActionTests.java
@@ -47,7 +47,6 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsException;
 import org.opensearch.common.unit.TimeValue;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.action.ActionResponse;
@@ -85,9 +84,8 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import static org.opensearch.common.util.FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL;
-import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdaterTests.createIndexMetadataWithDocrepSettings;
 import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdaterTests.createIndexMetadataWithRemoteStoreSettings;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
@@ -718,9 +716,6 @@ protected void masterOperation(Task task, Request request, ClusterState state, A
     }
 
     public void testDontAllowSwitchingToStrictCompatibilityModeForMixedCluster() {
-        Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
-
         // request to change cluster compatibility mode to STRICT
         Settings currentCompatibilityModeSettings = Settings.builder()
             .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), RemoteStoreNodeService.CompatibilityMode.MIXED)
@@ -809,84 +804,7 @@ public void testDontAllowSwitchingToStrictCompatibilityModeForMixedCluster() {
         transportClusterUpdateSettingsAction.validateCompatibilityModeSettingRequest(request, sameTypeClusterState);
     }
 
-    public void testDontAllowSwitchingToStrictCompatibilityModeWithoutRemoteIndexSettings() {
-        Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
-        Settings currentCompatibilityModeSettings = Settings.builder()
-            .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), RemoteStoreNodeService.CompatibilityMode.MIXED)
-            .build();
-        Settings intendedCompatibilityModeSettings = Settings.builder()
-            .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), RemoteStoreNodeService.CompatibilityMode.STRICT)
-            .build();
-        ClusterUpdateSettingsRequest request = new ClusterUpdateSettingsRequest();
-        request.persistentSettings(intendedCompatibilityModeSettings);
-        DiscoveryNode remoteNode1 = new DiscoveryNode(
-            UUIDs.base64UUID(),
-            buildNewFakeTransportAddress(),
-            getRemoteStoreNodeAttributes(),
-            DiscoveryNodeRole.BUILT_IN_ROLES,
-            Version.CURRENT
-        );
-        DiscoveryNode remoteNode2 = new DiscoveryNode(
-            UUIDs.base64UUID(),
-            buildNewFakeTransportAddress(),
-            getRemoteStoreNodeAttributes(),
-            DiscoveryNodeRole.BUILT_IN_ROLES,
-            Version.CURRENT
-        );
-        DiscoveryNodes discoveryNodes = DiscoveryNodes.builder()
-            .add(remoteNode1)
-            .localNodeId(remoteNode1.getId())
-            .add(remoteNode2)
-            .localNodeId(remoteNode2.getId())
-            .build();
-        AllocationService allocationService = new AllocationService(
-            new AllocationDeciders(Collections.singleton(new MaxRetryAllocationDecider())),
-            new TestGatewayAllocator(),
-            new BalancedShardsAllocator(Settings.EMPTY),
-            EmptyClusterInfoService.INSTANCE,
-            EmptySnapshotsInfoService.INSTANCE
-        );
-        TransportClusterUpdateSettingsAction transportClusterUpdateSettingsAction = new TransportClusterUpdateSettingsAction(
-            transportService,
-            clusterService,
-            threadPool,
-            allocationService,
-            new ActionFilters(Collections.emptySet()),
-            new IndexNameExpressionResolver(new ThreadContext(Settings.EMPTY)),
-            clusterService.getClusterSettings()
-        );
-
-        Metadata nonRemoteIndexMd = Metadata.builder(createIndexMetadataWithDocrepSettings("test"))
-            .persistentSettings(currentCompatibilityModeSettings)
-            .build();
-        final ClusterState clusterState = ClusterState.builder(ClusterName.DEFAULT)
-            .metadata(nonRemoteIndexMd)
-            .nodes(discoveryNodes)
-            .build();
-        final SettingsException exception = expectThrows(
-            SettingsException.class,
-            () -> transportClusterUpdateSettingsAction.validateCompatibilityModeSettingRequest(request, clusterState)
-        );
-        assertEquals(
-            "can not switch to STRICT compatibility mode since all indices in the cluster does not have remote store based index settings",
-            exception.getMessage()
-        );
-
-        Metadata remoteIndexMd = Metadata.builder(createIndexMetadataWithRemoteStoreSettings("test"))
-            .persistentSettings(currentCompatibilityModeSettings)
-            .build();
-        ClusterState clusterStateWithRemoteIndices = ClusterState.builder(ClusterName.DEFAULT)
-            .metadata(remoteIndexMd)
-            .nodes(discoveryNodes)
-            .build();
-        transportClusterUpdateSettingsAction.validateCompatibilityModeSettingRequest(request, clusterStateWithRemoteIndices);
-    }
-
     public void testDontAllowSwitchingCompatibilityModeForClusterWithMultipleVersions() {
-        Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
-
         // request to change cluster compatibility mode
         boolean toStrictMode = randomBoolean();
         Settings currentCompatibilityModeSettings = Settings.builder()
@@ -984,9 +902,9 @@ public void testDontAllowSwitchingCompatibilityModeForClusterWithMultipleVersion
 
     private Map<String, String> getRemoteStoreNodeAttributes() {
         Map<String, String> remoteStoreNodeAttributes = new HashMap<>();
+        remoteStoreNodeAttributes.put(REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-cluster-repo-1");
         remoteStoreNodeAttributes.put(REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-segment-repo-1");
         remoteStoreNodeAttributes.put(REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-translog-repo-1");
         return remoteStoreNodeAttributes;
     }
-
 }
diff --git a/server/src/test/java/org/opensearch/action/support/nodes/TransportClusterStatsActionTests.java b/server/src/test/java/org/opensearch/action/support/nodes/TransportClusterStatsActionTests.java
new file mode 100644
index 0000000000000..f8e14b477b8ef
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/support/nodes/TransportClusterStatsActionTests.java
@@ -0,0 +1,165 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.support.nodes;
+
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.stats.ClusterStatsRequest;
+import org.opensearch.action.admin.cluster.stats.TransportClusterStatsAction;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.node.NodeService;
+import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class TransportClusterStatsActionTests extends TransportNodesActionTests {
+
+    /**
+     * By default, we send discovery nodes list to each request that is sent across from the coordinator node. This
+     * behavior is asserted in this test.
+     */
+    public void testClusterStatsActionWithRetentionOfDiscoveryNodesList() {
+        ClusterStatsRequest request = new ClusterStatsRequest();
+        request.setIncludeDiscoveryNodes(true);
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> {
+                assertNotNull(sentRequest.getDiscoveryNodes());
+                assertEquals(sentRequest.getDiscoveryNodes().length, clusterService.state().nodes().getSize());
+            });
+        });
+    }
+
+    public void testClusterStatsActionWithPreFilledConcreteNodesAndWithRetentionOfDiscoveryNodesList() {
+        ClusterStatsRequest request = new ClusterStatsRequest();
+        Collection<DiscoveryNode> discoveryNodes = clusterService.state().getNodes().getNodes().values();
+        request.setConcreteNodes(discoveryNodes.toArray(DiscoveryNode[]::new));
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> {
+                assertNotNull(sentRequest.getDiscoveryNodes());
+                assertEquals(sentRequest.getDiscoveryNodes().length, clusterService.state().nodes().getSize());
+            });
+        });
+    }
+
+    /**
+     * In the optimized ClusterStats Request, we do not send the DiscoveryNodes List to each node. This behavior is
+     * asserted in this test.
+     */
+    public void testClusterStatsActionWithoutRetentionOfDiscoveryNodesList() {
+        ClusterStatsRequest request = new ClusterStatsRequest();
+        request.setIncludeDiscoveryNodes(false);
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> { assertNull(sentRequest.getDiscoveryNodes()); });
+        });
+    }
+
+    public void testClusterStatsActionWithPreFilledConcreteNodesAndWithoutRetentionOfDiscoveryNodesList() {
+        ClusterStatsRequest request = new ClusterStatsRequest();
+        Collection<DiscoveryNode> discoveryNodes = clusterService.state().getNodes().getNodes().values();
+        request.setConcreteNodes(discoveryNodes.toArray(DiscoveryNode[]::new));
+        request.setIncludeDiscoveryNodes(false);
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> { assertNull(sentRequest.getDiscoveryNodes()); });
+        });
+    }
+
+    private Map<String, List<MockClusterStatsNodeRequest>> performNodesInfoAction(ClusterStatsRequest request) {
+        TransportNodesAction action = getTestTransportClusterStatsAction();
+        PlainActionFuture<NodesStatsRequest> listener = new PlainActionFuture<>();
+        action.new AsyncAction(null, request, listener).start();
+        Map<String, List<CapturingTransport.CapturedRequest>> capturedRequests = transport.getCapturedRequestsByTargetNodeAndClear();
+        Map<String, List<MockClusterStatsNodeRequest>> combinedSentRequest = new HashMap<>();
+
+        capturedRequests.forEach((node, capturedRequestList) -> {
+            List<MockClusterStatsNodeRequest> sentRequestList = new ArrayList<>();
+
+            capturedRequestList.forEach(preSentRequest -> {
+                BytesStreamOutput out = new BytesStreamOutput();
+                try {
+                    TransportClusterStatsAction.ClusterStatsNodeRequest clusterStatsNodeRequestFromCoordinator =
+                        (TransportClusterStatsAction.ClusterStatsNodeRequest) preSentRequest.request;
+                    clusterStatsNodeRequestFromCoordinator.writeTo(out);
+                    StreamInput in = out.bytes().streamInput();
+                    MockClusterStatsNodeRequest mockClusterStatsNodeRequest = new MockClusterStatsNodeRequest(in);
+                    sentRequestList.add(mockClusterStatsNodeRequest);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+
+            combinedSentRequest.put(node, sentRequestList);
+        });
+
+        return combinedSentRequest;
+    }
+
+    private TestTransportClusterStatsAction getTestTransportClusterStatsAction() {
+        return new TestTransportClusterStatsAction(
+            THREAD_POOL,
+            clusterService,
+            transportService,
+            nodeService,
+            indicesService,
+            new ActionFilters(Collections.emptySet())
+        );
+    }
+
+    private static class TestTransportClusterStatsAction extends TransportClusterStatsAction {
+        public TestTransportClusterStatsAction(
+            ThreadPool threadPool,
+            ClusterService clusterService,
+            TransportService transportService,
+            NodeService nodeService,
+            IndicesService indicesService,
+            ActionFilters actionFilters
+        ) {
+            super(threadPool, clusterService, transportService, nodeService, indicesService, actionFilters);
+        }
+    }
+
+    private static class MockClusterStatsNodeRequest extends TransportClusterStatsAction.ClusterStatsNodeRequest {
+
+        public MockClusterStatsNodeRequest(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        public DiscoveryNode[] getDiscoveryNodes() {
+            return this.request.concreteNodes();
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesActionTests.java b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesActionTests.java
index 10f9708072889..799c5dd9482b6 100644
--- a/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesActionTests.java
+++ b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesActionTests.java
@@ -46,6 +46,8 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.io.stream.StreamOutput;
 import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.indices.IndicesService;
+import org.opensearch.node.NodeService;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.CapturingTransport;
@@ -75,11 +77,12 @@
 
 public class TransportNodesActionTests extends OpenSearchTestCase {
 
-    private static ThreadPool THREAD_POOL;
-
-    private ClusterService clusterService;
-    private CapturingTransport transport;
-    private TransportService transportService;
+    protected static ThreadPool THREAD_POOL;
+    protected ClusterService clusterService;
+    protected CapturingTransport transport;
+    protected TransportService transportService;
+    protected NodeService nodeService;
+    protected IndicesService indicesService;
 
     public void testRequestIsSentToEachNode() throws Exception {
         TransportNodesAction action = getTestTransportNodesAction();
diff --git a/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesInfoActionTests.java b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesInfoActionTests.java
new file mode 100644
index 0000000000000..e9e09d0dbbbf9
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesInfoActionTests.java
@@ -0,0 +1,131 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.support.nodes;
+
+import org.opensearch.action.admin.cluster.node.info.NodesInfoRequest;
+import org.opensearch.action.admin.cluster.node.info.TransportNodesInfoAction;
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.node.NodeService;
+import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class TransportNodesInfoActionTests extends TransportNodesActionTests {
+
+    /**
+     * By default, we send discovery nodes list to each request that is sent across from the coordinator node. This
+     * behavior is asserted in this test.
+     */
+    public void testNodesInfoActionWithRetentionOfDiscoveryNodesList() {
+        NodesInfoRequest request = new NodesInfoRequest();
+        request.setIncludeDiscoveryNodes(true);
+        Map<String, List<MockNodesInfoRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> {
+                assertNotNull(sentRequest.getDiscoveryNodes());
+                assertEquals(sentRequest.getDiscoveryNodes().length, clusterService.state().nodes().getSize());
+            });
+        });
+    }
+
+    /**
+     * In the optimized ClusterStats Request, we do not send the DiscoveryNodes List to each node. This behavior is
+     * asserted in this test.
+     */
+    public void testNodesInfoActionWithoutRetentionOfDiscoveryNodesList() {
+        NodesInfoRequest request = new NodesInfoRequest();
+        request.setIncludeDiscoveryNodes(false);
+        Map<String, List<MockNodesInfoRequest>> combinedSentRequest = performNodesInfoAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> { assertNull(sentRequest.getDiscoveryNodes()); });
+        });
+    }
+
+    private Map<String, List<MockNodesInfoRequest>> performNodesInfoAction(NodesInfoRequest request) {
+        TransportNodesAction action = getTestTransportNodesInfoAction();
+        PlainActionFuture<NodesStatsRequest> listener = new PlainActionFuture<>();
+        action.new AsyncAction(null, request, listener).start();
+        Map<String, List<CapturingTransport.CapturedRequest>> capturedRequests = transport.getCapturedRequestsByTargetNodeAndClear();
+        Map<String, List<MockNodesInfoRequest>> combinedSentRequest = new HashMap<>();
+
+        capturedRequests.forEach((node, capturedRequestList) -> {
+            List<MockNodesInfoRequest> sentRequestList = new ArrayList<>();
+
+            capturedRequestList.forEach(preSentRequest -> {
+                BytesStreamOutput out = new BytesStreamOutput();
+                try {
+                    TransportNodesInfoAction.NodeInfoRequest nodesInfoRequestFromCoordinator =
+                        (TransportNodesInfoAction.NodeInfoRequest) preSentRequest.request;
+                    nodesInfoRequestFromCoordinator.writeTo(out);
+                    StreamInput in = out.bytes().streamInput();
+                    MockNodesInfoRequest nodesStatsRequest = new MockNodesInfoRequest(in);
+                    sentRequestList.add(nodesStatsRequest);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+
+            combinedSentRequest.put(node, sentRequestList);
+        });
+
+        return combinedSentRequest;
+    }
+
+    private TestTransportNodesInfoAction getTestTransportNodesInfoAction() {
+        return new TestTransportNodesInfoAction(
+            THREAD_POOL,
+            clusterService,
+            transportService,
+            nodeService,
+            new ActionFilters(Collections.emptySet())
+        );
+    }
+
+    private static class TestTransportNodesInfoAction extends TransportNodesInfoAction {
+        public TestTransportNodesInfoAction(
+            ThreadPool threadPool,
+            ClusterService clusterService,
+            TransportService transportService,
+            NodeService nodeService,
+            ActionFilters actionFilters
+        ) {
+            super(threadPool, clusterService, transportService, nodeService, actionFilters);
+        }
+    }
+
+    private static class MockNodesInfoRequest extends TransportNodesInfoAction.NodeInfoRequest {
+
+        public MockNodesInfoRequest(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        public DiscoveryNode[] getDiscoveryNodes() {
+            return this.request.concreteNodes();
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesStatsActionTests.java b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesStatsActionTests.java
new file mode 100644
index 0000000000000..c7c420e353e1a
--- /dev/null
+++ b/server/src/test/java/org/opensearch/action/support/nodes/TransportNodesStatsActionTests.java
@@ -0,0 +1,130 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.action.support.nodes;
+
+import org.opensearch.action.admin.cluster.node.stats.NodesStatsRequest;
+import org.opensearch.action.admin.cluster.node.stats.TransportNodesStatsAction;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.PlainActionFuture;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.node.NodeService;
+import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportService;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class TransportNodesStatsActionTests extends TransportNodesActionTests {
+
+    /**
+     * By default, we send discovery nodes list to each request that is sent across from the coordinator node. This
+     * behavior is asserted in this test.
+     */
+    public void testNodesStatsActionWithRetentionOfDiscoveryNodesList() {
+        NodesStatsRequest request = new NodesStatsRequest();
+        request.setIncludeDiscoveryNodes(true);
+        Map<String, List<MockNodeStatsRequest>> combinedSentRequest = performNodesStatsAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> {
+                assertNotNull(sentRequest.getDiscoveryNodes());
+                assertEquals(sentRequest.getDiscoveryNodes().length, clusterService.state().nodes().getSize());
+            });
+        });
+    }
+
+    /**
+     * By default, we send discovery nodes list to each request that is sent across from the coordinator node. This
+     * behavior is asserted in this test.
+     */
+    public void testNodesStatsActionWithoutRetentionOfDiscoveryNodesList() {
+        NodesStatsRequest request = new NodesStatsRequest();
+        request.setIncludeDiscoveryNodes(false);
+        Map<String, List<MockNodeStatsRequest>> combinedSentRequest = performNodesStatsAction(request);
+
+        assertNotNull(combinedSentRequest);
+        combinedSentRequest.forEach((node, capturedRequestList) -> {
+            assertNotNull(capturedRequestList);
+            capturedRequestList.forEach(sentRequest -> { assertNull(sentRequest.getDiscoveryNodes()); });
+        });
+    }
+
+    private Map<String, List<MockNodeStatsRequest>> performNodesStatsAction(NodesStatsRequest request) {
+        TransportNodesAction action = getTestTransportNodesStatsAction();
+        PlainActionFuture<NodesStatsRequest> listener = new PlainActionFuture<>();
+        action.new AsyncAction(null, request, listener).start();
+        Map<String, List<CapturingTransport.CapturedRequest>> capturedRequests = transport.getCapturedRequestsByTargetNodeAndClear();
+        Map<String, List<MockNodeStatsRequest>> combinedSentRequest = new HashMap<>();
+
+        capturedRequests.forEach((node, capturedRequestList) -> {
+            List<MockNodeStatsRequest> sentRequestList = new ArrayList<>();
+
+            capturedRequestList.forEach(preSentRequest -> {
+                BytesStreamOutput out = new BytesStreamOutput();
+                try {
+                    TransportNodesStatsAction.NodeStatsRequest nodesStatsRequestFromCoordinator =
+                        (TransportNodesStatsAction.NodeStatsRequest) preSentRequest.request;
+                    nodesStatsRequestFromCoordinator.writeTo(out);
+                    StreamInput in = out.bytes().streamInput();
+                    MockNodeStatsRequest nodesStatsRequest = new MockNodeStatsRequest(in);
+                    sentRequestList.add(nodesStatsRequest);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+
+            combinedSentRequest.put(node, sentRequestList);
+        });
+
+        return combinedSentRequest;
+    }
+
+    private TestTransportNodesStatsAction getTestTransportNodesStatsAction() {
+        return new TestTransportNodesStatsAction(
+            THREAD_POOL,
+            clusterService,
+            transportService,
+            nodeService,
+            new ActionFilters(Collections.emptySet())
+        );
+    }
+
+    private static class TestTransportNodesStatsAction extends TransportNodesStatsAction {
+        public TestTransportNodesStatsAction(
+            ThreadPool threadPool,
+            ClusterService clusterService,
+            TransportService transportService,
+            NodeService nodeService,
+            ActionFilters actionFilters
+        ) {
+            super(threadPool, clusterService, transportService, nodeService, actionFilters);
+        }
+    }
+
+    private static class MockNodeStatsRequest extends TransportNodesStatsAction.NodeStatsRequest {
+
+        public MockNodeStatsRequest(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        public DiscoveryNode[] getDiscoveryNodes() {
+            return this.request.concreteNodes();
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java b/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
index ec5fc1d19e40d..6eb697d493bf4 100644
--- a/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
+++ b/server/src/test/java/org/opensearch/action/support/replication/ReplicationOperationTests.java
@@ -42,13 +42,19 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.action.shard.ShardStateAction;
 import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.routing.AllocationId;
+import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ConcurrentCollections;
 import org.opensearch.common.util.set.Sets;
@@ -89,6 +95,7 @@
 import static org.opensearch.action.support.replication.ClusterStateCreationUtils.state;
 import static org.opensearch.action.support.replication.ClusterStateCreationUtils.stateWithActivePrimary;
 import static org.opensearch.action.support.replication.ReplicationOperation.RetryOnPrimaryException;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS;
 import static org.opensearch.cluster.routing.TestShardRouting.newShardRouting;
 import static org.hamcrest.Matchers.arrayWithSize;
 import static org.hamcrest.Matchers.equalTo;
@@ -944,6 +951,83 @@ public void updateLocalCheckpointForShard(String allocationId, long checkpoint)
         assertThat(shardInfo.getSuccessful(), equalTo(1 + getExpectedReplicas(shardId, state, trackedShards).size()));
     }
 
+    public void testReplicationOperationsAreNotSentToSearchReplicas() throws Exception {
+        final String index = "test";
+        final ShardId shardId = new ShardId(index, "_na_", 0);
+
+        ClusterState initialState = stateWithActivePrimary(index, true, randomInt(5));
+        IndexMetadata indexMetadata = initialState.getMetadata().index(index);
+        // add a search only replica
+        DiscoveryNode node = new DiscoveryNode(
+            "nodeForSearchShard",
+            OpenSearchTestCase.buildNewFakeTransportAddress(),
+            Collections.emptyMap(),
+            new HashSet<>(DiscoveryNodeRole.BUILT_IN_ROLES),
+            Version.CURRENT
+        );
+        IndexMetadata.Builder indexMetadataBuilder = new IndexMetadata.Builder(indexMetadata);
+        indexMetadataBuilder.settings(Settings.builder().put(indexMetadata.getSettings()).put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 1));
+
+        ShardRouting searchShardRouting = TestShardRouting.newShardRouting(
+            shardId,
+            node.getId(),
+            null,
+            false,
+            true,
+            ShardRoutingState.STARTED,
+            null
+        );
+        IndexShardRoutingTable indexShardRoutingTable = initialState.getRoutingTable().shardRoutingTable(shardId);
+        IndexShardRoutingTable.Builder indexShardRoutingBuilder = new IndexShardRoutingTable.Builder(indexShardRoutingTable);
+        indexShardRoutingBuilder.addShard(searchShardRouting);
+        indexShardRoutingTable = indexShardRoutingBuilder.build();
+
+        ClusterState.Builder state = ClusterState.builder(initialState);
+        state.nodes(DiscoveryNodes.builder(initialState.nodes()).add(node).build());
+        state.metadata(Metadata.builder().put(indexMetadataBuilder.build(), false));
+        state.routingTable(
+            RoutingTable.builder().add(IndexRoutingTable.builder(indexMetadata.getIndex()).addIndexShard(indexShardRoutingTable)).build()
+        );
+        initialState = state.build();
+        // execute a request and check hits
+
+        final Set<String> trackedShards = new HashSet<>();
+        final Set<String> untrackedShards = new HashSet<>();
+        ShardRouting primaryShard = indexShardRoutingTable.primaryShard();
+        addTrackingInfo(indexShardRoutingTable, primaryShard, trackedShards, untrackedShards);
+        final ReplicationGroup replicationGroup = new ReplicationGroup(
+            indexShardRoutingTable,
+            indexMetadata.inSyncAllocationIds(0),
+            trackedShards,
+            0
+        );
+
+        // shards are not part of the rg
+        assertFalse(replicationGroup.getReplicationTargets().stream().anyMatch(ShardRouting::isSearchOnly));
+
+        Set<ShardRouting> initial = getExpectedReplicas(shardId, initialState, trackedShards);
+        final Set<ShardRouting> expectedReplicas = initial.stream().filter(shr -> shr.isSearchOnly() == false).collect(Collectors.toSet());
+        Request request = new Request(shardId);
+        PlainActionFuture<TestPrimary.Result> listener = new PlainActionFuture<>();
+        final TestReplicaProxy replicasProxy = new TestReplicaProxy(new HashMap<>());
+
+        final TestPrimary primary = new TestPrimary(primaryShard, () -> replicationGroup, threadPool);
+        final TestReplicationOperation op = new TestReplicationOperation(
+            request,
+            primary,
+            listener,
+            replicasProxy,
+            indexMetadata.primaryTerm(0),
+            new FanoutReplicationProxy<>(replicasProxy)
+        );
+        op.execute();
+        assertTrue("request was not processed on primary", request.processedOnPrimary.get());
+        assertEquals(request.processedOnReplicas, expectedReplicas);
+        assertEquals(replicasProxy.failedReplicas, Collections.emptySet());
+        assertEquals(replicasProxy.markedAsStaleCopies, Collections.emptySet());
+        assertTrue(listener.isDone());
+    }
+
     private Set<ShardRouting> getExpectedReplicas(ShardId shardId, ClusterState state, Set<String> trackedShards) {
         Set<ShardRouting> expectedReplicas = new HashSet<>();
         String localNodeId = state.nodes().getLocalNodeId();
diff --git a/server/src/test/java/org/opensearch/action/update/UpdateRequestTests.java b/server/src/test/java/org/opensearch/action/update/UpdateRequestTests.java
index b70fda0d86240..e85dfa8cca556 100644
--- a/server/src/test/java/org/opensearch/action/update/UpdateRequestTests.java
+++ b/server/src/test/java/org/opensearch/action/update/UpdateRequestTests.java
@@ -247,6 +247,7 @@ public void testFromXContent() throws Exception {
         assertThat(params, notNullValue());
         assertThat(params.size(), equalTo(1));
         assertThat(params.get("param1").toString(), equalTo("value1"));
+        assertThat(request.upsertRequest().index(), equalTo("test"));
         Map<String, Object> upsertDoc = XContentHelper.convertToMap(
             request.upsertRequest().source(),
             true,
@@ -304,6 +305,7 @@ public void testFromXContent() throws Exception {
             )
         );
         Map<String, Object> doc = request.doc().sourceAsMap();
+        assertThat(request.doc().index(), equalTo("test"));
         assertThat(doc.get("field1").toString(), equalTo("value1"));
         assertThat(((Map<String, Object>) doc.get("compound")).get("field2").toString(), equalTo("value2"));
     }
@@ -662,7 +664,7 @@ public void testToString() throws IOException {
             request.toString(),
             equalTo(
                 "update {[test][1], doc_as_upsert[false], "
-                    + "doc[index {[null][null], source[{\"body\":\"bar\"}]}], scripted_upsert[false], detect_noop[true]}"
+                    + "doc[index {[test][null], source[{\"body\":\"bar\"}]}], scripted_upsert[false], detect_noop[true]}"
             )
         );
     }
diff --git a/server/src/test/java/org/opensearch/bootstrap/IdentityPluginTests.java b/server/src/test/java/org/opensearch/bootstrap/IdentityPluginTests.java
index 2129810a99879..d7b9f5917c366 100644
--- a/server/src/test/java/org/opensearch/bootstrap/IdentityPluginTests.java
+++ b/server/src/test/java/org/opensearch/bootstrap/IdentityPluginTests.java
@@ -15,6 +15,7 @@
 import org.opensearch.identity.noop.NoopTokenManager;
 import org.opensearch.plugins.IdentityPlugin;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
 
 import java.util.List;
 
@@ -24,19 +25,23 @@
 public class IdentityPluginTests extends OpenSearchTestCase {
 
     public void testSingleIdentityPluginSucceeds() {
-        IdentityPlugin identityPlugin1 = new NoopIdentityPlugin();
+        TestThreadPool threadPool = new TestThreadPool(getTestName());
+        IdentityPlugin identityPlugin1 = new NoopIdentityPlugin(threadPool);
         List<IdentityPlugin> pluginList1 = List.of(identityPlugin1);
-        IdentityService identityService1 = new IdentityService(Settings.EMPTY, pluginList1);
-        assertTrue(identityService1.getSubject().getPrincipal().getName().equalsIgnoreCase("Unauthenticated"));
+        IdentityService identityService1 = new IdentityService(Settings.EMPTY, threadPool, pluginList1);
+        assertTrue(identityService1.getCurrentSubject().getPrincipal().getName().equalsIgnoreCase("Unauthenticated"));
         assertThat(identityService1.getTokenManager(), is(instanceOf(NoopTokenManager.class)));
+        terminate(threadPool);
     }
 
     public void testMultipleIdentityPluginsFail() {
-        IdentityPlugin identityPlugin1 = new NoopIdentityPlugin();
-        IdentityPlugin identityPlugin2 = new NoopIdentityPlugin();
-        IdentityPlugin identityPlugin3 = new NoopIdentityPlugin();
+        TestThreadPool threadPool = new TestThreadPool(getTestName());
+        IdentityPlugin identityPlugin1 = new NoopIdentityPlugin(threadPool);
+        IdentityPlugin identityPlugin2 = new NoopIdentityPlugin(threadPool);
+        IdentityPlugin identityPlugin3 = new NoopIdentityPlugin(threadPool);
         List<IdentityPlugin> pluginList = List.of(identityPlugin1, identityPlugin2, identityPlugin3);
-        Exception ex = assertThrows(OpenSearchException.class, () -> new IdentityService(Settings.EMPTY, pluginList));
+        Exception ex = assertThrows(OpenSearchException.class, () -> new IdentityService(Settings.EMPTY, threadPool, pluginList));
         assert (ex.getMessage().contains("Multiple identity plugins are not supported,"));
+        terminate(threadPool);
     }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/ClusterModuleTests.java b/server/src/test/java/org/opensearch/cluster/ClusterModuleTests.java
index 557e4dc2ca8c5..97706927ba857 100644
--- a/server/src/test/java/org/opensearch/cluster/ClusterModuleTests.java
+++ b/server/src/test/java/org/opensearch/cluster/ClusterModuleTests.java
@@ -33,6 +33,7 @@
 package org.opensearch.cluster;
 
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.QueryGroupMetadata;
 import org.opensearch.cluster.metadata.RepositoriesMetadata;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.allocation.ExistingShardsAllocator;
@@ -68,10 +69,12 @@
 import org.opensearch.common.settings.Setting.Property;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.settings.SettingsModule;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
 import org.opensearch.gateway.GatewayAllocator;
 import org.opensearch.plugins.ClusterPlugin;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.gateway.TestGatewayAllocator;
 import org.opensearch.test.gateway.TestShardBatchGatewayAllocator;
 
@@ -92,7 +95,7 @@ public class ClusterModuleTests extends ModuleTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadContext = new ThreadContext(Settings.EMPTY);
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             null
@@ -167,7 +170,7 @@ public void testRegisterAllocationDeciderDuplicate() {
                 public Collection<AllocationDecider> createAllocationDeciders(Settings settings, ClusterSettings clusterSettings) {
                     return Collections.singletonList(new EnableAllocationDecider(settings, clusterSettings));
                 }
-            }), clusterInfoService, null, threadContext)
+            }), clusterInfoService, null, threadContext, new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE))
         );
         assertEquals(e.getMessage(), "Cannot specify allocation decider [" + EnableAllocationDecider.class.getName() + "] twice");
     }
@@ -178,7 +181,7 @@ public void testRegisterAllocationDecider() {
             public Collection<AllocationDecider> createAllocationDeciders(Settings settings, ClusterSettings clusterSettings) {
                 return Collections.singletonList(new FakeAllocationDecider());
             }
-        }), clusterInfoService, null, threadContext);
+        }), clusterInfoService, null, threadContext, new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE));
         assertTrue(module.deciderList.stream().anyMatch(d -> d.getClass().equals(FakeAllocationDecider.class)));
     }
 
@@ -188,7 +191,7 @@ private ClusterModule newClusterModuleWithShardsAllocator(Settings settings, Str
             public Map<String, Supplier<ShardsAllocator>> getShardsAllocators(Settings settings, ClusterSettings clusterSettings) {
                 return Collections.singletonMap(name, supplier);
             }
-        }), clusterInfoService, null, threadContext);
+        }), clusterInfoService, null, threadContext, new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE));
     }
 
     public void testRegisterShardsAllocator() {
@@ -209,7 +212,15 @@ public void testUnknownShardsAllocator() {
         Settings settings = Settings.builder().put(ClusterModule.SHARDS_ALLOCATOR_TYPE_SETTING.getKey(), "dne").build();
         IllegalArgumentException e = expectThrows(
             IllegalArgumentException.class,
-            () -> new ClusterModule(settings, clusterService, Collections.emptyList(), clusterInfoService, null, threadContext)
+            () -> new ClusterModule(
+                settings,
+                clusterService,
+                Collections.emptyList(),
+                clusterInfoService,
+                null,
+                threadContext,
+                new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
+            )
         );
         assertEquals("Unknown ShardsAllocator [dne]", e.getMessage());
     }
@@ -243,11 +254,9 @@ public void testAllocationDeciderOrder() {
             ShardsLimitAllocationDecider.class,
             AwarenessAllocationDecider.class,
             NodeLoadAwareAllocationDecider.class,
-            TargetPoolAllocationDecider.class
+            TargetPoolAllocationDecider.class,
+            RemoteStoreMigrationAllocationDecider.class
         );
-        if (FeatureFlags.isEnabled(FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL_SETTING)) {
-            expectedDeciders.add(RemoteStoreMigrationAllocationDecider.class);
-        }
         Collection<AllocationDecider> deciders = ClusterModule.createAllocationDeciders(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
@@ -295,7 +304,8 @@ public void testRejectsReservedExistingShardsAllocatorName() {
             Collections.singletonList(existingShardsAllocatorPlugin(GatewayAllocator.ALLOCATOR_NAME)),
             clusterInfoService,
             null,
-            threadContext
+            threadContext,
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
         );
         expectThrows(
             IllegalArgumentException.class,
@@ -310,7 +320,8 @@ public void testRejectsDuplicateExistingShardsAllocatorName() {
             Arrays.asList(existingShardsAllocatorPlugin("duplicate"), existingShardsAllocatorPlugin("duplicate")),
             clusterInfoService,
             null,
-            threadContext
+            threadContext,
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
         );
         expectThrows(
             IllegalArgumentException.class,
@@ -318,6 +329,14 @@ public void testRejectsDuplicateExistingShardsAllocatorName() {
         );
     }
 
+    public void testQueryGroupMetadataRegister() {
+        List<NamedWriteableRegistry.Entry> customEntries = ClusterModule.getNamedWriteables();
+        assertTrue(
+            customEntries.stream()
+                .anyMatch(entry -> entry.categoryClass == Metadata.Custom.class && entry.name.equals(QueryGroupMetadata.TYPE))
+        );
+    }
+
     private static ClusterPlugin existingShardsAllocatorPlugin(final String allocatorName) {
         return new ClusterPlugin() {
             @Override
diff --git a/server/src/test/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoaderTests.java b/server/src/test/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoaderTests.java
new file mode 100644
index 0000000000000..c7cfab6d38e04
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/applicationtemplates/ClusterStateSystemTemplateLoaderTests.java
@@ -0,0 +1,153 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.OpenSearchCorruptionException;
+import org.opensearch.cluster.metadata.ComponentTemplate;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.core.xcontent.DeprecationHandler;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.test.OpenSearchSingleNodeTestCase;
+
+import java.io.IOException;
+import java.util.UUID;
+
+public class ClusterStateSystemTemplateLoaderTests extends OpenSearchSingleNodeTestCase {
+
+    public static final String SAMPLE_TEMPLATE = "{\n"
+        + "  \"template\": {\n"
+        + "    \"settings\": {\n"
+        + "       \"index\": {\n"
+        + "           \"codec\": \"best_compression\",\n"
+        + "           \"merge.policy\": \"log_byte_size\",\n"
+        + "           \"refresh_interval\": \"60s\"\n"
+        + "       }\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"_meta\": {\n"
+        + "    \"_type\": \"@abc_template\",\n"
+        + "    \"_version\": 1\n"
+        + "  },\n"
+        + "  \"version\": 1\n"
+        + "}";
+
+    public static final String SAMPLE_TEMPLATE_V2 = "{\n"
+        + "  \"template\": {\n"
+        + "    \"settings\": {\n"
+        + "       \"index\": {\n"
+        + "           \"codec\": \"best_compression\",\n"
+        + "           \"merge.policy\": \"log_byte_size\",\n"
+        + "           \"refresh_interval\": \"60s\"\n"
+        + "       }\n"
+        + "    }\n"
+        + "  },\n"
+        + "  \"_meta\": {\n"
+        + "    \"_type\": \"@abc_template\",\n"
+        + "    \"_version\": 2\n"
+        + "  },\n"
+        + "  \"version\": 2\n"
+        + "}";
+
+    public void testLoadTemplate() throws IOException {
+        ClusterStateSystemTemplateLoader loader = new ClusterStateSystemTemplateLoader(
+            node().client(),
+            () -> node().injector().getInstance(ClusterService.class).state()
+        );
+
+        TemplateRepositoryMetadata repositoryMetadata = new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L);
+        SystemTemplateMetadata metadata = SystemTemplateMetadata.fromComponentTemplateInfo("dummy", 1L);
+
+        // Load for the first time
+        assertTrue(
+            loader.loadTemplate(
+                new SystemTemplate(
+                    new BytesArray(SAMPLE_TEMPLATE),
+                    metadata,
+                    new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L)
+                )
+            )
+        );
+        assertTrue(
+            node().injector()
+                .getInstance(ClusterService.class)
+                .state()
+                .metadata()
+                .componentTemplates()
+                .containsKey(metadata.fullyQualifiedName())
+        );
+        XContentParser parser = JsonXContent.jsonXContent.createParser(
+            NamedXContentRegistry.EMPTY,
+            DeprecationHandler.IGNORE_DEPRECATIONS,
+            SAMPLE_TEMPLATE
+        );
+        assertEquals(
+            node().injector().getInstance(ClusterService.class).state().metadata().componentTemplates().get(metadata.fullyQualifiedName()),
+            ComponentTemplate.parse(parser)
+        );
+
+        // Retry and ensure loading does not happen again with same version
+        assertFalse(
+            loader.loadTemplate(
+                new SystemTemplate(
+                    new BytesArray(SAMPLE_TEMPLATE),
+                    metadata,
+                    new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L)
+                )
+            )
+        );
+
+        // Retry with new template version
+        SystemTemplateMetadata newVersionMetadata = SystemTemplateMetadata.fromComponentTemplateInfo("dummy", 2L);
+        assertTrue(loader.loadTemplate(new SystemTemplate(new BytesArray(SAMPLE_TEMPLATE_V2), newVersionMetadata, repositoryMetadata)));
+        parser = JsonXContent.jsonXContent.createParser(
+            NamedXContentRegistry.EMPTY,
+            DeprecationHandler.IGNORE_DEPRECATIONS,
+            SAMPLE_TEMPLATE_V2
+        );
+        assertEquals(
+            node().injector()
+                .getInstance(ClusterService.class)
+                .state()
+                .metadata()
+                .componentTemplates()
+                .get(newVersionMetadata.fullyQualifiedName()),
+            ComponentTemplate.parse(parser)
+        );
+    }
+
+    public void testLoadTemplateVersionMismatch() throws IOException {
+        ClusterStateSystemTemplateLoader loader = new ClusterStateSystemTemplateLoader(
+            node().client(),
+            () -> node().injector().getInstance(ClusterService.class).state()
+        );
+
+        TemplateRepositoryMetadata repositoryMetadata = new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L);
+        SystemTemplateMetadata metadata = SystemTemplateMetadata.fromComponentTemplateInfo("dummy", 2L);
+
+        // Load for the first time
+        assertThrows(
+            OpenSearchCorruptionException.class,
+            () -> loader.loadTemplate(
+                new SystemTemplate(
+                    new BytesArray(SAMPLE_TEMPLATE),
+                    metadata,
+                    new TemplateRepositoryMetadata(UUID.randomUUID().toString(), 1L)
+                )
+            )
+        );
+    }
+
+    @Override
+    protected boolean resetNodeAfterTest() {
+        return true;
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesServiceTests.java b/server/src/test/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesServiceTests.java
new file mode 100644
index 0000000000000..affb017264fdf
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/applicationtemplates/SystemTemplatesServiceTests.java
@@ -0,0 +1,102 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.applicationtemplates;
+
+import org.opensearch.cluster.service.applicationtemplates.TestSystemTemplatesRepositoryPlugin;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.mockito.Mockito;
+
+import static org.opensearch.common.settings.ClusterSettings.BUILT_IN_CLUSTER_SETTINGS;
+import static org.mockito.Mockito.when;
+
+public class SystemTemplatesServiceTests extends OpenSearchTestCase {
+
+    private SystemTemplatesService systemTemplatesService;
+
+    public void testSystemTemplatesLoaded() throws IOException {
+        setupService(true);
+
+        // First time load should happen, second time should short circuit.
+        for (int iter = 1; iter <= 2; iter++) {
+            systemTemplatesService.onClusterManager();
+            SystemTemplatesService.Stats stats = systemTemplatesService.stats();
+            assertNotNull(stats);
+            assertEquals(stats.getTemplatesLoaded(), iter % 2);
+            assertEquals(stats.getFailedLoadingTemplates(), 0L);
+            assertEquals(stats.getFailedLoadingRepositories(), iter % 2);
+        }
+    }
+
+    public void testSystemTemplatesVerifyAndLoad() throws IOException {
+        setupService(false);
+
+        systemTemplatesService.verifyRepositories();
+        SystemTemplatesService.Stats stats = systemTemplatesService.stats();
+        assertNotNull(stats);
+        assertEquals(stats.getTemplatesLoaded(), 0L);
+        assertEquals(stats.getFailedLoadingTemplates(), 0L);
+        assertEquals(stats.getFailedLoadingRepositories(), 0L);
+
+        systemTemplatesService.onClusterManager();
+        stats = systemTemplatesService.stats();
+        assertNotNull(stats);
+        assertEquals(stats.getTemplatesLoaded(), 1L);
+        assertEquals(stats.getFailedLoadingTemplates(), 0L);
+        assertEquals(stats.getFailedLoadingRepositories(), 0L);
+    }
+
+    public void testSystemTemplatesVerifyWithFailingRepository() throws IOException {
+        setupService(true);
+
+        // Do it multiple times to ensure verify checks are always executed.
+        for (int i = 0; i < 2; i++) {
+            assertThrows(IllegalStateException.class, () -> systemTemplatesService.verifyRepositories());
+
+            SystemTemplatesService.Stats stats = systemTemplatesService.stats();
+            assertNotNull(stats);
+            assertEquals(stats.getTemplatesLoaded(), 0L);
+            assertEquals(stats.getFailedLoadingTemplates(), 0L);
+            assertEquals(stats.getFailedLoadingRepositories(), 1L);
+        }
+    }
+
+    private void setupService(boolean errorFromMockPlugin) throws IOException {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+
+        ThreadPool mockPool = Mockito.mock(ThreadPool.class);
+        when(mockPool.generic()).thenReturn(OpenSearchExecutors.newDirectExecutorService());
+
+        List<SystemTemplatesPlugin> plugins = new ArrayList<>();
+        plugins.add(new TestSystemTemplatesRepositoryPlugin());
+
+        if (errorFromMockPlugin) {
+            SystemTemplatesPlugin mockPlugin = Mockito.mock(SystemTemplatesPlugin.class);
+            when(mockPlugin.loadRepository()).thenThrow(new IOException());
+            plugins.add(mockPlugin);
+        }
+
+        ClusterSettings mockSettings = new ClusterSettings(Settings.EMPTY, BUILT_IN_CLUSTER_SETTINGS);
+        systemTemplatesService = new SystemTemplatesService(
+            plugins,
+            mockPool,
+            mockSettings,
+            Settings.builder().put(SystemTemplatesService.SETTING_APPLICATION_BASED_CONFIGURATION_TEMPLATES_ENABLED.getKey(), true).build()
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/block/ClusterBlockTests.java b/server/src/test/java/org/opensearch/cluster/block/ClusterBlockTests.java
index 04e04bd96a7d3..0f049f99b49c0 100644
--- a/server/src/test/java/org/opensearch/cluster/block/ClusterBlockTests.java
+++ b/server/src/test/java/org/opensearch/cluster/block/ClusterBlockTests.java
@@ -136,7 +136,7 @@ public void testGetIndexBlockWithId() {
         assertThat(builder.build().getIndexBlockWithId("index", randomValueOtherThan(blockId, OpenSearchTestCase::randomInt)), nullValue());
     }
 
-    private ClusterBlock randomClusterBlock() {
+    public static ClusterBlock randomClusterBlock() {
         final String uuid = randomBoolean() ? UUIDs.randomBase64UUID() : null;
         final List<ClusterBlockLevel> levels = Arrays.asList(ClusterBlockLevel.values());
         return new ClusterBlock(
diff --git a/server/src/test/java/org/opensearch/cluster/block/ClusterBlocksTests.java b/server/src/test/java/org/opensearch/cluster/block/ClusterBlocksTests.java
new file mode 100644
index 0000000000000..e17cc7c24ffbd
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/block/ClusterBlocksTests.java
@@ -0,0 +1,55 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.block;
+
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.opensearch.cluster.block.ClusterBlockTests.randomClusterBlock;
+
+public class ClusterBlocksTests extends OpenSearchTestCase {
+
+    public void testWriteVerifiableTo() throws Exception {
+        ClusterBlock clusterBlock1 = randomClusterBlock();
+        ClusterBlock clusterBlock2 = randomClusterBlock();
+        ClusterBlock clusterBlock3 = randomClusterBlock();
+
+        ClusterBlocks clusterBlocks = ClusterBlocks.builder()
+            .addGlobalBlock(clusterBlock1)
+            .addGlobalBlock(clusterBlock2)
+            .addGlobalBlock(clusterBlock3)
+            .addIndexBlock("index-1", clusterBlock1)
+            .addIndexBlock("index-2", clusterBlock2)
+            .build();
+        BytesStreamOutput out = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out);
+        clusterBlocks.writeVerifiableTo(checksumOut);
+        StreamInput in = out.bytes().streamInput();
+        ClusterBlocks result = ClusterBlocks.readFrom(in);
+
+        assertEquals(clusterBlocks.global().size(), result.global().size());
+        assertEquals(clusterBlocks.global(), result.global());
+        assertEquals(clusterBlocks.indices().size(), result.indices().size());
+        assertEquals(clusterBlocks.indices(), result.indices());
+
+        ClusterBlocks clusterBlocks2 = ClusterBlocks.builder()
+            .addGlobalBlock(clusterBlock3)
+            .addGlobalBlock(clusterBlock1)
+            .addGlobalBlock(clusterBlock2)
+            .addIndexBlock("index-2", clusterBlock2)
+            .addIndexBlock("index-1", clusterBlock1)
+            .build();
+        BytesStreamOutput out2 = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut2 = new BufferedChecksumStreamOutput(out2);
+        clusterBlocks2.writeVerifiableTo(checksumOut2);
+        assertEquals(checksumOut.getChecksum(), checksumOut2.getChecksum());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/CoordinationMetadataTests.java b/server/src/test/java/org/opensearch/cluster/coordination/CoordinationMetadataTests.java
index 290479941aaa9..50ced86c41566 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/CoordinationMetadataTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/CoordinationMetadataTests.java
@@ -33,21 +33,27 @@
 
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfiguration;
+import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.common.xcontent.json.JsonXContent;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 import org.opensearch.test.EqualsHashCodeTestUtils;
 import org.opensearch.test.EqualsHashCodeTestUtils.CopyFunction;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import static org.hamcrest.Matchers.equalTo;
 
@@ -231,4 +237,29 @@ public void testXContent() throws IOException {
             assertThat(originalMeta, equalTo(fromXContentMeta));
         }
     }
+
+    public void testWriteVerifiableTo() throws IOException {
+        VotingConfiguration votingConfiguration = randomVotingConfig();
+        Set<VotingConfigExclusion> votingTombstones = randomVotingTombstones();
+        CoordinationMetadata meta1 = new CoordinationMetadata(1, votingConfiguration, votingConfiguration, votingTombstones);
+        BytesStreamOutput out = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out);
+        meta1.writeVerifiableTo(checksumOut);
+        StreamInput in = out.bytes().streamInput();
+        CoordinationMetadata result = new CoordinationMetadata(in);
+
+        assertEquals(meta1, result);
+
+        VotingConfiguration votingConfiguration2 = new VotingConfiguration(
+            (Set<String>) votingConfiguration.getNodeIds().stream().sorted().collect(Collectors.toCollection(LinkedHashSet::new))
+        );
+        Set<VotingConfigExclusion> votingTombstones2 = votingTombstones.stream()
+            .sorted(Comparator.comparing(VotingConfigExclusion::getNodeId))
+            .collect(Collectors.toCollection(LinkedHashSet::new));
+        CoordinationMetadata meta2 = new CoordinationMetadata(1, votingConfiguration2, votingConfiguration2, votingTombstones2);
+        BytesStreamOutput out2 = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut2 = new BufferedChecksumStreamOutput(out2);
+        meta2.writeVerifiableTo(checksumOut2);
+        assertEquals(checksumOut.getChecksum(), checksumOut2.getChecksum());
+    }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/CoordinationStateTests.java b/server/src/test/java/org/opensearch/cluster/coordination/CoordinationStateTests.java
index 1c0dc7fc1ca2d..ee9a2951ec541 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/CoordinationStateTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/CoordinationStateTests.java
@@ -48,6 +48,7 @@
 import org.opensearch.gateway.GatewayMetaState.RemotePersistedState;
 import org.opensearch.gateway.remote.ClusterMetadataManifest;
 import org.opensearch.gateway.remote.RemoteClusterStateService;
+import org.opensearch.gateway.remote.model.RemoteClusterStateManifestInfo;
 import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.test.EqualsHashCodeTestUtils;
 import org.opensearch.test.OpenSearchTestCase;
@@ -65,6 +66,9 @@
 
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.emptySet;
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.MANIFEST_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
@@ -930,21 +934,22 @@ public void testHandlePrePublishAndCommitWhenRemoteStateEnabled() throws IOExcep
         final VotingConfiguration initialConfig = VotingConfiguration.of(node1);
         final ClusterState clusterState = clusterState(0L, 0L, node1, initialConfig, initialConfig, 42L);
         final String previousClusterUUID = "prev-cluster-uuid";
-        final ClusterMetadataManifest manifest = new ClusterMetadataManifest(
-            0L,
-            0L,
-            randomAlphaOfLength(10),
-            randomAlphaOfLength(10),
-            Version.CURRENT,
-            randomAlphaOfLength(10),
-            false,
-            1,
-            randomAlphaOfLength(10),
-            Collections.emptyList(),
-            randomAlphaOfLength(10),
-            true
-        );
-        Mockito.when(remoteClusterStateService.writeFullMetadata(clusterState, previousClusterUUID)).thenReturn(manifest);
+        final ClusterMetadataManifest manifest = ClusterMetadataManifest.builder()
+            .clusterTerm(0L)
+            .stateVersion(0L)
+            .clusterUUID(randomAlphaOfLength(10))
+            .stateUUID(randomAlphaOfLength(10))
+            .opensearchVersion(Version.CURRENT)
+            .nodeId(randomAlphaOfLength(10))
+            .committed(false)
+            .codecVersion(1)
+            .globalMetadataFileName(randomAlphaOfLength(10))
+            .indices(Collections.emptyList())
+            .previousClusterUUID(randomAlphaOfLength(10))
+            .clusterUUIDCommitted(true)
+            .build();
+        Mockito.when(remoteClusterStateService.writeFullMetadata(clusterState, previousClusterUUID, MANIFEST_CURRENT_CODEC_VERSION))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest, "path/to/manifest"));
 
         final PersistedStateRegistry persistedStateRegistry = persistedStateRegistry();
         persistedStateRegistry.addPersistedState(PersistedStateType.LOCAL, ps1);
@@ -969,14 +974,17 @@ public void testHandlePrePublishAndCommitWhenRemoteStateEnabled() throws IOExcep
             .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, randomRepoName)
             .put(stateRepoTypeAttributeKey, FsRepository.TYPE)
             .put(stateRepoSettingsAttributeKeyPrefix + "location", "randomRepoPath")
-            .put(RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
+            .put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
             .build();
 
         final CoordinationState coordinationState = createCoordinationState(persistedStateRegistry, node1, settings);
         coordinationState.handlePrePublish(clusterState);
-        Mockito.verify(remoteClusterStateService, Mockito.times(1)).writeFullMetadata(clusterState, previousClusterUUID);
+        Mockito.verify(remoteClusterStateService, Mockito.times(1))
+            .writeFullMetadata(clusterState, previousClusterUUID, MANIFEST_CURRENT_CODEC_VERSION);
         assertThat(persistedStateRegistry.getPersistedState(PersistedStateType.REMOTE).getLastAcceptedState(), equalTo(clusterState));
 
+        Mockito.when(remoteClusterStateService.markLastStateAsCommitted(any(), any()))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest, "path/to/manifest"));
         coordinationState.handlePreCommit();
         ClusterState committedClusterState = ClusterState.builder(clusterState)
             .metadata(Metadata.builder(clusterState.metadata()).clusterUUIDCommitted(true).build())
@@ -998,6 +1006,16 @@ public void testHandlePrePublishAndCommitWhenRemoteStateEnabled() throws IOExcep
         );
     }
 
+    public void testIsRemotePublicationEnabled_WithInconsistentSettings() {
+        // create settings with remote state disabled but publication enabled
+        Settings settings = Settings.builder()
+            .put(REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), false)
+            .put(REMOTE_PUBLICATION_EXPERIMENTAL, true)
+            .build();
+        CoordinationState coordinationState = createCoordinationState(psr1, node1, settings);
+        assertFalse(coordinationState.isRemotePublicationEnabled());
+    }
+
     public static CoordinationState createCoordinationState(
         PersistedStateRegistry persistedStateRegistry,
         DiscoveryNode localNode,
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
index a106706c00732..d0bc41b459cc3 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/FollowersCheckerTests.java
@@ -33,6 +33,7 @@
 
 import org.opensearch.OpenSearchException;
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.coordination.Coordinator.Mode;
 import org.opensearch.cluster.coordination.FollowersChecker.FollowerCheckRequest;
@@ -47,6 +48,9 @@
 import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.monitor.NodeHealthService;
 import org.opensearch.monitor.StatusInfo;
+import org.opensearch.telemetry.TestInMemoryMetricsRegistry;
+import org.opensearch.telemetry.metrics.MetricsRegistry;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
 import org.opensearch.test.EqualsHashCodeTestUtils;
 import org.opensearch.test.EqualsHashCodeTestUtils.CopyFunction;
@@ -131,6 +135,8 @@ protected void onSendRequest(long requestId, String action, TransportRequest req
         transportService.start();
         transportService.acceptIncomingRequests();
 
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
+
         final FollowersChecker followersChecker = new FollowersChecker(
             settings,
             clusterSettings,
@@ -139,7 +145,8 @@ protected void onSendRequest(long requestId, String action, TransportRequest req
             (node, reason) -> {
                 assert false : node;
             },
-            () -> new StatusInfo(StatusInfo.Status.HEALTHY, "healthy-info")
+            () -> new StatusInfo(StatusInfo.Status.HEALTHY, "healthy-info"),
+            new ClusterManagerMetrics(metricsRegistry)
         );
 
         followersChecker.setCurrentNodes(discoveryNodesHolder[0]);
@@ -193,35 +200,43 @@ protected void onSendRequest(long requestId, String action, TransportRequest req
         followersChecker.clearCurrentNodes();
         deterministicTaskQueue.runAllTasks();
         assertThat(checkedNodes, empty());
+        assertEquals(Integer.valueOf(0), metricsRegistry.getCounterStore().get("followers.checker.failure.count").getCounterValue());
     }
 
     public void testFailsNodeThatDoesNotRespond() {
         final Settings settings = randomSettings();
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
         testBehaviourOfFailingNode(
             settings,
             () -> null,
             "followers check retry count exceeded",
             (FOLLOWER_CHECK_RETRY_COUNT_SETTING.get(settings) - 1) * FOLLOWER_CHECK_INTERVAL_SETTING.get(settings).millis()
                 + FOLLOWER_CHECK_RETRY_COUNT_SETTING.get(settings) * FOLLOWER_CHECK_TIMEOUT_SETTING.get(settings).millis(),
-            () -> new StatusInfo(HEALTHY, "healthy-info")
+            () -> new StatusInfo(HEALTHY, "healthy-info"),
+            metricsRegistry
         );
+        assertEquals(Integer.valueOf(2), metricsRegistry.getCounterStore().get("followers.checker.failure.count").getCounterValue());
     }
 
     public void testFailsNodeThatRejectsCheck() {
         final Settings settings = randomSettings();
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
         testBehaviourOfFailingNode(
             settings,
             () -> { throw new OpenSearchException("simulated exception"); },
             "followers check retry count exceeded",
             (FOLLOWER_CHECK_RETRY_COUNT_SETTING.get(settings) - 1) * FOLLOWER_CHECK_INTERVAL_SETTING.get(settings).millis(),
-            () -> new StatusInfo(HEALTHY, "healthy-info")
+            () -> new StatusInfo(HEALTHY, "healthy-info"),
+            metricsRegistry
         );
+        assertEquals(Integer.valueOf(2), metricsRegistry.getCounterStore().get("followers.checker.failure.count").getCounterValue());
     }
 
     public void testFailureCounterResetsOnSuccess() {
         final Settings settings = randomSettings();
         final int retryCount = FOLLOWER_CHECK_RETRY_COUNT_SETTING.get(settings);
         final int maxRecoveries = randomIntBetween(3, 10);
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
 
         // passes just enough checks to keep it alive, up to maxRecoveries, and then fails completely
         testBehaviourOfFailingNode(settings, new Supplier<Empty>() {
@@ -241,18 +256,23 @@ public Empty get() {
             "followers check retry count exceeded",
             (FOLLOWER_CHECK_RETRY_COUNT_SETTING.get(settings) * (maxRecoveries + 1) - 1) * FOLLOWER_CHECK_INTERVAL_SETTING.get(settings)
                 .millis(),
-            () -> new StatusInfo(HEALTHY, "healthy-info")
+            () -> new StatusInfo(HEALTHY, "healthy-info"),
+            metricsRegistry
         );
+        assertEquals(Integer.valueOf(2), metricsRegistry.getCounterStore().get("followers.checker.failure.count").getCounterValue());
     }
 
     public void testFailsNodeThatIsDisconnected() {
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
         testBehaviourOfFailingNode(
             Settings.EMPTY,
             () -> { throw new ConnectTransportException(null, "simulated exception"); },
             "disconnected",
             0,
-            () -> new StatusInfo(HEALTHY, "healthy-info")
+            () -> new StatusInfo(HEALTHY, "healthy-info"),
+            metricsRegistry
         );
+        assertEquals(Integer.valueOf(2), metricsRegistry.getCounterStore().get("followers.checker.failure.count").getCounterValue());
     }
 
     public void testFailsNodeThatDisconnects() {
@@ -297,6 +317,7 @@ public String toString() {
         transportService.acceptIncomingRequests();
 
         final AtomicBoolean nodeFailed = new AtomicBoolean();
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
 
         final FollowersChecker followersChecker = new FollowersChecker(
             settings,
@@ -307,7 +328,8 @@ public String toString() {
                 assertTrue(nodeFailed.compareAndSet(false, true));
                 assertThat(reason, equalTo("disconnected"));
             },
-            () -> new StatusInfo(HEALTHY, "healthy-info")
+            () -> new StatusInfo(HEALTHY, "healthy-info"),
+            new ClusterManagerMetrics(metricsRegistry)
         );
 
         DiscoveryNodes discoveryNodes = DiscoveryNodes.builder().add(localNode).add(otherNode).localNodeId(localNode.getId()).build();
@@ -318,16 +340,20 @@ public String toString() {
         deterministicTaskQueue.runAllRunnableTasks();
         assertTrue(nodeFailed.get());
         assertThat(followersChecker.getFaultyNodes(), contains(otherNode));
+        assertEquals(Integer.valueOf(1), metricsRegistry.getCounterStore().get("followers.checker.failure.count").getCounterValue());
     }
 
     public void testFailsNodeThatIsUnhealthy() {
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
         testBehaviourOfFailingNode(
             randomSettings(),
             () -> { throw new NodeHealthCheckFailureException("non writable exception"); },
             "health check failed",
             0,
-            () -> new StatusInfo(HEALTHY, "healthy-info")
+            () -> new StatusInfo(HEALTHY, "healthy-info"),
+            metricsRegistry
         );
+        assertEquals(Integer.valueOf(2), metricsRegistry.getCounterStore().get("followers.checker.failure.count").getCounterValue());
     }
 
     private void testBehaviourOfFailingNode(
@@ -335,7 +361,8 @@ private void testBehaviourOfFailingNode(
         Supplier<TransportResponse.Empty> responder,
         String failureReason,
         long expectedFailureTime,
-        NodeHealthService nodeHealthService
+        NodeHealthService nodeHealthService,
+        MetricsRegistry metricsRegistry
     ) {
         final DiscoveryNode localNode = new DiscoveryNode("local-node", buildNewFakeTransportAddress(), Version.CURRENT);
         final DiscoveryNode otherNode = new DiscoveryNode("other-node", buildNewFakeTransportAddress(), Version.CURRENT);
@@ -386,7 +413,6 @@ public String toString() {
         transportService.acceptIncomingRequests();
 
         final AtomicBoolean nodeFailed = new AtomicBoolean();
-
         final FollowersChecker followersChecker = new FollowersChecker(
             settings,
             clusterSettings,
@@ -396,7 +422,8 @@ public String toString() {
                 assertTrue(nodeFailed.compareAndSet(false, true));
                 assertThat(reason, equalTo(failureReason));
             },
-            nodeHealthService
+            nodeHealthService,
+            new ClusterManagerMetrics(metricsRegistry)
         );
 
         DiscoveryNodes discoveryNodes = DiscoveryNodes.builder().add(localNode).add(otherNode).localNodeId(localNode.getId()).build();
@@ -501,7 +528,11 @@ protected void onSendRequest(long requestId, String action, TransportRequest req
             if (exception != null) {
                 throw exception;
             }
-        }, (node, reason) -> { assert false : node; }, () -> new StatusInfo(UNHEALTHY, "unhealthy-info"));
+        },
+            (node, reason) -> { assert false : node; },
+            () -> new StatusInfo(UNHEALTHY, "unhealthy-info"),
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
+        );
 
         final long leaderTerm = randomLongBetween(2, Long.MAX_VALUE);
         final long followerTerm = randomLongBetween(1, leaderTerm - 1);
@@ -574,7 +605,11 @@ protected void onSendRequest(long requestId, String action, TransportRequest req
             if (exception != null) {
                 throw exception;
             }
-        }, (node, reason) -> { assert false : node; }, () -> new StatusInfo(HEALTHY, "healthy-info"));
+        },
+            (node, reason) -> { assert false : node; },
+            () -> new StatusInfo(HEALTHY, "healthy-info"),
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
+        );
 
         {
             // Does not call into the coordinator in the normal case
@@ -721,7 +756,11 @@ public void testPreferClusterManagerNodes() {
         );
         final FollowersChecker followersChecker = new FollowersChecker(Settings.EMPTY, clusterSettings, transportService, fcr -> {
             assert false : fcr;
-        }, (node, reason) -> { assert false : node; }, () -> new StatusInfo(HEALTHY, "healthy-info"));
+        },
+            (node, reason) -> { assert false : node; },
+            () -> new StatusInfo(HEALTHY, "healthy-info"),
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
+        );
         followersChecker.setCurrentNodes(discoveryNodes);
         List<DiscoveryNode> followerTargets = Stream.of(capturingTransport.getCapturedRequestsAndClear())
             .map(cr -> cr.node)
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/JoinTaskExecutorTests.java b/server/src/test/java/org/opensearch/cluster/coordination/JoinTaskExecutorTests.java
index 8dc7f3a472b11..e5b8d407af868 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/JoinTaskExecutorTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/JoinTaskExecutorTests.java
@@ -73,6 +73,7 @@
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
@@ -497,8 +498,6 @@ public void testRemoteStoreNodeJoiningNonRemoteStoreClusterMixedMode() {
             .put(MIGRATION_DIRECTION_SETTING.getKey(), RemoteStoreNodeService.Direction.REMOTE_STORE)
             .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed")
             .build();
-        final Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
         Metadata metadata = Metadata.builder().persistentSettings(settings).build();
         ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
             .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
@@ -516,8 +515,6 @@ public void testAllTypesNodeJoiningRemoteStoreClusterMixedMode() {
             .put(MIGRATION_DIRECTION_SETTING.getKey(), RemoteStoreNodeService.Direction.REMOTE_STORE)
             .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed")
             .build();
-        final Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
         Metadata metadata = Metadata.builder().persistentSettings(settings).build();
         ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
             .nodes(
@@ -692,6 +689,100 @@ public void testJoinClusterWithRemoteStateNodeJoiningRemoteStateCluster() {
         JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
     }
 
+    public void testJoinRemotePublicationClusterWithNonRemoteNodes() {
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            remotePublicationNodeAttributes(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        DiscoveryNode joiningNode = newDiscoveryNode(new HashMap<>());
+        JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
+    }
+
+    public void testJoinRemotePublicationCluster() {
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            remotePublicationNodeAttributes(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        DiscoveryNode joiningNode = newDiscoveryNode(remotePublicationNodeAttributes());
+        JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
+    }
+
+    public void testJoinRemotePubClusterWithRemoteStoreNodes() {
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            remotePublicationNodeAttributes(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        Map<String, String> newNodeAttributes = new HashMap<>();
+        newNodeAttributes.putAll(remoteStateNodeAttributes(CLUSTER_STATE_REPO));
+        newNodeAttributes.putAll(remoteRoutingTableAttributes(ROUTING_TABLE_REPO));
+        newNodeAttributes.putAll(remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO));
+
+        DiscoveryNode joiningNode = newDiscoveryNode(newNodeAttributes);
+        Exception e = assertThrows(
+            IllegalStateException.class,
+            () -> JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata())
+        );
+        assertTrue(e.getMessage().equals("a remote store node [" + joiningNode + "] is trying to join a non remote store cluster"));
+    }
+
+    public void testPreventJoinRemotePublicationClusterWithIncompatibleAttributes() {
+        Map<String, String> existingNodeAttributes = remotePublicationNodeAttributes();
+        Map<String, String> remoteStoreNodeAttributes = remotePublicationNodeAttributes();
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            existingNodeAttributes,
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        for (Map.Entry<String, String> nodeAttribute : existingNodeAttributes.entrySet()) {
+            remoteStoreNodeAttributes.put(nodeAttribute.getKey(), null);
+            DiscoveryNode joiningNode = newDiscoveryNode(remoteStoreNodeAttributes);
+            Exception e = assertThrows(
+                IllegalStateException.class,
+                () -> JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata())
+            );
+            assertTrue(
+                e.getMessage().equals("joining node [" + joiningNode + "] doesn't have the node attribute [" + nodeAttribute.getKey() + "]")
+                    || e.getMessage()
+                        .equals(
+                            "a remote store node ["
+                                + joiningNode
+                                + "] is trying to join a remote store cluster with incompatible node attributes in comparison with existing node ["
+                                + currentState.getNodes().getNodes().values().stream().findFirst().get()
+                                + "]"
+                        )
+            );
+
+            remoteStoreNodeAttributes.put(nodeAttribute.getKey(), nodeAttribute.getValue());
+        }
+    }
+
     public void testPreventJoinClusterWithRemoteStateNodeJoiningRemoteStoreCluster() {
         Map<String, String> existingNodeAttributes = remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO);
         final DiscoveryNode existingNode = new DiscoveryNode(
@@ -709,16 +800,7 @@ public void testPreventJoinClusterWithRemoteStateNodeJoiningRemoteStoreCluster()
             IllegalStateException.class,
             () -> JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata())
         );
-        assertTrue(
-            e.getMessage()
-                .equals(
-                    "a remote store node ["
-                        + joiningNode
-                        + "] is trying to join a remote store cluster with incompatible node attributes in comparison with existing node ["
-                        + currentState.getNodes().getNodes().values().stream().findFirst().get()
-                        + "]"
-                )
-        );
+        assertTrue(e.getMessage().equals("a non remote store node [" + joiningNode + "] is trying to join a remote store cluster"));
     }
 
     public void testPreventJoinClusterWithRemoteStoreNodeJoiningRemoteStateCluster() {
@@ -738,16 +820,7 @@ public void testPreventJoinClusterWithRemoteStoreNodeJoiningRemoteStateCluster()
             IllegalStateException.class,
             () -> JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata())
         );
-        assertTrue(
-            e.getMessage()
-                .equals(
-                    "a remote store node ["
-                        + joiningNode
-                        + "] is trying to join a remote store cluster with incompatible node attributes in comparison with existing node ["
-                        + currentState.getNodes().getNodes().values().stream().findFirst().get()
-                        + "]"
-                )
-        );
+        assertTrue(e.getMessage().equals("a remote store node [" + joiningNode + "] is trying to join a non remote store cluster"));
     }
 
     public void testUpdatesClusterStateWithSingleNodeCluster() throws Exception {
@@ -969,9 +1042,6 @@ public void testUpdatesClusterStateWithMultiNodeClusterAndSameRepository() throw
     }
 
     public void testNodeJoinInMixedMode() {
-        Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-        FeatureFlags.initializeFeatureFlags(nodeSettings);
-
         List<Version> versions = allOpenSearchVersions();
         assert versions.size() >= 2 : "test requires at least two open search versions";
         Version baseVersion = versions.get(versions.size() - 2);
@@ -1026,6 +1096,178 @@ public void testNodeJoinInMixedMode() {
         JoinTaskExecutor.ensureNodesCompatibility(joiningNode2, currentNodes, metadata);
     }
 
+    public void testRemoteRoutingTableRepoAbsentNodeJoin() {
+
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        DiscoveryNode joiningNode = newDiscoveryNode(remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO));
+        JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
+    }
+
+    public void testRemoteRoutingTableNodeJoinRepoPresentInJoiningNode() {
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        Map<String, String> attr = remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO);
+        attr.putAll(remoteRoutingTableAttributes(ROUTING_TABLE_REPO));
+        DiscoveryNode joiningNode = newDiscoveryNode(attr);
+        JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
+    }
+
+    public void testRemoteRoutingTableNodeJoinRepoPresentInExistingNode() {
+        Map<String, String> attr = remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO);
+        attr.putAll(remoteRoutingTableAttributes(ROUTING_TABLE_REPO));
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            attr,
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        DiscoveryNode joiningNode = newDiscoveryNode(remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO));
+        assertThrows(
+            IllegalStateException.class,
+            () -> JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata())
+        );
+    }
+
+    public void testRemoteRoutingTableNodeJoinRepoPresentInBothNode() {
+        Map<String, String> attr = remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO);
+        attr.putAll(remoteRoutingTableAttributes(ROUTING_TABLE_REPO));
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            attr,
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        DiscoveryNode joiningNode = newDiscoveryNode(attr);
+        JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
+    }
+
+    public void testRemoteRoutingTableNodeJoinNodeWithRemoteAndRoutingRepoDifference() {
+        Map<String, String> attr = remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO);
+        attr.putAll(remoteRoutingTableAttributes(ROUTING_TABLE_REPO));
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            attr,
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        final DiscoveryNode existingNode2 = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode2).add(existingNode).localNodeId(existingNode.getId()).build())
+            .build();
+
+        DiscoveryNode joiningNode = newDiscoveryNode(attr);
+        JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
+    }
+
+    public void testRemoteRoutingTableNodeJoinNodeWithRemoteAndRoutingRepoDifferenceMixedMode() {
+        Map<String, String> attr = remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO);
+        attr.putAll(remoteRoutingTableAttributes(ROUTING_TABLE_REPO));
+        final DiscoveryNode existingNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            attr,
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        final DiscoveryNode existingNode2 = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        final Settings settings = Settings.builder()
+            .put(MIGRATION_DIRECTION_SETTING.getKey(), RemoteStoreNodeService.Direction.REMOTE_STORE)
+            .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed")
+            .build();
+        final Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+        Metadata metadata = Metadata.builder().persistentSettings(settings).build();
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(existingNode2).add(existingNode).localNodeId(existingNode.getId()).build())
+            .metadata(metadata)
+            .build();
+
+        DiscoveryNode joiningNode = newDiscoveryNode(attr);
+        JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
+    }
+
+    public void testJoinRemoteStoreClusterWithRemotePublicationNodeInMixedMode() {
+        final DiscoveryNode remoteStoreNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            remoteStoreNodeAttributes(SEGMENT_REPO, TRANSLOG_REPO),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        final DiscoveryNode nonRemoteStoreNode = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            new HashMap<>(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+
+        final Settings settings = Settings.builder()
+            .put(MIGRATION_DIRECTION_SETTING.getKey(), RemoteStoreNodeService.Direction.REMOTE_STORE)
+            .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed")
+            .build();
+        final Settings nodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+        Metadata metadata = Metadata.builder().persistentSettings(settings).build();
+        ClusterState currentState = ClusterState.builder(ClusterName.DEFAULT)
+            .nodes(DiscoveryNodes.builder().add(remoteStoreNode).add(nonRemoteStoreNode).localNodeId(remoteStoreNode.getId()).build())
+            .metadata(metadata)
+            .build();
+
+        DiscoveryNode joiningNode = newDiscoveryNode(remotePublicationNodeAttributes());
+        JoinTaskExecutor.ensureNodesCompatibility(joiningNode, currentState.getNodes(), currentState.metadata());
+    }
+
     private void validateRepositoryMetadata(ClusterState updatedState, DiscoveryNode existingNode, int expectedRepositories)
         throws Exception {
 
@@ -1064,9 +1306,11 @@ private DiscoveryNode newDiscoveryNode(Map<String, String> attributes) {
     }
 
     private static final String SEGMENT_REPO = "segment-repo";
+
     private static final String TRANSLOG_REPO = "translog-repo";
     private static final String CLUSTER_STATE_REPO = "cluster-state-repo";
     private static final String COMMON_REPO = "remote-repo";
+    private static final String ROUTING_TABLE_REPO = "routing-table-repo";
 
     private Map<String, String> remoteStoreNodeAttributes(String segmentRepoName, String translogRepoName) {
         return remoteStoreNodeAttributes(segmentRepoName, translogRepoName, CLUSTER_STATE_REPO);
@@ -1109,6 +1353,13 @@ private Map<String, String> remoteStoreNodeAttributes(String segmentRepoName, St
         };
     }
 
+    private Map<String, String> remotePublicationNodeAttributes() {
+        Map<String, String> existingNodeAttributes = new HashMap<>();
+        existingNodeAttributes.putAll(remoteStateNodeAttributes(CLUSTER_STATE_REPO));
+        existingNodeAttributes.putAll(remoteRoutingTableAttributes(ROUTING_TABLE_REPO));
+        return existingNodeAttributes;
+    }
+
     private Map<String, String> remoteStateNodeAttributes(String clusterStateRepo) {
         String clusterStateRepositoryTypeAttributeKey = String.format(
             Locale.getDefault(),
@@ -1131,6 +1382,28 @@ private Map<String, String> remoteStateNodeAttributes(String clusterStateRepo) {
         };
     }
 
+    private Map<String, String> remoteRoutingTableAttributes(String repoName) {
+        String routingTableRepositoryTypeAttributeKey = String.format(
+            Locale.getDefault(),
+            REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+            repoName
+        );
+        String routingTableRepositorySettingsAttributeKeyPrefix = String.format(
+            Locale.getDefault(),
+            REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+            repoName
+        );
+
+        return new HashMap<>() {
+            {
+                put(REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, repoName);
+                putIfAbsent(routingTableRepositoryTypeAttributeKey, "s3");
+                putIfAbsent(routingTableRepositorySettingsAttributeKeyPrefix + "bucket", "state_bucket");
+                putIfAbsent(routingTableRepositorySettingsAttributeKeyPrefix + "base_path", "/state/path");
+            }
+        };
+    }
+
     private void validateAttributes(Map<String, String> remoteStoreNodeAttributes, ClusterState currentState, DiscoveryNode existingNode) {
         DiscoveryNode joiningNode = newDiscoveryNode(remoteStoreNodeAttributes);
         Exception e = assertThrows(
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
index fe65058333116..decdeddfa37a1 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/LeaderCheckerTests.java
@@ -34,6 +34,7 @@
 
 import org.opensearch.OpenSearchException;
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.coordination.LeaderChecker.LeaderCheckRequest;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -44,6 +45,7 @@
 import org.opensearch.core.transport.TransportResponse;
 import org.opensearch.core.transport.TransportResponse.Empty;
 import org.opensearch.monitor.StatusInfo;
+import org.opensearch.telemetry.TestInMemoryMetricsRegistry;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
 import org.opensearch.test.EqualsHashCodeTestUtils;
 import org.opensearch.test.EqualsHashCodeTestUtils.CopyFunction;
@@ -175,11 +177,13 @@ public String toString() {
         transportService.acceptIncomingRequests();
 
         final AtomicBoolean leaderFailed = new AtomicBoolean();
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
+        final ClusterManagerMetrics clusterManagerMetrics = new ClusterManagerMetrics(metricsRegistry);
 
         final LeaderChecker leaderChecker = new LeaderChecker(settings, clusterSettings, transportService, e -> {
             assertThat(e.getMessage(), matchesRegex("node \\[.*\\] failed \\[[1-9][0-9]*\\] consecutive checks"));
             assertTrue(leaderFailed.compareAndSet(false, true));
-        }, () -> new StatusInfo(StatusInfo.Status.HEALTHY, "healthy-info"));
+        }, () -> new StatusInfo(StatusInfo.Status.HEALTHY, "healthy-info"), clusterManagerMetrics);
 
         logger.info("--> creating first checker");
         leaderChecker.updateLeader(leader1);
@@ -229,6 +233,7 @@ public String toString() {
             );
         }
         leaderChecker.updateLeader(null);
+        assertEquals(Integer.valueOf(1), metricsRegistry.getCounterStore().get("leader.checker.failure.count").getCounterValue());
     }
 
     enum Response {
@@ -293,10 +298,13 @@ public String toString() {
         transportService.acceptIncomingRequests();
 
         final AtomicBoolean leaderFailed = new AtomicBoolean();
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
+        final ClusterManagerMetrics clusterManagerMetrics = new ClusterManagerMetrics(metricsRegistry);
+
         final LeaderChecker leaderChecker = new LeaderChecker(settings, clusterSettings, transportService, e -> {
             assertThat(e.getMessage(), anyOf(endsWith("disconnected"), endsWith("disconnected during check")));
             assertTrue(leaderFailed.compareAndSet(false, true));
-        }, () -> new StatusInfo(StatusInfo.Status.HEALTHY, "healthy-info"));
+        }, () -> new StatusInfo(StatusInfo.Status.HEALTHY, "healthy-info"), clusterManagerMetrics);
 
         leaderChecker.updateLeader(leader);
         {
@@ -351,6 +359,7 @@ public String toString() {
             deterministicTaskQueue.runAllRunnableTasks();
             assertTrue(leaderFailed.get());
         }
+        assertEquals(Integer.valueOf(3), metricsRegistry.getCounterStore().get("leader.checker.failure.count").getCounterValue());
     }
 
     public void testFollowerFailsImmediatelyOnHealthCheckFailure() {
@@ -407,10 +416,12 @@ public String toString() {
         transportService.acceptIncomingRequests();
 
         final AtomicBoolean leaderFailed = new AtomicBoolean();
+        TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
+        final ClusterManagerMetrics clusterManagerMetrics = new ClusterManagerMetrics(metricsRegistry);
         final LeaderChecker leaderChecker = new LeaderChecker(settings, clusterSettings, transportService, e -> {
             assertThat(e.getMessage(), endsWith("failed health checks"));
             assertTrue(leaderFailed.compareAndSet(false, true));
-        }, () -> new StatusInfo(StatusInfo.Status.HEALTHY, "healthy-info"));
+        }, () -> new StatusInfo(StatusInfo.Status.HEALTHY, "healthy-info"), clusterManagerMetrics);
 
         leaderChecker.updateLeader(leader);
 
@@ -430,6 +441,8 @@ public String toString() {
 
             assertTrue(leaderFailed.get());
         }
+
+        assertEquals(Integer.valueOf(1), metricsRegistry.getCounterStore().get("leader.checker.failure.count").getCounterValue());
     }
 
     public void testLeaderBehaviour() {
@@ -453,12 +466,15 @@ public void testLeaderBehaviour() {
         transportService.start();
         transportService.acceptIncomingRequests();
 
+        final TestInMemoryMetricsRegistry metricsRegistry = new TestInMemoryMetricsRegistry();
+        final ClusterManagerMetrics clusterManagerMetrics = new ClusterManagerMetrics(metricsRegistry);
         final LeaderChecker leaderChecker = new LeaderChecker(
             settings,
             clusterSettings,
             transportService,
             e -> fail("shouldn't be checking anything"),
-            () -> nodeHealthServiceStatus.get()
+            () -> nodeHealthServiceStatus.get(),
+            clusterManagerMetrics
         );
 
         final DiscoveryNodes discoveryNodes = DiscoveryNodes.builder()
@@ -523,6 +539,7 @@ public void testLeaderBehaviour() {
                 equalTo("rejecting leader check from [" + otherNode + "] sent to a node that is no longer the cluster-manager")
             );
         }
+        assertEquals(Integer.valueOf(0), metricsRegistry.getCounterStore().get("leader.checker.failure.count").getCounterValue());
     }
 
     private class CapturingTransportResponseHandler implements TransportResponseHandler<Empty> {
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java b/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
index d94f3fb304fe2..3a7988bcd2bda 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/NodeJoinTests.java
@@ -33,6 +33,7 @@
 
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.OpenSearchAllocationTestCase;
@@ -61,6 +62,7 @@
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.node.Node;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
 import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
@@ -179,7 +181,8 @@ private void setupRealClusterManagerServiceAndCoordinator(long term, ClusterStat
         ClusterManagerService clusterManagerService = new ClusterManagerService(
             Settings.builder().put(Node.NODE_NAME_SETTING.getKey(), "test_node").build(),
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-            threadPool
+            threadPool,
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
         );
         AtomicReference<ClusterState> clusterStateRef = new AtomicReference<>(initialState);
         clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
@@ -270,7 +273,9 @@ protected void onSendRequest(
             ElectionStrategy.DEFAULT_INSTANCE,
             nodeHealthService,
             persistedStateRegistry,
-            Mockito.mock(RemoteStoreNodeService.class)
+            Mockito.mock(RemoteStoreNodeService.class),
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE),
+            null
         );
         transportService.start();
         transportService.acceptIncomingRequests();
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/PersistedStateStatsTests.java b/server/src/test/java/org/opensearch/cluster/coordination/PersistedStateStatsTests.java
new file mode 100644
index 0000000000000..15c7d3ea206ef
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/coordination/PersistedStateStatsTests.java
@@ -0,0 +1,62 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.coordination;
+
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.util.concurrent.atomic.AtomicLong;
+
+public class PersistedStateStatsTests extends OpenSearchTestCase {
+    private PersistedStateStats persistedStateStats;
+
+    @Before
+    public void setup() {
+        persistedStateStats = new PersistedStateStats("testStats");
+    }
+
+    public void testAddToExtendedFieldsNewField() {
+        String fieldName = "testField";
+        AtomicLong fieldValue = new AtomicLong(42);
+
+        persistedStateStats.addToExtendedFields(fieldName, fieldValue);
+
+        assertTrue(persistedStateStats.getExtendedFields().containsKey(fieldName));
+        assertEquals(42, persistedStateStats.getExtendedFields().get(fieldName).get());
+    }
+
+    public void testAddToExtendedFieldsExistingField() {
+        String fieldName = "testField";
+        AtomicLong initialValue = new AtomicLong(42);
+        persistedStateStats.addToExtendedFields(fieldName, initialValue);
+
+        AtomicLong newValue = new AtomicLong(84);
+        persistedStateStats.addToExtendedFields(fieldName, newValue);
+
+        assertTrue(persistedStateStats.getExtendedFields().containsKey(fieldName));
+        assertEquals(84, persistedStateStats.getExtendedFields().get(fieldName).get());
+    }
+
+    public void testAddMultipleFields() {
+        String fieldName1 = "testField1";
+        AtomicLong fieldValue1 = new AtomicLong(42);
+
+        String fieldName2 = "testField2";
+        AtomicLong fieldValue2 = new AtomicLong(84);
+
+        persistedStateStats.addToExtendedFields(fieldName1, fieldValue1);
+        persistedStateStats.addToExtendedFields(fieldName2, fieldValue2);
+
+        assertTrue(persistedStateStats.getExtendedFields().containsKey(fieldName1));
+        assertTrue(persistedStateStats.getExtendedFields().containsKey(fieldName2));
+
+        assertEquals(42, persistedStateStats.getExtendedFields().get(fieldName1).get());
+        assertEquals(84, persistedStateStats.getExtendedFields().get(fieldName2).get());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/coordination/PublicationTransportHandlerTests.java b/server/src/test/java/org/opensearch/cluster/coordination/PublicationTransportHandlerTests.java
index 6d94054afdea2..266928c919fe2 100644
--- a/server/src/test/java/org/opensearch/cluster/coordination/PublicationTransportHandlerTests.java
+++ b/server/src/test/java/org/opensearch/cluster/coordination/PublicationTransportHandlerTests.java
@@ -37,33 +37,79 @@
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.Diff;
 import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfiguration;
+import org.opensearch.cluster.coordination.PersistedStateRegistry.PersistedStateType;
+import org.opensearch.cluster.coordination.PublicationTransportHandler.PublicationContext;
+import org.opensearch.cluster.coordination.PublicationTransportHandler.RemotePublicationContext;
+import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.gateway.GatewayMetaState.RemotePersistedState;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.ClusterStateDiffManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateService;
 import org.opensearch.node.Node;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.CapturingTransport;
+import org.opensearch.test.transport.CapturingTransport.CapturedRequest;
 import org.opensearch.transport.TransportService;
+import org.junit.Before;
 
 import java.io.IOException;
 import java.util.Collections;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Function;
 
+import org.mockito.Mockito;
+
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 
 public class PublicationTransportHandlerTests extends OpenSearchTestCase {
 
-    public void testDiffSerializationFailure() {
-        DeterministicTaskQueue deterministicTaskQueue = new DeterministicTaskQueue(
+    private static final long TERM = 5;
+    private static final long VERSION = 5;
+    private static final String CLUSTER_NAME = "test-cluster";
+    private static final String CLUSTER_UUID = "test-cluster-UUID";
+    private static final String MANIFEST_FILE = "path/to/manifest";
+    private static final String LOCAL_NODE_ID = "localNode";
+
+    private DeterministicTaskQueue deterministicTaskQueue;
+    private TransportService transportService;
+    private DiscoveryNode localNode;
+    private DiscoveryNode secondNode;
+
+    private CapturingTransport capturingTransport;
+
+    @Before
+    public void setup() {
+        deterministicTaskQueue = new DeterministicTaskQueue(
             Settings.builder().put(Node.NODE_NAME_SETTING.getKey(), "test").build(),
             random()
         );
         final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        final DiscoveryNode localNode = new DiscoveryNode("localNode", buildNewFakeTransportAddress(), Version.CURRENT);
-        final TransportService transportService = new CapturingTransport().createTransportService(
+        localNode = new DiscoveryNode(LOCAL_NODE_ID, buildNewFakeTransportAddress(), Version.CURRENT);
+        secondNode = new DiscoveryNode("secondNode", buildNewFakeTransportAddress(), Version.CURRENT);
+        capturingTransport = new CapturingTransport();
+        transportService = capturingTransport.createTransportService(
             Settings.EMPTY,
             deterministicTaskQueue.getThreadPool(),
             TransportService.NOOP_TRANSPORT_INTERCEPTOR,
@@ -72,14 +118,10 @@ public void testDiffSerializationFailure() {
             Collections.emptySet(),
             NoopTracer.INSTANCE
         );
-        final PublicationTransportHandler handler = new PublicationTransportHandler(
-            transportService,
-            writableRegistry(),
-            pu -> null,
-            (pu, l) -> {}
-        );
-        transportService.start();
-        transportService.acceptIncomingRequests();
+    }
+
+    public void testDiffSerializationFailure() {
+        final PublicationTransportHandler handler = getPublicationTransportHandler(p -> null, null);
 
         final DiscoveryNode otherNode = new DiscoveryNode("otherNode", buildNewFakeTransportAddress(), Version.CURRENT);
         final ClusterState clusterState = CoordinationStateTests.clusterState(
@@ -111,10 +153,381 @@ public void writeTo(StreamOutput out) throws IOException {
 
         OpenSearchException e = expectThrows(
             OpenSearchException.class,
-            () -> handler.newPublicationContext(new ClusterChangedEvent("test", unserializableClusterState, clusterState))
+            () -> handler.newPublicationContext(new ClusterChangedEvent("test", unserializableClusterState, clusterState), false, null)
         );
         assertNotNull(e.getCause());
         assertThat(e.getCause(), instanceOf(IOException.class));
         assertThat(e.getCause().getMessage(), containsString("Simulated failure of diff serialization"));
     }
+
+    public void testHandleIncomingRemotePublishRequestWhenNoCurrentPublishRequest() {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+            localNode,
+            TERM,
+            VERSION,
+            CLUSTER_NAME,
+            CLUSTER_UUID,
+            MANIFEST_FILE
+        );
+
+        IllegalStateException e = expectThrows(
+            IllegalStateException.class,
+            () -> handler.handleIncomingRemotePublishRequest(remotePublishRequest)
+        );
+        assertThat(e.getMessage(), containsString("publication to self failed"));
+        verify(remoteClusterStateService, times(0)).fullDownloadFailed();
+        verify(remoteClusterStateService, times(1)).diffDownloadFailed();
+        verifyNoMoreInteractions(remoteClusterStateService);
+    }
+
+    public void testHandleIncomingRemotePublishRequestWhenTermMismatch() {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+            localNode,
+            TERM,
+            VERSION,
+            CLUSTER_NAME,
+            CLUSTER_UUID,
+            MANIFEST_FILE
+        );
+        ClusterState clusterState = buildClusterState(6L, VERSION);
+        PublishRequest publishRequest = new PublishRequest(clusterState);
+        handler.setCurrentPublishRequestToSelf(publishRequest);
+        IllegalStateException e = expectThrows(
+            IllegalStateException.class,
+            () -> handler.handleIncomingRemotePublishRequest(remotePublishRequest)
+        );
+        assertThat(e.getMessage(), containsString("publication to self failed"));
+        verify(remoteClusterStateService, times(0)).fullDownloadFailed();
+        verify(remoteClusterStateService, times(1)).diffDownloadFailed();
+        verifyNoMoreInteractions(remoteClusterStateService);
+    }
+
+    public void testHandleIncomingRemotePublishRequestWhenVersionMismatch() {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+            localNode,
+            TERM,
+            VERSION,
+            CLUSTER_NAME,
+            CLUSTER_UUID,
+            MANIFEST_FILE
+        );
+        ClusterState clusterState = buildClusterState(TERM, 11L);
+        PublishRequest publishRequest = new PublishRequest(clusterState);
+        handler.setCurrentPublishRequestToSelf(publishRequest);
+        IllegalStateException e = expectThrows(
+            IllegalStateException.class,
+            () -> handler.handleIncomingRemotePublishRequest(remotePublishRequest)
+        );
+        assertThat(e.getMessage(), containsString("publication to self failed"));
+        verify(remoteClusterStateService, times(1)).diffDownloadFailed();
+        verify(remoteClusterStateService, times(0)).fullDownloadFailed();
+        verifyNoMoreInteractions(remoteClusterStateService);
+    }
+
+    public void testHandleIncomingRemotePublishRequestForLocalNode() throws IOException {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+            localNode,
+            TERM,
+            VERSION,
+            CLUSTER_NAME,
+            CLUSTER_UUID,
+            MANIFEST_FILE
+        );
+        ClusterState clusterState = buildClusterState(TERM, VERSION);
+        PublishRequest publishRequest = new PublishRequest(clusterState);
+        handler.setCurrentPublishRequestToSelf(publishRequest);
+        PublishWithJoinResponse publishWithJoinResponse = handler.handleIncomingRemotePublishRequest(remotePublishRequest);
+        assertThat(publishWithJoinResponse, is(expectedPublishResponse));
+        Mockito.verifyNoInteractions(remoteClusterStateService);
+    }
+
+    public void testDownloadRemotePersistedFullStateFailedStats() throws IOException {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+        PersistedStateStats remoteFullDownloadStats = new PersistedStateStats("dummy_full_stats");
+        PersistedStateStats remoteDiffDownloadStats = new PersistedStateStats("dummy_diff_stats");
+        when(remoteClusterStateService.getFullDownloadStats()).thenReturn(remoteFullDownloadStats);
+        when(remoteClusterStateService.getDiffDownloadStats()).thenReturn(remoteDiffDownloadStats);
+
+        doAnswer((i) -> {
+            remoteFullDownloadStats.stateFailed();
+            return null;
+        }).when(remoteClusterStateService).fullDownloadFailed();
+
+        doAnswer((i) -> {
+            remoteDiffDownloadStats.stateFailed();
+            return null;
+        }).when(remoteClusterStateService).diffDownloadFailed();
+
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+            secondNode,
+            TERM,
+            VERSION,
+            CLUSTER_NAME,
+            CLUSTER_UUID,
+            MANIFEST_FILE
+        );
+        ClusterState clusterState = buildClusterState(TERM, VERSION);
+        PublishRequest publishRequest = new PublishRequest(clusterState);
+        handler.setCurrentPublishRequestToSelf(publishRequest);
+
+        assertThrows(IllegalStateException.class, () -> handler.handleIncomingRemotePublishRequest(remotePublishRequest));
+        assertEquals(1, remoteClusterStateService.getDiffDownloadStats().getFailedCount());
+        assertEquals(0, remoteClusterStateService.getFullDownloadStats().getFailedCount());
+    }
+
+    public void testDownloadRemotePersistedDiffStateFailedStats() throws IOException {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+        PersistedStateStats remoteDiffDownloadStats = new PersistedStateStats("dummy_stats");
+        when(remoteClusterStateService.getDiffDownloadStats()).thenReturn(remoteDiffDownloadStats);
+
+        ClusterMetadataManifest metadataManifest = new ClusterMetadataManifest.Builder().diffManifest(
+            new ClusterStateDiffManifest.Builder().fromStateUUID("state-uuid").build()
+        ).build();
+        when(remoteClusterStateService.getClusterMetadataManifestByFileName(any(), any())).thenReturn(metadataManifest);
+
+        doAnswer((i) -> {
+            remoteDiffDownloadStats.stateFailed();
+            return null;
+        }).when(remoteClusterStateService).diffDownloadFailed();
+
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        ClusterState clusterState = mock(ClusterState.class);
+        when(clusterState.nodes()).thenReturn(mock(DiscoveryNodes.class));
+        handler.setLastSeenClusterState(clusterState);
+        when(clusterState.stateUUID()).thenReturn("state-uuid");
+        RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+            secondNode,
+            TERM,
+            VERSION,
+            CLUSTER_NAME,
+            CLUSTER_UUID,
+            MANIFEST_FILE
+        );
+        clusterState = buildClusterState(TERM, VERSION);
+        PublishRequest publishRequest = new PublishRequest(clusterState);
+        handler.setCurrentPublishRequestToSelf(publishRequest);
+
+        assertThrows(NullPointerException.class, () -> handler.handleIncomingRemotePublishRequest(remotePublishRequest));
+        assertEquals(1, remoteClusterStateService.getDiffDownloadStats().getFailedCount());
+
+    }
+
+    public void testHandleIncomingRemotePublishRequestWhenManifestNotFound() throws IOException {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+            secondNode,
+            TERM,
+            VERSION,
+            CLUSTER_NAME,
+            CLUSTER_UUID,
+            MANIFEST_FILE
+        );
+        when(remoteClusterStateService.getClusterMetadataManifestByFileName(CLUSTER_UUID, MANIFEST_FILE)).thenReturn(null);
+        ClusterState clusterState = buildClusterState(TERM, VERSION);
+        PublishRequest publishRequest = new PublishRequest(clusterState);
+        handler.setCurrentPublishRequestToSelf(publishRequest);
+        IllegalStateException e = expectThrows(
+            IllegalStateException.class,
+            () -> handler.handleIncomingRemotePublishRequest(remotePublishRequest)
+        );
+        assertThat(e.getMessage(), containsString("Publication failed as manifest was not found for"));
+        Mockito.verify(remoteClusterStateService, times(1)).getClusterMetadataManifestByFileName(Mockito.any(), Mockito.any());
+    }
+
+    public void testHandleIncomingRemotePublishRequestWhenNoLastSeenState() throws IOException {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        RemotePublishRequest remotePublishRequest = new RemotePublishRequest(
+            secondNode,
+            TERM,
+            VERSION,
+            CLUSTER_NAME,
+            CLUSTER_UUID,
+            MANIFEST_FILE
+        );
+        ClusterMetadataManifest manifest = ClusterMetadataManifest.builder().clusterTerm(TERM).stateVersion(VERSION).build();
+        when(remoteClusterStateService.getClusterMetadataManifestByFileName(CLUSTER_UUID, MANIFEST_FILE)).thenReturn(manifest);
+        when(remoteClusterStateService.getClusterStateForManifest(CLUSTER_NAME, manifest, LOCAL_NODE_ID, true)).thenReturn(
+            buildClusterState(TERM, VERSION)
+        );
+        ClusterState clusterState = buildClusterState(TERM, VERSION);
+        PublishRequest publishRequest = new PublishRequest(clusterState);
+        handler.setCurrentPublishRequestToSelf(publishRequest);
+        PublishWithJoinResponse publishWithJoinResponse = handler.handleIncomingRemotePublishRequest(remotePublishRequest);
+        assertThat(publishWithJoinResponse, is(expectedPublishResponse));
+        Mockito.verify(remoteClusterStateService, times(1)).getClusterMetadataManifestByFileName(Mockito.any(), Mockito.any());
+    }
+
+    public void testNewPublicationContext() {
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+
+        // Remote publication disabled
+        ClusterChangedEvent event1 = new ClusterChangedEvent(
+            "source1",
+            buildClusterState(TERM, VERSION + 1),
+            buildClusterState(TERM, VERSION)
+        );
+        PublicationContext publicationContext = handler.newPublicationContext(event1, false, new PersistedStateRegistry());
+        assertNotNull(publicationContext);
+        assertThat(publicationContext, not(instanceOf(RemotePublicationContext.class)));
+
+        // Remote publication enabled but some nodes are remote enabled and some remote disabled
+        ClusterChangedEvent event2 = new ClusterChangedEvent(
+            "source2",
+            buildClusterStateWithMixedNodes(TERM, VERSION + 1),
+            buildClusterState(TERM, VERSION)
+        );
+        PublicationContext publicationContext2 = handler.newPublicationContext(event2, true, new PersistedStateRegistry());
+        assertNotNull(publicationContext2);
+        assertThat(publicationContext2, not(instanceOf(RemotePublicationContext.class)));
+
+        // Remote publication enabled and all nodes are remote enabled
+        ClusterChangedEvent event3 = new ClusterChangedEvent(
+            "source3",
+            buildClusterStateWithRemoteNodes(TERM, VERSION + 1),
+            buildClusterState(TERM, VERSION)
+        );
+        PublicationContext publicationContext3 = handler.newPublicationContext(event3, true, new PersistedStateRegistry());
+        assertNotNull(publicationContext3);
+        assertThat(publicationContext3, instanceOf(RemotePublicationContext.class));
+    }
+
+    public void testRemotePublicationContext() throws Exception {
+        ClusterChangedEvent event = new ClusterChangedEvent(
+            "source3",
+            buildClusterStateWithRemoteNodes(TERM, VERSION + 1),
+            buildClusterState(TERM, VERSION)
+        );
+        RemoteClusterStateService remoteClusterStateService = mock(RemoteClusterStateService.class);
+        PublishWithJoinResponse expectedPublishResponse = new PublishWithJoinResponse(new PublishResponse(TERM, VERSION), Optional.empty());
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest = p -> expectedPublishResponse;
+        final PublicationTransportHandler handler = getPublicationTransportHandler(handlePublishRequest, remoteClusterStateService);
+        PersistedStateRegistry persistedStateRegistry = new PersistedStateRegistry();
+        RemotePersistedState remotePersistedState = mock(RemotePersistedState.class);
+        when(remotePersistedState.getLastUploadedManifestFile()).thenReturn("/path/to/manifest");
+        persistedStateRegistry.addPersistedState(PersistedStateType.REMOTE, remotePersistedState);
+
+        PublicationContext publicationContext3 = handler.newPublicationContext(event, true, persistedStateRegistry);
+        ActionListener<PublishWithJoinResponse> listener = new ActionListener<>() {
+            @Override
+            public void onResponse(PublishWithJoinResponse publishWithJoinResponse) {}
+
+            @Override
+            public void onFailure(Exception e) {}
+        };
+        DiscoveryNode discoveryNode = new DiscoveryNode("node1", buildNewFakeTransportAddress(), Version.CURRENT);
+        publicationContext3.sendClusterState(discoveryNode, listener);
+        CapturedRequest[] capturedRequests1 = capturingTransport.getCapturedRequestsAndClear();
+        assertThat(capturedRequests1.length, equalTo(1));
+        CapturedRequest capturedRequest1 = capturedRequests1[0];
+        assertThat(capturedRequest1.request, instanceOf(RemotePublishRequest.class));
+    }
+
+    private PublicationTransportHandler getPublicationTransportHandler(
+        Function<PublishRequest, PublishWithJoinResponse> handlePublishRequest,
+        RemoteClusterStateService remoteClusterStateService
+    ) {
+        final PublicationTransportHandler handler = new PublicationTransportHandler(
+            transportService,
+            writableRegistry(),
+            handlePublishRequest,
+            (pu, l) -> {},
+            remoteClusterStateService
+        );
+        transportService.start();
+        transportService.acceptIncomingRequests();
+        return handler;
+    }
+
+    private ClusterState buildClusterState(long term, long version) {
+        CoordinationMetadata.Builder coordMetadataBuilder = CoordinationMetadata.builder().term(term);
+        Metadata newMetadata = Metadata.builder().coordinationMetadata(coordMetadataBuilder.build()).build();
+        DiscoveryNodes nodes = DiscoveryNodes.builder().add(localNode).add(secondNode).localNodeId(LOCAL_NODE_ID).build();
+        return ClusterState.builder(ClusterState.EMPTY_STATE).version(version).metadata(newMetadata).nodes(nodes).build();
+    }
+
+    private ClusterState buildClusterStateWithMixedNodes(long term, long version) {
+        CoordinationMetadata.Builder coordMetadataBuilder = CoordinationMetadata.builder().term(term);
+        Metadata newMetadata = Metadata.builder().coordinationMetadata(coordMetadataBuilder.build()).build();
+        DiscoveryNode remoteNode = new DiscoveryNode(
+            "remoteNode",
+            buildNewFakeTransportAddress(),
+            Map.of(
+                REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+                "remote_state_repo",
+                REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+                "remote_routing_repo"
+            ),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        DiscoveryNodes nodes = DiscoveryNodes.builder().add(localNode).add(remoteNode).localNodeId(LOCAL_NODE_ID).build();
+        return ClusterState.builder(ClusterState.EMPTY_STATE).version(version).metadata(newMetadata).nodes(nodes).build();
+    }
+
+    private ClusterState buildClusterStateWithRemoteNodes(long term, long version) {
+        CoordinationMetadata.Builder coordMetadataBuilder = CoordinationMetadata.builder().term(term);
+        Metadata newMetadata = Metadata.builder().coordinationMetadata(coordMetadataBuilder.build()).build();
+        DiscoveryNode remoteNode1 = new DiscoveryNode(
+            "remoteNode1",
+            buildNewFakeTransportAddress(),
+            Map.of(
+                REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+                "remote_state_repo",
+                REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+                "remote_routing_repo"
+            ),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        DiscoveryNode remoteNode2 = new DiscoveryNode(
+            "remoteNode2",
+            buildNewFakeTransportAddress(),
+            Map.of(
+                REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+                "remote_state_repo",
+                REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+                "remote_routing_repo"
+            ),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        DiscoveryNodes nodes = DiscoveryNodes.builder().add(remoteNode1).add(remoteNode2).localNodeId(remoteNode1.getId()).build();
+        return ClusterState.builder(ClusterState.EMPTY_STATE).version(version).metadata(newMetadata).nodes(nodes).build();
+    }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/IndexMetadataTests.java b/server/src/test/java/org/opensearch/cluster/metadata/IndexMetadataTests.java
index 393a652952771..698ace4105d75 100644
--- a/server/src/test/java/org/opensearch/cluster/metadata/IndexMetadataTests.java
+++ b/server/src/test/java/org/opensearch/cluster/metadata/IndexMetadataTests.java
@@ -52,6 +52,7 @@
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 import org.opensearch.indices.IndicesModule;
 import org.opensearch.test.OpenSearchTestCase;
 import org.junit.Before;
@@ -118,6 +119,7 @@ public void testIndexMetadataSerialization() throws IOException {
                     randomNonNegativeLong()
                 )
             )
+            .context(new Context(randomAlphaOfLength(5)))
             .build();
         assertEquals(system, metadata.isSystem());
 
@@ -145,6 +147,7 @@ public void testIndexMetadataSerialization() throws IOException {
         assertEquals(metadata.getRoutingFactor(), fromXContentMeta.getRoutingFactor());
         assertEquals(metadata.primaryTerm(0), fromXContentMeta.primaryTerm(0));
         assertEquals(metadata.isSystem(), fromXContentMeta.isSystem());
+        assertEquals(metadata.context(), fromXContentMeta.context());
         final Map<String, DiffableStringMap> expectedCustom = Map.of("my_custom", new DiffableStringMap(customMap));
         assertEquals(metadata.getCustomData(), expectedCustom);
         assertEquals(metadata.getCustomData(), fromXContentMeta.getCustomData());
@@ -167,9 +170,90 @@ public void testIndexMetadataSerialization() throws IOException {
             assertEquals(deserialized.getCustomData(), expectedCustom);
             assertEquals(metadata.getCustomData(), deserialized.getCustomData());
             assertEquals(metadata.isSystem(), deserialized.isSystem());
+            assertEquals(metadata.context(), deserialized.context());
         }
     }
 
+    public void testWriteVerifiableTo() throws IOException {
+        int numberOfReplicas = randomIntBetween(0, 10);
+        final boolean system = randomBoolean();
+        Map<String, String> customMap = new HashMap<>();
+        customMap.put(randomAlphaOfLength(5), randomAlphaOfLength(10));
+        customMap.put(randomAlphaOfLength(10), randomAlphaOfLength(15));
+
+        RolloverInfo info1 = new RolloverInfo(
+            randomAlphaOfLength(5),
+            Arrays.asList(
+                new MaxAgeCondition(TimeValue.timeValueMillis(randomNonNegativeLong())),
+                new MaxSizeCondition(new ByteSizeValue(randomNonNegativeLong())),
+                new MaxDocsCondition(randomNonNegativeLong())
+            ),
+            randomNonNegativeLong()
+        );
+        RolloverInfo info2 = new RolloverInfo(
+            randomAlphaOfLength(5),
+            Arrays.asList(
+                new MaxAgeCondition(TimeValue.timeValueMillis(randomNonNegativeLong())),
+                new MaxSizeCondition(new ByteSizeValue(randomNonNegativeLong())),
+                new MaxDocsCondition(randomNonNegativeLong())
+            ),
+            randomNonNegativeLong()
+        );
+
+        IndexMetadata metadata1 = IndexMetadata.builder("foo")
+            .settings(
+                Settings.builder()
+                    .put("index.version.created", 1)
+                    .put("index.number_of_shards", 4)
+                    .put("index.number_of_replicas", numberOfReplicas)
+                    .build()
+            )
+            .creationDate(randomLong())
+            .primaryTerm(0, 2)
+            .primaryTerm(1, 3)
+            .setRoutingNumShards(32)
+            .system(system)
+            .putCustom("my_custom", customMap)
+            .putCustom("my_custom2", customMap)
+            .putAlias(AliasMetadata.builder("alias-1").routing("routing-1").build())
+            .putAlias(AliasMetadata.builder("alias-2").routing("routing-2").build())
+            .putRolloverInfo(info1)
+            .putRolloverInfo(info2)
+            .putInSyncAllocationIds(0, Set.of("1", "2", "3"))
+            .build();
+
+        BytesStreamOutput out = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out);
+        metadata1.writeVerifiableTo(checksumOut);
+
+        IndexMetadata metadata2 = IndexMetadata.builder(metadata1.getIndex().getName())
+            .settings(
+                Settings.builder()
+                    .put("index.number_of_replicas", numberOfReplicas)
+                    .put("index.number_of_shards", 4)
+                    .put("index.version.created", 1)
+                    .build()
+            )
+            .creationDate(metadata1.getCreationDate())
+            .primaryTerm(1, 3)
+            .primaryTerm(0, 2)
+            .setRoutingNumShards(32)
+            .system(system)
+            .putCustom("my_custom2", customMap)
+            .putCustom("my_custom", customMap)
+            .putAlias(AliasMetadata.builder("alias-2").routing("routing-2").build())
+            .putAlias(AliasMetadata.builder("alias-1").routing("routing-1").build())
+            .putRolloverInfo(info2)
+            .putRolloverInfo(info1)
+            .putInSyncAllocationIds(0, Set.of("3", "1", "2"))
+            .build();
+
+        BytesStreamOutput out2 = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut2 = new BufferedChecksumStreamOutput(out2);
+        metadata2.writeVerifiableTo(checksumOut2);
+        assertEquals(checksumOut.getChecksum(), checksumOut2.getChecksum());
+    }
+
     public void testGetRoutingFactor() {
         Integer numShard = randomFrom(1, 2, 4, 8, 16);
         int routingFactor = IndexMetadata.getRoutingFactor(32, numShard);
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/IndexTemplateMetadataTests.java b/server/src/test/java/org/opensearch/cluster/metadata/IndexTemplateMetadataTests.java
index 0ea2834cc3024..993cefb050ff7 100644
--- a/server/src/test/java/org/opensearch/cluster/metadata/IndexTemplateMetadataTests.java
+++ b/server/src/test/java/org/opensearch/cluster/metadata/IndexTemplateMetadataTests.java
@@ -31,17 +31,20 @@
 
 package org.opensearch.cluster.metadata;
 
+import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.XContentHelper;
 import org.opensearch.common.xcontent.json.JsonXContent;
 import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.xcontent.DeprecationHandler;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
@@ -232,6 +235,50 @@ public void testFromToXContent() throws Exception {
         }
     }
 
+    public void testWriteVerifiableTo() throws Exception {
+        String templateName = randomUnicodeOfCodepointLengthBetween(1, 10);
+        IndexTemplateMetadata.Builder templateBuilder = IndexTemplateMetadata.builder(templateName);
+        templateBuilder.patterns(Arrays.asList("pattern-1", "pattern-2"));
+        int numAlias = between(2, 5);
+        for (int i = 0; i < numAlias; i++) {
+            AliasMetadata.Builder alias = AliasMetadata.builder(randomRealisticUnicodeOfLengthBetween(1, 100));
+            alias.indexRouting(randomRealisticUnicodeOfLengthBetween(1, 100));
+            alias.searchRouting(randomRealisticUnicodeOfLengthBetween(1, 100));
+            templateBuilder.putAlias(alias);
+        }
+        templateBuilder.settings(Settings.builder().put("index.setting-1", randomLong()));
+        templateBuilder.settings(Settings.builder().put("index.setting-2", randomTimeValue()));
+        templateBuilder.order(randomInt());
+        templateBuilder.version(between(0, 100));
+        templateBuilder.putMapping("doc", "{\"doc\":{\"properties\":{\"type\":\"text\"}}}");
+
+        IndexTemplateMetadata template = templateBuilder.build();
+        BytesStreamOutput out = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out);
+        template.writeVerifiableTo(checksumOut);
+        StreamInput in = out.bytes().streamInput();
+        IndexTemplateMetadata result = IndexTemplateMetadata.readFrom(in);
+        assertEquals(result, template);
+
+        IndexTemplateMetadata.Builder templateBuilder2 = IndexTemplateMetadata.builder(templateName);
+        templateBuilder2.patterns(Arrays.asList("pattern-2", "pattern-1"));
+        template.getAliases()
+            .entrySet()
+            .stream()
+            .sorted(Map.Entry.comparingByKey())
+            .forEachOrdered(entry -> templateBuilder2.putAlias(entry.getValue()));
+        templateBuilder2.settings(template.settings());
+        templateBuilder2.order(template.order());
+        templateBuilder2.version(template.version());
+        templateBuilder2.putMapping("doc", template.mappings());
+
+        IndexTemplateMetadata template2 = templateBuilder.build();
+        BytesStreamOutput out2 = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut2 = new BufferedChecksumStreamOutput(out2);
+        template2.writeVerifiableTo(checksumOut2);
+        assertEquals(checksumOut.getChecksum(), checksumOut2.getChecksum());
+    }
+
     public void testDeprecationWarningsOnMultipleMappings() throws IOException {
         IndexTemplateMetadata.Builder builder = IndexTemplateMetadata.builder("my-template");
         builder.patterns(Arrays.asList("a", "b"));
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java b/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
index de1d422d6016b..5ffe5cedc8286 100644
--- a/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/metadata/MetadataCreateIndexServiceTests.java
@@ -57,6 +57,7 @@
 import org.opensearch.cluster.routing.allocation.decider.MaxRetryAllocationDecider;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.UUIDs;
+import org.opensearch.common.ValidationException;
 import org.opensearch.common.blobstore.BlobStore;
 import org.opensearch.common.compress.CompressedXContent;
 import org.opensearch.common.settings.ClusterSettings;
@@ -67,12 +68,16 @@
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.common.xcontent.json.JsonXContent;
 import org.opensearch.core.index.Index;
+import org.opensearch.core.xcontent.DeprecationHandler;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.env.Environment;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.IndexNotFoundException;
 import org.opensearch.index.IndexSettings;
+import org.opensearch.index.engine.EngineConfig;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
@@ -82,6 +87,7 @@
 import org.opensearch.indices.IndexCreationException;
 import org.opensearch.indices.IndicesService;
 import org.opensearch.indices.InvalidAliasNameException;
+import org.opensearch.indices.InvalidIndexContextException;
 import org.opensearch.indices.InvalidIndexNameException;
 import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.indices.ShardLimitValidator;
@@ -115,8 +121,11 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.TreeMap;
 import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -148,6 +157,7 @@
 import static org.opensearch.cluster.metadata.MetadataCreateIndexService.resolveAndValidateAliases;
 import static org.opensearch.common.util.FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL;
 import static org.opensearch.index.IndexModule.INDEX_STORE_TYPE_SETTING;
+import static org.opensearch.index.IndexSettings.INDEX_MERGE_POLICY;
 import static org.opensearch.index.IndexSettings.INDEX_REFRESH_INTERVAL_SETTING;
 import static org.opensearch.index.IndexSettings.INDEX_REMOTE_TRANSLOG_BUFFER_INTERVAL_SETTING;
 import static org.opensearch.index.IndexSettings.INDEX_SOFT_DELETES_SETTING;
@@ -159,6 +169,7 @@
 import static org.opensearch.indices.IndicesService.CLUSTER_REPLICATION_TYPE_SETTING;
 import static org.opensearch.indices.ShardLimitValidatorTests.createTestShardLimitService;
 import static org.opensearch.node.Node.NODE_ATTRIBUTES;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.getRemoteStoreTranslogRepo;
@@ -1205,7 +1216,7 @@ public void testParseMappingsWithTypelessTemplate() throws Exception {
         assertThat(mappings, Matchers.hasKey(MapperService.SINGLE_MAPPING_NAME));
     }
 
-    public void testvalidateIndexSettings() {
+    public void testValidateIndexSettings() {
         ClusterService clusterService = mock(ClusterService.class);
         Metadata metadata = Metadata.builder()
             .transientSettings(Settings.builder().put(Metadata.DEFAULT_REPLICA_COUNT_SETTING.getKey(), 1).build())
@@ -1603,7 +1614,7 @@ public void testNewIndexIsRemoteStoreBackedForRemoteStoreDirectionAndMixedMode()
 
         ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
 
-        request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test");
+        request = new CreateIndexClusterStateUpdateRequest("create index", "test-index", "test-index");
 
         Settings indexSettings = aggregateIndexSettings(
             clusterState,
@@ -1653,7 +1664,12 @@ public void testNewIndexIsRemoteStoreBackedForRemoteStoreDirectionAndMixedMode()
             null
         );
 
-        Map<String, String> missingTranslogAttribute = Map.of(REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-segment-repo-1");
+        Map<String, String> missingTranslogAttribute = Map.of(
+            REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            "cluster-state-repo-1",
+            REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            "my-segment-repo-1"
+        );
 
         DiscoveryNodes finalDiscoveryNodes = DiscoveryNodes.builder()
             .add(nonRemoteClusterManagerNode)
@@ -1684,7 +1700,7 @@ public void testNewIndexIsRemoteStoreBackedForRemoteStoreDirectionAndMixedMode()
                 finalClusterSettings
             );
         });
-
+        assertEquals(error.getMessage(), "failed to create index [test-index]");
         assertThat(
             error.getCause().getMessage(),
             containsString("Cluster is migrating to remote store but no remote node found, failing index creation")
@@ -1713,7 +1729,8 @@ public void testBuildIndexMetadata() {
             4,
             sourceIndexMetadata,
             false,
-            new HashMap<>()
+            new HashMap<>(),
+            null
         );
 
         assertThat(indexMetadata.getAliases().size(), is(1));
@@ -2160,6 +2177,33 @@ public void testAsyncDurabilityThrowsExceptionWhenRestrictSettingTrue() {
         );
     }
 
+    public void testAggregateIndexSettingsIndexReplicaIsSetToNull() {
+        // This checks that aggregateIndexSettings works for the case when the index setting `index.number_of_replicas` is set to null
+        request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test");
+        request.settings(Settings.builder().putNull(SETTING_NUMBER_OF_REPLICAS).build());
+        Integer clusterDefaultReplicaNumber = 5;
+        Metadata metadata = new Metadata.Builder().persistentSettings(
+            Settings.builder().put("cluster.default_number_of_replicas", clusterDefaultReplicaNumber).build()
+        ).build();
+        ClusterState clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .build();
+        Settings settings = Settings.builder().put(CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING.getKey(), true).build();
+        clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        Settings aggregatedSettings = aggregateIndexSettings(
+            clusterState,
+            request,
+            Settings.EMPTY,
+            null,
+            Settings.EMPTY,
+            IndexScopedSettings.DEFAULT_SCOPED_SETTINGS,
+            randomShardLimitService(),
+            Collections.emptySet(),
+            clusterSettings
+        );
+        assertEquals(clusterDefaultReplicaNumber.toString(), aggregatedSettings.get(SETTING_NUMBER_OF_REPLICAS));
+    }
+
     public void testRequestDurabilityWhenRestrictSettingTrue() {
         // This checks that aggregateIndexSettings works for the case when the cluster setting
         // cluster.remote_store.index.restrict.async-durability is false or not set, it allows all types of durability modes
@@ -2213,6 +2257,262 @@ public void testIndexCreationWithIndexStoreTypeRemoteStoreThrowsException() {
         );
     }
 
+    public void testCreateIndexWithContextDisabled() throws Exception {
+        request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test").context(new Context(randomAlphaOfLength(5)));
+        withTemporaryClusterService((clusterService, threadPool) -> {
+            MetadataCreateIndexService checkerService = new MetadataCreateIndexService(
+                Settings.EMPTY,
+                clusterService,
+                indicesServices,
+                null,
+                null,
+                createTestShardLimitService(randomIntBetween(1, 1000), false, clusterService),
+                mock(Environment.class),
+                IndexScopedSettings.DEFAULT_SCOPED_SETTINGS,
+                threadPool,
+                null,
+                new SystemIndices(Collections.emptyMap()),
+                false,
+                new AwarenessReplicaBalance(Settings.EMPTY, clusterService.getClusterSettings()),
+                DefaultRemoteStoreSettings.INSTANCE,
+                repositoriesServiceSupplier
+            );
+            CountDownLatch counter = new CountDownLatch(1);
+            InvalidIndexContextException exception = expectThrows(
+                InvalidIndexContextException.class,
+                () -> checkerService.validateContext(request)
+            );
+            assertTrue(
+                "Invalid exception message." + exception.getMessage(),
+                exception.getMessage().contains("index specifies a context which cannot be used without enabling")
+            );
+        });
+    }
+
+    public void testCreateIndexWithContextAbsent() throws Exception {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+        try {
+            request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test").context(new Context(randomAlphaOfLength(5)));
+            withTemporaryClusterService((clusterService, threadPool) -> {
+                MetadataCreateIndexService checkerService = new MetadataCreateIndexService(
+                    Settings.EMPTY,
+                    clusterService,
+                    indicesServices,
+                    null,
+                    null,
+                    createTestShardLimitService(randomIntBetween(1, 1000), false, clusterService),
+                    mock(Environment.class),
+                    IndexScopedSettings.DEFAULT_SCOPED_SETTINGS,
+                    threadPool,
+                    null,
+                    new SystemIndices(Collections.emptyMap()),
+                    false,
+                    new AwarenessReplicaBalance(Settings.EMPTY, clusterService.getClusterSettings()),
+                    DefaultRemoteStoreSettings.INSTANCE,
+                    repositoriesServiceSupplier
+                );
+                CountDownLatch counter = new CountDownLatch(1);
+                InvalidIndexContextException exception = expectThrows(
+                    InvalidIndexContextException.class,
+                    () -> checkerService.validateContext(request)
+                );
+                assertTrue(
+                    "Invalid exception message." + exception.getMessage(),
+                    exception.getMessage().contains("index specifies a context which is not loaded on the cluster.")
+                );
+            });
+        } finally {
+            // Disable so that other tests which are not dependent on this are not impacted.
+            FeatureFlags.initializeFeatureFlags(
+                Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, false).build()
+            );
+        }
+    }
+
+    public void testApplyContext() throws IOException {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+        request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test").context(new Context(randomAlphaOfLength(5)));
+
+        final Map<String, Object> mappings = new HashMap<>();
+        mappings.put("_doc", "\"properties\": { \"field1\": {\"type\": \"text\"}}");
+        List<Map<String, Object>> allMappings = new ArrayList<>();
+        allMappings.add(mappings);
+
+        Settings.Builder settingsBuilder = Settings.builder().put(INDEX_SOFT_DELETES_SETTING.getKey(), "false");
+
+        String templateContent = "{\n"
+            + "  \"template\": {\n"
+            + "    \"settings\": {\n"
+            + "      \"index.codec\": \"best_compression\",\n"
+            + "      \"index.merge.policy\": \"log_byte_size\",\n"
+            + "      \"index.refresh_interval\": \"60s\"\n"
+            + "    },\n"
+            + "    \"mappings\": {\n"
+            + "      \"properties\": {\n"
+            + "        \"field1\": {\n"
+            + "          \"type\": \"integer\"\n"
+            + "        }\n"
+            + "      }\n"
+            + "    }\n"
+            + "  },\n"
+            + "  \"_meta\": {\n"
+            + "    \"_type\": \"@abc_template\",\n"
+            + "    \"_version\": 1\n"
+            + "  },\n"
+            + "  \"version\": 1\n"
+            + "}\n";
+
+        AtomicReference<ComponentTemplate> componentTemplate = new AtomicReference<>();
+        try (
+            XContentParser contentParser = JsonXContent.jsonXContent.createParser(
+                NamedXContentRegistry.EMPTY,
+                DeprecationHandler.IGNORE_DEPRECATIONS,
+                templateContent
+            )
+        ) {
+            componentTemplate.set(ComponentTemplate.parse(contentParser));
+        }
+
+        String contextName = randomAlphaOfLength(5);
+        try {
+            request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test").context(new Context(contextName));
+            withTemporaryClusterService((clusterService, threadPool) -> {
+                MetadataCreateIndexService checkerService = new MetadataCreateIndexService(
+                    Settings.EMPTY,
+                    clusterService,
+                    indicesServices,
+                    null,
+                    null,
+                    createTestShardLimitService(randomIntBetween(1, 1000), false, clusterService),
+                    mock(Environment.class),
+                    IndexScopedSettings.DEFAULT_SCOPED_SETTINGS,
+                    threadPool,
+                    null,
+                    new SystemIndices(Collections.emptyMap()),
+                    false,
+                    new AwarenessReplicaBalance(Settings.EMPTY, clusterService.getClusterSettings()),
+                    DefaultRemoteStoreSettings.INSTANCE,
+                    repositoriesServiceSupplier
+                );
+
+                ClusterState mockState = mock(ClusterState.class);
+                Metadata metadata = mock(Metadata.class);
+
+                when(mockState.metadata()).thenReturn(metadata);
+                when(metadata.systemTemplatesLookup()).thenReturn(Map.of(contextName, new TreeMap<>() {
+                    {
+                        put(1L, contextName);
+                    }
+                }));
+                when(metadata.componentTemplates()).thenReturn(Map.of(contextName, componentTemplate.get()));
+
+                try {
+                    Template template = checkerService.applyContext(request, mockState, allMappings, settingsBuilder);
+                    assertEquals(componentTemplate.get().template(), template);
+
+                    assertEquals(2, allMappings.size());
+                    assertEquals(mappings, allMappings.get(0));
+                    assertEquals(
+                        MapperService.parseMapping(NamedXContentRegistry.EMPTY, componentTemplate.get().template().mappings().toString()),
+                        allMappings.get(1)
+                    );
+
+                    assertEquals("60s", settingsBuilder.get(INDEX_REFRESH_INTERVAL_SETTING.getKey()));
+                    assertEquals("log_byte_size", settingsBuilder.get(INDEX_MERGE_POLICY.getKey()));
+                    assertEquals("best_compression", settingsBuilder.get(EngineConfig.INDEX_CODEC_SETTING.getKey()));
+                    assertEquals("false", settingsBuilder.get(INDEX_SOFT_DELETES_SETTING.getKey()));
+                } catch (IOException ex) {
+                    throw new AssertionError(ex);
+                }
+            });
+        } finally {
+            // Disable so that other tests which are not dependent on this are not impacted.
+            FeatureFlags.initializeFeatureFlags(
+                Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, false).build()
+            );
+        }
+    }
+
+    public void testApplyContextWithSettingsOverlap() throws IOException {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+        request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test").context(new Context(randomAlphaOfLength(5)));
+        Settings.Builder settingsBuilder = Settings.builder().put(INDEX_REFRESH_INTERVAL_SETTING.getKey(), "30s");
+        String templateContent = "{\n"
+            + "  \"template\": {\n"
+            + "    \"settings\": {\n"
+            + "      \"index.refresh_interval\": \"60s\"\n"
+            + "    }\n"
+            + "   },\n"
+            + "  \"_meta\": {\n"
+            + "    \"_type\": \"@abc_template\",\n"
+            + "    \"_version\": 1\n"
+            + "  },\n"
+            + "  \"version\": 1\n"
+            + "}\n";
+
+        AtomicReference<ComponentTemplate> componentTemplate = new AtomicReference<>();
+        try (
+            XContentParser contentParser = JsonXContent.jsonXContent.createParser(
+                NamedXContentRegistry.EMPTY,
+                DeprecationHandler.IGNORE_DEPRECATIONS,
+                templateContent
+            )
+        ) {
+            componentTemplate.set(ComponentTemplate.parse(contentParser));
+        }
+
+        String contextName = randomAlphaOfLength(5);
+        try {
+            request = new CreateIndexClusterStateUpdateRequest("create index", "test", "test").context(new Context(contextName));
+            withTemporaryClusterService((clusterService, threadPool) -> {
+                MetadataCreateIndexService checkerService = new MetadataCreateIndexService(
+                    Settings.EMPTY,
+                    clusterService,
+                    indicesServices,
+                    null,
+                    null,
+                    createTestShardLimitService(randomIntBetween(1, 1000), false, clusterService),
+                    mock(Environment.class),
+                    IndexScopedSettings.DEFAULT_SCOPED_SETTINGS,
+                    threadPool,
+                    null,
+                    new SystemIndices(Collections.emptyMap()),
+                    false,
+                    new AwarenessReplicaBalance(Settings.EMPTY, clusterService.getClusterSettings()),
+                    DefaultRemoteStoreSettings.INSTANCE,
+                    repositoriesServiceSupplier
+                );
+
+                ClusterState mockState = mock(ClusterState.class);
+                Metadata metadata = mock(Metadata.class);
+
+                when(mockState.metadata()).thenReturn(metadata);
+                when(metadata.systemTemplatesLookup()).thenReturn(Map.of(contextName, new TreeMap<>() {
+                    {
+                        put(1L, contextName);
+                    }
+                }));
+                when(metadata.componentTemplates()).thenReturn(Map.of(contextName, componentTemplate.get()));
+
+                ValidationException validationException = expectThrows(
+                    ValidationException.class,
+                    () -> checkerService.applyContext(request, mockState, List.of(), settingsBuilder)
+                );
+                assertEquals(1, validationException.validationErrors().size());
+                assertTrue(
+                    "Invalid exception message: " + validationException.getMessage(),
+                    validationException.getMessage()
+                        .contains("Cannot apply context template as user provide settings have overlap with the included context template")
+                );
+            });
+        } finally {
+            // Disable so that other tests which are not dependent on this are not impacted.
+            FeatureFlags.initializeFeatureFlags(
+                Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, false).build()
+            );
+        }
+    }
+
     private IndexTemplateMetadata addMatchingTemplate(Consumer<IndexTemplateMetadata.Builder> configurator) {
         IndexTemplateMetadata.Builder builder = templateMetadataBuilder("template1", "te*");
         configurator.accept(builder);
@@ -2274,6 +2574,7 @@ private void verifyRemoteStoreIndexSettings(
 
     private DiscoveryNode getRemoteNode() {
         Map<String, String> attributes = new HashMap<>();
+        attributes.put(REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-cluster-rep-1");
         attributes.put(REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-segment-repo-1");
         attributes.put(REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-translog-repo-1");
         return new DiscoveryNode(
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/MetadataIndexTemplateServiceTests.java b/server/src/test/java/org/opensearch/cluster/metadata/MetadataIndexTemplateServiceTests.java
index b64cf0ed172af..c81ad933a8757 100644
--- a/server/src/test/java/org/opensearch/cluster/metadata/MetadataIndexTemplateServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/metadata/MetadataIndexTemplateServiceTests.java
@@ -36,6 +36,8 @@
 import org.opensearch.action.admin.indices.alias.Alias;
 import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.applicationtemplates.ClusterStateSystemTemplateLoader;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateMetadata;
 import org.opensearch.cluster.metadata.MetadataIndexTemplateService.PutRequest;
 import org.opensearch.cluster.routing.allocation.AwarenessReplicaBalance;
 import org.opensearch.cluster.service.ClusterService;
@@ -44,6 +46,8 @@
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.xcontent.LoggingDeprecationHandler;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.action.ActionListener;
@@ -52,6 +56,11 @@
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.env.Environment;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.codec.CodecService;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.engine.EngineConfig;
 import org.opensearch.index.mapper.MapperParsingException;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.indices.DefaultRemoteStoreSettings;
@@ -61,6 +70,7 @@
 import org.opensearch.indices.SystemIndices;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.test.OpenSearchSingleNodeTestCase;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
 import java.util.ArrayList;
@@ -75,10 +85,14 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import static java.util.Collections.singletonList;
+import static org.opensearch.cluster.applicationtemplates.ClusterStateSystemTemplateLoader.TEMPLATE_LOADER_IDENTIFIER;
+import static org.opensearch.cluster.applicationtemplates.SystemTemplateMetadata.fromComponentTemplateInfo;
 import static org.opensearch.common.settings.Settings.builder;
+import static org.opensearch.common.util.concurrent.ThreadContext.ACTION_ORIGIN_TRANSIENT_NAME;
 import static org.opensearch.env.Environment.PATH_HOME_SETTING;
 import static org.opensearch.index.mapper.DataStreamFieldMapper.Defaults.TIMESTAMP_FIELD;
 import static org.opensearch.indices.ShardLimitValidatorTests.createTestShardLimitService;
@@ -548,6 +562,64 @@ public void testRemoveIndexTemplateV2() throws Exception {
 
         ClusterState updatedState = MetadataIndexTemplateService.innerRemoveIndexTemplateV2(state, "foo");
         assertNull(updatedState.metadata().templatesV2().get("foo"));
+
+        // test remove a template which is not used by a data stream but index patterns can match
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_BLOCKS_READ, randomBoolean())
+            .put(IndexMetadata.SETTING_BLOCKS_WRITE, randomBoolean())
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, randomIntBetween(1, 10))
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, randomIntBetween(0, 5))
+            .put(IndexMetadata.SETTING_BLOCKS_WRITE, randomBoolean())
+            .put(IndexMetadata.SETTING_PRIORITY, randomIntBetween(0, 100000))
+            .build();
+        CompressedXContent mappings = new CompressedXContent(
+            "{\"properties\":{\"" + randomAlphaOfLength(5) + "\":{\"type\":\"keyword\"}}}"
+        );
+
+        Map<String, Object> meta = Collections.singletonMap(randomAlphaOfLength(4), randomAlphaOfLength(4));
+        List<String> indexPatterns = List.of("foo*");
+        List<String> componentTemplates = randomList(0, 10, () -> randomAlphaOfLength(5));
+        ComposableIndexTemplate templateToRemove = new ComposableIndexTemplate(
+            indexPatterns,
+            new Template(settings, mappings, null),
+            componentTemplates,
+            randomBoolean() ? null : randomNonNegativeLong(),
+            randomBoolean() ? null : randomNonNegativeLong(),
+            meta,
+            null
+        );
+
+        ClusterState stateWithDS = ClusterState.builder(state)
+            .metadata(
+                Metadata.builder(state.metadata())
+                    .put(
+                        new DataStream(
+                            "foo",
+                            new DataStream.TimestampField("@timestamp"),
+                            Collections.singletonList(new Index(".ds-foo-000001", "uuid2"))
+                        )
+                    )
+                    .put(
+                        IndexMetadata.builder(".ds-foo-000001")
+                            .settings(
+                                Settings.builder()
+                                    .put(IndexMetadata.SETTING_INDEX_UUID, "uuid2")
+                                    .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+                                    .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0)
+                                    .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                                    .build()
+                            )
+                    )
+                    .build()
+            )
+            .build();
+
+        final ClusterState clusterState = metadataIndexTemplateService.addIndexTemplateV2(stateWithDS, false, "foo", templateToRemove);
+        assertNotNull(clusterState.metadata().templatesV2().get("foo"));
+        assertTemplatesEqual(clusterState.metadata().templatesV2().get("foo"), templateToRemove);
+
+        updatedState = MetadataIndexTemplateService.innerRemoveIndexTemplateV2(clusterState, "foo");
+        assertNull(updatedState.metadata().templatesV2().get("foo"));
     }
 
     /**
@@ -655,6 +727,306 @@ public void onFailure(Exception e) {
         );
     }
 
+    public void testPutGlobalV2TemplateWhichProvidesContextWithContextDisabled() throws Exception {
+        MetadataIndexTemplateService metadataIndexTemplateService = getMetadataIndexTemplateService();
+        ComposableIndexTemplate globalIndexTemplate = new ComposableIndexTemplate(
+            List.of("*"),
+            null,
+            List.of(),
+            null,
+            null,
+            null,
+            null,
+            new Context("any")
+        );
+        InvalidIndexTemplateException ex = expectThrows(
+            InvalidIndexTemplateException.class,
+            () -> metadataIndexTemplateService.putIndexTemplateV2(
+                "testing",
+                true,
+                "template-referencing-context-as-ct",
+                TimeValue.timeValueSeconds(30L),
+                globalIndexTemplate,
+                new ActionListener<AcknowledgedResponse>() {
+                    @Override
+                    public void onResponse(AcknowledgedResponse response) {
+                        fail("the listener should not be invoked as validation should fail");
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        fail("the listener should not be invoked as validation should fail");
+                    }
+                }
+            )
+        );
+        assertTrue(
+            "Invalid exception message." + ex.getMessage(),
+            ex.getMessage().contains("specifies a context which cannot be used without enabling")
+        );
+    }
+
+    public void testPutGlobalV2TemplateWhichProvidesContextNotPresentInState() throws Exception {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+        MetadataIndexTemplateService metadataIndexTemplateService = getMetadataIndexTemplateService();
+        ComposableIndexTemplate globalIndexTemplate = new ComposableIndexTemplate(
+            List.of("*"),
+            null,
+            List.of(),
+            null,
+            null,
+            null,
+            null,
+            new Context("any")
+        );
+        InvalidIndexTemplateException ex = expectThrows(
+            InvalidIndexTemplateException.class,
+            () -> metadataIndexTemplateService.putIndexTemplateV2(
+                "testing",
+                true,
+                "template-referencing-context-as-ct",
+                TimeValue.timeValueSeconds(30L),
+                globalIndexTemplate,
+                new ActionListener<AcknowledgedResponse>() {
+                    @Override
+                    public void onResponse(AcknowledgedResponse response) {
+                        fail("the listener should not be invoked as validation should fail");
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        fail("the listener should not be invoked as validation should fail");
+                    }
+                }
+            )
+        );
+        assertTrue(
+            "Invalid exception message." + ex.getMessage(),
+            ex.getMessage().contains("specifies a context which is not loaded on the cluster")
+        );
+    }
+
+    public void testPutGlobalV2TemplateWhichProvidesContextWithNonExistingVersion() throws Exception {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+        MetadataIndexTemplateService metadataIndexTemplateService = getMetadataIndexTemplateService();
+
+        Function<String, Template> templateApplier = codec -> new Template(
+            Settings.builder().put(EngineConfig.INDEX_CODEC_SETTING.getKey(), codec).build(),
+            null,
+            null
+        );
+        ComponentTemplate systemTemplate = new ComponentTemplate(
+            templateApplier.apply(CodecService.BEST_COMPRESSION_CODEC),
+            1L,
+            Map.of(ClusterStateSystemTemplateLoader.TEMPLATE_TYPE_KEY, SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE, "_version", 1L)
+        );
+        SystemTemplateMetadata systemTemplateMetadata = fromComponentTemplateInfo("ct-best-compression-codec" + System.nanoTime(), 1);
+
+        CountDownLatch waitToCreateComponentTemplate = new CountDownLatch(1);
+        ActionListener<AcknowledgedResponse> createComponentTemplateListener = new ActionListener<AcknowledgedResponse>() {
+
+            @Override
+            public void onResponse(AcknowledgedResponse response) {
+                waitToCreateComponentTemplate.countDown();
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                fail("expecting the component template PUT to succeed but got: " + e.getMessage());
+            }
+        };
+
+        ThreadContext threadContext = getInstanceFromNode(ThreadPool.class).getThreadContext();
+        try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
+            getInstanceFromNode(ThreadPool.class).getThreadContext().putTransient(ACTION_ORIGIN_TRANSIENT_NAME, TEMPLATE_LOADER_IDENTIFIER);
+            metadataIndexTemplateService.putComponentTemplate(
+                "test",
+                true,
+                systemTemplateMetadata.fullyQualifiedName(),
+                TimeValue.timeValueSeconds(30L),
+                systemTemplate,
+                createComponentTemplateListener
+            );
+        }
+
+        assertTrue("Could not create component templates", waitToCreateComponentTemplate.await(10, TimeUnit.SECONDS));
+
+        Context context = new Context(systemTemplateMetadata.name(), Long.toString(2L), Map.of());
+        ComposableIndexTemplate globalIndexTemplate = new ComposableIndexTemplate(
+            List.of("*"),
+            templateApplier.apply(CodecService.LZ4),
+            List.of(),
+            null,
+            null,
+            null,
+            null,
+            context
+        );
+
+        InvalidIndexTemplateException ex = expectThrows(
+            InvalidIndexTemplateException.class,
+            () -> metadataIndexTemplateService.putIndexTemplateV2(
+                "testing",
+                true,
+                "template-referencing-context-as-ct",
+                TimeValue.timeValueSeconds(30L),
+                globalIndexTemplate,
+                new ActionListener<AcknowledgedResponse>() {
+                    @Override
+                    public void onResponse(AcknowledgedResponse response) {
+                        fail("the listener should not be invoked as validation should fail");
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        fail("the listener should not be invoked as validation should fail");
+                    }
+                }
+            )
+        );
+        assertTrue(
+            "Invalid exception message." + ex.getMessage(),
+            ex.getMessage().contains("specifies a context which is not loaded on the cluster")
+        );
+    }
+
+    public void testPutGlobalV2TemplateWhichProvidesContextInComposedOfSection() throws Exception {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+        MetadataIndexTemplateService metadataIndexTemplateService = getMetadataIndexTemplateService();
+
+        Function<String, Template> templateApplier = codec -> new Template(
+            Settings.builder().put(EngineConfig.INDEX_CODEC_SETTING.getKey(), codec).build(),
+            null,
+            null
+        );
+        ComponentTemplate systemTemplate = new ComponentTemplate(
+            templateApplier.apply(CodecService.BEST_COMPRESSION_CODEC),
+            1L,
+            Map.of(ClusterStateSystemTemplateLoader.TEMPLATE_TYPE_KEY, SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE, "_version", 1L)
+        );
+        SystemTemplateMetadata systemTemplateMetadata = fromComponentTemplateInfo("context-best-compression-codec" + System.nanoTime(), 1);
+
+        CountDownLatch waitToCreateComponentTemplate = new CountDownLatch(1);
+        ActionListener<AcknowledgedResponse> createComponentTemplateListener = new ActionListener<AcknowledgedResponse>() {
+
+            @Override
+            public void onResponse(AcknowledgedResponse response) {
+                waitToCreateComponentTemplate.countDown();
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                fail("expecting the component template PUT to succeed but got: " + e.getMessage());
+            }
+        };
+        ThreadContext context = getInstanceFromNode(ThreadPool.class).getThreadContext();
+        try (ThreadContext.StoredContext ignore = context.stashContext()) {
+            getInstanceFromNode(ThreadPool.class).getThreadContext().putTransient(ACTION_ORIGIN_TRANSIENT_NAME, TEMPLATE_LOADER_IDENTIFIER);
+            metadataIndexTemplateService.putComponentTemplate(
+                "test",
+                true,
+                systemTemplateMetadata.fullyQualifiedName(),
+                TimeValue.timeValueSeconds(30L),
+                systemTemplate,
+                createComponentTemplateListener
+            );
+        }
+        assertTrue("Could not create component templates", waitToCreateComponentTemplate.await(10, TimeUnit.SECONDS));
+
+        ComposableIndexTemplate globalIndexTemplate = new ComposableIndexTemplate(
+            List.of("*"),
+            templateApplier.apply(CodecService.LZ4),
+            List.of(systemTemplateMetadata.fullyQualifiedName()),
+            null,
+            null,
+            null,
+            null
+        );
+        InvalidIndexTemplateException ex = expectThrows(
+            InvalidIndexTemplateException.class,
+            () -> metadataIndexTemplateService.putIndexTemplateV2(
+                "testing",
+                true,
+                "template-referencing-context-as-ct",
+                TimeValue.timeValueSeconds(30L),
+                globalIndexTemplate,
+                new ActionListener<AcknowledgedResponse>() {
+                    @Override
+                    public void onResponse(AcknowledgedResponse response) {
+                        fail("the listener should not be invoked as validation should fail");
+                    }
+
+                    @Override
+                    public void onFailure(Exception e) {
+                        fail("the listener should not be invoked as validation should fail");
+                    }
+                }
+            )
+        );
+        assertTrue(
+            "Invalid exception message." + ex.getMessage(),
+            ex.getMessage().contains("specifies a component templates which can only be used in context")
+        );
+    }
+
+    public void testPutGlobalV2TemplateWhichProvidesContextWithSpecificVersion() throws Exception {
+        verifyTemplateCreationUsingContext("1");
+    }
+
+    public void testPutGlobalV2TemplateWhichProvidesContextWithLatestVersion() throws Exception {
+        verifyTemplateCreationUsingContext("_latest");
+    }
+
+    public void testModifySystemTemplateViaUnknownSource() throws Exception {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+        MetadataIndexTemplateService metadataIndexTemplateService = getMetadataIndexTemplateService();
+
+        Function<String, Template> templateApplier = codec -> new Template(
+            Settings.builder().put(EngineConfig.INDEX_CODEC_SETTING.getKey(), codec).build(),
+            null,
+            null
+        );
+
+        ComponentTemplate systemTemplate = new ComponentTemplate(
+            templateApplier.apply(CodecService.BEST_COMPRESSION_CODEC),
+            1L,
+            Map.of(ClusterStateSystemTemplateLoader.TEMPLATE_TYPE_KEY, SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE, "_version", 1L)
+        );
+        SystemTemplateMetadata systemTemplateMetadata = fromComponentTemplateInfo("ct-best-compression-codec" + System.nanoTime(), 1);
+
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> metadataIndexTemplateService.putComponentTemplate(
+                "test",
+                true,
+                systemTemplateMetadata.fullyQualifiedName(),
+                TimeValue.timeValueSeconds(30L),
+                systemTemplate,
+                ActionListener.wrap(() -> {})
+            )
+        );
+        assertTrue(
+            "Invalid exception message." + ex.getMessage(),
+            ex.getMessage().contains("A system template can only be created/updated/deleted with a repository")
+        );
+    }
+
+    public void testResolveSettingsWithContextVersion() throws Exception {
+        ClusterService clusterService = node().injector().getInstance(ClusterService.class);
+        final String indexTemplateName = verifyTemplateCreationUsingContext("1");
+
+        Settings settings = MetadataIndexTemplateService.resolveSettings(clusterService.state().metadata(), indexTemplateName);
+        assertThat(settings.get("index.codec"), equalTo(CodecService.BEST_COMPRESSION_CODEC));
+    }
+
+    public void testResolveSettingsWithContextLatest() throws Exception {
+        ClusterService clusterService = node().injector().getInstance(ClusterService.class);
+        final String indexTemplateName = verifyTemplateCreationUsingContext(Context.LATEST_VERSION);
+
+        Settings settings = MetadataIndexTemplateService.resolveSettings(clusterService.state().metadata(), indexTemplateName);
+        assertThat(settings.get("index.codec"), equalTo(CodecService.ZLIB));
+    }
+
     /**
      * Test that if we have a pre-existing v2 template and put a "*" v1 template, we generate a warning
      */
@@ -1512,6 +1884,16 @@ public void testResolveAliases() throws Exception {
         ComponentTemplate ct2 = new ComponentTemplate(new Template(null, null, a2), null, null);
         state = service.addComponentTemplate(state, true, "ct_high", ct1);
         state = service.addComponentTemplate(state, true, "ct_low", ct2);
+
+        Map<String, AliasMetadata> a4 = Map.of("sys", AliasMetadata.builder("sys").build());
+        ComponentTemplate sysTemplate = new ComponentTemplate(
+            new Template(null, null, a4),
+            1L,
+            Map.of(ClusterStateSystemTemplateLoader.TEMPLATE_TYPE_KEY, SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE, "_version", 1)
+        );
+        SystemTemplateMetadata systemTemplateMetadata = SystemTemplateMetadata.fromComponentTemplateInfo("sys-template", 1L);
+        state = service.addComponentTemplate(state, true, systemTemplateMetadata.fullyQualifiedName(), sysTemplate);
+
         ComposableIndexTemplate it = new ComposableIndexTemplate(
             Collections.singletonList("i*"),
             new Template(null, null, a3),
@@ -1519,14 +1901,15 @@ public void testResolveAliases() throws Exception {
             0L,
             1L,
             null,
-            null
+            null,
+            new Context(systemTemplateMetadata.name())
         );
         state = service.addIndexTemplateV2(state, true, "my-template", it);
 
         List<Map<String, AliasMetadata>> resolvedAliases = MetadataIndexTemplateService.resolveAliases(state.metadata(), "my-template");
 
-        // These should be order of precedence, so the index template (a3), then ct_high (a1), then ct_low (a2)
-        assertThat(resolvedAliases, equalTo(Arrays.asList(a3, a1, a2)));
+        // These should be order of precedence, so the context(a4), index template (a3), then ct_high (a1), then ct_low (a2)
+        assertThat(resolvedAliases, equalTo(Arrays.asList(a4, a3, a1, a2)));
     }
 
     public void testAddInvalidTemplate() throws Exception {
@@ -2029,9 +2412,44 @@ public void testLegacyNoopUpdate() {
         assertThat(MetadataIndexTemplateService.innerPutTemplate(state, pr, new IndexTemplateMetadata.Builder("id")), equalTo(state));
     }
 
+    public void testAsyncTranslogDurabilityBlocked() {
+        Settings clusterSettings = Settings.builder()
+            .put(IndicesService.CLUSTER_REMOTE_INDEX_RESTRICT_ASYNC_DURABILITY_SETTING.getKey(), true)
+            .build();
+        PutRequest request = new PutRequest("test", "test_replicas");
+        request.patterns(singletonList("test_shards_wait*"));
+        Settings.Builder settingsBuilder = builder().put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, "1")
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, "1")
+            .put(IndexSettings.INDEX_TRANSLOG_DURABILITY_SETTING.getKey(), "async");
+        request.settings(settingsBuilder.build());
+        List<Throwable> throwables = putTemplate(xContentRegistry(), request, clusterSettings);
+        assertThat(throwables.get(0), instanceOf(IllegalArgumentException.class));
+    }
+
+    public void testMaxTranslogFlushSizeWithCompositeIndex() {
+        Settings clusterSettings = Settings.builder()
+            .put(CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "130m")
+            .build();
+        PutRequest request = new PutRequest("test", "test_replicas");
+        request.patterns(singletonList("test_shards_wait*"));
+        Settings.Builder settingsBuilder = builder().put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), "true")
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "131m");
+        request.settings(settingsBuilder.build());
+        List<Throwable> throwables = putTemplate(xContentRegistry(), request, clusterSettings);
+        assertThat(throwables.get(0), instanceOf(IllegalArgumentException.class));
+    }
+
     private static List<Throwable> putTemplate(NamedXContentRegistry xContentRegistry, PutRequest request) {
+        return putTemplate(xContentRegistry, request, Settings.EMPTY);
+    }
+
+    private static List<Throwable> putTemplate(
+        NamedXContentRegistry xContentRegistry,
+        PutRequest request,
+        Settings incomingNodeScopedSettings
+    ) {
         ClusterService clusterService = mock(ClusterService.class);
-        Settings settings = Settings.builder().put(PATH_HOME_SETTING.getKey(), "dummy").build();
+        Settings settings = Settings.builder().put(incomingNodeScopedSettings).put(PATH_HOME_SETTING.getKey(), "dummy").build();
         ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
         Metadata metadata = Metadata.builder().build();
         ClusterState clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
@@ -2066,7 +2484,8 @@ private static List<Throwable> putTemplate(NamedXContentRegistry xContentRegistr
             new AliasValidator(),
             null,
             new IndexScopedSettings(Settings.EMPTY, IndexScopedSettings.BUILT_IN_INDEX_SETTINGS),
-            xContentRegistry
+            xContentRegistry,
+            null
         );
 
         final List<Throwable> throwables = new ArrayList<>();
@@ -2189,4 +2608,132 @@ public static void assertTemplatesEqual(ComposableIndexTemplate actual, Composab
             }
         }
     }
+
+    private String verifyTemplateCreationUsingContext(String contextVersion) throws Exception {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, true).build());
+        MetadataIndexTemplateService metadataIndexTemplateService = getMetadataIndexTemplateService();
+
+        Function<String, Template> templateApplier = codec -> new Template(
+            Settings.builder().put(EngineConfig.INDEX_CODEC_SETTING.getKey(), codec).build(),
+            null,
+            null
+        );
+
+        ComponentTemplate componentTemplate = new ComponentTemplate(templateApplier.apply(CodecService.DEFAULT_CODEC), 1L, new HashMap<>());
+
+        ComponentTemplate systemTemplate = new ComponentTemplate(
+            templateApplier.apply(CodecService.BEST_COMPRESSION_CODEC),
+            1L,
+            Map.of(ClusterStateSystemTemplateLoader.TEMPLATE_TYPE_KEY, SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE, "_version", 1L)
+        );
+        SystemTemplateMetadata systemTemplateMetadata = fromComponentTemplateInfo("ct-best-compression-codec" + System.nanoTime(), 1);
+
+        ComponentTemplate systemTemplateV2 = new ComponentTemplate(
+            templateApplier.apply(CodecService.ZLIB),
+            2L,
+            Map.of(ClusterStateSystemTemplateLoader.TEMPLATE_TYPE_KEY, SystemTemplateMetadata.COMPONENT_TEMPLATE_TYPE, "_version", 2L)
+        );
+        SystemTemplateMetadata systemTemplateV2Metadata = fromComponentTemplateInfo(systemTemplateMetadata.name(), 2);
+
+        CountDownLatch waitToCreateComponentTemplate = new CountDownLatch(3);
+        ActionListener<AcknowledgedResponse> createComponentTemplateListener = new ActionListener<AcknowledgedResponse>() {
+
+            @Override
+            public void onResponse(AcknowledgedResponse response) {
+                waitToCreateComponentTemplate.countDown();
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                fail("expecting the component template PUT to succeed but got: " + e.getMessage());
+            }
+        };
+
+        String componentTemplateName = "ct-default-codec" + System.nanoTime();
+        metadataIndexTemplateService.putComponentTemplate(
+            "test",
+            true,
+            componentTemplateName,
+            TimeValue.timeValueSeconds(30L),
+            componentTemplate,
+            createComponentTemplateListener
+        );
+
+        ThreadContext threadContext = getInstanceFromNode(ThreadPool.class).getThreadContext();
+        try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
+            getInstanceFromNode(ThreadPool.class).getThreadContext().putTransient(ACTION_ORIGIN_TRANSIENT_NAME, TEMPLATE_LOADER_IDENTIFIER);
+            metadataIndexTemplateService.putComponentTemplate(
+                "test",
+                true,
+                systemTemplateMetadata.fullyQualifiedName(),
+                TimeValue.timeValueSeconds(30L),
+                systemTemplate,
+                createComponentTemplateListener
+            );
+
+            metadataIndexTemplateService.putComponentTemplate(
+                "test",
+                true,
+                systemTemplateV2Metadata.fullyQualifiedName(),
+                TimeValue.timeValueSeconds(30L),
+                systemTemplateV2,
+                createComponentTemplateListener
+            );
+        }
+
+        assertTrue("Could not create component templates", waitToCreateComponentTemplate.await(10, TimeUnit.SECONDS));
+
+        Context context = new Context(systemTemplateMetadata.name(), contextVersion, Map.of());
+        ComposableIndexTemplate globalIndexTemplate = new ComposableIndexTemplate(
+            List.of("*"),
+            templateApplier.apply(CodecService.LZ4),
+            List.of(componentTemplateName),
+            null,
+            null,
+            null,
+            null,
+            context
+        );
+
+        String indexTemplateName = "template-referencing-ct-and-context";
+        CountDownLatch waitForIndexTemplate = new CountDownLatch(1);
+        metadataIndexTemplateService.putIndexTemplateV2(
+            "testing",
+            true,
+            indexTemplateName,
+            TimeValue.timeValueSeconds(30L),
+            globalIndexTemplate,
+            new ActionListener<AcknowledgedResponse>() {
+                @Override
+                public void onResponse(AcknowledgedResponse response) {
+                    waitForIndexTemplate.countDown();
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    fail("the listener should not be invoked as the template should succeed");
+                }
+            }
+        );
+        assertTrue("Expected index template to have been created.", waitForIndexTemplate.await(10, TimeUnit.SECONDS));
+        assertTemplatesEqual(
+            node().injector().getInstance(ClusterService.class).state().metadata().templatesV2().get(indexTemplateName),
+            globalIndexTemplate
+        );
+
+        return indexTemplateName;
+    }
+
+    @Override
+    protected boolean resetNodeAfterTest() {
+        return true;
+    }
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder()
+            .put(super.featureFlagSettings())
+            .put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES, false)
+            .build();
+    }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/MetadataTests.java b/server/src/test/java/org/opensearch/cluster/metadata/MetadataTests.java
index 618fcb923bc60..c6cde72ab60b1 100644
--- a/server/src/test/java/org/opensearch/cluster/metadata/MetadataTests.java
+++ b/server/src/test/java/org/opensearch/cluster/metadata/MetadataTests.java
@@ -1482,6 +1482,33 @@ public void testIsSegmentReplicationDisabled() {
         assertFalse(metadata.isSegmentReplicationEnabled(indexName));
     }
 
+    public void testTemplatesMetadata() {
+        TemplatesMetadata templatesMetadata1 = TemplatesMetadata.builder()
+            .put(
+                IndexTemplateMetadata.builder("template_1")
+                    .patterns(Arrays.asList("bar-*", "foo-*"))
+                    .settings(Settings.builder().put("random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build())
+                    .build()
+            )
+            .build();
+        Metadata metadata1 = Metadata.builder().templates(templatesMetadata1).build();
+        assertThat(metadata1.templates(), is(templatesMetadata1.getTemplates()));
+
+        TemplatesMetadata templatesMetadata2 = TemplatesMetadata.builder()
+            .put(
+                IndexTemplateMetadata.builder("template_2")
+                    .patterns(Arrays.asList("bar-*", "foo-*"))
+                    .settings(Settings.builder().put("random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build())
+                    .build()
+            )
+            .build();
+
+        Metadata metadata2 = Metadata.builder(metadata1).templates(templatesMetadata2).build();
+
+        assertThat(metadata2.templates(), is(templatesMetadata2.getTemplates()));
+
+    }
+
     public static Metadata randomMetadata() {
         Metadata.Builder md = Metadata.builder()
             .put(buildIndexMetadata("index", "alias", randomBoolean() ? null : randomBoolean()).build(), randomBoolean())
@@ -1509,6 +1536,41 @@ public static Metadata randomMetadata() {
         return md.build();
     }
 
+    public void testXContentWithTemplateMetadata() throws IOException {
+        final TemplatesMetadata templatesMetadata = getTemplatesMetadata(0);
+        verifyTemplatesMetadata(templatesMetadata);
+        final TemplatesMetadata templatesMetadata2 = getTemplatesMetadata(2);
+        verifyTemplatesMetadata(templatesMetadata2);
+    }
+
+    private void verifyTemplatesMetadata(TemplatesMetadata templatesMetadata) throws IOException {
+        final Metadata originalMeta = Metadata.builder().templates(templatesMetadata).build();
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        Metadata.FORMAT.toXContent(builder, originalMeta);
+        builder.endObject();
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final Metadata fromXContentMeta = Metadata.fromXContent(parser);
+            assertThat(fromXContentMeta.templates(), equalTo(originalMeta.templates()));
+        }
+    }
+
+    private static TemplatesMetadata getTemplatesMetadata(int numberOfTemplates) {
+        TemplatesMetadata.Builder builder = TemplatesMetadata.builder();
+        for (int i = 0; i < numberOfTemplates; i++) {
+            builder.put(
+                IndexTemplateMetadata.builder("template" + i)
+                    .order(1234)
+                    .patterns(Arrays.asList(randomAlphaOfLength(3) + "-*"))
+                    .settings(
+                        Settings.builder().put("index.random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build()
+                    )
+                    .build()
+            );
+        }
+        return builder.build();
+    }
+
     private static CreateIndexResult createIndices(int numIndices, int numBackingIndices, String dataStreamName) {
         // create some indices that do not back a data stream
         final List<Index> indices = new ArrayList<>();
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/QueryGroupMetadataTests.java b/server/src/test/java/org/opensearch/cluster/metadata/QueryGroupMetadataTests.java
new file mode 100644
index 0000000000000..3f8d231ffb91e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/metadata/QueryGroupMetadataTests.java
@@ -0,0 +1,93 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.cluster.Diff;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.test.AbstractDiffableSerializationTestCase;
+import org.opensearch.wlm.MutableQueryGroupFragment;
+import org.opensearch.wlm.ResourceType;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.Map;
+
+import static org.opensearch.cluster.metadata.QueryGroupTests.createRandomQueryGroup;
+
+public class QueryGroupMetadataTests extends AbstractDiffableSerializationTestCase<Metadata.Custom> {
+
+    public void testToXContent() throws IOException {
+        long updatedAt = 1720047207;
+        QueryGroupMetadata queryGroupMetadata = new QueryGroupMetadata(
+            Map.of(
+                "ajakgakg983r92_4242",
+                new QueryGroup(
+                    "test",
+                    "ajakgakg983r92_4242",
+                    new MutableQueryGroupFragment(MutableQueryGroupFragment.ResiliencyMode.ENFORCED, Map.of(ResourceType.MEMORY, 0.5)),
+                    updatedAt
+                )
+            )
+        );
+        XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        queryGroupMetadata.toXContent(builder, null);
+        builder.endObject();
+        assertEquals(
+            "{\"ajakgakg983r92_4242\":{\"_id\":\"ajakgakg983r92_4242\",\"name\":\"test\",\"resiliency_mode\":\"enforced\",\"resource_limits\":{\"memory\":0.5},\"updated_at\":1720047207}}",
+            builder.toString()
+        );
+    }
+
+    @Override
+    protected NamedWriteableRegistry getNamedWriteableRegistry() {
+        return new NamedWriteableRegistry(
+            Collections.singletonList(
+                new NamedWriteableRegistry.Entry(QueryGroupMetadata.class, QueryGroupMetadata.TYPE, QueryGroupMetadata::new)
+            )
+        );
+    }
+
+    @Override
+    protected Metadata.Custom makeTestChanges(Metadata.Custom testInstance) {
+        final QueryGroup queryGroup = createRandomQueryGroup("asdfakgjwrir23r25");
+        final QueryGroupMetadata queryGroupMetadata = new QueryGroupMetadata(Map.of(queryGroup.get_id(), queryGroup));
+        return queryGroupMetadata;
+    }
+
+    @Override
+    protected Writeable.Reader<Diff<Metadata.Custom>> diffReader() {
+        return QueryGroupMetadata::readDiffFrom;
+    }
+
+    @Override
+    protected Metadata.Custom doParseInstance(XContentParser parser) throws IOException {
+        return QueryGroupMetadata.fromXContent(parser);
+    }
+
+    @Override
+    protected Writeable.Reader<Metadata.Custom> instanceReader() {
+        return QueryGroupMetadata::new;
+    }
+
+    @Override
+    protected QueryGroupMetadata createTestInstance() {
+        return new QueryGroupMetadata(getRandomQueryGroups());
+    }
+
+    private Map<String, QueryGroup> getRandomQueryGroups() {
+        QueryGroup qg1 = createRandomQueryGroup("1243gsgsdgs");
+        QueryGroup qg2 = createRandomQueryGroup("lkajga8080");
+        return Map.of(qg1.get_id(), qg1, qg2.get_id(), qg2);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/QueryGroupTests.java b/server/src/test/java/org/opensearch/cluster/metadata/QueryGroupTests.java
new file mode 100644
index 0000000000000..ce1b1270fc94e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/metadata/QueryGroupTests.java
@@ -0,0 +1,199 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.common.UUIDs;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.test.AbstractSerializingTestCase;
+import org.opensearch.wlm.MutableQueryGroupFragment;
+import org.opensearch.wlm.MutableQueryGroupFragment.ResiliencyMode;
+import org.opensearch.wlm.ResourceType;
+import org.joda.time.Instant;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class QueryGroupTests extends AbstractSerializingTestCase<QueryGroup> {
+
+    private static final List<ResiliencyMode> allowedModes = List.of(ResiliencyMode.SOFT, ResiliencyMode.ENFORCED, ResiliencyMode.MONITOR);
+
+    static QueryGroup createRandomQueryGroup(String _id) {
+        String name = randomAlphaOfLength(10);
+        Map<ResourceType, Double> resourceLimit = new HashMap<>();
+        resourceLimit.put(ResourceType.MEMORY, randomDoubleBetween(0.0, 0.80, false));
+        return new QueryGroup(name, _id, new MutableQueryGroupFragment(randomMode(), resourceLimit), Instant.now().getMillis());
+    }
+
+    private static ResiliencyMode randomMode() {
+        return allowedModes.get(randomIntBetween(0, allowedModes.size() - 1));
+    }
+
+    /**
+     * Parses to a new instance using the provided {@link XContentParser}
+     *
+     * @param parser
+     */
+    @Override
+    protected QueryGroup doParseInstance(XContentParser parser) throws IOException {
+        return QueryGroup.fromXContent(parser);
+    }
+
+    /**
+     * Returns a {@link Writeable.Reader} that can be used to de-serialize the instance
+     */
+    @Override
+    protected Writeable.Reader<QueryGroup> instanceReader() {
+        return QueryGroup::new;
+    }
+
+    /**
+     * Creates a random test instance to use in the tests. This method will be
+     * called multiple times during test execution and should return a different
+     * random instance each time it is called.
+     */
+    @Override
+    protected QueryGroup createTestInstance() {
+        return createRandomQueryGroup("1232sfraeradf_");
+    }
+
+    public void testNullName() {
+        assertThrows(
+            NullPointerException.class,
+            () -> new QueryGroup(
+                null,
+                "_id",
+                new MutableQueryGroupFragment(randomMode(), Collections.emptyMap()),
+                Instant.now().getMillis()
+            )
+        );
+    }
+
+    public void testNullId() {
+        assertThrows(
+            NullPointerException.class,
+            () -> new QueryGroup(
+                "Dummy",
+                null,
+                new MutableQueryGroupFragment(randomMode(), Collections.emptyMap()),
+                Instant.now().getMillis()
+            )
+        );
+    }
+
+    public void testNullResourceLimits() {
+        assertThrows(
+            NullPointerException.class,
+            () -> new QueryGroup("analytics", "_id", new MutableQueryGroupFragment(randomMode(), null), Instant.now().getMillis())
+        );
+    }
+
+    public void testEmptyResourceLimits() {
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> new QueryGroup(
+                "analytics",
+                "_id",
+                new MutableQueryGroupFragment(randomMode(), Collections.emptyMap()),
+                Instant.now().getMillis()
+            )
+        );
+    }
+
+    public void testIllegalQueryGroupMode() {
+        assertThrows(
+            NullPointerException.class,
+            () -> new QueryGroup(
+                "analytics",
+                "_id",
+                new MutableQueryGroupFragment(null, Map.of(ResourceType.MEMORY, 0.4)),
+                Instant.now().getMillis()
+            )
+        );
+    }
+
+    public void testQueryGroupInitiation() {
+        QueryGroup queryGroup = new QueryGroup("analytics", new MutableQueryGroupFragment(randomMode(), Map.of(ResourceType.MEMORY, 0.4)));
+        assertNotNull(queryGroup.getName());
+        assertNotNull(queryGroup.get_id());
+        assertNotNull(queryGroup.getResourceLimits());
+        assertFalse(queryGroup.getResourceLimits().isEmpty());
+        assertEquals(1, queryGroup.getResourceLimits().size());
+        assertTrue(allowedModes.contains(queryGroup.getResiliencyMode()));
+        assertTrue(queryGroup.getUpdatedAtInMillis() != 0);
+    }
+
+    public void testIllegalQueryGroupName() {
+        assertThrows(
+            NullPointerException.class,
+            () -> new QueryGroup("a".repeat(51), "_id", new MutableQueryGroupFragment(), Instant.now().getMillis())
+        );
+        assertThrows(
+            NullPointerException.class,
+            () -> new QueryGroup("", "_id", new MutableQueryGroupFragment(), Instant.now().getMillis())
+        );
+
+    }
+
+    public void testInvalidResourceLimitWhenInvalidSystemResourceValueIsGiven() {
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> new QueryGroup(
+                "analytics",
+                "_id",
+                new MutableQueryGroupFragment(randomMode(), Map.of(ResourceType.MEMORY, randomDoubleBetween(1.1, 1.8, false))),
+                Instant.now().getMillis()
+            )
+        );
+    }
+
+    public void testValidQueryGroup() {
+        QueryGroup queryGroup = new QueryGroup(
+            "analytics",
+            "_id",
+            new MutableQueryGroupFragment(randomMode(), Map.of(ResourceType.MEMORY, randomDoubleBetween(0.01, 0.8, false))),
+            Instant.ofEpochMilli(1717187289).getMillis()
+        );
+
+        assertNotNull(queryGroup.getName());
+        assertEquals("analytics", queryGroup.getName());
+        assertNotNull(queryGroup.getResourceLimits());
+        assertFalse(queryGroup.getResourceLimits().isEmpty());
+        assertEquals(1, queryGroup.getResourceLimits().size());
+        assertTrue(allowedModes.contains(queryGroup.getResiliencyMode()));
+        assertEquals(1717187289, queryGroup.getUpdatedAtInMillis());
+    }
+
+    public void testToXContent() throws IOException {
+        long currentTimeInMillis = Instant.now().getMillis();
+        String queryGroupId = UUIDs.randomBase64UUID();
+        QueryGroup queryGroup = new QueryGroup(
+            "TestQueryGroup",
+            queryGroupId,
+            new MutableQueryGroupFragment(ResiliencyMode.ENFORCED, Map.of(ResourceType.CPU, 0.30, ResourceType.MEMORY, 0.40)),
+            currentTimeInMillis
+        );
+        XContentBuilder builder = JsonXContent.contentBuilder();
+        queryGroup.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        assertEquals(
+            "{\"_id\":\""
+                + queryGroupId
+                + "\",\"name\":\"TestQueryGroup\",\"resiliency_mode\":\"enforced\",\"resource_limits\":{\"cpu\":0.3,\"memory\":0.4},\"updated_at\":"
+                + currentTimeInMillis
+                + "}",
+            builder.toString()
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/SearchOnlyReplicaTests.java b/server/src/test/java/org/opensearch/cluster/metadata/SearchOnlyReplicaTests.java
new file mode 100644
index 0000000000000..3d11193a07884
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/metadata/SearchOnlyReplicaTests.java
@@ -0,0 +1,253 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.Version;
+import org.opensearch.action.admin.cluster.reroute.ClusterRerouteRequest;
+import org.opensearch.action.admin.indices.create.CreateIndexRequest;
+import org.opensearch.action.admin.indices.settings.put.UpdateSettingsRequest;
+import org.opensearch.action.support.ActiveShardCount;
+import org.opensearch.action.support.replication.ClusterStateCreationUtils;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.indices.ShardLimitValidator;
+import org.opensearch.indices.cluster.ClusterStateChanges;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.OpenSearchSingleNodeTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.opensearch.cluster.metadata.IndexMetadata.INDEX_REPLICATION_TYPE_SETTING;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
+
+public class SearchOnlyReplicaTests extends OpenSearchSingleNodeTestCase {
+
+    private ThreadPool threadPool;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        this.threadPool = new TestThreadPool(getClass().getName());
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        terminate(threadPool);
+    }
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder()
+            .put(super.featureFlagSettings())
+            .put(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL_SETTING.getKey(), true)
+            .build();
+    }
+
+    public void testCreateWithDefaultSearchReplicasSetting() {
+        final ClusterStateChanges cluster = new ClusterStateChanges(xContentRegistry(), threadPool);
+        ClusterState state = createIndexWithSettings(cluster, Settings.builder().build());
+        IndexShardRoutingTable indexShardRoutingTable = state.getRoutingTable().index("index").getShards().get(0);
+        assertEquals(1, indexShardRoutingTable.replicaShards().size());
+        assertEquals(0, indexShardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(1, indexShardRoutingTable.writerReplicas().size());
+    }
+
+    public void testSearchReplicasValidationWithDocumentReplication() {
+        final ClusterStateChanges cluster = new ClusterStateChanges(xContentRegistry(), threadPool);
+        RuntimeException exception = expectThrows(
+            RuntimeException.class,
+            () -> createIndexWithSettings(
+                cluster,
+                Settings.builder()
+                    .put(SETTING_NUMBER_OF_SHARDS, 1)
+                    .put(SETTING_NUMBER_OF_REPLICAS, 0)
+                    .put(INDEX_REPLICATION_TYPE_SETTING.getKey(), ReplicationType.DOCUMENT)
+                    .put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 1)
+                    .build()
+            )
+        );
+        assertEquals(
+            "To set index.number_of_search_only_replicas, index.replication.type must be set to SEGMENT",
+            exception.getCause().getMessage()
+        );
+    }
+
+    public void testUpdateSearchReplicaCount() {
+        final ClusterStateChanges cluster = new ClusterStateChanges(xContentRegistry(), threadPool);
+
+        ClusterState state = createIndexWithSettings(
+            cluster,
+            Settings.builder()
+                .put(SETTING_NUMBER_OF_SHARDS, 1)
+                .put(SETTING_NUMBER_OF_REPLICAS, 0)
+                .put(INDEX_REPLICATION_TYPE_SETTING.getKey(), ReplicationType.SEGMENT)
+                .put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 1)
+                .build()
+        );
+        assertTrue(state.metadata().hasIndex("index"));
+        rerouteUntilActive(state, cluster);
+        IndexShardRoutingTable indexShardRoutingTable = state.getRoutingTable().index("index").getShards().get(0);
+        assertEquals(1, indexShardRoutingTable.replicaShards().size());
+        assertEquals(1, indexShardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(0, indexShardRoutingTable.writerReplicas().size());
+
+        // add another replica
+        state = cluster.updateSettings(
+            state,
+            new UpdateSettingsRequest("index").settings(Settings.builder().put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 2).build())
+        );
+        rerouteUntilActive(state, cluster);
+        indexShardRoutingTable = state.getRoutingTable().index("index").getShards().get(0);
+        assertEquals(2, indexShardRoutingTable.replicaShards().size());
+        assertEquals(2, indexShardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(0, indexShardRoutingTable.writerReplicas().size());
+
+        // remove all replicas
+        state = cluster.updateSettings(
+            state,
+            new UpdateSettingsRequest("index").settings(Settings.builder().put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 0).build())
+        );
+        rerouteUntilActive(state, cluster);
+        indexShardRoutingTable = state.getRoutingTable().index("index").getShards().get(0);
+        assertEquals(0, indexShardRoutingTable.replicaShards().size());
+        assertEquals(0, indexShardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(0, indexShardRoutingTable.writerReplicas().size());
+    }
+
+    private ClusterState createIndexWithSettings(ClusterStateChanges cluster, Settings settings) {
+        List<DiscoveryNode> allNodes = new ArrayList<>();
+        // node for primary/local
+        DiscoveryNode localNode = createNode(Version.CURRENT, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE, DiscoveryNodeRole.DATA_ROLE);
+        allNodes.add(localNode);
+        // node for search replicas - we'll start with 1 and add another
+        for (int i = 0; i < 2; i++) {
+            allNodes.add(createNode(Version.CURRENT, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE, DiscoveryNodeRole.DATA_ROLE));
+        }
+        ClusterState state = ClusterStateCreationUtils.state(localNode, localNode, allNodes.toArray(new DiscoveryNode[0]));
+
+        CreateIndexRequest request = new CreateIndexRequest("index", settings).waitForActiveShards(ActiveShardCount.NONE);
+        state = cluster.createIndex(state, request);
+        return state;
+    }
+
+    public void testUpdateSearchReplicasOverShardLimit() {
+        final ClusterStateChanges cluster = new ClusterStateChanges(xContentRegistry(), threadPool);
+
+        List<DiscoveryNode> allNodes = new ArrayList<>();
+        // node for primary/local
+        DiscoveryNode localNode = createNode(Version.CURRENT, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE, DiscoveryNodeRole.DATA_ROLE);
+        allNodes.add(localNode);
+
+        allNodes.add(createNode(Version.CURRENT, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE, DiscoveryNodeRole.DATA_ROLE));
+
+        ClusterState state = ClusterStateCreationUtils.state(localNode, localNode, allNodes.toArray(new DiscoveryNode[0]));
+
+        CreateIndexRequest request = new CreateIndexRequest(
+            "index",
+            Settings.builder()
+                .put(SETTING_NUMBER_OF_SHARDS, 1)
+                .put(SETTING_NUMBER_OF_REPLICAS, 0)
+                .put(INDEX_REPLICATION_TYPE_SETTING.getKey(), ReplicationType.SEGMENT)
+                .put(SETTING_NUMBER_OF_SEARCH_REPLICAS, 1)
+                .build()
+        ).waitForActiveShards(ActiveShardCount.NONE);
+        state = cluster.createIndex(state, request);
+        assertTrue(state.metadata().hasIndex("index"));
+        rerouteUntilActive(state, cluster);
+
+        // add another replica
+        ClusterState finalState = state;
+        Integer maxShardPerNode = ShardLimitValidator.SETTING_CLUSTER_MAX_SHARDS_PER_NODE.getDefault(Settings.EMPTY);
+        expectThrows(
+            RuntimeException.class,
+            () -> cluster.updateSettings(
+                finalState,
+                new UpdateSettingsRequest("index").settings(
+                    Settings.builder().put(SETTING_NUMBER_OF_SEARCH_REPLICAS, maxShardPerNode * 2).build()
+                )
+            )
+        );
+    }
+
+    public void testUpdateSearchReplicasOnDocrepCluster() {
+        final ClusterStateChanges cluster = new ClusterStateChanges(xContentRegistry(), threadPool);
+
+        List<DiscoveryNode> allNodes = new ArrayList<>();
+        // node for primary/local
+        DiscoveryNode localNode = createNode(Version.CURRENT, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE, DiscoveryNodeRole.DATA_ROLE);
+        allNodes.add(localNode);
+
+        allNodes.add(createNode(Version.CURRENT, DiscoveryNodeRole.CLUSTER_MANAGER_ROLE, DiscoveryNodeRole.DATA_ROLE));
+
+        ClusterState state = ClusterStateCreationUtils.state(localNode, localNode, allNodes.toArray(new DiscoveryNode[0]));
+
+        CreateIndexRequest request = new CreateIndexRequest(
+            "index",
+            Settings.builder()
+                .put(SETTING_NUMBER_OF_SHARDS, 1)
+                .put(SETTING_NUMBER_OF_REPLICAS, 0)
+                .put(INDEX_REPLICATION_TYPE_SETTING.getKey(), ReplicationType.DOCUMENT)
+                .build()
+        ).waitForActiveShards(ActiveShardCount.NONE);
+        state = cluster.createIndex(state, request);
+        assertTrue(state.metadata().hasIndex("index"));
+        rerouteUntilActive(state, cluster);
+
+        // add another replica
+        ClusterState finalState = state;
+        Integer maxShardPerNode = ShardLimitValidator.SETTING_CLUSTER_MAX_SHARDS_PER_NODE.getDefault(Settings.EMPTY);
+        expectThrows(
+            RuntimeException.class,
+            () -> cluster.updateSettings(
+                finalState,
+                new UpdateSettingsRequest("index").settings(
+                    Settings.builder().put(SETTING_NUMBER_OF_SEARCH_REPLICAS, maxShardPerNode * 2).build()
+                )
+            )
+        );
+
+    }
+
+    private static void rerouteUntilActive(ClusterState state, ClusterStateChanges cluster) {
+        while (state.routingTable().index("index").shard(0).allShardsStarted() == false) {
+            state = cluster.applyStartedShards(
+                state,
+                state.routingTable().index("index").shard(0).shardsWithState(ShardRoutingState.INITIALIZING)
+            );
+            state = cluster.reroute(state, new ClusterRerouteRequest());
+        }
+    }
+
+    private static final AtomicInteger nodeIdGenerator = new AtomicInteger();
+
+    protected DiscoveryNode createNode(Version version, DiscoveryNodeRole... mustHaveRoles) {
+        Set<DiscoveryNodeRole> roles = new HashSet<>(randomSubsetOf(DiscoveryNodeRole.BUILT_IN_ROLES));
+        Collections.addAll(roles, mustHaveRoles);
+        final String id = String.format(Locale.ROOT, "node_%03d", nodeIdGenerator.incrementAndGet());
+        return new DiscoveryNode(id, id, buildNewFakeTransportAddress(), Collections.emptyMap(), roles, version);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/TemplateUpgradeServiceTests.java b/server/src/test/java/org/opensearch/cluster/metadata/TemplateUpgradeServiceTests.java
index 36d984b7eb99b..562e293083633 100644
--- a/server/src/test/java/org/opensearch/cluster/metadata/TemplateUpgradeServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/metadata/TemplateUpgradeServiceTests.java
@@ -47,6 +47,7 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.common.bytes.BytesReference;
@@ -225,7 +226,7 @@ public void testUpdateTemplates() {
         service.upgradesInProgress.set(additionsCount + deletionsCount + 2); // +2 to skip tryFinishUpgrade
         final ThreadContext threadContext = threadPool.getThreadContext();
         try (ThreadContext.StoredContext ignore = threadContext.stashContext()) {
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             service.upgradeTemplates(additions, deletions);
         }
 
diff --git a/server/src/test/java/org/opensearch/cluster/metadata/TranslogFlushIntervalSettingsTests.java b/server/src/test/java/org/opensearch/cluster/metadata/TranslogFlushIntervalSettingsTests.java
new file mode 100644
index 0000000000000..f54b6cdf1b152
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/metadata/TranslogFlushIntervalSettingsTests.java
@@ -0,0 +1,146 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.metadata;
+
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Optional;
+
+/**
+ * Tests for translog flush interval settings update with and without composite index
+ */
+public class TranslogFlushIntervalSettingsTests extends OpenSearchTestCase {
+
+    Settings settings = Settings.builder()
+        .put(CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "130mb")
+        .build();
+    ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+
+    public void testValidSettings() {
+        Settings requestSettings = Settings.builder()
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "50mb")
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .build();
+
+        // This should not throw an exception
+        MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(requestSettings, clusterSettings);
+    }
+
+    public void testDefaultTranslogFlushSetting() {
+        Settings requestSettings = Settings.builder().put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true).build();
+
+        // This should not throw an exception
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(requestSettings, clusterSettings)
+        );
+        assertEquals("You can configure 'index.translog.flush_threshold_size' with upto '130mb' for composite index", ex.getMessage());
+    }
+
+    public void testMissingCompositeIndexSetting() {
+        Settings requestSettings = Settings.builder()
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "50mb")
+            .build();
+
+        // This should not throw an exception
+        MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(requestSettings, clusterSettings);
+    }
+
+    public void testNullTranslogFlushSetting() {
+        Settings requestSettings = Settings.builder()
+            .putNull(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey())
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .build();
+
+        // This should not throw an exception
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(requestSettings, clusterSettings)
+        );
+        assertEquals("You can configure 'index.translog.flush_threshold_size' with upto '130mb' for composite index", ex.getMessage());
+    }
+
+    public void testExceedingMaxFlushSize() {
+        Settings requestSettings = Settings.builder()
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "150mb")
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .build();
+
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(requestSettings, clusterSettings)
+        );
+        assertEquals("You can configure 'index.translog.flush_threshold_size' with upto '130mb' for composite index", ex.getMessage());
+    }
+
+    public void testEqualToMaxFlushSize() {
+        Settings requestSettings = Settings.builder()
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "100mb")
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .build();
+
+        // This should not throw an exception
+        MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(requestSettings, clusterSettings);
+    }
+
+    public void testUpdateIndexThresholdFlushSize() {
+        Settings requestSettings = Settings.builder()
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "100mb")
+            .build();
+
+        Settings indexSettings = Settings.builder().put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true).build();
+
+        // This should not throw an exception
+        assertTrue(
+            MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(
+                requestSettings,
+                clusterSettings,
+                indexSettings
+            ).isEmpty()
+        );
+    }
+
+    public void testUpdateFlushSizeAboveThresholdWithCompositeIndex() {
+        Settings requestSettings = Settings.builder()
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "131mb")
+            .build();
+
+        Settings indexSettings = Settings.builder().put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true).build();
+
+        Optional<String> err = MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(
+            requestSettings,
+            clusterSettings,
+            indexSettings
+        );
+        assertTrue(err.isPresent());
+        assertEquals("You can configure 'index.translog.flush_threshold_size' with upto '130mb' for composite index", err.get());
+    }
+
+    public void testUpdateFlushSizeAboveThresholdWithoutCompositeIndex() {
+        Settings requestSettings = Settings.builder()
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "131mb")
+            .build();
+
+        Settings indexSettings = Settings.builder().build();
+
+        // This should not throw an exception
+        assertTrue(
+            MetadataCreateIndexService.validateTranslogFlushIntervalSettingsForCompositeIndex(
+                requestSettings,
+                clusterSettings,
+                indexSettings
+            ).isEmpty()
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeTests.java b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeTests.java
index 8f149e32ec6f5..9f406101203a0 100644
--- a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeTests.java
+++ b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodeTests.java
@@ -39,6 +39,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.transport.TransportAddress;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
 import org.opensearch.test.NodeRoles;
 import org.opensearch.test.OpenSearchTestCase;
@@ -47,6 +48,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
@@ -129,6 +131,43 @@ public void testDiscoveryNodeSerializationKeepsHost() throws Exception {
         assertEquals(transportAddress.getPort(), serialized.getAddress().getPort());
     }
 
+    public void testWriteVerifiableTo() throws Exception {
+        InetAddress inetAddress = InetAddress.getByAddress("name1", new byte[] { (byte) 192, (byte) 168, (byte) 0, (byte) 1 });
+        TransportAddress transportAddress = new TransportAddress(inetAddress, randomIntBetween(0, 65535));
+        final Set<DiscoveryNodeRole> roles = new HashSet<>(randomSubsetOf(DiscoveryNodeRole.BUILT_IN_ROLES));
+        Map<String, String> attributes = new HashMap<>();
+        attributes.put("att-1", "test-repo");
+        attributes.put("att-2", "test-repo");
+        DiscoveryNode node = new DiscoveryNode("name1", "id1", transportAddress, attributes, roles, Version.CURRENT);
+
+        BytesStreamOutput out = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out);
+        node.writeVerifiableTo(checksumOut);
+        StreamInput in = out.bytes().streamInput();
+        DiscoveryNode result = new DiscoveryNode(in);
+        assertEquals(result, node);
+
+        Map<String, String> attributes2 = new HashMap<>();
+        attributes2.put("att-2", "test-repo");
+        attributes2.put("att-1", "test-repo");
+
+        DiscoveryNode node2 = new DiscoveryNode(
+            node.getName(),
+            node.getId(),
+            node.getEphemeralId(),
+            node.getHostName(),
+            node.getHostAddress(),
+            transportAddress,
+            attributes2,
+            roles.stream().sorted().collect(Collectors.toCollection(LinkedHashSet::new)),
+            Version.CURRENT
+        );
+        BytesStreamOutput out2 = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut2 = new BufferedChecksumStreamOutput(out2);
+        node2.writeVerifiableTo(checksumOut2);
+        assertEquals(checksumOut.getChecksum(), checksumOut2.getChecksum());
+    }
+
     public void testDiscoveryNodeRoleWithOldVersion() throws Exception {
         InetAddress inetAddress = InetAddress.getByAddress("name1", new byte[] { (byte) 192, (byte) 168, (byte) 0, (byte) 1 });
         TransportAddress transportAddress = new TransportAddress(inetAddress, randomIntBetween(0, 65535));
diff --git a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodesTests.java b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodesTests.java
index ede64da1b3c1f..19c5464b6d3b7 100644
--- a/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodesTests.java
+++ b/server/src/test/java/org/opensearch/cluster/node/DiscoveryNodesTests.java
@@ -36,10 +36,14 @@
 
 import org.opensearch.LegacyESVersion;
 import org.opensearch.Version;
+import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.settings.Setting;
+import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.common.transport.TransportAddress;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 import org.opensearch.test.OpenSearchTestCase;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -328,6 +332,28 @@ public void testDeprecatedMasterNodeFilter() {
         assertThat(discoveryNodes.resolveNodes("master:false", "_all"), arrayContainingInAnyOrder(allNodes));
     }
 
+    public void testWriteVerifiableTo() throws IOException {
+        final DiscoveryNodes discoveryNodes = buildDiscoveryNodes();
+        BytesStreamOutput out = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out);
+        discoveryNodes.writeVerifiableTo(checksumOut);
+        StreamInput in = out.bytes().streamInput();
+        DiscoveryNodes result = DiscoveryNodes.readFrom(in, discoveryNodes.getLocalNode());
+        assertEquals(result, discoveryNodes);
+
+        final DiscoveryNodes.Builder discoveryNodesBuilder = DiscoveryNodes.builder()
+            .clusterManagerNodeId(discoveryNodes.getClusterManagerNodeId());
+        discoveryNodes.getNodes()
+            .entrySet()
+            .stream()
+            .sorted(Map.Entry.comparingByKey())
+            .forEachOrdered(entry -> discoveryNodesBuilder.add(entry.getValue()));
+        BytesStreamOutput out2 = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut2 = new BufferedChecksumStreamOutput(out2);
+        discoveryNodesBuilder.build().writeVerifiableTo(checksumOut2);
+        assertEquals(checksumOut.getChecksum(), checksumOut2.getChecksum());
+    }
+
     private static AtomicInteger idGenerator = new AtomicInteger();
 
     private static List<DiscoveryNode> randomNodes(final int numNodes) {
diff --git a/server/src/test/java/org/opensearch/cluster/routing/IndexShardRoutingTableTests.java b/server/src/test/java/org/opensearch/cluster/routing/IndexShardRoutingTableTests.java
index e881016fb9305..340e0d9bdf520 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/IndexShardRoutingTableTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/IndexShardRoutingTableTests.java
@@ -32,10 +32,13 @@
 
 package org.opensearch.cluster.routing;
 
+import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.translog.BufferedChecksumStreamOutput;
 import org.opensearch.test.OpenSearchTestCase;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -69,6 +72,31 @@ public void testEquals() {
         assertNotEquals(table1, null);
         assertNotEquals(table1, s);
         assertNotEquals(table1, table3);
+
+        ShardRouting primary = TestShardRouting.newShardRouting(shardId, "node-1", true, ShardRoutingState.STARTED);
+        ShardRouting replica = TestShardRouting.newShardRouting(shardId, "node-2", false, ShardRoutingState.STARTED);
+        IndexShardRoutingTable table4 = new IndexShardRoutingTable(shardId, Arrays.asList(primary, replica));
+        IndexShardRoutingTable table5 = new IndexShardRoutingTable(shardId, Arrays.asList(replica, primary));
+        assertEquals(table4, table5);
+    }
+
+    public void testWriteVerifiableTo() throws IOException {
+        Index index = new Index("a", "b");
+        ShardId shardId = new ShardId(index, 1);
+        ShardRouting shard1 = TestShardRouting.newShardRouting(shardId, "node-1", true, ShardRoutingState.STARTED);
+        ShardRouting shard2 = TestShardRouting.newShardRouting(shardId, "node-2", false, ShardRoutingState.STARTED);
+        ShardRouting shard3 = TestShardRouting.newShardRouting(shardId, null, false, ShardRoutingState.UNASSIGNED);
+
+        IndexShardRoutingTable table1 = new IndexShardRoutingTable(shardId, Arrays.asList(shard1, shard2, shard3));
+        BytesStreamOutput out = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut = new BufferedChecksumStreamOutput(out);
+        IndexShardRoutingTable.Builder.writeVerifiableTo(table1, checksumOut);
+
+        IndexShardRoutingTable table2 = new IndexShardRoutingTable(shardId, Arrays.asList(shard3, shard1, shard2));
+        BytesStreamOutput out2 = new BytesStreamOutput();
+        BufferedChecksumStreamOutput checksumOut2 = new BufferedChecksumStreamOutput(out2);
+        IndexShardRoutingTable.Builder.writeVerifiableTo(table2, checksumOut2);
+        assertEquals(checksumOut.getChecksum(), checksumOut2.getChecksum());
     }
 
     public void testShardsMatchingPredicate() {
diff --git a/server/src/test/java/org/opensearch/cluster/routing/OperationRoutingTests.java b/server/src/test/java/org/opensearch/cluster/routing/OperationRoutingTests.java
index 4f3e50eebb9c6..aaeeb52ab5709 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/OperationRoutingTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/OperationRoutingTests.java
@@ -41,9 +41,11 @@
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.routing.allocation.decider.AwarenessAllocationDecider;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.SuppressForbidden;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
@@ -1054,6 +1056,144 @@ public void testSearchableSnapshotPrimaryDefault() throws Exception {
         }
     }
 
+    @SuppressForbidden(reason = "feature flag overrides")
+    public void testPartialIndexPrimaryDefault() throws Exception {
+        System.setProperty(FeatureFlags.TIERED_REMOTE_INDEX, "true");
+        final int numIndices = 1;
+        final int numShards = 2;
+        final int numReplicas = 2;
+        final String[] indexNames = new String[numIndices];
+        for (int i = 0; i < numIndices; i++) {
+            indexNames[i] = "test" + i;
+        }
+        // The first index is a partial index
+        final String indexName = indexNames[0];
+        ClusterService clusterService = null;
+        ThreadPool threadPool = null;
+
+        try {
+            OperationRouting opRouting = new OperationRouting(
+                Settings.EMPTY,
+                new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+            );
+
+            ClusterState state = ClusterStateCreationUtils.stateWithAssignedPrimariesAndReplicas(indexNames, numShards, numReplicas);
+            threadPool = new TestThreadPool("testPartialIndexPrimaryDefault");
+            clusterService = ClusterServiceUtils.createClusterService(threadPool);
+
+            // Update the index config within the cluster state to modify the index to a partial index
+            IndexMetadata partialIndexMetadata = IndexMetadata.builder(indexName)
+                .settings(
+                    Settings.builder()
+                        .put(state.metadata().index(indexName).getSettings())
+                        .put(IndexModule.INDEX_STORE_LOCALITY_SETTING.getKey(), IndexModule.DataLocalityType.PARTIAL)
+                        .build()
+                )
+                .build();
+            Metadata.Builder metadataBuilder = Metadata.builder(state.metadata())
+                .put(partialIndexMetadata, false)
+                .generateClusterUuidIfNeeded();
+            state = ClusterState.builder(state).metadata(metadataBuilder.build()).build();
+
+            // Verify default preference is primary only
+            GroupShardsIterator<ShardIterator> groupIterator = opRouting.searchShards(state, indexNames, null, null);
+            assertThat("One group per index shard", groupIterator.size(), equalTo(numIndices * numShards));
+
+            for (ShardIterator shardIterator : groupIterator) {
+                assertTrue("Only primary should exist with no preference", shardIterator.nextOrNull().primary());
+            }
+
+            // Verify alternative preference can be applied to a partial index
+            groupIterator = opRouting.searchShards(state, indexNames, null, "_replica");
+            assertThat("One group per index shard", groupIterator.size(), equalTo(numIndices * numShards));
+
+            for (ShardIterator shardIterator : groupIterator) {
+                assertThat("Replica shards will be returned", shardIterator.size(), equalTo(numReplicas));
+                assertFalse("Returned shard should be a replica", shardIterator.nextOrNull().primary());
+            }
+        } finally {
+            IOUtils.close(clusterService);
+            terminate(threadPool);
+            System.setProperty(FeatureFlags.TIERED_REMOTE_INDEX, "false");
+        }
+    }
+
+    public void testSearchReplicaDefaultRouting() throws Exception {
+        final int numShards = 1;
+        final int numReplicas = 2;
+        final int numSearchReplicas = 2;
+        final String indexName = "test";
+        final String[] indexNames = new String[] { indexName };
+
+        ClusterService clusterService = null;
+        ThreadPool threadPool = null;
+
+        try {
+            OperationRouting opRouting = new OperationRouting(
+                Settings.builder().put(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL, "true").build(),
+                new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+            );
+
+            ClusterState state = ClusterStateCreationUtils.stateWithAssignedPrimariesAndReplicas(
+                indexNames,
+                numShards,
+                numReplicas,
+                numSearchReplicas
+            );
+            IndexShardRoutingTable indexShardRoutingTable = state.getRoutingTable().index(indexName).getShards().get(0);
+            ShardId shardId = indexShardRoutingTable.searchOnlyReplicas().get(0).shardId();
+
+            threadPool = new TestThreadPool("testSearchReplicaDefaultRouting");
+            clusterService = ClusterServiceUtils.createClusterService(threadPool);
+
+            // add a search replica in initializing state:
+            DiscoveryNode node = new DiscoveryNode(
+                "node_initializing",
+                OpenSearchTestCase.buildNewFakeTransportAddress(),
+                Collections.emptyMap(),
+                new HashSet<>(DiscoveryNodeRole.BUILT_IN_ROLES),
+                Version.CURRENT
+            );
+
+            IndexMetadata indexMetadata = IndexMetadata.builder(indexName)
+                .settings(Settings.builder().put(state.metadata().index(indexName).getSettings()).build())
+                .numberOfSearchReplicas(3)
+                .numberOfReplicas(2)
+                .build();
+            Metadata.Builder metadataBuilder = Metadata.builder(state.metadata()).put(indexMetadata, false).generateClusterUuidIfNeeded();
+            IndexRoutingTable.Builder indexShardRoutingBuilder = IndexRoutingTable.builder(indexMetadata.getIndex());
+            indexShardRoutingBuilder.addIndexShard(indexShardRoutingTable);
+            indexShardRoutingBuilder.addShard(
+                TestShardRouting.newShardRouting(shardId, node.getId(), null, false, true, ShardRoutingState.INITIALIZING, null)
+            );
+            state = ClusterState.builder(state)
+                .routingTable(RoutingTable.builder().add(indexShardRoutingBuilder).build())
+                .metadata(metadataBuilder.build())
+                .build();
+
+            // Verify default preference is primary only
+            GroupShardsIterator<ShardIterator> groupIterator = opRouting.searchShards(state, indexNames, null, null);
+            assertThat("one group per shard", groupIterator.size(), equalTo(numShards));
+            for (ShardIterator shardIterator : groupIterator) {
+                assertEquals("We should have 3 shards returned", shardIterator.size(), 3);
+                int i = 0;
+                for (ShardRouting shardRouting : shardIterator) {
+                    assertTrue(
+                        "Only search replicas should exist with preference SEARCH_REPLICA",
+                        shardIterator.nextOrNull().isSearchOnly()
+                    );
+                    if (i == shardIterator.size()) {
+                        assertTrue("Initializing shard should appear last", shardRouting.initializing());
+                        assertFalse("Initializing shard should appear last", shardRouting.active());
+                    }
+                }
+            }
+        } finally {
+            IOUtils.close(clusterService);
+            terminate(threadPool);
+        }
+    }
+
     private DiscoveryNode[] setupNodes() {
         // Sets up two data nodes in zone-a and one data node in zone-b
         List<String> zones = Arrays.asList("a", "a", "b");
diff --git a/server/src/test/java/org/opensearch/cluster/routing/RoutingTableDiffTests.java b/server/src/test/java/org/opensearch/cluster/routing/RoutingTableDiffTests.java
new file mode 100644
index 0000000000000..d8c93523c34b9
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/RoutingTableDiffTests.java
@@ -0,0 +1,325 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.OpenSearchAllocationTestCase;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.allocation.AllocationService;
+import org.opensearch.cluster.routing.allocation.decider.ThrottlingAllocationDecider;
+import org.opensearch.common.settings.Settings;
+import org.junit.Before;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+
+public class RoutingTableDiffTests extends OpenSearchAllocationTestCase {
+
+    private static final String TEST_INDEX_1 = "test1";
+    private static final String TEST_INDEX_2 = "test2";
+    private static final String TEST_INDEX_3 = "test3";
+    private int numberOfShards;
+    private int numberOfReplicas;
+    private int shardsPerIndex;
+    private int totalNumberOfShards;
+    private static final Settings DEFAULT_SETTINGS = Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT).build();
+    private final AllocationService ALLOCATION_SERVICE = createAllocationService(
+        Settings.builder()
+            .put("cluster.routing.allocation.node_concurrent_recoveries", Integer.MAX_VALUE) // don't limit recoveries
+            .put("cluster.routing.allocation.node_initial_primaries_recoveries", Integer.MAX_VALUE)
+            .put(
+                ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_INITIAL_REPLICAS_RECOVERIES_SETTING.getKey(),
+                Integer.MAX_VALUE
+            )
+            .build()
+    );
+    private ClusterState clusterState;
+
+    @Override
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        this.numberOfShards = randomIntBetween(1, 5);
+        this.numberOfReplicas = randomIntBetween(1, 5);
+        this.shardsPerIndex = this.numberOfShards * (this.numberOfReplicas + 1);
+        this.totalNumberOfShards = this.shardsPerIndex * 2;
+        logger.info("Setup test with {} shards and {} replicas.", this.numberOfShards, this.numberOfReplicas);
+        RoutingTable emptyRoutingTable = new RoutingTable.Builder().build();
+        Metadata metadata = Metadata.builder().put(createIndexMetadata(TEST_INDEX_1)).put(createIndexMetadata(TEST_INDEX_2)).build();
+
+        RoutingTable testRoutingTable = new RoutingTable.Builder().add(
+            new IndexRoutingTable.Builder(metadata.index(TEST_INDEX_1).getIndex()).initializeAsNew(metadata.index(TEST_INDEX_1)).build()
+        )
+            .add(
+                new IndexRoutingTable.Builder(metadata.index(TEST_INDEX_2).getIndex()).initializeAsNew(metadata.index(TEST_INDEX_2)).build()
+            )
+            .build();
+        this.clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(testRoutingTable)
+            .build();
+    }
+
+    /**
+     * puts primary shard indexRoutings into initializing state
+     */
+    private void initPrimaries() {
+        logger.info("adding {} nodes and performing rerouting", this.numberOfReplicas + 1);
+        DiscoveryNodes.Builder discoBuilder = DiscoveryNodes.builder();
+        for (int i = 0; i < this.numberOfReplicas + 1; i++) {
+            discoBuilder = discoBuilder.add(newNode("node" + i));
+        }
+        this.clusterState = ClusterState.builder(clusterState).nodes(discoBuilder).build();
+        ClusterState rerouteResult = ALLOCATION_SERVICE.reroute(clusterState, "reroute");
+        assertThat(rerouteResult, not(equalTo(this.clusterState)));
+        this.clusterState = rerouteResult;
+    }
+
+    private void startInitializingShards(String index) {
+        logger.info("start primary shards for index {}", index);
+        clusterState = startInitializingShardsAndReroute(ALLOCATION_SERVICE, clusterState, index);
+    }
+
+    private IndexMetadata.Builder createIndexMetadata(String indexName) {
+        return new IndexMetadata.Builder(indexName).settings(DEFAULT_SETTINGS)
+            .numberOfReplicas(this.numberOfReplicas)
+            .numberOfShards(this.numberOfShards);
+    }
+
+    public void testRoutingTableUpserts() {
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(this.totalNumberOfShards));
+        initPrimaries();
+        int expectedUnassignedShardCount = this.totalNumberOfShards - 2 * this.numberOfShards;
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(expectedUnassignedShardCount));
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(2 * this.numberOfShards));
+        Metadata metadata = Metadata.builder().put(createIndexMetadata(TEST_INDEX_1)).put(createIndexMetadata(TEST_INDEX_2)).build();
+        ClusterState oldClusterState = clusterState;
+
+        // create index routing table for TEST_INDEX_3
+        metadata = Metadata.builder(metadata).put(createIndexMetadata(TEST_INDEX_3)).build();
+        RoutingTable testRoutingTable = new RoutingTable.Builder(clusterState.routingTable()).add(
+            new IndexRoutingTable.Builder(metadata.index(TEST_INDEX_3).getIndex()).initializeAsNew(metadata.index(TEST_INDEX_3)).build()
+        ).build();
+        this.clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(testRoutingTable)
+            .build();
+        this.totalNumberOfShards = this.shardsPerIndex * 3;
+        assertThat(
+            clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
+            is(expectedUnassignedShardCount + this.shardsPerIndex)
+        );
+        Diff<RoutingTable> fullDiff = clusterState.routingTable().diff(oldClusterState.getRoutingTable());
+        Diff<RoutingTable> incrementalDiff = clusterState.routingTable().incrementalDiff(oldClusterState.getRoutingTable());
+        RoutingTable newRoutingTable = incrementalDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTable.version());
+            assertEquals(indexRoutingTable, newRoutingTable.index(indexRoutingTable.getIndex()));
+        }
+        RoutingTable newRoutingTableWithFullDiff = fullDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTableWithFullDiff.version());
+            assertEquals(indexRoutingTable, newRoutingTableWithFullDiff.index(indexRoutingTable.getIndex()));
+        }
+    }
+
+    public void testRoutingTableDeletes() {
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(this.totalNumberOfShards));
+        initPrimaries();
+        int expectedUnassignedShardCount = this.totalNumberOfShards - 2 * this.numberOfShards;
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(expectedUnassignedShardCount));
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(2 * this.numberOfShards));
+        Metadata metadata = Metadata.builder().put(createIndexMetadata(TEST_INDEX_1)).put(createIndexMetadata(TEST_INDEX_2)).build();
+        ClusterState oldClusterState = clusterState;
+
+        // delete index routing table for TEST_INDEX_1
+        metadata = Metadata.builder(metadata).put(createIndexMetadata(TEST_INDEX_3)).build();
+        RoutingTable testRoutingTable = new RoutingTable.Builder(clusterState.routingTable()).remove(TEST_INDEX_1).build();
+        this.clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(testRoutingTable)
+            .build();
+        this.totalNumberOfShards = this.shardsPerIndex;
+        assertThat(
+            clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
+            is(expectedUnassignedShardCount - this.numberOfShards * this.numberOfReplicas)
+        );
+        Diff<RoutingTable> fullDiff = clusterState.routingTable().diff(oldClusterState.getRoutingTable());
+        Diff<RoutingTable> incrementalDiff = clusterState.routingTable().incrementalDiff(oldClusterState.getRoutingTable());
+        RoutingTable newRoutingTable = incrementalDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTable.version());
+            assertEquals(indexRoutingTable, newRoutingTable.index(indexRoutingTable.getIndex()));
+        }
+        RoutingTable newRoutingTableWithFullDiff = fullDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTableWithFullDiff.version());
+            assertEquals(indexRoutingTable, newRoutingTableWithFullDiff.index(indexRoutingTable.getIndex()));
+        }
+    }
+
+    public void testRoutingTableUpsertsWithDiff() {
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(this.totalNumberOfShards));
+        initPrimaries();
+        int expectedUnassignedShardCount = this.totalNumberOfShards - 2 * this.numberOfShards;
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(expectedUnassignedShardCount));
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(2 * this.numberOfShards));
+        Metadata metadata = Metadata.builder().put(createIndexMetadata(TEST_INDEX_1)).put(createIndexMetadata(TEST_INDEX_2)).build();
+        ClusterState oldClusterState = clusterState;
+
+        // create index routing table for TEST_INDEX_3
+        metadata = Metadata.builder(metadata).put(createIndexMetadata(TEST_INDEX_3)).build();
+        RoutingTable testRoutingTable = new RoutingTable.Builder(clusterState.routingTable()).add(
+            new IndexRoutingTable.Builder(metadata.index(TEST_INDEX_3).getIndex()).initializeAsNew(metadata.index(TEST_INDEX_3)).build()
+        ).build();
+        this.clusterState = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(testRoutingTable)
+            .build();
+        this.totalNumberOfShards = this.shardsPerIndex * 3;
+        assertThat(
+            clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
+            is(expectedUnassignedShardCount + this.shardsPerIndex)
+        );
+        initPrimaries();
+        clusterState = startRandomInitializingShard(clusterState, ALLOCATION_SERVICE, TEST_INDEX_2);
+        // assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(2 * this.numberOfShards + 1));
+        Diff<RoutingTable> fullDiff = clusterState.routingTable().diff(oldClusterState.getRoutingTable());
+        Diff<RoutingTable> incrementalDiff = clusterState.routingTable().incrementalDiff(oldClusterState.getRoutingTable());
+        RoutingTable newRoutingTable = incrementalDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTable.version());
+            assertEquals(indexRoutingTable, newRoutingTable.index(indexRoutingTable.getIndex()));
+        }
+        RoutingTable newRoutingTableWithFullDiff = fullDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTableWithFullDiff.version());
+            assertEquals(indexRoutingTable, newRoutingTableWithFullDiff.index(indexRoutingTable.getIndex()));
+        }
+    }
+
+    public void testRoutingTableDiffWithReplicaAdded() {
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(this.totalNumberOfShards));
+        initPrimaries();
+        int expectedUnassignedShardCount = this.totalNumberOfShards - 2 * this.numberOfShards;
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(expectedUnassignedShardCount));
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(2 * this.numberOfShards));
+        ClusterState oldClusterState = clusterState;
+
+        // update replica count for TEST_INDEX_1
+        RoutingTable updatedRoutingTable = RoutingTable.builder(clusterState.routingTable())
+            .updateNumberOfReplicas(this.numberOfReplicas + 1, new String[] { TEST_INDEX_1 })
+            .build();
+        Metadata metadata = Metadata.builder(clusterState.metadata())
+            .updateNumberOfReplicas(this.numberOfReplicas + 1, new String[] { TEST_INDEX_1 })
+            .build();
+        clusterState = ClusterState.builder(clusterState).routingTable(updatedRoutingTable).metadata(metadata).build();
+        assertThat(
+            clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
+            is(expectedUnassignedShardCount + this.numberOfShards)
+        );
+        Diff<RoutingTable> fullDiff = clusterState.routingTable().diff(oldClusterState.getRoutingTable());
+        Diff<RoutingTable> incrementalDiff = clusterState.routingTable().incrementalDiff(oldClusterState.getRoutingTable());
+        RoutingTable newRoutingTable = incrementalDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTable.version());
+            assertEquals(indexRoutingTable, newRoutingTable.index(indexRoutingTable.getIndex()));
+        }
+        RoutingTable newRoutingTableWithFullDiff = fullDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTableWithFullDiff.version());
+            assertEquals(indexRoutingTable, newRoutingTableWithFullDiff.index(indexRoutingTable.getIndex()));
+        }
+    }
+
+    public void testRoutingTableDiffWithReplicaRemoved() {
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(this.totalNumberOfShards));
+        initPrimaries();
+        int expectedUnassignedShardCount = this.totalNumberOfShards - 2 * this.numberOfShards;
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(expectedUnassignedShardCount));
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(2 * this.numberOfShards));
+        ClusterState oldClusterState = clusterState;
+
+        // update replica count for TEST_INDEX_1
+        RoutingTable updatedRoutingTable = RoutingTable.builder(clusterState.routingTable())
+            .updateNumberOfReplicas(this.numberOfReplicas - 1, new String[] { TEST_INDEX_1 })
+            .build();
+        Metadata metadata = Metadata.builder(clusterState.metadata())
+            .updateNumberOfReplicas(this.numberOfReplicas - 1, new String[] { TEST_INDEX_1 })
+            .build();
+        clusterState = ClusterState.builder(clusterState).routingTable(updatedRoutingTable).metadata(metadata).build();
+        assertThat(
+            clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
+            is(expectedUnassignedShardCount - this.numberOfShards)
+        );
+        Diff<RoutingTable> fullDiff = clusterState.routingTable().diff(oldClusterState.getRoutingTable());
+        Diff<RoutingTable> incrementalDiff = clusterState.routingTable().incrementalDiff(oldClusterState.getRoutingTable());
+        RoutingTable newRoutingTable = incrementalDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTable.version());
+            assertEquals(indexRoutingTable, newRoutingTable.index(indexRoutingTable.getIndex()));
+        }
+        RoutingTable newRoutingTableWithFullDiff = fullDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTableWithFullDiff.version());
+            assertEquals(indexRoutingTable, newRoutingTableWithFullDiff.index(indexRoutingTable.getIndex()));
+        }
+    }
+
+    public void testRoutingTableDiffsWithStartedState() {
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(), is(this.totalNumberOfShards));
+        initPrimaries();
+        assertThat(
+            clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
+            is(this.totalNumberOfShards - 2 * this.numberOfShards)
+        );
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(2 * this.numberOfShards));
+
+        startInitializingShards(TEST_INDEX_1);
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.STARTED).size(), is(this.numberOfShards));
+        int initializingExpected = this.numberOfShards + this.numberOfShards * this.numberOfReplicas;
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(initializingExpected));
+        assertThat(
+            clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
+            is(this.totalNumberOfShards - initializingExpected - this.numberOfShards)
+        );
+
+        startInitializingShards(TEST_INDEX_2);
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.STARTED).size(), is(2 * this.numberOfShards));
+        initializingExpected = 2 * this.numberOfShards * this.numberOfReplicas;
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(initializingExpected));
+        assertThat(
+            clusterState.routingTable().shardsWithState(ShardRoutingState.UNASSIGNED).size(),
+            is(this.totalNumberOfShards - initializingExpected - 2 * this.numberOfShards)
+        );
+        ClusterState oldClusterState = clusterState;
+        // start a random replica to change a single shard routing
+        clusterState = startRandomInitializingShard(clusterState, ALLOCATION_SERVICE);
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.INITIALIZING).size(), is(initializingExpected - 1));
+        assertThat(clusterState.routingTable().shardsWithState(ShardRoutingState.STARTED).size(), is(2 * this.numberOfShards + 1));
+        Diff<RoutingTable> fullDiff = clusterState.routingTable().diff(oldClusterState.getRoutingTable());
+        Diff<RoutingTable> incrementalDiff = clusterState.routingTable().incrementalDiff(oldClusterState.getRoutingTable());
+        RoutingTable newRoutingTable = incrementalDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTable.version());
+            assertEquals(indexRoutingTable, newRoutingTable.index(indexRoutingTable.getIndex()));
+        }
+        RoutingTable newRoutingTableWithFullDiff = fullDiff.apply(oldClusterState.getRoutingTable());
+        for (IndexRoutingTable indexRoutingTable : clusterState.routingTable()) {
+            assertEquals(clusterState.routingTable().version(), newRoutingTableWithFullDiff.version());
+            assertEquals(indexRoutingTable, newRoutingTableWithFullDiff.index(indexRoutingTable.getIndex()));
+        }
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/cluster/routing/RoutingTableTests.java b/server/src/test/java/org/opensearch/cluster/routing/RoutingTableTests.java
index 97283f561d6d4..d8a67c09e442c 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/RoutingTableTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/RoutingTableTests.java
@@ -714,4 +714,5 @@ public static IndexMetadata updateActiveAllocations(IndexRoutingTable indexRouti
         }
         return imdBuilder.build();
     }
+
 }
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationConstraintsTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationConstraintsTests.java
index 90546620e9e3e..4c9fcd1650664 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationConstraintsTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationConstraintsTests.java
@@ -93,7 +93,7 @@ public void testPerIndexPrimaryShardsConstraint() {
 
         assertEquals(0, constraints.weight(balancer, node, indexName));
 
-        perIndexPrimaryShardCount = 3;
+        perIndexPrimaryShardCount = 2;
         when(node.numPrimaryShards(anyString())).thenReturn(perIndexPrimaryShardCount);
         assertEquals(CONSTRAINT_WEIGHT, constraints.weight(balancer, node, indexName));
 
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationServiceTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationServiceTests.java
index 64d9c243304d8..cce75105dd33f 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/AllocationServiceTests.java
@@ -33,6 +33,7 @@
 
 import org.opensearch.Version;
 import org.opensearch.cluster.ClusterInfo;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.EmptyClusterInfoService;
@@ -56,6 +57,9 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.gateway.GatewayAllocator;
 import org.opensearch.snapshots.EmptySnapshotsInfoService;
+import org.opensearch.telemetry.metrics.Histogram;
+import org.opensearch.telemetry.metrics.MetricsRegistry;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.gateway.TestGatewayAllocator;
 
@@ -77,6 +81,12 @@
 import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.not;
+import static org.mockito.ArgumentMatchers.anyDouble;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 public class AllocationServiceTests extends OpenSearchTestCase {
 
@@ -137,6 +147,16 @@ public void testAssignsPrimariesInPriorityOrderThenReplicas() {
             .put(CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_OUTGOING_RECOVERIES_SETTING.getKey(), Integer.MAX_VALUE)
             .build();
         final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        final MetricsRegistry metricsRegistry = mock(MetricsRegistry.class);
+        final Histogram rerouteHistogram = mock(Histogram.class);
+        final Histogram mockedHistogram = mock(Histogram.class);
+        when(metricsRegistry.createHistogram(anyString(), anyString(), anyString())).thenAnswer(invocationOnMock -> {
+            String histogramName = (String) invocationOnMock.getArguments()[0];
+            if (histogramName.contains("reroute.latency")) {
+                return rerouteHistogram;
+            }
+            return mockedHistogram;
+        });
         final AllocationService allocationService = new AllocationService(
             new AllocationDeciders(
                 Arrays.asList(
@@ -158,7 +178,8 @@ public ShardAllocationDecision decideShardAllocation(ShardRouting shard, Routing
                 }
             },
             new EmptyClusterInfoService(),
-            EmptySnapshotsInfoService.INSTANCE
+            EmptySnapshotsInfoService.INSTANCE,
+            new ClusterManagerMetrics(metricsRegistry)
         );
 
         final String unrealisticAllocatorName = "unrealistic";
@@ -258,10 +279,18 @@ public ShardAllocationDecision decideShardAllocation(ShardRouting shard, Routing
         assertThat(routingTable3.index("mediumPriority").shardsWithState(ShardRoutingState.STARTED).size(), equalTo(4));
         assertTrue(routingTable3.index("lowPriority").allPrimaryShardsActive());
         assertThat(routingTable3.index("invalid").shardsWithState(ShardRoutingState.STARTED), empty());
+
+        verify(rerouteHistogram, times(3)).record(anyDouble());
     }
 
     public void testExplainsNonAllocationOfShardWithUnknownAllocator() {
-        final AllocationService allocationService = new AllocationService(null, null, null, null);
+        final AllocationService allocationService = new AllocationService(
+            null,
+            null,
+            null,
+            null,
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
+        );
         allocationService.setExistingShardsAllocators(
             Collections.singletonMap(GatewayAllocator.ALLOCATOR_NAME, new TestGatewayAllocator())
         );
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/BalancedSingleShardTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/BalancedSingleShardTests.java
index d29249cef0818..11a43019f648e 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/BalancedSingleShardTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/BalancedSingleShardTests.java
@@ -33,7 +33,6 @@
 package org.opensearch.cluster.routing.allocation;
 
 import org.opensearch.action.support.replication.ClusterStateCreationUtils;
-import org.opensearch.cluster.ClusterInfo;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.OpenSearchAllocationTestCase;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -50,7 +49,6 @@
 import org.opensearch.cluster.routing.allocation.decider.Decision.Type;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.snapshots.SnapshotShardSizeInfo;
 
 import java.util.Arrays;
 import java.util.Collections;
@@ -398,19 +396,6 @@ public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation alloca
         return Tuple.tuple(clusterState, rebalanceDecision);
     }
 
-    private RoutingAllocation newRoutingAllocation(AllocationDeciders deciders, ClusterState state) {
-        RoutingAllocation allocation = new RoutingAllocation(
-            deciders,
-            new RoutingNodes(state, false),
-            state,
-            ClusterInfo.EMPTY,
-            SnapshotShardSizeInfo.EMPTY,
-            System.nanoTime()
-        );
-        allocation.debugDecision(true);
-        return allocation;
-    }
-
     private void assertAssignedNodeRemainsSame(
         BalancedShardsAllocator allocator,
         RoutingAllocation routingAllocation,
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/DecideAllocateUnassignedTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/DecideAllocateUnassignedTests.java
new file mode 100644
index 0000000000000..6df2ffc6149d5
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/DecideAllocateUnassignedTests.java
@@ -0,0 +1,154 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation;
+
+import org.opensearch.Version;
+import org.opensearch.action.support.replication.ClusterStateCreationUtils;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.OpenSearchAllocationTestCase;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.AllocationId;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RoutingNode;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
+import org.opensearch.cluster.routing.UnassignedInfo;
+import org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
+import org.opensearch.cluster.routing.allocation.decider.AllocationDecider;
+import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
+import org.opensearch.cluster.routing.allocation.decider.Decision;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.shard.ShardId;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_CREATION_DATE;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_VERSION_CREATED;
+import static org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator.IGNORE_THROTTLE_FOR_REMOTE_RESTORE;
+
+public class DecideAllocateUnassignedTests extends OpenSearchAllocationTestCase {
+    public void testAllocateUnassignedRemoteRestore_IgnoreThrottle() {
+        final String[] indices = { "idx1" };
+        // Create a cluster state with 1 indices, each with 1 started primary shard, and only
+        // one node initially so that all primary shards get allocated to the same node.
+        //
+        // When we add 1 more 1 index with 1 started primary shard and 1 more node , if the new node throttles the recovery
+        // shard should get assigned on the older node if IgnoreThrottle is set to true
+        ClusterState clusterState = ClusterStateCreationUtils.state(1, indices, 1);
+        clusterState = addNodesToClusterState(clusterState, 1);
+        clusterState = addRestoringIndexToClusterState(clusterState, "idx2");
+        List<AllocationDecider> allocationDeciders = getAllocationDecidersThrottleOnNode1();
+        RoutingAllocation routingAllocation = newRoutingAllocation(new AllocationDeciders(allocationDeciders), clusterState);
+        // allocate and get the node that is now relocating
+        Settings build = Settings.builder().put(IGNORE_THROTTLE_FOR_REMOTE_RESTORE.getKey(), true).build();
+        BalancedShardsAllocator allocator = new BalancedShardsAllocator(build);
+        allocator.allocate(routingAllocation);
+        assertEquals(routingAllocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).get(0).currentNodeId(), "node_0");
+        assertEquals(routingAllocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).get(0).getIndexName(), "idx2");
+        assertFalse(routingAllocation.routingNodes().hasUnassignedPrimaries());
+    }
+
+    public void testAllocateUnassignedRemoteRestore() {
+        final String[] indices = { "idx1" };
+        // Create a cluster state with 1 indices, each with 1 started primary shard, and only
+        // one node initially so that all primary shards get allocated to the same node.
+        //
+        // When we add 1 more 1 index with 1 started primary shard and 1 more node , if the new node throttles the recovery
+        // shard should remain unassigned if IgnoreThrottle is set to false
+        ClusterState clusterState = ClusterStateCreationUtils.state(1, indices, 1);
+        clusterState = addNodesToClusterState(clusterState, 1);
+        clusterState = addRestoringIndexToClusterState(clusterState, "idx2");
+        List<AllocationDecider> allocationDeciders = getAllocationDecidersThrottleOnNode1();
+        RoutingAllocation routingAllocation = newRoutingAllocation(new AllocationDeciders(allocationDeciders), clusterState);
+        // allocate and get the node that is now relocating
+        Settings build = Settings.builder().put(IGNORE_THROTTLE_FOR_REMOTE_RESTORE.getKey(), false).build();
+        BalancedShardsAllocator allocator = new BalancedShardsAllocator(build);
+        allocator.allocate(routingAllocation);
+        assertEquals(routingAllocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING).size(), 0);
+        assertTrue(routingAllocation.routingNodes().hasUnassignedPrimaries());
+    }
+
+    private static List<AllocationDecider> getAllocationDecidersThrottleOnNode1() {
+        // Allocation Deciders to throttle on `node_1`
+        final Set<String> throttleNodes = new HashSet<>();
+        throttleNodes.add("node_1");
+        AllocationDecider allocationDecider = new AllocationDecider() {
+            @Override
+            public Decision canAllocate(ShardRouting shardRouting, RoutingNode node, RoutingAllocation allocation) {
+                if (throttleNodes.contains(node.nodeId())) {
+                    return Decision.THROTTLE;
+                }
+                return Decision.YES;
+            }
+        };
+        List<AllocationDecider> allocationDeciders = Arrays.asList(allocationDecider);
+        return allocationDeciders;
+    }
+
+    private ClusterState addNodesToClusterState(ClusterState clusterState, int nodeId) {
+        DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder(clusterState.nodes());
+        DiscoveryNode discoveryNode = newNode("node_" + nodeId);
+        nodesBuilder.add(discoveryNode);
+        return ClusterState.builder(clusterState).nodes(nodesBuilder).build();
+    }
+
+    private ClusterState addRestoringIndexToClusterState(ClusterState clusterState, String index) {
+        final int primaryTerm = 1 + randomInt(200);
+        final ShardId shardId = new ShardId(index, "_na_", 0);
+
+        IndexMetadata indexMetadata = IndexMetadata.builder(index)
+            .settings(
+                Settings.builder()
+                    .put(SETTING_VERSION_CREATED, Version.CURRENT)
+                    .put(SETTING_NUMBER_OF_SHARDS, 1)
+                    .put(SETTING_NUMBER_OF_REPLICAS, 0)
+                    .put(SETTING_CREATION_DATE, System.currentTimeMillis())
+            )
+            .primaryTerm(0, primaryTerm)
+            .build();
+
+        IndexShardRoutingTable.Builder indexShardRoutingBuilder = new IndexShardRoutingTable.Builder(shardId);
+        UnassignedInfo unassignedInfo = new UnassignedInfo(UnassignedInfo.Reason.EXISTING_INDEX_RESTORED, null);
+        indexShardRoutingBuilder.addShard(
+            TestShardRouting.newShardRoutingRemoteRestore(index, shardId, null, null, true, ShardRoutingState.UNASSIGNED, unassignedInfo)
+        );
+        final IndexShardRoutingTable indexShardRoutingTable = indexShardRoutingBuilder.build();
+
+        IndexMetadata.Builder indexMetadataBuilder = new IndexMetadata.Builder(indexMetadata);
+        indexMetadataBuilder.putInSyncAllocationIds(
+            0,
+            indexShardRoutingTable.activeShards()
+                .stream()
+                .map(ShardRouting::allocationId)
+                .map(AllocationId::getId)
+                .collect(Collectors.toSet())
+        );
+        ClusterState.Builder state = ClusterState.builder(clusterState);
+        state.metadata(Metadata.builder(clusterState.metadata()).put(indexMetadataBuilder.build(), false).generateClusterUuidIfNeeded());
+        state.routingTable(
+            RoutingTable.builder(clusterState.routingTable())
+                .add(IndexRoutingTable.builder(indexMetadata.getIndex()).addIndexShard(indexShardRoutingTable))
+                .build()
+        );
+        return state.build();
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/ExistingShardsAllocatorTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/ExistingShardsAllocatorTests.java
new file mode 100644
index 0000000000000..1da8f5ef7f695
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/ExistingShardsAllocatorTests.java
@@ -0,0 +1,118 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.OpenSearchAllocationTestCase;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.settings.Settings;
+
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+public class ExistingShardsAllocatorTests extends OpenSearchAllocationTestCase {
+
+    public void testRunnablesExecutedForUnassignedShards() throws InterruptedException {
+
+        Metadata metadata = Metadata.builder()
+            .put(IndexMetadata.builder("test").settings(settings(Version.CURRENT)).numberOfShards(3).numberOfReplicas(2))
+            .build();
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index("test")).build();
+
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(initialRoutingTable)
+            .build();
+        clusterState = ClusterState.builder(clusterState)
+            .nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")).add(newNode("node3")))
+            .build();
+        RoutingAllocation allocation = new RoutingAllocation(
+            yesAllocationDeciders(),
+            clusterState.getRoutingNodes(),
+            clusterState,
+            null,
+            null,
+            0L
+        );
+        CountDownLatch expectedStateLatch = new CountDownLatch(3);
+        TestAllocator testAllocator = new TestAllocator(expectedStateLatch);
+        testAllocator.allocateAllUnassignedShards(allocation, true).run();
+        // if the below condition is passed, then we are sure runnable executed for all primary shards
+        assertTrue(expectedStateLatch.await(30, TimeUnit.SECONDS));
+
+        expectedStateLatch = new CountDownLatch(6);
+        testAllocator = new TestAllocator(expectedStateLatch);
+        testAllocator.allocateAllUnassignedShards(allocation, false).run();
+        // if the below condition is passed, then we are sure runnable executed for all replica shards
+        assertTrue(expectedStateLatch.await(30, TimeUnit.SECONDS));
+    }
+
+    private static class TestAllocator implements ExistingShardsAllocator {
+
+        final CountDownLatch countDownLatch;
+
+        TestAllocator(CountDownLatch latch) {
+            this.countDownLatch = latch;
+        }
+
+        @Override
+        public void beforeAllocation(RoutingAllocation allocation) {
+
+        }
+
+        @Override
+        public void afterPrimariesBeforeReplicas(RoutingAllocation allocation) {
+
+        }
+
+        @Override
+        public void allocateUnassigned(
+            ShardRouting shardRouting,
+            RoutingAllocation allocation,
+            UnassignedAllocationHandler unassignedAllocationHandler
+        ) {
+            countDownLatch.countDown();
+        }
+
+        @Override
+        public AllocateUnassignedDecision explainUnassignedShardAllocation(
+            ShardRouting unassignedShard,
+            RoutingAllocation routingAllocation
+        ) {
+            return null;
+        }
+
+        @Override
+        public void cleanCaches() {
+
+        }
+
+        @Override
+        public void applyStartedShards(List<ShardRouting> startedShards, RoutingAllocation allocation) {
+
+        }
+
+        @Override
+        public void applyFailedShards(List<FailedShard> failedShards, RoutingAllocation allocation) {
+
+        }
+
+        @Override
+        public int getNumberOfInFlightFetches() {
+            return 0;
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/FailedShardsRoutingTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/FailedShardsRoutingTests.java
index 5e3b74ee138ab..f8e1c609e6ee8 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/FailedShardsRoutingTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/FailedShardsRoutingTests.java
@@ -68,6 +68,7 @@
 import static org.opensearch.cluster.routing.ShardRoutingState.STARTED;
 import static org.opensearch.cluster.routing.ShardRoutingState.UNASSIGNED;
 import static org.opensearch.common.util.FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
@@ -853,6 +854,8 @@ public void testPreferReplicaOnRemoteNodeForPrimaryPromotion() {
 
         // add a remote node and start primary shard
         Map<String, String> remoteStoreNodeAttributes = Map.of(
+            REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            "REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY",
             REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY,
             "REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_VALUE",
             REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY,
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteStoreMigrationAllocationDeciderTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteStoreMigrationAllocationDeciderTests.java
index ee4dbe9738e04..e6e81c94e7f32 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteStoreMigrationAllocationDeciderTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/RemoteStoreMigrationAllocationDeciderTests.java
@@ -54,7 +54,6 @@
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
@@ -68,8 +67,8 @@
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REMOTE_STORE_ENABLED;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REMOTE_TRANSLOG_STORE_REPOSITORY;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REPLICATION_TYPE;
-import static org.opensearch.common.util.FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.Direction.NONE;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.Direction.REMOTE_STORE;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
@@ -81,8 +80,6 @@ public class RemoteStoreMigrationAllocationDeciderTests extends OpenSearchAlloca
     private final static String TEST_INDEX = "test_index";
     private final static String TEST_REPO = "test_repo";
 
-    private final Settings directionEnabledNodeSettings = Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build();
-
     private final Settings strictModeCompatibilitySettings = Settings.builder()
         .put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), RemoteStoreNodeService.CompatibilityMode.STRICT)
         .build();
@@ -111,7 +108,6 @@ public class RemoteStoreMigrationAllocationDeciderTests extends OpenSearchAlloca
     private ShardId shardId = new ShardId(TEST_INDEX, "_na_", 0);
 
     private void beforeAllocation(String direction) {
-        FeatureFlags.initializeFeatureFlags(directionEnabledNodeSettings);
         if (isRemoteStoreBackedIndex == null) {
             isRemoteStoreBackedIndex = randomBoolean();
         }
@@ -584,9 +580,6 @@ private Settings getCustomSettings(String direction, String compatibilityMode, I
 
         // index metadata settings
         builder.put(indexMetadataBuilder.build().getSettings());
-
-        builder.put(directionEnabledNodeSettings);
-
         return builder.build();
     }
 
@@ -625,6 +618,7 @@ private DiscoveryNode getRemoteNode() {
             REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
             "REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_VALUE"
         );
+        attributes.put(REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_VALUE");
         return new DiscoveryNode(
             UUIDs.base64UUID(),
             buildNewFakeTransportAddress(),
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/ShardsTieringAllocationTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/ShardsTieringAllocationTests.java
new file mode 100644
index 0000000000000..8d45ebd2781b1
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/ShardsTieringAllocationTests.java
@@ -0,0 +1,128 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.RoutingNode;
+import org.opensearch.cluster.routing.RoutingNodes;
+import org.opensearch.cluster.routing.RoutingPool;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.index.IndexModule;
+import org.opensearch.test.FeatureFlagSetter;
+import org.junit.Before;
+
+import static org.opensearch.cluster.routing.RoutingPool.LOCAL_ONLY;
+import static org.opensearch.cluster.routing.RoutingPool.REMOTE_CAPABLE;
+import static org.opensearch.cluster.routing.RoutingPool.getIndexPool;
+import static org.opensearch.index.IndexModule.INDEX_STORE_LOCALITY_SETTING;
+
+public class ShardsTieringAllocationTests extends TieringAllocationBaseTestCase {
+
+    @Before
+    public void setup() {
+        FeatureFlagSetter.set(FeatureFlags.TIERED_REMOTE_INDEX);
+    }
+
+    public void testShardsInLocalPool() {
+        int localOnlyNodes = 5;
+        int remoteCapableNodes = 3;
+        int localIndices = 5;
+        int remoteIndices = 0;
+        ClusterState clusterState = createInitialCluster(localOnlyNodes, remoteCapableNodes, localIndices, remoteIndices);
+        AllocationService service = this.createRemoteCapableAllocationService();
+        // assign shards to respective nodes
+        clusterState = allocateShardsAndBalance(clusterState, service);
+        RoutingNodes routingNodes = clusterState.getRoutingNodes();
+        RoutingAllocation allocation = getRoutingAllocation(clusterState, routingNodes);
+        assertEquals(0, routingNodes.unassigned().size());
+
+        for (ShardRouting shard : clusterState.getRoutingTable().allShards()) {
+            assertFalse(shard.unassigned());
+            RoutingPool shardPool = RoutingPool.getShardPool(shard, allocation);
+            assertEquals(LOCAL_ONLY, shardPool);
+        }
+    }
+
+    public void testShardsInRemotePool() {
+        int localOnlyNodes = 7;
+        int remoteCapableNodes = 3;
+        int localIndices = 0;
+        int remoteIndices = 13;
+        ClusterState clusterState = createInitialCluster(localOnlyNodes, remoteCapableNodes, localIndices, remoteIndices);
+        AllocationService service = this.createRemoteCapableAllocationService();
+        // assign shards to respective nodes
+        clusterState = allocateShardsAndBalance(clusterState, service);
+        RoutingNodes routingNodes = clusterState.getRoutingNodes();
+        RoutingAllocation allocation = getRoutingAllocation(clusterState, routingNodes);
+        assertEquals(0, routingNodes.unassigned().size());
+
+        for (ShardRouting shard : clusterState.getRoutingTable().allShards()) {
+            assertFalse(shard.unassigned());
+            RoutingPool shardPool = RoutingPool.getShardPool(shard, allocation);
+            assertEquals(REMOTE_CAPABLE, shardPool);
+        }
+    }
+
+    public void testShardsWithTiering() {
+        int localOnlyNodes = 15;
+        int remoteCapableNodes = 13;
+        int localIndices = 10;
+        int remoteIndices = 0;
+        ClusterState clusterState = createInitialCluster(localOnlyNodes, remoteCapableNodes, localIndices, remoteIndices);
+        AllocationService service = this.createRemoteCapableAllocationService();
+        // assign shards to respective nodes
+        clusterState = allocateShardsAndBalance(clusterState, service);
+        // put indices in the hot to warm tiering state
+        clusterState = updateIndexMetadataForTiering(
+            clusterState,
+            localIndices,
+            IndexModule.TieringState.HOT_TO_WARM.name(),
+            IndexModule.DataLocalityType.PARTIAL.name()
+        );
+        // trigger shard relocation
+        clusterState = allocateShardsAndBalance(clusterState, service);
+        RoutingNodes routingNodes = clusterState.getRoutingNodes();
+        RoutingAllocation allocation = getRoutingAllocation(clusterState, routingNodes);
+        assertEquals(0, routingNodes.unassigned().size());
+
+        for (ShardRouting shard : clusterState.getRoutingTable().allShards()) {
+            assertFalse(shard.unassigned());
+            RoutingNode node = routingNodes.node(shard.currentNodeId());
+            RoutingPool nodePool = RoutingPool.getNodePool(node);
+            RoutingPool shardPool = RoutingPool.getShardPool(shard, allocation);
+            assertEquals(RoutingPool.REMOTE_CAPABLE, shardPool);
+            assertEquals(nodePool, shardPool);
+        }
+    }
+
+    public void testShardPoolForPartialIndices() {
+        String index = "test-index";
+        IndexMetadata indexMetadata = IndexMetadata.builder(index)
+            .settings(settings(Version.CURRENT).put(INDEX_STORE_LOCALITY_SETTING.getKey(), IndexModule.DataLocalityType.PARTIAL.name()))
+            .numberOfShards(PRIMARIES)
+            .numberOfReplicas(REPLICAS)
+            .build();
+        RoutingPool indexPool = getIndexPool(indexMetadata);
+        assertEquals(REMOTE_CAPABLE, indexPool);
+    }
+
+    public void testShardPoolForFullIndices() {
+        String index = "test-index";
+        IndexMetadata indexMetadata = IndexMetadata.builder(index)
+            .settings(settings(Version.CURRENT).put(INDEX_STORE_LOCALITY_SETTING.getKey(), IndexModule.DataLocalityType.FULL.name()))
+            .numberOfShards(PRIMARIES)
+            .numberOfReplicas(REPLICAS)
+            .build();
+        RoutingPool indexPool = getIndexPool(indexMetadata);
+        assertEquals(LOCAL_ONLY, indexPool);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/TieringAllocationBaseTestCase.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/TieringAllocationBaseTestCase.java
new file mode 100644
index 0000000000000..aba6fe74e0634
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/TieringAllocationBaseTestCase.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation;
+
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.common.SuppressForbidden;
+import org.opensearch.common.settings.Settings;
+
+import static org.opensearch.index.IndexModule.INDEX_STORE_LOCALITY_SETTING;
+import static org.opensearch.index.IndexModule.INDEX_TIERING_STATE;
+
+@SuppressForbidden(reason = "feature flag overrides")
+public abstract class TieringAllocationBaseTestCase extends RemoteShardsBalancerBaseTestCase {
+
+    public ClusterState updateIndexMetadataForTiering(
+        ClusterState clusterState,
+        int localIndices,
+        String tieringState,
+        String dataLocality
+    ) {
+        Metadata.Builder mb = Metadata.builder(clusterState.metadata());
+        for (int i = 0; i < localIndices; i++) {
+            IndexMetadata indexMetadata = clusterState.metadata().index(getIndexName(i, false));
+            Settings settings = indexMetadata.getSettings();
+            mb.put(
+                IndexMetadata.builder(indexMetadata)
+                    .settings(
+                        Settings.builder()
+                            .put(settings)
+                            .put(settings)
+                            .put(INDEX_TIERING_STATE.getKey(), tieringState)
+                            .put(INDEX_STORE_LOCALITY_SETTING.getKey(), dataLocality)
+                    )
+            );
+        }
+        Metadata metadata = mb.build();
+        return ClusterState.builder(clusterState).metadata(metadata).build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/UpdateNumberOfReplicasTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/UpdateNumberOfReplicasTests.java
index b53e520581321..5082d6ab0a37c 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/UpdateNumberOfReplicasTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/UpdateNumberOfReplicasTests.java
@@ -41,7 +41,9 @@
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
 import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.common.settings.Settings;
 
 import static org.opensearch.cluster.routing.ShardRoutingState.INITIALIZING;
@@ -188,4 +190,248 @@ public void testUpdateNumberOfReplicas() {
         newState = strategy.reroute(clusterState, "reroute");
         assertThat(newState, equalTo(clusterState));
     }
+
+    public void testUpdateNumberOfReplicasDoesNotImpactSearchReplicas() {
+        AllocationService strategy = createAllocationService(
+            Settings.builder().put("cluster.routing.allocation.node_concurrent_recoveries", 10).build()
+        );
+
+        logger.info("Building initial routing table");
+
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder("test")
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(1)
+                    .numberOfReplicas(1)
+                    .numberOfSearchReplicas(1)
+            )
+            .build();
+
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(metadata.index("test")).build();
+
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .build();
+
+        assertEquals(1, routingTable.index("test").shards().size());
+        IndexShardRoutingTable shardRoutingTable = routingTable.index("test").shard(0);
+        // 1 primary, 1 replica, 1 search replica
+        assertEquals(3, shardRoutingTable.size());
+        assertEquals(2, shardRoutingTable.replicaShards().size());
+        assertEquals(1, shardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(UNASSIGNED, shardRoutingTable.shards().get(0).state());
+        assertEquals(UNASSIGNED, shardRoutingTable.shards().get(1).state());
+        assertEquals(UNASSIGNED, shardRoutingTable.shards().get(2).state());
+        assertNull(shardRoutingTable.shards().get(0).currentNodeId());
+        assertNull(shardRoutingTable.shards().get(1).currentNodeId());
+        assertNull(shardRoutingTable.shards().get(2).currentNodeId());
+
+        logger.info("Adding two nodes and performing rerouting");
+        clusterState = ClusterState.builder(clusterState)
+            .nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")).add(newNode("node3")))
+            .build();
+
+        clusterState = strategy.reroute(clusterState, "reroute");
+
+        logger.info("Start all the primary shards");
+        clusterState = startInitializingShardsAndReroute(strategy, clusterState);
+
+        logger.info("Start all the replica and search shards");
+        ClusterState newState = startInitializingShardsAndReroute(strategy, clusterState);
+        assertNotEquals(newState, clusterState);
+        clusterState = newState;
+
+        shardRoutingTable = clusterState.routingTable().index("test").shard(0);
+        final String nodeHoldingPrimary = shardRoutingTable.primaryShard().currentNodeId();
+        final String nodeHoldingSearchReplica = shardRoutingTable.searchOnlyReplicas().get(0).currentNodeId();
+        final String nodeHoldingReplica = shardRoutingTable.writerReplicas().get(0).currentNodeId();
+
+        assertNotEquals(nodeHoldingPrimary, nodeHoldingReplica);
+        assertNotEquals(nodeHoldingPrimary, nodeHoldingSearchReplica);
+        assertNotEquals(nodeHoldingReplica, nodeHoldingSearchReplica);
+
+        assertEquals(
+            "There is a single routing shard routing table in the cluster",
+            clusterState.routingTable().index("test").shards().size(),
+            1
+        );
+        assertEquals("There are three shards as part of the shard routing table", 3, shardRoutingTable.size());
+        assertEquals("There are two replicas one search and one write", 2, shardRoutingTable.replicaShards().size());
+        assertEquals(1, shardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(STARTED, shardRoutingTable.shards().get(0).state());
+        assertEquals(STARTED, shardRoutingTable.shards().get(1).state());
+        assertEquals(STARTED, shardRoutingTable.shards().get(2).state());
+
+        logger.info("add another replica");
+        final String[] indices = { "test" };
+        routingTable = RoutingTable.builder(clusterState.routingTable()).updateNumberOfReplicas(2, indices).build();
+        metadata = Metadata.builder(clusterState.metadata()).updateNumberOfReplicas(2, indices).build();
+        clusterState = ClusterState.builder(clusterState).routingTable(routingTable).metadata(metadata).build();
+        IndexMetadata indexMetadata = clusterState.metadata().index("test");
+        assertEquals(2, indexMetadata.getNumberOfReplicas());
+        assertEquals(1, indexMetadata.getNumberOfSearchOnlyReplicas());
+        shardRoutingTable = clusterState.routingTable().index("test").shard(0);
+        assertEquals(4, shardRoutingTable.size());
+        assertEquals(3, shardRoutingTable.replicaShards().size());
+        assertEquals(2, shardRoutingTable.writerReplicas().size());
+        assertEquals(1, shardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(shardRoutingTable.primaryShard().state(), STARTED);
+        assertEquals(shardRoutingTable.searchOnlyReplicas().get(0).state(), STARTED);
+
+        ShardRouting existingReplica = shardRoutingTable.writerReplicas().get(0);
+        assertEquals(existingReplica.state(), STARTED);
+        assertEquals(existingReplica.currentNodeId(), nodeHoldingReplica);
+        ShardRouting newReplica = shardRoutingTable.writerReplicas().get(0);
+        assertEquals(newReplica.state(), STARTED);
+
+        logger.info("Add another node and start the added replica");
+        clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder(clusterState.nodes()).add(newNode("node4"))).build();
+        newState = strategy.reroute(clusterState, "reroute");
+        newState = startInitializingShardsAndReroute(strategy, newState);
+        assertNotEquals(newState, clusterState);
+        clusterState = newState;
+        shardRoutingTable = clusterState.routingTable().index("test").shard(0);
+        for (ShardRouting replicaShard : shardRoutingTable.replicaShards()) {
+            assertEquals(replicaShard.state(), STARTED);
+        }
+        assertTrue(shardRoutingTable.replicaShards().stream().allMatch(r -> r.state().equals(STARTED)));
+
+        // remove both replicas and assert search replica is unchanged
+        routingTable = RoutingTable.builder(clusterState.routingTable()).updateNumberOfReplicas(0, indices).build();
+        metadata = Metadata.builder(clusterState.metadata()).updateNumberOfReplicas(0, indices).build();
+        clusterState = ClusterState.builder(clusterState).routingTable(routingTable).metadata(metadata).build();
+        indexMetadata = clusterState.metadata().index("test");
+        assertEquals(0, indexMetadata.getNumberOfReplicas());
+        assertEquals(1, indexMetadata.getNumberOfSearchOnlyReplicas());
+        shardRoutingTable = clusterState.routingTable().index("test").shard(0);
+        assertEquals(2, shardRoutingTable.size());
+        assertEquals(1, shardRoutingTable.replicaShards().size());
+        assertEquals(0, shardRoutingTable.writerReplicas().size());
+        assertEquals(1, shardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(shardRoutingTable.primaryShard().state(), STARTED);
+        assertEquals(shardRoutingTable.searchOnlyReplicas().get(0).state(), STARTED);
+        assertEquals(shardRoutingTable.searchOnlyReplicas().get(0).currentNodeId(), nodeHoldingSearchReplica);
+    }
+
+    public void testUpdateSearchReplicasDoesNotImpactRegularReplicas() {
+        AllocationService strategy = createAllocationService(
+            Settings.builder().put("cluster.routing.allocation.node_concurrent_recoveries", 10).build()
+        );
+
+        logger.info("Building initial routing table");
+
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder("test")
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(1)
+                    .numberOfReplicas(1)
+                    .numberOfSearchReplicas(1)
+            )
+            .build();
+
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(metadata.index("test")).build();
+
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .build();
+
+        assertEquals(1, routingTable.index("test").shards().size());
+        IndexShardRoutingTable shardRoutingTable = routingTable.index("test").shard(0);
+        // 1 primary, 1 replica, 1 search replica
+        assertEquals(3, shardRoutingTable.size());
+        assertEquals(2, shardRoutingTable.replicaShards().size());
+        assertEquals(1, shardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(UNASSIGNED, shardRoutingTable.shards().get(0).state());
+        assertEquals(UNASSIGNED, shardRoutingTable.shards().get(1).state());
+        assertEquals(UNASSIGNED, shardRoutingTable.shards().get(2).state());
+        assertNull(shardRoutingTable.shards().get(0).currentNodeId());
+        assertNull(shardRoutingTable.shards().get(1).currentNodeId());
+        assertNull(shardRoutingTable.shards().get(2).currentNodeId());
+
+        logger.info("Adding three nodes and performing rerouting");
+        clusterState = ClusterState.builder(clusterState)
+            .nodes(DiscoveryNodes.builder().add(newNode("node1")).add(newNode("node2")).add(newNode("node3")))
+            .build();
+
+        clusterState = strategy.reroute(clusterState, "reroute");
+
+        logger.info("Start all the primary shards");
+        clusterState = startInitializingShardsAndReroute(strategy, clusterState);
+
+        logger.info("Start all the replica and search shards");
+        ClusterState newState = startInitializingShardsAndReroute(strategy, clusterState);
+        assertNotEquals(newState, clusterState);
+        clusterState = newState;
+
+        shardRoutingTable = clusterState.routingTable().index("test").shard(0);
+        final String nodeHoldingPrimary = shardRoutingTable.primaryShard().currentNodeId();
+        final String nodeHoldingSearchReplica = shardRoutingTable.searchOnlyReplicas().get(0).currentNodeId();
+        final String nodeHoldingReplica = shardRoutingTable.writerReplicas().get(0).currentNodeId();
+
+        assertNotEquals(nodeHoldingPrimary, nodeHoldingReplica);
+        assertNotEquals(nodeHoldingPrimary, nodeHoldingSearchReplica);
+        assertNotEquals(nodeHoldingReplica, nodeHoldingSearchReplica);
+
+        assertEquals(
+            "There is a single routing shard routing table in the cluster",
+            clusterState.routingTable().index("test").shards().size(),
+            1
+        );
+        assertEquals("There are three shards as part of the shard routing table", 3, shardRoutingTable.size());
+        assertEquals("There are two replicas one search and one write", 2, shardRoutingTable.replicaShards().size());
+        assertEquals(1, shardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(STARTED, shardRoutingTable.shards().get(0).state());
+        assertEquals(STARTED, shardRoutingTable.shards().get(1).state());
+        assertEquals(STARTED, shardRoutingTable.shards().get(2).state());
+
+        logger.info("add another replica");
+        final String[] indices = { "test" };
+        routingTable = RoutingTable.builder(clusterState.routingTable()).updateNumberOfSearchReplicas(2, indices).build();
+        metadata = Metadata.builder(clusterState.metadata()).updateNumberOfSearchReplicas(2, indices).build();
+        clusterState = ClusterState.builder(clusterState).routingTable(routingTable).metadata(metadata).build();
+        IndexMetadata indexMetadata = clusterState.metadata().index("test");
+        assertEquals(1, indexMetadata.getNumberOfReplicas());
+        assertEquals(2, indexMetadata.getNumberOfSearchOnlyReplicas());
+        shardRoutingTable = clusterState.routingTable().index("test").shard(0);
+        assertEquals(4, shardRoutingTable.size());
+        assertEquals(3, shardRoutingTable.replicaShards().size());
+        assertEquals(1, shardRoutingTable.writerReplicas().size());
+        assertEquals(2, shardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(shardRoutingTable.primaryShard().state(), STARTED);
+        assertEquals(shardRoutingTable.writerReplicas().get(0).state(), STARTED);
+        assertEquals(shardRoutingTable.searchOnlyReplicas().get(0).state(), STARTED);
+        assertEquals(shardRoutingTable.searchOnlyReplicas().get(1).state(), UNASSIGNED);
+
+        logger.info("Add another node and start the added replica");
+        clusterState = ClusterState.builder(clusterState).nodes(DiscoveryNodes.builder(clusterState.nodes()).add(newNode("node4"))).build();
+        newState = strategy.reroute(clusterState, "reroute");
+        newState = startInitializingShardsAndReroute(strategy, newState);
+        assertNotEquals(newState, clusterState);
+        clusterState = newState;
+        shardRoutingTable = clusterState.routingTable().index("test").shard(0);
+        for (ShardRouting replicaShard : shardRoutingTable.replicaShards()) {
+            assertEquals(replicaShard.state(), STARTED);
+        }
+        assertTrue(shardRoutingTable.replicaShards().stream().allMatch(r -> r.state().equals(STARTED)));
+
+        // remove both replicas and assert search replica is unchanged
+        routingTable = RoutingTable.builder(clusterState.routingTable()).updateNumberOfSearchReplicas(0, indices).build();
+        metadata = Metadata.builder(clusterState.metadata()).updateNumberOfSearchReplicas(0, indices).build();
+        clusterState = ClusterState.builder(clusterState).routingTable(routingTable).metadata(metadata).build();
+        indexMetadata = clusterState.metadata().index("test");
+        assertEquals(1, indexMetadata.getNumberOfReplicas());
+        assertEquals(0, indexMetadata.getNumberOfSearchOnlyReplicas());
+        shardRoutingTable = clusterState.routingTable().index("test").shard(0);
+        assertEquals(2, shardRoutingTable.size());
+        assertEquals(1, shardRoutingTable.replicaShards().size());
+        assertEquals(1, shardRoutingTable.writerReplicas().size());
+        assertEquals(0, shardRoutingTable.searchOnlyReplicas().size());
+        assertEquals(shardRoutingTable.primaryShard().state(), STARTED);
+        assertEquals(shardRoutingTable.replicaShards().get(0).state(), STARTED);
+        assertEquals(shardRoutingTable.replicaShards().get(0).currentNodeId(), nodeHoldingReplica);
+    }
 }
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/allocator/TimeBoundBalancedShardsAllocatorTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/allocator/TimeBoundBalancedShardsAllocatorTests.java
new file mode 100644
index 0000000000000..a10c305686638
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/allocator/TimeBoundBalancedShardsAllocatorTests.java
@@ -0,0 +1,479 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation.allocator;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterInfo;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.OpenSearchAllocationTestCase;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingNodes;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.allocation.RoutingAllocation;
+import org.opensearch.cluster.routing.allocation.decider.AllocationDecider;
+import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
+import org.opensearch.cluster.routing.allocation.decider.Decision;
+import org.opensearch.cluster.routing.allocation.decider.SameShardAllocationDecider;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+
+import static org.opensearch.cluster.routing.ShardRoutingState.INITIALIZING;
+import static org.opensearch.cluster.routing.ShardRoutingState.STARTED;
+import static org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator.ALLOCATOR_TIMEOUT_SETTING;
+
+public class TimeBoundBalancedShardsAllocatorTests extends OpenSearchAllocationTestCase {
+
+    private final DiscoveryNode node1 = newNode("node1", "node1", Collections.singletonMap("zone", "1a"));
+    private final DiscoveryNode node2 = newNode("node2", "node2", Collections.singletonMap("zone", "1b"));
+    private final DiscoveryNode node3 = newNode("node3", "node3", Collections.singletonMap("zone", "1c"));
+
+    public void testAllUnassignedShardsAllocatedWhenNoTimeOut() {
+        int numberOfIndices = 2;
+        int numberOfShards = 5;
+        int numberOfReplicas = 1;
+        int totalPrimaryCount = numberOfIndices * numberOfShards;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Settings.Builder settings = Settings.builder();
+        // passing total shard count for timed out latch such that no shard times out
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(settings.build(), new CountDownLatch(totalShardCount));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        RoutingAllocation allocation = new RoutingAllocation(
+            yesAllocationDeciders(),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> initializingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING);
+        int node1Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node1.getId());
+        int node2Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node2.getId());
+        int node3Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node3.getId());
+        assertEquals(totalShardCount, initializingShards.size());
+        assertEquals(0, allocation.routingNodes().unassigned().ignored().size());
+        assertEquals(totalPrimaryCount, node1Recoveries + node2Recoveries + node3Recoveries);
+    }
+
+    public void testAllUnassignedShardsIgnoredWhenTimedOut() {
+        int numberOfIndices = 2;
+        int numberOfShards = 5;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Settings.Builder settings = Settings.builder();
+        // passing 0 for timed out latch such that all shard times out
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(settings.build(), new CountDownLatch(0));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        RoutingAllocation allocation = new RoutingAllocation(
+            yesAllocationDeciders(),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> initializingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING);
+        int node1Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node1.getId());
+        int node2Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node2.getId());
+        int node3Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node3.getId());
+        assertEquals(0, initializingShards.size());
+        assertEquals(totalShardCount, allocation.routingNodes().unassigned().ignored().size());
+        assertEquals(0, node1Recoveries + node2Recoveries + node3Recoveries);
+    }
+
+    public void testAllocatePartialPrimaryShardsUntilTimedOut() {
+        int numberOfIndices = 2;
+        int numberOfShards = 5;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Settings.Builder settings = Settings.builder();
+        int shardsToAllocate = randomIntBetween(1, numberOfShards * numberOfIndices);
+        // passing shards to allocate for timed out latch such that only few primary shards are allocated in this reroute round
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(settings.build(), new CountDownLatch(shardsToAllocate));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        RoutingAllocation allocation = new RoutingAllocation(
+            yesAllocationDeciders(),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> initializingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING);
+        int node1Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node1.getId());
+        int node2Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node2.getId());
+        int node3Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node3.getId());
+        assertEquals(shardsToAllocate, initializingShards.size());
+        assertEquals(totalShardCount - shardsToAllocate, allocation.routingNodes().unassigned().ignored().size());
+        assertEquals(shardsToAllocate, node1Recoveries + node2Recoveries + node3Recoveries);
+    }
+
+    public void testAllocateAllPrimaryShardsAndPartialReplicaShardsUntilTimedOut() {
+        int numberOfIndices = 2;
+        int numberOfShards = 5;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Settings.Builder settings = Settings.builder();
+        int shardsToAllocate = randomIntBetween(numberOfShards * numberOfIndices, totalShardCount);
+        // passing shards to allocate for timed out latch such that all primary shards and few replica shards are allocated in this reroute
+        // round
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(settings.build(), new CountDownLatch(shardsToAllocate));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        RoutingAllocation allocation = new RoutingAllocation(
+            yesAllocationDeciders(),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> initializingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING);
+        int node1Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node1.getId());
+        int node2Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node2.getId());
+        int node3Recoveries = allocation.routingNodes().getInitialPrimariesIncomingRecoveries(node3.getId());
+        assertEquals(shardsToAllocate, initializingShards.size());
+        assertEquals(totalShardCount - shardsToAllocate, allocation.routingNodes().unassigned().ignored().size());
+        assertEquals(numberOfShards * numberOfIndices, node1Recoveries + node2Recoveries + node3Recoveries);
+    }
+
+    public void testAllShardsMoveWhenExcludedAndTimeoutNotBreached() {
+        int numberOfIndices = 3;
+        int numberOfShards = 5;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        MockAllocationService allocationService = createAllocationService();
+        state = applyStartedShardsUntilNoChange(state, allocationService);
+        // check all shards allocated
+        assertEquals(0, state.getRoutingNodes().shardsWithState(INITIALIZING).size());
+        assertEquals(totalShardCount, state.getRoutingNodes().shardsWithState(STARTED).size());
+        int node1ShardCount = state.getRoutingNodes().node("node1").size();
+        Settings settings = Settings.builder().put("cluster.routing.allocation.exclude.zone", "1a").build();
+        int shardsToMove = 10 + 1000; // such that time out is never breached
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(settings, new CountDownLatch(shardsToMove));
+        RoutingAllocation allocation = new RoutingAllocation(
+            allocationDecidersForExcludeAPI(settings),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> relocatingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.RELOCATING);
+        assertEquals(node1ShardCount, relocatingShards.size());
+    }
+
+    public void testNoShardsMoveWhenExcludedAndTimeoutBreached() {
+        int numberOfIndices = 3;
+        int numberOfShards = 5;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        MockAllocationService allocationService = createAllocationService();
+        state = applyStartedShardsUntilNoChange(state, allocationService);
+        // check all shards allocated
+        assertEquals(0, state.getRoutingNodes().shardsWithState(INITIALIZING).size());
+        assertEquals(totalShardCount, state.getRoutingNodes().shardsWithState(STARTED).size());
+        Settings settings = Settings.builder().put("cluster.routing.allocation.exclude.zone", "1a").build();
+        int shardsToMove = 0; // such that time out is never breached
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(settings, new CountDownLatch(shardsToMove));
+        RoutingAllocation allocation = new RoutingAllocation(
+            allocationDecidersForExcludeAPI(settings),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> relocatingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.RELOCATING);
+        assertEquals(0, relocatingShards.size());
+    }
+
+    public void testPartialShardsMoveWhenExcludedAndTimeoutBreached() {
+        int numberOfIndices = 3;
+        int numberOfShards = 5;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        MockAllocationService allocationService = createAllocationService();
+        state = applyStartedShardsUntilNoChange(state, allocationService);
+        // check all shards allocated
+        assertEquals(0, state.getRoutingNodes().shardsWithState(INITIALIZING).size());
+        assertEquals(totalShardCount, state.getRoutingNodes().shardsWithState(STARTED).size());
+        Settings settings = Settings.builder().put("cluster.routing.allocation.exclude.zone", "1a").build();
+        // since for moves, it creates an iterator over shards which interleaves between nodes, hence
+        // for shardsToMove=6, it will have 2 shards from node1, node2, node3 each attempting to move with only
+        // shards from node1 can actually move. Hence, total moves that will be executed is 2 (6/3).
+        int shardsToMove = 6; // such that time out is never breached
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(settings, new CountDownLatch(shardsToMove));
+        RoutingAllocation allocation = new RoutingAllocation(
+            allocationDecidersForExcludeAPI(settings),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> relocatingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.RELOCATING);
+        assertEquals(shardsToMove / 3, relocatingShards.size());
+    }
+
+    public void testClusterRebalancedWhenNotTimedOut() {
+        int numberOfIndices = 1;
+        int numberOfShards = 15;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        MockAllocationService allocationService = createAllocationService(
+            Settings.builder().put("cluster.routing.allocation.exclude.zone", "1a").build()
+        ); // such that no shards are allocated to node1
+        state = applyStartedShardsUntilNoChange(state, allocationService);
+        int node1ShardCount = state.getRoutingNodes().node("node1").size();
+        // check all shards allocated
+        assertEquals(0, state.getRoutingNodes().shardsWithState(INITIALIZING).size());
+        assertEquals(totalShardCount, state.getRoutingNodes().shardsWithState(STARTED).size());
+        assertEquals(0, node1ShardCount);
+        Settings newSettings = Settings.builder().put("cluster.routing.allocation.exclude.zone", "").build();
+        int shardsToMove = 1000; // such that time out is never breached
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(newSettings, new CountDownLatch(shardsToMove));
+        RoutingAllocation allocation = new RoutingAllocation(
+            allocationDecidersForExcludeAPI(newSettings),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> relocatingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.RELOCATING);
+        assertEquals(totalShardCount / 3, relocatingShards.size());
+    }
+
+    public void testClusterNotRebalancedWhenTimedOut() {
+        int numberOfIndices = 1;
+        int numberOfShards = 15;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        MockAllocationService allocationService = createAllocationService(
+            Settings.builder().put("cluster.routing.allocation.exclude.zone", "1a").build()
+        ); // such that no shards are allocated to node1
+        state = applyStartedShardsUntilNoChange(state, allocationService);
+        int node1ShardCount = state.getRoutingNodes().node("node1").size();
+        // check all shards allocated
+        assertEquals(0, state.getRoutingNodes().shardsWithState(INITIALIZING).size());
+        assertEquals(totalShardCount, state.getRoutingNodes().shardsWithState(STARTED).size());
+        assertEquals(0, node1ShardCount);
+        Settings newSettings = Settings.builder().put("cluster.routing.allocation.exclude.zone", "").build();
+        int shardsToMove = 0; // such that it never balances anything
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(newSettings, new CountDownLatch(shardsToMove));
+        RoutingAllocation allocation = new RoutingAllocation(
+            allocationDecidersForExcludeAPI(newSettings),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> relocatingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.RELOCATING);
+        assertEquals(0, relocatingShards.size());
+    }
+
+    public void testClusterPartialRebalancedWhenTimedOut() {
+        int numberOfIndices = 1;
+        int numberOfShards = 15;
+        int numberOfReplicas = 1;
+        int totalShardCount = numberOfIndices * (numberOfShards * (numberOfReplicas + 1));
+        Metadata metadata = buildMetadata(Metadata.builder(), numberOfIndices, numberOfShards, numberOfReplicas);
+        RoutingTable routingTable = buildRoutingTable(metadata);
+        ClusterState state = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        MockAllocationService allocationService = createAllocationService(
+            Settings.builder().put("cluster.routing.allocation.exclude.zone", "1a").build()
+        ); // such that no shards are allocated to node1
+        state = applyStartedShardsUntilNoChange(state, allocationService);
+        int node1ShardCount = state.getRoutingNodes().node("node1").size();
+        // check all shards allocated
+        assertEquals(0, state.getRoutingNodes().shardsWithState(INITIALIZING).size());
+        assertEquals(totalShardCount, state.getRoutingNodes().shardsWithState(STARTED).size());
+        assertEquals(0, node1ShardCount);
+        Settings newSettings = Settings.builder().put("cluster.routing.allocation.exclude.zone", "").build();
+
+        // making custom set of allocation deciders such that it never attempts to move shards but always attempts to rebalance
+        List<AllocationDecider> allocationDeciders = Arrays.asList(new AllocationDecider() {
+            @Override
+            public Decision canMoveAnyShard(RoutingAllocation allocation) {
+                return Decision.NO;
+            }
+        }, new AllocationDecider() {
+            @Override
+            public Decision canRebalance(ShardRouting shardRouting, RoutingAllocation allocation) {
+                return Decision.YES;
+            }
+        }, new SameShardAllocationDecider(newSettings, new ClusterSettings(newSettings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)));
+        int shardsToMove = 3; // such that it only partially balances few shards
+        // adding +1 as during rebalance we do per index timeout check and then per node check
+        BalancedShardsAllocator allocator = new TestBalancedShardsAllocator(newSettings, new CountDownLatch(shardsToMove + 1));
+        RoutingAllocation allocation = new RoutingAllocation(
+            new AllocationDeciders(allocationDeciders),
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            null,
+            System.nanoTime()
+        );
+        allocator.allocate(allocation);
+        List<ShardRouting> relocatingShards = allocation.routingNodes().shardsWithState(ShardRoutingState.RELOCATING);
+        assertEquals(3, relocatingShards.size());
+    }
+
+    public void testAllocatorNeverTimedOutIfValueIsMinusOne() {
+        Settings build = Settings.builder().put("cluster.routing.allocation.balanced_shards_allocator.allocator_timeout", "-1").build();
+        BalancedShardsAllocator allocator = new BalancedShardsAllocator(build);
+        assertFalse(allocator.allocatorTimedOut());
+    }
+
+    public void testAllocatorTimeout() {
+        String settingKey = "cluster.routing.allocation.balanced_shards_allocator.allocator_timeout";
+        // Valid setting with timeout = 20s
+        Settings build = Settings.builder().put(settingKey, "20s").build();
+        assertEquals(20, ALLOCATOR_TIMEOUT_SETTING.get(build).getSeconds());
+
+        // Valid setting with timeout > 20s
+        build = Settings.builder().put(settingKey, "30000ms").build();
+        assertEquals(30, ALLOCATOR_TIMEOUT_SETTING.get(build).getSeconds());
+
+        // Invalid setting with timeout < 20s
+        Settings lessThan20sSetting = Settings.builder().put(settingKey, "10s").build();
+        IllegalArgumentException iae = expectThrows(
+            IllegalArgumentException.class,
+            () -> ALLOCATOR_TIMEOUT_SETTING.get(lessThan20sSetting)
+        );
+        assertEquals("Setting [" + settingKey + "] should be more than 20s or -1ms to disable timeout", iae.getMessage());
+
+        // Valid setting with timeout = -1
+        build = Settings.builder().put(settingKey, "-1").build();
+        assertEquals(-1, ALLOCATOR_TIMEOUT_SETTING.get(build).getMillis());
+    }
+
+    private RoutingTable buildRoutingTable(Metadata metadata) {
+        RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
+        for (Map.Entry<String, IndexMetadata> entry : metadata.getIndices().entrySet()) {
+            routingTableBuilder.addAsNew(entry.getValue());
+        }
+        return routingTableBuilder.build();
+    }
+
+    private Metadata buildMetadata(Metadata.Builder mb, int numberOfIndices, int numberOfShards, int numberOfReplicas) {
+        for (int i = 0; i < numberOfIndices; i++) {
+            mb.put(
+                IndexMetadata.builder("test_" + i)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            );
+        }
+
+        return mb.build();
+    }
+
+    static class TestBalancedShardsAllocator extends BalancedShardsAllocator {
+        private final CountDownLatch timedOutLatch;
+
+        public TestBalancedShardsAllocator(Settings settings, CountDownLatch timedOutLatch) {
+            super(settings);
+            this.timedOutLatch = timedOutLatch;
+        }
+
+        @Override
+        protected boolean allocatorTimedOut() {
+            if (timedOutLatch.getCount() == 0) {
+                return true;
+            }
+            timedOutLatch.countDown();
+            return false;
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java
index bde8a45359814..94e91c3f7c3c1 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/DiskThresholdDeciderTests.java
@@ -69,7 +69,6 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
-import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.index.store.remote.filecache.FileCacheStats;
 import org.opensearch.repositories.IndexId;
 import org.opensearch.snapshots.EmptySnapshotsInfoService;
@@ -95,6 +94,7 @@
 import static org.opensearch.cluster.routing.ShardRoutingState.STARTED;
 import static org.opensearch.cluster.routing.ShardRoutingState.UNASSIGNED;
 import static org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider.CLUSTER_ROUTING_REBALANCE_ENABLE_SETTING;
+import static org.opensearch.index.store.remote.filecache.FileCacheSettings.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
@@ -381,6 +381,7 @@ public void testFileCacheRemoteShardsDecisions() {
             .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_THRESHOLD_ENABLED_SETTING.getKey(), true)
             .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK_SETTING.getKey(), "60%")
             .put(DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey(), "70%")
+            .put(DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.getKey(), 5)
             .build();
 
         // We have an index with 2 primary shards each taking 40 bytes. Each node has 100 bytes available
@@ -406,7 +407,6 @@ public void testFileCacheRemoteShardsDecisions() {
         DiskThresholdDecider diskThresholdDecider = makeDecider(diskSettings);
         Metadata metadata = Metadata.builder()
             .put(IndexMetadata.builder("test").settings(remoteIndexSettings(Version.CURRENT)).numberOfShards(2).numberOfReplicas(0))
-            .persistentSettings(Settings.builder().put(FileCache.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.getKey(), 5).build())
             .build();
 
         RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index("test")).build();
@@ -530,6 +530,8 @@ public void testDiskThresholdWithAbsoluteSizes() {
         // Primary should initialize, even though both nodes are over the limit initialize
         assertThat(clusterState.getRoutingNodes().shardsWithState(INITIALIZING).size(), equalTo(1));
 
+        // below checks are unnecessary as the primary shard is always assigned to node2 as BSA always picks up that node
+        // first as both node1 and node2 have equal weight as both of them contain zero shards.
         String nodeWithPrimary, nodeWithoutPrimary;
         if (clusterState.getRoutingNodes().node("node1").size() == 1) {
             nodeWithPrimary = "node1";
@@ -679,10 +681,12 @@ public void testDiskThresholdWithAbsoluteSizes() {
         clusterState = startInitializingShardsAndReroute(strategy, clusterState);
 
         logShardStates(clusterState);
-        // primary shard already has been relocated away
-        assertThat(clusterState.getRoutingNodes().node(nodeWithPrimary).size(), equalTo(0));
-        // node with increased space still has its shard
-        assertThat(clusterState.getRoutingNodes().node(nodeWithoutPrimary).size(), equalTo(1));
+        // primary shard already has been relocated away - this is a wrong expectation as we don't really move
+        // primary first unless explicitly set by setting. This is caught with PR
+        // https://github.com/opensearch-project/OpenSearch/pull/15239/
+        // as it randomises nodes to check for potential moves
+        // assertThat(clusterState.getRoutingNodes().node(nodeWithPrimary).size(), equalTo(0));
+        // assertThat(clusterState.getRoutingNodes().node(nodeWithoutPrimary).size(), equalTo(1));
         assertThat(clusterState.getRoutingNodes().node("node3").size(), equalTo(1));
         assertThat(clusterState.getRoutingNodes().node("node4").size(), equalTo(1));
 
@@ -863,19 +867,6 @@ public void testUnknownDiskUsage() {
         assertThat(clusterState.getRoutingNodes().node("node1").size(), equalTo(1));
     }
 
-    public void testAverageUsage() {
-        RoutingNode rn = new RoutingNode("node1", newNode("node1"));
-        DiskThresholdDecider decider = makeDecider(Settings.EMPTY);
-
-        final Map<String, DiskUsage> usages = new HashMap<>();
-        usages.put("node2", new DiskUsage("node2", "n2", "/dev/null", 100, 50)); // 50% used
-        usages.put("node3", new DiskUsage("node3", "n3", "/dev/null", 100, 0));  // 100% used
-
-        DiskUsage node1Usage = decider.averageUsage(rn, usages);
-        assertThat(node1Usage.getTotalBytes(), equalTo(100L));
-        assertThat(node1Usage.getFreeBytes(), equalTo(25L));
-    }
-
     public void testFreeDiskPercentageAfterShardAssigned() {
         DiskThresholdDecider decider = makeDecider(Settings.EMPTY);
 
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/FilterAllocationDeciderTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/FilterAllocationDeciderTests.java
index e8273d294f24f..f226c45553d57 100644
--- a/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/FilterAllocationDeciderTests.java
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/FilterAllocationDeciderTests.java
@@ -51,7 +51,6 @@
 import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
-import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.snapshots.EmptySnapshotsInfoService;
 import org.opensearch.test.gateway.TestGatewayAllocator;
@@ -64,7 +63,6 @@
 import static org.opensearch.cluster.routing.ShardRoutingState.INITIALIZING;
 import static org.opensearch.cluster.routing.ShardRoutingState.STARTED;
 import static org.opensearch.cluster.routing.ShardRoutingState.UNASSIGNED;
-import static org.opensearch.common.util.FeatureFlags.REMOTE_STORE_MIGRATION_EXPERIMENTAL;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
 
@@ -325,7 +323,7 @@ private ClusterState createInitialClusterState(AllocationService service, Settin
         return createInitialClusterState(service, indexSettings, Settings.EMPTY);
     }
 
-    private ClusterState createInitialClusterState(AllocationService service, Settings idxSettings, Settings clusterSettings) {
+    static ClusterState createInitialClusterState(AllocationService service, Settings idxSettings, Settings clusterSettings) {
         Metadata.Builder metadata = Metadata.builder();
         metadata.persistentSettings(clusterSettings);
         final Settings.Builder indexSettings = settings(Version.CURRENT).put(idxSettings);
@@ -416,7 +414,6 @@ public void testWildcardIPFilter() {
     public void testMixedModeRemoteStoreAllocation() {
         // For mixed mode remote store direction cluster's existing indices replica creation ,
         // we don't consider filter allocation decider for replica of existing indices
-        FeatureFlags.initializeFeatureFlags(Settings.builder().put(REMOTE_STORE_MIGRATION_EXPERIMENTAL, "true").build());
         ClusterSettings clusterSettings = new ClusterSettings(Settings.builder().build(), ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
         Settings initialSettings = Settings.builder()
             .put("cluster.routing.allocation.exclude._id", "node2")
diff --git a/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/SearchReplicaAllocationDeciderTests.java b/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/SearchReplicaAllocationDeciderTests.java
new file mode 100644
index 0000000000000..8d4f4cdee26cc
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/allocation/decider/SearchReplicaAllocationDeciderTests.java
@@ -0,0 +1,133 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.allocation.decider;
+
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.EmptyClusterInfoService;
+import org.opensearch.cluster.OpenSearchAllocationTestCase;
+import org.opensearch.cluster.routing.RecoverySource;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.UnassignedInfo;
+import org.opensearch.cluster.routing.allocation.AllocationService;
+import org.opensearch.cluster.routing.allocation.RoutingAllocation;
+import org.opensearch.cluster.routing.allocation.allocator.BalancedShardsAllocator;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.snapshots.EmptySnapshotsInfoService;
+import org.opensearch.test.gateway.TestGatewayAllocator;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.opensearch.cluster.routing.allocation.decider.SearchReplicaAllocationDecider.SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING;
+
+public class SearchReplicaAllocationDeciderTests extends OpenSearchAllocationTestCase {
+
+    public void testSearchReplicaRoutingDedicatedIncludes() {
+        // we aren't using a settingsModule here so we need to set feature flag gated setting
+        Set<Setting<?>> settings = new HashSet<>(ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        settings.add(SEARCH_REPLICA_ROUTING_INCLUDE_GROUP_SETTING);
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.builder().build(), settings);
+        Settings initialSettings = Settings.builder()
+            .put("cluster.routing.allocation.search.replica.dedicated.include._id", "node1,node2")
+            .build();
+
+        SearchReplicaAllocationDecider filterAllocationDecider = new SearchReplicaAllocationDecider(initialSettings, clusterSettings);
+        AllocationDeciders allocationDeciders = new AllocationDeciders(
+            Arrays.asList(
+                filterAllocationDecider,
+                new SameShardAllocationDecider(Settings.EMPTY, clusterSettings),
+                new ReplicaAfterPrimaryActiveAllocationDecider()
+            )
+        );
+        AllocationService service = new AllocationService(
+            allocationDeciders,
+            new TestGatewayAllocator(),
+            new BalancedShardsAllocator(Settings.EMPTY),
+            EmptyClusterInfoService.INSTANCE,
+            EmptySnapshotsInfoService.INSTANCE
+        );
+        ClusterState state = FilterAllocationDeciderTests.createInitialClusterState(service, Settings.EMPTY, Settings.EMPTY);
+        RoutingTable routingTable = state.routingTable();
+        RoutingAllocation allocation = new RoutingAllocation(allocationDeciders, state.getRoutingNodes(), state, null, null, 0);
+        allocation.debugDecision(true);
+
+        ShardRouting searchReplica = ShardRouting.newUnassigned(
+            routingTable.index("sourceIndex").shard(0).shardId(),
+            false,
+            true,
+            RecoverySource.PeerRecoverySource.INSTANCE,
+            new UnassignedInfo(UnassignedInfo.Reason.NODE_LEFT, "")
+        );
+
+        ShardRouting regularReplica = ShardRouting.newUnassigned(
+            routingTable.index("sourceIndex").shard(0).shardId(),
+            false,
+            false,
+            RecoverySource.PeerRecoverySource.INSTANCE,
+            new UnassignedInfo(UnassignedInfo.Reason.INDEX_CREATED, "")
+        );
+
+        ShardRouting primary = ShardRouting.newUnassigned(
+            routingTable.index("sourceIndex").shard(0).shardId(),
+            true,
+            false,
+            RecoverySource.PeerRecoverySource.INSTANCE,
+            new UnassignedInfo(UnassignedInfo.Reason.INDEX_CREATED, "")
+        );
+
+        Decision.Single decision = (Decision.Single) filterAllocationDecider.canAllocate(
+            searchReplica,
+            state.getRoutingNodes().node("node2"),
+            allocation
+        );
+        assertEquals(decision.toString(), Decision.Type.YES, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(searchReplica, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.YES, decision.type());
+
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(regularReplica, state.getRoutingNodes().node("node2"), allocation);
+        assertEquals(decision.toString(), Decision.Type.NO, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(regularReplica, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.NO, decision.type());
+
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(primary, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.NO, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(primary, state.getRoutingNodes().node("node2"), allocation);
+        assertEquals(decision.toString(), Decision.Type.NO, decision.type());
+
+        Settings updatedSettings = Settings.builder()
+            .put("cluster.routing.allocation.search.replica.dedicated.include._id", "node2")
+            .build();
+        clusterSettings.applySettings(updatedSettings);
+
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(searchReplica, state.getRoutingNodes().node("node2"), allocation);
+        assertEquals(decision.toString(), Decision.Type.YES, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(searchReplica, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.NO, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canRemain(searchReplica, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.NO, decision.type());
+
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(regularReplica, state.getRoutingNodes().node("node2"), allocation);
+        assertEquals(decision.toString(), Decision.Type.NO, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(regularReplica, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.YES, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canRemain(regularReplica, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.YES, decision.type());
+
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(primary, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.YES, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canAllocate(primary, state.getRoutingNodes().node("node2"), allocation);
+        assertEquals(decision.toString(), Decision.Type.NO, decision.type());
+        decision = (Decision.Single) filterAllocationDecider.canRemain(primary, state.getRoutingNodes().node("node1"), allocation);
+        assertEquals(decision.toString(), Decision.Type.YES, decision.type());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactoryTests.java b/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactoryTests.java
new file mode 100644
index 0000000000000..86f4b9502d6ab
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceFactoryTests.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.remote;
+
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.fs.FsRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+
+import java.util.function.Supplier;
+
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+
+public class RemoteRoutingTableServiceFactoryTests extends OpenSearchTestCase {
+
+    Supplier<RepositoriesService> repositoriesService;
+    private ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @After
+    public void teardown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testGetServiceWhenRemoteRoutingDisabled() {
+        Settings settings = Settings.builder().build();
+        RemoteRoutingTableService service = RemoteRoutingTableServiceFactory.getService(
+            repositoriesService,
+            settings,
+            new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+            threadPool,
+            "test-cluster"
+        );
+        assertTrue(service instanceof NoopRemoteRoutingTableService);
+    }
+
+    public void testGetServiceWhenRemoteRoutingEnabled() {
+        Settings settings = Settings.builder()
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, "routing_repository")
+            .put(FsRepository.REPOSITORIES_COMPRESS_SETTING.getKey(), false)
+            .build();
+        Settings nodeSettings = Settings.builder().put(REMOTE_PUBLICATION_EXPERIMENTAL, "true").build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+        RemoteRoutingTableService service = RemoteRoutingTableServiceFactory.getService(
+            repositoriesService,
+            settings,
+            new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+            threadPool,
+            "test-cluster"
+        );
+        assertTrue(service instanceof InternalRemoteRoutingTableService);
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceTests.java b/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceTests.java
new file mode 100644
index 0000000000000..d7009641c2b76
--- /dev/null
+++ b/server/src/test/java/org/opensearch/cluster/routing/remote/RemoteRoutingTableServiceTests.java
@@ -0,0 +1,834 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.routing.remote;
+
+import org.opensearch.Version;
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.BlobStore;
+import org.opensearch.common.blobstore.stream.write.WritePriority;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.common.util.TestCapturingListener;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.index.Index;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.FilterRepository;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.RepositoryMissingException;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.List;
+import java.util.Locale;
+import java.util.concurrent.CountDownLatch;
+import java.util.function.Supplier;
+
+import org.mockito.Mockito;
+
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
+import static org.opensearch.gateway.remote.ClusterMetadataManifestTests.randomUploadedIndexMetadataList;
+import static org.opensearch.gateway.remote.RemoteClusterStateServiceTests.generateClusterStateWithOneIndex;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.PATH_DELIMITER;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_FILE;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE_FORMAT;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.REMOTE_ROUTING_TABLE_DIFF_FORMAT;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_FILE;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_METADATA_PREFIX;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_PATH_TOKEN;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.HASHED_PREFIX;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class RemoteRoutingTableServiceTests extends OpenSearchTestCase {
+
+    private InternalRemoteRoutingTableService remoteRoutingTableService;
+    private Supplier<RepositoriesService> repositoriesServiceSupplier;
+    private RepositoriesService repositoriesService;
+    private BlobStoreRepository blobStoreRepository;
+    private BlobStore blobStore;
+    private BlobContainer blobContainer;
+    private BlobPath basePath;
+    private ClusterSettings clusterSettings;
+    private ClusterService clusterService;
+    private Compressor compressor;
+    private BlobStoreTransferService blobStoreTransferService;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        repositoriesServiceSupplier = mock(Supplier.class);
+        repositoriesService = mock(RepositoriesService.class);
+        when(repositoriesServiceSupplier.get()).thenReturn(repositoriesService);
+
+        Settings settings = Settings.builder()
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, "routing_repository")
+            .build();
+        clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        clusterService = mock(ClusterService.class);
+        blobStoreTransferService = mock(BlobStoreTransferService.class);
+        when(clusterService.getClusterSettings()).thenReturn(clusterSettings);
+        blobStoreRepository = mock(BlobStoreRepository.class);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        blobStore = mock(BlobStore.class);
+        blobContainer = mock(BlobContainer.class);
+        when(repositoriesService.repository("routing_repository")).thenReturn(blobStoreRepository);
+        when(blobStoreRepository.blobStore()).thenReturn(blobStore);
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        Settings nodeSettings = Settings.builder().put(REMOTE_PUBLICATION_EXPERIMENTAL, "true").build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+        compressor = new NoneCompressor();
+        basePath = BlobPath.cleanPath().add("base-path");
+        when(blobStoreRepository.basePath()).thenReturn(basePath);
+        remoteRoutingTableService = new InternalRemoteRoutingTableService(
+            repositoriesServiceSupplier,
+            settings,
+            new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+            threadPool,
+            "test-cluster"
+        );
+        remoteRoutingTableService.doStart();
+    }
+
+    @After
+    public void teardown() throws Exception {
+        super.tearDown();
+        remoteRoutingTableService.doClose();
+        threadPool.shutdown();
+    }
+
+    public void testFailInitializationWhenRemoteRoutingDisabled() {
+        final Settings settings = Settings.builder().build();
+        assertThrows(
+            AssertionError.class,
+            () -> new InternalRemoteRoutingTableService(
+                repositoriesServiceSupplier,
+                settings,
+                new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                threadPool,
+                "test-cluster"
+            )
+        );
+    }
+
+    public void testFailStartWhenRepositoryNotSet() {
+        doThrow(new RepositoryMissingException("repository missing")).when(repositoriesService).repository("routing_repository");
+        assertThrows(RepositoryMissingException.class, () -> remoteRoutingTableService.start());
+    }
+
+    public void testFailStartWhenNotBlobRepository() {
+        final FilterRepository filterRepository = mock(FilterRepository.class);
+        when(repositoriesService.repository("routing_repository")).thenReturn(filterRepository);
+        assertThrows(AssertionError.class, () -> remoteRoutingTableService.start());
+    }
+
+    public void testGetIndicesRoutingMapDiff() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        final Index index = new Index(indexName, "uuid");
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(1).numberOfReplicas(1).build();
+
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetadata).build();
+
+        StringKeyDiffProvider<IndexRoutingTable> diff = remoteRoutingTableService.getIndicesRoutingMapDiff(routingTable, routingTable);
+        assertEquals(0, diff.provideDiff().getUpserts().size());
+        assertEquals(0, diff.provideDiff().getDeletes().size());
+
+        // Reversing order to check for equality without order.
+        IndexRoutingTable indexRouting = routingTable.getIndicesRouting().get(indexName);
+        IndexRoutingTable indexRoutingTableReversed = IndexRoutingTable.builder(index)
+            .addShard(indexRouting.getShards().get(0).replicaShards().get(0))
+            .addShard(indexRouting.getShards().get(0).primaryShard())
+            .build();
+        RoutingTable routingTable2 = RoutingTable.builder().add(indexRoutingTableReversed).build();
+
+        diff = remoteRoutingTableService.getIndicesRoutingMapDiff(routingTable, routingTable2);
+        assertEquals(0, diff.provideDiff().getUpserts().size());
+        assertEquals(0, diff.provideDiff().getDeletes().size());
+    }
+
+    public void testGetChangedIndicesRouting() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        final Index index = new Index(indexName, "uuid");
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(1).numberOfReplicas(1).build();
+
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetadata).build();
+        ClusterState state = ClusterState.builder(ClusterName.DEFAULT).routingTable(routingTable).build();
+
+        assertEquals(
+            0,
+            remoteRoutingTableService.getIndicesRoutingMapDiff(state.getRoutingTable(), state.getRoutingTable())
+                .provideDiff()
+                .getUpserts()
+                .size()
+        );
+
+        // Reversing order to check for equality without order.
+        IndexRoutingTable indexRouting = routingTable.getIndicesRouting().get(indexName);
+        IndexRoutingTable indexRoutingTable = IndexRoutingTable.builder(index)
+            .addShard(indexRouting.getShards().get(0).replicaShards().get(0))
+            .addShard(indexRouting.getShards().get(0).primaryShard())
+            .build();
+        ClusterState newState = ClusterState.builder(ClusterName.DEFAULT)
+            .routingTable(RoutingTable.builder().add(indexRoutingTable).build())
+            .build();
+        assertEquals(
+            0,
+            remoteRoutingTableService.getIndicesRoutingMapDiff(state.getRoutingTable(), newState.getRoutingTable())
+                .provideDiff()
+                .getUpserts()
+                .size()
+        );
+    }
+
+    public void testGetIndicesRoutingMapDiffIndexAdded() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(between(1, 1000)).numberOfReplicas(randomInt(10)).build();
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetadata).build();
+
+        String indexName2 = randomAlphaOfLength(randomIntBetween(1, 50));
+        int noOfShards = between(1, 1000);
+        int noOfReplicas = randomInt(10);
+        final IndexMetadata indexMetadata2 = new IndexMetadata.Builder(indexName2).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid2")
+                .build()
+        ).numberOfShards(noOfShards).numberOfReplicas(noOfReplicas).build();
+        RoutingTable routingTable2 = RoutingTable.builder(routingTable).addAsNew(indexMetadata2).build();
+
+        StringKeyDiffProvider<IndexRoutingTable> diff = remoteRoutingTableService.getIndicesRoutingMapDiff(routingTable, routingTable2);
+        assertEquals(1, diff.provideDiff().getUpserts().size());
+        assertNotNull(diff.provideDiff().getUpserts().get(indexName2));
+        assertEquals(noOfShards, diff.provideDiff().getUpserts().get(indexName2).getShards().size());
+
+        assertEquals(0, diff.provideDiff().getDeletes().size());
+    }
+
+    public void testGetIndicesRoutingMapDiffShardChanged() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int noOfShards = between(1, 1000);
+        int noOfReplicas = randomInt(10);
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(noOfShards).numberOfReplicas(noOfReplicas).build();
+
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetadata).build();
+
+        final IndexMetadata indexMetadata2 = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(noOfShards + 1).numberOfReplicas(noOfReplicas).build();
+        RoutingTable routingTable2 = RoutingTable.builder().addAsNew(indexMetadata2).build();
+
+        StringKeyDiffProvider<IndexRoutingTable> diff = remoteRoutingTableService.getIndicesRoutingMapDiff(routingTable, routingTable2);
+        assertEquals(0, diff.provideDiff().getUpserts().size());
+        assertEquals(1, diff.provideDiff().getDiffs().size());
+        assertNotNull(diff.provideDiff().getDiffs().get(indexName));
+        assertEquals(
+            noOfShards + 1,
+            diff.provideDiff().getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).shards().size()
+        );
+        assertEquals(
+            noOfReplicas + 1,
+            diff.provideDiff().getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).getShards().get(0).getSize()
+        );
+        assertEquals(0, diff.provideDiff().getDeletes().size());
+
+        final IndexMetadata indexMetadata3 = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(noOfShards + 1).numberOfReplicas(noOfReplicas + 1).build();
+        RoutingTable routingTable3 = RoutingTable.builder().addAsNew(indexMetadata3).build();
+
+        diff = remoteRoutingTableService.getIndicesRoutingMapDiff(routingTable2, routingTable3);
+        assertEquals(0, diff.provideDiff().getUpserts().size());
+        assertEquals(1, diff.provideDiff().getDiffs().size());
+        assertNotNull(diff.provideDiff().getDiffs().get(indexName));
+        assertEquals(
+            noOfShards + 1,
+            diff.provideDiff().getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).shards().size()
+        );
+        assertEquals(
+            noOfReplicas + 2,
+            diff.provideDiff().getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).getShards().get(0).getSize()
+        );
+        assertEquals(0, diff.provideDiff().getDeletes().size());
+    }
+
+    public void testGetIndicesRoutingMapDiffShardDetailChanged() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int noOfShards = between(1, 1000);
+        int noOfReplicas = randomInt(10);
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(noOfShards).numberOfReplicas(noOfReplicas).build();
+
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetadata).build();
+        RoutingTable routingTable2 = RoutingTable.builder().addAsRecovery(indexMetadata).build();
+
+        StringKeyDiffProvider<IndexRoutingTable> diff = remoteRoutingTableService.getIndicesRoutingMapDiff(routingTable, routingTable2);
+        assertEquals(1, diff.provideDiff().getDiffs().size());
+        assertNotNull(diff.provideDiff().getDiffs().get(indexName));
+        assertEquals(
+            noOfShards,
+            diff.provideDiff().getDiffs().get(indexName).apply(routingTable.indicesRouting().get(indexName)).shards().size()
+        );
+        assertEquals(0, diff.provideDiff().getUpserts().size());
+        assertEquals(0, diff.provideDiff().getDeletes().size());
+    }
+
+    public void testGetIndicesRoutingMapDiffIndexDeleted() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(between(1, 1000)).numberOfReplicas(randomInt(10)).build();
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetadata).build();
+
+        String indexName2 = randomAlphaOfLength(randomIntBetween(1, 50));
+        final IndexMetadata indexMetadata2 = new IndexMetadata.Builder(indexName2).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid2")
+                .build()
+        ).numberOfShards(between(1, 1000)).numberOfReplicas(randomInt(10)).build();
+        RoutingTable routingTable2 = RoutingTable.builder().addAsNew(indexMetadata2).build();
+
+        StringKeyDiffProvider<IndexRoutingTable> diff = remoteRoutingTableService.getIndicesRoutingMapDiff(routingTable, routingTable2);
+        assertEquals(1, diff.provideDiff().getUpserts().size());
+        assertNotNull(diff.provideDiff().getUpserts().get(indexName2));
+
+        assertEquals(1, diff.provideDiff().getDeletes().size());
+        assertEquals(indexName, diff.provideDiff().getDeletes().get(0));
+    }
+
+    public void testGetAllUploadedIndicesRouting() {
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().build();
+        final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata = new ClusterMetadataManifest.UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "index-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+
+        List<ClusterMetadataManifest.UploadedIndexMetadata> allIndiceRoutingMetadata = remoteRoutingTableService
+            .getAllUploadedIndicesRouting(previousManifest, List.of(uploadedIndexMetadata), List.of());
+        assertNotNull(allIndiceRoutingMetadata);
+        assertEquals(1, allIndiceRoutingMetadata.size());
+        assertEquals(uploadedIndexMetadata, allIndiceRoutingMetadata.get(0));
+    }
+
+    public void testGetAllUploadedIndicesRoutingExistingIndexInManifest() {
+        final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata = new ClusterMetadataManifest.UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "index-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
+            .indicesRouting(List.of(uploadedIndexMetadata))
+            .build();
+
+        List<ClusterMetadataManifest.UploadedIndexMetadata> allIndiceRoutingMetadata = remoteRoutingTableService
+            .getAllUploadedIndicesRouting(previousManifest, List.of(uploadedIndexMetadata), List.of());
+        assertNotNull(allIndiceRoutingMetadata);
+        assertEquals(1, allIndiceRoutingMetadata.size());
+        assertEquals(uploadedIndexMetadata, allIndiceRoutingMetadata.get(0));
+    }
+
+    public void testGetAllUploadedIndicesRoutingNewIndexFromManifest() {
+        final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata = new ClusterMetadataManifest.UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "index-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
+            .indicesRouting(List.of(uploadedIndexMetadata))
+            .build();
+        final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata2 = new ClusterMetadataManifest.UploadedIndexMetadata(
+            "test-index2",
+            "index-uuid",
+            "index-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+
+        List<ClusterMetadataManifest.UploadedIndexMetadata> allIndiceRoutingMetadata = remoteRoutingTableService
+            .getAllUploadedIndicesRouting(previousManifest, List.of(uploadedIndexMetadata2), List.of());
+        assertNotNull(allIndiceRoutingMetadata);
+        assertEquals(2, allIndiceRoutingMetadata.size());
+        assertEquals(uploadedIndexMetadata, allIndiceRoutingMetadata.get(0));
+        assertEquals(uploadedIndexMetadata2, allIndiceRoutingMetadata.get(1));
+    }
+
+    public void testGetAllUploadedIndicesRoutingIndexDeleted() {
+        final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata = new ClusterMetadataManifest.UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "index-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata2 = new ClusterMetadataManifest.UploadedIndexMetadata(
+            "test-index2",
+            "index-uuid",
+            "index-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
+            .indicesRouting(List.of(uploadedIndexMetadata, uploadedIndexMetadata2))
+            .build();
+
+        List<ClusterMetadataManifest.UploadedIndexMetadata> allIndiceRoutingMetadata = remoteRoutingTableService
+            .getAllUploadedIndicesRouting(previousManifest, List.of(uploadedIndexMetadata2), List.of("test-index"));
+        assertNotNull(allIndiceRoutingMetadata);
+        assertEquals(1, allIndiceRoutingMetadata.size());
+        assertEquals(uploadedIndexMetadata2, allIndiceRoutingMetadata.get(0));
+    }
+
+    public void testGetAllUploadedIndicesRoutingNoChange() {
+        final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata = new ClusterMetadataManifest.UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "index-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        final ClusterMetadataManifest.UploadedIndexMetadata uploadedIndexMetadata2 = new ClusterMetadataManifest.UploadedIndexMetadata(
+            "test-index2",
+            "index-uuid",
+            "index-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
+            .indicesRouting(List.of(uploadedIndexMetadata, uploadedIndexMetadata2))
+            .build();
+
+        List<ClusterMetadataManifest.UploadedIndexMetadata> allIndiceRoutingMetadata = remoteRoutingTableService
+            .getAllUploadedIndicesRouting(previousManifest, List.of(), List.of());
+        assertNotNull(allIndiceRoutingMetadata);
+        assertEquals(2, allIndiceRoutingMetadata.size());
+        assertEquals(uploadedIndexMetadata, allIndiceRoutingMetadata.get(0));
+        assertEquals(uploadedIndexMetadata2, allIndiceRoutingMetadata.get(1));
+    }
+
+    public void testIndicesRoutingDiffWhenIndexDeleted() {
+
+        ClusterState state = createIndices(randomIntBetween(1, 100));
+        RoutingTable routingTable = state.routingTable();
+
+        List<String> allIndices = new ArrayList<>();
+        routingTable.getIndicesRouting().forEach((k, v) -> allIndices.add(k));
+
+        String indexNameToDelete = allIndices.get(randomIntBetween(0, allIndices.size() - 1));
+        RoutingTable updatedRoutingTable = RoutingTable.builder(routingTable).remove(indexNameToDelete).build();
+
+        assertEquals(
+            1,
+            remoteRoutingTableService.getIndicesRoutingMapDiff(state.getRoutingTable(), updatedRoutingTable)
+                .provideDiff()
+                .getDeletes()
+                .size()
+        );
+        assertEquals(
+            indexNameToDelete,
+            remoteRoutingTableService.getIndicesRoutingMapDiff(state.getRoutingTable(), updatedRoutingTable)
+                .provideDiff()
+                .getDeletes()
+                .get(0)
+        );
+    }
+
+    public void testIndicesRoutingDiffWhenIndexDeletedAndAdded() {
+
+        ClusterState state = createIndices(randomIntBetween(1, 100));
+        RoutingTable routingTable = state.routingTable();
+
+        List<String> allIndices = new ArrayList<>();
+        routingTable.getIndicesRouting().forEach((k, v) -> allIndices.add(k));
+
+        String indexNameToDelete = allIndices.get(randomIntBetween(0, allIndices.size() - 1));
+        RoutingTable.Builder updatedRoutingTableBuilder = RoutingTable.builder(routingTable).remove(indexNameToDelete);
+
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(1).numberOfReplicas(1).build();
+
+        RoutingTable updatedRoutingTable = updatedRoutingTableBuilder.addAsNew(indexMetadata).build();
+
+        assertEquals(
+            1,
+            remoteRoutingTableService.getIndicesRoutingMapDiff(state.getRoutingTable(), updatedRoutingTable)
+                .provideDiff()
+                .getDeletes()
+                .size()
+        );
+        assertEquals(
+            indexNameToDelete,
+            remoteRoutingTableService.getIndicesRoutingMapDiff(state.getRoutingTable(), updatedRoutingTable)
+                .provideDiff()
+                .getDeletes()
+                .get(0)
+        );
+
+        assertEquals(
+            1,
+            remoteRoutingTableService.getIndicesRoutingMapDiff(state.getRoutingTable(), updatedRoutingTable)
+                .provideDiff()
+                .getUpserts()
+                .size()
+        );
+        assertTrue(
+            remoteRoutingTableService.getIndicesRoutingMapDiff(state.getRoutingTable(), updatedRoutingTable)
+                .provideDiff()
+                .getUpserts()
+                .containsKey(indexName)
+        );
+    }
+
+    public void testGetAsyncIndexRoutingReadAction() throws Exception {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState clusterState = createClusterState(indexName);
+        String uploadedFileName = String.format(Locale.ROOT, "index-routing/" + indexName);
+        when(blobContainer.readBlob(indexName)).thenReturn(
+            INDEX_ROUTING_TABLE_FORMAT.serialize(
+                clusterState.getRoutingTable().getIndicesRouting().get(indexName),
+                uploadedFileName,
+                compressor
+            ).streamInput()
+        );
+        TestCapturingListener<IndexRoutingTable> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteRoutingTableService.getAsyncIndexRoutingReadAction(
+            "cluster-uuid",
+            uploadedFileName,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        IndexRoutingTable indexRoutingTable = listener.getResult();
+        assertEquals(clusterState.getRoutingTable().getIndicesRouting().get(indexName), indexRoutingTable);
+    }
+
+    public void testGetAsyncIndexRoutingTableDiffReadAction() throws Exception {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, 5, 1, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, 5, 2, true).build();
+
+        RoutingTableIncrementalDiff diff = new RoutingTableIncrementalDiff(previousState.getRoutingTable(), currentState.getRoutingTable());
+
+        String uploadedFileName = String.format(Locale.ROOT, "routing-table-diff/" + indexName);
+        when(blobContainer.readBlob(indexName)).thenReturn(
+            REMOTE_ROUTING_TABLE_DIFF_FORMAT.serialize(diff, uploadedFileName, compressor).streamInput()
+        );
+
+        TestCapturingListener<Diff<RoutingTable>> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteRoutingTableService.getAsyncIndexRoutingTableDiffReadAction(
+            "cluster-uuid",
+            uploadedFileName,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        Diff<RoutingTable> resultDiff = listener.getResult();
+        assertEquals(
+            currentState.getRoutingTable().getIndicesRouting(),
+            resultDiff.apply(previousState.getRoutingTable()).getIndicesRouting()
+        );
+    }
+
+    public void testGetAsyncIndexRoutingWriteAction() throws Exception {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState clusterState = createClusterState(indexName);
+        Iterable<String> remotePath = HASHED_PREFIX.path(
+            RemoteStorePathStrategy.BasePathInput.builder()
+                .basePath(
+                    new BlobPath().add("base-path")
+                        .add(RemoteClusterStateUtils.encodeString(ClusterName.DEFAULT.toString()))
+                        .add(CLUSTER_STATE_PATH_TOKEN)
+                        .add(clusterState.metadata().clusterUUID())
+                        .add(INDEX_ROUTING_TABLE)
+                )
+                .indexUUID(clusterState.getRoutingTable().indicesRouting().get(indexName).getIndex().getUUID())
+                .build(),
+            FNV_1A_BASE64
+        );
+
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), eq(remotePath), anyString(), eq(WritePriority.URGENT), any(ActionListener.class));
+
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteRoutingTableService.getAsyncIndexRoutingWriteAction(
+            clusterState.metadata().clusterUUID(),
+            clusterState.term(),
+            clusterState.version(),
+            clusterState.getRoutingTable().indicesRouting().get(indexName),
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+
+        assertEquals(INDEX_ROUTING_METADATA_PREFIX + indexName, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(8, pathTokens.length);
+        assertEquals(pathTokens[1], "base-path");
+        String[] fileNameTokens = pathTokens[7].split(DELIMITER);
+
+        assertEquals(4, fileNameTokens.length);
+        assertEquals(fileNameTokens[0], INDEX_ROUTING_FILE);
+        assertEquals(fileNameTokens[1], RemoteStoreUtils.invertLong(1L));
+        assertEquals(fileNameTokens[2], RemoteStoreUtils.invertLong(2L));
+        assertThat(RemoteStoreUtils.invertLong(fileNameTokens[3]), lessThanOrEqualTo(System.currentTimeMillis()));
+    }
+
+    public void testGetAsyncIndexRoutingDiffWriteAction() throws Exception {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, 5, 1, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, 5, 2, true).build();
+
+        Iterable<String> remotePath = new BlobPath().add("base-path")
+            .add(
+                Base64.getUrlEncoder()
+                    .withoutPadding()
+                    .encodeToString(currentState.getClusterName().value().getBytes(StandardCharsets.UTF_8))
+            )
+            .add("cluster-state")
+            .add(currentState.metadata().clusterUUID())
+            .add(ROUTING_TABLE_DIFF_PATH_TOKEN);
+
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), eq(remotePath), anyString(), eq(WritePriority.URGENT), any(ActionListener.class));
+
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteRoutingTableService.getAsyncIndexRoutingDiffWriteAction(
+            currentState.metadata().clusterUUID(),
+            currentState.term(),
+            currentState.version(),
+            new RoutingTableIncrementalDiff(previousState.getRoutingTable(), currentState.getRoutingTable()),
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+
+        assertEquals(ROUTING_TABLE_DIFF_FILE, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(6, pathTokens.length);
+        assertEquals(pathTokens[0], "base-path");
+        String[] fileNameTokens = pathTokens[5].split(DELIMITER);
+
+        assertEquals(4, fileNameTokens.length);
+        assertEquals(ROUTING_TABLE_DIFF_METADATA_PREFIX, fileNameTokens[0]);
+        assertEquals(RemoteStoreUtils.invertLong(1L), fileNameTokens[1]);
+        assertEquals(RemoteStoreUtils.invertLong(1L), fileNameTokens[2]);
+        assertThat(RemoteStoreUtils.invertLong(fileNameTokens[3]), lessThanOrEqualTo(System.currentTimeMillis()));
+    }
+
+    public void testGetUpdatedIndexRoutingTableMetadataWhenNoChange() {
+        List<String> updatedIndicesRouting = new ArrayList<>();
+        List<ClusterMetadataManifest.UploadedIndexMetadata> indicesRouting = randomUploadedIndexMetadataList();
+        List<ClusterMetadataManifest.UploadedIndexMetadata> updatedIndexMetadata = remoteRoutingTableService
+            .getUpdatedIndexRoutingTableMetadata(updatedIndicesRouting, indicesRouting);
+        assertEquals(0, updatedIndexMetadata.size());
+    }
+
+    public void testGetUpdatedIndexRoutingTableMetadataWhenIndexIsUpdated() {
+        List<String> updatedIndicesRouting = new ArrayList<>();
+        List<ClusterMetadataManifest.UploadedIndexMetadata> indicesRouting = randomUploadedIndexMetadataList();
+        ClusterMetadataManifest.UploadedIndexMetadata expectedIndexRouting = indicesRouting.get(
+            randomIntBetween(0, indicesRouting.size() - 1)
+        );
+        updatedIndicesRouting.add(expectedIndexRouting.getIndexName());
+        List<ClusterMetadataManifest.UploadedIndexMetadata> updatedIndexMetadata = remoteRoutingTableService
+            .getUpdatedIndexRoutingTableMetadata(updatedIndicesRouting, indicesRouting);
+        assertEquals(1, updatedIndexMetadata.size());
+        assertEquals(expectedIndexRouting, updatedIndexMetadata.get(0));
+    }
+
+    private ClusterState createIndices(int numberOfIndices) {
+        RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
+        for (int i = 0; i < numberOfIndices; i++) {
+            String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+            final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+                Settings.builder()
+                    .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                    .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                    .build()
+            ).numberOfShards(1).numberOfReplicas(1).build();
+
+            routingTableBuilder.addAsNew(indexMetadata);
+        }
+        return ClusterState.builder(ClusterName.DEFAULT).routingTable(routingTableBuilder.build()).build();
+    }
+
+    private ClusterState createClusterState(String indexName) {
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(indexName).settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(between(1, 1000)).numberOfReplicas(randomInt(10)).build();
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(indexMetadata).build();
+        return ClusterState.builder(ClusterName.DEFAULT)
+            .routingTable(routingTable)
+            .metadata(Metadata.builder().coordinationMetadata(CoordinationMetadata.builder().term(1L).build()))
+            .version(2L)
+            .build();
+    }
+
+    private BlobPath getPath() {
+        BlobPath indexRoutingPath = basePath.add(INDEX_ROUTING_TABLE);
+        return RemoteStoreEnums.PathType.HASHED_PREFIX.path(
+            RemoteStorePathStrategy.BasePathInput.builder().basePath(indexRoutingPath).indexUUID("uuid").build(),
+            RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64
+        );
+    }
+
+    public void testDeleteStaleIndexRoutingPaths() throws IOException {
+        doNothing().when(blobContainer).deleteBlobsIgnoringIfNotExists(any());
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        List<String> stalePaths = Arrays.asList("path1", "path2");
+        remoteRoutingTableService.doStart();
+        remoteRoutingTableService.deleteStaleIndexRoutingPaths(stalePaths);
+        verify(blobContainer).deleteBlobsIgnoringIfNotExists(stalePaths);
+    }
+
+    public void testDeleteStaleIndexRoutingPathsThrowsIOException() throws IOException {
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        List<String> stalePaths = Arrays.asList("path1", "path2");
+        // Simulate an IOException
+        doThrow(new IOException("test exception")).when(blobContainer).deleteBlobsIgnoringIfNotExists(Mockito.anyList());
+
+        remoteRoutingTableService.doStart();
+        IOException thrown = assertThrows(IOException.class, () -> {
+            remoteRoutingTableService.deleteStaleIndexRoutingPaths(stalePaths);
+        });
+        assertEquals("test exception", thrown.getMessage());
+        verify(blobContainer).deleteBlobsIgnoringIfNotExists(stalePaths);
+    }
+
+    public void testDeleteStaleIndexRoutingDiffPaths() throws IOException {
+        doNothing().when(blobContainer).deleteBlobsIgnoringIfNotExists(any());
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        List<String> stalePaths = Arrays.asList("path1", "path2");
+        remoteRoutingTableService.doStart();
+        remoteRoutingTableService.deleteStaleIndexRoutingDiffPaths(stalePaths);
+        verify(blobContainer).deleteBlobsIgnoringIfNotExists(stalePaths);
+    }
+
+    public void testDeleteStaleIndexRoutingDiffPathsThrowsIOException() throws IOException {
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        List<String> stalePaths = Arrays.asList("path1", "path2");
+        // Simulate an IOException
+        doThrow(new IOException("test exception")).when(blobContainer).deleteBlobsIgnoringIfNotExists(Mockito.anyList());
+
+        remoteRoutingTableService.doStart();
+        IOException thrown = assertThrows(IOException.class, () -> {
+            remoteRoutingTableService.deleteStaleIndexRoutingDiffPaths(stalePaths);
+        });
+        assertEquals("test exception", thrown.getMessage());
+        verify(blobContainer).deleteBlobsIgnoringIfNotExists(stalePaths);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/cluster/service/ClusterApplierServiceTests.java b/server/src/test/java/org/opensearch/cluster/service/ClusterApplierServiceTests.java
index c5ed505e6bbf2..be6057a391b2e 100644
--- a/server/src/test/java/org/opensearch/cluster/service/ClusterApplierServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/service/ClusterApplierServiceTests.java
@@ -35,6 +35,7 @@
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.LogManager;
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateObserver;
@@ -51,6 +52,8 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.telemetry.metrics.Histogram;
+import org.opensearch.telemetry.metrics.MetricsRegistry;
 import org.opensearch.test.MockLogAppender;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.junit.annotations.TestLogging;
@@ -64,6 +67,7 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
@@ -74,15 +78,30 @@
 import static org.opensearch.test.ClusterServiceUtils.setState;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.is;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyDouble;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
 
 public class ClusterApplierServiceTests extends OpenSearchTestCase {
 
     private static ThreadPool threadPool;
     private TimedClusterApplierService clusterApplierService;
+    private static MetricsRegistry metricsRegistry;
+    private static Histogram applierslatencyHistogram;
+    private static Histogram listenerslatencyHistogram;
 
     @BeforeClass
     public static void createThreadPool() {
         threadPool = new TestThreadPool(ClusterApplierServiceTests.class.getName());
+        metricsRegistry = mock(MetricsRegistry.class);
+        applierslatencyHistogram = mock(Histogram.class);
+        listenerslatencyHistogram = mock(Histogram.class);
     }
 
     @AfterClass
@@ -96,7 +115,14 @@ public static void stopThreadPool() {
     @Before
     public void setUp() throws Exception {
         super.setUp();
-        clusterApplierService = createTimedClusterService(true);
+        when(metricsRegistry.createHistogram(anyString(), anyString(), anyString())).thenAnswer(invocationOnMock -> {
+            String histogramName = (String) invocationOnMock.getArguments()[0];
+            if (histogramName.contains("appliers.latency")) {
+                return applierslatencyHistogram;
+            }
+            return listenerslatencyHistogram;
+        });
+        clusterApplierService = createTimedClusterService(true, Optional.of(metricsRegistry));
     }
 
     @After
@@ -105,13 +131,26 @@ public void tearDown() throws Exception {
         super.tearDown();
     }
 
-    private TimedClusterApplierService createTimedClusterService(boolean makeClusterManager) {
+    private TimedClusterApplierService createTimedClusterService(
+        boolean makeClusterManager,
+        Optional<MetricsRegistry> metricsRegistryOptional
+    ) {
         DiscoveryNode localNode = new DiscoveryNode("node1", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
-        TimedClusterApplierService timedClusterApplierService = new TimedClusterApplierService(
-            Settings.builder().put("cluster.name", "ClusterApplierServiceTests").build(),
-            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-            threadPool
-        );
+        TimedClusterApplierService timedClusterApplierService;
+        if (metricsRegistryOptional != null && metricsRegistryOptional.isPresent()) {
+            timedClusterApplierService = new TimedClusterApplierService(
+                Settings.builder().put("cluster.name", "ClusterApplierServiceTests").build(),
+                new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                threadPool,
+                new ClusterManagerMetrics(metricsRegistry)
+            );
+        } else {
+            timedClusterApplierService = new TimedClusterApplierService(
+                Settings.builder().put("cluster.name", "ClusterApplierServiceTests").build(),
+                new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                threadPool
+            );
+        }
         timedClusterApplierService.setNodeConnectionsService(createNoOpNodeConnectionsService());
         timedClusterApplierService.setInitialState(
             ClusterState.builder(new ClusterName("ClusterApplierServiceTests"))
@@ -194,6 +233,8 @@ public void onFailure(String source, Exception e) {
             });
             assertBusy(mockAppender::assertAllExpectationsMatched);
         }
+        verifyNoInteractions(applierslatencyHistogram);
+        verifyNoInteractions(listenerslatencyHistogram);
     }
 
     @TestLogging(value = "org.opensearch.cluster.service:WARN", reason = "to ensure that we log cluster state events on WARN level")
@@ -291,10 +332,12 @@ public void onFailure(String source, Exception e) {
             latch.await();
             mockAppender.assertAllExpectationsMatched();
         }
+        verifyNoInteractions(applierslatencyHistogram);
+        verifyNoInteractions(listenerslatencyHistogram);
     }
 
     public void testLocalNodeClusterManagerListenerCallbacks() {
-        TimedClusterApplierService timedClusterApplierService = createTimedClusterService(false);
+        TimedClusterApplierService timedClusterApplierService = createTimedClusterService(false, Optional.empty());
 
         AtomicBoolean isClusterManager = new AtomicBoolean();
         timedClusterApplierService.addLocalNodeClusterManagerListener(new LocalNodeClusterManagerListener() {
@@ -329,6 +372,8 @@ public void offClusterManager() {
         setState(timedClusterApplierService, state);
         assertThat(isClusterManager.get(), is(true));
 
+        verifyNoInteractions(applierslatencyHistogram, listenerslatencyHistogram);
+
         timedClusterApplierService.close();
     }
 
@@ -338,7 +383,7 @@ public void offClusterManager() {
      * To support inclusive language, LocalNodeMasterListener is deprecated in 2.2.
      */
     public void testDeprecatedLocalNodeMasterListenerCallbacks() {
-        TimedClusterApplierService timedClusterApplierService = createTimedClusterService(false);
+        TimedClusterApplierService timedClusterApplierService = createTimedClusterService(false, Optional.empty());
 
         AtomicBoolean isClusterManager = new AtomicBoolean();
         timedClusterApplierService.addLocalNodeMasterListener(new LocalNodeMasterListener() {
@@ -366,6 +411,8 @@ public void offMaster() {
         setState(timedClusterApplierService, state);
         assertThat(isClusterManager.get(), is(false));
 
+        verifyNoInteractions(applierslatencyHistogram, listenerslatencyHistogram);
+
         timedClusterApplierService.close();
     }
 
@@ -405,6 +452,10 @@ public void onFailure(String source, Exception e) {
         latch.await();
         assertNull(error.get());
         assertTrue(applierCalled.get());
+
+        verify(applierslatencyHistogram, atLeastOnce()).record(anyDouble(), any());
+        clearInvocations(applierslatencyHistogram);
+        verifyNoInteractions(listenerslatencyHistogram);
     }
 
     public void testClusterStateApplierBubblesUpExceptionsInApplier() throws InterruptedException {
@@ -435,6 +486,9 @@ public void onFailure(String source, Exception e) {
         latch.await();
         assertNotNull(error.get());
         assertThat(error.get().getMessage(), containsString("dummy exception"));
+
+        verifyNoInteractions(applierslatencyHistogram);
+        verifyNoInteractions(listenerslatencyHistogram);
     }
 
     public void testClusterStateApplierBubblesUpExceptionsInSettingsApplier() throws InterruptedException {
@@ -478,6 +532,9 @@ public void onFailure(String source, Exception e) {
         latch.await();
         assertNotNull(error.get());
         assertThat(error.get().getMessage(), containsString("illegal value can't update"));
+
+        verifyNoInteractions(applierslatencyHistogram);
+        verifyNoInteractions(listenerslatencyHistogram);
     }
 
     public void testClusterStateApplierSwallowsExceptionInListener() throws InterruptedException {
@@ -509,6 +566,9 @@ public void onFailure(String source, Exception e) {
         latch.await();
         assertNull(error.get());
         assertTrue(applierCalled.get());
+
+        verifyNoInteractions(applierslatencyHistogram);
+        verifyNoInteractions(listenerslatencyHistogram);
     }
 
     public void testClusterStateApplierCanCreateAnObserver() throws InterruptedException {
@@ -565,6 +625,10 @@ public void onFailure(String source, Exception e) {
         latch.await();
         assertNull(error.get());
         assertTrue(applierCalled.get());
+
+        verify(applierslatencyHistogram, atLeastOnce()).record(anyDouble(), any());
+        clearInvocations(applierslatencyHistogram);
+        verifyNoInteractions(listenerslatencyHistogram);
     }
 
     public void testThreadContext() throws InterruptedException {
@@ -609,6 +673,9 @@ public void onFailure(String source, Exception e) {
         }
 
         latch.await();
+
+        verifyNoInteractions(applierslatencyHistogram);
+        verifyNoInteractions(listenerslatencyHistogram);
     }
 
     static class TimedClusterApplierService extends ClusterApplierService {
@@ -622,6 +689,16 @@ static class TimedClusterApplierService extends ClusterApplierService {
             this.clusterSettings = clusterSettings;
         }
 
+        TimedClusterApplierService(
+            Settings settings,
+            ClusterSettings clusterSettings,
+            ThreadPool threadPool,
+            ClusterManagerMetrics clusterManagerMetrics
+        ) {
+            super("test_node", settings, clusterSettings, threadPool, clusterManagerMetrics);
+            this.clusterSettings = clusterSettings;
+        }
+
         @Override
         protected long currentTimeInMillis() {
             if (currentTimeOverride != null) {
diff --git a/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java b/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
index 85f6c129944fa..db9abe0310e40 100644
--- a/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
+++ b/server/src/test/java/org/opensearch/cluster/service/MasterServiceTests.java
@@ -40,6 +40,7 @@
 import org.opensearch.Version;
 import org.opensearch.cluster.AckedClusterStateUpdateTask;
 import org.opensearch.cluster.ClusterChangedEvent;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateTaskConfig;
@@ -61,6 +62,9 @@
 import org.opensearch.common.util.concurrent.BaseFuture;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.node.Node;
+import org.opensearch.telemetry.metrics.Histogram;
+import org.opensearch.telemetry.metrics.MetricsRegistry;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.test.MockLogAppender;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.junit.annotations.TestLogging;
@@ -76,6 +80,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.BrokenBarrierException;
 import java.util.concurrent.ConcurrentHashMap;
@@ -95,6 +100,13 @@
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasKey;
 import static org.hamcrest.Matchers.is;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyDouble;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 public class MasterServiceTests extends OpenSearchTestCase {
 
@@ -125,15 +137,36 @@ public void randomizeCurrentTime() {
     }
 
     private ClusterManagerService createClusterManagerService(boolean makeClusterManager) {
+        return createClusterManagerService(makeClusterManager, Optional.empty());
+    }
+
+    private ClusterManagerService createClusterManagerService(
+        boolean makeClusterManager,
+        Optional<MetricsRegistry> metricsRegistryOptional
+    ) {
         final DiscoveryNode localNode = new DiscoveryNode("node1", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
-        final ClusterManagerService clusterManagerService = new ClusterManagerService(
-            Settings.builder()
-                .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), MasterServiceTests.class.getSimpleName())
-                .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
-                .build(),
-            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-            threadPool
-        );
+        final ClusterManagerService clusterManagerService;
+        if (metricsRegistryOptional != null && metricsRegistryOptional.isPresent()) {
+            clusterManagerService = new ClusterManagerService(
+                Settings.builder()
+                    .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), MasterServiceTests.class.getSimpleName())
+                    .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
+                    .build(),
+                new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                threadPool,
+                new ClusterManagerMetrics(metricsRegistryOptional.get())
+            );
+        } else {
+            clusterManagerService = new ClusterManagerService(
+                Settings.builder()
+                    .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), MasterServiceTests.class.getSimpleName())
+                    .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
+                    .build(),
+                new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                threadPool
+            );
+        }
+
         final ClusterState initialClusterState = ClusterState.builder(new ClusterName(MasterServiceTests.class.getSimpleName()))
             .nodes(
                 DiscoveryNodes.builder()
@@ -154,7 +187,18 @@ private ClusterManagerService createClusterManagerService(boolean makeClusterMan
     }
 
     public void testClusterManagerAwareExecution() throws Exception {
-        final ClusterManagerService nonClusterManager = createClusterManagerService(false);
+        final MetricsRegistry metricsRegistry = mock(MetricsRegistry.class);
+        final Histogram clusterStateComputeHistogram = mock(Histogram.class);
+        final Histogram clusterStatePublishHistogram = mock(Histogram.class);
+        when(metricsRegistry.createHistogram(anyString(), anyString(), anyString())).thenAnswer(invocationOnMock -> {
+            String histogramName = (String) invocationOnMock.getArguments()[0];
+            if (histogramName.contains("cluster.state.new.compute.latency")) {
+                return clusterStateComputeHistogram;
+            }
+            return clusterStatePublishHistogram;
+        });
+
+        final ClusterManagerService nonClusterManager = createClusterManagerService(false, Optional.of(metricsRegistry));
 
         final boolean[] taskFailed = { false };
         final CountDownLatch latch1 = new CountDownLatch(1);
@@ -194,6 +238,8 @@ public void onFailure(String source, Exception e) {
         assertFalse("non-cluster-manager cluster state update task was not executed", taskFailed[0]);
 
         nonClusterManager.close();
+
+        verify(clusterStateComputeHistogram, times(1)).record(anyDouble(), any());
     }
 
     public void testThreadContext() throws InterruptedException {
@@ -330,13 +376,13 @@ public void onFailure(String source, Exception e) {}
     }
 
     @TestLogging(value = "org.opensearch.cluster.service:TRACE", reason = "to ensure that we log cluster state events on TRACE level")
-    public void testClusterStateUpdateLogging() throws Exception {
+    public void testClusterStateUpdateLoggingWithTraceEnabled() throws Exception {
         try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(MasterService.class))) {
             mockAppender.addExpectation(
                 new MockLogAppender.SeenEventExpectation(
                     "test1 start",
                     MasterService.class.getCanonicalName(),
-                    Level.DEBUG,
+                    Level.TRACE,
                     "executing cluster state update for [test1]"
                 )
             );
@@ -345,7 +391,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test1 computation",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [1s] to compute cluster state update for [test1]"
+                    "took [1s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -353,7 +399,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test1 notification",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [0s] to notify listeners on unchanged cluster state for [test1]"
+                    "took [0s] to notify listeners on unchanged cluster state for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
 
@@ -361,7 +407,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                 new MockLogAppender.SeenEventExpectation(
                     "test2 start",
                     MasterService.class.getCanonicalName(),
-                    Level.DEBUG,
+                    Level.TRACE,
                     "executing cluster state update for [test2]"
                 )
             );
@@ -370,7 +416,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test2 failure",
                     MasterService.class.getCanonicalName(),
                     Level.TRACE,
-                    "failed to execute cluster state update (on version: [*], uuid: [*]) for [test2]*"
+                    "failed to execute cluster state update (on version: [*], uuid: [*]) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]*"
                 )
             );
             mockAppender.addExpectation(
@@ -378,7 +424,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test2 computation",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [2s] to compute cluster state update for [test2]"
+                    "took [2s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -386,7 +432,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test2 notification",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [0s] to notify listeners on unchanged cluster state for [test2]"
+                    "took [0s] to notify listeners on unchanged cluster state for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
 
@@ -394,7 +440,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                 new MockLogAppender.SeenEventExpectation(
                     "test3 start",
                     MasterService.class.getCanonicalName(),
-                    Level.DEBUG,
+                    Level.TRACE,
                     "executing cluster state update for [test3]"
                 )
             );
@@ -403,7 +449,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test3 computation",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [3s] to compute cluster state update for [test3]"
+                    "took [3s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -411,7 +457,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                     "test3 notification",
                     MasterService.class.getCanonicalName(),
                     Level.DEBUG,
-                    "took [4s] to notify listeners on successful publication of cluster state (version: *, uuid: *) for [test3]"
+                    "took [4s] to notify listeners on successful publication of cluster state (version: *, uuid: *) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
 
@@ -419,7 +465,7 @@ public void testClusterStateUpdateLogging() throws Exception {
                 new MockLogAppender.SeenEventExpectation(
                     "test4",
                     MasterService.class.getCanonicalName(),
-                    Level.DEBUG,
+                    Level.TRACE,
                     "executing cluster state update for [test4]"
                 )
             );
@@ -488,8 +534,173 @@ public void onFailure(String source, Exception e) {
                 });
                 assertBusy(mockAppender::assertAllExpectationsMatched);
                 // verify stats values after state is published
-                assertEquals(1, clusterManagerService.getClusterStateStats().getUpdateSuccess());
-                assertEquals(0, clusterManagerService.getClusterStateStats().getUpdateFailed());
+                assertBusy(() -> assertEquals(1, clusterManagerService.getClusterStateStats().getUpdateSuccess()));
+                assertBusy(() -> assertEquals(0, clusterManagerService.getClusterStateStats().getUpdateFailed()));
+            }
+        }
+    }
+
+    @TestLogging(value = "org.opensearch.cluster.service:DEBUG", reason = "to ensure that we log cluster state events on DEBUG level")
+    public void testClusterStateUpdateLoggingWithDebugEnabled() throws Exception {
+        try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(MasterService.class))) {
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test1 start",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "executing cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test1 computation",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [1s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test1 notification",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [0s] to notify listeners on unchanged cluster state for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test2 start",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "executing cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.UnseenEventExpectation(
+                    "test2 failure",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "failed to execute cluster state update (on version: [*], uuid: [*]) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]*"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test2 computation",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [2s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test2 notification",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [0s] to notify listeners on unchanged cluster state for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test3 start",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "executing cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test3 computation",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [3s] to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test3 notification",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "took [4s] to notify listeners on successful publication of cluster state (version: *, uuid: *) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test4",
+                    MasterService.class.getCanonicalName(),
+                    Level.DEBUG,
+                    "executing cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
+                )
+            );
+
+            try (ClusterManagerService clusterManagerService = createClusterManagerService(true)) {
+                clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        timeDiffInMillis += TimeValue.timeValueSeconds(1).millis();
+                        return currentState;
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {}
+
+                    @Override
+                    public void onFailure(String source, Exception e) {
+                        fail();
+                    }
+                });
+                clusterManagerService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        timeDiffInMillis += TimeValue.timeValueSeconds(2).millis();
+                        throw new IllegalArgumentException("Testing handling of exceptions in the cluster state task");
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
+                        fail();
+                    }
+
+                    @Override
+                    public void onFailure(String source, Exception e) {}
+                });
+                clusterManagerService.submitStateUpdateTask("test3", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        timeDiffInMillis += TimeValue.timeValueSeconds(3).millis();
+                        return ClusterState.builder(currentState).incrementVersion().build();
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
+                        timeDiffInMillis += TimeValue.timeValueSeconds(4).millis();
+                    }
+
+                    @Override
+                    public void onFailure(String source, Exception e) {
+                        fail();
+                    }
+                });
+                clusterManagerService.submitStateUpdateTask("test4", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        return currentState;
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {}
+
+                    @Override
+                    public void onFailure(String source, Exception e) {
+                        fail();
+                    }
+                });
+                assertBusy(mockAppender::assertAllExpectationsMatched);
+                // verify stats values after state is published
+                assertBusy(() -> assertEquals(1, clusterManagerService.getClusterStateStats().getUpdateSuccess()));
+                assertBusy(() -> assertEquals(0, clusterManagerService.getClusterStateStats().getUpdateFailed()));
             }
         }
     }
@@ -1027,7 +1238,7 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     "test2",
                     MasterService.class.getCanonicalName(),
                     Level.WARN,
-                    "*took [*], which is over [10s], to compute cluster state update for [test2]"
+                    "*took [*], which is over [10s], to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -1035,7 +1246,7 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     "test3",
                     MasterService.class.getCanonicalName(),
                     Level.WARN,
-                    "*took [*], which is over [10s], to compute cluster state update for [test3]"
+                    "*took [*], which is over [10s], to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -1043,7 +1254,7 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     "test4",
                     MasterService.class.getCanonicalName(),
                     Level.WARN,
-                    "*took [*], which is over [10s], to compute cluster state update for [test4]"
+                    "*took [*], which is over [10s], to compute cluster state update for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]"
                 )
             );
             mockAppender.addExpectation(
@@ -1054,14 +1265,6 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                     "*took*test5*"
                 )
             );
-            mockAppender.addExpectation(
-                new MockLogAppender.SeenEventExpectation(
-                    "test6 should log due to slow and failing publication",
-                    MasterService.class.getCanonicalName(),
-                    Level.WARN,
-                    "took [*] and then failed to publish updated cluster state (version: *, uuid: *) for [test6]:*"
-                )
-            );
 
             try (
                 ClusterManagerService clusterManagerService = new ClusterManagerService(
@@ -1070,7 +1273,8 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                         .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
                         .build(),
                     new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-                    threadPool
+                    threadPool,
+                    new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
                 )
             ) {
 
@@ -1092,19 +1296,13 @@ public void testLongClusterStateUpdateLogging() throws Exception {
                             Settings.EMPTY
                         ).millis() + randomLongBetween(1, 1000000);
                     }
-                    if (event.source().contains("test6")) {
-                        timeDiffInMillis += ClusterManagerService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(
-                            Settings.EMPTY
-                        ).millis() + randomLongBetween(1, 1000000);
-                        throw new OpenSearchException("simulated error during slow publication which should trigger logging");
-                    }
                     clusterStateRef.set(event.state());
                     publishListener.onResponse(null);
                 });
                 clusterManagerService.setClusterStateSupplier(clusterStateRef::get);
                 clusterManagerService.start();
 
-                final CountDownLatch latch = new CountDownLatch(6);
+                final CountDownLatch latch = new CountDownLatch(5);
                 final CountDownLatch processedFirstTask = new CountDownLatch(1);
                 clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
                     @Override
@@ -1202,7 +1400,77 @@ public void onFailure(String source, Exception e) {
                         fail();
                     }
                 });
+                // Additional update task to make sure all previous logging made it to the loggerName
+                // We don't check logging for this on since there is no guarantee that it will occur before our check
                 clusterManagerService.submitStateUpdateTask("test6", new ClusterStateUpdateTask() {
+                    @Override
+                    public ClusterState execute(ClusterState currentState) {
+                        return currentState;
+                    }
+
+                    @Override
+                    public void clusterStateProcessed(String source, ClusterState oldState, ClusterState newState) {
+                        latch.countDown();
+                    }
+
+                    @Override
+                    public void onFailure(String source, Exception e) {
+                        fail();
+                    }
+                });
+                latch.await();
+            }
+            mockAppender.assertAllExpectationsMatched();
+        }
+    }
+
+    @TestLogging(value = "org.opensearch.cluster.service:WARN", reason = "to ensure that we log failed cluster state events on WARN level")
+    public void testLongClusterStateUpdateLoggingForFailedPublication() throws Exception {
+        try (MockLogAppender mockAppender = MockLogAppender.createForLoggers(LogManager.getLogger(MasterService.class))) {
+            mockAppender.addExpectation(
+                new MockLogAppender.SeenEventExpectation(
+                    "test1 should log due to slow and failing publication",
+                    MasterService.class.getCanonicalName(),
+                    Level.WARN,
+                    "took [*] and then failed to publish updated cluster state (version: *, uuid: *) for [Tasks batched with key: org.opensearch.cluster.service.MasterServiceTests and count: 1]:*"
+                )
+            );
+
+            try (
+                ClusterManagerService clusterManagerService = new ClusterManagerService(
+                    Settings.builder()
+                        .put(ClusterName.CLUSTER_NAME_SETTING.getKey(), MasterServiceTests.class.getSimpleName())
+                        .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
+                        .build(),
+                    new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                    threadPool,
+                    new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
+                )
+            ) {
+
+                final DiscoveryNode localNode = new DiscoveryNode(
+                    "node1",
+                    buildNewFakeTransportAddress(),
+                    emptyMap(),
+                    emptySet(),
+                    Version.CURRENT
+                );
+                final ClusterState initialClusterState = ClusterState.builder(new ClusterName(MasterServiceTests.class.getSimpleName()))
+                    .nodes(DiscoveryNodes.builder().add(localNode).localNodeId(localNode.getId()).masterNodeId(localNode.getId()))
+                    .blocks(ClusterBlocks.EMPTY_CLUSTER_BLOCK)
+                    .build();
+                final AtomicReference<ClusterState> clusterStateRef = new AtomicReference<>(initialClusterState);
+                clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
+                    timeDiffInMillis += ClusterManagerService.CLUSTER_MANAGER_SERVICE_SLOW_TASK_LOGGING_THRESHOLD_SETTING.get(
+                        Settings.EMPTY
+                    ).millis() + randomLongBetween(1, 1000000);
+                    throw new OpenSearchException("simulated error during slow publication which should trigger logging");
+                });
+                clusterManagerService.setClusterStateSupplier(clusterStateRef::get);
+                clusterManagerService.start();
+
+                final CountDownLatch latch = new CountDownLatch(1);
+                clusterManagerService.submitStateUpdateTask("test1", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return ClusterState.builder(currentState).incrementVersion().build();
@@ -1215,12 +1483,12 @@ public void clusterStateProcessed(String source, ClusterState oldState, ClusterS
 
                     @Override
                     public void onFailure(String source, Exception e) {
-                        fail(); // maybe we should notify here?
+                        fail();
                     }
                 });
                 // Additional update task to make sure all previous logging made it to the loggerName
                 // We don't check logging for this on since there is no guarantee that it will occur before our check
-                clusterManagerService.submitStateUpdateTask("test7", new ClusterStateUpdateTask() {
+                clusterManagerService.submitStateUpdateTask("test2", new ClusterStateUpdateTask() {
                     @Override
                     public ClusterState execute(ClusterState currentState) {
                         return currentState;
@@ -1246,6 +1514,18 @@ public void testAcking() throws InterruptedException {
         final DiscoveryNode node1 = new DiscoveryNode("node1", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
         final DiscoveryNode node2 = new DiscoveryNode("node2", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
         final DiscoveryNode node3 = new DiscoveryNode("node3", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
+
+        final MetricsRegistry metricsRegistry = mock(MetricsRegistry.class);
+        final Histogram clusterStateComputeHistogram = mock(Histogram.class);
+        final Histogram clusterStatePublishHistogram = mock(Histogram.class);
+        when(metricsRegistry.createHistogram(anyString(), anyString(), anyString())).thenAnswer(invocationOnMock -> {
+            String histogramName = (String) invocationOnMock.getArguments()[0];
+            if (histogramName.contains("cluster.state.new.compute.latency")) {
+                return clusterStateComputeHistogram;
+            }
+            return clusterStatePublishHistogram;
+        });
+
         try (
             ClusterManagerService clusterManagerService = new ClusterManagerService(
                 Settings.builder()
@@ -1253,7 +1533,8 @@ public void testAcking() throws InterruptedException {
                     .put(Node.NODE_NAME_SETTING.getKey(), "test_node")
                     .build(),
                 new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-                threadPool
+                threadPool,
+                new ClusterManagerMetrics(metricsRegistry)
             )
         ) {
 
@@ -1372,6 +1653,9 @@ public void onAckTimeout() {
                 latch.await();
             }
         }
+
+        verify(clusterStateComputeHistogram, times(2)).record(anyDouble(), any());
+        verify(clusterStatePublishHistogram, times(1)).record(anyDouble());
     }
 
     public void testDeprecatedMasterServiceUpdateTaskThreadName() {
diff --git a/server/src/test/java/org/opensearch/cluster/service/TaskBatcherTests.java b/server/src/test/java/org/opensearch/cluster/service/TaskBatcherTests.java
index b0916ce9236f7..0ebcb51b557ae 100644
--- a/server/src/test/java/org/opensearch/cluster/service/TaskBatcherTests.java
+++ b/server/src/test/java/org/opensearch/cluster/service/TaskBatcherTests.java
@@ -55,6 +55,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.Semaphore;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import static org.hamcrest.Matchers.containsString;
@@ -78,7 +79,7 @@ static class TestTaskBatcher extends TaskBatcher {
         }
 
         @Override
-        protected void run(Object batchingKey, List<? extends BatchedTask> tasks, String tasksSummary) {
+        protected void run(Object batchingKey, List<? extends BatchedTask> tasks, Function<Boolean, String> taskSummaryGenerator) {
             List<UpdateTask> updateTasks = (List) tasks;
             ((TestExecutor) batchingKey).execute(updateTasks.stream().map(t -> t.task).collect(Collectors.toList()));
             updateTasks.forEach(updateTask -> updateTask.listener.processed(updateTask.source));
diff --git a/server/src/test/java/org/opensearch/common/LocalTimeOffsetTests.java b/server/src/test/java/org/opensearch/common/LocalTimeOffsetTests.java
index b032e27397f2d..cfef82b2d65a1 100644
--- a/server/src/test/java/org/opensearch/common/LocalTimeOffsetTests.java
+++ b/server/src/test/java/org/opensearch/common/LocalTimeOffsetTests.java
@@ -302,7 +302,7 @@ private static long time(String time, ZoneId zone) {
     }
 
     /**
-     * The the last "fully defined" transitions in the provided {@linkplain ZoneId}.
+     * The last "fully defined" transitions in the provided {@linkplain ZoneId}.
      */
     private static ZoneOffsetTransition lastTransitionIn(ZoneId zone) {
         List<ZoneOffsetTransition> transitions = zone.getRules().getTransitions();
diff --git a/server/src/test/java/org/opensearch/common/blobstore/EncryptedBlobContainerTests.java b/server/src/test/java/org/opensearch/common/blobstore/EncryptedBlobContainerTests.java
new file mode 100644
index 0000000000000..28772eaf79ee7
--- /dev/null
+++ b/server/src/test/java/org/opensearch/common/blobstore/EncryptedBlobContainerTests.java
@@ -0,0 +1,41 @@
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.blobstore;
+
+import org.opensearch.common.crypto.CryptoHandler;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class EncryptedBlobContainerTests extends OpenSearchTestCase {
+
+    public void testBlobContainerReadBlobWithMetadata() throws IOException {
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        CryptoHandler cryptoHandler = mock(CryptoHandler.class);
+        EncryptedBlobContainer encryptedBlobContainer = new EncryptedBlobContainer(blobContainer, cryptoHandler);
+        InputStreamWithMetadata inputStreamWithMetadata = new InputStreamWithMetadata(
+            new ByteArrayInputStream(new byte[0]),
+            new HashMap<>()
+        );
+        when(blobContainer.readBlobWithMetadata("test")).thenReturn(inputStreamWithMetadata);
+        InputStream decrypt = new ByteArrayInputStream(new byte[2]);
+        when(cryptoHandler.createDecryptingStream(inputStreamWithMetadata.getInputStream())).thenReturn(decrypt);
+        InputStreamWithMetadata result = encryptedBlobContainer.readBlobWithMetadata("test");
+        assertEquals(result.getInputStream(), decrypt);
+        assertEquals(result.getMetadata(), inputStreamWithMetadata.getMetadata());
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/common/cache/serializer/ICacheKeySerializerTests.java b/server/src/test/java/org/opensearch/common/cache/serializer/ICacheKeySerializerTests.java
index 7713fdf1d0adc..4b0fc3d2a7366 100644
--- a/server/src/test/java/org/opensearch/common/cache/serializer/ICacheKeySerializerTests.java
+++ b/server/src/test/java/org/opensearch/common/cache/serializer/ICacheKeySerializerTests.java
@@ -43,10 +43,9 @@ public void testInvalidInput() throws Exception {
         ICacheKeySerializer<BytesReference> serializer = new ICacheKeySerializer<>(keySer);
 
         Random rand = Randomness.get();
-        byte[] randomInput = new byte[1000];
-        rand.nextBytes(randomInput);
-
-        assertThrows(OpenSearchException.class, () -> serializer.deserialize(randomInput));
+        // The first thing the serializer reads is a VInt for the number of dimensions.
+        // This is an invalid input for StreamInput.readVInt(), so we are guaranteed to have an exception
+        assertThrows(OpenSearchException.class, () -> serializer.deserialize(new byte[] { -1, -1, -1, -1, -1 }));
     }
 
     public void testDimNumbers() throws Exception {
diff --git a/server/src/test/java/org/opensearch/common/cache/stats/DefaultCacheStatsHolderTests.java b/server/src/test/java/org/opensearch/common/cache/stats/DefaultCacheStatsHolderTests.java
index c6e8252ddf806..8a59dd9d2d105 100644
--- a/server/src/test/java/org/opensearch/common/cache/stats/DefaultCacheStatsHolderTests.java
+++ b/server/src/test/java/org/opensearch/common/cache/stats/DefaultCacheStatsHolderTests.java
@@ -127,49 +127,58 @@ public void testCount() throws Exception {
     }
 
     public void testConcurrentRemoval() throws Exception {
-        List<String> dimensionNames = List.of("dim1", "dim2");
+        List<String> dimensionNames = List.of("A", "B");
         DefaultCacheStatsHolder cacheStatsHolder = new DefaultCacheStatsHolder(dimensionNames, storeName);
 
         // Create stats for the following dimension sets
-        List<List<String>> populatedStats = List.of(List.of("A1", "B1"), List.of("A2", "B2"), List.of("A2", "B3"));
+        List<List<String>> populatedStats = new ArrayList<>();
+        int numAValues = 10;
+        int numBValues = 2;
+        for (int indexA = 0; indexA < numAValues; indexA++) {
+            for (int indexB = 0; indexB < numBValues; indexB++) {
+                populatedStats.add(List.of("A" + indexA, "B" + indexB));
+            }
+        }
         for (List<String> dims : populatedStats) {
             cacheStatsHolder.incrementHits(dims);
         }
 
-        // Remove (A2, B2) and (A1, B1), before re-adding (A2, B2). At the end we should have stats for (A2, B2) but not (A1, B1).
-
-        Thread[] threads = new Thread[3];
-        CountDownLatch countDownLatch = new CountDownLatch(3);
-        threads[0] = new Thread(() -> {
-            cacheStatsHolder.removeDimensions(List.of("A2", "B2"));
-            countDownLatch.countDown();
-        });
-        threads[1] = new Thread(() -> {
-            cacheStatsHolder.removeDimensions(List.of("A1", "B1"));
-            countDownLatch.countDown();
-        });
-        threads[2] = new Thread(() -> {
-            cacheStatsHolder.incrementMisses(List.of("A2", "B2"));
-            cacheStatsHolder.incrementMisses(List.of("A2", "B3"));
-            countDownLatch.countDown();
-        });
+        // Remove a subset of the dimensions concurrently.
+        // Remove both (A0, B0), and (A0, B1), so we expect the intermediate node for A0 to be null afterwards.
+        // For all the others, remove only the B0 value. Then we expect the intermediate nodes for A1 through A9 to be present
+        // and reflect only the stats for their B1 child.
+
+        Thread[] threads = new Thread[numAValues + 1];
+        for (int i = 0; i < numAValues; i++) {
+            int finalI = i;
+            threads[i] = new Thread(() -> { cacheStatsHolder.removeDimensions(List.of("A" + finalI, "B0")); });
+        }
+        threads[numAValues] = new Thread(() -> { cacheStatsHolder.removeDimensions(List.of("A0", "B1")); });
         for (Thread thread : threads) {
             thread.start();
-            // Add short sleep to ensure threads start their functions in order (so that incrementing doesn't happen before removal)
-            Thread.sleep(1);
         }
-        countDownLatch.await();
-        assertNull(getNode(List.of("A1", "B1"), cacheStatsHolder.getStatsRoot()));
-        assertNull(getNode(List.of("A1"), cacheStatsHolder.getStatsRoot()));
-        assertNotNull(getNode(List.of("A2", "B2"), cacheStatsHolder.getStatsRoot()));
-        assertEquals(
-            new ImmutableCacheStats(0, 1, 0, 0, 0),
-            getNode(List.of("A2", "B2"), cacheStatsHolder.getStatsRoot()).getImmutableStats()
-        );
-        assertEquals(
-            new ImmutableCacheStats(1, 1, 0, 0, 0),
-            getNode(List.of("A2", "B3"), cacheStatsHolder.getStatsRoot()).getImmutableStats()
-        );
+        for (Thread thread : threads) {
+            thread.join();
+        }
+
+        // intermediate node for A0 should be null
+        assertNull(getNode(List.of("A0"), cacheStatsHolder.getStatsRoot()));
+
+        // leaf nodes for all B0 values should be null since they were removed
+        for (int indexA = 0; indexA < numAValues; indexA++) {
+            assertNull(getNode(List.of("A" + indexA, "B0"), cacheStatsHolder.getStatsRoot()));
+        }
+
+        // leaf nodes for all B1 values, except (A0, B1), should not be null as they weren't removed,
+        // and the intermediate nodes A1 through A9 shouldn't be null as they have remaining children
+        for (int indexA = 1; indexA < numAValues; indexA++) {
+            DefaultCacheStatsHolder.Node b1LeafNode = getNode(List.of("A" + indexA, "B1"), cacheStatsHolder.getStatsRoot());
+            assertNotNull(b1LeafNode);
+            assertEquals(new ImmutableCacheStats(1, 0, 0, 0, 0), b1LeafNode.getImmutableStats());
+            DefaultCacheStatsHolder.Node intermediateLevelNode = getNode(List.of("A" + indexA), cacheStatsHolder.getStatsRoot());
+            assertNotNull(intermediateLevelNode);
+            assertEquals(b1LeafNode.getImmutableStats(), intermediateLevelNode.getImmutableStats());
+        }
     }
 
     /**
diff --git a/server/src/test/java/org/opensearch/common/hash/MessageDigestsTests.java b/server/src/test/java/org/opensearch/common/hash/MessageDigestsTests.java
index 9e793e5487eb8..6b7cfb4c8932c 100644
--- a/server/src/test/java/org/opensearch/common/hash/MessageDigestsTests.java
+++ b/server/src/test/java/org/opensearch/common/hash/MessageDigestsTests.java
@@ -91,6 +91,31 @@ public void testSha256() throws Exception {
         );
     }
 
+    public void testSha3256() throws Exception {
+        assertHash("a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a", "", MessageDigests.sha3256());
+        assertHash("3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532", "abc", MessageDigests.sha3256());
+        assertHash(
+            "41c0dba2a9d6240849100376a8235e2c82e1b9998a999e21db32dd97496d3376",
+            "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+            MessageDigests.sha3256()
+        );
+        assertHash(
+            "5c8875ae474a3634ba4fd55ec85bffd661f32aca75c6d699d0cdcb6c115891c1",
+            new String(new char[1000000]).replace("\0", "a"),
+            MessageDigests.sha3256()
+        );
+        assertHash(
+            "69070dda01975c8c120c3aada1b282394e7f032fa9cf32f4cb2259a0897dfc04",
+            "The quick brown fox jumps over the lazy dog",
+            MessageDigests.sha3256()
+        );
+        assertHash(
+            "cc80b0b13ba89613d93f02ee7ccbe72ee26c6edfe577f22e63a1380221caedbc",
+            "The quick brown fox jumps over the lazy cog",
+            MessageDigests.sha3256()
+        );
+    }
+
     public void testToHexString() throws Exception {
         BigInteger expected = BigInteger.probablePrime(256, random());
         byte[] bytes = expected.toByteArray();
diff --git a/server/src/test/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManagerTests.java b/server/src/test/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManagerTests.java
new file mode 100644
index 0000000000000..d236274c99236
--- /dev/null
+++ b/server/src/test/java/org/opensearch/common/remote/AbstractRemoteWritableEntityManagerTests.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.remote;
+
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class AbstractRemoteWritableEntityManagerTests extends OpenSearchTestCase {
+    public void testGetStoreWithKnownEntityType() {
+        AbstractRemoteWritableEntityManager manager = new ConcreteRemoteWritableEntityManager();
+        String knownEntityType = "knownType";
+        RemoteWritableEntityStore mockStore = mock(RemoteWritableEntityStore.class);
+        manager.remoteWritableEntityStores.put(knownEntityType, mockStore);
+        AbstractClusterMetadataWriteableBlobEntity mockEntity = mock(AbstractClusterMetadataWriteableBlobEntity.class);
+        when(mockEntity.getType()).thenReturn(knownEntityType);
+
+        RemoteWritableEntityStore store = manager.getStore(mockEntity);
+        verify(mockEntity).getType();
+        assertEquals(mockStore, store);
+    }
+
+    public void testGetStoreWithUnknownEntityType() {
+        AbstractRemoteWritableEntityManager manager = new ConcreteRemoteWritableEntityManager();
+        String unknownEntityType = "unknownType";
+        AbstractClusterMetadataWriteableBlobEntity mockEntity = mock(AbstractClusterMetadataWriteableBlobEntity.class);
+        when(mockEntity.getType()).thenReturn(unknownEntityType);
+
+        assertThrows(IllegalArgumentException.class, () -> manager.getStore(mockEntity));
+        verify(mockEntity, times(2)).getType();
+    }
+
+    private static class ConcreteRemoteWritableEntityManager extends AbstractRemoteWritableEntityManager {
+        @Override
+        protected ActionListener<Void> getWrappedWriteListener(
+            String component,
+            AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+            ActionListener<ClusterMetadataManifest.UploadedMetadata> listener
+        ) {
+            return null;
+        }
+
+        @Override
+        protected ActionListener<Object> getWrappedReadListener(
+            String component,
+            AbstractClusterMetadataWriteableBlobEntity remoteEntity,
+            ActionListener<RemoteReadResult> listener
+        ) {
+            return null;
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/common/settings/ScopedSettingsTests.java b/server/src/test/java/org/opensearch/common/settings/ScopedSettingsTests.java
index c6eb1843d05e1..7dfea69729b4e 100644
--- a/server/src/test/java/org/opensearch/common/settings/ScopedSettingsTests.java
+++ b/server/src/test/java/org/opensearch/common/settings/ScopedSettingsTests.java
@@ -61,6 +61,9 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.startsWith;
@@ -1462,4 +1465,106 @@ public List<String> getListValue(final List<String> value) {
         );
     }
 
+    public void testGetOrNullWhenSettingIsNotSet() {
+        Setting<Integer> testSetting = Setting.intSetting("foo.bar", 1, Property.Dynamic, Property.NodeScope);
+        Setting<Integer> testSetting2 = Setting.intSetting("foo.bar.baz", 1, Property.Dynamic, Property.NodeScope);
+        AbstractScopedSettings clusterSettings = new ClusterSettings(
+            Settings.EMPTY,
+            new HashSet<>(Arrays.asList(testSetting, testSetting2))
+        );
+        clusterSettings.registerSetting(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE);
+        clusterSettings.registerSetting(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING);
+        assertNull(clusterSettings.getOrNull(CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING));
+
+    }
+
+    public void testGetOrNullWhenSettingIsSet() {
+        Setting<Integer> testSetting = Setting.intSetting("foo.bar", 1, Property.Dynamic, Property.NodeScope);
+        Setting<Integer> testSetting2 = Setting.intSetting("foo.bar.baz", 1, Property.Dynamic, Property.NodeScope);
+        AbstractScopedSettings clusterSettings = new ClusterSettings(
+            Settings.EMPTY,
+            new HashSet<>(Arrays.asList(testSetting, testSetting2))
+        );
+        clusterSettings.registerSetting(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE);
+        clusterSettings.applySettings(
+            Settings.builder().put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO).build()
+        );
+        assertEquals(clusterSettings.getOrNull(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE), "auto");
+
+    }
+
+    public void testGetOrNullWhenSettingIsSetInNodeSettings() {
+        Setting<Integer> testSetting = Setting.intSetting("foo.bar", 1, Property.Dynamic, Property.NodeScope);
+        Setting<Integer> testSetting2 = Setting.intSetting("foo.bar.baz", 1, Property.Dynamic, Property.NodeScope);
+        Settings concurrentSearchModeSetting = Settings.builder()
+            .put(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), CONCURRENT_SEGMENT_SEARCH_MODE_AUTO)
+            .build();
+        AbstractScopedSettings clusterSettings = new ClusterSettings(
+            concurrentSearchModeSetting,
+            new HashSet<>(Arrays.asList(testSetting, testSetting2, CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE))
+        );
+        assertEquals(clusterSettings.getOrNull(CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE), "auto");
+
+    }
+
+    public void testGetOrNullWhenSettingScopeDoesntMatch() {
+        Setting<Integer> testSetting = Setting.intSetting("foo.bar", 1, Property.Dynamic, Property.NodeScope);
+        Setting<Integer> testSetting2 = Setting.intSetting("foo.bar.baz", 1, Property.Dynamic, Property.NodeScope);
+        AbstractScopedSettings clusterSettings = new ClusterSettings(
+            Settings.EMPTY,
+            new HashSet<>(Arrays.asList(testSetting, testSetting2))
+        );
+        Setting<Integer> failedSetting = Setting.intSetting("foo.bar.scope.fail", 1, Property.Dynamic, Property.IndexScope);
+        clusterSettings.registerSetting(failedSetting);
+        try {
+            clusterSettings.getOrNull(failedSetting);
+            fail("setting scope doesn't match");
+        } catch (SettingsException ex) {
+            assertEquals("settings scope doesn't match the setting scope [NodeScope] not in [[Dynamic, IndexScope]]", ex.getMessage());
+        }
+
+    }
+
+    public void testGetOrNullWhenSettingIsNotRegistered() {
+        Setting<Integer> testSetting = Setting.intSetting("foo.bar", 1, Property.Dynamic, Property.NodeScope);
+        Setting<Integer> testSetting2 = Setting.intSetting("foo.bar.baz", 1, Property.Dynamic, Property.NodeScope);
+        AbstractScopedSettings clusterSettings = new ClusterSettings(
+            Settings.EMPTY,
+            new HashSet<>(Arrays.asList(testSetting, testSetting2))
+        );
+        Setting<Integer> failedSetting = Setting.intSetting("foo.bar.register.fail", 1, Property.Dynamic, Property.NodeScope);
+
+        try {
+            clusterSettings.getOrNull(failedSetting);
+            fail("setting is not registered");
+        } catch (SettingsException ex) {
+            assertEquals("setting foo.bar.register.fail has not been registered", ex.getMessage());
+        }
+
+    }
+
+    public void testGetOrNullWhenSettingIsRegisteredWithFallback() {
+        Setting<Integer> fallbackSetting = Setting.intSetting("foo.bar", 10, Property.Dynamic, Property.NodeScope);
+        AbstractScopedSettings clusterSettings = new ClusterSettings(Settings.EMPTY, new HashSet<>(Arrays.asList(fallbackSetting)));
+        clusterSettings.registerSetting(fallbackSetting);
+        clusterSettings.applySettings(Settings.builder().put(fallbackSetting.getKey(), 100).build());
+        Setting<Integer> settingWithFallback = Setting.intSetting("foo.fallback", fallbackSetting, 1, Property.Dynamic, Property.NodeScope);
+        clusterSettings.registerSetting(settingWithFallback);
+
+        assertEquals(clusterSettings.getOrNull(settingWithFallback), Integer.valueOf(100));
+
+    }
+
+    public void testGetOrNullWhenSettingIsRegisteredNodeSettingFallback() {
+        Setting<Integer> fallbackSetting = Setting.intSetting("foo.bar", 10, Property.Dynamic, Property.NodeScope);
+        Settings settings = Settings.builder().put(fallbackSetting.getKey(), 100).build();
+        AbstractScopedSettings clusterSettings = new ClusterSettings(settings, new HashSet<>(Arrays.asList(fallbackSetting)));
+
+        Setting<Integer> settingWithFallback = Setting.intSetting("foo.fallback", fallbackSetting, 1, Property.Dynamic, Property.NodeScope);
+        clusterSettings.registerSetting(settingWithFallback);
+
+        assertEquals(clusterSettings.getOrNull(settingWithFallback), Integer.valueOf(100));
+
+    }
+
 }
diff --git a/server/src/test/java/org/opensearch/common/settings/SettingsModuleTests.java b/server/src/test/java/org/opensearch/common/settings/SettingsModuleTests.java
index 17c6587c9f4c7..28f1df70fce09 100644
--- a/server/src/test/java/org/opensearch/common/settings/SettingsModuleTests.java
+++ b/server/src/test/java/org/opensearch/common/settings/SettingsModuleTests.java
@@ -290,20 +290,27 @@ public void testConcurrentSegmentSearchClusterSettings() {
         Settings settings = Settings.builder().put(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), settingValue).build();
         SettingsModule settingsModule = new SettingsModule(settings);
         assertEquals(settingValue, SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.get(settingsModule.getSettings()));
+        assertSettingDeprecationsAndWarnings(new Setting[] { SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING });
     }
 
     public void testConcurrentSegmentSearchIndexSettings() {
         Settings.Builder target = Settings.builder().put(Settings.EMPTY);
         Settings.Builder update = Settings.builder();
-
+        boolean settingValue = randomBoolean();
         SettingsModule module = new SettingsModule(Settings.EMPTY);
         IndexScopedSettings indexScopedSettings = module.getIndexScopedSettings();
         indexScopedSettings.updateDynamicSettings(
-            Settings.builder().put(IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build(),
+            Settings.builder().put(IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), settingValue).build(),
             target,
             update,
             "node"
         );
+        // apply the setting update
+        module.getIndexScopedSettings()
+            .applySettings(Settings.builder().put(IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), settingValue).build());
+        // assert value
+        assertEquals(settingValue, module.getIndexScopedSettings().get(IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING));
+        assertSettingDeprecationsAndWarnings(new Setting[] { IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING });
     }
 
     public void testMaxSliceCountClusterSettingsForConcurrentSearch() {
diff --git a/server/src/test/java/org/opensearch/common/util/BatchRunnableExecutorTests.java b/server/src/test/java/org/opensearch/common/util/BatchRunnableExecutorTests.java
new file mode 100644
index 0000000000000..2f63ae43d0ded
--- /dev/null
+++ b/server/src/test/java/org/opensearch/common/util/BatchRunnableExecutorTests.java
@@ -0,0 +1,126 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.util;
+
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.concurrent.TimeoutAwareRunnable;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.function.Supplier;
+
+import static org.mockito.Mockito.atMost;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+public class BatchRunnableExecutorTests extends OpenSearchTestCase {
+    private Supplier<TimeValue> timeoutSupplier;
+    private TimeoutAwareRunnable runnable1;
+    private TimeoutAwareRunnable runnable2;
+    private TimeoutAwareRunnable runnable3;
+    private List<TimeoutAwareRunnable> runnableList;
+
+    public void setupRunnables() {
+        timeoutSupplier = mock(Supplier.class);
+        runnable1 = mock(TimeoutAwareRunnable.class);
+        runnable2 = mock(TimeoutAwareRunnable.class);
+        runnable3 = mock(TimeoutAwareRunnable.class);
+        runnableList = Arrays.asList(runnable1, runnable2, runnable3);
+    }
+
+    public void testRunWithoutTimeout() {
+        setupRunnables();
+        timeoutSupplier = () -> TimeValue.timeValueSeconds(1);
+        CountDownLatch countDownLatch = new CountDownLatch(1);
+        BatchRunnableExecutor executor = new BatchRunnableExecutor(runnableList, timeoutSupplier) {
+            @Override
+            public void onComplete() {
+                countDownLatch.countDown();
+            }
+        };
+        executor.run();
+        verify(runnable1, times(1)).run();
+        verify(runnable2, times(1)).run();
+        verify(runnable3, times(1)).run();
+        verify(runnable1, never()).onTimeout();
+        verify(runnable2, never()).onTimeout();
+        verify(runnable3, never()).onTimeout();
+        assertEquals(0, countDownLatch.getCount());
+    }
+
+    public void testRunWithTimeout() {
+        setupRunnables();
+        timeoutSupplier = () -> TimeValue.timeValueNanos(1);
+        CountDownLatch countDownLatch = new CountDownLatch(1);
+        BatchRunnableExecutor executor = new BatchRunnableExecutor(runnableList, timeoutSupplier) {
+            @Override
+            public void onComplete() {
+                countDownLatch.countDown();
+            }
+        };
+        executor.run();
+        verify(runnable1, times(1)).onTimeout();
+        verify(runnable2, times(1)).onTimeout();
+        verify(runnable3, times(1)).onTimeout();
+        verify(runnable1, never()).run();
+        verify(runnable2, never()).run();
+        verify(runnable3, never()).run();
+        assertEquals(0, countDownLatch.getCount());
+    }
+
+    public void testRunWithPartialTimeout() {
+        setupRunnables();
+        timeoutSupplier = () -> TimeValue.timeValueMillis(50);
+        CountDownLatch countDownLatch = new CountDownLatch(1);
+        BatchRunnableExecutor executor = new BatchRunnableExecutor(runnableList, timeoutSupplier) {
+            @Override
+            public void onComplete() {
+                countDownLatch.countDown();
+            }
+        };
+        doAnswer(invocation -> {
+            Thread.sleep(100);
+            return null;
+        }).when(runnable1).run();
+        executor.run();
+        verify(runnable1, atMost(1)).run();
+        verify(runnable2, atMost(1)).run();
+        verify(runnable3, atMost(1)).run();
+        verify(runnable2, atMost(1)).onTimeout();
+        verify(runnable3, atMost(1)).onTimeout();
+        verify(runnable2, atMost(1)).onTimeout();
+        verify(runnable3, atMost(1)).onTimeout();
+        assertEquals(0, countDownLatch.getCount());
+    }
+
+    public void testRunWithEmptyRunnableList() {
+        setupRunnables();
+        CountDownLatch countDownLatch = new CountDownLatch(1);
+        BatchRunnableExecutor executor = new BatchRunnableExecutor(Collections.emptyList(), timeoutSupplier) {
+            @Override
+            public void onComplete() {
+                countDownLatch.countDown();
+            }
+        };
+        executor.run();
+        verify(runnable1, never()).onTimeout();
+        verify(runnable2, never()).onTimeout();
+        verify(runnable3, never()).onTimeout();
+        verify(runnable1, never()).run();
+        verify(runnable2, never()).run();
+        verify(runnable3, never()).run();
+        assertEquals(1, countDownLatch.getCount());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/common/util/ByteArrayBackedBitsetTests.java b/server/src/test/java/org/opensearch/common/util/ByteArrayBackedBitsetTests.java
new file mode 100644
index 0000000000000..6750a9e48f033
--- /dev/null
+++ b/server/src/test/java/org/opensearch/common/util/ByteArrayBackedBitsetTests.java
@@ -0,0 +1,56 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.util;
+
+import org.apache.lucene.store.FSDirectory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.RandomAccessInput;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+/**
+ * Tests for {@link ByteArrayBackedBitset}
+ */
+public class ByteArrayBackedBitsetTests extends OpenSearchTestCase {
+    public void testWriteAndReadNullBitSets() throws IOException {
+        for (int k = 0; k < 10; k++) {
+            int randomArraySize = randomIntBetween(2, 300);
+            int randomIndex1 = randomIntBetween(0, (randomArraySize - 1) * 8);
+            int randomIndex2 = randomIntBetween(0, (randomArraySize - 1) * 8);
+            testWriteAndReadBitset(randomArraySize, randomIndex1, randomIndex2);
+        }
+    }
+
+    private static void testWriteAndReadBitset(int randomArraySize, int randomIndex1, int randomIndex2) throws IOException {
+        ByteArrayBackedBitset bitset = new ByteArrayBackedBitset(randomArraySize);
+        Path basePath = createTempDir("OffHeapTests");
+        FSDirectory fsDirectory = FSDirectory.open(basePath);
+        String TEST_FILE = "test_file";
+        IndexOutput indexOutput = fsDirectory.createOutput(TEST_FILE, IOContext.DEFAULT);
+        bitset.set(randomIndex1);
+        bitset.set(randomIndex2);
+        bitset.write(indexOutput);
+        indexOutput.close();
+
+        IndexInput in = fsDirectory.openInput(TEST_FILE, IOContext.DEFAULT);
+        RandomAccessInput randomAccessInput = in.randomAccessSlice(0, in.length());
+        ByteArrayBackedBitset bitset1 = new ByteArrayBackedBitset(randomAccessInput, 0, randomArraySize);
+        for (int i = 0; i < (randomArraySize * 8); i++) {
+            if (randomIndex1 == i || randomIndex2 == i) {
+                assertTrue(bitset1.get(i));
+            } else {
+                assertFalse(bitset1.get(i));
+            }
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/common/util/concurrent/ThreadContextTests.java b/server/src/test/java/org/opensearch/common/util/concurrent/ThreadContextTests.java
index 10669ca1a805b..5992ffa1465b4 100644
--- a/server/src/test/java/org/opensearch/common/util/concurrent/ThreadContextTests.java
+++ b/server/src/test/java/org/opensearch/common/util/concurrent/ThreadContextTests.java
@@ -206,7 +206,7 @@ public void testStashWithOrigin() {
         }
 
         assertNull(threadContext.getTransient(ThreadContext.ACTION_ORIGIN_TRANSIENT_NAME));
-        try (ThreadContext.StoredContext storedContext = threadContext.stashWithOrigin(origin)) {
+        try (ThreadContext.StoredContext storedContext = ThreadContextAccess.doPrivileged(() -> threadContext.stashWithOrigin(origin))) {
             assertEquals(origin, threadContext.getTransient(ThreadContext.ACTION_ORIGIN_TRANSIENT_NAME));
             assertNull(threadContext.getTransient("foo"));
             assertNull(threadContext.getTransient("bar"));
@@ -231,7 +231,7 @@ public void testStashAndMerge() {
         HashMap<String, String> toMerge = new HashMap<>();
         toMerge.put("foo", "baz");
         toMerge.put("simon", "says");
-        try (ThreadContext.StoredContext ctx = threadContext.stashAndMergeHeaders(toMerge)) {
+        try (ThreadContext.StoredContext ctx = ThreadContextAccess.doPrivileged(() -> threadContext.stashAndMergeHeaders(toMerge))) {
             assertEquals("bar", threadContext.getHeader("foo"));
             assertEquals("says", threadContext.getHeader("simon"));
             assertNull(threadContext.getTransient("ctx.foo"));
@@ -344,11 +344,11 @@ public void testResponseHeaders() {
         }
 
         final String value = HeaderWarning.formatWarning("qux");
-        threadContext.addResponseHeader("baz", value, s -> HeaderWarning.extractWarningValueFromWarningHeader(s, false));
+        threadContext.updateResponseHeader("baz", value, s -> HeaderWarning.extractWarningValueFromWarningHeader(s, false));
         // pretend that another thread created the same response at a different time
         if (randomBoolean()) {
             final String duplicateValue = HeaderWarning.formatWarning("qux");
-            threadContext.addResponseHeader("baz", duplicateValue, s -> HeaderWarning.extractWarningValueFromWarningHeader(s, false));
+            threadContext.updateResponseHeader("baz", duplicateValue, s -> HeaderWarning.extractWarningValueFromWarningHeader(s, false));
         }
 
         threadContext.addResponseHeader("Warning", "One is the loneliest number");
@@ -493,7 +493,13 @@ public void testStashAndMergeWithModifiedDefaults() {
         ThreadContext threadContext = new ThreadContext(build);
         HashMap<String, String> toMerge = new HashMap<>();
         toMerge.put("default", "2");
-        try (ThreadContext.StoredContext ctx = threadContext.stashAndMergeHeaders(toMerge)) {
+        ThreadContext finalThreadContext1 = threadContext;
+        HashMap<String, String> finalToMerge1 = toMerge;
+        try (
+            ThreadContext.StoredContext ctx = ThreadContextAccess.doPrivileged(
+                () -> finalThreadContext1.stashAndMergeHeaders(finalToMerge1)
+            )
+        ) {
             assertEquals("2", threadContext.getHeader("default"));
         }
 
@@ -502,7 +508,13 @@ public void testStashAndMergeWithModifiedDefaults() {
         threadContext.putHeader("default", "4");
         toMerge = new HashMap<>();
         toMerge.put("default", "2");
-        try (ThreadContext.StoredContext ctx = threadContext.stashAndMergeHeaders(toMerge)) {
+        ThreadContext finalThreadContext2 = threadContext;
+        HashMap<String, String> finalToMerge2 = toMerge;
+        try (
+            ThreadContext.StoredContext ctx = ThreadContextAccess.doPrivileged(
+                () -> finalThreadContext2.stashAndMergeHeaders(finalToMerge2)
+            )
+        ) {
             assertEquals("4", threadContext.getHeader("default"));
         }
     }
@@ -565,7 +577,7 @@ public void testPreservesThreadsOriginalContextOnRunException() throws IOExcepti
             threadContext.putHeader("foo", "bar");
             boolean systemContext = randomBoolean();
             if (systemContext) {
-                threadContext.markAsSystemContext();
+                ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             }
             threadContext.putTransient("foo", "bar_transient");
             withContext = threadContext.preserveContext(new AbstractRunnable() {
@@ -736,7 +748,7 @@ public void testMarkAsSystemContext() throws IOException {
         assertFalse(threadContext.isSystemContext());
         try (ThreadContext.StoredContext context = threadContext.stashContext()) {
             assertFalse(threadContext.isSystemContext());
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             assertTrue(threadContext.isSystemContext());
         }
         assertFalse(threadContext.isSystemContext());
@@ -761,7 +773,7 @@ public void testSystemContextWithPropagator() {
         assertEquals(Integer.valueOf(1), threadContext.getTransient("test_transient_propagation_key"));
         assertEquals("bar", threadContext.getHeader("foo"));
         try (ThreadContext.StoredContext ctx = threadContext.stashContext()) {
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             assertNull(threadContext.getHeader("foo"));
             assertNull(threadContext.getTransient("test_transient_propagation_key"));
             assertEquals("1", threadContext.getHeader("default"));
@@ -793,7 +805,7 @@ public void testSerializeSystemContext() throws IOException {
         threadContext.writeTo(out);
         try (ThreadContext.StoredContext ctx = threadContext.stashContext()) {
             assertEquals("test", threadContext.getTransient("test_transient_propagation_key"));
-            threadContext.markAsSystemContext();
+            ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
             threadContext.writeTo(outFromSystemContext);
             assertNull(threadContext.getHeader("foo"));
             assertNull(threadContext.getTransient("test_transient_propagation_key"));
diff --git a/server/src/test/java/org/opensearch/common/xcontent/JsonToStringXContentParserTests.java b/server/src/test/java/org/opensearch/common/xcontent/JsonToStringXContentParserTests.java
index 0feb7bcd1ceec..3c292181b4d8f 100644
--- a/server/src/test/java/org/opensearch/common/xcontent/JsonToStringXContentParserTests.java
+++ b/server/src/test/java/org/opensearch/common/xcontent/JsonToStringXContentParserTests.java
@@ -19,7 +19,6 @@
 public class JsonToStringXContentParserTests extends OpenSearchTestCase {
 
     private String flattenJsonString(String fieldName, String in) throws IOException {
-        String transformed;
         try (
             XContentParser parser = JsonXContent.jsonXContent.createParser(
                 xContentRegistry(),
@@ -33,10 +32,11 @@ private String flattenJsonString(String fieldName, String in) throws IOException
                 parser,
                 fieldName
             );
-            // Skip the START_OBJECT token:
+            // Point to the first token (should be START_OBJECT)
             jsonToStringXContentParser.nextToken();
 
             XContentParser transformedParser = jsonToStringXContentParser.parseObject();
+            assertSame(XContentParser.Token.END_OBJECT, jsonToStringXContentParser.currentToken());
             try (XContentBuilder jsonBuilder = XContentFactory.jsonBuilder()) {
                 jsonBuilder.copyCurrentStructure(transformedParser);
                 return jsonBuilder.toString();
@@ -49,9 +49,9 @@ public void testNestedObjects() throws IOException {
 
         assertEquals(
             "{"
-                + "\"flat\":[\"first\",\"second\",\"inner\",\"third\"],"
+                + "\"flat\":[\"third\",\"inner\",\"first\",\"second\"],"
                 + "\"flat._value\":[\"1\",\"2.0\",\"three\"],"
-                + "\"flat._valueAndPath\":[\"flat.first=1\",\"flat.second.inner=2.0\",\"flat.third=three\"]"
+                + "\"flat._valueAndPath\":[\"flat.second.inner=2.0\",\"flat.first=1\",\"flat.third=three\"]"
                 + "}",
             flattenJsonString("flat", jsonExample)
         );
@@ -64,9 +64,9 @@ public void testChildHasDots() throws IOException {
 
         assertEquals(
             "{"
-                + "\"flat\":[\"first\",\"second\",\"inner\",\"third\"],"
+                + "\"flat\":[\"third\",\"inner\",\"first\",\"second\"],"
                 + "\"flat._value\":[\"1\",\"2.0\",\"three\"],"
-                + "\"flat._valueAndPath\":[\"flat.first=1\",\"flat.second.inner=2.0\",\"flat.third=three\"]"
+                + "\"flat._valueAndPath\":[\"flat.second.inner=2.0\",\"flat.first=1\",\"flat.third=three\"]"
                 + "}",
             flattenJsonString("flat", jsonExample)
         );
@@ -83,7 +83,7 @@ public void testNestChildObjectWithDots() throws IOException {
 
         assertEquals(
             "{"
-                + "\"flat\":[\"first\",\"second\",\"inner\",\"really_inner\",\"third\"],"
+                + "\"flat\":[\"really_inner\",\"third\",\"inner\",\"first\",\"second\"],"
                 + "\"flat._value\":[\"1\",\"2.0\",\"three\"],"
                 + "\"flat._valueAndPath\":[\"flat.first=1\",\"flat.second.inner.really_inner=2.0\",\"flat.third=three\"]"
                 + "}",
@@ -102,7 +102,7 @@ public void testNestChildObjectWithDotsAndFieldWithDots() throws IOException {
 
         assertEquals(
             "{"
-                + "\"flat\":[\"first\",\"second\",\"inner\",\"totally\",\"absolutely\",\"inner\",\"third\"],"
+                + "\"flat\":[\"third\",\"absolutely\",\"totally\",\"inner\",\"first\",\"second\"],"
                 + "\"flat._value\":[\"1\",\"2.0\",\"three\"],"
                 + "\"flat._valueAndPath\":[\"flat.first=1\",\"flat.second.inner.totally.absolutely.inner=2.0\",\"flat.third=three\"]"
                 + "}",
@@ -110,4 +110,55 @@ public void testNestChildObjectWithDotsAndFieldWithDots() throws IOException {
         );
     }
 
+    public void testArrayOfObjects() throws IOException {
+        String jsonExample = "{"
+            + "\"field\": {"
+            + "  \"detail\": {"
+            + "    \"foooooooooooo\": ["
+            + "      {\"name\":\"baz\"},"
+            + "      {\"name\":\"baz\"}"
+            + "    ]"
+            + "  }"
+            + "}}";
+
+        assertEquals(
+            "{"
+                + "\"flat\":[\"field\",\"name\",\"detail\",\"foooooooooooo\"],"
+                + "\"flat._value\":[\"baz\"],"
+                + "\"flat._valueAndPath\":["
+                + "\"flat.field.detail.foooooooooooo.name=baz\""
+                + "]}",
+            flattenJsonString("flat", jsonExample)
+        );
+    }
+
+    public void testArraysOfObjectsAndValues() throws IOException {
+        String jsonExample = "{"
+            + "\"field\": {"
+            + "  \"detail\": {"
+            + "    \"foooooooooooo\": ["
+            + "      {\"name\":\"baz\"},"
+            + "      {\"name\":\"baz\"}"
+            + "    ]"
+            + "  },"
+            + "  \"numbers\" : ["
+            + "    1,"
+            + "    2,"
+            + "    3"
+            + "  ]"
+            + "}}";
+
+        assertEquals(
+            "{"
+                + "\"flat\":[\"field\",\"name\",\"numbers\",\"detail\",\"foooooooooooo\"],"
+                + "\"flat._value\":[\"1\",\"2\",\"3\",\"baz\"],"
+                + "\"flat._valueAndPath\":["
+                + "\"flat.field.detail.foooooooooooo.name=baz\","
+                + "\"flat.field.numbers=1\","
+                + "\"flat.field.numbers=3\","
+                + "\"flat.field.numbers=2\""
+                + "]}",
+            flattenJsonString("flat", jsonExample)
+        );
+    }
 }
diff --git a/server/src/test/java/org/opensearch/core/RestStatusTests.java b/server/src/test/java/org/opensearch/core/RestStatusTests.java
index f8dba99aa8b60..fbd238bd035d0 100644
--- a/server/src/test/java/org/opensearch/core/RestStatusTests.java
+++ b/server/src/test/java/org/opensearch/core/RestStatusTests.java
@@ -55,7 +55,11 @@ public void testStatusReturnsFailureStatusWhenFailuresExist() {
             heapOfFailures.add(failure);
         }
 
-        assertEquals(heapOfFailures.peek().status(), RestStatus.status(successfulShards, totalShards, failures));
+        final RestStatus status = heapOfFailures.peek().status();
+        // RestStatus.status will return RestStatus.OK when the highest failure code is 100 level.
+        final RestStatus expected = status.getStatusFamilyCode() == 1 ? RestStatus.OK : status;
+
+        assertEquals(expected, RestStatus.status(successfulShards, totalShards, failures));
     }
 
     public void testSerialization() throws IOException {
diff --git a/server/src/test/java/org/opensearch/discovery/DiscoveryModuleTests.java b/server/src/test/java/org/opensearch/discovery/DiscoveryModuleTests.java
index b33ebf8333b36..cd3e8af2a3cd1 100644
--- a/server/src/test/java/org/opensearch/discovery/DiscoveryModuleTests.java
+++ b/server/src/test/java/org/opensearch/discovery/DiscoveryModuleTests.java
@@ -32,6 +32,7 @@
 package org.opensearch.discovery;
 
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.coordination.Coordinator;
 import org.opensearch.cluster.coordination.PersistedStateRegistry;
@@ -48,6 +49,7 @@
 import org.opensearch.gateway.GatewayMetaState;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.plugins.DiscoveryPlugin;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.transport.MockTransportService;
@@ -128,7 +130,9 @@ private DiscoveryModule newModule(Settings settings, List<DiscoveryPlugin> plugi
             mock(RerouteService.class),
             null,
             new PersistedStateRegistry(),
-            remoteStoreNodeService
+            remoteStoreNodeService,
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE),
+            null
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/env/NodeRepurposeCommandTests.java b/server/src/test/java/org/opensearch/env/NodeRepurposeCommandTests.java
index 2a3525143c01f..d2d6fdc387dfe 100644
--- a/server/src/test/java/org/opensearch/env/NodeRepurposeCommandTests.java
+++ b/server/src/test/java/org/opensearch/env/NodeRepurposeCommandTests.java
@@ -95,7 +95,7 @@ public void createNodePaths() throws IOException {
         dataClusterManagerSettings = buildEnvSettings(Settings.EMPTY);
         Settings defaultSearchSettings = Settings.builder()
             .put(dataClusterManagerSettings)
-            .put(NODE_SEARCH_CACHE_SIZE_SETTING.getKey(), new ByteSizeValue(16, ByteSizeUnit.GB))
+            .put(NODE_SEARCH_CACHE_SIZE_SETTING.getKey(), new ByteSizeValue(16, ByteSizeUnit.GB).toString())
             .build();
 
         searchNoDataNoClusterManagerSettings = onlyRole(dataClusterManagerSettings, DiscoveryNodeRole.SEARCH_ROLE);
diff --git a/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java b/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
index 1d4fbc3d81b55..cf39d2460aebb 100644
--- a/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
+++ b/server/src/test/java/org/opensearch/extensions/ExtensionsManagerTests.java
@@ -154,7 +154,7 @@ public List<Setting<?>> getExtensionSettings() {
             new NodeClient(Settings.EMPTY, threadPool),
             new NoneCircuitBreakerService(),
             new UsageService(),
-            new IdentityService(Settings.EMPTY, List.of())
+            new IdentityService(Settings.EMPTY, threadPool, List.of())
         );
         when(actionModule.getDynamicActionRegistry()).thenReturn(mock(DynamicActionRegistry.class));
         when(actionModule.getRestController()).thenReturn(restController);
@@ -171,7 +171,7 @@ public List<Setting<?>> getExtensionSettings() {
             Collections.emptyList()
         );
         client = new NoOpNodeClient(this.getTestName());
-        identityService = new IdentityService(Settings.EMPTY, List.of());
+        identityService = new IdentityService(Settings.EMPTY, threadPool, List.of());
     }
 
     @Override
diff --git a/server/src/test/java/org/opensearch/extensions/rest/ExtensionRestRequestTests.java b/server/src/test/java/org/opensearch/extensions/rest/ExtensionRestRequestTests.java
index 8b73f2e81972f..7d9ebe1d1e26a 100644
--- a/server/src/test/java/org/opensearch/extensions/rest/ExtensionRestRequestTests.java
+++ b/server/src/test/java/org/opensearch/extensions/rest/ExtensionRestRequestTests.java
@@ -29,6 +29,7 @@
 import org.opensearch.rest.BytesRestResponse;
 import org.opensearch.rest.RestRequest.Method;
 import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.ThreadPool;
 
 import java.nio.charset.StandardCharsets;
 import java.security.Principal;
@@ -38,6 +39,7 @@
 import java.util.Map;
 
 import static java.util.Map.entry;
+import static org.mockito.Mockito.mock;
 
 public class ExtensionRestRequestTests extends OpenSearchTestCase {
 
@@ -72,12 +74,12 @@ public void setUp() throws Exception {
         userPrincipal = () -> "user1";
         expectedHttpVersion = HttpRequest.HttpVersion.HTTP_1_1;
         extensionTokenProcessor = "placeholder_extension_token_processor";
-        identityService = new IdentityService(Settings.EMPTY, List.of());
+        identityService = new IdentityService(Settings.EMPTY, mock(ThreadPool.class), List.of());
         TokenManager tokenManager = identityService.getTokenManager();
-        Subject subject = this.identityService.getSubject();
+        Subject subject = this.identityService.getCurrentSubject();
         OnBehalfOfClaims claims = new OnBehalfOfClaims("testID", subject.getPrincipal().getName());
         expectedRequestIssuerIdentity = identityService.getTokenManager()
-            .issueOnBehalfOfToken(identityService.getSubject(), claims)
+            .issueOnBehalfOfToken(identityService.getCurrentSubject(), claims)
             .asAuthHeaderValue();
     }
 
diff --git a/server/src/test/java/org/opensearch/extensions/rest/RestInitializeExtensionActionTests.java b/server/src/test/java/org/opensearch/extensions/rest/RestInitializeExtensionActionTests.java
index 0dae0ae1b4e0b..ac818c3bb4a7b 100644
--- a/server/src/test/java/org/opensearch/extensions/rest/RestInitializeExtensionActionTests.java
+++ b/server/src/test/java/org/opensearch/extensions/rest/RestInitializeExtensionActionTests.java
@@ -121,7 +121,7 @@ public void testRestInitializeExtensionActionResponse() throws Exception {
     }
 
     public void testRestInitializeExtensionActionFailure() throws Exception {
-        ExtensionsManager extensionsManager = new ExtensionsManager(Set.of(), new IdentityService(Settings.EMPTY, List.of()));
+        ExtensionsManager extensionsManager = new ExtensionsManager(Set.of(), new IdentityService(Settings.EMPTY, threadPool, List.of()));
         RestInitializeExtensionAction restInitializeExtensionAction = new RestInitializeExtensionAction(extensionsManager);
 
         final String content = "{\"name\":\"ad-extension\",\"uniqueId\":\"\",\"hostAddress\":\"127.0.0.1\","
@@ -156,7 +156,7 @@ public void testRestInitializeExtensionActionResponseWithAdditionalSettings() th
         );
         ExtensionsManager extensionsManager = new ExtensionsManager(
             Set.of(boolSetting, stringSetting, intSetting, listSetting),
-            new IdentityService(Settings.EMPTY, List.of())
+            new IdentityService(Settings.EMPTY, threadPool, List.of())
         );
         ExtensionsManager spy = spy(extensionsManager);
 
@@ -206,7 +206,7 @@ public void testRestInitializeExtensionActionResponseWithAdditionalSettingsUsing
         );
         ExtensionsManager extensionsManager = new ExtensionsManager(
             Set.of(boolSetting, stringSetting, intSetting, listSetting),
-            new IdentityService(Settings.EMPTY, List.of())
+            new IdentityService(Settings.EMPTY, threadPool, List.of())
         );
         ExtensionsManager spy = spy(extensionsManager);
 
diff --git a/server/src/test/java/org/opensearch/extensions/rest/RestSendToExtensionActionTests.java b/server/src/test/java/org/opensearch/extensions/rest/RestSendToExtensionActionTests.java
index ceaef8e006691..c002c4610a955 100644
--- a/server/src/test/java/org/opensearch/extensions/rest/RestSendToExtensionActionTests.java
+++ b/server/src/test/java/org/opensearch/extensions/rest/RestSendToExtensionActionTests.java
@@ -122,10 +122,10 @@ public void setup() throws Exception {
             null,
             usageService,
             null,
-            new IdentityService(Settings.EMPTY, new ArrayList<>()),
-            new ExtensionsManager(Set.of(), new IdentityService(Settings.EMPTY, List.of()))
+            new IdentityService(Settings.EMPTY, mock(ThreadPool.class), new ArrayList<>()),
+            new ExtensionsManager(Set.of(), new IdentityService(Settings.EMPTY, mock(ThreadPool.class), List.of()))
         );
-        identityService = new IdentityService(Settings.EMPTY, new ArrayList<>());
+        identityService = new IdentityService(Settings.EMPTY, mock(ThreadPool.class), new ArrayList<>());
         dynamicActionRegistry = actionModule.getDynamicActionRegistry();
     }
 
diff --git a/server/src/test/java/org/opensearch/gateway/ClusterStateUpdatersTests.java b/server/src/test/java/org/opensearch/gateway/ClusterStateUpdatersTests.java
index 1c43bb565ef69..dd2fb51151a5b 100644
--- a/server/src/test/java/org/opensearch/gateway/ClusterStateUpdatersTests.java
+++ b/server/src/test/java/org/opensearch/gateway/ClusterStateUpdatersTests.java
@@ -55,6 +55,7 @@
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.repositories.IndexId;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.Arrays;
@@ -123,7 +124,7 @@ public String getValue(final String value) {
 
             })
         );
-        final ClusterService clusterService = new ClusterService(Settings.EMPTY, clusterSettings, null);
+        final ClusterService clusterService = ClusterServiceUtils.createClusterService(Settings.EMPTY, clusterSettings, null);
         final Metadata.Builder builder = Metadata.builder();
         final Settings settings = Settings.builder().put("foo.old", randomAlphaOfLength(8)).build();
         applySettingsToBuilder.accept(builder, settings);
diff --git a/server/src/test/java/org/opensearch/gateway/GatewayAllocatorTests.java b/server/src/test/java/org/opensearch/gateway/GatewayAllocatorTests.java
index bb59a5792ec8c..c7eae77d6deba 100644
--- a/server/src/test/java/org/opensearch/gateway/GatewayAllocatorTests.java
+++ b/server/src/test/java/org/opensearch/gateway/GatewayAllocatorTests.java
@@ -18,14 +18,23 @@
 import org.opensearch.cluster.OpenSearchAllocationTestCase;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.routing.IndexRoutingTable;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.RoutingNodes;
 import org.opensearch.cluster.routing.RoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
+import org.opensearch.cluster.routing.UnassignedInfo;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
 import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.BatchRunnableExecutor;
+import org.opensearch.common.util.set.Sets;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.snapshots.SnapshotShardSizeInfo;
 import org.opensearch.test.gateway.TestShardBatchGatewayAllocator;
@@ -37,8 +46,15 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
+import static org.opensearch.gateway.ShardsBatchGatewayAllocator.PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING;
+import static org.opensearch.gateway.ShardsBatchGatewayAllocator.PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY;
+import static org.opensearch.gateway.ShardsBatchGatewayAllocator.REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING;
+import static org.opensearch.gateway.ShardsBatchGatewayAllocator.REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY;
+
 public class GatewayAllocatorTests extends OpenSearchAllocationTestCase {
 
     private final Logger logger = LogManager.getLogger(GatewayAllocatorTests.class);
@@ -54,6 +70,13 @@ public void setUp() throws Exception {
         testShardsBatchGatewayAllocator = new TestShardBatchGatewayAllocator();
     }
 
+    public void testExecutorNotNull() {
+        createIndexAndUpdateClusterState(1, 3, 1);
+        createBatchesAndAssert(1);
+        BatchRunnableExecutor executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, true);
+        assertNotNull(executor);
+    }
+
     public void testSingleBatchCreation() {
         createIndexAndUpdateClusterState(1, 3, 1);
         createBatchesAndAssert(1);
@@ -222,6 +245,21 @@ public void testSafelyRemoveShardFromBothBatch() {
         assertEquals(0, testShardsBatchGatewayAllocator.getBatchIdToStoreShardBatch().size());
     }
 
+    public void testDeDuplicationOfReplicaShardsAcrossBatch() {
+        final ShardId shardId = new ShardId("test", "_na_", 0);
+        final DiscoveryNode node = newNode("node1");
+        // number of replicas is greater than batch size - to ensure shardRouting gets de-duped across batch
+        createRoutingWithDifferentUnAssignedInfo(shardId, node, 50);
+        testShardsBatchGatewayAllocator = new TestShardBatchGatewayAllocator(10);
+
+        // only replica shard should be in the batch
+        Set<String> replicaBatches = testShardsBatchGatewayAllocator.createAndUpdateBatches(testAllocation, false);
+        assertEquals(1, replicaBatches.size());
+        ShardsBatchGatewayAllocator.ShardsBatch shardsBatch = testShardsBatchGatewayAllocator.getBatchIdToStoreShardBatch()
+            .get(replicaBatches.iterator().next());
+        assertEquals(1, shardsBatch.getBatchedShards().size());
+    }
+
     public void testGetBatchIdExisting() {
         createIndexAndUpdateClusterState(2, 1020, 1);
         // get all shardsRoutings for test index
@@ -314,6 +352,98 @@ public void testGetBatchIdNonExisting() {
         allShardRoutings.forEach(shard -> assertNull(testShardsBatchGatewayAllocator.getBatchId(shard, shard.primary())));
     }
 
+    public void testCreatePrimaryAndReplicaExecutorOfSizeOne() {
+        createIndexAndUpdateClusterState(1, 3, 2);
+        BatchRunnableExecutor executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, true);
+        assertEquals(executor.getTimeoutAwareRunnables().size(), 1);
+        executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, false);
+        assertEquals(executor.getTimeoutAwareRunnables().size(), 1);
+    }
+
+    public void testCreatePrimaryExecutorOfSizeOneAndReplicaExecutorOfSizeZero() {
+        createIndexAndUpdateClusterState(1, 3, 0);
+        BatchRunnableExecutor executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, true);
+        assertEquals(executor.getTimeoutAwareRunnables().size(), 1);
+        executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, false);
+        assertNull(executor);
+    }
+
+    public void testCreatePrimaryAndReplicaExecutorOfSizeTwo() {
+        createIndexAndUpdateClusterState(2, 1001, 1);
+        BatchRunnableExecutor executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, true);
+        assertEquals(executor.getTimeoutAwareRunnables().size(), 2);
+        executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, false);
+        assertEquals(executor.getTimeoutAwareRunnables().size(), 2);
+    }
+
+    public void testPrimaryAllocatorTimeout() {
+        // Valid setting with timeout = 20s
+        Settings build = Settings.builder().put(PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY, "20s").build();
+        assertEquals(20, PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(build).getSeconds());
+
+        // Valid setting with timeout > 20s
+        build = Settings.builder().put(PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY, "30000ms").build();
+        assertEquals(30, PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(build).getSeconds());
+
+        // Invalid setting with timeout < 20s
+        Settings lessThan20sSetting = Settings.builder().put(PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY, "10s").build();
+        IllegalArgumentException iae = expectThrows(
+            IllegalArgumentException.class,
+            () -> PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(lessThan20sSetting)
+        );
+        assertEquals(
+            "Setting [" + PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.getKey() + "] should be more than 20s or -1ms to disable timeout",
+            iae.getMessage()
+        );
+
+        // Valid setting with timeout = -1
+        build = Settings.builder().put(PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY, "-1").build();
+        assertEquals(-1, PRIMARY_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(build).getMillis());
+    }
+
+    public void testReplicaAllocatorTimeout() {
+        // Valid setting with timeout = 20s
+        Settings build = Settings.builder().put(REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY, "20s").build();
+        assertEquals(20, REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(build).getSeconds());
+
+        // Valid setting with timeout > 20s
+        build = Settings.builder().put(REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY, "30000ms").build();
+        assertEquals(30, REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(build).getSeconds());
+
+        // Invalid setting with timeout < 20s
+        Settings lessThan20sSetting = Settings.builder().put(REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY, "10s").build();
+        IllegalArgumentException iae = expectThrows(
+            IllegalArgumentException.class,
+            () -> REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(lessThan20sSetting)
+        );
+        assertEquals(
+            "Setting [" + REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.getKey() + "] should be more than 20s or -1ms to disable timeout",
+            iae.getMessage()
+        );
+
+        // Valid setting with timeout = -1
+        build = Settings.builder().put(REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING_KEY, "-1").build();
+        assertEquals(-1, REPLICA_BATCH_ALLOCATOR_TIMEOUT_SETTING.get(build).getMillis());
+    }
+
+    public void testCollectTimedOutShards() throws InterruptedException {
+        createIndexAndUpdateClusterState(2, 5, 2);
+        CountDownLatch latch = new CountDownLatch(10);
+        testShardsBatchGatewayAllocator = new TestShardBatchGatewayAllocator(latch);
+        testShardsBatchGatewayAllocator.setPrimaryBatchAllocatorTimeout(TimeValue.ZERO);
+        testShardsBatchGatewayAllocator.setReplicaBatchAllocatorTimeout(TimeValue.ZERO);
+        BatchRunnableExecutor executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, true);
+        executor.run();
+        assertTrue(latch.await(1, TimeUnit.MINUTES));
+        latch = new CountDownLatch(10);
+        testShardsBatchGatewayAllocator = new TestShardBatchGatewayAllocator(latch);
+        testShardsBatchGatewayAllocator.setPrimaryBatchAllocatorTimeout(TimeValue.ZERO);
+        testShardsBatchGatewayAllocator.setReplicaBatchAllocatorTimeout(TimeValue.ZERO);
+        executor = testShardsBatchGatewayAllocator.allocateAllUnassignedShards(testAllocation, false);
+        executor.run();
+        assertTrue(latch.await(1, TimeUnit.MINUTES));
+    }
+
     private void createIndexAndUpdateClusterState(int count, int numberOfShards, int numberOfReplicas) {
         if (count == 0) return;
         Metadata.Builder metadata = Metadata.builder();
@@ -345,6 +475,59 @@ private void createIndexAndUpdateClusterState(int count, int numberOfShards, int
         );
     }
 
+    private void createRoutingWithDifferentUnAssignedInfo(ShardId primaryShardId, DiscoveryNode node, int numberOfReplicas) {
+
+        ShardRouting primaryShard = TestShardRouting.newShardRouting(primaryShardId, node.getId(), true, ShardRoutingState.STARTED);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(primaryShardId.getIndexName())
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(1)
+                    .numberOfReplicas(numberOfReplicas)
+                    .putInSyncAllocationIds(0, Sets.newHashSet(primaryShard.allocationId().getId()))
+            )
+            .build();
+
+        IndexRoutingTable.Builder isd = IndexRoutingTable.builder(primaryShardId.getIndex())
+            .addIndexShard(new IndexShardRoutingTable.Builder(primaryShardId).addShard(primaryShard).build());
+
+        for (int i = 0; i < numberOfReplicas; i++) {
+            isd.addShard(
+                ShardRouting.newUnassigned(
+                    primaryShardId,
+                    false,
+                    RecoverySource.PeerRecoverySource.INSTANCE,
+                    new UnassignedInfo(
+                        UnassignedInfo.Reason.REPLICA_ADDED,
+                        "message for replica-copy " + i,
+                        null,
+                        0,
+                        System.nanoTime(),
+                        System.currentTimeMillis(),
+                        false,
+                        UnassignedInfo.AllocationStatus.NO_ATTEMPT,
+                        Collections.emptySet()
+                    )
+                )
+            );
+        }
+
+        RoutingTable routingTable = RoutingTable.builder().add(isd).build();
+        clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .build();
+        testAllocation = new RoutingAllocation(
+            new AllocationDeciders(Collections.emptyList()),
+            new RoutingNodes(clusterState, false),
+            clusterState,
+            ClusterInfo.EMPTY,
+            SnapshotShardSizeInfo.EMPTY,
+            System.nanoTime()
+        );
+
+    }
+
     // call this after index creation and update cluster state
     private Tuple<Set<String>, Set<String>> createBatchesAndAssert(int expectedBatchSize) {
         Set<String> primaryBatches = testShardsBatchGatewayAllocator.createAndUpdateBatches(testAllocation, true);
diff --git a/server/src/test/java/org/opensearch/gateway/GatewayMetaStatePersistedStateTests.java b/server/src/test/java/org/opensearch/gateway/GatewayMetaStatePersistedStateTests.java
index 3ba98c44f8d3e..9972bbfff5d66 100644
--- a/server/src/test/java/org/opensearch/gateway/GatewayMetaStatePersistedStateTests.java
+++ b/server/src/test/java/org/opensearch/gateway/GatewayMetaStatePersistedStateTests.java
@@ -68,10 +68,12 @@
 import org.opensearch.gateway.PersistedClusterStateService.Writer;
 import org.opensearch.gateway.remote.ClusterMetadataManifest;
 import org.opensearch.gateway.remote.RemoteClusterStateService;
-import org.opensearch.gateway.remote.RemotePersistenceStats;
+import org.opensearch.gateway.remote.RemoteUploadStats;
+import org.opensearch.gateway.remote.model.RemoteClusterStateManifestInfo;
 import org.opensearch.index.recovery.RemoteStoreRestoreService;
 import org.opensearch.index.recovery.RemoteStoreRestoreService.RemoteRestoreResult;
 import org.opensearch.index.remote.RemoteIndexPathUploader;
+import org.opensearch.indices.DefaultRemoteStoreSettings;
 import org.opensearch.node.Node;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.fs.FsRepository;
@@ -97,6 +99,8 @@
 import org.mockito.Mockito;
 
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_INDEX_UUID;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V1;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.MANIFEST_CURRENT_CODEC_VERSION;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
@@ -108,7 +112,8 @@
 import static org.hamcrest.Matchers.nullValue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -212,6 +217,18 @@ private ClusterState createClusterState(long version, Metadata metadata) {
             .build();
     }
 
+    private ClusterState createClusterStateWithNodes(long version, Metadata metadata) {
+        DiscoveryNode oldNode = new DiscoveryNode(
+            "node2",
+            buildNewFakeTransportAddress(),
+            Collections.emptyMap(),
+            Sets.newHashSet(DiscoveryNodeRole.CLUSTER_MANAGER_ROLE),
+            Version.V_2_13_0
+        );
+        DiscoveryNodes discoveryNodes = DiscoveryNodes.builder().add(localNode).localNodeId(localNode.getId()).add(oldNode).build();
+        return ClusterState.builder(clusterName).nodes(discoveryNodes).version(version).metadata(metadata).build();
+    }
+
     private CoordinationMetadata createCoordinationMetadata(long term) {
         CoordinationMetadata.Builder builder = CoordinationMetadata.builder();
         builder.term(term);
@@ -462,9 +479,7 @@ public void testDataOnlyNodePersistence() throws Exception {
             });
             when(transportService.getThreadPool()).thenReturn(threadPool);
             ClusterService clusterService = mock(ClusterService.class);
-            when(clusterService.getClusterSettings()).thenReturn(
-                new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
-            );
+            when(clusterService.getClusterSettings()).thenReturn(new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS));
             final PersistedClusterStateService persistedClusterStateService = new PersistedClusterStateService(
                 nodeEnvironment,
                 xContentRegistry(),
@@ -487,10 +502,19 @@ public void testDataOnlyNodePersistence() throws Exception {
                         nodeEnvironment.nodeId(),
                         repositoriesServiceSupplier,
                         settings,
-                        clusterSettings,
+                        clusterService,
                         () -> 0L,
                         threadPool,
-                        List.of(new RemoteIndexPathUploader(threadPool, settings, repositoriesServiceSupplier, clusterSettings))
+                        List.of(
+                            new RemoteIndexPathUploader(
+                                threadPool,
+                                settings,
+                                repositoriesServiceSupplier,
+                                clusterSettings,
+                                DefaultRemoteStoreSettings.INSTANCE
+                            )
+                        ),
+                        writableRegistry()
                     );
                 } else {
                     return null;
@@ -725,9 +749,11 @@ public void testRemotePersistedState() throws IOException {
         final RemoteClusterStateService remoteClusterStateService = Mockito.mock(RemoteClusterStateService.class);
         final ClusterMetadataManifest manifest = ClusterMetadataManifest.builder().clusterTerm(1L).stateVersion(5L).build();
         final String previousClusterUUID = "prev-cluster-uuid";
-        Mockito.when(remoteClusterStateService.writeFullMetadata(Mockito.any(), Mockito.any())).thenReturn(manifest);
+        Mockito.when(remoteClusterStateService.writeFullMetadata(Mockito.any(), Mockito.any(), eq(MANIFEST_CURRENT_CODEC_VERSION)))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest, "path/to/manifest"));
 
-        Mockito.when(remoteClusterStateService.writeIncrementalMetadata(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(manifest);
+        Mockito.when(remoteClusterStateService.writeIncrementalMetadata(Mockito.any(), Mockito.any(), Mockito.any()))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest, "path/to/manifest"));
         CoordinationState.PersistedState remotePersistedState = new RemotePersistedState(remoteClusterStateService, previousClusterUUID);
 
         assertThat(remotePersistedState.getLastAcceptedState(), nullValue());
@@ -740,7 +766,7 @@ public void testRemotePersistedState() throws IOException {
         );
 
         remotePersistedState.setLastAcceptedState(clusterState);
-        Mockito.verify(remoteClusterStateService).writeFullMetadata(clusterState, previousClusterUUID);
+        Mockito.verify(remoteClusterStateService).writeFullMetadata(clusterState, previousClusterUUID, MANIFEST_CURRENT_CODEC_VERSION);
 
         assertThat(remotePersistedState.getLastAcceptedState(), equalTo(clusterState));
         assertThat(remotePersistedState.getCurrentTerm(), equalTo(clusterTerm));
@@ -751,11 +777,15 @@ public void testRemotePersistedState() throws IOException {
         );
 
         remotePersistedState.setLastAcceptedState(secondClusterState);
-        Mockito.verify(remoteClusterStateService, times(1)).writeFullMetadata(secondClusterState, previousClusterUUID);
+        Mockito.verify(remoteClusterStateService, times(1))
+            .writeFullMetadata(secondClusterState, previousClusterUUID, MANIFEST_CURRENT_CODEC_VERSION);
 
         assertThat(remotePersistedState.getLastAcceptedState(), equalTo(secondClusterState));
         assertThat(remotePersistedState.getCurrentTerm(), equalTo(clusterTerm));
 
+        when(remoteClusterStateService.markLastStateAsCommitted(Mockito.any(), Mockito.any())).thenReturn(
+            new RemoteClusterStateManifestInfo(manifest, "path/to/manifest")
+        );
         remotePersistedState.markLastAcceptedStateAsCommitted();
         Mockito.verify(remoteClusterStateService, times(1)).markLastStateAsCommitted(Mockito.any(), Mockito.any());
 
@@ -771,6 +801,54 @@ public void testRemotePersistedState() throws IOException {
         assertThat(remotePersistedState.getLastAcceptedState().metadata().clusterUUIDCommitted(), equalTo(true));
     }
 
+    public void testRemotePersistedStateWithDifferentNodeConfiguration() throws IOException {
+        final RemoteClusterStateService remoteClusterStateService = Mockito.mock(RemoteClusterStateService.class);
+        final String previousClusterUUID = "prev-cluster-uuid";
+        final ClusterMetadataManifest manifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(5L)
+            .codecVersion(CODEC_V1)
+            .opensearchVersion(Version.CURRENT)
+            .build();
+        Mockito.when(remoteClusterStateService.writeFullMetadata(Mockito.any(), Mockito.any(), eq(CODEC_V1)))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest, "path/to/manifest2"));
+
+        CoordinationState.PersistedState remotePersistedState = new RemotePersistedState(remoteClusterStateService, previousClusterUUID);
+
+        ClusterState clusterState1 = createClusterStateWithNodes(
+            randomNonNegativeLong(),
+            Metadata.builder().coordinationMetadata(CoordinationMetadata.builder().term(1L).build()).build()
+        );
+        remotePersistedState.setLastAcceptedState(clusterState1);
+
+        Mockito.verify(remoteClusterStateService).writeFullMetadata(clusterState1, previousClusterUUID, CODEC_V1);
+
+        ClusterState clusterState2 = createClusterState(
+            randomNonNegativeLong(),
+            Metadata.builder().coordinationMetadata(CoordinationMetadata.builder().term(1L).build()).build()
+        );
+        final ClusterMetadataManifest manifest2 = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(5L)
+            .codecVersion(MANIFEST_CURRENT_CODEC_VERSION)
+            .opensearchVersion(Version.CURRENT)
+            .build();
+        Mockito.when(remoteClusterStateService.writeFullMetadata(Mockito.any(), Mockito.any(), eq(MANIFEST_CURRENT_CODEC_VERSION)))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest2, "path/to/manifest"));
+        remotePersistedState.setLastAcceptedState(clusterState2);
+        Mockito.verify(remoteClusterStateService).writeFullMetadata(clusterState2, previousClusterUUID, MANIFEST_CURRENT_CODEC_VERSION);
+
+        ClusterState clusterState3 = createClusterState(
+            randomNonNegativeLong(),
+            Metadata.builder().coordinationMetadata(CoordinationMetadata.builder().term(1L).build()).build()
+        );
+        Mockito.when(remoteClusterStateService.writeIncrementalMetadata(Mockito.any(), Mockito.any(), Mockito.any()))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest2, "path/to/manifest3"));
+        remotePersistedState.setLastAcceptedState(clusterState3);
+        Mockito.verify(remoteClusterStateService).writeIncrementalMetadata(clusterState2, clusterState3, manifest2);
+
+    }
+
     public void testRemotePersistedStateNotCommitted() throws IOException {
         final RemoteClusterStateService remoteClusterStateService = Mockito.mock(RemoteClusterStateService.class);
         final String previousClusterUUID = "prev-cluster-uuid";
@@ -781,9 +859,11 @@ public void testRemotePersistedStateNotCommitted() throws IOException {
             .build();
         Mockito.when(remoteClusterStateService.getLatestClusterMetadataManifest(Mockito.any(), Mockito.any()))
             .thenReturn(Optional.of(manifest));
-        Mockito.when(remoteClusterStateService.writeFullMetadata(Mockito.any(), Mockito.any())).thenReturn(manifest);
+        Mockito.when(remoteClusterStateService.writeFullMetadata(Mockito.any(), Mockito.any(), eq(MANIFEST_CURRENT_CODEC_VERSION)))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest, "path/to/manifest"));
 
-        Mockito.when(remoteClusterStateService.writeIncrementalMetadata(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(manifest);
+        Mockito.when(remoteClusterStateService.writeIncrementalMetadata(Mockito.any(), Mockito.any(), Mockito.any()))
+            .thenReturn(new RemoteClusterStateManifestInfo(manifest, "path/to/manifest"));
         CoordinationState.PersistedState remotePersistedState = new RemotePersistedState(
             remoteClusterStateService,
             ClusterState.UNKNOWN_UUID
@@ -804,14 +884,17 @@ public void testRemotePersistedStateNotCommitted() throws IOException {
         remotePersistedState.setLastAcceptedState(clusterState);
         ArgumentCaptor<String> previousClusterUUIDCaptor = ArgumentCaptor.forClass(String.class);
         ArgumentCaptor<ClusterState> clusterStateCaptor = ArgumentCaptor.forClass(ClusterState.class);
-        Mockito.verify(remoteClusterStateService).writeFullMetadata(clusterStateCaptor.capture(), previousClusterUUIDCaptor.capture());
+        Mockito.verify(remoteClusterStateService)
+            .writeFullMetadata(clusterStateCaptor.capture(), previousClusterUUIDCaptor.capture(), eq(MANIFEST_CURRENT_CODEC_VERSION));
         assertEquals(previousClusterUUID, previousClusterUUIDCaptor.getValue());
     }
 
     public void testRemotePersistedStateExceptionOnFullStateUpload() throws IOException {
         final RemoteClusterStateService remoteClusterStateService = Mockito.mock(RemoteClusterStateService.class);
         final String previousClusterUUID = "prev-cluster-uuid";
-        Mockito.doThrow(IOException.class).when(remoteClusterStateService).writeFullMetadata(Mockito.any(), Mockito.any());
+        Mockito.doThrow(IOException.class)
+            .when(remoteClusterStateService)
+            .writeFullMetadata(Mockito.any(), Mockito.any(), eq(MANIFEST_CURRENT_CODEC_VERSION));
 
         CoordinationState.PersistedState remotePersistedState = new RemotePersistedState(remoteClusterStateService, previousClusterUUID);
 
@@ -825,12 +908,17 @@ public void testRemotePersistedStateExceptionOnFullStateUpload() throws IOExcept
     }
 
     public void testRemotePersistedStateFailureStats() throws IOException {
-        RemotePersistenceStats remoteStateStats = new RemotePersistenceStats();
+        RemoteUploadStats remoteStateStats = new RemoteUploadStats();
         final RemoteClusterStateService remoteClusterStateService = Mockito.mock(RemoteClusterStateService.class);
         final String previousClusterUUID = "prev-cluster-uuid";
-        Mockito.doThrow(IOException.class).when(remoteClusterStateService).writeFullMetadata(Mockito.any(), Mockito.any());
-        when(remoteClusterStateService.getStats()).thenReturn(remoteStateStats);
-        doCallRealMethod().when(remoteClusterStateService).writeMetadataFailed();
+        Mockito.doThrow(IOException.class)
+            .when(remoteClusterStateService)
+            .writeFullMetadata(Mockito.any(), Mockito.any(), eq(MANIFEST_CURRENT_CODEC_VERSION));
+        when(remoteClusterStateService.getUploadStats()).thenReturn(remoteStateStats);
+        doAnswer((i) -> {
+            remoteStateStats.stateFailed();
+            return null;
+        }).when(remoteClusterStateService).writeMetadataFailed();
         CoordinationState.PersistedState remotePersistedState = new RemotePersistedState(remoteClusterStateService, previousClusterUUID);
 
         final long clusterTerm = randomNonNegativeLong();
@@ -840,8 +928,8 @@ public void testRemotePersistedStateFailureStats() throws IOException {
         );
 
         assertThrows(OpenSearchException.class, () -> remotePersistedState.setLastAcceptedState(clusterState));
-        assertEquals(1, remoteClusterStateService.getStats().getFailedCount());
-        assertEquals(0, remoteClusterStateService.getStats().getSuccessCount());
+        assertEquals(1, remoteClusterStateService.getUploadStats().getFailedCount());
+        assertEquals(0, remoteClusterStateService.getUploadStats().getSuccessCount());
     }
 
     public void testGatewayForRemoteState() throws IOException {
diff --git a/server/src/test/java/org/opensearch/gateway/GatewayServiceTests.java b/server/src/test/java/org/opensearch/gateway/GatewayServiceTests.java
index c448c4b07e03b..59fb7df5428e2 100644
--- a/server/src/test/java/org/opensearch/gateway/GatewayServiceTests.java
+++ b/server/src/test/java/org/opensearch/gateway/GatewayServiceTests.java
@@ -53,6 +53,7 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.common.transport.TransportAddress;
 import org.opensearch.snapshots.EmptySnapshotsInfoService;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.gateway.TestGatewayAllocator;
 import org.hamcrest.Matchers;
@@ -68,7 +69,7 @@
 public class GatewayServiceTests extends OpenSearchTestCase {
 
     private GatewayService createService(final Settings.Builder settings) {
-        final ClusterService clusterService = new ClusterService(
+        final ClusterService clusterService = ClusterServiceUtils.createClusterService(
             Settings.builder().put("cluster.name", "GatewayServiceTests").build(),
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             null
diff --git a/server/src/test/java/org/opensearch/gateway/PrimaryShardBatchAllocatorTests.java b/server/src/test/java/org/opensearch/gateway/PrimaryShardBatchAllocatorTests.java
index 522ad2a64ea5d..2edde8281b11a 100644
--- a/server/src/test/java/org/opensearch/gateway/PrimaryShardBatchAllocatorTests.java
+++ b/server/src/test/java/org/opensearch/gateway/PrimaryShardBatchAllocatorTests.java
@@ -9,6 +9,7 @@
 
 import org.apache.lucene.codecs.Codec;
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterInfo;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.OpenSearchAllocationTestCase;
@@ -19,12 +20,15 @@
 import org.opensearch.cluster.routing.RoutingNodes;
 import org.opensearch.cluster.routing.RoutingTable;
 import org.opensearch.cluster.routing.ShardRouting;
+import org.opensearch.cluster.routing.ShardRoutingState;
 import org.opensearch.cluster.routing.UnassignedInfo;
 import org.opensearch.cluster.routing.allocation.AllocateUnassignedDecision;
 import org.opensearch.cluster.routing.allocation.AllocationDecision;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
 import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
+import org.opensearch.cluster.routing.allocation.decider.ThrottlingAllocationDecider;
 import org.opensearch.common.Nullable;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.set.Sets;
 import org.opensearch.core.index.shard.ShardId;
@@ -44,8 +48,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import static org.opensearch.cluster.routing.UnassignedInfo.Reason.CLUSTER_RECOVERED;
+import static org.opensearch.cluster.routing.UnassignedInfo.Reason.INDEX_CREATED;
 
 public class PrimaryShardBatchAllocatorTests extends OpenSearchAllocationTestCase {
 
@@ -80,49 +86,38 @@ private void allocateAllUnassignedBatch(final RoutingAllocation allocation) {
         final RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
         List<ShardRouting> shardsToBatch = new ArrayList<>();
         while (iterator.hasNext()) {
-            shardsToBatch.add(iterator.next());
+            ShardRouting unassignedShardRouting = iterator.next();
+            if (unassignedShardRouting.primary()) {
+                shardsToBatch.add(unassignedShardRouting);
+            }
         }
         batchAllocator.allocateUnassignedBatch(shardsToBatch, allocation);
     }
 
     public void testMakeAllocationDecisionDataFetching() {
         final RoutingAllocation allocation = routingAllocationWithOnePrimary(noAllocationDeciders(), CLUSTER_RECOVERED, "allocId1");
-
-        List<ShardRouting> shards = new ArrayList<>();
-        allocateAllUnassignedBatch(allocation);
         ShardRouting shard = allocation.routingTable().getIndicesRouting().get("test").shard(shardId.id()).primaryShard();
-        shards.add(shard);
-        HashMap<ShardRouting, AllocateUnassignedDecision> allDecisions = batchAllocator.makeAllocationDecision(shards, allocation, logger);
-        // verify we get decisions for all the shards
-        assertEquals(shards.size(), allDecisions.size());
-        assertEquals(shards, new ArrayList<>(allDecisions.keySet()));
-        assertEquals(AllocationDecision.AWAITING_INFO, allDecisions.get(shard).getAllocationDecision());
+        AllocateUnassignedDecision allocateUnassignedDecision = batchAllocator.makeAllocationDecision(shard, allocation, logger);
+        assertEquals(AllocationDecision.AWAITING_INFO, allocateUnassignedDecision.getAllocationDecision());
     }
 
     public void testMakeAllocationDecisionForReplicaShard() {
         final RoutingAllocation allocation = routingAllocationWithOnePrimary(noAllocationDeciders(), CLUSTER_RECOVERED, "allocId1");
 
         List<ShardRouting> replicaShards = allocation.routingTable().getIndicesRouting().get("test").shard(shardId.id()).replicaShards();
-        List<ShardRouting> shards = new ArrayList<>(replicaShards);
-        HashMap<ShardRouting, AllocateUnassignedDecision> allDecisions = batchAllocator.makeAllocationDecision(shards, allocation, logger);
-        // verify we get decisions for all the shards
-        assertEquals(shards.size(), allDecisions.size());
-        assertEquals(shards, new ArrayList<>(allDecisions.keySet()));
-        assertFalse(allDecisions.get(replicaShards.get(0)).isDecisionTaken());
+        for (ShardRouting shardRouting : replicaShards) {
+            AllocateUnassignedDecision allocateUnassignedDecision = batchAllocator.makeAllocationDecision(shardRouting, allocation, logger);
+            assertFalse(allocateUnassignedDecision.isDecisionTaken());
+        }
     }
 
     public void testMakeAllocationDecisionDataFetched() {
         final RoutingAllocation allocation = routingAllocationWithOnePrimary(noAllocationDeciders(), CLUSTER_RECOVERED, "allocId1");
 
-        List<ShardRouting> shards = new ArrayList<>();
         ShardRouting shard = allocation.routingTable().getIndicesRouting().get("test").shard(shardId.id()).primaryShard();
-        shards.add(shard);
         batchAllocator.addData(node1, "allocId1", true, new ReplicationCheckpoint(shardId, 20, 101, 1, Codec.getDefault().getName()));
-        HashMap<ShardRouting, AllocateUnassignedDecision> allDecisions = batchAllocator.makeAllocationDecision(shards, allocation, logger);
-        // verify we get decisions for all the shards
-        assertEquals(shards.size(), allDecisions.size());
-        assertEquals(shards, new ArrayList<>(allDecisions.keySet()));
-        assertEquals(AllocationDecision.YES, allDecisions.get(shard).getAllocationDecision());
+        AllocateUnassignedDecision allocateUnassignedDecision = batchAllocator.makeAllocationDecision(shard, allocation, logger);
+        assertEquals(AllocationDecision.YES, allocateUnassignedDecision.getAllocationDecision());
     }
 
     public void testMakeAllocationDecisionDataFetchedMultipleShards() {
@@ -149,13 +144,159 @@ public void testMakeAllocationDecisionDataFetchedMultipleShards() {
                 null
             );
         }
-        HashMap<ShardRouting, AllocateUnassignedDecision> allDecisions = batchAllocator.makeAllocationDecision(shards, allocation, logger);
-        // verify we get decisions for all the shards
-        assertEquals(shards.size(), allDecisions.size());
-        assertEquals(new HashSet<>(shards), allDecisions.keySet());
-        for (ShardRouting shard : shards) {
-            assertEquals(AllocationDecision.YES, allDecisions.get(shard).getAllocationDecision());
+        for (ShardRouting shardRouting : shards) {
+            AllocateUnassignedDecision allocateUnassignedDecision = batchAllocator.makeAllocationDecision(shardRouting, allocation, logger);
+            assertEquals(AllocationDecision.YES, allocateUnassignedDecision.getAllocationDecision());
+        }
+    }
+
+    public void testInitializePrimaryShards() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        AllocationDeciders allocationDeciders = randomAllocationDeciders(Settings.builder().build(), clusterSettings, random());
+        setUpShards(2);
+        final RoutingAllocation routingAllocation = routingAllocationWithMultiplePrimaries(
+            allocationDeciders,
+            CLUSTER_RECOVERED,
+            2,
+            0,
+            "allocId-0",
+            "allocId-1"
+        );
+
+        for (ShardId shardId : shardsInBatch) {
+            batchAllocator.addShardData(
+                node1,
+                "allocId-" + shardId.id(),
+                shardId,
+                true,
+                new ReplicationCheckpoint(shardId, 20, 101, 1, Codec.getDefault().getName()),
+                null
+            );
         }
+
+        allocateAllUnassignedBatch(routingAllocation);
+
+        assertEquals(0, routingAllocation.routingNodes().unassigned().size());
+        List<ShardRouting> initializingShards = routingAllocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING);
+        assertEquals(2, initializingShards.size());
+        assertTrue(shardsInBatch.contains(initializingShards.get(0).shardId()));
+        assertTrue(shardsInBatch.contains(initializingShards.get(1).shardId()));
+        assertEquals(2, routingAllocation.routingNodes().getInitialPrimariesIncomingRecoveries(node1.getId()));
+    }
+
+    public void testInitializeOnlyPrimaryUnassignedShardsIgnoreReplicaShards() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        AllocationDeciders allocationDeciders = randomAllocationDeciders(Settings.builder().build(), clusterSettings, random());
+        setUpShards(1);
+        final RoutingAllocation routingAllocation = routingAllocationWithOnePrimary(allocationDeciders, CLUSTER_RECOVERED, "allocId-0");
+
+        for (ShardId shardId : shardsInBatch) {
+            batchAllocator.addShardData(
+                node1,
+                "allocId-0",
+                shardId,
+                true,
+                new ReplicationCheckpoint(shardId, 20, 101, 1, Codec.getDefault().getName()),
+                null
+            );
+        }
+
+        allocateAllUnassignedBatch(routingAllocation);
+
+        List<ShardRouting> initializingShards = routingAllocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING);
+        assertEquals(1, initializingShards.size());
+        assertTrue(shardsInBatch.contains(initializingShards.get(0).shardId()));
+        assertTrue(initializingShards.get(0).primary());
+        assertEquals(1, routingAllocation.routingNodes().getInitialPrimariesIncomingRecoveries(node1.getId()));
+        List<ShardRouting> unassignedShards = routingAllocation.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED);
+        assertEquals(1, unassignedShards.size());
+        assertTrue(!unassignedShards.get(0).primary());
+    }
+
+    public void testAllocateUnassignedBatchThrottlingAllocationDeciderIsHonoured() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        AllocationDeciders allocationDeciders = randomAllocationDeciders(
+            Settings.builder()
+                .put(ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_INITIAL_PRIMARIES_RECOVERIES_SETTING.getKey(), 1)
+                .build(),
+            clusterSettings,
+            random()
+        );
+        setUpShards(2);
+        final RoutingAllocation routingAllocation = routingAllocationWithMultiplePrimaries(
+            allocationDeciders,
+            CLUSTER_RECOVERED,
+            2,
+            0,
+            "allocId-0",
+            "allocId-1"
+        );
+
+        for (ShardId shardId : shardsInBatch) {
+            batchAllocator.addShardData(
+                node1,
+                "allocId-" + shardId.id(),
+                shardId,
+                true,
+                new ReplicationCheckpoint(shardId, 20, 101, 1, Codec.getDefault().getName()),
+                null
+            );
+        }
+
+        allocateAllUnassignedBatch(routingAllocation);
+
+        // Verify the throttling decider was not throttled, recovering shards on node greater than initial concurrent recovery setting
+        assertEquals(1, routingAllocation.routingNodes().getInitialPrimariesIncomingRecoveries(node1.getId()));
+        List<ShardRouting> initializingShards = routingAllocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING);
+        assertEquals(1, initializingShards.size());
+        Set<String> nodesWithInitialisingShards = initializingShards.stream().map(ShardRouting::currentNodeId).collect(Collectors.toSet());
+        assertEquals(1, nodesWithInitialisingShards.size());
+        assertEquals(Collections.singleton(node1.getId()), nodesWithInitialisingShards);
+        List<ShardRouting> ignoredShards = routingAllocation.routingNodes().unassigned().ignored();
+        assertEquals(1, ignoredShards.size());
+        assertEquals(UnassignedInfo.AllocationStatus.DECIDERS_THROTTLED, ignoredShards.get(0).unassignedInfo().getLastAllocationStatus());
+    }
+
+    public void testAllocateUnassignedBatchOnTimeoutWithMatchingPrimaryShards() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        AllocationDeciders allocationDeciders = randomAllocationDeciders(Settings.builder().build(), clusterSettings, random());
+        setUpShards(1);
+        final RoutingAllocation routingAllocation = routingAllocationWithOnePrimary(allocationDeciders, CLUSTER_RECOVERED, "allocId-0");
+        ShardRouting shardRouting = routingAllocation.routingTable().getIndicesRouting().get("test").shard(shardId.id()).primaryShard();
+
+        Set<ShardId> shardIds = new HashSet<>();
+        shardIds.add(shardRouting.shardId());
+        batchAllocator.allocateUnassignedBatchOnTimeout(shardIds, routingAllocation, true);
+
+        List<ShardRouting> ignoredShards = routingAllocation.routingNodes().unassigned().ignored();
+        assertEquals(1, ignoredShards.size());
+        assertEquals(UnassignedInfo.AllocationStatus.DECIDERS_THROTTLED, ignoredShards.get(0).unassignedInfo().getLastAllocationStatus());
+    }
+
+    public void testAllocateUnassignedBatchOnTimeoutWithNoMatchingPrimaryShards() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        AllocationDeciders allocationDeciders = randomAllocationDeciders(Settings.builder().build(), clusterSettings, random());
+        setUpShards(1);
+        final RoutingAllocation routingAllocation = routingAllocationWithOnePrimary(allocationDeciders, CLUSTER_RECOVERED, "allocId-0");
+        batchAllocator.allocateUnassignedBatchOnTimeout(new HashSet<>(), routingAllocation, true);
+
+        List<ShardRouting> ignoredShards = routingAllocation.routingNodes().unassigned().ignored();
+        assertEquals(0, ignoredShards.size());
+    }
+
+    public void testAllocateUnassignedBatchOnTimeoutSkipIgnoringNewPrimaryShards() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        AllocationDeciders allocationDeciders = randomAllocationDeciders(Settings.builder().build(), clusterSettings, random());
+        setUpShards(1);
+        final RoutingAllocation routingAllocation = routingAllocationWithOnePrimary(allocationDeciders, INDEX_CREATED);
+        ShardRouting shardRouting = routingAllocation.routingTable().getIndicesRouting().get("test").shard(shardId.id()).primaryShard();
+
+        Set<ShardId> shardIds = new HashSet<>();
+        shardIds.add(shardRouting.shardId());
+        batchAllocator.allocateUnassignedBatchOnTimeout(shardIds, routingAllocation, true);
+
+        List<ShardRouting> ignoredShards = routingAllocation.routingNodes().unassigned().ignored();
+        assertEquals(0, ignoredShards.size());
     }
 
     private RoutingAllocation routingAllocationWithOnePrimary(
@@ -192,7 +333,7 @@ private RoutingAllocation routingAllocationWithOnePrimary(
             .routingTable(routingTableBuilder.build())
             .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
             .build();
-        return new RoutingAllocation(deciders, new RoutingNodes(state, false), state, null, null, System.nanoTime());
+        return new RoutingAllocation(deciders, new RoutingNodes(state, false), state, ClusterInfo.EMPTY, null, System.nanoTime());
     }
 
     private RoutingAllocation routingAllocationWithMultiplePrimaries(
@@ -235,7 +376,7 @@ private RoutingAllocation routingAllocationWithMultiplePrimaries(
             .routingTable(routingTableBuilder.build())
             .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
             .build();
-        return new RoutingAllocation(deciders, new RoutingNodes(state, false), state, null, null, System.nanoTime());
+        return new RoutingAllocation(deciders, new RoutingNodes(state, false), state, ClusterInfo.EMPTY, null, System.nanoTime());
     }
 
     class TestBatchAllocator extends PrimaryShardBatchAllocator {
diff --git a/server/src/test/java/org/opensearch/gateway/ReplicaShardBatchAllocatorTests.java b/server/src/test/java/org/opensearch/gateway/ReplicaShardBatchAllocatorTests.java
index 464038c93228b..988723e023a2a 100644
--- a/server/src/test/java/org/opensearch/gateway/ReplicaShardBatchAllocatorTests.java
+++ b/server/src/test/java/org/opensearch/gateway/ReplicaShardBatchAllocatorTests.java
@@ -28,16 +28,19 @@
 import org.opensearch.cluster.routing.ShardRoutingState;
 import org.opensearch.cluster.routing.TestShardRouting;
 import org.opensearch.cluster.routing.UnassignedInfo;
+import org.opensearch.cluster.routing.allocation.AllocateUnassignedDecision;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
 import org.opensearch.cluster.routing.allocation.decider.AllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
 import org.opensearch.cluster.routing.allocation.decider.Decision;
 import org.opensearch.cluster.routing.allocation.decider.SameShardAllocationDecider;
+import org.opensearch.cluster.routing.allocation.decider.ThrottlingAllocationDecider;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.set.Sets;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.engine.Engine;
 import org.opensearch.index.seqno.ReplicationTracker;
@@ -72,6 +75,7 @@ public class ReplicaShardBatchAllocatorTests extends OpenSearchAllocationTestCas
     private static final org.apache.lucene.util.Version MIN_SUPPORTED_LUCENE_VERSION = org.opensearch.Version.CURRENT
         .minimumIndexCompatibilityVersion().luceneVersion;
     private final ShardId shardId = new ShardId("test", "_na_", 0);
+    private static Set<ShardId> shardsInBatch;
     private final DiscoveryNode node1 = newNode("node1");
     private final DiscoveryNode node2 = newNode("node2");
     private final DiscoveryNode node3 = newNode("node3");
@@ -83,6 +87,14 @@ public void buildTestAllocator() {
         this.testBatchAllocator = new TestBatchAllocator();
     }
 
+    public static void setUpShards(int numberOfShards) {
+        shardsInBatch = new HashSet<>();
+        for (int shardNumber = 0; shardNumber < numberOfShards; shardNumber++) {
+            ShardId shardId = new ShardId("test", "_na_", shardNumber);
+            shardsInBatch.add(shardId);
+        }
+    }
+
     private void allocateAllUnassignedBatch(final RoutingAllocation allocation) {
         final RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
         List<ShardRouting> shardToBatch = new ArrayList<>();
@@ -115,8 +127,6 @@ public void testAsyncFetchWithNoShardOnIndexCreation() {
         );
         testBatchAllocator.clean();
         allocateAllUnassignedBatch(allocation);
-        assertThat(testBatchAllocator.getFetchDataCalledAndClean(), equalTo(false));
-        assertThat(testBatchAllocator.getShardEligibleFetchDataCountAndClean(), equalTo(0));
         assertThat(allocation.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED).size(), equalTo(1));
         assertThat(allocation.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED).get(0).shardId(), equalTo(shardId));
     }
@@ -634,6 +644,124 @@ public void testDoNotCancelForBrokenNode() {
         assertThat(allocation.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED), empty());
     }
 
+    public void testDoNotCancelForInactivePrimaryNode() {
+        RoutingAllocation allocation = oneInactivePrimaryOnNode1And1ReplicaRecovering(yesAllocationDeciders(), null);
+        testBatchAllocator.addData(
+            node1,
+            null,
+            "MATCH",
+            null,
+            new StoreFileMetadata("file1", 10, "MATCH_CHECKSUM", MIN_SUPPORTED_LUCENE_VERSION)
+        ).addData(node2, randomSyncId(), null, new StoreFileMetadata("file1", 10, "MATCH_CHECKSUM", MIN_SUPPORTED_LUCENE_VERSION));
+
+        testBatchAllocator.processExistingRecoveries(
+            allocation,
+            Collections.singletonList(new ArrayList<>(allocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING)))
+        );
+
+        assertThat(allocation.routingNodesChanged(), equalTo(false));
+        assertThat(allocation.routingNodes().shardsWithState(ShardRoutingState.UNASSIGNED), empty());
+    }
+
+    public void testAllocateUnassignedBatchThrottlingAllocationDeciderIsHonoured() throws InterruptedException {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        AllocationDeciders allocationDeciders = randomAllocationDeciders(
+            Settings.builder()
+                .put(ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_RECOVERIES_SETTING.getKey(), 1)
+                .put(ThrottlingAllocationDecider.CLUSTER_ROUTING_ALLOCATION_NODE_CONCURRENT_INCOMING_RECOVERIES_SETTING.getKey(), 1)
+                .build(),
+            clusterSettings,
+            random()
+        );
+        setUpShards(2);
+        final RoutingAllocation routingAllocation = twoPrimaryAndOneUnAssignedReplica(allocationDeciders);
+        for (ShardId shardIdFromBatch : shardsInBatch) {
+            testBatchAllocator.addShardData(
+                node1,
+                shardIdFromBatch,
+                "MATCH",
+                null,
+                new StoreFileMetadata("file1", 10, "MATCH_CHECKSUM", MIN_SUPPORTED_LUCENE_VERSION)
+            )
+                .addShardData(
+                    node2,
+                    shardIdFromBatch,
+                    "NO_MATCH",
+                    null,
+                    new StoreFileMetadata("file1", 10, "MATCH_CHECKSUM", MIN_SUPPORTED_LUCENE_VERSION)
+                )
+                .addShardData(
+                    node3,
+                    shardIdFromBatch,
+                    "MATCH",
+                    null,
+                    new StoreFileMetadata("file1", 10, "MATCH_CHECKSUM", MIN_SUPPORTED_LUCENE_VERSION)
+                );
+        }
+        allocateAllUnassignedBatch(routingAllocation);
+        // Verify the throttling decider was throttled, incoming recoveries on a node should be
+        // lesser than or equal to allowed concurrent recoveries
+        assertEquals(0, routingAllocation.routingNodes().getIncomingRecoveries(node2.getId()));
+        assertEquals(1, routingAllocation.routingNodes().getIncomingRecoveries(node3.getId()));
+        List<ShardRouting> initializingShards = routingAllocation.routingNodes().shardsWithState(ShardRoutingState.INITIALIZING);
+        assertEquals(1, initializingShards.size());
+        List<ShardRouting> ignoredShardRoutings = routingAllocation.routingNodes().unassigned().ignored();
+        assertEquals(1, ignoredShardRoutings.size());
+        // Allocation status for ignored replicas shards is not updated after running the deciders they just get marked as ignored.
+        assertEquals(UnassignedInfo.AllocationStatus.NO_ATTEMPT, ignoredShardRoutings.get(0).unassignedInfo().getLastAllocationStatus());
+        AllocateUnassignedDecision allocateUnassignedDecision = testBatchAllocator.makeAllocationDecision(
+            ignoredShardRoutings.get(0),
+            routingAllocation,
+            logger
+        );
+        assertEquals(UnassignedInfo.AllocationStatus.DECIDERS_THROTTLED, allocateUnassignedDecision.getAllocationStatus());
+    }
+
+    public void testAllocateUnassignedBatchOnTimeoutWithUnassignedReplicaShard() {
+        RoutingAllocation allocation = onePrimaryOnNode1And1Replica(yesAllocationDeciders());
+        final RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
+        Set<ShardId> shards = new HashSet<>();
+        while (iterator.hasNext()) {
+            shards.add(iterator.next().shardId());
+        }
+        testBatchAllocator.allocateUnassignedBatchOnTimeout(shards, allocation, false);
+        assertThat(allocation.routingNodes().unassigned().ignored().size(), equalTo(1));
+        assertThat(allocation.routingNodes().unassigned().ignored().get(0).shardId(), equalTo(shardId));
+        assertEquals(
+            UnassignedInfo.AllocationStatus.NO_ATTEMPT,
+            allocation.routingNodes().unassigned().ignored().get(0).unassignedInfo().getLastAllocationStatus()
+        );
+    }
+
+    public void testAllocateUnassignedBatchOnTimeoutWithAlreadyRecoveringReplicaShard() {
+        RoutingAllocation allocation = onePrimaryOnNode1And1ReplicaRecovering(yesAllocationDeciders());
+        final RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
+        Set<ShardId> shards = new HashSet<>();
+        while (iterator.hasNext()) {
+            shards.add(iterator.next().shardId());
+        }
+        testBatchAllocator.allocateUnassignedBatchOnTimeout(shards, allocation, false);
+        assertThat(allocation.routingNodes().unassigned().ignored().size(), equalTo(0));
+    }
+
+    public void testAllocateUnassignedBatchOnTimeoutSkipIgnoringNewReplicaShards() {
+        RoutingAllocation allocation = onePrimaryOnNode1And1Replica(
+            yesAllocationDeciders(),
+            Settings.EMPTY,
+            UnassignedInfo.Reason.INDEX_CREATED
+        );
+        final RoutingNodes.UnassignedShards.UnassignedIterator iterator = allocation.routingNodes().unassigned().iterator();
+        Set<ShardId> shards = new HashSet<>();
+        while (iterator.hasNext()) {
+            ShardRouting sr = iterator.next();
+            if (sr.primary() == false) {
+                shards.add(sr.shardId());
+            }
+        }
+        testBatchAllocator.allocateUnassignedBatchOnTimeout(shards, allocation, false);
+        assertThat(allocation.routingNodes().unassigned().ignored().size(), equalTo(0));
+    }
+
     private RoutingAllocation onePrimaryOnNode1And1Replica(AllocationDeciders deciders) {
         return onePrimaryOnNode1And1Replica(deciders, Settings.EMPTY, UnassignedInfo.Reason.CLUSTER_RECOVERED);
     }
@@ -692,6 +820,77 @@ private RoutingAllocation onePrimaryOnNode1And1Replica(AllocationDeciders decide
         );
     }
 
+    private RoutingAllocation twoPrimaryAndOneUnAssignedReplica(AllocationDeciders deciders) throws InterruptedException {
+        Map<ShardId, ShardRouting> shardIdShardRoutingMap = new HashMap<>();
+        Index index = shardId.getIndex();
+
+        // Created started ShardRouting for each primary shards
+        for (ShardId shardIdFromBatch : shardsInBatch) {
+            shardIdShardRoutingMap.put(
+                shardIdFromBatch,
+                TestShardRouting.newShardRouting(shardIdFromBatch, node1.getId(), true, ShardRoutingState.STARTED)
+            );
+        }
+
+        // Create Index Metadata
+        IndexMetadata.Builder indexMetadata = IndexMetadata.builder(index.getName())
+            .settings(settings(Version.CURRENT).put(Settings.EMPTY))
+            .numberOfShards(2)
+            .numberOfReplicas(1);
+        for (ShardId shardIdFromBatch : shardsInBatch) {
+            indexMetadata.putInSyncAllocationIds(
+                shardIdFromBatch.id(),
+                Sets.newHashSet(shardIdShardRoutingMap.get(shardIdFromBatch).allocationId().getId())
+            );
+        }
+        Metadata metadata = Metadata.builder().put(indexMetadata).build();
+
+        // Create Index Routing table
+        IndexRoutingTable.Builder indexRoutingTableBuilder = IndexRoutingTable.builder(index);
+        for (ShardId shardIdFromBatch : shardsInBatch) {
+            IndexShardRoutingTable.Builder indexShardRoutingTableBuilder = new IndexShardRoutingTable.Builder(shardIdFromBatch);
+            // Add a primary shard in started state
+            indexShardRoutingTableBuilder.addShard(shardIdShardRoutingMap.get(shardIdFromBatch));
+            // Add replicas of primary shard in un-assigned state.
+            for (int i = 0; i < 1; i++) {
+                indexShardRoutingTableBuilder.addShard(
+                    ShardRouting.newUnassigned(
+                        shardIdFromBatch,
+                        false,
+                        RecoverySource.PeerRecoverySource.INSTANCE,
+                        new UnassignedInfo(
+                            UnassignedInfo.Reason.CLUSTER_RECOVERED,
+                            null,
+                            null,
+                            0,
+                            System.nanoTime(),
+                            System.currentTimeMillis(),
+                            false,
+                            UnassignedInfo.AllocationStatus.NO_ATTEMPT,
+                            Collections.emptySet()
+                        )
+                    )
+                );
+            }
+            indexRoutingTableBuilder.addIndexShard(indexShardRoutingTableBuilder.build());
+        }
+
+        RoutingTable routingTable = RoutingTable.builder().add(indexRoutingTableBuilder.build()).build();
+        ClusterState state = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2).add(node3))
+            .build();
+        return new RoutingAllocation(
+            deciders,
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            SnapshotShardSizeInfo.EMPTY,
+            System.nanoTime()
+        );
+    }
+
     private RoutingAllocation onePrimaryOnNode1And1ReplicaRecovering(AllocationDeciders deciders, UnassignedInfo unassignedInfo) {
         ShardRouting primaryShard = TestShardRouting.newShardRouting(shardId, node1.getId(), true, ShardRoutingState.STARTED);
         Metadata metadata = Metadata.builder()
@@ -737,6 +936,41 @@ private RoutingAllocation onePrimaryOnNode1And1ReplicaRecovering(AllocationDecid
         );
     }
 
+    private RoutingAllocation oneInactivePrimaryOnNode1And1ReplicaRecovering(AllocationDeciders deciders, UnassignedInfo unassignedInfo) {
+        ShardRouting primaryShard = TestShardRouting.newShardRouting(shardId, node1.getId(), true, ShardRoutingState.INITIALIZING);
+        RoutingTable routingTable = RoutingTable.builder()
+            .add(
+                IndexRoutingTable.builder(shardId.getIndex())
+                    .addIndexShard(
+                        new IndexShardRoutingTable.Builder(shardId).addShard(primaryShard)
+                            .addShard(
+                                TestShardRouting.newShardRouting(
+                                    shardId,
+                                    node2.getId(),
+                                    null,
+                                    false,
+                                    ShardRoutingState.INITIALIZING,
+                                    unassignedInfo
+                                )
+                            )
+                            .build()
+                    )
+            )
+            .build();
+        ClusterState state = ClusterState.builder(org.opensearch.cluster.ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .routingTable(routingTable)
+            .nodes(DiscoveryNodes.builder().add(node1).add(node2))
+            .build();
+        return new RoutingAllocation(
+            deciders,
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            SnapshotShardSizeInfo.EMPTY,
+            System.nanoTime()
+        );
+    }
+
     private RoutingAllocation onePrimaryOnNode1And1ReplicaRecovering(AllocationDeciders deciders) {
         return onePrimaryOnNode1And1ReplicaRecovering(deciders, new UnassignedInfo(UnassignedInfo.Reason.CLUSTER_RECOVERED, null));
     }
@@ -755,7 +989,7 @@ static String randomSyncId() {
     }
 
     class TestBatchAllocator extends ReplicaShardBatchAllocator {
-        private Map<DiscoveryNode, TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadata> data = null;
+        private Map<DiscoveryNode, TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadataBatch> data = null;
         private AtomicBoolean fetchDataCalled = new AtomicBoolean(false);
         private AtomicInteger eligibleShardFetchDataCount = new AtomicInteger(0);
 
@@ -800,6 +1034,55 @@ public TestBatchAllocator addData(
             }
             data.put(
                 node,
+                new TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadataBatch(
+                    node,
+                    Map.of(
+                        shardId,
+                        new TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadata(
+                            new TransportNodesListShardStoreMetadataHelper.StoreFilesMetadata(
+                                shardId,
+                                new Store.MetadataSnapshot(unmodifiableMap(filesAsMap), unmodifiableMap(commitData), randomInt()),
+                                peerRecoveryRetentionLeases
+                            ),
+                            storeFileFetchException
+                        )
+                    )
+                )
+            );
+            return this;
+        }
+
+        public TestBatchAllocator addShardData(
+            DiscoveryNode node,
+            ShardId shardId,
+            String syncId,
+            @Nullable Exception storeFileFetchException,
+            StoreFileMetadata... files
+        ) {
+            return addShardData(node, Collections.emptyList(), shardId, syncId, storeFileFetchException, files);
+        }
+
+        public TestBatchAllocator addShardData(
+            DiscoveryNode node,
+            List<RetentionLease> peerRecoveryRetentionLeases,
+            ShardId shardId,
+            String syncId,
+            @Nullable Exception storeFileFetchException,
+            StoreFileMetadata... files
+        ) {
+            if (data == null) {
+                data = new HashMap<>();
+            }
+            Map<String, StoreFileMetadata> filesAsMap = new HashMap<>();
+            for (StoreFileMetadata file : files) {
+                filesAsMap.put(file.name(), file);
+            }
+            Map<String, String> commitData = new HashMap<>();
+            if (syncId != null) {
+                commitData.put(Engine.SYNC_COMMIT_ID, syncId);
+            }
+
+            TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadata nodeStoreFilesMetadata =
                 new TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadata(
                     new TransportNodesListShardStoreMetadataHelper.StoreFilesMetadata(
                         shardId,
@@ -807,8 +1090,19 @@ public TestBatchAllocator addData(
                         peerRecoveryRetentionLeases
                     ),
                     storeFileFetchException
-                )
+                );
+            Map<ShardId, TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadata> shardIdNodeStoreFilesMetadataHashMap =
+                new HashMap<>();
+            if (data.containsKey(node)) {
+                NodeStoreFilesMetadataBatch nodeStoreFilesMetadataBatch = data.get(node);
+                shardIdNodeStoreFilesMetadataHashMap.putAll(nodeStoreFilesMetadataBatch.getNodeStoreFilesMetadataBatch());
+            }
+            shardIdNodeStoreFilesMetadataHashMap.put(shardId, nodeStoreFilesMetadata);
+            data.put(
+                node,
+                new TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadataBatch(node, shardIdNodeStoreFilesMetadataHashMap)
             );
+
             return this;
         }
 
@@ -820,25 +1114,7 @@ protected AsyncShardFetch.FetchResult<NodeStoreFilesMetadataBatch> fetchData(
         ) {
             fetchDataCalled.set(true);
             eligibleShardFetchDataCount.set(eligibleShards.size());
-            Map<DiscoveryNode, NodeStoreFilesMetadataBatch> tData = null;
-            if (data != null) {
-                tData = new HashMap<>();
-                for (Map.Entry<DiscoveryNode, TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadata> entry : data.entrySet()) {
-                    Map<ShardId, TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadata> shardData = Map.of(
-                        shardId,
-                        entry.getValue()
-                    );
-                    tData.put(
-                        entry.getKey(),
-                        new TransportNodesListShardStoreMetadataBatch.NodeStoreFilesMetadataBatch(entry.getKey(), shardData)
-                    );
-                }
-            }
-            return new AsyncShardFetch.FetchResult<>(tData, new HashMap<>() {
-                {
-                    put(shardId, Collections.emptySet());
-                }
-            });
+            return new AsyncShardFetch.FetchResult<>(data, Collections.<ShardId, Set<String>>emptyMap());
         }
 
         @Override
diff --git a/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java b/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
index 6c9a3201656d7..3f9aa1245cab3 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/ClusterMetadataManifestTests.java
@@ -9,39 +9,76 @@
 package org.opensearch.gateway.remote;
 
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.metadata.IndexGraveyard;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.IndexTemplateMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.RepositoriesMetadata;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.cluster.metadata.WeightedRoutingMetadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.json.JsonXContent;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedIndexMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
 import org.opensearch.test.EqualsHashCodeTestUtils;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.mockito.Mockito;
+
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V0;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V1;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V2;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V3;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V4;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_BLOCKS;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.DISCOVERY_NODES;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_DELIMITER;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
 
 public class ClusterMetadataManifestTests extends OpenSearchTestCase {
 
     public void testClusterMetadataManifestXContentV0() throws IOException {
-        UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
-        ClusterMetadataManifest originalManifest = new ClusterMetadataManifest(
-            1L,
-            1L,
-            "test-cluster-uuid",
-            "test-state-uuid",
-            Version.CURRENT,
-            "test-node-id",
-            false,
-            ClusterMetadataManifest.CODEC_V0,
-            null,
-            Collections.singletonList(uploadedIndexMetadata),
-            "prev-cluster-uuid",
-            true
-        );
+        UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path", CODEC_V0);
+        ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .clusterUUID("test-cluster-uuid")
+            .stateUUID("test-state-uuid")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("test-node-id")
+            .committed(false)
+            .codecVersion(CODEC_V0)
+            .indices(Collections.singletonList(uploadedIndexMetadata))
+            .previousClusterUUID("prev-cluster-uuid")
+            .clusterUUIDCommitted(true)
+            .build();
         final XContentBuilder builder = JsonXContent.contentBuilder();
         builder.startObject();
         originalManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
@@ -53,22 +90,70 @@ public void testClusterMetadataManifestXContentV0() throws IOException {
         }
     }
 
+    public void testClusterMetadataManifestXContentV1() throws IOException {
+        UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path", CODEC_V1);
+        ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .clusterUUID("test-cluster-uuid")
+            .stateUUID("test-state-uuid")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("test-node-id")
+            .committed(false)
+            .codecVersion(CODEC_V1)
+            .globalMetadataFileName("test-global-metadata-file")
+            .indices(Collections.singletonList(uploadedIndexMetadata))
+            .previousClusterUUID("prev-cluster-uuid")
+            .clusterUUIDCommitted(true)
+            .build();
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        originalManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterMetadataManifest fromXContentManifest = ClusterMetadataManifest.fromXContentV1(parser);
+            assertEquals(originalManifest, fromXContentManifest);
+        }
+    }
+
     public void testClusterMetadataManifestXContent() throws IOException {
         UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
-        ClusterMetadataManifest originalManifest = new ClusterMetadataManifest(
-            1L,
-            1L,
-            "test-cluster-uuid",
-            "test-state-uuid",
-            Version.CURRENT,
-            "test-node-id",
-            false,
-            ClusterMetadataManifest.CODEC_V1,
-            "test-global-metadata-file",
-            Collections.singletonList(uploadedIndexMetadata),
-            "prev-cluster-uuid",
-            true
-        );
+        ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .clusterUUID("test-cluster-uuid")
+            .stateUUID("test-state-uuid")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("test-node-id")
+            .committed(false)
+            .codecVersion(CODEC_V2)
+            .indices(Collections.singletonList(uploadedIndexMetadata))
+            .previousClusterUUID("prev-cluster-uuid")
+            .clusterUUIDCommitted(true)
+            .coordinationMetadata(new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination-file"))
+            .settingMetadata(new UploadedMetadataAttribute(SETTING_METADATA, "setting-file"))
+            .templatesMetadata(new UploadedMetadataAttribute(TEMPLATES_METADATA, "templates-file"))
+            .customMetadataMap(
+                Collections.unmodifiableList(
+                    Arrays.asList(
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + RepositoriesMetadata.TYPE,
+                            "custom--repositories-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + IndexGraveyard.TYPE,
+                            "custom--index_graveyard-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + WeightedRoutingMetadata.TYPE,
+                            "custom--weighted_routing_netadata-file"
+                        )
+                    )
+                ).stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()))
+            )
+            .routingTableVersion(1L)
+            .build();
         final XContentBuilder builder = JsonXContent.contentBuilder();
         builder.startObject();
         originalManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
@@ -81,20 +166,56 @@ public void testClusterMetadataManifestXContent() throws IOException {
     }
 
     public void testClusterMetadataManifestSerializationEqualsHashCode() {
-        ClusterMetadataManifest initialManifest = new ClusterMetadataManifest(
-            1337L,
-            7L,
-            "HrYF3kP5SmSPWtKlWhnNSA",
-            "6By9p9G0Rv2MmFYJcPAOgA",
-            Version.CURRENT,
-            "B10RX1f5RJenMQvYccCgSQ",
-            true,
-            1,
-            "test-global-metadata-file",
-            randomUploadedIndexMetadataList(),
-            "yfObdx8KSMKKrXf8UyHhM",
-            true
-        );
+        ClusterMetadataManifest initialManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1337L)
+            .stateVersion(7L)
+            .clusterUUID("HrYF3kP5SmSPWtKlWhnNSA")
+            .stateUUID("6By9p9G0Rv2MmFYJcPAOgA")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("B10RX1f5RJenMQvYccCgSQ")
+            .committed(true)
+            .codecVersion(ClusterMetadataManifest.CODEC_V4)
+            .indices(randomUploadedIndexMetadataList())
+            .previousClusterUUID("yfObdx8KSMKKrXf8UyHhM")
+            .clusterUUIDCommitted(true)
+            .coordinationMetadata(new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination-file"))
+            .settingMetadata(new UploadedMetadataAttribute(SETTING_METADATA, "setting-file"))
+            .templatesMetadata(new UploadedMetadataAttribute(TEMPLATES_METADATA, "templates-file"))
+            .customMetadataMap(
+                Collections.unmodifiableList(
+                    Arrays.asList(
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + RepositoriesMetadata.TYPE,
+                            "custom--repositories-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + IndexGraveyard.TYPE,
+                            "custom--index_graveyard-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + WeightedRoutingMetadata.TYPE,
+                            "custom--weighted_routing_netadata-file"
+                        )
+                    )
+                ).stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()))
+            )
+            .routingTableVersion(1L)
+            .discoveryNodesMetadata(new UploadedMetadataAttribute(DISCOVERY_NODES, "discovery-nodes-file"))
+            .clusterBlocksMetadata(new UploadedMetadataAttribute(CLUSTER_BLOCKS, "cluster-block-file"))
+            .transientSettingsMetadata(new UploadedMetadataAttribute(TRANSIENT_SETTING_METADATA, "transient-settings-file"))
+            .hashesOfConsistentSettings(new UploadedMetadataAttribute(HASHES_OF_CONSISTENT_SETTINGS, "hashes-of-consistent-settings-file"))
+            .clusterStateCustomMetadataMap(Collections.emptyMap())
+            .diffManifest(
+                new ClusterStateDiffManifest(
+                    RemoteClusterStateServiceTests.generateClusterStateWithOneIndex().build(),
+                    ClusterState.EMPTY_STATE,
+                    ClusterMetadataManifest.CODEC_V3,
+                    null,
+                    "indicesRoutingDiffPath"
+                )
+            )
+            .checksum(new ClusterStateChecksum(createClusterState()))
+            .build();
         {  // Mutate Cluster Term
             EqualsHashCodeTestUtils.checkEqualsAndHashCode(
                 initialManifest,
@@ -231,9 +352,420 @@ public void testClusterMetadataManifestSerializationEqualsHashCode() {
                 }
             );
         }
+        {
+            // Mutate Coordination metadata
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.coordinationMetadata(randomUploadedMetadataAttribute());
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate setting metadata
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.settingMetadata(randomUploadedMetadataAttribute());
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate template metadata
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.templatesMetadata(randomUploadedMetadataAttribute());
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate custom metadata
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.customMetadataMap(Collections.emptyMap());
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate discovery nodes
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.discoveryNodesMetadata(randomUploadedMetadataAttribute());
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate cluster blocks
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.clusterBlocksMetadata(randomUploadedMetadataAttribute());
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate transient settings metadata
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.transientSettingsMetadata(randomUploadedMetadataAttribute());
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate diff manifest
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.diffManifest(null);
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate hashes of consistent settings
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.hashesOfConsistentSettings(randomUploadedMetadataAttribute());
+                    return builder.build();
+                }
+            );
+        }
+        {
+            // Mutate checksum
+            EqualsHashCodeTestUtils.checkEqualsAndHashCode(
+                initialManifest,
+                orig -> OpenSearchTestCase.copyWriteable(
+                    orig,
+                    new NamedWriteableRegistry(Collections.emptyList()),
+                    ClusterMetadataManifest::new
+                ),
+                manifest -> {
+                    ClusterMetadataManifest.Builder builder = ClusterMetadataManifest.builder(manifest);
+                    builder.checksum(null);
+                    return builder.build();
+                }
+            );
+        }
     }
 
-    private List<UploadedIndexMetadata> randomUploadedIndexMetadataList() {
+    public void testClusterMetadataManifestXContentV2() throws IOException {
+        UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
+        UploadedMetadataAttribute uploadedMetadataAttribute = new UploadedMetadataAttribute("attribute_name", "testing_attribute");
+        ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .clusterUUID("test-cluster-uuid")
+            .stateUUID("test-state-uuid")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("test-node-id")
+            .committed(false)
+            .codecVersion(CODEC_V2)
+            .indices(Collections.singletonList(uploadedIndexMetadata))
+            .previousClusterUUID("prev-cluster-uuid")
+            .clusterUUIDCommitted(true)
+            .coordinationMetadata(uploadedMetadataAttribute)
+            .settingMetadata(uploadedMetadataAttribute)
+            .templatesMetadata(uploadedMetadataAttribute)
+            .customMetadataMap(
+                Collections.unmodifiableList(
+                    Arrays.asList(
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + RepositoriesMetadata.TYPE,
+                            "custom--repositories-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + IndexGraveyard.TYPE,
+                            "custom--index_graveyard-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + WeightedRoutingMetadata.TYPE,
+                            "custom--weighted_routing_netadata-file"
+                        )
+                    )
+                ).stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()))
+            )
+            .routingTableVersion(1L)
+            .indicesRouting(Collections.singletonList(uploadedIndexMetadata))
+            .discoveryNodesMetadata(uploadedMetadataAttribute)
+            .clusterBlocksMetadata(uploadedMetadataAttribute)
+            .transientSettingsMetadata(uploadedMetadataAttribute)
+            .hashesOfConsistentSettings(uploadedMetadataAttribute)
+            .clusterStateCustomMetadataMap(Collections.emptyMap())
+            .diffManifest(
+                new ClusterStateDiffManifest(
+                    RemoteClusterStateServiceTests.generateClusterStateWithOneIndex().build(),
+                    ClusterState.EMPTY_STATE,
+                    CODEC_V2,
+                    null,
+                    null
+                )
+            )
+            .build();
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        originalManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterMetadataManifest fromXContentManifest = ClusterMetadataManifest.fromXContent(parser);
+            assertEquals(originalManifest, fromXContentManifest);
+        }
+    }
+
+    public void testClusterMetadataManifestXContentV3() throws IOException {
+        UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
+        UploadedMetadataAttribute uploadedMetadataAttribute = new UploadedMetadataAttribute("attribute_name", "testing_attribute");
+        final StringKeyDiffProvider<IndexRoutingTable> routingTableIncrementalDiff = Mockito.mock(StringKeyDiffProvider.class);
+        ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .clusterUUID("test-cluster-uuid")
+            .stateUUID("test-state-uuid")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("test-node-id")
+            .committed(false)
+            .codecVersion(CODEC_V3)
+            .indices(Collections.singletonList(uploadedIndexMetadata))
+            .previousClusterUUID("prev-cluster-uuid")
+            .clusterUUIDCommitted(true)
+            .coordinationMetadata(uploadedMetadataAttribute)
+            .settingMetadata(uploadedMetadataAttribute)
+            .templatesMetadata(uploadedMetadataAttribute)
+            .customMetadataMap(
+                Collections.unmodifiableList(
+                    Arrays.asList(
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + RepositoriesMetadata.TYPE,
+                            "custom--repositories-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + IndexGraveyard.TYPE,
+                            "custom--index_graveyard-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + WeightedRoutingMetadata.TYPE,
+                            "custom--weighted_routing_netadata-file"
+                        )
+                    )
+                ).stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()))
+            )
+            .routingTableVersion(1L)
+            .indicesRouting(Collections.singletonList(uploadedIndexMetadata))
+            .discoveryNodesMetadata(uploadedMetadataAttribute)
+            .clusterBlocksMetadata(uploadedMetadataAttribute)
+            .transientSettingsMetadata(uploadedMetadataAttribute)
+            .hashesOfConsistentSettings(uploadedMetadataAttribute)
+            .clusterStateCustomMetadataMap(Collections.emptyMap())
+            .diffManifest(
+                new ClusterStateDiffManifest(
+                    RemoteClusterStateServiceTests.generateClusterStateWithOneIndex().build(),
+                    ClusterState.EMPTY_STATE,
+                    CODEC_V3,
+                    routingTableIncrementalDiff,
+                    uploadedMetadataAttribute.getUploadedFilename()
+                )
+            )
+            .build();
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        originalManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterMetadataManifest fromXContentManifest = ClusterMetadataManifest.fromXContent(parser);
+            assertEquals(originalManifest, fromXContentManifest);
+        }
+    }
+
+    public void testClusterMetadataManifestXContentV4() throws IOException {
+        UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
+        UploadedMetadataAttribute uploadedMetadataAttribute = new UploadedMetadataAttribute("attribute_name", "testing_attribute");
+        final StringKeyDiffProvider<IndexRoutingTable> routingTableIncrementalDiff = Mockito.mock(StringKeyDiffProvider.class);
+        ClusterStateChecksum checksum = new ClusterStateChecksum(createClusterState());
+        ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .clusterUUID("test-cluster-uuid")
+            .stateUUID("test-state-uuid")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("test-node-id")
+            .committed(false)
+            .codecVersion(ClusterMetadataManifest.CODEC_V4)
+            .indices(Collections.singletonList(uploadedIndexMetadata))
+            .previousClusterUUID("prev-cluster-uuid")
+            .clusterUUIDCommitted(true)
+            .coordinationMetadata(uploadedMetadataAttribute)
+            .settingMetadata(uploadedMetadataAttribute)
+            .templatesMetadata(uploadedMetadataAttribute)
+            .customMetadataMap(
+                Collections.unmodifiableList(
+                    Arrays.asList(
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + RepositoriesMetadata.TYPE,
+                            "custom--repositories-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + IndexGraveyard.TYPE,
+                            "custom--index_graveyard-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + WeightedRoutingMetadata.TYPE,
+                            "custom--weighted_routing_netadata-file"
+                        )
+                    )
+                ).stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()))
+            )
+            .routingTableVersion(1L)
+            .indicesRouting(Collections.singletonList(uploadedIndexMetadata))
+            .discoveryNodesMetadata(uploadedMetadataAttribute)
+            .clusterBlocksMetadata(uploadedMetadataAttribute)
+            .transientSettingsMetadata(uploadedMetadataAttribute)
+            .hashesOfConsistentSettings(uploadedMetadataAttribute)
+            .clusterStateCustomMetadataMap(Collections.emptyMap())
+            .diffManifest(
+                new ClusterStateDiffManifest(
+                    RemoteClusterStateServiceTests.generateClusterStateWithOneIndex().build(),
+                    ClusterState.EMPTY_STATE,
+                    CODEC_V4,
+                    routingTableIncrementalDiff,
+                    uploadedMetadataAttribute.getUploadedFilename()
+                )
+            )
+            .checksum(checksum)
+            .build();
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        originalManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterMetadataManifest fromXContentManifest = ClusterMetadataManifest.fromXContent(parser);
+            assertEquals(originalManifest, fromXContentManifest);
+        }
+    }
+
+    public void testClusterMetadataManifestXContentV2WithoutEphemeral() throws IOException {
+        UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
+        UploadedMetadataAttribute uploadedMetadataAttribute = new UploadedMetadataAttribute("attribute_name", "testing_attribute");
+        UploadedIndexMetadata uploadedIndexRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "test-uuid",
+            "routing-path",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        ClusterMetadataManifest originalManifest = ClusterMetadataManifest.builder()
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .clusterUUID("test-cluster-uuid")
+            .stateUUID("test-state-uuid")
+            .opensearchVersion(Version.CURRENT)
+            .nodeId("test-node-id")
+            .committed(false)
+            .codecVersion(CODEC_V2)
+            .indices(Collections.singletonList(uploadedIndexMetadata))
+            .previousClusterUUID("prev-cluster-uuid")
+            .clusterUUIDCommitted(true)
+            .coordinationMetadata(uploadedMetadataAttribute)
+            .settingMetadata(uploadedMetadataAttribute)
+            .templatesMetadata(uploadedMetadataAttribute)
+            .customMetadataMap(
+                Collections.unmodifiableList(
+                    Arrays.asList(
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + RepositoriesMetadata.TYPE,
+                            "custom--repositories-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + IndexGraveyard.TYPE,
+                            "custom--index_graveyard-file"
+                        ),
+                        new UploadedMetadataAttribute(
+                            CUSTOM_METADATA + CUSTOM_DELIMITER + WeightedRoutingMetadata.TYPE,
+                            "custom--weighted_routing_netadata-file"
+                        )
+                    )
+                ).stream().collect(Collectors.toMap(UploadedMetadataAttribute::getAttributeName, Function.identity()))
+            )
+            .indicesRouting(Collections.singletonList(uploadedIndexRoutingMetadata))
+            .build();
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        originalManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterMetadataManifest fromXContentManifest = ClusterMetadataManifest.fromXContent(parser);
+            assertEquals(originalManifest, fromXContentManifest);
+        }
+    }
+
+    public static List<UploadedIndexMetadata> randomUploadedIndexMetadataList() {
         final int size = randomIntBetween(1, 10);
         final List<UploadedIndexMetadata> uploadedIndexMetadataList = new ArrayList<>(size);
         while (uploadedIndexMetadataList.size() < size) {
@@ -242,10 +774,14 @@ private List<UploadedIndexMetadata> randomUploadedIndexMetadataList() {
         return uploadedIndexMetadataList;
     }
 
-    private UploadedIndexMetadata randomUploadedIndexMetadata() {
+    private static UploadedIndexMetadata randomUploadedIndexMetadata() {
         return new UploadedIndexMetadata(randomAlphaOfLength(10), randomAlphaOfLength(10), randomAlphaOfLength(10));
     }
 
+    private UploadedMetadataAttribute randomUploadedMetadataAttribute() {
+        return new UploadedMetadataAttribute("attribute_name", "testing_attribute");
+    }
+
     public void testUploadedIndexMetadataSerializationEqualsHashCode() {
         UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "test-uuid", "/test/upload/path");
         EqualsHashCodeTestUtils.checkEqualsAndHashCode(
@@ -255,6 +791,35 @@ public void testUploadedIndexMetadataSerializationEqualsHashCode() {
         );
     }
 
+    public void testUploadedIndexMetadataWithoutComponentPrefix() throws IOException {
+        final UploadedIndexMetadata originalUploadedIndexMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "test-index-uuid",
+            "test_file_name",
+            CODEC_V1
+        );
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        originalUploadedIndexMetadata.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final UploadedIndexMetadata fromXContentUploadedIndexMetadata = UploadedIndexMetadata.fromXContent(parser, 1L);
+            assertEquals(originalUploadedIndexMetadata, fromXContentUploadedIndexMetadata);
+        }
+    }
+
+    public void testGetCodecForVersion() {
+        assertEquals(-1, ClusterMetadataManifest.getCodecForVersion(Version.fromString("1.3.0")));
+        assertEquals(-1, ClusterMetadataManifest.getCodecForVersion(Version.V_2_1_0));
+        assertEquals(CODEC_V0, ClusterMetadataManifest.getCodecForVersion(Version.V_2_10_0));
+        assertEquals(CODEC_V1, ClusterMetadataManifest.getCodecForVersion(Version.V_2_12_0));
+        assertEquals(CODEC_V1, ClusterMetadataManifest.getCodecForVersion(Version.V_2_13_0));
+        assertEquals(CODEC_V2, ClusterMetadataManifest.getCodecForVersion(Version.V_2_15_0));
+        assertEquals(CODEC_V3, ClusterMetadataManifest.getCodecForVersion(Version.V_2_16_0));
+        assertEquals(CODEC_V4, ClusterMetadataManifest.getCodecForVersion(Version.V_2_17_0));
+    }
+
     private UploadedIndexMetadata randomlyChangingUploadedIndexMetadata(UploadedIndexMetadata uploadedIndexMetadata) {
         switch (randomInt(2)) {
             case 0:
@@ -278,4 +843,41 @@ private UploadedIndexMetadata randomlyChangingUploadedIndexMetadata(UploadedInde
         }
         return uploadedIndexMetadata;
     }
+
+    static ClusterState createClusterState() {
+        final Index index = new Index("test-index", "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final Settings settings = Settings.builder().put("mock-settings", true).build();
+        final TemplatesMetadata templatesMetadata = TemplatesMetadata.builder()
+            .put(IndexTemplateMetadata.builder("template1").settings(idxSettings).patterns(List.of("test*")).build())
+            .build();
+        final RemoteClusterStateTestUtils.CustomMetadata1 customMetadata = new RemoteClusterStateTestUtils.CustomMetadata1(
+            "custom-metadata-1"
+        );
+        return ClusterState.builder(ClusterName.DEFAULT)
+            .version(1L)
+            .stateUUID("state-uuid")
+            .metadata(
+                Metadata.builder()
+                    .version(randomNonNegativeLong())
+                    .put(indexMetadata, true)
+                    .clusterUUID("cluster-uuid")
+                    .coordinationMetadata(coordinationMetadata)
+                    .persistentSettings(settings)
+                    .templates(templatesMetadata)
+                    .hashesOfConsistentSettings(Map.of("key1", "value1", "key2", "value2"))
+                    .putCustom(customMetadata.getWriteableName(), customMetadata)
+                    .build()
+            )
+            .routingTable(RoutingTable.builder().addAsNew(indexMetadata).version(1L).build())
+            .build();
+    }
 }
diff --git a/server/src/test/java/org/opensearch/gateway/remote/ClusterStateChecksumTests.java b/server/src/test/java/org/opensearch/gateway/remote/ClusterStateChecksumTests.java
new file mode 100644
index 0000000000000..0203e56dd2d5c
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/ClusterStateChecksumTests.java
@@ -0,0 +1,222 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.block.ClusterBlock;
+import org.opensearch.cluster.block.ClusterBlockLevel;
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.IndexTemplateMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.transport.TransportAddress;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+
+public class ClusterStateChecksumTests extends OpenSearchTestCase {
+
+    public void testClusterStateChecksumEmptyClusterState() {
+        ClusterStateChecksum checksum = new ClusterStateChecksum(ClusterState.EMPTY_STATE);
+        assertNotNull(checksum);
+    }
+
+    public void testClusterStateChecksum() {
+        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState());
+        assertNotNull(checksum);
+        assertTrue(checksum.routingTableChecksum != 0);
+        assertTrue(checksum.nodesChecksum != 0);
+        assertTrue(checksum.blocksChecksum != 0);
+        assertTrue(checksum.clusterStateCustomsChecksum != 0);
+        assertTrue(checksum.coordinationMetadataChecksum != 0);
+        assertTrue(checksum.settingMetadataChecksum != 0);
+        assertTrue(checksum.transientSettingsMetadataChecksum != 0);
+        assertTrue(checksum.templatesMetadataChecksum != 0);
+        assertTrue(checksum.customMetadataMapChecksum != 0);
+        assertTrue(checksum.hashesOfConsistentSettingsChecksum != 0);
+        assertTrue(checksum.indicesChecksum != 0);
+        assertTrue(checksum.clusterStateChecksum != 0);
+    }
+
+    public void testClusterStateMatchChecksum() {
+        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState());
+        ClusterStateChecksum newChecksum = new ClusterStateChecksum(generateClusterState());
+        assertNotNull(checksum);
+        assertNotNull(newChecksum);
+        assertEquals(checksum.routingTableChecksum, newChecksum.routingTableChecksum);
+        assertEquals(checksum.nodesChecksum, newChecksum.nodesChecksum);
+        assertEquals(checksum.blocksChecksum, newChecksum.blocksChecksum);
+        assertEquals(checksum.clusterStateCustomsChecksum, newChecksum.clusterStateCustomsChecksum);
+        assertEquals(checksum.coordinationMetadataChecksum, newChecksum.coordinationMetadataChecksum);
+        assertEquals(checksum.settingMetadataChecksum, newChecksum.settingMetadataChecksum);
+        assertEquals(checksum.transientSettingsMetadataChecksum, newChecksum.transientSettingsMetadataChecksum);
+        assertEquals(checksum.templatesMetadataChecksum, newChecksum.templatesMetadataChecksum);
+        assertEquals(checksum.customMetadataMapChecksum, newChecksum.customMetadataMapChecksum);
+        assertEquals(checksum.hashesOfConsistentSettingsChecksum, newChecksum.hashesOfConsistentSettingsChecksum);
+        assertEquals(checksum.indicesChecksum, newChecksum.indicesChecksum);
+        assertEquals(checksum.clusterStateChecksum, newChecksum.clusterStateChecksum);
+    }
+
+    public void testXContentConversion() throws IOException {
+        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState());
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        checksum.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterStateChecksum parsedChecksum = ClusterStateChecksum.fromXContent(parser);
+            assertEquals(checksum, parsedChecksum);
+        }
+    }
+
+    public void testSerialization() throws IOException {
+        ClusterStateChecksum checksum = new ClusterStateChecksum(generateClusterState());
+        BytesStreamOutput output = new BytesStreamOutput();
+        checksum.writeTo(output);
+
+        try (StreamInput in = output.bytes().streamInput()) {
+            ClusterStateChecksum deserializedChecksum = new ClusterStateChecksum(in);
+            assertEquals(checksum, deserializedChecksum);
+        }
+    }
+
+    public void testGetMismatchEntities() {
+        ClusterState clsState1 = generateClusterState();
+        ClusterStateChecksum checksum = new ClusterStateChecksum(clsState1);
+        assertTrue(checksum.getMismatchEntities(checksum).isEmpty());
+
+        ClusterStateChecksum checksum2 = new ClusterStateChecksum(clsState1);
+        assertTrue(checksum.getMismatchEntities(checksum2).isEmpty());
+
+        ClusterState clsState2 = ClusterState.builder(ClusterName.DEFAULT)
+            .routingTable(RoutingTable.builder().build())
+            .nodes(DiscoveryNodes.builder().build())
+            .blocks(ClusterBlocks.builder().build())
+            .customs(Map.of())
+            .metadata(Metadata.EMPTY_METADATA)
+            .build();
+        ClusterStateChecksum checksum3 = new ClusterStateChecksum(clsState2);
+        List<String> mismatches = checksum.getMismatchEntities(checksum3);
+        assertFalse(mismatches.isEmpty());
+        assertEquals(11, mismatches.size());
+        assertEquals(ClusterStateChecksum.ROUTING_TABLE_CS, mismatches.get(0));
+        assertEquals(ClusterStateChecksum.NODES_CS, mismatches.get(1));
+        assertEquals(ClusterStateChecksum.BLOCKS_CS, mismatches.get(2));
+        assertEquals(ClusterStateChecksum.CUSTOMS_CS, mismatches.get(3));
+        assertEquals(ClusterStateChecksum.COORDINATION_MD_CS, mismatches.get(4));
+        assertEquals(ClusterStateChecksum.SETTINGS_MD_CS, mismatches.get(5));
+        assertEquals(ClusterStateChecksum.TRANSIENT_SETTINGS_MD_CS, mismatches.get(6));
+        assertEquals(ClusterStateChecksum.TEMPLATES_MD_CS, mismatches.get(7));
+        assertEquals(ClusterStateChecksum.CUSTOM_MD_CS, mismatches.get(8));
+        assertEquals(ClusterStateChecksum.HASHES_MD_CS, mismatches.get(9));
+        assertEquals(ClusterStateChecksum.INDICES_CS, mismatches.get(10));
+    }
+
+    public void testGetMismatchEntitiesUnorderedInput() {
+        ClusterState state1 = generateClusterState();
+        DiscoveryNode node1 = DiscoveryNode.createLocal(Settings.EMPTY, new TransportAddress(TransportAddress.META_ADDRESS, 9200), "node1");
+        DiscoveryNode node2 = DiscoveryNode.createLocal(Settings.EMPTY, new TransportAddress(TransportAddress.META_ADDRESS, 9201), "node2");
+        DiscoveryNode node3 = DiscoveryNode.createLocal(Settings.EMPTY, new TransportAddress(TransportAddress.META_ADDRESS, 9202), "node3");
+
+        DiscoveryNodes nodes1 = DiscoveryNodes.builder().clusterManagerNodeId("test-node").add(node1).add(node2).add(node3).build();
+        DiscoveryNodes nodes2 = DiscoveryNodes.builder().clusterManagerNodeId("test-node").add(node2).add(node3).build();
+        nodes2 = nodes2.newNode(node1);
+        ClusterState state2 = ClusterState.builder(state1).nodes(nodes1).build();
+        ClusterState state3 = ClusterState.builder(state1).nodes(nodes2).build();
+
+        ClusterStateChecksum checksum1 = new ClusterStateChecksum(state2);
+        ClusterStateChecksum checksum2 = new ClusterStateChecksum(state3);
+        assertEquals(checksum2, checksum1);
+    }
+
+    private ClusterState generateClusterState() {
+        final Index index = new Index("test-index", "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .put(IndexMetadata.INDEX_READ_ONLY_SETTING.getKey(), true)
+            .build();
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+        final Index index2 = new Index("test-index2", "index-uuid2");
+        final Settings idxSettings2 = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index2.getUUID())
+            .put(IndexMetadata.INDEX_READ_ONLY_SETTING.getKey(), true)
+            .build();
+        final IndexMetadata indexMetadata2 = new IndexMetadata.Builder(index2.getName()).settings(idxSettings2)
+            .numberOfShards(3)
+            .numberOfReplicas(2)
+            .build();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final Settings settings = Settings.builder().put("mock-settings", true).build();
+        final TemplatesMetadata templatesMetadata = TemplatesMetadata.builder()
+            .put(IndexTemplateMetadata.builder("template1").settings(idxSettings).patterns(List.of("test*")).build())
+            .build();
+        final RemoteClusterStateTestUtils.CustomMetadata1 customMetadata1 = new RemoteClusterStateTestUtils.CustomMetadata1(
+            "custom-metadata-1"
+        );
+        RemoteClusterStateTestUtils.TestClusterStateCustom1 clusterStateCustom1 = new RemoteClusterStateTestUtils.TestClusterStateCustom1(
+            "custom-1"
+        );
+        return ClusterState.builder(ClusterName.DEFAULT)
+            .version(1L)
+            .stateUUID("state-uuid")
+            .metadata(
+                Metadata.builder()
+                    .version(1L)
+                    .put(indexMetadata, true)
+                    .clusterUUID("cluster-uuid")
+                    .coordinationMetadata(coordinationMetadata)
+                    .persistentSettings(settings)
+                    .transientSettings(settings)
+                    .templates(templatesMetadata)
+                    .hashesOfConsistentSettings(Map.of("key1", "value1", "key2", "value2"))
+                    .putCustom(customMetadata1.getWriteableName(), customMetadata1)
+                    .indices(Map.of(indexMetadata.getIndex().getName(), indexMetadata, indexMetadata2.getIndex().getName(), indexMetadata2))
+                    .build()
+            )
+            .nodes(DiscoveryNodes.builder().clusterManagerNodeId("test-node").build())
+            .blocks(
+                ClusterBlocks.builder()
+                    .addBlocks(indexMetadata)
+                    .addGlobalBlock(new ClusterBlock(1, "block", true, true, true, RestStatus.ACCEPTED, EnumSet.of(ClusterBlockLevel.READ)))
+                    .addGlobalBlock(
+                        new ClusterBlock(2, "block-name", false, true, true, RestStatus.OK, EnumSet.of(ClusterBlockLevel.WRITE))
+                    )
+                    .build()
+            )
+            .customs(Map.of(clusterStateCustom1.getWriteableName(), clusterStateCustom1))
+            .routingTable(RoutingTable.builder().addAsNew(indexMetadata).addAsNew(indexMetadata2).version(1L).build())
+            .build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManagerTests.java
new file mode 100644
index 0000000000000..67b1528466a9e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateAttributesManagerTests.java
@@ -0,0 +1,370 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.ClusterState.Custom;
+import org.opensearch.cluster.DiffableUtils;
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.TestCapturingListener;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.gateway.remote.model.RemoteClusterBlocks;
+import org.opensearch.gateway.remote.model.RemoteClusterStateCustoms;
+import org.opensearch.gateway.remote.model.RemoteDiscoveryNodes;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+
+import static org.opensearch.common.blobstore.stream.write.WritePriority.URGENT;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTE;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.DISCOVERY_NODES;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom1;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom2;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom3;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom4;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_EPHEMERAL_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CUSTOM_DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.PATH_DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.encodeString;
+import static org.opensearch.gateway.remote.model.RemoteClusterBlocks.CLUSTER_BLOCKS;
+import static org.opensearch.gateway.remote.model.RemoteClusterBlocks.CLUSTER_BLOCKS_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteClusterBlocksTests.randomClusterBlocks;
+import static org.opensearch.gateway.remote.model.RemoteClusterStateCustoms.CLUSTER_STATE_CUSTOM;
+import static org.opensearch.gateway.remote.model.RemoteClusterStateCustomsTests.getClusterStateCustom;
+import static org.opensearch.gateway.remote.model.RemoteDiscoveryNodes.DISCOVERY_NODES_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteDiscoveryNodesTests.getDiscoveryNodes;
+import static org.opensearch.index.remote.RemoteStoreUtils.invertLong;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyIterable;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteClusterStateAttributesManagerTests extends OpenSearchTestCase {
+    private RemoteClusterStateAttributesManager remoteClusterStateAttributesManager;
+    private BlobStoreTransferService blobStoreTransferService;
+    private Compressor compressor;
+    private final ThreadPool threadPool = new TestThreadPool(RemoteClusterStateAttributesManagerTests.class.getName());
+    private final long VERSION = 7331L;
+    private NamedWriteableRegistry namedWriteableRegistry;
+    private final String CLUSTER_NAME = "test-cluster";
+    private final String CLUSTER_UUID = "test-cluster-uuid";
+
+    @Before
+    public void setup() throws Exception {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        namedWriteableRegistry = writableRegistry();
+        BlobStoreRepository blobStoreRepository = mock(BlobStoreRepository.class);
+        when(blobStoreRepository.basePath()).thenReturn(new BlobPath());
+        blobStoreTransferService = mock(BlobStoreTransferService.class);
+        compressor = new NoneCompressor();
+
+        remoteClusterStateAttributesManager = new RemoteClusterStateAttributesManager(
+            CLUSTER_NAME,
+            blobStoreRepository,
+            blobStoreTransferService,
+            writableRegistry(),
+            threadPool
+        );
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testGetAsyncWriteRunnable_DiscoveryNodes() throws IOException, InterruptedException {
+        DiscoveryNodes discoveryNodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteDiscoveryNodes = new RemoteDiscoveryNodes(discoveryNodes, VERSION, CLUSTER_UUID, compressor);
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        final CountDownLatch latch = new CountDownLatch(1);
+        final TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        remoteClusterStateAttributesManager.writeAsync(DISCOVERY_NODES, remoteDiscoveryNodes, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(DISCOVERY_NODES, listener.getResult().getComponent());
+        String uploadedFileName = listener.getResult().getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(RemoteClusterStateUtils.encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(CLUSTER_STATE_EPHEMERAL_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(DISCOVERY_NODES, splitFileName[0]);
+        assertEquals(invertLong(VERSION), splitFileName[1]);
+        assertEquals(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_DiscoveryNodes() throws IOException, InterruptedException {
+        DiscoveryNodes discoveryNodes = getDiscoveryNodes();
+        String fileName = randomAlphaOfLength(10);
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            DISCOVERY_NODES_FORMAT.serialize(
+                (out, discoveryNode) -> discoveryNode.writeToWithAttribute(out),
+                discoveryNodes,
+                fileName,
+                compressor
+            ).streamInput()
+        );
+        RemoteDiscoveryNodes remoteObjForDownload = new RemoteDiscoveryNodes(fileName, "cluster-uuid", compressor);
+        CountDownLatch latch = new CountDownLatch(1);
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        remoteClusterStateAttributesManager.readAsync(DISCOVERY_NODES, remoteObjForDownload, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(CLUSTER_STATE_ATTRIBUTE, listener.getResult().getComponent());
+        assertEquals(DISCOVERY_NODES, listener.getResult().getComponentName());
+        DiscoveryNodes readDiscoveryNodes = (DiscoveryNodes) listener.getResult().getObj();
+        assertEquals(discoveryNodes.getSize(), readDiscoveryNodes.getSize());
+        discoveryNodes.getNodes().forEach((nodeId, node) -> assertEquals(readDiscoveryNodes.get(nodeId), node));
+        assertEquals(discoveryNodes.getClusterManagerNodeId(), readDiscoveryNodes.getClusterManagerNodeId());
+    }
+
+    public void testGetAsyncWriteRunnable_ClusterBlocks() throws IOException, InterruptedException {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        RemoteClusterBlocks remoteClusterBlocks = new RemoteClusterBlocks(clusterBlocks, VERSION, CLUSTER_UUID, compressor);
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        final CountDownLatch latch = new CountDownLatch(1);
+        final TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        remoteClusterStateAttributesManager.writeAsync(CLUSTER_BLOCKS, remoteClusterBlocks, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(CLUSTER_BLOCKS, listener.getResult().getComponent());
+        String uploadedFileName = listener.getResult().getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(CLUSTER_STATE_EPHEMERAL_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(CLUSTER_BLOCKS, splitFileName[0]);
+        assertEquals(invertLong(VERSION), splitFileName[1]);
+        assertEquals(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_ClusterBlocks() throws IOException, InterruptedException {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        String fileName = randomAlphaOfLength(10);
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            CLUSTER_BLOCKS_FORMAT.serialize(clusterBlocks, fileName, compressor).streamInput()
+        );
+        RemoteClusterBlocks remoteClusterBlocks = new RemoteClusterBlocks(fileName, "cluster-uuid", compressor);
+        CountDownLatch latch = new CountDownLatch(1);
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+
+        remoteClusterStateAttributesManager.readAsync(CLUSTER_BLOCKS, remoteClusterBlocks, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(CLUSTER_STATE_ATTRIBUTE, listener.getResult().getComponent());
+        assertEquals(CLUSTER_BLOCKS, listener.getResult().getComponentName());
+        ClusterBlocks readClusterBlocks = (ClusterBlocks) listener.getResult().getObj();
+        assertEquals(clusterBlocks.global(), readClusterBlocks.global());
+        assertEquals(clusterBlocks.indices().keySet(), readClusterBlocks.indices().keySet());
+        for (String index : clusterBlocks.indices().keySet()) {
+            assertEquals(clusterBlocks.indices().get(index), readClusterBlocks.indices().get(index));
+        }
+    }
+
+    public void testGetAsyncWriteRunnable_Custom() throws IOException, InterruptedException {
+        Custom custom = getClusterStateCustom();
+        RemoteClusterStateCustoms remoteClusterStateCustoms = new RemoteClusterStateCustoms(
+            custom,
+            custom.getWriteableName(),
+            VERSION,
+            CLUSTER_UUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        final TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        final CountDownLatch latch = new CountDownLatch(1);
+        remoteClusterStateAttributesManager.writeAsync(
+            CLUSTER_STATE_CUSTOM,
+            remoteClusterStateCustoms,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, custom.getWriteableName()), listener.getResult().getComponent());
+        String uploadedFileName = listener.getResult().getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(CLUSTER_STATE_EPHEMERAL_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, custom.getWriteableName()), splitFileName[0]);
+        assertEquals(invertLong(VERSION), splitFileName[1]);
+        assertEquals(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_Custom() throws IOException, InterruptedException {
+        Custom custom = getClusterStateCustom();
+        String fileName = randomAlphaOfLength(10);
+        RemoteClusterStateCustoms remoteClusterStateCustoms = new RemoteClusterStateCustoms(
+            fileName,
+            custom.getWriteableName(),
+            CLUSTER_UUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            remoteClusterStateCustoms.clusterStateCustomsFormat.serialize(custom, fileName, compressor).streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> capturingListener = new TestCapturingListener<>();
+        final CountDownLatch latch = new CountDownLatch(1);
+        remoteClusterStateAttributesManager.readAsync(
+            CLUSTER_STATE_CUSTOM,
+            remoteClusterStateCustoms,
+            new LatchedActionListener<>(capturingListener, latch)
+        );
+        latch.await();
+        assertNull(capturingListener.getFailure());
+        assertNotNull(capturingListener.getResult());
+        assertEquals(custom, capturingListener.getResult().getObj());
+        assertEquals(CLUSTER_STATE_ATTRIBUTE, capturingListener.getResult().getComponent());
+        assertEquals(CLUSTER_STATE_CUSTOM, capturingListener.getResult().getComponentName());
+    }
+
+    public void testGetAsyncWriteRunnable_Exception() throws IOException, InterruptedException {
+        DiscoveryNodes discoveryNodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteDiscoveryNodes = new RemoteDiscoveryNodes(discoveryNodes, VERSION, CLUSTER_UUID, compressor);
+
+        IOException ioException = new IOException("mock test exception");
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onFailure(ioException);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> capturingListener = new TestCapturingListener<>();
+        final CountDownLatch latch = new CountDownLatch(1);
+        remoteClusterStateAttributesManager.writeAsync(
+            DISCOVERY_NODES,
+            remoteDiscoveryNodes,
+            new LatchedActionListener<>(capturingListener, latch)
+        );
+        latch.await();
+        assertNull(capturingListener.getResult());
+        assertTrue(capturingListener.getFailure() instanceof RemoteStateTransferException);
+        assertEquals(ioException, capturingListener.getFailure().getCause());
+    }
+
+    public void testGetAsyncReadRunnable_Exception() throws IOException, InterruptedException {
+        String fileName = randomAlphaOfLength(10);
+        RemoteDiscoveryNodes remoteDiscoveryNodes = new RemoteDiscoveryNodes(fileName, CLUSTER_UUID, compressor);
+        Exception ioException = new IOException("mock test exception");
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenThrow(ioException);
+        CountDownLatch latch = new CountDownLatch(1);
+        TestCapturingListener<RemoteReadResult> capturingListener = new TestCapturingListener<>();
+        remoteClusterStateAttributesManager.readAsync(
+            DISCOVERY_NODES,
+            remoteDiscoveryNodes,
+            new LatchedActionListener<>(capturingListener, latch)
+        );
+        latch.await();
+        assertNull(capturingListener.getResult());
+        assertEquals(ioException, capturingListener.getFailure().getCause());
+        assertTrue(capturingListener.getFailure() instanceof RemoteStateTransferException);
+    }
+
+    public void testGetUpdatedCustoms() {
+        Map<String, ClusterState.Custom> previousCustoms = Map.of(
+            TestClusterStateCustom1.TYPE,
+            new TestClusterStateCustom1("data1"),
+            TestClusterStateCustom2.TYPE,
+            new TestClusterStateCustom2("data2"),
+            TestClusterStateCustom3.TYPE,
+            new TestClusterStateCustom3("data3")
+        );
+        ClusterState previousState = ClusterState.builder(new ClusterName("test-cluster")).customs(previousCustoms).build();
+
+        Map<String, Custom> currentCustoms = Map.of(
+            TestClusterStateCustom2.TYPE,
+            new TestClusterStateCustom2("data2"),
+            TestClusterStateCustom3.TYPE,
+            new TestClusterStateCustom3("data3-changed"),
+            TestClusterStateCustom4.TYPE,
+            new TestClusterStateCustom4("data4")
+        );
+
+        ClusterState currentState = ClusterState.builder(new ClusterName("test-cluster")).customs(currentCustoms).build();
+
+        DiffableUtils.MapDiff<String, ClusterState.Custom, Map<String, ClusterState.Custom>> customsDiff =
+            remoteClusterStateAttributesManager.getUpdatedCustoms(currentState, previousState, false, randomBoolean());
+        assertThat(customsDiff.getUpserts(), is(Collections.emptyMap()));
+        assertThat(customsDiff.getDeletes(), is(Collections.emptyList()));
+
+        customsDiff = remoteClusterStateAttributesManager.getUpdatedCustoms(currentState, previousState, true, true);
+        assertThat(customsDiff.getUpserts(), is(currentCustoms));
+        assertThat(customsDiff.getDeletes(), is(Collections.emptyList()));
+
+        Map<String, ClusterState.Custom> expectedCustoms = Map.of(
+            TestClusterStateCustom3.TYPE,
+            new TestClusterStateCustom3("data3-changed"),
+            TestClusterStateCustom4.TYPE,
+            new TestClusterStateCustom4("data4")
+        );
+
+        customsDiff = remoteClusterStateAttributesManager.getUpdatedCustoms(currentState, previousState, true, false);
+        assertThat(customsDiff.getUpserts(), is(expectedCustoms));
+        assertThat(customsDiff.getDeletes(), is(List.of(TestClusterStateCustom1.TYPE)));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java
new file mode 100644
index 0000000000000..8e114c9a26534
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateCleanupManagerTests.java
@@ -0,0 +1,788 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.remote.InternalRemoteRoutingTableService;
+import org.opensearch.cluster.routing.remote.NoopRemoteRoutingTableService;
+import org.opensearch.cluster.routing.remote.RemoteRoutingTableService;
+import org.opensearch.cluster.service.ClusterApplierService;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobMetadata;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.BlobStore;
+import org.opensearch.common.blobstore.support.PlainBlobMetadata;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.concurrent.AbstractAsyncTask;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.fs.FsRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.VersionUtils;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Supplier;
+
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V1;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V2;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V3;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedIndexMetadata;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.AsyncStaleFileDeletion;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.CLUSTER_STATE_CLEANUP_INTERVAL_DEFAULT;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.RETAINED_MANIFESTS;
+import static org.opensearch.gateway.remote.RemoteClusterStateCleanupManager.SKIP_CLEANUP_STATE_CHANGES;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.encodeString;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.getFormattedIndexFileName;
+import static org.opensearch.gateway.remote.model.RemoteClusterMetadataManifest.MANIFEST;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class RemoteClusterStateCleanupManagerTests extends OpenSearchTestCase {
+    private RemoteClusterStateCleanupManager remoteClusterStateCleanupManager;
+    private Supplier<RepositoriesService> repositoriesServiceSupplier;
+    private RepositoriesService repositoriesService;
+    private BlobStoreRepository blobStoreRepository;
+    private BlobStore blobStore;
+    private ClusterSettings clusterSettings;
+    private ClusterApplierService clusterApplierService;
+    private ClusterState clusterState;
+    private Metadata metadata;
+    private RemoteClusterStateService remoteClusterStateService;
+    private RemoteManifestManager remoteManifestManager;
+    private RemoteRoutingTableService remoteRoutingTableService;
+    private ClusterService clusterService;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        repositoriesServiceSupplier = mock(Supplier.class);
+        repositoriesService = mock(RepositoriesService.class);
+        when(repositoriesServiceSupplier.get()).thenReturn(repositoriesService);
+
+        String stateRepoTypeAttributeKey = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+            "remote_store_repository"
+        );
+        String stateRepoSettingsAttributeKeyPrefix = String.format(
+            Locale.getDefault(),
+            "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+            "remote_store_repository"
+        );
+
+        Settings settings = Settings.builder()
+            .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, "remote_store_repository")
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, "routing_repository")
+            .put(stateRepoTypeAttributeKey, FsRepository.TYPE)
+            .put(stateRepoSettingsAttributeKeyPrefix + "location", "randomRepoPath")
+            .put(RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
+            .build();
+
+        clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        clusterApplierService = mock(ClusterApplierService.class);
+        clusterState = mock(ClusterState.class);
+        metadata = mock(Metadata.class);
+        clusterService = mock(ClusterService.class);
+        when(clusterService.getClusterSettings()).thenReturn(clusterSettings);
+        when(clusterState.getClusterName()).thenReturn(new ClusterName("test"));
+        when(metadata.clusterUUID()).thenReturn("testUUID");
+        when(clusterState.metadata()).thenReturn(metadata);
+        when(clusterApplierService.state()).thenReturn(clusterState);
+        when(clusterService.getClusterApplierService()).thenReturn(clusterApplierService);
+
+        blobStoreRepository = mock(BlobStoreRepository.class);
+        blobStore = mock(BlobStore.class);
+        when(blobStoreRepository.blobStore()).thenReturn(blobStore);
+        when(repositoriesService.repository("remote_store_repository")).thenReturn(blobStoreRepository);
+
+        remoteManifestManager = mock(RemoteManifestManager.class);
+        remoteClusterStateService = mock(RemoteClusterStateService.class);
+        when(remoteClusterStateService.getRemoteManifestManager()).thenReturn(remoteManifestManager);
+        when(remoteClusterStateService.getRemoteStateStats()).thenReturn(new RemotePersistenceStats());
+        when(remoteClusterStateService.getThreadpool()).thenReturn(threadPool);
+        when(remoteClusterStateService.getBlobStore()).thenReturn(blobStore);
+        when(remoteClusterStateService.getBlobStoreRepository()).thenReturn(blobStoreRepository);
+        remoteRoutingTableService = mock(InternalRemoteRoutingTableService.class);
+        remoteClusterStateCleanupManager = new RemoteClusterStateCleanupManager(
+            remoteClusterStateService,
+            clusterService,
+            remoteRoutingTableService
+        );
+    }
+
+    @After
+    public void teardown() throws Exception {
+        super.tearDown();
+        remoteClusterStateCleanupManager.close();
+        threadPool.shutdown();
+    }
+
+    public void testDeleteClusterMetadata() throws IOException {
+        String clusterUUID = "clusterUUID";
+        String clusterName = "test-cluster";
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(
+            new PlainBlobMetadata("manifest1.dat", 1L),
+            new PlainBlobMetadata("manifest2.dat", 1L),
+            new PlainBlobMetadata("manifest3.dat", 1L),
+            new PlainBlobMetadata("manifest6.dat", 1L)
+        );
+        List<BlobMetadata> activeBlobs = Arrays.asList(
+            new PlainBlobMetadata("manifest4.dat", 1L),
+            new PlainBlobMetadata("manifest5.dat", 1L),
+            new PlainBlobMetadata("manifest7.dat", 1L)
+        );
+        UploadedIndexMetadata index1Metadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1__1");
+        UploadedIndexMetadata index2Metadata = new UploadedIndexMetadata("index2", "indexUUID2", "index_metadata2__2");
+        UploadedIndexMetadata index1UpdatedMetadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1_updated__2");
+        UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
+        UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
+        UploadedMetadataAttribute settingMetadata = new UploadedMetadataAttribute(SETTING_METADATA, "settings_metadata");
+        UploadedMetadataAttribute coordinationMetadataUpdated = new UploadedMetadataAttribute(
+            COORDINATION_METADATA,
+            "coordination_metadata_updated"
+        );
+        UploadedMetadataAttribute templateMetadataUpdated = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata_updated");
+        UploadedMetadataAttribute settingMetadataUpdated = new UploadedMetadataAttribute(SETTING_METADATA, "settings_metadata_updated");
+        ClusterMetadataManifest manifest1 = ClusterMetadataManifest.builder()
+            .indices(List.of(index1Metadata))
+            .globalMetadataFileName("global_metadata")
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V1)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .build();
+        ClusterMetadataManifest manifest2 = ClusterMetadataManifest.builder(manifest1)
+            .indices(List.of(index1Metadata, index2Metadata))
+            .codecVersion(CODEC_V2)
+            .globalMetadataFileName(null)
+            .coordinationMetadata(coordinationMetadata)
+            .templatesMetadata(templateMetadata)
+            .settingMetadata(settingMetadata)
+            .build();
+        ClusterMetadataManifest manifest3 = ClusterMetadataManifest.builder(manifest2)
+            .indices(List.of(index1UpdatedMetadata, index2Metadata))
+            .settingMetadata(settingMetadataUpdated)
+            .build();
+
+        UploadedIndexMetadata index3Metadata = new UploadedIndexMetadata("index3", "indexUUID3", "index_metadata3__2");
+        UploadedIndexMetadata index4Metadata = new UploadedIndexMetadata("index4", "indexUUID4", "index_metadata4__2");
+        List<UploadedIndexMetadata> indicesRouting1 = List.of(index3Metadata, index4Metadata);
+        List<UploadedIndexMetadata> indicesRouting2 = List.of(index4Metadata);
+        ClusterMetadataManifest manifest6 = ClusterMetadataManifest.builder()
+            .indices(List.of(index1Metadata))
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .templatesMetadata(templateMetadataUpdated)
+            .settingMetadata(settingMetadataUpdated)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V2)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .routingTableVersion(0L)
+            .indicesRouting(indicesRouting1)
+            .build();
+        ClusterMetadataManifest manifest7 = ClusterMetadataManifest.builder()
+            .indices(List.of(index2Metadata))
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .templatesMetadata(templateMetadataUpdated)
+            .settingMetadata(settingMetadataUpdated)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V2)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .routingTableVersion(0L)
+            .indicesRouting(indicesRouting2)
+            .build();
+
+        // active manifest have reference to index1Updated, index2, settingsUpdated, coordinationUpdated, templates, templatesUpdated
+        ClusterMetadataManifest manifest4 = ClusterMetadataManifest.builder(manifest3)
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .build();
+        ClusterMetadataManifest manifest5 = ClusterMetadataManifest.builder(manifest4).templatesMetadata(templateMetadataUpdated).build();
+
+        when(remoteManifestManager.fetchRemoteClusterMetadataManifest(eq(clusterName), eq(clusterUUID), any())).thenReturn(
+            manifest4,
+            manifest5,
+            manifest7,
+            manifest1,
+            manifest2,
+            manifest3,
+            manifest6
+        );
+        when(remoteManifestManager.getManifestFolderPath(eq(clusterName), eq(clusterUUID))).thenReturn(
+            new BlobPath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID).add(MANIFEST)
+        );
+        BlobContainer container = mock(BlobContainer.class);
+        when(blobStore.blobContainer(any())).thenReturn(container);
+        doNothing().when(container).deleteBlobsIgnoringIfNotExists(any());
+        remoteClusterStateCleanupManager.start();
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        verify(container).deleteBlobsIgnoringIfNotExists(
+            List.of(
+                // coordination/setting metadata is from CODEC_V2, the uploaded filename with contain the complete path
+                coordinationMetadata.getUploadedFilename(),
+                settingMetadata.getUploadedFilename(),
+                new BlobPath().add(GLOBAL_METADATA_PATH_TOKEN).buildAsString() + "global_metadata.dat"
+            )
+        );
+        verify(container).deleteBlobsIgnoringIfNotExists(List.of(getFormattedIndexFileName(index1Metadata.getUploadedFilePath())));
+        Set<String> staleManifest = new HashSet<>();
+        inactiveBlobs.forEach(
+            blob -> staleManifest.add(
+                remoteClusterStateService.getRemoteManifestManager().getManifestFolderPath(clusterName, clusterUUID).buildAsString() + blob
+                    .name()
+            )
+        );
+        verify(container).deleteBlobsIgnoringIfNotExists(new ArrayList<>(staleManifest));
+        verify(remoteRoutingTableService).deleteStaleIndexRoutingPaths(List.of(index3Metadata.getUploadedFilename()));
+    }
+
+    public void testDeleteStaleIndicesRoutingDiffFile() throws IOException {
+        String clusterUUID = "clusterUUID";
+        String clusterName = "test-cluster";
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+
+        UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
+        UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
+        UploadedMetadataAttribute settingMetadata = new UploadedMetadataAttribute(SETTING_METADATA, "settings_metadata");
+        UploadedMetadataAttribute coordinationMetadataUpdated = new UploadedMetadataAttribute(
+            COORDINATION_METADATA,
+            "coordination_metadata_updated"
+        );
+
+        UploadedIndexMetadata index1Metadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1__2");
+        UploadedIndexMetadata index2Metadata = new UploadedIndexMetadata("index2", "indexUUID2", "index_metadata2__2");
+        List<UploadedIndexMetadata> indicesRouting1 = List.of(index1Metadata);
+        List<UploadedIndexMetadata> indicesRouting2 = List.of(index2Metadata);
+        ClusterStateDiffManifest diffManifest1 = ClusterStateDiffManifest.builder().indicesRoutingDiffPath("index1RoutingDiffPath").build();
+        ClusterStateDiffManifest diffManifest2 = ClusterStateDiffManifest.builder().indicesRoutingDiffPath("index2RoutingDiffPath").build();
+
+        ClusterMetadataManifest manifest1 = ClusterMetadataManifest.builder()
+            .indices(List.of(index1Metadata))
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .templatesMetadata(templateMetadata)
+            .settingMetadata(settingMetadata)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V3)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .routingTableVersion(0L)
+            .indicesRouting(indicesRouting1)
+            .diffManifest(diffManifest1)
+            .build();
+        ClusterMetadataManifest manifest2 = ClusterMetadataManifest.builder(manifest1)
+            .indices(List.of(index2Metadata))
+            .indicesRouting(indicesRouting2)
+            .diffManifest(diffManifest2)
+            .build();
+
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        doThrow(IOException.class).when(blobContainer).delete();
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        BlobPath blobPath = new BlobPath().add("random-path");
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        remoteClusterStateCleanupManager.start();
+        when(remoteManifestManager.getManifestFolderPath(eq(clusterName), eq(clusterUUID))).thenReturn(
+            new BlobPath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID).add(MANIFEST)
+        );
+        when(remoteManifestManager.fetchRemoteClusterMetadataManifest(eq(clusterName), eq(clusterUUID), any())).thenReturn(
+            manifest2,
+            manifest1
+        );
+        remoteClusterStateCleanupManager = new RemoteClusterStateCleanupManager(
+            remoteClusterStateService,
+            clusterService,
+            remoteRoutingTableService
+        );
+        remoteClusterStateCleanupManager.start();
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        verify(remoteRoutingTableService).deleteStaleIndexRoutingDiffPaths(List.of("index1RoutingDiffPath"));
+    }
+
+    public void testDeleteClusterMetadataNoOpsRoutingTableService() throws IOException {
+        String clusterUUID = "clusterUUID";
+        String clusterName = "test-cluster";
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+
+        UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
+        UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
+        UploadedMetadataAttribute settingMetadata = new UploadedMetadataAttribute(SETTING_METADATA, "settings_metadata");
+        UploadedMetadataAttribute coordinationMetadataUpdated = new UploadedMetadataAttribute(
+            COORDINATION_METADATA,
+            "coordination_metadata_updated"
+        );
+
+        UploadedIndexMetadata index1Metadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1__2");
+        UploadedIndexMetadata index2Metadata = new UploadedIndexMetadata("index2", "indexUUID2", "index_metadata2__2");
+        List<UploadedIndexMetadata> indicesRouting1 = List.of(index1Metadata);
+        List<UploadedIndexMetadata> indicesRouting2 = List.of(index2Metadata);
+
+        ClusterMetadataManifest manifest1 = ClusterMetadataManifest.builder()
+            .indices(List.of(index1Metadata))
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .templatesMetadata(templateMetadata)
+            .settingMetadata(settingMetadata)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V2)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .routingTableVersion(0L)
+            .indicesRouting(indicesRouting1)
+            .build();
+        ClusterMetadataManifest manifest2 = ClusterMetadataManifest.builder(manifest1)
+            .indices(List.of(index2Metadata))
+            .indicesRouting(indicesRouting2)
+            .build();
+
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        doThrow(IOException.class).when(blobContainer).delete();
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        BlobPath blobPath = new BlobPath().add("random-path");
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        remoteClusterStateCleanupManager.start();
+        when(remoteManifestManager.getManifestFolderPath(eq(clusterName), eq(clusterUUID))).thenReturn(
+            new BlobPath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID).add(MANIFEST)
+        );
+        when(remoteManifestManager.fetchRemoteClusterMetadataManifest(eq(clusterName), eq(clusterUUID), any())).thenReturn(
+            manifest2,
+            manifest1
+        );
+        remoteRoutingTableService = mock(NoopRemoteRoutingTableService.class);
+        remoteClusterStateCleanupManager = new RemoteClusterStateCleanupManager(
+            remoteClusterStateService,
+            clusterService,
+            remoteRoutingTableService
+        );
+        remoteClusterStateCleanupManager.start();
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        verify(remoteRoutingTableService).deleteStaleIndexRoutingPaths(List.of(index1Metadata.getUploadedFilename()));
+    }
+
+    public void testDeleteStaleClusterUUIDs() throws IOException {
+        final ClusterState clusterState = RemoteClusterStateServiceTests.generateClusterStateWithOneIndex()
+            .nodes(RemoteClusterStateServiceTests.nodesWithLocalNodeClusterManager())
+            .build();
+        ClusterMetadataManifest clusterMetadataManifest = ClusterMetadataManifest.builder()
+            .indices(List.of())
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID("cluster-uuid1")
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .build();
+
+        BlobPath blobPath = new BlobPath().add("random-path");
+        BlobContainer uuidContainerContainer = mock(BlobContainer.class);
+        BlobContainer manifest2Container = mock(BlobContainer.class);
+        BlobContainer manifest3Container = mock(BlobContainer.class);
+        when(blobStore.blobContainer(any())).then(invocation -> {
+            BlobPath blobPath1 = invocation.getArgument(0);
+            if (blobPath1.buildAsString().endsWith("cluster-state/")) {
+                return uuidContainerContainer;
+            } else if (blobPath1.buildAsString().contains("cluster-state/cluster-uuid2/")) {
+                return manifest2Container;
+            } else if (blobPath1.buildAsString().contains("cluster-state/cluster-uuid3/")) {
+                return manifest3Container;
+            } else {
+                throw new IllegalArgumentException("Unexpected blob path " + blobPath1);
+            }
+        });
+        when(
+            manifest2Container.listBlobsByPrefixInSortedOrder(
+                MANIFEST + DELIMITER,
+                Integer.MAX_VALUE,
+                BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
+            )
+        ).thenReturn(List.of(new PlainBlobMetadata("mainfest2", 1L)));
+        when(
+            manifest3Container.listBlobsByPrefixInSortedOrder(
+                MANIFEST + DELIMITER,
+                Integer.MAX_VALUE,
+                BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
+            )
+        ).thenReturn(List.of(new PlainBlobMetadata("mainfest3", 1L)));
+        Set<String> uuids = new HashSet<>(Arrays.asList("cluster-uuid1", "cluster-uuid2", "cluster-uuid3"));
+        when(remoteClusterStateService.getAllClusterUUIDs(any())).thenReturn(uuids);
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        remoteClusterStateCleanupManager.start();
+        remoteClusterStateCleanupManager.deleteStaleClusterUUIDs(clusterState, clusterMetadataManifest);
+        try {
+            assertBusy(() -> {
+                verify(manifest2Container, times(1)).delete();
+                verify(manifest3Container, times(1)).delete();
+            });
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void testRemoteStateCleanupFailureStats() throws IOException {
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        doThrow(IOException.class).when(blobContainer).delete();
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        BlobPath blobPath = new BlobPath().add("random-path");
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        remoteClusterStateCleanupManager.start();
+        remoteClusterStateCleanupManager.deleteStaleUUIDsClusterMetadata("cluster1", Arrays.asList("cluster-uuid1"));
+        try {
+            assertBusy(() -> {
+                // wait for stats to get updated
+                assertTrue(remoteClusterStateCleanupManager.getStats() != null);
+                assertEquals(0, remoteClusterStateCleanupManager.getStats().getUploadStats().getSuccessCount());
+                assertEquals(1, remoteClusterStateCleanupManager.getStats().getCleanupAttemptFailedCount());
+            });
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void testIndexRoutingFilesCleanupFailureStats() throws Exception {
+        String clusterUUID = "clusterUUID";
+        String clusterName = "test-cluster";
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+
+        UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
+        UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
+        UploadedMetadataAttribute settingMetadata = new UploadedMetadataAttribute(SETTING_METADATA, "settings_metadata");
+        UploadedMetadataAttribute coordinationMetadataUpdated = new UploadedMetadataAttribute(
+            COORDINATION_METADATA,
+            "coordination_metadata_updated"
+        );
+
+        UploadedIndexMetadata index1Metadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1__2");
+        UploadedIndexMetadata index2Metadata = new UploadedIndexMetadata("index2", "indexUUID2", "index_metadata2__2");
+        List<UploadedIndexMetadata> indicesRouting1 = List.of(index1Metadata);
+        List<UploadedIndexMetadata> indicesRouting2 = List.of(index2Metadata);
+
+        ClusterMetadataManifest manifest1 = ClusterMetadataManifest.builder()
+            .indices(List.of(index1Metadata))
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .templatesMetadata(templateMetadata)
+            .settingMetadata(settingMetadata)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V2)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .routingTableVersion(0L)
+            .indicesRouting(indicesRouting1)
+            .build();
+        ClusterMetadataManifest manifest2 = ClusterMetadataManifest.builder(manifest1)
+            .indices(List.of(index2Metadata))
+            .indicesRouting(indicesRouting2)
+            .build();
+
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        doThrow(IOException.class).when(blobContainer).delete();
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+
+        BlobPath blobPath = new BlobPath().add("random-path");
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        remoteClusterStateCleanupManager.start();
+        when(remoteManifestManager.getManifestFolderPath(eq(clusterName), eq(clusterUUID))).thenReturn(
+            new BlobPath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID).add(MANIFEST)
+        );
+        when(remoteManifestManager.fetchRemoteClusterMetadataManifest(eq(clusterName), eq(clusterUUID), any())).thenReturn(
+            manifest1,
+            manifest2
+        );
+        doNothing().when(remoteRoutingTableService).deleteStaleIndexRoutingPaths(any());
+
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        assertBusy(() -> {
+            // wait for stats to get updated
+            assertNotNull(remoteClusterStateCleanupManager.getStats());
+            assertEquals(0, remoteClusterStateCleanupManager.getStats().getIndexRoutingFilesCleanupAttemptFailedCount());
+        });
+
+        doThrow(IOException.class).when(remoteRoutingTableService).deleteStaleIndexRoutingPaths(any());
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        assertBusy(() -> {
+            // wait for stats to get updated
+            assertNotNull(remoteClusterStateCleanupManager.getStats());
+            assertEquals(1, remoteClusterStateCleanupManager.getStats().getIndexRoutingFilesCleanupAttemptFailedCount());
+        });
+    }
+
+    public void testIndicesRoutingDiffFilesCleanupFailureStats() throws Exception {
+        String clusterUUID = "clusterUUID";
+        String clusterName = "test-cluster";
+        List<BlobMetadata> inactiveBlobs = Arrays.asList(new PlainBlobMetadata("manifest1.dat", 1L));
+        List<BlobMetadata> activeBlobs = Arrays.asList(new PlainBlobMetadata("manifest2.dat", 1L));
+
+        UploadedMetadataAttribute coordinationMetadata = new UploadedMetadataAttribute(COORDINATION_METADATA, "coordination_metadata");
+        UploadedMetadataAttribute templateMetadata = new UploadedMetadataAttribute(TEMPLATES_METADATA, "template_metadata");
+        UploadedMetadataAttribute settingMetadata = new UploadedMetadataAttribute(SETTING_METADATA, "settings_metadata");
+        UploadedMetadataAttribute coordinationMetadataUpdated = new UploadedMetadataAttribute(
+            COORDINATION_METADATA,
+            "coordination_metadata_updated"
+        );
+
+        UploadedIndexMetadata index1Metadata = new UploadedIndexMetadata("index1", "indexUUID1", "index_metadata1__2");
+        UploadedIndexMetadata index2Metadata = new UploadedIndexMetadata("index2", "indexUUID2", "index_metadata2__2");
+        List<UploadedIndexMetadata> indicesRouting1 = List.of(index1Metadata);
+        List<UploadedIndexMetadata> indicesRouting2 = List.of(index2Metadata);
+        ClusterStateDiffManifest diffManifest1 = ClusterStateDiffManifest.builder().indicesRoutingDiffPath("index1RoutingDiffPath").build();
+        ClusterStateDiffManifest diffManifest2 = ClusterStateDiffManifest.builder().indicesRoutingDiffPath("index2RoutingDiffPath").build();
+
+        ClusterMetadataManifest manifest1 = ClusterMetadataManifest.builder()
+            .indices(List.of(index1Metadata))
+            .coordinationMetadata(coordinationMetadataUpdated)
+            .templatesMetadata(templateMetadata)
+            .settingMetadata(settingMetadata)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .codecVersion(CODEC_V3)
+            .stateUUID(randomAlphaOfLength(10))
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
+            .committed(true)
+            .routingTableVersion(0L)
+            .indicesRouting(indicesRouting1)
+            .diffManifest(diffManifest1)
+            .build();
+        ClusterMetadataManifest manifest2 = ClusterMetadataManifest.builder(manifest1)
+            .indices(List.of(index2Metadata))
+            .indicesRouting(indicesRouting2)
+            .diffManifest(diffManifest2)
+            .build();
+
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        doThrow(IOException.class).when(blobContainer).delete();
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+
+        BlobPath blobPath = new BlobPath().add("random-path");
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        remoteClusterStateCleanupManager.start();
+        when(remoteManifestManager.getManifestFolderPath(eq(clusterName), eq(clusterUUID))).thenReturn(
+            new BlobPath().add(encodeString(clusterName)).add(CLUSTER_STATE_PATH_TOKEN).add(clusterUUID).add(MANIFEST)
+        );
+        when(remoteManifestManager.fetchRemoteClusterMetadataManifest(eq(clusterName), eq(clusterUUID), any())).thenReturn(
+            manifest1,
+            manifest2
+        );
+        doNothing().when(remoteRoutingTableService).deleteStaleIndexRoutingDiffPaths(any());
+
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        assertBusy(() -> {
+            // wait for stats to get updated
+            assertNotNull(remoteClusterStateCleanupManager.getStats());
+            assertEquals(0, remoteClusterStateCleanupManager.getStats().getIndicesRoutingDiffFileCleanupAttemptFailedCount());
+        });
+
+        doThrow(IOException.class).when(remoteRoutingTableService).deleteStaleIndexRoutingDiffPaths(any());
+        remoteClusterStateCleanupManager.deleteClusterMetadata(clusterName, clusterUUID, activeBlobs, inactiveBlobs);
+        assertBusy(() -> {
+            // wait for stats to get updated
+            assertNotNull(remoteClusterStateCleanupManager.getStats());
+            assertEquals(1, remoteClusterStateCleanupManager.getStats().getIndicesRoutingDiffFileCleanupAttemptFailedCount());
+        });
+    }
+
+    public void testSingleConcurrentExecutionOfStaleManifestCleanup() throws Exception {
+        BlobContainer blobContainer = mock(BlobContainer.class);
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+
+        CountDownLatch latch = new CountDownLatch(1);
+        AtomicInteger callCount = new AtomicInteger(0);
+        doAnswer(invocation -> {
+            callCount.incrementAndGet();
+            if (latch.await(5000, TimeUnit.SECONDS) == false) {
+                throw new Exception("Timed out waiting for delete task queuing to complete");
+            }
+            return null;
+        }).when(blobContainer)
+            .listBlobsByPrefixInSortedOrder(
+                any(String.class),
+                any(int.class),
+                any(BlobContainer.BlobNameSortOrder.class),
+                any(ActionListener.class)
+            );
+
+        remoteClusterStateCleanupManager.start();
+        remoteClusterStateCleanupManager.deleteStaleClusterMetadata("cluster-name", "cluster-uuid", RETAINED_MANIFESTS);
+        remoteClusterStateCleanupManager.deleteStaleClusterMetadata("cluster-name", "cluster-uuid", RETAINED_MANIFESTS);
+
+        latch.countDown();
+        assertBusy(() -> assertEquals(1, callCount.get()));
+    }
+
+    public void testRemoteClusterStateCleanupSetting() {
+        remoteClusterStateCleanupManager.start();
+        // verify default value
+        assertEquals(CLUSTER_STATE_CLEANUP_INTERVAL_DEFAULT, remoteClusterStateCleanupManager.getStaleFileCleanupInterval());
+
+        // verify update interval
+        int cleanupInterval = randomIntBetween(1, 10);
+        Settings newSettings = Settings.builder().put("cluster.remote_store.state.cleanup_interval", cleanupInterval + "s").build();
+        clusterSettings.applySettings(newSettings);
+        assertEquals(cleanupInterval, remoteClusterStateCleanupManager.getStaleFileCleanupInterval().seconds());
+    }
+
+    public void testRemoteCleanupTaskScheduled() {
+        AbstractAsyncTask cleanupTask = remoteClusterStateCleanupManager.getStaleFileDeletionTask();
+        assertNull(cleanupTask);
+        // now the task should be initialized
+        remoteClusterStateCleanupManager.start();
+        assertNotNull(remoteClusterStateCleanupManager.getStaleFileDeletionTask());
+        assertTrue(remoteClusterStateCleanupManager.getStaleFileDeletionTask().mustReschedule());
+        assertEquals(
+            clusterSettings.get(REMOTE_CLUSTER_STATE_CLEANUP_INTERVAL_SETTING),
+            remoteClusterStateCleanupManager.getStaleFileDeletionTask().getInterval()
+        );
+        assertTrue(remoteClusterStateCleanupManager.getStaleFileDeletionTask().isScheduled());
+        assertFalse(remoteClusterStateCleanupManager.getStaleFileDeletionTask().isClosed());
+    }
+
+    public void testRemoteCleanupSkipsOnOnlyElectedClusterManager() {
+        DiscoveryNodes nodes = mock(DiscoveryNodes.class);
+        when(nodes.isLocalNodeElectedClusterManager()).thenReturn(false);
+        when(clusterState.nodes()).thenReturn(nodes);
+        RemoteClusterStateCleanupManager spyManager = spy(remoteClusterStateCleanupManager);
+        AtomicInteger callCount = new AtomicInteger(0);
+        doAnswer(invocation -> callCount.incrementAndGet()).when(spyManager).deleteStaleClusterMetadata(any(), any(), anyInt());
+        spyManager.cleanUpStaleFiles();
+        assertEquals(0, callCount.get());
+
+        when(nodes.isLocalNodeElectedClusterManager()).thenReturn(true);
+        when(clusterState.version()).thenReturn(randomLongBetween(11, 20));
+        spyManager.cleanUpStaleFiles();
+        assertEquals(1, callCount.get());
+    }
+
+    public void testRemoteCleanupSkipsIfVersionIncrementLessThanThreshold() {
+        DiscoveryNodes nodes = mock(DiscoveryNodes.class);
+        long version = randomLongBetween(1, SKIP_CLEANUP_STATE_CHANGES);
+        when(clusterApplierService.state()).thenReturn(clusterState);
+        when(nodes.isLocalNodeElectedClusterManager()).thenReturn(true);
+        when(clusterState.nodes()).thenReturn(nodes);
+        when(clusterState.version()).thenReturn(version);
+
+        RemoteClusterStateCleanupManager spyManager = spy(remoteClusterStateCleanupManager);
+        AtomicInteger callCount = new AtomicInteger(0);
+        doAnswer(invocation -> callCount.incrementAndGet()).when(spyManager).deleteStaleClusterMetadata(any(), any(), anyInt());
+
+        remoteClusterStateCleanupManager.cleanUpStaleFiles();
+        assertEquals(0, callCount.get());
+    }
+
+    public void testRemoteCleanupCallsDeleteIfVersionIncrementGreaterThanThreshold() {
+        DiscoveryNodes nodes = mock(DiscoveryNodes.class);
+        long version = randomLongBetween(SKIP_CLEANUP_STATE_CHANGES + 1, SKIP_CLEANUP_STATE_CHANGES + 10);
+        when(clusterApplierService.state()).thenReturn(clusterState);
+        when(nodes.isLocalNodeElectedClusterManager()).thenReturn(true);
+        when(clusterState.nodes()).thenReturn(nodes);
+        when(clusterState.version()).thenReturn(version);
+
+        RemoteClusterStateCleanupManager spyManager = spy(remoteClusterStateCleanupManager);
+        AtomicInteger callCount = new AtomicInteger(0);
+        doAnswer(invocation -> callCount.incrementAndGet()).when(spyManager).deleteStaleClusterMetadata(any(), any(), anyInt());
+
+        // using spied cleanup manager so that stubbed deleteStaleClusterMetadata is called
+        spyManager.cleanUpStaleFiles();
+        assertEquals(1, callCount.get());
+    }
+
+    public void testRemoteCleanupSchedulesEvenAfterFailure() {
+        remoteClusterStateCleanupManager.start();
+        RemoteClusterStateCleanupManager spyManager = spy(remoteClusterStateCleanupManager);
+        AtomicInteger callCount = new AtomicInteger(0);
+        doAnswer(invocationOnMock -> {
+            callCount.incrementAndGet();
+            throw new RuntimeException("Test exception");
+        }).when(spyManager).cleanUpStaleFiles();
+        AsyncStaleFileDeletion task = new AsyncStaleFileDeletion(spyManager);
+        assertTrue(task.isScheduled());
+        task.run();
+        // Task is still scheduled after the failure
+        assertTrue(task.isScheduled());
+        assertEquals(1, callCount.get());
+
+        task.run();
+        // Task is still scheduled after the failure
+        assertTrue(task.isScheduled());
+        assertEquals(2, callCount.get());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
index 9f321cd62847c..9bfa0d9c0b80f 100644
--- a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateServiceTests.java
@@ -9,14 +9,27 @@
 package org.opensearch.gateway.remote;
 
 import org.opensearch.Version;
+import org.opensearch.action.LatchedActionListener;
 import org.opensearch.cluster.ClusterModule;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.RepositoryCleanupInProgress;
+import org.opensearch.cluster.block.ClusterBlocks;
 import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.metadata.DiffableStringMap;
 import org.opensearch.cluster.metadata.IndexGraveyard;
 import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.IndexTemplateMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.cluster.node.DiscoveryNode;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.cluster.routing.remote.InternalRemoteRoutingTableService;
+import org.opensearch.cluster.routing.remote.NoopRemoteRoutingTableService;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.CheckedRunnable;
 import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
 import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.common.blobstore.BlobMetadata;
@@ -29,22 +42,33 @@
 import org.opensearch.common.compress.DeflateCompressor;
 import org.opensearch.common.lucene.store.ByteArrayIndexInput;
 import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.AbstractClusterMetadataWriteableBlobEntity;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.ParseField;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedIndexMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.gateway.remote.model.RemoteClusterMetadataManifest;
+import org.opensearch.gateway.remote.model.RemoteClusterStateManifestInfo;
+import org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata;
 import org.opensearch.index.remote.RemoteIndexPathUploader;
-import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.indices.DefaultRemoteStoreSettings;
 import org.opensearch.indices.IndicesModule;
 import org.opensearch.repositories.FilterRepository;
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.repositories.RepositoryMissingException;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.blobstore.ChecksumWritableBlobStoreFormat;
 import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.VersionUtils;
@@ -61,42 +85,92 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiConsumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import org.mockito.ArgumentCaptor;
+import org.mockito.ArgumentMatcher;
 import org.mockito.ArgumentMatchers;
+import org.mockito.Mockito;
 
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
 import static java.util.stream.Collectors.toList;
-import static org.opensearch.gateway.remote.RemoteClusterStateService.DELIMITER;
-import static org.opensearch.gateway.remote.RemoteClusterStateService.FORMAT_PARAMS;
-import static org.opensearch.gateway.remote.RemoteClusterStateService.INDEX_METADATA_CURRENT_CODEC_VERSION;
-import static org.opensearch.gateway.remote.RemoteClusterStateService.MANIFEST_CURRENT_CODEC_VERSION;
-import static org.opensearch.gateway.remote.RemoteClusterStateService.MANIFEST_FILE_PREFIX;
-import static org.opensearch.gateway.remote.RemoteClusterStateService.METADATA_FILE_PREFIX;
-import static org.opensearch.gateway.remote.RemoteClusterStateService.RETAINED_MANIFESTS;
+import static org.opensearch.common.util.FeatureFlags.REMOTE_PUBLICATION_EXPERIMENTAL;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V1;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V2;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.MANIFEST_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_BLOCKS;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTE;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.CustomMetadata1;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.CustomMetadata2;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.CustomMetadata3;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom1;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom2;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.TestClusterStateCustom3;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CUSTOM_DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.FORMAT_PARAMS;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.getFormattedIndexFileName;
+import static org.opensearch.gateway.remote.RemoteGlobalMetadataManager.GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT;
+import static org.opensearch.gateway.remote.model.RemoteClusterBlocks.CLUSTER_BLOCKS_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteClusterBlocksTests.randomClusterBlocks;
+import static org.opensearch.gateway.remote.model.RemoteClusterStateCustoms.CLUSTER_STATE_CUSTOM;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.readFrom;
+import static org.opensearch.gateway.remote.model.RemoteDiscoveryNodes.DISCOVERY_NODES;
+import static org.opensearch.gateway.remote.model.RemoteDiscoveryNodes.DISCOVERY_NODES_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteDiscoveryNodesTests.getDiscoveryNodes;
+import static org.opensearch.gateway.remote.model.RemoteGlobalMetadata.GLOBAL_METADATA_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettingsTests.getHashesOfConsistentSettings;
+import static org.opensearch.gateway.remote.model.RemoteIndexMetadata.INDEX;
+import static org.opensearch.gateway.remote.model.RemoteIndexMetadata.INDEX_METADATA_FORMAT;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTINGS_METADATA_FORMAT;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadataTests.getTemplatesMetadata;
+import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.isRemoteRoutingTableEnabled;
+import static org.hamcrest.Matchers.anEmptyMap;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.hamcrest.Matchers.nullValue;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.anyMap;
 import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
@@ -104,13 +178,27 @@
 public class RemoteClusterStateServiceTests extends OpenSearchTestCase {
 
     private RemoteClusterStateService remoteClusterStateService;
+    private ClusterService clusterService;
     private ClusterSettings clusterSettings;
     private Supplier<RepositoriesService> repositoriesServiceSupplier;
     private RepositoriesService repositoriesService;
     private BlobStoreRepository blobStoreRepository;
+    private Compressor compressor;
     private BlobStore blobStore;
+    private Settings settings;
+    private boolean publicationEnabled;
+    private NamedWriteableRegistry namedWriteableRegistry;
     private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
 
+    private static final String NODE_ID = "test-node";
+    private static final String COORDINATION_METADATA_FILENAME = "coordination-metadata-file__1";
+    private static final String PERSISTENT_SETTINGS_FILENAME = "persistent-settings-file__1";
+    private static final String TRANSIENT_SETTINGS_FILENAME = "transient-settings-file__1";
+    private static final String TEMPLATES_METADATA_FILENAME = "templates-metadata-file__1";
+    private static final String DISCOVERY_NODES_FILENAME = "discovery-nodes-file__1";
+    private static final String CLUSTER_BLOCKS_FILENAME = "cluster-blocks-file__1";
+    private static final String HASHES_OF_CONSISTENT_SETTINGS_FILENAME = "consistent-settings-hashes-file__1";
+
     @Before
     public void setup() {
         repositoriesServiceSupplier = mock(Supplier.class);
@@ -128,14 +216,22 @@ public void setup() {
             "remote_store_repository"
         );
 
-        Settings settings = Settings.builder()
+        settings = Settings.builder()
             .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, "remote_store_repository")
             .put(stateRepoTypeAttributeKey, FsRepository.TYPE)
             .put(stateRepoSettingsAttributeKeyPrefix + "location", "randomRepoPath")
             .put(RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, "routing_repository")
             .build();
+        List<NamedWriteableRegistry.Entry> writeableEntries = ClusterModule.getNamedWriteables();
+        writeableEntries.add(new NamedWriteableRegistry.Entry(Metadata.Custom.class, CustomMetadata1.TYPE, CustomMetadata1::new));
+        writeableEntries.add(new NamedWriteableRegistry.Entry(Metadata.Custom.class, CustomMetadata2.TYPE, CustomMetadata2::new));
+        writeableEntries.add(new NamedWriteableRegistry.Entry(Metadata.Custom.class, CustomMetadata3.TYPE, CustomMetadata3::new));
+        namedWriteableRegistry = new NamedWriteableRegistry(writeableEntries);
 
         clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        clusterService = mock(ClusterService.class);
+        when(clusterService.getClusterSettings()).thenReturn(clusterSettings);
         NamedXContentRegistry xContentRegistry = new NamedXContentRegistry(
             Stream.of(
                 NetworkModule.getNamedXContents().stream(),
@@ -144,19 +240,31 @@ public void setup() {
             ).flatMap(Function.identity()).collect(toList())
         );
 
+        compressor = new DeflateCompressor();
         blobStoreRepository = mock(BlobStoreRepository.class);
         blobStore = mock(BlobStore.class);
         when(blobStoreRepository.blobStore()).thenReturn(blobStore);
         when(repositoriesService.repository("remote_store_repository")).thenReturn(blobStoreRepository);
+        when(repositoriesService.repository("routing_repository")).thenReturn(blobStoreRepository);
+
         when(blobStoreRepository.getNamedXContentRegistry()).thenReturn(xContentRegistry);
         remoteClusterStateService = new RemoteClusterStateService(
             "test-node-id",
             repositoriesServiceSupplier,
             settings,
-            clusterSettings,
+            clusterService,
             () -> 0L,
             threadPool,
-            List.of(new RemoteIndexPathUploader(threadPool, settings, repositoriesServiceSupplier, clusterSettings))
+            List.of(
+                new RemoteIndexPathUploader(
+                    threadPool,
+                    settings,
+                    repositoriesServiceSupplier,
+                    clusterSettings,
+                    DefaultRemoteStoreSettings.INSTANCE
+                )
+            ),
+            namedWriteableRegistry
         );
     }
 
@@ -164,28 +272,44 @@ public void setup() {
     public void teardown() throws Exception {
         super.tearDown();
         remoteClusterStateService.close();
+        publicationEnabled = false;
+        Settings nodeSettings = Settings.builder().build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
         threadPool.shutdown();
     }
 
     public void testFailWriteFullMetadataNonClusterManagerNode() throws IOException {
         final ClusterState clusterState = generateClusterStateWithOneIndex().build();
-        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(clusterState, randomAlphaOfLength(10));
-        Assert.assertThat(manifest, nullValue());
+        final RemoteClusterStateManifestInfo manifestDetails = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            randomAlphaOfLength(10),
+            MANIFEST_CURRENT_CODEC_VERSION
+        );
+        Assert.assertThat(manifestDetails, nullValue());
     }
 
     public void testFailInitializationWhenRemoteStateDisabled() {
         final Settings settings = Settings.builder().build();
-        ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        when(clusterService.getClusterSettings()).thenReturn(new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS));
         assertThrows(
             AssertionError.class,
             () -> new RemoteClusterStateService(
                 "test-node-id",
                 repositoriesServiceSupplier,
                 settings,
-                clusterSettings,
+                clusterService,
                 () -> 0L,
                 threadPool,
-                List.of(new RemoteIndexPathUploader(threadPool, settings, repositoriesServiceSupplier, clusterSettings))
+                List.of(
+                    new RemoteIndexPathUploader(
+                        threadPool,
+                        settings,
+                        repositoriesServiceSupplier,
+                        clusterSettings,
+                        DefaultRemoteStoreSettings.INSTANCE
+                    )
+                ),
+                writableRegistry()
             )
         );
     }
@@ -205,7 +329,83 @@ public void testWriteFullMetadataSuccess() throws IOException {
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         mockBlobStoreObjects();
         remoteClusterStateService.start();
-        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(clusterState, "prev-cluster-uuid");
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            "prev-cluster-uuid",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
+
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(indices)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .previousClusterUUID("prev-cluster-uuid")
+            .build();
+
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
+        assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
+        assertThat(manifest.getIndices().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getPreviousClusterUUID(), is(expectedManifest.getPreviousClusterUUID()));
+        assertThat(manifest.getGlobalMetadataFileName(), nullValue());
+        assertThat(manifest.getCoordinationMetadata(), notNullValue());
+        assertThat(manifest.getSettingsMetadata(), notNullValue());
+        assertThat(manifest.getTemplatesMetadata(), notNullValue());
+        assertFalse(manifest.getCustomMetadataMap().isEmpty());
+        assertThat(manifest.getCustomMetadataMap().containsKey(CustomMetadata1.TYPE), is(true));
+        assertThat(manifest.getClusterBlocksMetadata(), nullValue());
+        assertThat(manifest.getDiscoveryNodesMetadata(), nullValue());
+        assertThat(manifest.getTransientSettingsMetadata(), nullValue());
+        assertThat(manifest.getHashesOfConsistentSettings(), nullValue());
+        assertThat(manifest.getClusterStateCustomMap().size(), is(0));
+    }
+
+    public void testWriteFullMetadataSuccessPublicationEnabled() throws IOException {
+        // TODO Make the publication flag parameterized
+        publicationEnabled = true;
+        Settings nodeSettings = Settings.builder().put(REMOTE_PUBLICATION_EXPERIMENTAL, publicationEnabled).build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+        remoteClusterStateService = new RemoteClusterStateService(
+            "test-node-id",
+            repositoriesServiceSupplier,
+            settings,
+            clusterService,
+            () -> 0L,
+            threadPool,
+            List.of(
+                new RemoteIndexPathUploader(
+                    threadPool,
+                    settings,
+                    repositoriesServiceSupplier,
+                    clusterSettings,
+                    DefaultRemoteStoreSettings.INSTANCE
+                )
+            ),
+            writableRegistry()
+        );
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager())
+            .customs(
+                Map.of(
+                    RepositoryCleanupInProgress.TYPE,
+                    new RepositoryCleanupInProgress(List.of(new RepositoryCleanupInProgress.Entry("test-repo", 10L)))
+                )
+            )
+            .build();
+        mockBlobStoreObjects();
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            "prev-cluster-uuid",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
         final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
         List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
 
@@ -227,29 +427,37 @@ public void testWriteFullMetadataSuccess() throws IOException {
         assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
         assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
         assertThat(manifest.getPreviousClusterUUID(), is(expectedManifest.getPreviousClusterUUID()));
+        assertThat(manifest.getGlobalMetadataFileName(), nullValue());
+        assertThat(manifest.getCoordinationMetadata(), notNullValue());
+        assertThat(manifest.getSettingsMetadata(), notNullValue());
+        assertThat(manifest.getTemplatesMetadata(), notNullValue());
+        assertFalse(manifest.getCustomMetadataMap().isEmpty());
+        assertThat(manifest.getCustomMetadataMap().containsKey(CustomMetadata1.TYPE), is(true));
+        assertThat(manifest.getClusterStateCustomMap().size(), is(1));
+        assertThat(manifest.getClusterStateCustomMap().containsKey(RepositoryCleanupInProgress.TYPE), is(true));
     }
 
     public void testWriteFullMetadataInParallelSuccess() throws IOException {
+        // TODO Add test with publication flag enabled
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         AsyncMultiStreamBlobContainer container = (AsyncMultiStreamBlobContainer) mockBlobStoreObjects(AsyncMultiStreamBlobContainer.class);
 
         ArgumentCaptor<ActionListener<Void>> actionListenerArgumentCaptor = ArgumentCaptor.forClass(ActionListener.class);
         ArgumentCaptor<WriteContext> writeContextArgumentCaptor = ArgumentCaptor.forClass(WriteContext.class);
-        AtomicReference<WriteContext> capturedWriteContext = new AtomicReference<>();
+        ConcurrentHashMap<String, WriteContext> capturedWriteContext = new ConcurrentHashMap<>();
         doAnswer((i) -> {
             actionListenerArgumentCaptor.getValue().onResponse(null);
-            return null;
-        }).doAnswer((i) -> {
-            actionListenerArgumentCaptor.getValue().onResponse(null);
-            capturedWriteContext.set(writeContextArgumentCaptor.getValue());
-            return null;
-        }).doAnswer((i) -> {
-            actionListenerArgumentCaptor.getValue().onResponse(null);
+            WriteContext writeContext = writeContextArgumentCaptor.getValue();
+            capturedWriteContext.put(writeContext.getFileName().split(DELIMITER)[0], writeContextArgumentCaptor.getValue());
             return null;
         }).when(container).asyncBlobUpload(writeContextArgumentCaptor.capture(), actionListenerArgumentCaptor.capture());
 
         remoteClusterStateService.start();
-        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(clusterState, "prev-cluster-uuid");
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            "prev-cluster-uuid",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
 
         final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
         List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
@@ -267,37 +475,41 @@ public void testWriteFullMetadataInParallelSuccess() throws IOException {
         assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
         assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
         assertThat(manifest.getIndices().get(0).getUploadedFilename(), notNullValue());
-        assertThat(manifest.getGlobalMetadataFileName(), notNullValue());
+        assertThat(manifest.getGlobalMetadataFileName(), nullValue());
+        assertThat(manifest.getCoordinationMetadata(), notNullValue());
+        assertThat(manifest.getSettingsMetadata(), notNullValue());
+        assertThat(manifest.getTemplatesMetadata(), notNullValue());
+        assertThat(manifest.getCustomMetadataMap().size(), not(0));
         assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
         assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
         assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
         assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
         assertThat(manifest.getPreviousClusterUUID(), is(expectedManifest.getPreviousClusterUUID()));
 
-        assertEquals(actionListenerArgumentCaptor.getAllValues().size(), 3);
-        assertEquals(writeContextArgumentCaptor.getAllValues().size(), 3);
+        assertEquals(8, actionListenerArgumentCaptor.getAllValues().size());
+        assertEquals(8, writeContextArgumentCaptor.getAllValues().size());
 
-        byte[] writtenBytes = capturedWriteContext.get()
+        byte[] writtenBytes = capturedWriteContext.get("metadata")
             .getStreamProvider(Integer.MAX_VALUE)
             .provideStream(0)
             .getInputStream()
             .readAllBytes();
-        IndexMetadata writtenIndexMetadata = RemoteClusterStateService.INDEX_METADATA_FORMAT.deserialize(
-            capturedWriteContext.get().getFileName(),
+        IndexMetadata writtenIndexMetadata = INDEX_METADATA_FORMAT.deserialize(
+            capturedWriteContext.get("metadata").getFileName(),
             blobStoreRepository.getNamedXContentRegistry(),
             new BytesArray(writtenBytes)
         );
 
-        assertEquals(capturedWriteContext.get().getWritePriority(), WritePriority.URGENT);
+        assertEquals(capturedWriteContext.get("metadata").getWritePriority(), WritePriority.URGENT);
         assertEquals(writtenIndexMetadata.getNumberOfShards(), 1);
         assertEquals(writtenIndexMetadata.getNumberOfReplicas(), 0);
         assertEquals(writtenIndexMetadata.getIndex().getName(), "test-index");
         assertEquals(writtenIndexMetadata.getIndex().getUUID(), "index-uuid");
         long expectedChecksum = RemoteTransferContainer.checksumOfChecksum(new ByteArrayIndexInput("metadata-filename", writtenBytes), 8);
-        if (capturedWriteContext.get().doRemoteDataIntegrityCheck()) {
-            assertEquals(capturedWriteContext.get().getExpectedChecksum().longValue(), expectedChecksum);
+        if (capturedWriteContext.get("metadata").doRemoteDataIntegrityCheck()) {
+            assertEquals(capturedWriteContext.get("metadata").getExpectedChecksum().longValue(), expectedChecksum);
         } else {
-            assertEquals(capturedWriteContext.get().getExpectedChecksum(), null);
+            assertEquals(capturedWriteContext.get("metadata").getExpectedChecksum(), null);
         }
 
     }
@@ -321,8 +533,8 @@ public void run() {
 
         remoteClusterStateService.start();
         assertThrows(
-            RemoteClusterStateService.RemoteStateTransferException.class,
-            () -> remoteClusterStateService.writeFullMetadata(clusterState, randomAlphaOfLength(10))
+            RemoteStateTransferException.class,
+            () -> remoteClusterStateService.writeFullMetadata(clusterState, randomAlphaOfLength(10), MANIFEST_CURRENT_CODEC_VERSION)
         );
     }
 
@@ -339,24 +551,36 @@ public void testTimeoutWhileWritingManifestFile() throws IOException {
 
         ArgumentCaptor<ActionListener<Void>> actionListenerArgumentCaptor = ArgumentCaptor.forClass(ActionListener.class);
 
-        doAnswer((i) -> { // For Global Metadata
-            actionListenerArgumentCaptor.getValue().onResponse(null);
-            return null;
-        }).doAnswer((i) -> { // For Index Metadata
-            actionListenerArgumentCaptor.getValue().onResponse(null);
-            return null;
-        }).doAnswer((i) -> {
+        doAnswer((i) -> {
             // For Manifest file perform No Op, so latch in code will timeout
             return null;
         }).when(container).asyncBlobUpload(any(WriteContext.class), actionListenerArgumentCaptor.capture());
 
         remoteClusterStateService.start();
-        try {
-            remoteClusterStateService.writeFullMetadata(clusterState, randomAlphaOfLength(10));
-        } catch (Exception e) {
-            assertTrue(e instanceof RemoteClusterStateService.RemoteStateTransferException);
-            assertTrue(e.getMessage().contains("Timed out waiting for transfer of manifest file to complete"));
-        }
+        RemoteClusterStateService spiedService = spy(remoteClusterStateService);
+        when(
+            spiedService.writeMetadataInParallel(
+                any(),
+                anyList(),
+                anyMap(),
+                anyMap(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyMap(),
+                anyBoolean(),
+                anyList(),
+                any()
+            )
+        ).thenReturn(new RemoteClusterStateUtils.UploadedMetadataResults());
+        RemoteStateTransferException ex = expectThrows(
+            RemoteStateTransferException.class,
+            () -> spiedService.writeFullMetadata(clusterState, randomAlphaOfLength(10), MANIFEST_CURRENT_CODEC_VERSION)
+        );
+        assertTrue(ex.getMessage().contains("Timed out waiting for transfer"));
     }
 
     public void testWriteFullMetadataInParallelFailureForIndexMetadata() throws IOException {
@@ -375,18 +599,22 @@ public void testWriteFullMetadataInParallelFailureForIndexMetadata() throws IOEx
 
         remoteClusterStateService.start();
         assertThrows(
-            RemoteClusterStateService.RemoteStateTransferException.class,
-            () -> remoteClusterStateService.writeFullMetadata(clusterState, randomAlphaOfLength(10))
+            RemoteStateTransferException.class,
+            () -> remoteClusterStateService.writeFullMetadata(clusterState, randomAlphaOfLength(10), MANIFEST_CURRENT_CODEC_VERSION)
         );
-        assertEquals(0, remoteClusterStateService.getStats().getSuccessCount());
+        assertEquals(0, remoteClusterStateService.getUploadStats().getSuccessCount());
     }
 
     public void testFailWriteIncrementalMetadataNonClusterManagerNode() throws IOException {
         final ClusterState clusterState = generateClusterStateWithOneIndex().build();
         remoteClusterStateService.start();
-        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(clusterState, clusterState, null);
-        Assert.assertThat(manifest, nullValue());
-        assertEquals(0, remoteClusterStateService.getStats().getSuccessCount());
+        final RemoteClusterStateManifestInfo manifestDetails = remoteClusterStateService.writeIncrementalMetadata(
+            clusterState,
+            clusterState,
+            null
+        );
+        Assert.assertThat(manifestDetails, nullValue());
+        assertEquals(0, remoteClusterStateService.getUploadStats().getSuccessCount());
     }
 
     public void testFailWriteIncrementalMetadataWhenTermChanged() {
@@ -401,6 +629,56 @@ public void testFailWriteIncrementalMetadataWhenTermChanged() {
         );
     }
 
+    public void testWriteMetadataInParallelIncompleteUpload() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        final RemoteClusterStateService rcssSpy = Mockito.spy(remoteClusterStateService);
+        rcssSpy.start();
+        RemoteIndexMetadataManager mockedIndexManager = mock(RemoteIndexMetadataManager.class);
+        RemoteGlobalMetadataManager mockedGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
+        RemoteClusterStateAttributesManager mockedClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
+        ClusterMetadataManifest.UploadedMetadata mockedUploadedMetadata = mock(ClusterMetadataManifest.UploadedMetadata.class);
+        rcssSpy.setRemoteIndexMetadataManager(mockedIndexManager);
+        rcssSpy.setRemoteGlobalMetadataManager(mockedGlobalMetadataManager);
+        rcssSpy.setRemoteClusterStateAttributesManager(mockedClusterStateAttributeManager);
+        ArgumentCaptor<LatchedActionListener> listenerArgumentCaptor = ArgumentCaptor.forClass(LatchedActionListener.class);
+
+        when(mockedGlobalMetadataManager.getGlobalMetadataUploadTimeout()).thenReturn(GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT);
+        when(mockedUploadedMetadata.getComponent()).thenReturn("test-component");
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedUploadedMetadata);
+            return null;
+        }).when(mockedIndexManager).writeAsync(any(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedUploadedMetadata);
+            return null;
+        }).when(mockedGlobalMetadataManager).writeAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedUploadedMetadata);
+            return null;
+        }).when(mockedClusterStateAttributeManager).writeAsync(any(), any(), listenerArgumentCaptor.capture());
+
+        RemoteStateTransferException exception = expectThrows(
+            RemoteStateTransferException.class,
+            () -> rcssSpy.writeMetadataInParallel(
+                clusterState,
+                new ArrayList<>(clusterState.getMetadata().indices().values()),
+                emptyMap(),
+                clusterState.getMetadata().customs(),
+                true,
+                true,
+                true,
+                true,
+                true,
+                true,
+                clusterState.getCustoms(),
+                true,
+                emptyList(),
+                null
+            )
+        );
+        assertTrue(exception.getMessage().startsWith("Some metadata components were not uploaded successfully"));
+    }
+
     public void testWriteIncrementalMetadataSuccess() throws IOException {
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         mockBlobStoreObjects();
@@ -412,12 +690,14 @@ public void testWriteIncrementalMetadataSuccess() throws IOException {
         final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(Collections.emptyList()).build();
 
         remoteClusterStateService.start();
-        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+        final RemoteClusterStateService rcssSpy = Mockito.spy(remoteClusterStateService);
+        final RemoteClusterStateManifestInfo manifestInfo = rcssSpy.writeIncrementalMetadata(
             previousClusterState,
             clusterState,
             previousManifest
         );
-        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final ClusterMetadataManifest manifest = manifestInfo.getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename__2");
         final List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
 
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
@@ -429,6 +709,25 @@ public void testWriteIncrementalMetadataSuccess() throws IOException {
             .previousClusterUUID("prev-cluster-uuid")
             .build();
 
+        Mockito.verify(rcssSpy)
+            .writeMetadataInParallel(
+                eq(clusterState),
+                eq(new ArrayList<IndexMetadata>(clusterState.metadata().indices().values())),
+                eq(Collections.singletonMap(indices.get(0).getIndexName(), null)),
+                eq(clusterState.metadata().customs()),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(false),
+                eq(false),
+                eq(false),
+                eq(Collections.emptyMap()),
+                eq(false),
+                anyList(),
+                Mockito.any(StringKeyDiffProvider.class)
+            );
+
+        assertThat(manifestInfo.getManifestFileName(), notNullValue());
         assertThat(manifest.getIndices().size(), is(1));
         assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
         assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
@@ -437,77 +736,61 @@ public void testWriteIncrementalMetadataSuccess() throws IOException {
         assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
         assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
         assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getHashesOfConsistentSettings(), nullValue());
+        assertThat(manifest.getDiscoveryNodesMetadata(), nullValue());
+        assertThat(manifest.getClusterBlocksMetadata(), nullValue());
+        assertThat(manifest.getClusterStateCustomMap(), anEmptyMap());
+        assertThat(manifest.getTransientSettingsMetadata(), nullValue());
+        assertThat(manifest.getTemplatesMetadata(), notNullValue());
+        assertThat(manifest.getCoordinationMetadata(), notNullValue());
+        assertThat(manifest.getCustomMetadataMap().size(), is(2));
+        assertThat(manifest.getIndicesRouting().size(), is(1));
     }
 
-    /*
-     * Here we will verify the migration of manifest file from codec V0 and V1.
-     *
-     * Initially codec version is 0 and global metadata is also null, we will perform index metadata update.
-     * In final manifest codec version should be 1 and
-     * global metadata should be updated, even if it was not changed in this cluster state update
-     */
-    public void testMigrationFromCodecV0ManifestToCodecV1Manifest() throws IOException {
-        mockBlobStoreObjects();
-        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
-        final ClusterState previousClusterState = ClusterState.builder(ClusterName.DEFAULT)
-            .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata))
-            .nodes(nodesWithLocalNodeClusterManager())
-            .build();
-
-        // Update only index metadata
-        final IndexMetadata indexMetadata = new IndexMetadata.Builder("test").settings(
-            Settings.builder()
-                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
-                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
-                .build()
-        ).numberOfShards(1).numberOfReplicas(0).build();
-        Metadata newMetadata = Metadata.builder(previousClusterState.metadata()).put(indexMetadata, true).build();
-        ClusterState newClusterState = ClusterState.builder(previousClusterState).metadata(newMetadata).build();
-
-        // previous manifest with codec 0 and null global metadata
-        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
-            .codecVersion(ClusterMetadataManifest.CODEC_V0)
-            .globalMetadataFileName(null)
-            .indices(Collections.emptyList())
-            .build();
-
-        remoteClusterStateService.start();
-        final ClusterMetadataManifest manifestAfterUpdate = remoteClusterStateService.writeIncrementalMetadata(
-            previousClusterState,
-            newClusterState,
-            previousManifest
+    public void testWriteIncrementalMetadataSuccessWhenPublicationEnabled() throws IOException {
+        publicationEnabled = true;
+        Settings nodeSettings = Settings.builder().put(REMOTE_PUBLICATION_EXPERIMENTAL, publicationEnabled).build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+        remoteClusterStateService = new RemoteClusterStateService(
+            "test-node-id",
+            repositoriesServiceSupplier,
+            settings,
+            clusterService,
+            () -> 0L,
+            threadPool,
+            List.of(
+                new RemoteIndexPathUploader(
+                    threadPool,
+                    settings,
+                    repositoriesServiceSupplier,
+                    clusterSettings,
+                    DefaultRemoteStoreSettings.INSTANCE
+                )
+            ),
+            writableRegistry()
         );
-
-        // global metadata is updated
-        assertThat(manifestAfterUpdate.getGlobalMetadataFileName(), notNullValue());
-        // Manifest file with codec version with 1 is updated.
-        assertThat(manifestAfterUpdate.getCodecVersion(), is(ClusterMetadataManifest.CODEC_V1));
-    }
-
-    public void testWriteIncrementalGlobalMetadataSuccess() throws IOException {
-        final ClusterState clusterState = generateClusterStateWithGlobalMetadata().nodes(nodesWithLocalNodeClusterManager()).build();
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         mockBlobStoreObjects();
         final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
         final ClusterState previousClusterState = ClusterState.builder(ClusterName.DEFAULT)
             .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata))
             .build();
 
-        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
-            .codecVersion(2)
-            .globalMetadataFileName("global-metadata-file")
-            .indices(Collections.emptyList())
-            .build();
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(Collections.emptyList()).build();
 
         remoteClusterStateService.start();
-        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+        final RemoteClusterStateService rcssSpy = Mockito.spy(remoteClusterStateService);
+        final RemoteClusterStateManifestInfo manifestInfo = rcssSpy.writeIncrementalMetadata(
             previousClusterState,
             clusterState,
             previousManifest
         );
+        final ClusterMetadataManifest manifest = manifestInfo.getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename__2");
+        final List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
 
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
-            .indices(Collections.emptyList())
-            .globalMetadataFileName("mock-filename")
+            .indices(indices)
             .clusterTerm(1L)
             .stateVersion(1L)
             .stateUUID("state-uuid")
@@ -515,189 +798,1700 @@ public void testWriteIncrementalGlobalMetadataSuccess() throws IOException {
             .previousClusterUUID("prev-cluster-uuid")
             .build();
 
-        assertThat(manifest.getGlobalMetadataFileName(), notNullValue());
+        Mockito.verify(rcssSpy)
+            .writeMetadataInParallel(
+                eq(clusterState),
+                eq(new ArrayList<IndexMetadata>(clusterState.metadata().indices().values())),
+                eq(Collections.singletonMap(indices.get(0).getIndexName(), null)),
+                eq(clusterState.metadata().customs()),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(false),
+                eq(false),
+                eq(Collections.emptyMap()),
+                eq(true),
+                anyList(),
+                Mockito.any(StringKeyDiffProvider.class)
+            );
+
+        assertThat(manifestInfo.getManifestFileName(), notNullValue());
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
+        assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
+        assertThat(manifest.getIndices().get(0).getUploadedFilename(), notNullValue());
         assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
         assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
         assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
         assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getHashesOfConsistentSettings(), notNullValue());
+        assertThat(manifest.getDiscoveryNodesMetadata(), notNullValue());
+        assertThat(manifest.getClusterBlocksMetadata(), nullValue());
+        assertThat(manifest.getClusterStateCustomMap(), anEmptyMap());
+        assertThat(manifest.getTransientSettingsMetadata(), nullValue());
+        assertThat(manifest.getTemplatesMetadata(), notNullValue());
+        assertThat(manifest.getCoordinationMetadata(), notNullValue());
+        assertThat(manifest.getCustomMetadataMap().size(), is(2));
+        assertThat(manifest.getIndicesRouting().size(), is(1));
     }
 
-    /*
-     * Here we will verify index metadata is not uploaded again if change is only in global metadata
-     */
-    public void testGlobalMetadataOnlyUpdated() throws IOException {
-        // setup
-        mockBlobStoreObjects();
-        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
-        final ClusterState initialClusterState = ClusterState.builder(ClusterName.DEFAULT)
-            .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata).version(randomNonNegativeLong()))
-            .build();
-        final ClusterMetadataManifest initialManifest = ClusterMetadataManifest.builder()
-            .codecVersion(2)
-            .globalMetadataFileName("global-metadata-file")
-            .indices(Collections.emptyList())
+    public void testTimeoutWhileWritingMetadata() throws IOException {
+        AsyncMultiStreamBlobContainer container = (AsyncMultiStreamBlobContainer) mockBlobStoreObjects(AsyncMultiStreamBlobContainer.class);
+        doNothing().when(container).asyncBlobUpload(any(), any());
+        int writeTimeout = 2;
+        Settings newSettings = Settings.builder()
+            .put("cluster.remote_store.state.global_metadata.upload_timeout", writeTimeout + "s")
             .build();
+        clusterSettings.applySettings(newSettings);
         remoteClusterStateService.start();
-
-        // Initial cluster state with index.
-        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
-        // Updating remote cluster state with changing index metadata
-        final ClusterMetadataManifest manifestAfterIndexMetadataUpdate = remoteClusterStateService.writeIncrementalMetadata(
-            initialClusterState,
-            clusterState,
-            initialManifest
-        );
-
-        // new cluster state where only global metadata is different
-        Metadata newMetadata = Metadata.builder(clusterState.metadata())
-            .persistentSettings(Settings.builder().put("cluster.blocks.read_only", true).build())
-            .version(randomNonNegativeLong())
-            .build();
-        ClusterState newClusterState = ClusterState.builder(clusterState).metadata(newMetadata).build();
-
-        // updating remote cluster state with global metadata
-        final ClusterMetadataManifest manifestAfterGlobalMetadataUpdate = remoteClusterStateService.writeIncrementalMetadata(
-            clusterState,
-            newClusterState,
-            manifestAfterIndexMetadataUpdate
+        RemoteStateTransferException exception = assertThrows(
+            RemoteStateTransferException.class,
+            () -> remoteClusterStateService.writeMetadataInParallel(
+                ClusterState.EMPTY_STATE,
+                emptyList(),
+                emptyMap(),
+                emptyMap(),
+                true,
+                true,
+                true,
+                true,
+                true,
+                true,
+                emptyMap(),
+                true,
+                emptyList(),
+                null
+            )
         );
+        assertTrue(exception.getMessage().startsWith("Timed out waiting for transfer of following metadata to complete"));
+    }
 
-        // Verify that index metadata information is same in manifest files
-        assertThat(manifestAfterIndexMetadataUpdate.getIndices().size(), is(manifestAfterGlobalMetadataUpdate.getIndices().size()));
-        assertThat(
-            manifestAfterIndexMetadataUpdate.getIndices().get(0).getIndexName(),
-            is(manifestAfterGlobalMetadataUpdate.getIndices().get(0).getIndexName())
+    public void testGetClusterStateForManifest_IncludeEphemeral() throws IOException {
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().build();
+        mockBlobStoreObjects();
+        remoteClusterStateService.start();
+        RemoteReadResult mockedResult = mock(RemoteReadResult.class);
+        RemoteIndexMetadataManager mockedIndexManager = mock(RemoteIndexMetadataManager.class);
+        RemoteGlobalMetadataManager mockedGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
+        RemoteClusterStateAttributesManager mockedClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
+        remoteClusterStateService.setRemoteIndexMetadataManager(mockedIndexManager);
+        remoteClusterStateService.setRemoteGlobalMetadataManager(mockedGlobalMetadataManager);
+        remoteClusterStateService.setRemoteClusterStateAttributesManager(mockedClusterStateAttributeManager);
+        ArgumentCaptor<LatchedActionListener<RemoteReadResult>> listenerArgumentCaptor = ArgumentCaptor.forClass(
+            LatchedActionListener.class
         );
-        assertThat(
-            manifestAfterIndexMetadataUpdate.getIndices().get(0).getIndexUUID(),
-            is(manifestAfterGlobalMetadataUpdate.getIndices().get(0).getIndexUUID())
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedIndexManager).readAsync(any(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedGlobalMetadataManager).readAsync(any(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedClusterStateAttributeManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        when(mockedResult.getComponent()).thenReturn(COORDINATION_METADATA);
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        mockService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true);
+
+        assertNotNull(remoteClusterStateService.getFullDownloadStats());
+        assertEquals(1, remoteClusterStateService.getFullDownloadStats().getSuccessCount());
+        assertEquals(0, remoteClusterStateService.getFullDownloadStats().getFailedCount());
+        verify(mockService, times(1)).readClusterStateInParallel(
+            any(),
+            eq(manifest),
+            eq(manifest.getClusterUUID()),
+            eq(NODE_ID),
+            eq(manifest.getIndices()),
+            eq(manifest.getCustomMetadataMap()),
+            eq(true),
+            eq(true),
+            eq(true),
+            eq(true),
+            eq(true),
+            eq(true),
+            eq(manifest.getIndicesRouting()),
+            eq(true),
+            eq(manifest.getClusterStateCustomMap()),
+            eq(false),
+            eq(true)
         );
+    }
 
-        // since timestamp is part of file name, if file name is same we can confirm that file is not update in global metadata update
-        assertThat(
-            manifestAfterIndexMetadataUpdate.getIndices().get(0).getUploadedFilename(),
-            is(manifestAfterGlobalMetadataUpdate.getIndices().get(0).getUploadedFilename())
+    public void testGetClusterStateForManifest_ExcludeEphemeral() throws IOException {
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().build();
+        mockBlobStoreObjects();
+        remoteClusterStateService.start();
+        RemoteReadResult mockedResult = mock(RemoteReadResult.class);
+        RemoteIndexMetadataManager mockedIndexManager = mock(RemoteIndexMetadataManager.class);
+        RemoteGlobalMetadataManager mockedGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
+        RemoteClusterStateAttributesManager mockedClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
+        ArgumentCaptor<LatchedActionListener<RemoteReadResult>> listenerArgumentCaptor = ArgumentCaptor.forClass(
+            LatchedActionListener.class
         );
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedIndexManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedGlobalMetadataManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedClusterStateAttributeManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        when(mockedResult.getComponent()).thenReturn(COORDINATION_METADATA);
+        remoteClusterStateService.setRemoteIndexMetadataManager(mockedIndexManager);
+        remoteClusterStateService.setRemoteGlobalMetadataManager(mockedGlobalMetadataManager);
+        remoteClusterStateService.setRemoteClusterStateAttributesManager(mockedClusterStateAttributeManager);
+        RemoteClusterStateService spiedService = spy(remoteClusterStateService);
+        spiedService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, false);
+        verify(spiedService, times(1)).readClusterStateInParallel(
+            any(),
+            eq(manifest),
+            eq(manifest.getClusterUUID()),
+            eq(NODE_ID),
+            eq(manifest.getIndices()),
+            eq(manifest.getCustomMetadataMap()),
+            eq(true),
+            eq(true),
+            eq(false),
+            eq(true),
+            eq(false),
+            eq(false),
+            eq(emptyList()),
+            eq(false),
+            eq(emptyMap()),
+            eq(false),
+            eq(false)
 
-        // global metadata file would have changed
-        assertFalse(
-            manifestAfterIndexMetadataUpdate.getGlobalMetadataFileName()
-                .equalsIgnoreCase(manifestAfterGlobalMetadataUpdate.getGlobalMetadataFileName())
         );
     }
 
-    /*
-     * Here we will verify global metadata is not uploaded again if change is only in index metadata
-     */
-    public void testIndexMetadataOnlyUpdated() throws IOException {
-        // setup
+    public void testGetClusterStateFromManifest_CodecV1() throws IOException {
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().codecVersion(CODEC_V1).build();
         mockBlobStoreObjects();
-        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
-        final ClusterState initialClusterState = ClusterState.builder(ClusterName.DEFAULT)
-            .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata))
+        remoteClusterStateService.start();
+        final Index index = new Index("test-index", "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
             .build();
-        final ClusterMetadataManifest initialManifest = ClusterMetadataManifest.builder()
-            .codecVersion(2)
-            .indices(Collections.emptyList())
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
             .build();
-        remoteClusterStateService.start();
-
-        // Initial cluster state with global metadata.
-        final ClusterState clusterState = generateClusterStateWithGlobalMetadata().nodes(nodesWithLocalNodeClusterManager()).build();
-
-        // Updating remote cluster state with changing global metadata
-        final ClusterMetadataManifest manifestAfterGlobalMetadataUpdate = remoteClusterStateService.writeIncrementalMetadata(
-            initialClusterState,
-            clusterState,
-            initialManifest
-        );
-
-        // new cluster state where only Index metadata is different
-        final IndexMetadata indexMetadata = new IndexMetadata.Builder("test").settings(
-            Settings.builder()
-                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
-                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
-                .build()
-        ).numberOfShards(1).numberOfReplicas(0).build();
-        Metadata newMetadata = Metadata.builder(clusterState.metadata()).put(indexMetadata, true).build();
-        ClusterState newClusterState = ClusterState.builder(clusterState).metadata(newMetadata).build();
-
-        // updating remote cluster state with index metadata
-        final ClusterMetadataManifest manifestAfterIndexMetadataUpdate = remoteClusterStateService.writeIncrementalMetadata(
-            clusterState,
-            newClusterState,
-            manifestAfterGlobalMetadataUpdate
+        RemoteIndexMetadataManager mockedIndexManager = mock(RemoteIndexMetadataManager.class);
+        RemoteGlobalMetadataManager mockedGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
+        remoteClusterStateService.setRemoteIndexMetadataManager(mockedIndexManager);
+        remoteClusterStateService.setRemoteGlobalMetadataManager(mockedGlobalMetadataManager);
+        ArgumentCaptor<LatchedActionListener<RemoteReadResult>> listenerArgumentCaptor = ArgumentCaptor.forClass(
+            LatchedActionListener.class
         );
-
-        // Verify that global metadata information is same in manifest files after updating index Metadata
-        // since timestamp is part of file name, if file name is same we can confirm that file is not update in index metadata update
-        assertThat(
-            manifestAfterIndexMetadataUpdate.getGlobalMetadataFileName(),
-            is(manifestAfterGlobalMetadataUpdate.getGlobalMetadataFileName())
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(new RemoteReadResult(indexMetadata, INDEX, INDEX));
+            return null;
+        }).when(mockedIndexManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        when(mockedGlobalMetadataManager.getGlobalMetadata(anyString(), eq(manifest))).thenReturn(Metadata.EMPTY_METADATA);
+        RemoteClusterStateService spiedService = spy(remoteClusterStateService);
+        spiedService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true);
+        verify(spiedService, times(1)).readClusterStateInParallel(
+            any(),
+            eq(manifest),
+            eq(manifest.getClusterUUID()),
+            eq(NODE_ID),
+            eq(manifest.getIndices()),
+            eq(emptyMap()),
+            eq(false),
+            eq(false),
+            eq(false),
+            eq(false),
+            eq(false),
+            eq(false),
+            eq(emptyList()),
+            eq(false),
+            eq(emptyMap()),
+            eq(false),
+            eq(false)
         );
-
-        // Index metadata would have changed
-        assertThat(manifestAfterGlobalMetadataUpdate.getIndices().size(), is(0));
-        assertThat(manifestAfterIndexMetadataUpdate.getIndices().size(), is(1));
+        verify(mockedGlobalMetadataManager, times(1)).getGlobalMetadata(eq(manifest.getClusterUUID()), eq(manifest));
     }
 
-    public void testReadLatestMetadataManifestFailedIOException() throws IOException {
-        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
-
-        BlobContainer blobContainer = mockBlobStoreObjects();
-        when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
-            .thenThrow(IOException.class);
-
-        remoteClusterStateService.start();
-        Exception e = assertThrows(
-            IllegalStateException.class,
-            () -> remoteClusterStateService.getLatestClusterMetadataManifest(
-                clusterState.getClusterName().value(),
-                clusterState.metadata().clusterUUID()
-            )
+    public void testGetClusterStateUsingDiffFailWhenDiffManifestAbsent() {
+        ClusterMetadataManifest manifest = ClusterMetadataManifest.builder().build();
+        ClusterState previousState = ClusterState.EMPTY_STATE;
+        AssertionError error = assertThrows(
+            AssertionError.class,
+            () -> remoteClusterStateService.getClusterStateUsingDiff(manifest, previousState, "test-node")
         );
-        assertEquals(e.getMessage(), "Error while fetching latest manifest file for remote cluster state");
+        assertEquals("Diff manifest null which is required for downloading cluster state", error.getMessage());
     }
 
-    public void testReadLatestMetadataManifestFailedNoManifestFileInRemote() throws IOException {
-        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
-
-        BlobContainer blobContainer = mockBlobStoreObjects();
-        when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
-            .thenReturn(List.of());
-
-        remoteClusterStateService.start();
-        Optional<ClusterMetadataManifest> manifest = remoteClusterStateService.getLatestClusterMetadataManifest(
-            clusterState.getClusterName().value(),
-            clusterState.metadata().clusterUUID()
-        );
-        assertEquals(manifest, Optional.empty());
+    public void testGetClusterStateUsingDiff_NoDiff() throws IOException {
+        ClusterStateDiffManifest diffManifest = ClusterStateDiffManifest.builder().build();
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = ClusterMetadataManifest.builder()
+            .diffManifest(diffManifest)
+            .stateUUID(clusterState.stateUUID())
+            .stateVersion(clusterState.version())
+            .metadataVersion(clusterState.metadata().version())
+            .clusterUUID(clusterState.getMetadata().clusterUUID())
+            .routingTableVersion(clusterState.routingTable().version())
+            .build();
+        ClusterState updatedClusterState = remoteClusterStateService.getClusterStateUsingDiff(manifest, clusterState, "test-node");
+        assertEquals(clusterState.getClusterName(), updatedClusterState.getClusterName());
+        assertEquals(clusterState.metadata().clusterUUID(), updatedClusterState.metadata().clusterUUID());
+        assertEquals(clusterState.metadata().version(), updatedClusterState.metadata().version());
+        assertEquals(clusterState.metadata().coordinationMetadata(), updatedClusterState.metadata().coordinationMetadata());
+        assertEquals(clusterState.metadata().getIndices(), updatedClusterState.metadata().getIndices());
+        assertEquals(clusterState.metadata().templates(), updatedClusterState.metadata().templates());
+        assertEquals(clusterState.metadata().persistentSettings(), updatedClusterState.metadata().persistentSettings());
+        assertEquals(clusterState.metadata().transientSettings(), updatedClusterState.metadata().transientSettings());
+        assertEquals(clusterState.metadata().getCustoms(), updatedClusterState.metadata().getCustoms());
+        assertEquals(clusterState.metadata().hashesOfConsistentSettings(), updatedClusterState.metadata().hashesOfConsistentSettings());
+        assertEquals(clusterState.getCustoms(), updatedClusterState.getCustoms());
+        assertEquals(clusterState.stateUUID(), updatedClusterState.stateUUID());
+        assertEquals(clusterState.version(), updatedClusterState.version());
+        assertEquals(clusterState.getRoutingTable().version(), updatedClusterState.getRoutingTable().version());
+        assertEquals(clusterState.getRoutingTable().getIndicesRouting(), updatedClusterState.getRoutingTable().getIndicesRouting());
+        assertEquals(clusterState.getNodes(), updatedClusterState.getNodes());
+        assertEquals(clusterState.getBlocks(), updatedClusterState.getBlocks());
     }
 
-    public void testReadLatestMetadataManifestFailedManifestFileRemoveAfterFetchInRemote() throws IOException {
-        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
-
+    public void testGetClusterStateUsingDiff() throws IOException {
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterState.Builder expectedClusterStateBuilder = ClusterState.builder(clusterState);
+        Metadata.Builder mb = Metadata.builder(clusterState.metadata());
+        ClusterStateDiffManifest.Builder diffManifestBuilder = ClusterStateDiffManifest.builder();
+        ClusterMetadataManifest.Builder manifestBuilder = ClusterMetadataManifest.builder();
         BlobContainer blobContainer = mockBlobStoreObjects();
-        BlobMetadata blobMetadata = new PlainBlobMetadata("manifestFileName", 1);
-        when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
-            .thenReturn(Arrays.asList(blobMetadata));
-        when(blobContainer.readBlob("manifestFileName")).thenThrow(FileNotFoundException.class);
-
-        remoteClusterStateService.start();
-        Exception e = assertThrows(
-            IllegalStateException.class,
-            () -> remoteClusterStateService.getLatestClusterMetadataManifest(
+        if (randomBoolean()) {
+            // updated coordination metadata
+            CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder()
+                .term(clusterState.metadata().coordinationMetadata().term() + 1)
+                .build();
+            mb.coordinationMetadata(coordinationMetadata);
+            diffManifestBuilder.coordinationMetadataUpdated(true);
+            manifestBuilder.coordinationMetadata(new UploadedMetadataAttribute(COORDINATION_METADATA, COORDINATION_METADATA_FILENAME));
+            when(blobContainer.readBlob(COORDINATION_METADATA_FILENAME)).thenAnswer(i -> {
+                BytesReference bytes = COORDINATION_METADATA_FORMAT.serialize(
+                    coordinationMetadata,
+                    COORDINATION_METADATA_FILENAME,
+                    compressor,
+                    FORMAT_PARAMS
+                );
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+        }
+        if (randomBoolean()) {
+            // updated templates
+            TemplatesMetadata templatesMetadata = TemplatesMetadata.builder()
+                .put(
+                    IndexTemplateMetadata.builder("template" + randomAlphaOfLength(3))
+                        .patterns(Arrays.asList("bar-*", "foo-*"))
+                        .settings(Settings.builder().put("random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build())
+                        .build()
+                )
+                .build();
+            mb.templates(templatesMetadata);
+            diffManifestBuilder.templatesMetadataUpdated(true);
+            manifestBuilder.templatesMetadata(new UploadedMetadataAttribute(TEMPLATES_METADATA, TEMPLATES_METADATA_FILENAME));
+            when(blobContainer.readBlob(TEMPLATES_METADATA_FILENAME)).thenAnswer(i -> {
+                BytesReference bytes = TEMPLATES_METADATA_FORMAT.serialize(
+                    templatesMetadata,
+                    TEMPLATES_METADATA_FILENAME,
+                    compressor,
+                    FORMAT_PARAMS
+                );
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+        }
+        if (randomBoolean()) {
+            // updated persistent settings
+            Settings persistentSettings = Settings.builder()
+                .put("random_persistent_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5))
+                .build();
+            mb.persistentSettings(persistentSettings);
+            diffManifestBuilder.settingsMetadataUpdated(true);
+            manifestBuilder.settingMetadata(new UploadedMetadataAttribute(SETTING_METADATA, PERSISTENT_SETTINGS_FILENAME));
+            when(blobContainer.readBlob(PERSISTENT_SETTINGS_FILENAME)).thenAnswer(i -> {
+                BytesReference bytes = RemotePersistentSettingsMetadata.SETTINGS_METADATA_FORMAT.serialize(
+                    persistentSettings,
+                    PERSISTENT_SETTINGS_FILENAME,
+                    compressor,
+                    FORMAT_PARAMS
+                );
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+        }
+        if (randomBoolean()) {
+            // updated transient settings
+            Settings transientSettings = Settings.builder()
+                .put("random_transient_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5))
+                .build();
+            mb.transientSettings(transientSettings);
+            diffManifestBuilder.transientSettingsMetadataUpdate(true);
+            manifestBuilder.transientSettingsMetadata(
+                new UploadedMetadataAttribute(TRANSIENT_SETTING_METADATA, TRANSIENT_SETTINGS_FILENAME)
+            );
+            when(blobContainer.readBlob(TRANSIENT_SETTINGS_FILENAME)).thenAnswer(i -> {
+                BytesReference bytes = RemoteTransientSettingsMetadata.SETTINGS_METADATA_FORMAT.serialize(
+                    transientSettings,
+                    TRANSIENT_SETTINGS_FILENAME,
+                    compressor,
+                    FORMAT_PARAMS
+                );
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+        }
+        if (randomBoolean()) {
+            // updated customs
+            CustomMetadata2 addedCustom = new CustomMetadata2(randomAlphaOfLength(10));
+            mb.putCustom(addedCustom.getWriteableName(), addedCustom);
+            diffManifestBuilder.customMetadataUpdated(Collections.singletonList(addedCustom.getWriteableName()));
+            manifestBuilder.customMetadataMap(
+                Map.of(addedCustom.getWriteableName(), new UploadedMetadataAttribute(addedCustom.getWriteableName(), "custom-md2-file__1"))
+            );
+            when(blobContainer.readBlob("custom-md2-file__1")).thenAnswer(i -> {
+                ChecksumWritableBlobStoreFormat<Metadata.Custom> customMetadataFormat = new ChecksumWritableBlobStoreFormat<>(
+                    "custom",
+                    is -> readFrom(is, namedWriteableRegistry, addedCustom.getWriteableName())
+                );
+                BytesReference bytes = customMetadataFormat.serialize(addedCustom, "custom-md2-file__1", compressor);
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+        }
+        if (randomBoolean()) {
+            Set<String> customsToRemove = clusterState.metadata().customs().keySet();
+            customsToRemove.forEach(mb::removeCustom);
+            diffManifestBuilder.customMetadataDeleted(new ArrayList<>(customsToRemove));
+        }
+        if (randomBoolean()) {
+            // updated hashes of consistent settings
+            DiffableStringMap hashesOfConsistentSettings = new DiffableStringMap(Map.of("secure_setting_key", "secure_setting_value"));
+            mb.hashesOfConsistentSettings(hashesOfConsistentSettings);
+            diffManifestBuilder.hashesOfConsistentSettingsUpdated(true);
+            manifestBuilder.hashesOfConsistentSettings(
+                new UploadedMetadataAttribute(HASHES_OF_CONSISTENT_SETTINGS, HASHES_OF_CONSISTENT_SETTINGS_FILENAME)
+            );
+            when(blobContainer.readBlob(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)).thenAnswer(i -> {
+                BytesReference bytes = HASHES_OF_CONSISTENT_SETTINGS_FORMAT.serialize(
+                    hashesOfConsistentSettings,
+                    HASHES_OF_CONSISTENT_SETTINGS_FILENAME,
+                    compressor
+                );
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+        }
+        if (randomBoolean()) {
+            // updated index metadata
+            IndexMetadata indexMetadata = new IndexMetadata.Builder("add-test-index").settings(
+                Settings.builder()
+                    .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                    .put(IndexMetadata.SETTING_INDEX_UUID, "add-test-index-uuid")
+                    .build()
+            ).numberOfShards(1).numberOfReplicas(0).build();
+            mb.put(indexMetadata, true);
+            diffManifestBuilder.indicesUpdated(Collections.singletonList(indexMetadata.getIndex().getName()));
+            manifestBuilder.indices(
+                List.of(
+                    new UploadedIndexMetadata(indexMetadata.getIndex().getName(), indexMetadata.getIndexUUID(), "add-test-index-file__2")
+                )
+            );
+            when(blobContainer.readBlob("add-test-index-file__2")).thenAnswer(i -> {
+                BytesReference bytes = INDEX_METADATA_FORMAT.serialize(indexMetadata, "add-test-index-file__2", compressor, FORMAT_PARAMS);
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+        }
+        if (randomBoolean()) {
+            // remove index metadata
+            Set<String> indicesToDelete = clusterState.metadata().getIndices().keySet();
+            indicesToDelete.forEach(mb::remove);
+            diffManifestBuilder.indicesDeleted(new ArrayList<>(indicesToDelete));
+        }
+        if (randomBoolean()) {
+            // update nodes
+            DiscoveryNode node = new DiscoveryNode("node_id", buildNewFakeTransportAddress(), Version.CURRENT);
+            DiscoveryNodes.Builder nodesBuilder = DiscoveryNodes.builder(clusterState.nodes()).add(node);
+            expectedClusterStateBuilder.nodes(nodesBuilder.build());
+            diffManifestBuilder.discoveryNodesUpdated(true);
+            manifestBuilder.discoveryNodesMetadata(new UploadedMetadataAttribute(DISCOVERY_NODES, DISCOVERY_NODES_FILENAME));
+            when(blobContainer.readBlob(DISCOVERY_NODES_FILENAME)).thenAnswer(invocationOnMock -> {
+                BytesReference bytes = DISCOVERY_NODES_FORMAT.serialize(
+                    (out, nodes) -> nodes.writeToWithAttribute(out),
+                    nodesBuilder.build(),
+                    DISCOVERY_NODES_FILENAME,
+                    compressor
+                );
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+        }
+        if (randomBoolean()) {
+            // update blocks
+            ClusterBlocks newClusterBlock = randomClusterBlocks();
+            expectedClusterStateBuilder.blocks(newClusterBlock);
+            diffManifestBuilder.clusterBlocksUpdated(true);
+            manifestBuilder.clusterBlocksMetadata(new UploadedMetadataAttribute(CLUSTER_BLOCKS, CLUSTER_BLOCKS_FILENAME));
+            when(blobContainer.readBlob(CLUSTER_BLOCKS_FILENAME)).thenAnswer(invocationOnMock -> {
+                BytesReference bytes = CLUSTER_BLOCKS_FORMAT.serialize(newClusterBlock, CLUSTER_BLOCKS_FILENAME, compressor);
+                return new ByteArrayInputStream(bytes.streamInput().readAllBytes());
+            });
+
+        }
+        ClusterState expectedClusterState = expectedClusterStateBuilder.metadata(mb).build();
+        ClusterStateDiffManifest diffManifest = diffManifestBuilder.build();
+        manifestBuilder.diffManifest(diffManifest)
+            .stateUUID(clusterState.stateUUID())
+            .stateVersion(clusterState.version())
+            .metadataVersion(clusterState.metadata().version())
+            .clusterUUID(clusterState.getMetadata().clusterUUID())
+            .routingTableVersion(clusterState.getRoutingTable().version());
+
+        remoteClusterStateService.start();
+        ClusterState updatedClusterState = remoteClusterStateService.getClusterStateUsingDiff(
+            manifestBuilder.build(),
+            clusterState,
+            NODE_ID
+        );
+
+        assertEquals(expectedClusterState.getClusterName(), updatedClusterState.getClusterName());
+        assertEquals(expectedClusterState.stateUUID(), updatedClusterState.stateUUID());
+        assertEquals(expectedClusterState.version(), updatedClusterState.version());
+        assertEquals(expectedClusterState.metadata().clusterUUID(), updatedClusterState.metadata().clusterUUID());
+        assertEquals(expectedClusterState.getRoutingTable().version(), updatedClusterState.getRoutingTable().version());
+        assertNotEquals(diffManifest.isClusterBlocksUpdated(), updatedClusterState.getBlocks().equals(clusterState.getBlocks()));
+        assertNotEquals(diffManifest.isDiscoveryNodesUpdated(), updatedClusterState.getNodes().equals(clusterState.getNodes()));
+        assertNotEquals(
+            diffManifest.isCoordinationMetadataUpdated(),
+            updatedClusterState.getMetadata().coordinationMetadata().equals(clusterState.getMetadata().coordinationMetadata())
+        );
+        assertNotEquals(
+            diffManifest.isTemplatesMetadataUpdated(),
+            updatedClusterState.getMetadata().templates().equals(clusterState.getMetadata().getTemplates())
+        );
+        assertNotEquals(
+            diffManifest.isSettingsMetadataUpdated(),
+            updatedClusterState.getMetadata().persistentSettings().equals(clusterState.getMetadata().persistentSettings())
+        );
+        assertNotEquals(
+            diffManifest.isTransientSettingsMetadataUpdated(),
+            updatedClusterState.getMetadata().transientSettings().equals(clusterState.getMetadata().transientSettings())
+        );
+        diffManifest.getIndicesUpdated().forEach(indexName -> {
+            IndexMetadata updatedIndexMetadata = updatedClusterState.metadata().index(indexName);
+            IndexMetadata originalIndexMetadata = clusterState.metadata().index(indexName);
+            assertNotEquals(originalIndexMetadata, updatedIndexMetadata);
+        });
+        diffManifest.getCustomMetadataUpdated().forEach(customMetadataName -> {
+            Metadata.Custom updatedCustomMetadata = updatedClusterState.metadata().custom(customMetadataName);
+            Metadata.Custom originalCustomMetadata = clusterState.metadata().custom(customMetadataName);
+            assertNotEquals(originalCustomMetadata, updatedCustomMetadata);
+        });
+        diffManifest.getClusterStateCustomUpdated().forEach(clusterStateCustomName -> {
+            ClusterState.Custom updateClusterStateCustom = updatedClusterState.customs().get(clusterStateCustomName);
+            ClusterState.Custom originalClusterStateCustom = clusterState.customs().get(clusterStateCustomName);
+            assertNotEquals(originalClusterStateCustom, updateClusterStateCustom);
+        });
+        diffManifest.getIndicesDeleted()
+            .forEach(indexName -> { assertFalse(updatedClusterState.metadata().getIndices().containsKey(indexName)); });
+        diffManifest.getCustomMetadataDeleted().forEach(customMetadataName -> {
+            assertFalse(updatedClusterState.metadata().customs().containsKey(customMetadataName));
+        });
+        diffManifest.getClusterStateCustomDeleted().forEach(clusterStateCustomName -> {
+            assertFalse(updatedClusterState.customs().containsKey(clusterStateCustomName));
+        });
+    }
+
+    public void testReadClusterStateInParallel_TimedOut() throws IOException {
+        ClusterState previousClusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().build();
+        BlobContainer container = mockBlobStoreObjects();
+        int readTimeOut = 2;
+        Settings newSettings = Settings.builder().put("cluster.remote_store.state.read_timeout", readTimeOut + "s").build();
+        clusterSettings.applySettings(newSettings);
+        when(container.readBlob(anyString())).thenAnswer(invocationOnMock -> {
+            Thread.sleep(readTimeOut * 1000 + 100);
+            return null;
+        });
+        remoteClusterStateService.start();
+        RemoteStateTransferException exception = expectThrows(
+            RemoteStateTransferException.class,
+            () -> remoteClusterStateService.readClusterStateInParallel(
+                previousClusterState,
+                manifest,
+                manifest.getClusterUUID(),
+                NODE_ID,
+                emptyList(),
+                emptyMap(),
+                true,
+                true,
+                true,
+                true,
+                true,
+                true,
+                emptyList(),
+                true,
+                emptyMap(),
+                false,
+                true
+            )
+        );
+        assertEquals("Timed out waiting to read cluster state from remote within timeout " + readTimeOut + "s", exception.getMessage());
+    }
+
+    public void testReadClusterStateInParallel_ExceptionDuringRead() throws IOException {
+        ClusterState previousClusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().build();
+        BlobContainer container = mockBlobStoreObjects();
+        Exception mockException = new IOException("mock exception");
+        when(container.readBlob(anyString())).thenThrow(mockException);
+        remoteClusterStateService.start();
+        RemoteStateTransferException exception = expectThrows(
+            RemoteStateTransferException.class,
+            () -> remoteClusterStateService.readClusterStateInParallel(
+                previousClusterState,
+                manifest,
+                manifest.getClusterUUID(),
+                NODE_ID,
+                emptyList(),
+                emptyMap(),
+                true,
+                true,
+                true,
+                true,
+                true,
+                true,
+                emptyList(),
+                true,
+                emptyMap(),
+                false,
+                true
+            )
+        );
+        assertEquals("Exception during reading cluster state from remote", exception.getMessage());
+        assertTrue(exception.getSuppressed().length > 0);
+        assertEquals(mockException, exception.getSuppressed()[0].getCause());
+    }
+
+    public void testReadClusterStateInParallel_UnexpectedResult() throws IOException {
+        ClusterState previousClusterState = generateClusterStateWithAllAttributes().build();
+        // index already present in previous state
+        List<UploadedIndexMetadata> uploadedIndexMetadataList = new ArrayList<>(
+            List.of(new UploadedIndexMetadata("test-index", "test-index-uuid", "test-index-file__2"))
+        );
+        // new index to be added
+        List<UploadedIndexMetadata> newIndicesToRead = List.of(
+            new UploadedIndexMetadata("test-index-1", "test-index-1-uuid", "test-index-1-file__2")
+        );
+        uploadedIndexMetadataList.addAll(newIndicesToRead);
+        // existing custom metadata
+        Map<String, UploadedMetadataAttribute> uploadedCustomMetadataMap = new HashMap<>(
+            Map.of(
+                "custom_md_1",
+                new UploadedMetadataAttribute("custom_md_1", "test-custom1-file__1"),
+                "custom_md_2",
+                new UploadedMetadataAttribute("custom_md_2", "test-custom2-file__1")
+            )
+        );
+        // new custom metadata to be added
+        Map<String, UploadedMetadataAttribute> newCustomMetadataMap = Map.of(
+            "custom_md_3",
+            new UploadedMetadataAttribute("custom_md_3", "test-custom3-file__1")
+        );
+        uploadedCustomMetadataMap.putAll(newCustomMetadataMap);
+        // already existing cluster state customs
+        Map<String, UploadedMetadataAttribute> uploadedClusterStateCustomMap = new HashMap<>(
+            Map.of(
+                "custom_1",
+                new UploadedMetadataAttribute("custom_1", "test-cluster-state-custom1-file__1"),
+                "custom_2",
+                new UploadedMetadataAttribute("custom_2", "test-cluster-state-custom2-file__1")
+            )
+        );
+        // new customs uploaded
+        Map<String, UploadedMetadataAttribute> newClusterStateCustoms = Map.of(
+            "custom_3",
+            new UploadedMetadataAttribute("custom_3", "test-cluster-state-custom3-file__1")
+        );
+        uploadedClusterStateCustomMap.putAll(newClusterStateCustoms);
+        ClusterMetadataManifest manifest = ClusterMetadataManifest.builder()
+            .clusterUUID(previousClusterState.getMetadata().clusterUUID())
+            .indices(uploadedIndexMetadataList)
+            .coordinationMetadata(new UploadedMetadataAttribute(COORDINATION_METADATA, COORDINATION_METADATA_FILENAME))
+            .settingMetadata(new UploadedMetadataAttribute(SETTING_METADATA, PERSISTENT_SETTINGS_FILENAME))
+            .transientSettingsMetadata(new UploadedMetadataAttribute(TRANSIENT_SETTING_METADATA, TRANSIENT_SETTINGS_FILENAME))
+            .templatesMetadata(new UploadedMetadataAttribute(TEMPLATES_METADATA, TEMPLATES_METADATA_FILENAME))
+            .hashesOfConsistentSettings(
+                new UploadedMetadataAttribute(HASHES_OF_CONSISTENT_SETTINGS, HASHES_OF_CONSISTENT_SETTINGS_FILENAME)
+            )
+            .customMetadataMap(uploadedCustomMetadataMap)
+            .discoveryNodesMetadata(new UploadedMetadataAttribute(DISCOVERY_NODES, DISCOVERY_NODES_FILENAME))
+            .clusterBlocksMetadata(new UploadedMetadataAttribute(CLUSTER_BLOCKS, CLUSTER_BLOCKS_FILENAME))
+            .clusterStateCustomMetadataMap(uploadedClusterStateCustomMap)
+            .build();
+
+        RemoteReadResult mockResult = mock(RemoteReadResult.class);
+        RemoteIndexMetadataManager mockIndexMetadataManager = mock(RemoteIndexMetadataManager.class);
+        CheckedRunnable<IOException> mockRunnable = mock(CheckedRunnable.class);
+        ArgumentCaptor<LatchedActionListener<RemoteReadResult>> latchCapture = ArgumentCaptor.forClass(LatchedActionListener.class);
+        doAnswer(invocation -> {
+            latchCapture.getValue().onResponse(mockResult);
+            return null;
+        }).when(mockIndexMetadataManager).readAsync(anyString(), any(), latchCapture.capture());
+        RemoteGlobalMetadataManager mockGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
+        doAnswer(invocation -> {
+            latchCapture.getValue().onResponse(mockResult);
+            return null;
+        }).when(mockGlobalMetadataManager).readAsync(any(), any(), latchCapture.capture());
+        RemoteClusterStateAttributesManager mockClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
+        doAnswer(invocation -> {
+            latchCapture.getValue().onResponse(mockResult);
+            return null;
+        }).when(mockClusterStateAttributeManager).readAsync(anyString(), any(), latchCapture.capture());
+        when(mockResult.getComponent()).thenReturn("mock-result");
+        remoteClusterStateService.start();
+        remoteClusterStateService.setRemoteIndexMetadataManager(mockIndexMetadataManager);
+        remoteClusterStateService.setRemoteGlobalMetadataManager(mockGlobalMetadataManager);
+        remoteClusterStateService.setRemoteClusterStateAttributesManager(mockClusterStateAttributeManager);
+        IllegalStateException exception = expectThrows(
+            IllegalStateException.class,
+            () -> remoteClusterStateService.readClusterStateInParallel(
+                previousClusterState,
+                manifest,
+                manifest.getClusterUUID(),
+                NODE_ID,
+                newIndicesToRead,
+                newCustomMetadataMap,
+                true,
+                true,
+                true,
+                true,
+                true,
+                true,
+                emptyList(),
+                true,
+                newClusterStateCustoms,
+                false,
+                true
+            )
+        );
+        assertEquals("Unknown component: mock-result", exception.getMessage());
+        newIndicesToRead.forEach(
+            uploadedIndexMetadata -> verify(mockIndexMetadataManager, times(1)).readAsync(
+                eq("test-index-1"),
+                argThat(new BlobNameMatcher(uploadedIndexMetadata.getUploadedFilename())),
+                any()
+            )
+        );
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
+            eq(COORDINATION_METADATA),
+            argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)),
+            any()
+        );
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
+            eq(SETTING_METADATA),
+            argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)),
+            any()
+        );
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
+            eq(TRANSIENT_SETTING_METADATA),
+            argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)),
+            any()
+        );
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
+            eq(TEMPLATES_METADATA),
+            argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)),
+            any()
+        );
+        verify(mockGlobalMetadataManager, times(1)).readAsync(
+            eq(HASHES_OF_CONSISTENT_SETTINGS),
+            argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)),
+            any()
+        );
+        newCustomMetadataMap.keySet().forEach(uploadedCustomMetadataKey -> {
+            verify(mockGlobalMetadataManager, times(1)).readAsync(
+                eq(uploadedCustomMetadataKey),
+                argThat(new BlobNameMatcher(newCustomMetadataMap.get(uploadedCustomMetadataKey).getUploadedFilename())),
+                any()
+            );
+        });
+        verify(mockClusterStateAttributeManager, times(1)).readAsync(
+            eq(DISCOVERY_NODES),
+            argThat(new BlobNameMatcher(DISCOVERY_NODES_FILENAME)),
+            any()
+        );
+        verify(mockClusterStateAttributeManager, times(1)).readAsync(
+            eq(CLUSTER_BLOCKS),
+            argThat(new BlobNameMatcher(CLUSTER_BLOCKS_FILENAME)),
+            any()
+        );
+        newClusterStateCustoms.keySet().forEach(uploadedClusterStateCustomMetadataKey -> {
+            verify(mockClusterStateAttributeManager, times(1)).readAsync(
+                eq(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, uploadedClusterStateCustomMetadataKey)),
+                argThat(new BlobNameMatcher(newClusterStateCustoms.get(uploadedClusterStateCustomMetadataKey).getUploadedFilename())),
+                any()
+            );
+        });
+    }
+
+    public void testReadClusterStateInParallel_Success() throws IOException {
+        ClusterState previousClusterState = generateClusterStateWithAllAttributes().build();
+        String indexFilename = "test-index-1-file__2";
+        String customMetadataFilename = "test-custom3-file__1";
+        String clusterStateCustomFilename = "test-cluster-state-custom3-file__1";
+        // index already present in previous state
+        List<UploadedIndexMetadata> uploadedIndexMetadataList = new ArrayList<>(
+            List.of(new UploadedIndexMetadata("test-index", "test-index-uuid", "test-index-file__2"))
+        );
+        // new index to be added
+        List<UploadedIndexMetadata> newIndicesToRead = List.of(
+            new UploadedIndexMetadata("test-index-1", "test-index-1-uuid", indexFilename)
+        );
+        uploadedIndexMetadataList.addAll(newIndicesToRead);
+        // existing custom metadata
+        Map<String, UploadedMetadataAttribute> uploadedCustomMetadataMap = new HashMap<>(
+            Map.of(
+                "custom_md_1",
+                new UploadedMetadataAttribute("custom_md_1", "test-custom1-file__1"),
+                "custom_md_2",
+                new UploadedMetadataAttribute("custom_md_2", "test-custom2-file__1")
+            )
+        );
+        // new custom metadata to be added
+        Map<String, UploadedMetadataAttribute> newCustomMetadataMap = Map.of(
+            "custom_md_3",
+            new UploadedMetadataAttribute("custom_md_3", customMetadataFilename)
+        );
+        uploadedCustomMetadataMap.putAll(newCustomMetadataMap);
+        // already existing cluster state customs
+        Map<String, UploadedMetadataAttribute> uploadedClusterStateCustomMap = new HashMap<>(
+            Map.of(
+                "custom_1",
+                new UploadedMetadataAttribute("custom_1", "test-cluster-state-custom1-file__1"),
+                "custom_2",
+                new UploadedMetadataAttribute("custom_2", "test-cluster-state-custom2-file__1")
+            )
+        );
+        // new customs uploaded
+        Map<String, UploadedMetadataAttribute> newClusterStateCustoms = Map.of(
+            "custom_3",
+            new UploadedMetadataAttribute("custom_3", clusterStateCustomFilename)
+        );
+        uploadedClusterStateCustomMap.putAll(newClusterStateCustoms);
+
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().indices(uploadedIndexMetadataList)
+            .customMetadataMap(uploadedCustomMetadataMap)
+            .clusterStateCustomMetadataMap(uploadedClusterStateCustomMap)
+            .build();
+
+        IndexMetadata newIndexMetadata = new IndexMetadata.Builder("test-index-1").state(IndexMetadata.State.OPEN)
+            .settings(Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT).build())
+            .numberOfShards(1)
+            .numberOfReplicas(1)
+            .build();
+        CustomMetadata3 customMetadata3 = new CustomMetadata3("custom_md_3");
+        CoordinationMetadata updatedCoordinationMetadata = CoordinationMetadata.builder()
+            .term(previousClusterState.metadata().coordinationMetadata().term() + 1)
+            .build();
+        Settings updatedPersistentSettings = Settings.builder()
+            .put("random_persistent_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5))
+            .build();
+        Settings updatedTransientSettings = Settings.builder()
+            .put("random_transient_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5))
+            .build();
+        TemplatesMetadata updatedTemplateMetadata = getTemplatesMetadata();
+        DiffableStringMap updatedHashesOfConsistentSettings = getHashesOfConsistentSettings();
+        DiscoveryNodes updatedDiscoveryNodes = getDiscoveryNodes();
+        ClusterBlocks updatedClusterBlocks = randomClusterBlocks();
+        TestClusterStateCustom3 updatedClusterStateCustom3 = new TestClusterStateCustom3("custom_3");
+
+        RemoteIndexMetadataManager mockedIndexManager = mock(RemoteIndexMetadataManager.class);
+        RemoteGlobalMetadataManager mockedGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
+        RemoteClusterStateAttributesManager mockedClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
+
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(new RemoteReadResult(newIndexMetadata, INDEX, "test-index-1"));
+            return null;
+        }).when(mockedIndexManager)
+            .readAsync(eq("test-index-1"), argThat(new BlobNameMatcher(indexFilename)), any(LatchedActionListener.class));
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(new RemoteReadResult(customMetadata3, CUSTOM_METADATA, "custom_md_3"));
+            return null;
+        }).when(mockedGlobalMetadataManager).readAsync(eq("custom_md_3"), argThat(new BlobNameMatcher(customMetadataFilename)), any());
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(
+                new RemoteReadResult(updatedCoordinationMetadata, COORDINATION_METADATA, COORDINATION_METADATA)
+            );
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(COORDINATION_METADATA), argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(new RemoteReadResult(updatedPersistentSettings, SETTING_METADATA, SETTING_METADATA));
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(SETTING_METADATA), argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(
+                new RemoteReadResult(updatedTransientSettings, TRANSIENT_SETTING_METADATA, TRANSIENT_SETTING_METADATA)
+            );
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(TRANSIENT_SETTING_METADATA), argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(new RemoteReadResult(updatedTemplateMetadata, TEMPLATES_METADATA, TEMPLATES_METADATA));
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(TEMPLATES_METADATA), argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(
+                new RemoteReadResult(updatedHashesOfConsistentSettings, HASHES_OF_CONSISTENT_SETTINGS, HASHES_OF_CONSISTENT_SETTINGS)
+            );
+            return null;
+        }).when(mockedGlobalMetadataManager)
+            .readAsync(eq(HASHES_OF_CONSISTENT_SETTINGS), argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(new RemoteReadResult(updatedDiscoveryNodes, CLUSTER_STATE_ATTRIBUTE, DISCOVERY_NODES));
+            return null;
+        }).when(mockedClusterStateAttributeManager)
+            .readAsync(eq(DISCOVERY_NODES), argThat(new BlobNameMatcher(DISCOVERY_NODES_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(new RemoteReadResult(updatedClusterBlocks, CLUSTER_STATE_ATTRIBUTE, CLUSTER_BLOCKS));
+            return null;
+        }).when(mockedClusterStateAttributeManager)
+            .readAsync(eq(CLUSTER_BLOCKS), argThat(new BlobNameMatcher(CLUSTER_BLOCKS_FILENAME)), any());
+        doAnswer(invocationOnMock -> {
+            LatchedActionListener<RemoteReadResult> latchedActionListener = invocationOnMock.getArgument(2, LatchedActionListener.class);
+            latchedActionListener.onResponse(
+                new RemoteReadResult(
+                    updatedClusterStateCustom3,
+                    CLUSTER_STATE_ATTRIBUTE,
+                    String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, updatedClusterStateCustom3.getWriteableName())
+                )
+            );
+            return null;
+        }).when(mockedClusterStateAttributeManager)
+            .readAsync(
+                eq(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, updatedClusterStateCustom3.getWriteableName())),
+                argThat(new BlobNameMatcher(clusterStateCustomFilename)),
+                any()
+            );
+
+        remoteClusterStateService.start();
+        remoteClusterStateService.setRemoteIndexMetadataManager(mockedIndexManager);
+        remoteClusterStateService.setRemoteGlobalMetadataManager(mockedGlobalMetadataManager);
+        remoteClusterStateService.setRemoteClusterStateAttributesManager(mockedClusterStateAttributeManager);
+
+        ClusterState updatedClusterState = remoteClusterStateService.readClusterStateInParallel(
+            previousClusterState,
+            manifest,
+            manifest.getClusterUUID(),
+            NODE_ID,
+            newIndicesToRead,
+            newCustomMetadataMap,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            emptyList(),
+            true,
+            newClusterStateCustoms,
+            false,
+            true
+        );
+
+        assertEquals(uploadedIndexMetadataList.size(), updatedClusterState.metadata().indices().size());
+        assertTrue(updatedClusterState.metadata().indices().containsKey("test-index-1"));
+        assertEquals(newIndexMetadata, updatedClusterState.metadata().index(newIndexMetadata.getIndex()));
+        uploadedCustomMetadataMap.keySet().forEach(key -> assertTrue(updatedClusterState.metadata().customs().containsKey(key)));
+        assertEquals(customMetadata3, updatedClusterState.metadata().custom(customMetadata3.getWriteableName()));
+        assertEquals(
+            previousClusterState.metadata().coordinationMetadata().term() + 1,
+            updatedClusterState.metadata().coordinationMetadata().term()
+        );
+        assertEquals(updatedPersistentSettings, updatedClusterState.metadata().persistentSettings());
+        assertEquals(updatedTransientSettings, updatedClusterState.metadata().transientSettings());
+        assertEquals(updatedTemplateMetadata.getTemplates(), updatedClusterState.metadata().templates());
+        assertEquals(updatedHashesOfConsistentSettings, updatedClusterState.metadata().hashesOfConsistentSettings());
+        assertEquals(updatedDiscoveryNodes.getSize(), updatedClusterState.getNodes().getSize());
+        updatedDiscoveryNodes.getNodes().forEach((nodeId, node) -> assertEquals(updatedClusterState.getNodes().get(nodeId), node));
+        assertEquals(updatedDiscoveryNodes.getClusterManagerNodeId(), updatedClusterState.getNodes().getClusterManagerNodeId());
+        assertEquals(updatedClusterBlocks, updatedClusterState.blocks());
+        uploadedClusterStateCustomMap.keySet().forEach(key -> assertTrue(updatedClusterState.customs().containsKey(key)));
+        assertEquals(updatedClusterStateCustom3, updatedClusterState.custom("custom_3"));
+        newIndicesToRead.forEach(
+            uploadedIndexMetadata -> verify(mockedIndexManager, times(1)).readAsync(
+                eq("test-index-1"),
+                argThat(new BlobNameMatcher(uploadedIndexMetadata.getUploadedFilename())),
+                any()
+            )
+        );
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
+            eq(COORDINATION_METADATA),
+            argThat(new BlobNameMatcher(COORDINATION_METADATA_FILENAME)),
+            any()
+        );
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
+            eq(SETTING_METADATA),
+            argThat(new BlobNameMatcher(PERSISTENT_SETTINGS_FILENAME)),
+            any()
+        );
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
+            eq(TRANSIENT_SETTING_METADATA),
+            argThat(new BlobNameMatcher(TRANSIENT_SETTINGS_FILENAME)),
+            any()
+        );
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
+            eq(TEMPLATES_METADATA),
+            argThat(new BlobNameMatcher(TEMPLATES_METADATA_FILENAME)),
+            any()
+        );
+        verify(mockedGlobalMetadataManager, times(1)).readAsync(
+            eq(HASHES_OF_CONSISTENT_SETTINGS),
+            argThat(new BlobNameMatcher(HASHES_OF_CONSISTENT_SETTINGS_FILENAME)),
+            any()
+        );
+        newCustomMetadataMap.keySet().forEach(uploadedCustomMetadataKey -> {
+            verify(mockedGlobalMetadataManager, times(1)).readAsync(
+                eq(uploadedCustomMetadataKey),
+                argThat(new BlobNameMatcher(newCustomMetadataMap.get(uploadedCustomMetadataKey).getUploadedFilename())),
+                any()
+            );
+        });
+        verify(mockedClusterStateAttributeManager, times(1)).readAsync(
+            eq(DISCOVERY_NODES),
+            argThat(new BlobNameMatcher(DISCOVERY_NODES_FILENAME)),
+            any()
+        );
+        verify(mockedClusterStateAttributeManager, times(1)).readAsync(
+            eq(CLUSTER_BLOCKS),
+            argThat(new BlobNameMatcher(CLUSTER_BLOCKS_FILENAME)),
+            any()
+        );
+        newClusterStateCustoms.keySet().forEach(uploadedClusterStateCustomMetadataKey -> {
+            verify(mockedClusterStateAttributeManager, times(1)).readAsync(
+                eq(String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, uploadedClusterStateCustomMetadataKey)),
+                argThat(new BlobNameMatcher(newClusterStateCustoms.get(uploadedClusterStateCustomMetadataKey).getUploadedFilename())),
+                any()
+            );
+        });
+    }
+
+    /*
+     * Here we will verify the migration of manifest file from codec V0.
+     *
+     * Initially codec version is 0 and global metadata is also null, we will perform index metadata update.
+     * In final manifest codec version should be 2 and have metadata files updated,
+     * even if it was not changed in this cluster state update
+     */
+    public void testMigrationFromCodecV0ManifestToCodecV2Manifest() throws IOException {
+        verifyCodecMigrationManifest(ClusterMetadataManifest.CODEC_V0);
+    }
+
+    /*
+     * Here we will verify the migration of manifest file from codec V1.
+     *
+     * Initially codec version is 1 and a global metadata file is there, we will perform index metadata update.
+     * In final manifest codec version should be 2 and have metadata files updated,
+     * even if it was not changed in this cluster state update
+     */
+    public void testMigrationFromCodecV1ManifestToCodecV2Manifest() throws IOException {
+        verifyCodecMigrationManifest(CODEC_V1);
+    }
+
+    private void verifyCodecMigrationManifest(int previousCodec) throws IOException {
+        mockBlobStoreObjects();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final ClusterState previousClusterState = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata))
+            .nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        // Update only index metadata
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder("test").settings(
+            Settings.builder()
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                .build()
+        ).numberOfShards(1).numberOfReplicas(0).build();
+        Metadata newMetadata = Metadata.builder(previousClusterState.metadata()).put(indexMetadata, true).build();
+        ClusterState newClusterState = ClusterState.builder(previousClusterState).metadata(newMetadata).build();
+
+        // previous manifest with codec 0 and null global metadata
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
+            .codecVersion(previousCodec)
+            .globalMetadataFileName(null)
+            .indices(Collections.emptyList())
+            .build();
+
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifestAfterUpdate = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            newClusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+
+        // global metadata is updated
+        assertThat(manifestAfterUpdate.hasMetadataAttributesFiles(), is(true));
+        // During incremental update, codec version will not change.
+        assertThat(manifestAfterUpdate.getCodecVersion(), is(previousCodec));
+    }
+
+    public void testWriteIncrementalGlobalMetadataFromCodecV0Success() throws IOException {
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(Collections.emptyList()).build();
+
+        verifyWriteIncrementalGlobalMetadataFromOlderCodecSuccess(previousManifest);
+    }
+
+    public void testWriteIncrementalGlobalMetadataFromCodecV1Success() throws IOException {
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
+            .codecVersion(CODEC_V1)
+            .globalMetadataFileName("global-metadata-file")
+            .indices(Collections.emptyList())
+            .build();
+
+        verifyWriteIncrementalGlobalMetadataFromOlderCodecSuccess(previousManifest);
+    }
+
+    private void verifyWriteIncrementalGlobalMetadataFromOlderCodecSuccess(ClusterMetadataManifest previousManifest) throws IOException {
+        final ClusterState clusterState = generateClusterStateWithGlobalMetadata().nodes(nodesWithLocalNodeClusterManager()).build();
+        mockBlobStoreObjects();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final ClusterState previousClusterState = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata))
+            .build();
+
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            clusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .codecVersion(previousManifest.getCodecVersion())
+            .indices(Collections.emptyList())
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .previousClusterUUID("prev-cluster-uuid")
+            .build();
+
+        assertNull(manifest.getGlobalMetadataFileName());
+        assertNotNull(manifest.getCoordinationMetadata());
+        assertNotNull(manifest.getSettingsMetadata());
+        assertNotNull(manifest.getTemplatesMetadata());
+        assertNotNull(manifest.getCustomMetadataMap());
+
+        assertEquals(expectedManifest.getClusterTerm(), manifest.getClusterTerm());
+        assertEquals(expectedManifest.getStateVersion(), manifest.getStateVersion());
+        assertEquals(expectedManifest.getClusterUUID(), manifest.getClusterUUID());
+        assertEquals(expectedManifest.getStateUUID(), manifest.getStateUUID());
+        assertEquals(expectedManifest.getCodecVersion(), manifest.getCodecVersion());
+    }
+
+    public void testCoordinationMetadataOnlyUpdated() throws IOException {
+        // Updating the voting config, as updating the term will upload the full cluster state and other files will also get updated
+        Function<ClusterState, ClusterState> updater = (initialClusterState) -> ClusterState.builder(initialClusterState)
+            .metadata(
+                Metadata.builder(initialClusterState.metadata())
+                    .version(initialClusterState.metadata().version() + 1)
+                    .coordinationMetadata(
+                        CoordinationMetadata.builder(initialClusterState.coordinationMetadata())
+                            .addVotingConfigExclusion(new CoordinationMetadata.VotingConfigExclusion("excludedNodeId", "excludedNodeName"))
+                            .build()
+                    )
+                    .build()
+            )
+            .build();
+        verifyMetadataAttributeOnlyUpdated(updater, (initialMetadata, metadataAfterUpdate) -> {
+            // Verify that index metadata information is same in manifest files
+            assertEquals(metadataAfterUpdate.getIndices().size(), initialMetadata.getIndices().size());
+            IntStream.range(0, initialMetadata.getIndices().size()).forEach(i -> {
+                assertEquals(metadataAfterUpdate.getIndices().get(i).getIndexName(), initialMetadata.getIndices().get(i).getIndexName());
+                assertEquals(metadataAfterUpdate.getIndices().get(i).getIndexUUID(), initialMetadata.getIndices().get(i).getIndexUUID());
+                // since timestamp is part of file name, if file name is same we can confirm that file is not update in global metadata
+                // update
+                assertEquals(
+                    metadataAfterUpdate.getIndices().get(i).getUploadedFilename(),
+                    initialMetadata.getIndices().get(i).getUploadedFilename()
+                );
+            });
+
+            // coordination metadata file would have changed
+            assertFalse(
+                metadataAfterUpdate.getCoordinationMetadata()
+                    .getUploadedFilename()
+                    .equalsIgnoreCase(initialMetadata.getCoordinationMetadata().getUploadedFilename())
+            );
+            // Other files will be equal
+            assertEquals(
+                metadataAfterUpdate.getSettingsMetadata().getUploadedFilename(),
+                initialMetadata.getSettingsMetadata().getUploadedFilename()
+            );
+            assertEquals(metadataAfterUpdate.getTemplatesMetadata(), initialMetadata.getTemplatesMetadata());
+            assertEquals(metadataAfterUpdate.getCustomMetadataMap(), initialMetadata.getCustomMetadataMap());
+        });
+    }
+
+    public void testSettingsMetadataOnlyUpdated() throws IOException {
+        Function<ClusterState, ClusterState> updater = (initialClusterState) -> ClusterState.builder(initialClusterState)
+            .metadata(
+                Metadata.builder(initialClusterState.metadata()).persistentSettings(Settings.builder().put("foo", "bar").build()).build()
+            )
+            .build();
+
+        verifyMetadataAttributeOnlyUpdated(updater, (initialMetadata, metadataAfterUpdate) -> {
+            // Verify that index metadata information is same in manifest files
+            assertEquals(metadataAfterUpdate.getIndices().size(), initialMetadata.getIndices().size());
+            IntStream.range(0, initialMetadata.getIndices().size()).forEach(i -> {
+                assertEquals(metadataAfterUpdate.getIndices().get(i).getIndexName(), initialMetadata.getIndices().get(i).getIndexName());
+                assertEquals(metadataAfterUpdate.getIndices().get(i).getIndexUUID(), initialMetadata.getIndices().get(i).getIndexUUID());
+                // since timestamp is part of file name, if file name is same we can confirm that file is not update in global metadata
+                // update
+                assertEquals(
+                    metadataAfterUpdate.getIndices().get(i).getUploadedFilename(),
+                    initialMetadata.getIndices().get(i).getUploadedFilename()
+                );
+            });
+
+            // setting metadata file would have changed
+            assertFalse(
+                metadataAfterUpdate.getSettingsMetadata()
+                    .getUploadedFilename()
+                    .equalsIgnoreCase(initialMetadata.getSettingsMetadata().getUploadedFilename())
+            );
+            assertEquals(metadataAfterUpdate.getCoordinationMetadata(), initialMetadata.getCoordinationMetadata());
+            assertEquals(metadataAfterUpdate.getTemplatesMetadata(), initialMetadata.getTemplatesMetadata());
+            assertEquals(metadataAfterUpdate.getCustomMetadataMap(), initialMetadata.getCustomMetadataMap());
+        });
+    }
+
+    public void testTemplatesMetadataOnlyUpdated() throws IOException {
+        Function<ClusterState, ClusterState> updater = (initialClusterState) -> ClusterState.builder(initialClusterState)
+            .metadata(
+                Metadata.builder(initialClusterState.metadata())
+                    .templates(
+                        TemplatesMetadata.builder()
+                            .put(
+                                IndexTemplateMetadata.builder("template" + randomAlphaOfLength(3))
+                                    .patterns(Arrays.asList("bar-*", "foo-*"))
+                                    .settings(
+                                        Settings.builder()
+                                            .put("random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5))
+                                            .build()
+                                    )
+                                    .build()
+                            )
+                            .build()
+                    )
+                    .build()
+            )
+            .build();
+
+        verifyMetadataAttributeOnlyUpdated(updater, (initialMetadata, metadataAfterUpdate) -> {
+            // Verify that index metadata information is same in manifest files
+            assertEquals(metadataAfterUpdate.getIndices().size(), initialMetadata.getIndices().size());
+            IntStream.range(0, initialMetadata.getIndices().size()).forEach(i -> {
+                assertEquals(metadataAfterUpdate.getIndices().get(i).getIndexName(), initialMetadata.getIndices().get(i).getIndexName());
+                assertEquals(metadataAfterUpdate.getIndices().get(i).getIndexUUID(), initialMetadata.getIndices().get(i).getIndexUUID());
+                // since timestamp is part of file name, if file name is same we can confirm that file is not update in global metadata
+                // update
+                assertEquals(
+                    metadataAfterUpdate.getIndices().get(i).getUploadedFilename(),
+                    initialMetadata.getIndices().get(i).getUploadedFilename()
+                );
+            });
+
+            // template metadata file would have changed
+            assertFalse(
+                metadataAfterUpdate.getTemplatesMetadata()
+                    .getUploadedFilename()
+                    .equalsIgnoreCase(initialMetadata.getTemplatesMetadata().getUploadedFilename())
+            );
+            assertEquals(metadataAfterUpdate.getCoordinationMetadata(), initialMetadata.getCoordinationMetadata());
+            assertEquals(metadataAfterUpdate.getSettingsMetadata(), initialMetadata.getSettingsMetadata());
+            assertEquals(metadataAfterUpdate.getCustomMetadataMap(), initialMetadata.getCustomMetadataMap());
+        });
+    }
+
+    public void testCustomMetadataOnlyUpdated() throws IOException {
+        Function<ClusterState, ClusterState> updater = (initialClusterState) -> ClusterState.builder(initialClusterState)
+            .metadata(
+                Metadata.builder(initialClusterState.metadata())
+                    .putCustom("custom_metadata_type", new CustomMetadata1("mock_custom_metadata"))
+                    .build()
+            )
+            .build();
+
+        verifyMetadataAttributeOnlyUpdated(updater, (initialMetadata, metadataAfterUpdate) -> {
+            // Verify that index metadata information is same in manifest files
+            assertEquals(metadataAfterUpdate.getIndices().size(), initialMetadata.getIndices().size());
+            IntStream.range(0, initialMetadata.getIndices().size()).forEach(i -> {
+                assertEquals(metadataAfterUpdate.getIndices().get(i).getIndexName(), initialMetadata.getIndices().get(i).getIndexName());
+                assertEquals(metadataAfterUpdate.getIndices().get(i).getIndexUUID(), initialMetadata.getIndices().get(i).getIndexUUID());
+                // since timestamp is part of file name, if file name is same we can confirm that file is not update in global metadata
+                // update
+                assertEquals(
+                    metadataAfterUpdate.getIndices().get(i).getUploadedFilename(),
+                    initialMetadata.getIndices().get(i).getUploadedFilename()
+                );
+                // custom metadata map would have changed
+                assertNotEquals(metadataAfterUpdate.getCustomMetadataMap(), initialMetadata.getCustomMetadataMap());
+                assertEquals(initialMetadata.getCustomMetadataMap().size() + 1, metadataAfterUpdate.getCustomMetadataMap().size());
+                initialMetadata.getCustomMetadataMap().forEach((k, v) -> {
+                    assertTrue(metadataAfterUpdate.getCustomMetadataMap().containsKey(k));
+                    assertEquals(v, metadataAfterUpdate.getCustomMetadataMap().get(k));
+                });
+                assertEquals(metadataAfterUpdate.getCoordinationMetadata(), initialMetadata.getCoordinationMetadata());
+                assertEquals(metadataAfterUpdate.getSettingsMetadata(), initialMetadata.getSettingsMetadata());
+                assertEquals(metadataAfterUpdate.getTemplatesMetadata(), initialMetadata.getTemplatesMetadata());
+            });
+        });
+    }
+
+    public void testCustomMetadataDeletedUpdatedAndAdded() throws IOException {
+        // setup
+        mockBlobStoreObjects();
+
+        // Initial cluster state with index.
+        final ClusterState initialClusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest initialManifest = remoteClusterStateService.writeFullMetadata(
+            initialClusterState,
+            "_na_",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
+
+        ClusterState clusterState1 = ClusterState.builder(initialClusterState)
+            .metadata(
+                Metadata.builder(initialClusterState.metadata())
+                    .putCustom("custom1", new CustomMetadata1("mock_custom_metadata1"))
+                    .putCustom("custom2", new CustomMetadata1("mock_custom_metadata2"))
+                    .putCustom("custom3", new CustomMetadata1("mock_custom_metadata3"))
+                    .version(initialClusterState.metadata().version() + 1)
+            )
+            .build();
+
+        ClusterMetadataManifest manifest1 = remoteClusterStateService.writeIncrementalMetadata(
+            initialClusterState,
+            clusterState1,
+            initialManifest
+        ).getClusterMetadataManifest();
+        // remove custom1 from the cluster state, update custom2, custom3 is at it is, added custom4
+        ClusterState clusterState2 = ClusterState.builder(initialClusterState)
+            .metadata(
+                Metadata.builder(initialClusterState.metadata())
+                    .putCustom("custom2", new CustomMetadata1("mock_updated_custom_metadata"))
+                    .putCustom("custom3", new CustomMetadata1("mock_custom_metadata3"))
+                    .putCustom("custom4", new CustomMetadata1("mock_custom_metadata4"))
+                    .version(clusterState1.metadata().version() + 1)
+            )
+            .build();
+        ClusterMetadataManifest manifest2 = remoteClusterStateService.writeIncrementalMetadata(clusterState1, clusterState2, manifest1)
+            .getClusterMetadataManifest();
+        // custom1 is removed
+        assertFalse(manifest2.getCustomMetadataMap().containsKey("custom1"));
+        // custom2 is updated
+        assertNotEquals(manifest1.getCustomMetadataMap().get("custom2"), manifest2.getCustomMetadataMap().get("custom2"));
+        // custom3 is unchanged
+        assertEquals(manifest1.getCustomMetadataMap().get("custom3"), manifest2.getCustomMetadataMap().get("custom3"));
+        // custom4 is added
+        assertTrue(manifest2.getCustomMetadataMap().containsKey("custom4"));
+        assertFalse(manifest1.getCustomMetadataMap().containsKey("custom4"));
+    }
+
+    /*
+     * Here we will verify global metadata is not uploaded again if change is only in index metadata
+     */
+    public void testIndexMetadataOnlyUpdated() throws IOException {
+        Function<ClusterState, ClusterState> updater = (initialState) -> ClusterState.builder(initialState)
+            .metadata(
+                Metadata.builder(initialState.metadata())
+                    .put(
+                        IndexMetadata.builder("test" + randomAlphaOfLength(3))
+                            .settings(
+                                Settings.builder()
+                                    .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                                    .put(IndexMetadata.SETTING_INDEX_UUID, "uuid")
+                                    .build()
+                            )
+                            .numberOfShards(1)
+                            .numberOfReplicas(0)
+                    )
+                    .build()
+            )
+            .build();
+
+        verifyMetadataAttributeOnlyUpdated(updater, (initialMetadata, metadataAfterUpdate) -> {
+            assertEquals(metadataAfterUpdate.getCoordinationMetadata(), initialMetadata.getCoordinationMetadata());
+            assertEquals(metadataAfterUpdate.getSettingsMetadata(), initialMetadata.getSettingsMetadata());
+            assertEquals(metadataAfterUpdate.getTemplatesMetadata(), initialMetadata.getTemplatesMetadata());
+            assertEquals(metadataAfterUpdate.getCustomMetadataMap(), initialMetadata.getCustomMetadataMap());
+            assertEquals(initialMetadata.getIndices().size() + 1, metadataAfterUpdate.getIndices().size());
+        });
+    }
+
+    public void testIndexMetadataDeletedUpdatedAndAdded() throws IOException {
+        // setup
+        mockBlobStoreObjects();
+
+        // Initial cluster state with index.
+        final ClusterState initialClusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest initialManifest = remoteClusterStateService.writeFullMetadata(
+            initialClusterState,
+            "_na_",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
+        String initialIndex = "test-index";
+        Index index1 = new Index("test-index-1", "index-uuid-1");
+        Index index2 = new Index("test-index-2", "index-uuid-2");
+        Settings idxSettings1 = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index1.getUUID())
+            .build();
+        IndexMetadata indexMetadata1 = new IndexMetadata.Builder(index1.getName()).settings(idxSettings1)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+        Settings idxSettings2 = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index2.getUUID())
+            .build();
+        IndexMetadata indexMetadata2 = new IndexMetadata.Builder(index2.getName()).settings(idxSettings2)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+        ClusterState clusterState1 = ClusterState.builder(initialClusterState)
+            .metadata(
+                Metadata.builder(initialClusterState.getMetadata())
+                    .put(indexMetadata1, true)
+                    .put(indexMetadata2, true)
+                    .remove(initialIndex)
+                    .build()
+            )
+            .build();
+        ClusterMetadataManifest manifest1 = remoteClusterStateService.writeIncrementalMetadata(
+            initialClusterState,
+            clusterState1,
+            initialManifest
+        ).getClusterMetadataManifest();
+        // verify that initial index is removed, and new index are added
+        assertEquals(1, initialManifest.getIndices().size());
+        assertEquals(2, manifest1.getIndices().size());
+        assertTrue(initialManifest.getIndices().stream().anyMatch(indexMetadata -> indexMetadata.getIndexName().equals(initialIndex)));
+        assertFalse(manifest1.getIndices().stream().anyMatch(indexMetadata -> indexMetadata.getIndexName().equals(initialIndex)));
+        // update index1, index2 is unchanged
+        indexMetadata1 = new IndexMetadata.Builder(indexMetadata1).version(indexMetadata1.getVersion() + 1).build();
+        ClusterState clusterState2 = ClusterState.builder(clusterState1)
+            .metadata(Metadata.builder(clusterState1.getMetadata()).put(indexMetadata1, true).build())
+            .build();
+        ClusterMetadataManifest manifest2 = remoteClusterStateService.writeIncrementalMetadata(clusterState1, clusterState2, manifest1)
+            .getClusterMetadataManifest();
+        // index1 is updated
+        assertEquals(2, manifest2.getIndices().size());
+        assertEquals(
+            1,
+            manifest2.getIndices().stream().filter(uploadedIndex -> uploadedIndex.getIndexName().equals(index1.getName())).count()
+        );
+        assertNotEquals(
+            manifest2.getIndices()
+                .stream()
+                .filter(uploadedIndex -> uploadedIndex.getIndexName().equals(index1.getName()))
+                .findFirst()
+                .get()
+                .getUploadedFilename(),
+            manifest1.getIndices()
+                .stream()
+                .filter(uploadedIndex -> uploadedIndex.getIndexName().equals(index1.getName()))
+                .findFirst()
+                .get()
+                .getUploadedFilename()
+        );
+    }
+
+    private void verifyMetadataAttributeOnlyUpdated(
+        Function<ClusterState, ClusterState> clusterStateUpdater,
+        BiConsumer<ClusterMetadataManifest, ClusterMetadataManifest> assertions
+    ) throws IOException {
+        // setup
+        mockBlobStoreObjects();
+
+        // Initial cluster state with index.
+        final ClusterState initialClusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest initialManifest = remoteClusterStateService.writeFullMetadata(
+            initialClusterState,
+            "_na_",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
+
+        ClusterState newClusterState = clusterStateUpdater.apply(initialClusterState);
+
+        // updating remote cluster state with global metadata
+        final ClusterMetadataManifest manifestAfterMetadataUpdate;
+        if (initialClusterState.term() == newClusterState.term()) {
+            manifestAfterMetadataUpdate = remoteClusterStateService.writeIncrementalMetadata(
+                initialClusterState,
+                newClusterState,
+                initialManifest
+            ).getClusterMetadataManifest();
+        } else {
+            manifestAfterMetadataUpdate = remoteClusterStateService.writeFullMetadata(
+                newClusterState,
+                initialClusterState.stateUUID(),
+                MANIFEST_CURRENT_CODEC_VERSION
+            ).getClusterMetadataManifest();
+        }
+
+        assertions.accept(initialManifest, manifestAfterMetadataUpdate);
+    }
+
+    public void testReadLatestMetadataManifestFailedNoManifestFileInRemote() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+
+        BlobContainer blobContainer = mockBlobStoreObjects();
+        when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
+            .thenReturn(List.of());
+
+        remoteClusterStateService.start();
+        Optional<ClusterMetadataManifest> manifest = remoteClusterStateService.getLatestClusterMetadataManifest(
+            clusterState.getClusterName().value(),
+            clusterState.metadata().clusterUUID()
+        );
+        assertEquals(manifest, Optional.empty());
+    }
+
+    public void testReadLatestMetadataManifestFailedManifestFileRemoveAfterFetchInRemote() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+
+        BlobContainer blobContainer = mockBlobStoreObjects();
+        BlobMetadata blobMetadata = new PlainBlobMetadata("manifestFileName", 1);
+        when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
+            .thenReturn(Arrays.asList(blobMetadata));
+        when(blobContainer.readBlob("manifestFileName")).thenThrow(FileNotFoundException.class);
+
+        remoteClusterStateService.start();
+        Exception e = assertThrows(
+            IllegalStateException.class,
+            () -> remoteClusterStateService.getLatestClusterMetadataManifest(
+                clusterState.getClusterName().value(),
+                clusterState.metadata().clusterUUID()
+            )
+        );
+        assertEquals(e.getMessage(), "Error while downloading cluster metadata - manifestFileName");
+    }
+
+    public void testReadLatestMetadataManifestSuccessButNoIndexMetadata() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(List.of())
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID("prev-cluster-uuid")
+            .codecVersion(ClusterMetadataManifest.CODEC_V0)
+            .build();
+
+        BlobContainer blobContainer = mockBlobStoreObjects();
+        mockBlobContainer(blobContainer, expectedManifest, Map.of());
+
+        remoteClusterStateService.start();
+        assertEquals(
+            remoteClusterStateService.getLatestClusterState(
+                clusterState.getClusterName().value(),
+                clusterState.metadata().clusterUUID(),
+                false
+            ).getMetadata().getIndices().size(),
+            0
+        );
+    }
+
+    public void testReadLatestMetadataManifestSuccessButIndexMetadataFetchIOException() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename__2");
+        final List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(indices)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .codecVersion(CODEC_V2)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID("prev-cluster-uuid")
+            .build();
+
+        BlobContainer blobContainer = mockBlobStoreObjects();
+        mockBlobContainer(blobContainer, expectedManifest, Map.of(), CODEC_V2);
+        when(blobContainer.readBlob(uploadedIndexMetadata.getUploadedFilename())).thenThrow(FileNotFoundException.class);
+
+        remoteClusterStateService.start();
+        Exception e = assertThrows(
+            RemoteStateTransferException.class,
+            () -> remoteClusterStateService.getLatestClusterState(
+                clusterState.getClusterName().value(),
+                clusterState.metadata().clusterUUID(),
+                false
+            ).getMetadata().getIndices()
+        );
+        assertEquals("Exception during reading cluster state from remote", e.getMessage());
+    }
+
+    public void testReadLatestMetadataManifestSuccess() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
+
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(indices)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .codecVersion(CODEC_V2)
+            .previousClusterUUID("prev-cluster-uuid")
+            .build();
+
+        mockBlobContainer(mockBlobStoreObjects(), expectedManifest, new HashMap<>(), CODEC_V2);
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.getLatestClusterMetadataManifest(
+            clusterState.getClusterName().value(),
+            clusterState.metadata().clusterUUID()
+        ).get();
+
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
+        assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
+        assertThat(manifest.getIndices().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+    }
+
+    public void testReadGlobalMetadata() throws IOException {
+        when(blobStoreRepository.getNamedXContentRegistry()).thenReturn(new NamedXContentRegistry(
+            List.of(new NamedXContentRegistry.Entry(Metadata.Custom.class, new ParseField(IndexGraveyard.TYPE), IndexGraveyard::fromXContent))));
+        final ClusterState clusterState = generateClusterStateWithGlobalMetadata().nodes(nodesWithLocalNodeClusterManager()).build();
+        remoteClusterStateService.start();
+
+        long prevClusterStateVersion = 13L;
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(List.of())
+            .clusterTerm(1L)
+            .stateVersion(prevClusterStateVersion)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .codecVersion(MANIFEST_CURRENT_CODEC_VERSION)
+            .coordinationMetadata(new ClusterMetadataManifest.UploadedMetadataAttribute(COORDINATION_METADATA, "mock-coordination-file"))
+            .settingMetadata(new ClusterMetadataManifest.UploadedMetadataAttribute(SETTING_METADATA, "mock-setting-file"))
+            .templatesMetadata(new ClusterMetadataManifest.UploadedMetadataAttribute(TEMPLATES_METADATA, "mock-templates-file"))
+            .put(IndexGraveyard.TYPE, new ClusterMetadataManifest.UploadedMetadataAttribute(IndexGraveyard.TYPE, "mock-custom-" + IndexGraveyard.TYPE + "-file"))
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1)
+            .indicesRouting(List.of())
+            .build();
+
+        Metadata expectedMetadata = Metadata.builder().clusterUUID("cluster-uuid").persistentSettings(Settings.builder().put("readonly", true).build()).build();
+        mockBlobContainerForGlobalMetadata(mockBlobStoreObjects(), expectedManifest, expectedMetadata);
+
+        ClusterState newClusterState = remoteClusterStateService.getLatestClusterState(
+            clusterState.getClusterName().value(),
+            clusterState.metadata().clusterUUID(),
+            false
+        );
+
+        assertTrue(Metadata.isGlobalStateEquals(newClusterState.getMetadata(), expectedMetadata));
+
+        long newClusterStateVersion = newClusterState.getVersion();
+        assert prevClusterStateVersion == newClusterStateVersion : String.format(
+            Locale.ROOT,
+            "ClusterState version is not restored. previousClusterVersion: [%s] is not equal to current [%s]",
+            prevClusterStateVersion,
+            newClusterStateVersion
+        );
+    }
+
+    public void testReadGlobalMetadataIOException() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithGlobalMetadata().nodes(nodesWithLocalNodeClusterManager()).build();
+        remoteClusterStateService.start();
+        String globalIndexMetadataName = "global-metadata-file";
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(List.of())
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .codecVersion(CODEC_V1)
+            .globalMetadataFileName(globalIndexMetadataName)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID("prev-cluster-uuid")
+            .build();
+
+        Metadata expactedMetadata = Metadata.builder().persistentSettings(Settings.builder().put("readonly", true).build()).build();
+
+        BlobContainer blobContainer = mockBlobStoreObjects();
+        mockBlobContainerForGlobalMetadata(blobContainer, expectedManifest, expactedMetadata);
+
+        when(blobContainer.readBlob(GLOBAL_METADATA_FORMAT.blobName(globalIndexMetadataName))).thenThrow(FileNotFoundException.class);
+
+        remoteClusterStateService.start();
+        Exception e = assertThrows(
+            IllegalStateException.class,
+            () -> remoteClusterStateService.getLatestClusterState(
                 clusterState.getClusterName().value(),
-                clusterState.metadata().clusterUUID()
+                clusterState.metadata().clusterUUID(),
+                false
             )
         );
-        assertEquals(e.getMessage(), "Error while downloading cluster metadata - manifestFileName");
+        assertEquals(e.getMessage(), "Error while downloading Global Metadata - " + globalIndexMetadataName);
     }
 
-    public void testReadLatestMetadataManifestSuccessButNoIndexMetadata() throws IOException {
+    public void testReadLatestIndexMetadataSuccess() throws IOException {
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        remoteClusterStateService.start();
+
+        final Index index = new Index("test-index", "index-uuid");
+        String fileName = "metadata-" + index.getUUID() + "__1";
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata(index.getName(), index.getUUID(), fileName);
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(11)
+            .numberOfReplicas(10)
+            .build();
+
+        final List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
-            .indices(List.of())
+            .indices(indices)
             .clusterTerm(1L)
             .stateVersion(1L)
             .stateUUID("state-uuid")
@@ -705,521 +2499,1141 @@ public void testReadLatestMetadataManifestSuccessButNoIndexMetadata() throws IOE
             .nodeId("nodeA")
             .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
             .previousClusterUUID("prev-cluster-uuid")
-            .codecVersion(ClusterMetadataManifest.CODEC_V0)
+            .codecVersion(CODEC_V2)
             .build();
 
-        BlobContainer blobContainer = mockBlobStoreObjects();
-        mockBlobContainer(blobContainer, expectedManifest, Map.of());
+        mockBlobContainer(mockBlobStoreObjects(), expectedManifest, Map.of(index.getUUID(), indexMetadata), CODEC_V2);
+
+        Map<String, IndexMetadata> indexMetadataMap = remoteClusterStateService.getLatestClusterState(
+            clusterState.getClusterName().value(),
+            clusterState.metadata().clusterUUID(),
+            false
+        ).getMetadata().getIndices();
+
+        assertEquals(indexMetadataMap.size(), 1);
+        assertEquals(indexMetadataMap.get(index.getName()).getIndex().getName(), index.getName());
+        assertEquals(indexMetadataMap.get(index.getName()).getNumberOfShards(), indexMetadata.getNumberOfShards());
+        assertEquals(indexMetadataMap.get(index.getName()).getNumberOfReplicas(), indexMetadata.getNumberOfReplicas());
+    }
 
+    public void testMarkLastStateAsCommittedSuccess() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        mockBlobStoreObjects();
         remoteClusterStateService.start();
-        assertEquals(
-            remoteClusterStateService.getLatestClusterState(clusterState.getClusterName().value(), clusterState.metadata().clusterUUID())
-                .getMetadata()
-                .getIndices()
-                .size(),
-            0
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(indices).build();
+
+        final ClusterMetadataManifest manifest = remoteClusterStateService.markLastStateAsCommitted(clusterState, previousManifest)
+            .getClusterMetadataManifest();
+
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(indices)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .nodeId("nodeA")
+            .previousClusterUUID("prev-cluster-uuid")
+            .build();
+
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
+        assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
+        assertThat(manifest.getIndices().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+    }
+
+    public void testGetValidPreviousClusterUUID() throws IOException {
+        Map<String, String> clusterUUIDsPointers = Map.of(
+            "cluster-uuid1",
+            ClusterState.UNKNOWN_UUID,
+            "cluster-uuid2",
+            "cluster-uuid1",
+            "cluster-uuid3",
+            "cluster-uuid2"
         );
+        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers);
+
+        remoteClusterStateService.start();
+        String previousClusterUUID = remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster");
+        assertThat(previousClusterUUID, equalTo("cluster-uuid3"));
     }
 
-    public void testReadLatestMetadataManifestSuccessButIndexMetadataFetchIOException() throws IOException {
+    public void testGetValidPreviousClusterUUIDForInvalidChain() throws IOException {
+        Map<String, String> clusterUUIDsPointers = Map.of(
+            "cluster-uuid2",
+            "cluster-uuid1",
+            "cluster-uuid3",
+            "cluster-uuid2",
+            "cluster-uuid5",
+            "cluster-uuid4"
+        );
+        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers);
+
+        remoteClusterStateService.start();
+        assertThrows(IllegalStateException.class, () -> remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster"));
+    }
+
+    public void testGetValidPreviousClusterUUIDWithMultipleChains() throws IOException {
+        Map<String, String> clusterUUIDsPointers = Map.of(
+            "cluster-uuid2",
+            "cluster-uuid1",
+            "cluster-uuid1",
+            ClusterState.UNKNOWN_UUID,
+            "cluster-uuid3",
+            "cluster-uuid1"
+        );
+        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers, randomBoolean(), Collections.emptyMap());
+
+        remoteClusterStateService.start();
+        String previousClusterUUID = remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster");
+        assertThat(previousClusterUUID, equalTo("cluster-uuid3"));
+    }
+
+    public void testGetValidPreviousClusterUUIDWithInvalidMultipleChains() throws IOException {
+        Map<String, String> clusterUUIDsPointers = Map.of(
+            "cluster-uuid1",
+            ClusterState.UNKNOWN_UUID,
+            "cluster-uuid2",
+            "cluster-uuid1",
+            "cluster-uuid3",
+            ClusterState.UNKNOWN_UUID
+        );
+        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers);
+
+        remoteClusterStateService.start();
+        assertThrows(IllegalStateException.class, () -> remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster"));
+    }
+
+    public void testGetValidPreviousClusterUUIDWhenLastUUIDUncommitted() throws IOException {
+        Map<String, String> clusterUUIDsPointers = Map.of(
+            "cluster-uuid1",
+            ClusterState.UNKNOWN_UUID,
+            "cluster-uuid2",
+            "cluster-uuid1",
+            "cluster-uuid3",
+            "cluster-uuid2"
+        );
+        Map<String, Boolean> clusterUUIDCommitted = Map.of("cluster-uuid1", true, "cluster-uuid2", true, "cluster-uuid3", false);
+        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers, clusterUUIDCommitted);
+
+        remoteClusterStateService.start();
+        String previousClusterUUID = remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster");
+        assertThat(previousClusterUUID, equalTo("cluster-uuid2"));
+    }
+
+    public void testRemoteStateUploadStats() throws IOException {
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        mockBlobStoreObjects();
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            "prev-cluster-uuid",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
+
+        assertTrue(remoteClusterStateService.getUploadStats() != null);
+        assertEquals(1, remoteClusterStateService.getUploadStats().getSuccessCount());
+        assertEquals(0, remoteClusterStateService.getRemoteStateStats().getCleanupAttemptFailedCount());
+        assertEquals(0, remoteClusterStateService.getUploadStats().getFailedCount());
+    }
+
+    public void testRemoteRoutingTableNotInitializedWhenDisabled() {
+        if (isRemoteRoutingTableEnabled(settings)) {
+            assertTrue(remoteClusterStateService.getRemoteRoutingTableService() instanceof InternalRemoteRoutingTableService);
+        } else {
+            assertTrue(remoteClusterStateService.getRemoteRoutingTableService() instanceof NoopRemoteRoutingTableService);
+        }
+    }
+
+    public void testRemoteRoutingTableInitializedWhenEnabled() {
+        Settings newSettings = Settings.builder()
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, "routing_repository")
+            .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, "remote_store_repository")
+            .put(RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
+            .build();
+        clusterSettings.applySettings(newSettings);
+
+        Settings nodeSettings = Settings.builder().put(REMOTE_PUBLICATION_EXPERIMENTAL, "true").build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+
+        remoteClusterStateService = new RemoteClusterStateService(
+            "test-node-id",
+            repositoriesServiceSupplier,
+            newSettings,
+            clusterService,
+            () -> 0L,
+            threadPool,
+            List.of(
+                new RemoteIndexPathUploader(
+                    threadPool,
+                    newSettings,
+                    repositoriesServiceSupplier,
+                    clusterSettings,
+                    DefaultRemoteStoreSettings.INSTANCE
+                )
+            ),
+            writableRegistry()
+        );
+        assertTrue(remoteClusterStateService.getRemoteRoutingTableService() instanceof InternalRemoteRoutingTableService);
+    }
+
+    public void testWriteFullMetadataSuccessWithRoutingTable() throws IOException {
+        initializeRoutingTable();
+        mockBlobStoreObjects();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
+
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            "prev-cluster-uuid",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
         final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
-        final List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
-            .indices(indices)
+            .indices(List.of(uploadedIndexMetadata))
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1L)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
+            .build();
+
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getPreviousClusterUUID(), is(expectedManifest.getPreviousClusterUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+    }
+
+    public void testWriteFullMetadataInParallelSuccessWithRoutingTable() throws IOException {
+        initializeRoutingTable();
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        AsyncMultiStreamBlobContainer container = (AsyncMultiStreamBlobContainer) mockBlobStoreObjects(AsyncMultiStreamBlobContainer.class);
+
+        ArgumentCaptor<ActionListener<Void>> actionListenerArgumentCaptor = ArgumentCaptor.forClass(ActionListener.class);
+        ArgumentCaptor<WriteContext> writeContextArgumentCaptor = ArgumentCaptor.forClass(WriteContext.class);
+        ConcurrentHashMap<String, WriteContext> capturedWriteContext = new ConcurrentHashMap<>();
+        doAnswer((i) -> {
+            actionListenerArgumentCaptor.getValue().onResponse(null);
+            WriteContext writeContext = writeContextArgumentCaptor.getValue();
+            capturedWriteContext.put(writeContext.getFileName().split(DELIMITER)[0], writeContextArgumentCaptor.getValue());
+            return null;
+        }).when(container).asyncBlobUpload(writeContextArgumentCaptor.capture(), actionListenerArgumentCaptor.capture());
+
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
+
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            "prev-cluster-uuid",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
+
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(List.of(uploadedIndexMetadata))
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1)
+            .codecVersion(CODEC_V2)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
+            .build();
+
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
+        assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
+        assertThat(manifest.getIndices().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getPreviousClusterUUID(), is(expectedManifest.getPreviousClusterUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+
+        assertEquals(12, actionListenerArgumentCaptor.getAllValues().size());
+        assertEquals(12, writeContextArgumentCaptor.getAllValues().size());
+    }
+
+    public void testWriteIncrementalMetadataSuccessWithRoutingTable() throws IOException {
+        initializeRoutingTable();
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
+        mockBlobStoreObjects();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final ClusterState previousClusterState = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata))
+            .build();
+
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(Collections.emptyList()).build();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
+
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            clusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(List.of(uploadedIndexMetadata))
             .clusterTerm(1L)
             .stateVersion(1L)
             .stateUUID("state-uuid")
             .clusterUUID("cluster-uuid")
-            .nodeId("nodeA")
-            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
             .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
             .build();
 
-        BlobContainer blobContainer = mockBlobStoreObjects();
-        mockBlobContainer(blobContainer, expectedManifest, Map.of());
-        when(blobContainer.readBlob(uploadedIndexMetadata.getUploadedFilename() + ".dat")).thenThrow(FileNotFoundException.class);
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+    }
 
-        remoteClusterStateService.start();
-        Exception e = assertThrows(
-            IllegalStateException.class,
-            () -> remoteClusterStateService.getLatestClusterState(
-                clusterState.getClusterName().value(),
-                clusterState.metadata().clusterUUID()
-            ).getMetadata().getIndices()
+    public void testWriteIncrementalMetadataSuccessWithRoutingTableDiff() throws IOException {
+        initializeRoutingTable();
+        final ClusterState clusterState = generateClusterStateWithOneIndex("test-index", 5, 1, false).nodes(
+            nodesWithLocalNodeClusterManager()
+        ).build();
+        mockBlobStoreObjects();
+        List<UploadedIndexMetadata> indices = new ArrayList<>();
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
         );
-        assertEquals(e.getMessage(), "Error while downloading IndexMetadata - " + uploadedIndexMetadata.getUploadedFilename());
-    }
+        indices.add(uploadedIndiceRoutingMetadata);
+        final ClusterState previousClusterState = generateClusterStateWithOneIndex("test-index", 5, 1, true).nodes(
+            nodesWithLocalNodeClusterManager()
+        ).build();
 
-    public void testReadLatestMetadataManifestSuccess() throws IOException {
-        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
-        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
-        final List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(indices).build();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
 
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            clusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
-            .indices(indices)
-            .clusterTerm(1L)
+            .indices(List.of(uploadedIndexMetadata))
+            .clusterTerm(clusterState.term())
             .stateVersion(1L)
             .stateUUID("state-uuid")
             .clusterUUID("cluster-uuid")
-            .nodeId("nodeA")
-            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
-            .codecVersion(ClusterMetadataManifest.CODEC_V0)
             .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
             .build();
 
-        mockBlobContainer(mockBlobStoreObjects(), expectedManifest, new HashMap<>());
-        remoteClusterStateService.start();
-        final ClusterMetadataManifest manifest = remoteClusterStateService.getLatestClusterMetadataManifest(
-            clusterState.getClusterName().value(),
-            clusterState.metadata().clusterUUID()
-        ).get();
-
         assertThat(manifest.getIndices().size(), is(1));
-        assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
-        assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
-        assertThat(manifest.getIndices().get(0).getUploadedFilename(), notNullValue());
         assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
         assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
         assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
         assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getDiffManifest().getIndicesRoutingDiffPath(), notNullValue());
     }
 
-    public void testReadGlobalMetadata() throws IOException {
-        when(blobStoreRepository.getNamedXContentRegistry()).thenReturn(new NamedXContentRegistry(
-            List.of(new NamedXContentRegistry.Entry(Metadata.Custom.class, new ParseField(IndexGraveyard.TYPE), IndexGraveyard::fromXContent))));
-        final ClusterState clusterState = generateClusterStateWithGlobalMetadata().nodes(nodesWithLocalNodeClusterManager()).build();
-        remoteClusterStateService.start();
+    public void testWriteIncrementalMetadataSuccessWithRoutingTableDiffNull() throws IOException {
+        initializeRoutingTable();
+        final ClusterState clusterState = generateClusterStateWithOneIndex("test-index", 5, 1, false).nodes(
+            nodesWithLocalNodeClusterManager()
+        ).build();
+        mockBlobStoreObjects();
+        List<UploadedIndexMetadata> indices = new ArrayList<>();
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
+        indices.add(uploadedIndiceRoutingMetadata);
+        final ClusterState previousClusterState = clusterState;
 
-        long prevClusterStateVersion = 13L;
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(indices).build();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
+
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            clusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
-            .indices(List.of())
-            .clusterTerm(1L)
-            .stateVersion(prevClusterStateVersion)
+            .indices(List.of(uploadedIndexMetadata))
+            .clusterTerm(clusterState.term())
+            .stateVersion(1L)
             .stateUUID("state-uuid")
             .clusterUUID("cluster-uuid")
-            .codecVersion(MANIFEST_CURRENT_CODEC_VERSION)
-            .globalMetadataFileName("global-metadata-file")
-            .nodeId("nodeA")
-            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
             .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
             .build();
 
-        Metadata expactedMetadata = Metadata.builder().persistentSettings(Settings.builder().put("readonly", true).build()).build();
-        mockBlobContainerForGlobalMetadata(mockBlobStoreObjects(), expectedManifest, expactedMetadata);
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getDiffManifest().getIndicesRoutingDiffPath(), nullValue());
+    }
 
-        ClusterState newClusterState = remoteClusterStateService.getLatestClusterState(
-            clusterState.getClusterName().value(),
-            clusterState.metadata().clusterUUID()
+    private void initializeRoutingTable() {
+        Settings newSettings = Settings.builder()
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, "routing_repository")
+            .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, "remote_store_repository")
+            .put(RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
+            .build();
+        clusterSettings.applySettings(newSettings);
+
+        Settings nodeSettings = Settings.builder().put(REMOTE_PUBLICATION_EXPERIMENTAL, "true").build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+        remoteClusterStateService = new RemoteClusterStateService(
+            "test-node-id",
+            repositoriesServiceSupplier,
+            newSettings,
+            clusterService,
+            () -> 0L,
+            threadPool,
+            List.of(
+                new RemoteIndexPathUploader(
+                    threadPool,
+                    newSettings,
+                    repositoriesServiceSupplier,
+                    clusterSettings,
+                    DefaultRemoteStoreSettings.INSTANCE
+                )
+            ),
+            writableRegistry()
         );
+    }
 
-        assertTrue(Metadata.isGlobalStateEquals(newClusterState.getMetadata(), expactedMetadata));
+    private void initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode mode) {
+        Settings newSettings = Settings.builder()
+            .put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, "routing_repository")
+            .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, "remote_store_repository")
+            .put(RemoteClusterStateService.REMOTE_CLUSTER_STATE_ENABLED_SETTING.getKey(), true)
+            .put(RemoteClusterStateService.REMOTE_CLUSTER_STATE_CHECKSUM_VALIDATION_MODE_SETTING.getKey(), mode.name())
+            .build();
+        clusterSettings.applySettings(newSettings);
 
-        long newClusterStateVersion = newClusterState.getVersion();
-        assert prevClusterStateVersion == newClusterStateVersion : String.format(
-            Locale.ROOT,
-            "ClusterState version is not restored. previousClusterVersion: [%s] is not equal to current [%s]",
-            prevClusterStateVersion,
-            newClusterStateVersion
+        Settings nodeSettings = Settings.builder().put(REMOTE_PUBLICATION_EXPERIMENTAL, "true").build();
+        FeatureFlags.initializeFeatureFlags(nodeSettings);
+        remoteClusterStateService = new RemoteClusterStateService(
+            "test-node-id",
+            repositoriesServiceSupplier,
+            newSettings,
+            clusterService,
+            () -> 0L,
+            threadPool,
+            List.of(
+                new RemoteIndexPathUploader(
+                    threadPool,
+                    newSettings,
+                    repositoriesServiceSupplier,
+                    clusterSettings,
+                    DefaultRemoteStoreSettings.INSTANCE
+                )
+            ),
+            writableRegistry()
         );
     }
 
-    public void testReadGlobalMetadataIOException() throws IOException {
-        final ClusterState clusterState = generateClusterStateWithGlobalMetadata().nodes(nodesWithLocalNodeClusterManager()).build();
+    public void testWriteFullMetadataSuccessWithChecksumValidationEnabled() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
+        mockBlobStoreObjects();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
+
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         remoteClusterStateService.start();
-        String globalIndexMetadataName = "global-metadata-file";
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            "prev-cluster-uuid",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
-            .indices(List.of())
+            .indices(List.of(uploadedIndexMetadata))
             .clusterTerm(1L)
             .stateVersion(1L)
             .stateUUID("state-uuid")
             .clusterUUID("cluster-uuid")
-            .codecVersion(MANIFEST_CURRENT_CODEC_VERSION)
-            .globalMetadataFileName(globalIndexMetadataName)
-            .nodeId("nodeA")
-            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
             .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1L)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
+            .checksum(new ClusterStateChecksum(clusterState))
             .build();
 
-        Metadata expactedMetadata = Metadata.builder().persistentSettings(Settings.builder().put("readonly", true).build()).build();
-
-        BlobContainer blobContainer = mockBlobStoreObjects();
-        mockBlobContainerForGlobalMetadata(blobContainer, expectedManifest, expactedMetadata);
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getPreviousClusterUUID(), is(expectedManifest.getPreviousClusterUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getClusterStateChecksum(), is(expectedManifest.getClusterStateChecksum()));
+    }
 
-        when(blobContainer.readBlob(RemoteClusterStateService.GLOBAL_METADATA_FORMAT.blobName(globalIndexMetadataName))).thenThrow(
-            FileNotFoundException.class
-        );
+    public void testWriteFullMetadataSuccessWithChecksumValidationModeNone() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.NONE);
+        mockBlobStoreObjects();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
 
+        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         remoteClusterStateService.start();
-        Exception e = assertThrows(
-            IllegalStateException.class,
-            () -> remoteClusterStateService.getLatestClusterState(
-                clusterState.getClusterName().value(),
-                clusterState.metadata().clusterUUID()
-            )
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(
+            clusterState,
+            "prev-cluster-uuid",
+            MANIFEST_CURRENT_CODEC_VERSION
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
         );
-        assertEquals(e.getMessage(), "Error while downloading Global Metadata - " + globalIndexMetadataName);
+        final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
+            .indices(List.of(uploadedIndexMetadata))
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .clusterUUID("cluster-uuid")
+            .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1L)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
+            .build();
+
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getPreviousClusterUUID(), is(expectedManifest.getPreviousClusterUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+        assertNull(manifest.getClusterStateChecksum());
     }
 
-    public void testReadLatestIndexMetadataSuccess() throws IOException {
+    public void testWriteIncrementalMetadataSuccessWithChecksumValidationEnabled() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
-        remoteClusterStateService.start();
-
-        final Index index = new Index("test-index", "index-uuid");
-        String fileName = "metadata-" + index.getUUID();
-        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata(index.getName(), index.getUUID(), fileName);
-        final Settings idxSettings = Settings.builder()
-            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
-            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+        mockBlobStoreObjects();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final ClusterState previousClusterState = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata))
             .build();
-        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
-            .numberOfShards(11)
-            .numberOfReplicas(10)
+
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
+            .indices(Collections.emptyList())
+            .checksum(new ClusterStateChecksum(clusterState))
             .build();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
 
-        final List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            clusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
-            .indices(indices)
+            .indices(List.of(uploadedIndexMetadata))
             .clusterTerm(1L)
             .stateVersion(1L)
             .stateUUID("state-uuid")
             .clusterUUID("cluster-uuid")
-            .nodeId("nodeA")
-            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
             .previousClusterUUID("prev-cluster-uuid")
-            .codecVersion(ClusterMetadataManifest.CODEC_V0)
+            .routingTableVersion(1)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
+            .checksum(new ClusterStateChecksum(clusterState))
             .build();
 
-        mockBlobContainer(mockBlobStoreObjects(), expectedManifest, Map.of(index.getUUID(), indexMetadata));
-
-        Map<String, IndexMetadata> indexMetadataMap = remoteClusterStateService.getLatestClusterState(
-            clusterState.getClusterName().value(),
-            clusterState.metadata().clusterUUID()
-        ).getMetadata().getIndices();
-
-        assertEquals(indexMetadataMap.size(), 1);
-        assertEquals(indexMetadataMap.get(index.getName()).getIndex().getName(), index.getName());
-        assertEquals(indexMetadataMap.get(index.getName()).getNumberOfShards(), indexMetadata.getNumberOfShards());
-        assertEquals(indexMetadataMap.get(index.getName()).getNumberOfReplicas(), indexMetadata.getNumberOfReplicas());
+        assertThat(manifest.getIndices().size(), is(1));
+        assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
+        assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
+        assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
+        assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+        assertThat(manifest.getClusterStateChecksum(), is(expectedManifest.getClusterStateChecksum()));
     }
 
-    public void testMarkLastStateAsCommittedSuccess() throws IOException {
+    public void testWriteIncrementalMetadataSuccessWithChecksumValidationModeNone() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.NONE);
         final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
         mockBlobStoreObjects();
-        remoteClusterStateService.start();
-        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
-        List<UploadedIndexMetadata> indices = List.of(uploadedIndexMetadata);
-        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder().indices(indices).build();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final ClusterState previousClusterState = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(Metadata.builder().coordinationMetadata(coordinationMetadata))
+            .build();
 
-        final ClusterMetadataManifest manifest = remoteClusterStateService.markLastStateAsCommitted(clusterState, previousManifest);
+        final ClusterMetadataManifest previousManifest = ClusterMetadataManifest.builder()
+            .indices(Collections.emptyList())
+            .checksum(new ClusterStateChecksum(clusterState))
+            .build();
+        when((blobStoreRepository.basePath())).thenReturn(BlobPath.cleanPath().add("base-path"));
 
+        remoteClusterStateService.start();
+        final ClusterMetadataManifest manifest = remoteClusterStateService.writeIncrementalMetadata(
+            previousClusterState,
+            clusterState,
+            previousManifest
+        ).getClusterMetadataManifest();
+        final UploadedIndexMetadata uploadedIndexMetadata = new UploadedIndexMetadata("test-index", "index-uuid", "metadata-filename");
+        final UploadedIndexMetadata uploadedIndiceRoutingMetadata = new UploadedIndexMetadata(
+            "test-index",
+            "index-uuid",
+            "routing-filename",
+            INDEX_ROUTING_METADATA_PREFIX
+        );
         final ClusterMetadataManifest expectedManifest = ClusterMetadataManifest.builder()
-            .indices(indices)
+            .indices(List.of(uploadedIndexMetadata))
             .clusterTerm(1L)
             .stateVersion(1L)
             .stateUUID("state-uuid")
             .clusterUUID("cluster-uuid")
-            .nodeId("nodeA")
             .previousClusterUUID("prev-cluster-uuid")
+            .routingTableVersion(1)
+            .indicesRouting(List.of(uploadedIndiceRoutingMetadata))
+            .checksum(new ClusterStateChecksum(clusterState))
             .build();
 
         assertThat(manifest.getIndices().size(), is(1));
-        assertThat(manifest.getIndices().get(0).getIndexName(), is(uploadedIndexMetadata.getIndexName()));
-        assertThat(manifest.getIndices().get(0).getIndexUUID(), is(uploadedIndexMetadata.getIndexUUID()));
-        assertThat(manifest.getIndices().get(0).getUploadedFilename(), notNullValue());
         assertThat(manifest.getClusterTerm(), is(expectedManifest.getClusterTerm()));
         assertThat(manifest.getStateVersion(), is(expectedManifest.getStateVersion()));
         assertThat(manifest.getClusterUUID(), is(expectedManifest.getClusterUUID()));
         assertThat(manifest.getStateUUID(), is(expectedManifest.getStateUUID()));
+        assertThat(manifest.getRoutingTableVersion(), is(expectedManifest.getRoutingTableVersion()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexName(), is(uploadedIndiceRoutingMetadata.getIndexName()));
+        assertThat(manifest.getIndicesRouting().get(0).getIndexUUID(), is(uploadedIndiceRoutingMetadata.getIndexUUID()));
+        assertThat(manifest.getIndicesRouting().get(0).getUploadedFilename(), notNullValue());
+        assertNull(manifest.getClusterStateChecksum());
     }
 
-    public void testGetValidPreviousClusterUUID() throws IOException {
-        Map<String, String> clusterUUIDsPointers = Map.of(
-            "cluster-uuid1",
-            ClusterState.UNKNOWN_UUID,
-            "cluster-uuid2",
-            "cluster-uuid1",
-            "cluster-uuid3",
-            "cluster-uuid2"
-        );
-        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers);
-
+    public void testGetClusterStateForManifestWithChecksumValidationEnabledWithNullChecksum() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().build();
+        mockBlobStoreObjects();
         remoteClusterStateService.start();
-        String previousClusterUUID = remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster");
-        assertThat(previousClusterUUID, equalTo("cluster-uuid3"));
-    }
-
-    public void testGetValidPreviousClusterUUIDForInvalidChain() throws IOException {
-        Map<String, String> clusterUUIDsPointers = Map.of(
-            "cluster-uuid2",
-            "cluster-uuid1",
-            "cluster-uuid3",
-            "cluster-uuid2",
-            "cluster-uuid5",
-            "cluster-uuid4"
+        RemoteReadResult mockedResult = mock(RemoteReadResult.class);
+        RemoteIndexMetadataManager mockedIndexManager = mock(RemoteIndexMetadataManager.class);
+        RemoteGlobalMetadataManager mockedGlobalMetadataManager = mock(RemoteGlobalMetadataManager.class);
+        RemoteClusterStateAttributesManager mockedClusterStateAttributeManager = mock(RemoteClusterStateAttributesManager.class);
+        remoteClusterStateService.setRemoteIndexMetadataManager(mockedIndexManager);
+        remoteClusterStateService.setRemoteGlobalMetadataManager(mockedGlobalMetadataManager);
+        remoteClusterStateService.setRemoteClusterStateAttributesManager(mockedClusterStateAttributeManager);
+        ArgumentCaptor<LatchedActionListener<RemoteReadResult>> listenerArgumentCaptor = ArgumentCaptor.forClass(
+            LatchedActionListener.class
+        );
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedIndexManager).readAsync(any(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedGlobalMetadataManager).readAsync(any(), any(), listenerArgumentCaptor.capture());
+        doAnswer(invocation -> {
+            listenerArgumentCaptor.getValue().onResponse(mockedResult);
+            return null;
+        }).when(mockedClusterStateAttributeManager).readAsync(anyString(), any(), listenerArgumentCaptor.capture());
+        when(mockedResult.getComponent()).thenReturn(COORDINATION_METADATA);
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        mockService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true);
+        verify(mockService, times(1)).readClusterStateInParallel(
+            any(),
+            eq(manifest),
+            eq(manifest.getClusterUUID()),
+            eq(NODE_ID),
+            eq(manifest.getIndices()),
+            eq(manifest.getCustomMetadataMap()),
+            eq(true),
+            eq(true),
+            eq(true),
+            eq(true),
+            eq(true),
+            eq(true),
+            eq(manifest.getIndicesRouting()),
+            eq(true),
+            eq(manifest.getClusterStateCustomMap()),
+            eq(false),
+            eq(true)
         );
-        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers);
+        verify(mockService, times(0)).validateClusterStateFromChecksum(
+            any(ClusterMetadataManifest.class),
+            any(ClusterState.class),
+            anyString(),
+            anyString(),
+            anyBoolean()
+        );
+    }
 
+    public void testGetClusterStateForManifestWithChecksumValidationEnabled() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).build();
         remoteClusterStateService.start();
-        assertThrows(IllegalStateException.class, () -> remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster"));
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        doReturn(clusterState).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(manifest.getIndices()),
+                eq(manifest.getCustomMetadataMap()),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(manifest.getIndicesRouting()),
+                eq(true),
+                eq(manifest.getClusterStateCustomMap()),
+                eq(false),
+                eq(true)
+            );
+        mockService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true);
+        verify(mockService, times(1)).validateClusterStateFromChecksum(manifest, clusterState, ClusterName.DEFAULT.value(), NODE_ID, true);
     }
 
-    public void testGetValidPreviousClusterUUIDWithMultipleChains() throws IOException {
-        Map<String, String> clusterUUIDsPointers = Map.of(
-            "cluster-uuid2",
-            "cluster-uuid1",
-            "cluster-uuid1",
-            ClusterState.UNKNOWN_UUID,
-            "cluster-uuid3",
-            "cluster-uuid1"
-        );
-        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers, randomBoolean(), Collections.emptyMap());
-
+    public void testGetClusterStateForManifestWithChecksumValidationModeNone() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.NONE);
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).build();
         remoteClusterStateService.start();
-        String previousClusterUUID = remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster");
-        assertThat(previousClusterUUID, equalTo("cluster-uuid3"));
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        doReturn(clusterState).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(manifest.getIndices()),
+                eq(manifest.getCustomMetadataMap()),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(manifest.getIndicesRouting()),
+                eq(true),
+                eq(manifest.getClusterStateCustomMap()),
+                eq(false),
+                eq(true)
+            );
+        mockService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true);
+        verify(mockService, times(0)).validateClusterStateFromChecksum(any(), any(), anyString(), anyString(), anyBoolean());
     }
 
-    public void testGetValidPreviousClusterUUIDWithInvalidMultipleChains() throws IOException {
-        Map<String, String> clusterUUIDsPointers = Map.of(
-            "cluster-uuid1",
-            ClusterState.UNKNOWN_UUID,
-            "cluster-uuid2",
-            "cluster-uuid1",
-            "cluster-uuid3",
-            ClusterState.UNKNOWN_UUID
-        );
-        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers);
-
+    public void testGetClusterStateForManifestWithChecksumValidationEnabledWithMismatch() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).build();
         remoteClusterStateService.start();
-        assertThrows(IllegalStateException.class, () -> remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster"));
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        ClusterState clusterStateWrong = ClusterState.builder(clusterState).routingTable(RoutingTable.EMPTY_ROUTING_TABLE).build();
+        doReturn(clusterStateWrong).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(manifest.getIndices()),
+                eq(manifest.getCustomMetadataMap()),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(manifest.getIndicesRouting()),
+                eq(true),
+                eq(manifest.getClusterStateCustomMap()),
+                eq(false),
+                eq(true)
+            );
+        expectThrows(
+            IllegalStateException.class,
+            () -> mockService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true)
+        );
+        verify(mockService, times(1)).validateClusterStateFromChecksum(
+            manifest,
+            clusterStateWrong,
+            ClusterName.DEFAULT.value(),
+            NODE_ID,
+            true
+        );
     }
 
-    public void testGetValidPreviousClusterUUIDWhenLastUUIDUncommitted() throws IOException {
-        Map<String, String> clusterUUIDsPointers = Map.of(
-            "cluster-uuid1",
-            ClusterState.UNKNOWN_UUID,
-            "cluster-uuid2",
-            "cluster-uuid1",
-            "cluster-uuid3",
-            "cluster-uuid2"
+    public void testGetClusterStateForManifestWithChecksumValidationDebugWithMismatch() throws IOException {
+        initializeWithChecksumEnabled(
+            randomFrom(
+                Arrays.asList(
+                    RemoteClusterStateService.RemoteClusterStateValidationMode.DEBUG,
+                    RemoteClusterStateService.RemoteClusterStateValidationMode.TRACE
+                )
+            )
         );
-        Map<String, Boolean> clusterUUIDCommitted = Map.of("cluster-uuid1", true, "cluster-uuid2", true, "cluster-uuid3", false);
-        mockObjectsForGettingPreviousClusterUUID(clusterUUIDsPointers, clusterUUIDCommitted);
-
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).build();
         remoteClusterStateService.start();
-        String previousClusterUUID = remoteClusterStateService.getLastKnownUUIDFromRemote("test-cluster");
-        assertThat(previousClusterUUID, equalTo("cluster-uuid2"));
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        ClusterState clusterStateWrong = ClusterState.builder(clusterState).routingTable(RoutingTable.EMPTY_ROUTING_TABLE).build();
+        doReturn(clusterStateWrong).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(manifest.getIndices()),
+                eq(manifest.getCustomMetadataMap()),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(manifest.getIndicesRouting()),
+                eq(true),
+                eq(manifest.getClusterStateCustomMap()),
+                eq(false),
+                eq(true)
+            );
+        mockService.getClusterStateForManifest(ClusterName.DEFAULT.value(), manifest, NODE_ID, true);
+        verify(mockService, times(1)).validateClusterStateFromChecksum(
+            manifest,
+            clusterStateWrong,
+            ClusterName.DEFAULT.value(),
+            NODE_ID,
+            true
+        );
     }
 
-    public void testDeleteStaleClusterUUIDs() throws IOException {
-        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
-        ClusterMetadataManifest clusterMetadataManifest = ClusterMetadataManifest.builder()
-            .indices(List.of())
-            .clusterTerm(1L)
-            .stateVersion(1L)
-            .stateUUID(randomAlphaOfLength(10))
-            .clusterUUID("cluster-uuid1")
-            .nodeId("nodeA")
-            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
-            .previousClusterUUID(ClusterState.UNKNOWN_UUID)
-            .committed(true)
-            .build();
+    public void testGetClusterStateUsingDiffWithChecksum() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
-        BlobPath blobPath = new BlobPath().add("random-path");
-        when((blobStoreRepository.basePath())).thenReturn(blobPath);
-        BlobContainer uuidContainerContainer = mock(BlobContainer.class);
-        BlobContainer manifest2Container = mock(BlobContainer.class);
-        BlobContainer manifest3Container = mock(BlobContainer.class);
-        when(blobStore.blobContainer(any())).then(invocation -> {
-            BlobPath blobPath1 = invocation.getArgument(0);
-            if (blobPath1.buildAsString().endsWith("cluster-state/")) {
-                return uuidContainerContainer;
-            } else if (blobPath1.buildAsString().contains("cluster-state/cluster-uuid2/")) {
-                return manifest2Container;
-            } else if (blobPath1.buildAsString().contains("cluster-state/cluster-uuid3/")) {
-                return manifest3Container;
-            } else {
-                throw new IllegalArgumentException("Unexpected blob path " + blobPath1);
-            }
-        });
-        Map<String, BlobContainer> blobMetadataMap = Map.of(
-            "cluster-uuid1",
-            mock(BlobContainer.class),
-            "cluster-uuid2",
-            mock(BlobContainer.class),
-            "cluster-uuid3",
-            mock(BlobContainer.class)
-        );
-        when(uuidContainerContainer.children()).thenReturn(blobMetadataMap);
-        when(
-            manifest2Container.listBlobsByPrefixInSortedOrder(
-                MANIFEST_FILE_PREFIX + DELIMITER,
-                Integer.MAX_VALUE,
-                BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
-            )
-        ).thenReturn(List.of(new PlainBlobMetadata("mainfest2", 1L)));
-        when(
-            manifest3Container.listBlobsByPrefixInSortedOrder(
-                MANIFEST_FILE_PREFIX + DELIMITER,
-                Integer.MAX_VALUE,
-                BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
-            )
-        ).thenReturn(List.of(new PlainBlobMetadata("mainfest3", 1L)));
         remoteClusterStateService.start();
-        remoteClusterStateService.deleteStaleClusterUUIDs(clusterState, clusterMetadataManifest);
-        try {
-            assertBusy(() -> {
-                verify(manifest2Container, times(1)).delete();
-                verify(manifest3Container, times(1)).delete();
-            });
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+
+        doReturn(clusterState).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(emptyList()),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                eq(emptyList()),
+                anyBoolean(),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean()
+            );
+        mockService.getClusterStateUsingDiff(manifest, clusterState, NODE_ID);
+
+        verify(mockService, times(1)).validateClusterStateFromChecksum(
+            eq(manifest),
+            any(ClusterState.class),
+            eq(ClusterName.DEFAULT.value()),
+            eq(NODE_ID),
+            eq(false)
+        );
     }
 
-    public void testRemoteStateStats() throws IOException {
-        final ClusterState clusterState = generateClusterStateWithOneIndex().nodes(nodesWithLocalNodeClusterManager()).build();
-        mockBlobStoreObjects();
-        remoteClusterStateService.start();
-        final ClusterMetadataManifest manifest = remoteClusterStateService.writeFullMetadata(clusterState, "prev-cluster-uuid");
-
-        assertTrue(remoteClusterStateService.getStats() != null);
-        assertEquals(1, remoteClusterStateService.getStats().getSuccessCount());
-        assertEquals(0, remoteClusterStateService.getStats().getCleanupAttemptFailedCount());
-        assertEquals(0, remoteClusterStateService.getStats().getFailedCount());
-    }
+    public void testGetClusterStateUsingDiffWithChecksumModeNone() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.NONE);
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
-    public void testRemoteStateCleanupFailureStats() throws IOException {
-        BlobContainer blobContainer = mock(BlobContainer.class);
-        doThrow(IOException.class).when(blobContainer).delete();
-        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
-        BlobPath blobPath = new BlobPath().add("random-path");
-        when((blobStoreRepository.basePath())).thenReturn(blobPath);
         remoteClusterStateService.start();
-        remoteClusterStateService.deleteStaleUUIDsClusterMetadata("cluster1", Arrays.asList("cluster-uuid1"));
-        try {
-            assertBusy(() -> {
-                // wait for stats to get updated
-                assertTrue(remoteClusterStateService.getStats() != null);
-                assertEquals(0, remoteClusterStateService.getStats().getSuccessCount());
-                assertEquals(1, remoteClusterStateService.getStats().getCleanupAttemptFailedCount());
-            });
-        } catch (Exception e) {
-            throw new RuntimeException(e);
-        }
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+
+        doReturn(clusterState).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(emptyList()),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                eq(emptyList()),
+                anyBoolean(),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean()
+            );
+        mockService.getClusterStateUsingDiff(manifest, clusterState, NODE_ID);
+
+        verify(mockService, times(0)).validateClusterStateFromChecksum(
+            eq(manifest),
+            any(ClusterState.class),
+            eq(ClusterName.DEFAULT.value()),
+            eq(NODE_ID),
+            eq(false)
+        );
     }
 
-    public void testFileNames() {
-        final Index index = new Index("test-index", "index-uuid");
-        final Settings idxSettings = Settings.builder()
-            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
-            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
-            .build();
-        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
-            .numberOfShards(1)
-            .numberOfReplicas(0)
-            .build();
-
-        String indexMetadataFileName = RemoteClusterStateService.indexMetadataFileName(indexMetadata);
-        String[] splittedIndexMetadataFileName = indexMetadataFileName.split(DELIMITER);
-        assertThat(indexMetadataFileName.split(DELIMITER).length, is(4));
-        assertThat(splittedIndexMetadataFileName[0], is(METADATA_FILE_PREFIX));
-        assertThat(splittedIndexMetadataFileName[1], is(RemoteStoreUtils.invertLong(indexMetadata.getVersion())));
-        assertThat(splittedIndexMetadataFileName[3], is(String.valueOf(INDEX_METADATA_CURRENT_CODEC_VERSION)));
-
-        int term = randomIntBetween(5, 10);
-        int version = randomIntBetween(5, 10);
-        String manifestFileName = RemoteClusterStateService.getManifestFileName(term, version, true);
-        assertThat(manifestFileName.split(DELIMITER).length, is(6));
-        String[] splittedName = manifestFileName.split(DELIMITER);
-        assertThat(splittedName[0], is(MANIFEST_FILE_PREFIX));
-        assertThat(splittedName[1], is(RemoteStoreUtils.invertLong(term)));
-        assertThat(splittedName[2], is(RemoteStoreUtils.invertLong(version)));
-        assertThat(splittedName[3], is("C"));
-        assertThat(splittedName[5], is(String.valueOf(MANIFEST_CURRENT_CODEC_VERSION)));
-
-        manifestFileName = RemoteClusterStateService.getManifestFileName(term, version, false);
-        splittedName = manifestFileName.split(DELIMITER);
-        assertThat(splittedName[3], is("P"));
-    }
-
-    public void testSingleConcurrentExecutionOfStaleManifestCleanup() throws Exception {
-        BlobContainer blobContainer = mock(BlobContainer.class);
-        BlobPath blobPath = new BlobPath().add("random-path");
-        when((blobStoreRepository.basePath())).thenReturn(blobPath);
-        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+    public void testGetClusterStateUsingDiffWithChecksumModeDebugMismatch() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.DEBUG);
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
-        CountDownLatch latch = new CountDownLatch(1);
-        AtomicInteger callCount = new AtomicInteger(0);
-        doAnswer(invocation -> {
-            callCount.incrementAndGet();
-            if (latch.await(5000, TimeUnit.SECONDS) == false) {
-                throw new Exception("Timed out waiting for delete task queuing to complete");
-            }
-            return null;
-        }).when(blobContainer)
-            .listBlobsByPrefixInSortedOrder(
-                any(String.class),
-                any(int.class),
-                any(BlobContainer.BlobNameSortOrder.class),
-                any(ActionListener.class)
+        remoteClusterStateService.start();
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        ClusterState clusterStateWrong = ClusterState.builder(clusterState).routingTable(RoutingTable.EMPTY_ROUTING_TABLE).build();
+        doReturn(clusterStateWrong).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(emptyList()),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                eq(emptyList()),
+                anyBoolean(),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean()
             );
+        mockService.getClusterStateUsingDiff(manifest, clusterState, NODE_ID);
+        verify(mockService, times(1)).validateClusterStateFromChecksum(
+            eq(manifest),
+            any(ClusterState.class),
+            eq(ClusterName.DEFAULT.value()),
+            eq(NODE_ID),
+            eq(false)
+        );
+    }
 
-        remoteClusterStateService.start();
-        remoteClusterStateService.deleteStaleClusterMetadata("cluster-name", "cluster-uuid", RETAINED_MANIFESTS);
-        remoteClusterStateService.deleteStaleClusterMetadata("cluster-name", "cluster-uuid", RETAINED_MANIFESTS);
+    public void testGetClusterStateUsingDiffWithChecksumModeTraceMismatch() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.TRACE);
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
-        latch.countDown();
-        assertBusy(() -> assertEquals(1, callCount.get()));
-    }
+        remoteClusterStateService.start();
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        ClusterState clusterStateWrong = ClusterState.builder(clusterState).routingTable(RoutingTable.EMPTY_ROUTING_TABLE).build();
+        doReturn(clusterStateWrong).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(emptyList()),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                eq(emptyList()),
+                anyBoolean(),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean()
+            );
+        doReturn(clusterState).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(manifest.getIndices()),
+                eq(manifest.getCustomMetadataMap()),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(manifest.getIndicesRouting()),
+                eq(true),
+                eq(manifest.getClusterStateCustomMap()),
+                eq(false),
+                eq(true)
+            );
 
-    public void testIndexMetadataUploadWaitTimeSetting() {
-        // verify default value
-        assertEquals(
-            RemoteClusterStateService.INDEX_METADATA_UPLOAD_TIMEOUT_DEFAULT,
-            remoteClusterStateService.getIndexMetadataUploadTimeout()
+        mockService.getClusterStateUsingDiff(manifest, clusterState, NODE_ID);
+        verify(mockService, times(1)).validateClusterStateFromChecksum(
+            eq(manifest),
+            any(ClusterState.class),
+            eq(ClusterName.DEFAULT.value()),
+            eq(NODE_ID),
+            eq(false)
         );
-
-        // verify update index metadata upload timeout
-        int indexMetadataUploadTimeout = randomIntBetween(1, 10);
-        Settings newSettings = Settings.builder()
-            .put("cluster.remote_store.state.index_metadata.upload_timeout", indexMetadataUploadTimeout + "s")
-            .build();
-        clusterSettings.applySettings(newSettings);
-        assertEquals(indexMetadataUploadTimeout, remoteClusterStateService.getIndexMetadataUploadTimeout().seconds());
     }
 
-    public void testMetadataManifestUploadWaitTimeSetting() {
-        // verify default value
-        assertEquals(
-            RemoteClusterStateService.METADATA_MANIFEST_UPLOAD_TIMEOUT_DEFAULT,
-            remoteClusterStateService.getMetadataManifestUploadTimeout()
-        );
+    public void testGetClusterStateUsingDiffWithChecksumMismatch() throws IOException {
+        initializeWithChecksumEnabled(RemoteClusterStateService.RemoteClusterStateValidationMode.FAILURE);
+        ClusterState clusterState = generateClusterStateWithAllAttributes().build();
+        ClusterMetadataManifest manifest = generateClusterMetadataManifestWithAllAttributes().checksum(
+            new ClusterStateChecksum(clusterState)
+        ).diffManifest(ClusterStateDiffManifest.builder().build()).build();
 
-        // verify update metadata manifest upload timeout
-        int metadataManifestUploadTimeout = randomIntBetween(1, 10);
-        Settings newSettings = Settings.builder()
-            .put("cluster.remote_store.state.metadata_manifest.upload_timeout", metadataManifestUploadTimeout + "s")
-            .build();
-        clusterSettings.applySettings(newSettings);
-        assertEquals(metadataManifestUploadTimeout, remoteClusterStateService.getMetadataManifestUploadTimeout().seconds());
-    }
+        remoteClusterStateService.start();
+        RemoteClusterStateService mockService = spy(remoteClusterStateService);
+        ClusterState clusterStateWrong = ClusterState.builder(clusterState).routingTable(RoutingTable.EMPTY_ROUTING_TABLE).build();
+        doReturn(clusterStateWrong).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(emptyList()),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                anyBoolean(),
+                eq(emptyList()),
+                anyBoolean(),
+                eq(emptyMap()),
+                anyBoolean(),
+                anyBoolean()
+            );
+        doReturn(clusterState).when(mockService)
+            .readClusterStateInParallel(
+                any(),
+                eq(manifest),
+                eq(manifest.getClusterUUID()),
+                eq(NODE_ID),
+                eq(manifest.getIndices()),
+                eq(manifest.getCustomMetadataMap()),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(true),
+                eq(manifest.getIndicesRouting()),
+                eq(true),
+                eq(manifest.getClusterStateCustomMap()),
+                eq(false),
+                eq(true)
+            );
 
-    public void testGlobalMetadataUploadWaitTimeSetting() {
-        // verify default value
-        assertEquals(
-            RemoteClusterStateService.GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT,
-            remoteClusterStateService.getGlobalMetadataUploadTimeout()
+        expectThrows(IllegalStateException.class, () -> mockService.getClusterStateUsingDiff(manifest, clusterState, NODE_ID));
+        verify(mockService, times(1)).validateClusterStateFromChecksum(
+            eq(manifest),
+            any(ClusterState.class),
+            eq(ClusterName.DEFAULT.value()),
+            eq(NODE_ID),
+            eq(false)
         );
-
-        // verify update global metadata upload timeout
-        int globalMetadataUploadTimeout = randomIntBetween(1, 10);
-        Settings newSettings = Settings.builder()
-            .put("cluster.remote_store.state.global_metadata.upload_timeout", globalMetadataUploadTimeout + "s")
-            .build();
-        clusterSettings.applySettings(newSettings);
-        assertEquals(globalMetadataUploadTimeout, remoteClusterStateService.getGlobalMetadataUploadTimeout().seconds());
     }
 
     private void mockObjectsForGettingPreviousClusterUUID(Map<String, String> clusterUUIDsPointers) throws IOException {
@@ -1252,15 +3666,19 @@ private void mockObjectsForGettingPreviousClusterUUID(
 
         mockBlobContainerForClusterUUIDs(uuidBlobContainer, clusterUUIDsPointers.keySet());
         List<UploadedIndexMetadata> uploadedIndexMetadataList1 = List.of(
-            new UploadedIndexMetadata("index1", "index-uuid1", "key1"),
-            new UploadedIndexMetadata("index2", "index-uuid2", "key2")
+            new UploadedIndexMetadata("index1", "index-uuid1", "key1__2"),
+            new UploadedIndexMetadata("index2", "index-uuid2", "key2__2")
         );
+        Map<String, UploadedMetadataAttribute> customMetadataMap = new HashMap<>();
         final ClusterMetadataManifest clusterManifest1 = generateClusterMetadataManifest(
             "cluster-uuid1",
             clusterUUIDsPointers.get("cluster-uuid1"),
             randomAlphaOfLength(10),
             uploadedIndexMetadataList1,
-            "test-metadata1",
+            customMetadataMap,
+            new UploadedMetadataAttribute(COORDINATION_METADATA, "key3"),
+            new UploadedMetadataAttribute(SETTING_METADATA, "key4"),
+            new UploadedMetadataAttribute(TEMPLATES_METADATA, "key5"),
             clusterUUIDCommitted.getOrDefault("cluster-uuid1", true)
         );
         Settings indexSettings = Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT).build();
@@ -1279,18 +3697,21 @@ private void mockObjectsForGettingPreviousClusterUUID(
             .build();
         Map<String, IndexMetadata> indexMetadataMap1 = Map.of("index-uuid1", indexMetadata1, "index-uuid2", indexMetadata2);
         mockBlobContainerForGlobalMetadata(blobContainer1, clusterManifest1, metadata1);
-        mockBlobContainer(blobContainer1, clusterManifest1, indexMetadataMap1, ClusterMetadataManifest.CODEC_V1);
+        mockBlobContainer(blobContainer1, clusterManifest1, indexMetadataMap1, MANIFEST_CURRENT_CODEC_VERSION);
 
         List<UploadedIndexMetadata> uploadedIndexMetadataList2 = List.of(
-            new UploadedIndexMetadata("index1", "index-uuid1", "key1"),
-            new UploadedIndexMetadata("index2", "index-uuid2", "key2")
+            new UploadedIndexMetadata("index1", "index-uuid1", "key1__2"),
+            new UploadedIndexMetadata("index2", "index-uuid2", "key2__2")
         );
         final ClusterMetadataManifest clusterManifest2 = generateClusterMetadataManifest(
             "cluster-uuid2",
             clusterUUIDsPointers.get("cluster-uuid2"),
             randomAlphaOfLength(10),
             uploadedIndexMetadataList2,
-            "test-metadata2",
+            customMetadataMap,
+            new UploadedMetadataAttribute(COORDINATION_METADATA, "key3"),
+            new UploadedMetadataAttribute(SETTING_METADATA, "key4"),
+            new UploadedMetadataAttribute(TEMPLATES_METADATA, "key5"),
             clusterUUIDCommitted.getOrDefault("cluster-uuid2", true)
         );
         IndexMetadata indexMetadata3 = IndexMetadata.builder("index1")
@@ -1308,7 +3729,7 @@ private void mockObjectsForGettingPreviousClusterUUID(
             .build();
         Map<String, IndexMetadata> indexMetadataMap2 = Map.of("index-uuid1", indexMetadata3, "index-uuid2", indexMetadata4);
         mockBlobContainerForGlobalMetadata(blobContainer2, clusterManifest2, metadata2);
-        mockBlobContainer(blobContainer2, clusterManifest2, indexMetadataMap2, ClusterMetadataManifest.CODEC_V1);
+        mockBlobContainer(blobContainer2, clusterManifest2, indexMetadataMap2, MANIFEST_CURRENT_CODEC_VERSION);
 
         // differGlobalMetadata controls which one of IndexMetadata or Metadata object would be different
         // when comparing cluster-uuid3 and cluster-uuid1 state.
@@ -1318,7 +3739,7 @@ private void mockObjectsForGettingPreviousClusterUUID(
         // IndexMetadata and Metadata when deciding if the remote state b/w two different cluster uuids is same.
         List<UploadedIndexMetadata> uploadedIndexMetadataList3 = differGlobalMetadata
             ? new ArrayList<>(uploadedIndexMetadataList1)
-            : List.of(new UploadedIndexMetadata("index1", "index-uuid1", "key1"));
+            : List.of(new UploadedIndexMetadata("index1", "index-uuid1", "key1__2"));
         IndexMetadata indexMetadata5 = IndexMetadata.builder("index1")
             .settings(indexSettings)
             .numberOfShards(1)
@@ -1330,17 +3751,19 @@ private void mockObjectsForGettingPreviousClusterUUID(
         Metadata metadata3 = Metadata.builder()
             .persistentSettings(Settings.builder().put(Metadata.SETTING_READ_ONLY_SETTING.getKey(), !differGlobalMetadata).build())
             .build();
-
         final ClusterMetadataManifest clusterManifest3 = generateClusterMetadataManifest(
             "cluster-uuid3",
             clusterUUIDsPointers.get("cluster-uuid3"),
             randomAlphaOfLength(10),
             uploadedIndexMetadataList3,
-            "test-metadata3",
+            customMetadataMap,
+            new UploadedMetadataAttribute(COORDINATION_METADATA, "key3"),
+            new UploadedMetadataAttribute(SETTING_METADATA, "key4"),
+            new UploadedMetadataAttribute(TEMPLATES_METADATA, "key5"),
             clusterUUIDCommitted.getOrDefault("cluster-uuid3", true)
         );
         mockBlobContainerForGlobalMetadata(blobContainer3, clusterManifest3, metadata3);
-        mockBlobContainer(blobContainer3, clusterManifest3, indexMetadataMap3, ClusterMetadataManifest.CODEC_V1);
+        mockBlobContainer(blobContainer3, clusterManifest3, indexMetadataMap3, MANIFEST_CURRENT_CODEC_VERSION);
 
         ArrayList<BlobContainer> mockBlobContainerOrderedList = new ArrayList<>(
             List.of(blobContainer1, blobContainer1, blobContainer3, blobContainer3, blobContainer2, blobContainer2)
@@ -1348,19 +3771,41 @@ private void mockObjectsForGettingPreviousClusterUUID(
 
         if (differGlobalMetadata) {
             mockBlobContainerOrderedList.addAll(
-                List.of(blobContainer3, blobContainer1, blobContainer3, blobContainer1, blobContainer1, blobContainer3)
+                List.of(
+                    blobContainer3,
+                    blobContainer1,
+                    blobContainer3,
+                    blobContainer1,
+                    blobContainer1,
+                    blobContainer1,
+                    blobContainer1,
+                    blobContainer3,
+                    blobContainer3,
+                    blobContainer3
+                )
             );
         }
         mockBlobContainerOrderedList.addAll(
-            List.of(blobContainer2, blobContainer1, blobContainer2, blobContainer1, blobContainer1, blobContainer2)
+            List.of(
+                blobContainer2,
+                blobContainer1,
+                blobContainer2,
+                blobContainer1,
+                blobContainer1,
+                blobContainer1,
+                blobContainer1,
+                blobContainer2,
+                blobContainer2,
+                blobContainer2
+            )
         );
         BlobContainer[] mockBlobContainerOrderedArray = new BlobContainer[mockBlobContainerOrderedList.size()];
         mockBlobContainerOrderedList.toArray(mockBlobContainerOrderedArray);
         when(blobStore.blobContainer(ArgumentMatchers.any())).thenReturn(uuidBlobContainer, mockBlobContainerOrderedArray);
-        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        when(blobStoreRepository.getCompressor()).thenReturn(compressor);
     }
 
-    private ClusterMetadataManifest generateClusterMetadataManifest(
+    private ClusterMetadataManifest generateV1ClusterMetadataManifest(
         String clusterUUID,
         String previousClusterUUID,
         String stateUUID,
@@ -1380,7 +3825,37 @@ private ClusterMetadataManifest generateClusterMetadataManifest(
             .committed(true)
             .clusterUUIDCommitted(isUUIDCommitted)
             .globalMetadataFileName(globalMetadataFileName)
-            .codecVersion(ClusterMetadataManifest.CODEC_V1)
+            .codecVersion(CODEC_V1)
+            .build();
+    }
+
+    private ClusterMetadataManifest generateClusterMetadataManifest(
+        String clusterUUID,
+        String previousClusterUUID,
+        String stateUUID,
+        List<UploadedIndexMetadata> uploadedIndexMetadata,
+        Map<String, UploadedMetadataAttribute> customMetadataMap,
+        UploadedMetadataAttribute coordinationMetadata,
+        UploadedMetadataAttribute settingsMetadata,
+        UploadedMetadataAttribute templatesMetadata,
+        Boolean isUUIDCommitted
+    ) {
+        return ClusterMetadataManifest.builder()
+            .indices(uploadedIndexMetadata)
+            .clusterTerm(1L)
+            .stateVersion(1L)
+            .stateUUID(stateUUID)
+            .clusterUUID(clusterUUID)
+            .nodeId("nodeA")
+            .opensearchVersion(VersionUtils.randomOpenSearchVersion(random()))
+            .previousClusterUUID(previousClusterUUID)
+            .committed(true)
+            .clusterUUIDCommitted(isUUIDCommitted)
+            .coordinationMetadata(coordinationMetadata)
+            .settingMetadata(settingsMetadata)
+            .templatesMetadata(templatesMetadata)
+            .customMetadataMap(customMetadataMap)
+            .codecVersion(MANIFEST_CURRENT_CODEC_VERSION)
             .build();
     }
 
@@ -1392,6 +3867,17 @@ private BlobContainer mockBlobStoreObjects(Class<? extends BlobContainer> blobCo
         final BlobPath blobPath = mock(BlobPath.class);
         when((blobStoreRepository.basePath())).thenReturn(blobPath);
         when(blobPath.add(anyString())).thenReturn(blobPath);
+        when(blobPath.iterator()).thenReturn(new Iterator<String>() {
+            @Override
+            public boolean hasNext() {
+                return false;
+            }
+
+            @Override
+            public String next() {
+                return null;
+            }
+        });
         when(blobPath.buildAsString()).thenReturn("/blob/path/");
         final BlobContainer blobContainer = mock(blobContainerClazz);
         when(blobContainer.path()).thenReturn(blobPath);
@@ -1422,14 +3908,14 @@ private void mockBlobContainer(
         Map<String, IndexMetadata> indexMetadataMap,
         int codecVersion
     ) throws IOException {
-        String manifestFileName = codecVersion >= ClusterMetadataManifest.CODEC_V1
-            ? "manifest__manifestFileName__abcd__abcd__abcd__1"
+        String manifestFileName = codecVersion >= CODEC_V1
+            ? "manifest__manifestFileName__abcd__abcd__abcd__" + codecVersion
             : "manifestFileName";
         BlobMetadata blobMetadata = new PlainBlobMetadata(manifestFileName, 1);
         when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
             .thenReturn(Arrays.asList(blobMetadata));
 
-        BytesReference bytes = RemoteClusterStateService.CLUSTER_METADATA_MANIFEST_FORMAT.serialize(
+        BytesReference bytes = RemoteClusterMetadataManifest.CLUSTER_METADATA_MANIFEST_FORMAT.serialize(
             clusterMetadataManifest,
             manifestFileName,
             blobStoreRepository.getCompressor(),
@@ -1444,8 +3930,8 @@ private void mockBlobContainer(
                     return;
                 }
                 String fileName = uploadedIndexMetadata.getUploadedFilename();
-                when(blobContainer.readBlob(fileName + ".dat")).thenAnswer((invocationOnMock) -> {
-                    BytesReference bytesIndexMetadata = RemoteClusterStateService.INDEX_METADATA_FORMAT.serialize(
+                when(blobContainer.readBlob(getFormattedIndexFileName(fileName))).thenAnswer((invocationOnMock) -> {
+                    BytesReference bytesIndexMetadata = INDEX_METADATA_FORMAT.serialize(
                         indexMetadata,
                         fileName,
                         blobStoreRepository.getCompressor(),
@@ -1464,39 +3950,93 @@ private void mockBlobContainerForGlobalMetadata(
         ClusterMetadataManifest clusterMetadataManifest,
         Metadata metadata
     ) throws IOException {
-        String mockManifestFileName = "manifest__1__2__C__456__1";
+        int codecVersion = clusterMetadataManifest.getCodecVersion();
+        String mockManifestFileName = "manifest__1__2__C__456__" + codecVersion;
         BlobMetadata blobMetadata = new PlainBlobMetadata(mockManifestFileName, 1);
-        when(
-            blobContainer.listBlobsByPrefixInSortedOrder(
-                "manifest" + RemoteClusterStateService.DELIMITER,
-                1,
-                BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC
-            )
-        ).thenReturn(Arrays.asList(blobMetadata));
+        when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
+            .thenReturn(Arrays.asList(blobMetadata));
 
-        BytesReference bytes = RemoteClusterStateService.CLUSTER_METADATA_MANIFEST_FORMAT.serialize(
+        BytesReference bytes = RemoteClusterMetadataManifest.CLUSTER_METADATA_MANIFEST_FORMAT.serialize(
             clusterMetadataManifest,
             mockManifestFileName,
             blobStoreRepository.getCompressor(),
             FORMAT_PARAMS
         );
         when(blobContainer.readBlob(mockManifestFileName)).thenReturn(new ByteArrayInputStream(bytes.streamInput().readAllBytes()));
+        if (codecVersion >= CODEC_V2) {
+            String coordinationFileName = getFileNameFromPath(clusterMetadataManifest.getCoordinationMetadata().getUploadedFilename());
+            when(blobContainer.readBlob(COORDINATION_METADATA_FORMAT.blobName(coordinationFileName))).thenAnswer((invocationOnMock) -> {
+                BytesReference bytesReference = COORDINATION_METADATA_FORMAT.serialize(
+                    metadata.coordinationMetadata(),
+                    coordinationFileName,
+                    blobStoreRepository.getCompressor(),
+                    FORMAT_PARAMS
+                );
+                return new ByteArrayInputStream(bytesReference.streamInput().readAllBytes());
+            });
 
-        String[] splitPath = clusterMetadataManifest.getGlobalMetadataFileName().split("/");
-        when(blobContainer.readBlob(RemoteClusterStateService.GLOBAL_METADATA_FORMAT.blobName(splitPath[splitPath.length - 1]))).thenAnswer(
-            (invocationOnMock) -> {
-                BytesReference bytesGlobalMetadata = RemoteClusterStateService.GLOBAL_METADATA_FORMAT.serialize(
-                    metadata,
-                    "global-metadata-file",
+            String settingsFileName = getFileNameFromPath(clusterMetadataManifest.getSettingsMetadata().getUploadedFilename());
+            when(blobContainer.readBlob(SETTINGS_METADATA_FORMAT.blobName(settingsFileName))).thenAnswer((invocationOnMock) -> {
+                BytesReference bytesReference = SETTINGS_METADATA_FORMAT.serialize(
+                    metadata.persistentSettings(),
+                    settingsFileName,
                     blobStoreRepository.getCompressor(),
                     FORMAT_PARAMS
                 );
-                return new ByteArrayInputStream(bytesGlobalMetadata.streamInput().readAllBytes());
+                return new ByteArrayInputStream(bytesReference.streamInput().readAllBytes());
+            });
+
+            String templatesFileName = getFileNameFromPath(clusterMetadataManifest.getTemplatesMetadata().getUploadedFilename());
+            when(blobContainer.readBlob(TEMPLATES_METADATA_FORMAT.blobName(templatesFileName))).thenAnswer((invocationOnMock) -> {
+                BytesReference bytesReference = TEMPLATES_METADATA_FORMAT.serialize(
+                    metadata.templatesMetadata(),
+                    templatesFileName,
+                    blobStoreRepository.getCompressor(),
+                    FORMAT_PARAMS
+                );
+                return new ByteArrayInputStream(bytesReference.streamInput().readAllBytes());
+            });
+
+            Map<String, String> customFileMap = clusterMetadataManifest.getCustomMetadataMap()
+                .entrySet()
+                .stream()
+                .collect(Collectors.toMap(Map.Entry::getKey, entry -> getFileNameFromPath(entry.getValue().getUploadedFilename())));
+
+            ChecksumWritableBlobStoreFormat<Metadata.Custom> customMetadataFormat = new ChecksumWritableBlobStoreFormat<>("custom", null);
+            for (Map.Entry<String, String> entry : customFileMap.entrySet()) {
+                String custom = entry.getKey();
+                String fileName = entry.getValue();
+                when(blobContainer.readBlob(fileName)).thenAnswer((invocation) -> {
+                    BytesReference bytesReference = customMetadataFormat.serialize(
+                        metadata.custom(custom),
+                        fileName,
+                        blobStoreRepository.getCompressor()
+                    );
+                    return new ByteArrayInputStream(bytesReference.streamInput().readAllBytes());
+                });
             }
-        );
+        } else if (codecVersion == CODEC_V1) {
+            String[] splitPath = clusterMetadataManifest.getGlobalMetadataFileName().split("/");
+            when(blobContainer.readBlob(GLOBAL_METADATA_FORMAT.blobName(splitPath[splitPath.length - 1]))).thenAnswer(
+                (invocationOnMock) -> {
+                    BytesReference bytesGlobalMetadata = GLOBAL_METADATA_FORMAT.serialize(
+                        metadata,
+                        "global-metadata-file",
+                        blobStoreRepository.getCompressor(),
+                        FORMAT_PARAMS
+                    );
+                    return new ByteArrayInputStream(bytesGlobalMetadata.streamInput().readAllBytes());
+                }
+            );
+        }
+    }
+
+    private String getFileNameFromPath(String filePath) {
+        String[] splitPath = filePath.split("/");
+        return splitPath[splitPath.length - 1];
     }
 
-    private static ClusterState.Builder generateClusterStateWithGlobalMetadata() {
+    static ClusterState.Builder generateClusterStateWithGlobalMetadata() {
         final Settings clusterSettings = Settings.builder().put("cluster.blocks.read_only", true).build();
         final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
 
@@ -1512,7 +4052,7 @@ private static ClusterState.Builder generateClusterStateWithGlobalMetadata() {
             );
     }
 
-    private static ClusterState.Builder generateClusterStateWithOneIndex() {
+    static ClusterState.Builder generateClusterStateWithOneIndex() {
         final Index index = new Index("test-index", "index-uuid");
         final Settings idxSettings = Settings.builder()
             .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
@@ -1523,6 +4063,58 @@ private static ClusterState.Builder generateClusterStateWithOneIndex() {
             .numberOfReplicas(0)
             .build();
         final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final Settings settings = Settings.builder().put("mock-settings", true).build();
+        final TemplatesMetadata templatesMetadata = TemplatesMetadata.builder()
+            .put(IndexTemplateMetadata.builder("template1").settings(idxSettings).patterns(List.of("test*")).build())
+            .build();
+        final CustomMetadata1 customMetadata1 = new CustomMetadata1("custom-metadata-1");
+        return ClusterState.builder(ClusterName.DEFAULT)
+            .version(1L)
+            .stateUUID("state-uuid")
+            .metadata(
+                Metadata.builder()
+                    .version(randomNonNegativeLong())
+                    .put(indexMetadata, true)
+                    .clusterUUID("cluster-uuid")
+                    .coordinationMetadata(coordinationMetadata)
+                    .persistentSettings(settings)
+                    .templates(templatesMetadata)
+                    .hashesOfConsistentSettings(Map.of("key1", "value1", "key2", "value2"))
+                    .putCustom(customMetadata1.getWriteableName(), customMetadata1)
+                    .build()
+            )
+            .routingTable(RoutingTable.builder().addAsNew(indexMetadata).version(1L).build());
+    }
+
+    public static ClusterState.Builder generateClusterStateWithOneIndex(
+        String indexName,
+        int primaryShards,
+        int replicaShards,
+        boolean addAsNew
+    ) {
+
+        final Index index = new Index(indexName, "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(primaryShards)
+            .numberOfReplicas(replicaShards)
+            .build();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final Settings settings = Settings.builder().put("mock-settings", true).build();
+        final TemplatesMetadata templatesMetadata = TemplatesMetadata.builder()
+            .put(IndexTemplateMetadata.builder("template1").settings(idxSettings).patterns(List.of("test*")).build())
+            .build();
+        final CustomMetadata1 customMetadata1 = new CustomMetadata1("custom-metadata-1");
+
+        RoutingTable.Builder routingTableBuilder = RoutingTable.builder();
+        if (addAsNew) {
+            routingTableBuilder.addAsNew(indexMetadata);
+        } else {
+            routingTableBuilder.addAsRecovery(indexMetadata);
+        }
 
         return ClusterState.builder(ClusterName.DEFAULT)
             .version(1L)
@@ -1533,12 +4125,117 @@ private static ClusterState.Builder generateClusterStateWithOneIndex() {
                     .put(indexMetadata, true)
                     .clusterUUID("cluster-uuid")
                     .coordinationMetadata(coordinationMetadata)
+                    .persistentSettings(settings)
+                    .templates(templatesMetadata)
+                    .hashesOfConsistentSettings(Map.of("key1", "value1", "key2", "value2"))
+                    .putCustom(customMetadata1.getWriteableName(), customMetadata1)
                     .build()
-            );
+            )
+            .routingTable(routingTableBuilder.version(1L).build());
+    }
+
+    static ClusterState.Builder generateClusterStateWithAllAttributes() {
+        final Index index = new Index("test-index", "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+        final IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+        final CoordinationMetadata coordinationMetadata = CoordinationMetadata.builder().term(1L).build();
+        final Settings settings = Settings.builder().put("mock-settings", true).build();
+        final Settings transientSettings = Settings.builder().put("mock-transient-settings", true).build();
+        final DiffableStringMap hashesOfConsistentSettings = new DiffableStringMap(emptyMap());
+        final TemplatesMetadata templatesMetadata = TemplatesMetadata.builder()
+            .put(IndexTemplateMetadata.builder("template-1").patterns(List.of("test-index* ")).build())
+            .build();
+        final CustomMetadata1 customMetadata1 = new CustomMetadata1("custom-metadata-1");
+        final CustomMetadata2 customMetadata2 = new CustomMetadata2("custom-metadata-2");
+        final DiscoveryNodes nodes = nodesWithLocalNodeClusterManager();
+        final ClusterBlocks clusterBlocks = randomClusterBlocks();
+        final TestClusterStateCustom1 custom1 = new RemoteClusterStateTestUtils.TestClusterStateCustom1("custom-1");
+        final TestClusterStateCustom2 custom2 = new RemoteClusterStateTestUtils.TestClusterStateCustom2("custom-2");
+        return ClusterState.builder(ClusterName.DEFAULT)
+            .version(1L)
+            .stateUUID("state-uuid")
+            .metadata(
+                Metadata.builder()
+                    .version(randomNonNegativeLong())
+                    .put(indexMetadata, true)
+                    .clusterUUID("cluster-uuid")
+                    .coordinationMetadata(coordinationMetadata)
+                    .persistentSettings(settings)
+                    .transientSettings(transientSettings)
+                    .hashesOfConsistentSettings(hashesOfConsistentSettings)
+                    .templates(templatesMetadata)
+                    .putCustom(customMetadata1.getWriteableName(), customMetadata1)
+                    .putCustom(customMetadata2.getWriteableName(), customMetadata2)
+                    .build()
+            )
+            .routingTable(RoutingTable.builder().addAsNew(indexMetadata).version(1L).build())
+            .nodes(nodes)
+            .blocks(clusterBlocks)
+            .putCustom(custom1.getWriteableName(), custom1)
+            .putCustom(custom2.getWriteableName(), custom2);
     }
 
-    private static DiscoveryNodes nodesWithLocalNodeClusterManager() {
-        return DiscoveryNodes.builder().clusterManagerNodeId("cluster-manager-id").localNodeId("cluster-manager-id").build();
+    static ClusterMetadataManifest.Builder generateClusterMetadataManifestWithAllAttributes() {
+        return ClusterMetadataManifest.builder()
+            .codecVersion(CODEC_V2)
+            .clusterUUID("cluster-uuid")
+            .stateVersion(1L)
+            .stateUUID("state-uuid")
+            .indices(List.of(new UploadedIndexMetadata("test-index", "test-index-uuid", "test-index-file__2")))
+            .customMetadataMap(
+                Map.of(
+                    "custom_md_1",
+                    new UploadedMetadataAttribute("custom_md_1", "test-custom1-file__1"),
+                    "custom_md_2",
+                    new UploadedMetadataAttribute("custom_md_2", "test-custom2-file__1")
+                )
+            )
+            .coordinationMetadata(new UploadedMetadataAttribute(COORDINATION_METADATA, COORDINATION_METADATA_FILENAME))
+            .settingMetadata(new UploadedMetadataAttribute(SETTING_METADATA, PERSISTENT_SETTINGS_FILENAME))
+            .transientSettingsMetadata(new UploadedMetadataAttribute(TRANSIENT_SETTING_METADATA, TRANSIENT_SETTINGS_FILENAME))
+            .templatesMetadata(new UploadedMetadataAttribute(TEMPLATES_METADATA, TEMPLATES_METADATA_FILENAME))
+            .hashesOfConsistentSettings(
+                new UploadedMetadataAttribute(HASHES_OF_CONSISTENT_SETTINGS, HASHES_OF_CONSISTENT_SETTINGS_FILENAME)
+            )
+            .discoveryNodesMetadata(new UploadedMetadataAttribute(DISCOVERY_NODES, DISCOVERY_NODES_FILENAME))
+            .clusterBlocksMetadata(new UploadedMetadataAttribute(CLUSTER_BLOCKS, CLUSTER_BLOCKS_FILENAME))
+            .clusterStateCustomMetadataMap(
+                Map.of(
+                    "custom_1",
+                    new UploadedMetadataAttribute("custom_1", "test-cluster-state-custom1-file__1"),
+                    "custom_2",
+                    new UploadedMetadataAttribute("custom_2", "test-cluster-state-custom2-file__1")
+                )
+            )
+            .routingTableVersion(1L);
+    }
+
+    public static DiscoveryNodes nodesWithLocalNodeClusterManager() {
+        final DiscoveryNode localNode = new DiscoveryNode("cluster-manager-id", buildNewFakeTransportAddress(), Version.CURRENT);
+        return DiscoveryNodes.builder().clusterManagerNodeId("cluster-manager-id").localNodeId("cluster-manager-id").add(localNode).build();
     }
 
+    private class BlobNameMatcher implements ArgumentMatcher<AbstractClusterMetadataWriteableBlobEntity> {
+        private final String expectedBlobName;
+
+        BlobNameMatcher(String expectedBlobName) {
+            this.expectedBlobName = expectedBlobName;
+        }
+
+        @Override
+        public boolean matches(AbstractClusterMetadataWriteableBlobEntity argument) {
+            return argument != null && expectedBlobName.equals(argument.getFullBlobName());
+        }
+
+        @Override
+        public String toString() {
+            return "BlobNameMatcher[Expected blobName: " + expectedBlobName + "]";
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateTestUtils.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateTestUtils.java
new file mode 100644
index 0000000000000..b17ffcbaac344
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteClusterStateTestUtils.java
@@ -0,0 +1,227 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.test.TestClusterStateCustom;
+import org.opensearch.test.TestCustomMetadata;
+
+import java.io.IOException;
+import java.util.EnumSet;
+
+public class RemoteClusterStateTestUtils {
+    public static class CustomMetadata1 extends TestCustomMetadata {
+        public static final String TYPE = "custom_md_1";
+
+        public CustomMetadata1(String data) {
+            super(data);
+        }
+
+        public CustomMetadata1(StreamInput in) throws IOException {
+            super(in.readString());
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+
+        @Override
+        public Version getMinimalSupportedVersion() {
+            return Version.CURRENT;
+        }
+
+        @Override
+        public EnumSet<Metadata.XContentContext> context() {
+            return EnumSet.of(Metadata.XContentContext.GATEWAY);
+        }
+    }
+
+    public static class CustomMetadata2 extends TestCustomMetadata {
+        public static final String TYPE = "custom_md_2";
+
+        public CustomMetadata2(String data) {
+            super(data);
+        }
+
+        public CustomMetadata2(StreamInput in) throws IOException {
+            super(in.readString());
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+
+        @Override
+        public Version getMinimalSupportedVersion() {
+            return Version.CURRENT;
+        }
+
+        @Override
+        public EnumSet<Metadata.XContentContext> context() {
+            return EnumSet.of(Metadata.XContentContext.GATEWAY);
+        }
+    }
+
+    public static class CustomMetadata3 extends TestCustomMetadata {
+        public static final String TYPE = "custom_md_3";
+
+        public CustomMetadata3(String data) {
+            super(data);
+        }
+
+        public CustomMetadata3(StreamInput in) throws IOException {
+            super(in.readString());
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+
+        @Override
+        public Version getMinimalSupportedVersion() {
+            return Version.CURRENT;
+        }
+
+        @Override
+        public EnumSet<Metadata.XContentContext> context() {
+            return EnumSet.of(Metadata.XContentContext.GATEWAY);
+        }
+    }
+
+    public static class CustomMetadata4 extends TestCustomMetadata {
+        public static final String TYPE = "custom_md_4";
+
+        public CustomMetadata4(String data) {
+            super(data);
+        }
+
+        public CustomMetadata4(StreamInput in) throws IOException {
+            super(in.readString());
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+
+        @Override
+        public Version getMinimalSupportedVersion() {
+            return Version.CURRENT;
+        }
+
+        @Override
+        public EnumSet<Metadata.XContentContext> context() {
+            return EnumSet.of(Metadata.XContentContext.GATEWAY);
+        }
+    }
+
+    public static class CustomMetadata5 extends TestCustomMetadata {
+        public static final String TYPE = "custom_md_5";
+
+        public CustomMetadata5(String data) {
+            super(data);
+        }
+
+        public CustomMetadata5(StreamInput in) throws IOException {
+            super(in.readString());
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+
+        @Override
+        public Version getMinimalSupportedVersion() {
+            return Version.CURRENT;
+        }
+
+        @Override
+        public EnumSet<Metadata.XContentContext> context() {
+            return EnumSet.of(Metadata.XContentContext.API);
+        }
+    }
+
+    public static class TestClusterStateCustom1 extends TestClusterStateCustom {
+
+        public static final String TYPE = "custom_1";
+
+        public TestClusterStateCustom1(String value) {
+            super(value);
+        }
+
+        public TestClusterStateCustom1(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+    }
+
+    public static class TestClusterStateCustom2 extends TestClusterStateCustom {
+
+        public static final String TYPE = "custom_2";
+
+        public TestClusterStateCustom2(String value) {
+            super(value);
+        }
+
+        public TestClusterStateCustom2(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+    }
+
+    public static class TestClusterStateCustom3 extends TestClusterStateCustom {
+
+        public static final String TYPE = "custom_3";
+
+        public TestClusterStateCustom3(String value) {
+            super(value);
+        }
+
+        public TestClusterStateCustom3(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+    }
+
+    public static class TestClusterStateCustom4 extends TestClusterStateCustom {
+
+        public static final String TYPE = "custom_4";
+
+        public TestClusterStateCustom4(String value) {
+            super(value);
+        }
+
+        public TestClusterStateCustom4(StreamInput in) throws IOException {
+            super(in);
+        }
+
+        @Override
+        public String getWriteableName() {
+            return TYPE;
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManagerTests.java
new file mode 100644
index 0000000000000..a2da1e8b0fdb2
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteGlobalMetadataManagerTests.java
@@ -0,0 +1,698 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiffableUtils;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.metadata.DiffableStringMap;
+import org.opensearch.cluster.metadata.IndexGraveyard;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.TestCapturingListener;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.model.RemoteCoordinationMetadata;
+import org.opensearch.gateway.remote.model.RemoteCustomMetadata;
+import org.opensearch.gateway.remote.model.RemoteGlobalMetadata;
+import org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings;
+import org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.gateway.remote.model.RemoteTemplatesMetadata;
+import org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.cluster.metadata.Metadata.isGlobalStateEquals;
+import static org.opensearch.common.blobstore.stream.write.WritePriority.URGENT;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.CustomMetadata1;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.CustomMetadata2;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.CustomMetadata3;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.CustomMetadata4;
+import static org.opensearch.gateway.remote.RemoteClusterStateTestUtils.CustomMetadata5;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CUSTOM_DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.FORMAT_PARAMS;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.PATH_DELIMITER;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadata.COORDINATION_METADATA_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteCoordinationMetadataTests.getCoordinationMetadata;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadataTests.getCustomMetadata;
+import static org.opensearch.gateway.remote.model.RemoteGlobalMetadata.GLOBAL_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteGlobalMetadata.GLOBAL_METADATA_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteGlobalMetadataTests.getGlobalMetadata;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettingsTests.getHashesOfConsistentSettings;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadata.SETTING_METADATA;
+import static org.opensearch.gateway.remote.model.RemotePersistentSettingsMetadataTests.getSettings;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadata.TEMPLATES_METADATA_FORMAT;
+import static org.opensearch.gateway.remote.model.RemoteTemplatesMetadataTests.getTemplatesMetadata;
+import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyIterable;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteGlobalMetadataManagerTests extends OpenSearchTestCase {
+    private RemoteGlobalMetadataManager remoteGlobalMetadataManager;
+    private ClusterSettings clusterSettings;
+    private BlobStoreRepository blobStoreRepository;
+    private BlobStoreTransferService blobStoreTransferService;
+    private Compressor compressor;
+    private NamedXContentRegistry xContentRegistry;
+    private NamedWriteableRegistry namedWriteableRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+    private final long METADATA_VERSION = 7331L;
+    private final String CLUSTER_NAME = "test-cluster";
+    private final String CLUSTER_UUID = "test-cluster-uuid";
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        blobStoreRepository = mock(BlobStoreRepository.class);
+        blobStoreTransferService = mock(BlobStoreTransferService.class);
+        compressor = new NoneCompressor();
+        xContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+        namedWriteableRegistry = writableRegistry();
+        BlobPath blobPath = new BlobPath();
+        when(blobStoreRepository.getCompressor()).thenReturn(compressor);
+        when(blobStoreRepository.getNamedXContentRegistry()).thenReturn(xContentRegistry);
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        remoteGlobalMetadataManager = new RemoteGlobalMetadataManager(
+            clusterSettings,
+            CLUSTER_NAME,
+            blobStoreRepository,
+            blobStoreTransferService,
+            writableRegistry(),
+            threadPool
+        );
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testGlobalMetadataUploadWaitTimeSetting() {
+        // verify default value
+        assertEquals(
+            RemoteGlobalMetadataManager.GLOBAL_METADATA_UPLOAD_TIMEOUT_DEFAULT,
+            remoteGlobalMetadataManager.getGlobalMetadataUploadTimeout()
+        );
+
+        // verify update global metadata upload timeout
+        int globalMetadataUploadTimeout = randomIntBetween(1, 10);
+        Settings newSettings = Settings.builder()
+            .put("cluster.remote_store.state.global_metadata.upload_timeout", globalMetadataUploadTimeout + "s")
+            .build();
+        clusterSettings.applySettings(newSettings);
+        assertEquals(globalMetadataUploadTimeout, remoteGlobalMetadataManager.getGlobalMetadataUploadTimeout().seconds());
+    }
+
+    public void testGetAsyncReadRunnable_CoordinationMetadata() throws Exception {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        String fileName = randomAlphaOfLength(10);
+        RemoteCoordinationMetadata coordinationMetadataForDownload = new RemoteCoordinationMetadata(
+            fileName,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            COORDINATION_METADATA_FORMAT.serialize(coordinationMetadata, fileName, compressor, FORMAT_PARAMS).streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteGlobalMetadataManager.readAsync(
+            COORDINATION_METADATA,
+            coordinationMetadataForDownload,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(coordinationMetadata, listener.getResult().getObj());
+        assertEquals(COORDINATION_METADATA, listener.getResult().getComponent());
+        assertEquals(COORDINATION_METADATA, listener.getResult().getComponentName());
+    }
+
+    public void testGetAsyncWriteRunnable_CoordinationMetadata() throws Exception {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteCoordinationMetadata = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteGlobalMetadataManager.writeAsync(
+            COORDINATION_METADATA,
+            remoteCoordinationMetadata,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+        assertEquals(COORDINATION_METADATA, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(RemoteClusterStateUtils.encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(GLOBAL_METADATA_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(COORDINATION_METADATA, splitFileName[0]);
+        assertEquals(RemoteStoreUtils.invertLong(METADATA_VERSION), splitFileName[1]);
+        assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_PersistentSettings() throws Exception {
+        Settings settingsMetadata = getSettings();
+        String fileName = randomAlphaOfLength(10);
+        RemotePersistentSettingsMetadata persistentSettings = new RemotePersistentSettingsMetadata(
+            fileName,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            RemotePersistentSettingsMetadata.SETTINGS_METADATA_FORMAT.serialize(settingsMetadata, fileName, compressor, FORMAT_PARAMS)
+                .streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteGlobalMetadataManager.readAsync(SETTING_METADATA, persistentSettings, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(settingsMetadata, listener.getResult().getObj());
+        assertEquals(SETTING_METADATA, listener.getResult().getComponent());
+        assertEquals(SETTING_METADATA, listener.getResult().getComponentName());
+    }
+
+    public void testGetAsyncWriteRunnable_PersistentSettings() throws Exception {
+        Settings settingsMetadata = getSettings();
+        RemotePersistentSettingsMetadata persistentSettings = new RemotePersistentSettingsMetadata(
+            settingsMetadata,
+            METADATA_VERSION,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.writeAsync(SETTING_METADATA, persistentSettings, new LatchedActionListener<>(listener, latch));
+
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+        assertEquals(SETTING_METADATA, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(RemoteClusterStateUtils.encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(GLOBAL_METADATA_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(SETTING_METADATA, splitFileName[0]);
+        assertEquals(RemoteStoreUtils.invertLong(METADATA_VERSION), splitFileName[1]);
+        assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_TransientSettings() throws Exception {
+        Settings settingsMetadata = getSettings();
+        String fileName = randomAlphaOfLength(10);
+        RemoteTransientSettingsMetadata transientSettings = new RemoteTransientSettingsMetadata(
+            fileName,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            RemoteTransientSettingsMetadata.SETTINGS_METADATA_FORMAT.serialize(settingsMetadata, fileName, compressor, FORMAT_PARAMS)
+                .streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteGlobalMetadataManager.readAsync(TRANSIENT_SETTING_METADATA, transientSettings, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(settingsMetadata, listener.getResult().getObj());
+        assertEquals(TRANSIENT_SETTING_METADATA, listener.getResult().getComponent());
+        assertEquals(TRANSIENT_SETTING_METADATA, listener.getResult().getComponentName());
+    }
+
+    public void testGetAsyncWriteRunnable_TransientSettings() throws Exception {
+        Settings settingsMetadata = getSettings();
+        RemoteTransientSettingsMetadata transientSettings = new RemoteTransientSettingsMetadata(
+            settingsMetadata,
+            METADATA_VERSION,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.writeAsync(TRANSIENT_SETTING_METADATA, transientSettings, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+        assertEquals(TRANSIENT_SETTING_METADATA, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(RemoteClusterStateUtils.encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(GLOBAL_METADATA_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(TRANSIENT_SETTING_METADATA, splitFileName[0]);
+        assertEquals(RemoteStoreUtils.invertLong(METADATA_VERSION), splitFileName[1]);
+        assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_HashesOfConsistentSettings() throws Exception {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        String fileName = randomAlphaOfLength(10);
+        RemoteHashesOfConsistentSettings hashesOfConsistentSettingsForDownload = new RemoteHashesOfConsistentSettings(
+            fileName,
+            CLUSTER_UUID,
+            compressor
+        );
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            HASHES_OF_CONSISTENT_SETTINGS_FORMAT.serialize(hashesOfConsistentSettings, fileName, compressor).streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteGlobalMetadataManager.readAsync(
+            HASHES_OF_CONSISTENT_SETTINGS,
+            hashesOfConsistentSettingsForDownload,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(hashesOfConsistentSettings, listener.getResult().getObj());
+        assertEquals(HASHES_OF_CONSISTENT_SETTINGS, listener.getResult().getComponent());
+        assertEquals(HASHES_OF_CONSISTENT_SETTINGS, listener.getResult().getComponentName());
+    }
+
+    public void testGetAsyncWriteRunnable_HashesOfConsistentSettings() throws Exception {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        RemoteHashesOfConsistentSettings hashesOfConsistentSettingsForUpload = new RemoteHashesOfConsistentSettings(
+            hashesOfConsistentSettings,
+            METADATA_VERSION,
+            CLUSTER_UUID,
+            compressor
+        );
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.writeAsync(
+            HASHES_OF_CONSISTENT_SETTINGS,
+            hashesOfConsistentSettingsForUpload,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+        assertEquals(HASHES_OF_CONSISTENT_SETTINGS, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(RemoteClusterStateUtils.encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(GLOBAL_METADATA_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(HASHES_OF_CONSISTENT_SETTINGS, splitFileName[0]);
+        assertEquals(RemoteStoreUtils.invertLong(METADATA_VERSION), splitFileName[1]);
+        assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_TemplatesMetadata() throws Exception {
+        TemplatesMetadata templatesMetadata = getTemplatesMetadata();
+        String fileName = randomAlphaOfLength(10);
+        RemoteTemplatesMetadata templatesMetadataForDownload = new RemoteTemplatesMetadata(
+            fileName,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            TEMPLATES_METADATA_FORMAT.serialize(templatesMetadata, fileName, compressor, FORMAT_PARAMS).streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.readAsync(
+            TEMPLATES_METADATA,
+            templatesMetadataForDownload,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(templatesMetadata, listener.getResult().getObj());
+        assertEquals(TEMPLATES_METADATA, listener.getResult().getComponent());
+        assertEquals(TEMPLATES_METADATA, listener.getResult().getComponentName());
+    }
+
+    public void testGetAsyncWriteRunnable_TemplatesMetadata() throws Exception {
+        TemplatesMetadata templatesMetadata = getTemplatesMetadata();
+        RemoteTemplatesMetadata templateMetadataForUpload = new RemoteTemplatesMetadata(
+            templatesMetadata,
+            METADATA_VERSION,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.writeAsync(TEMPLATES_METADATA, templateMetadataForUpload, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+        assertEquals(TEMPLATES_METADATA, uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(RemoteClusterStateUtils.encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(GLOBAL_METADATA_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(TEMPLATES_METADATA, splitFileName[0]);
+        assertEquals(RemoteStoreUtils.invertLong(METADATA_VERSION), splitFileName[1]);
+        assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_CustomMetadata() throws Exception {
+        Metadata.Custom customMetadata = getCustomMetadata();
+        String fileName = randomAlphaOfLength(10);
+        RemoteCustomMetadata customMetadataForDownload = new RemoteCustomMetadata(
+            fileName,
+            IndexGraveyard.TYPE,
+            CLUSTER_UUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            customMetadataForDownload.customBlobStoreFormat.serialize(customMetadata, fileName, compressor).streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.readAsync(IndexGraveyard.TYPE, customMetadataForDownload, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(customMetadata, listener.getResult().getObj());
+        assertEquals(CUSTOM_METADATA, listener.getResult().getComponent());
+        assertEquals(IndexGraveyard.TYPE, listener.getResult().getComponentName());
+    }
+
+    public void testGetAsyncWriteRunnable_CustomMetadata() throws Exception {
+        Metadata.Custom customMetadata = getCustomMetadata();
+        RemoteCustomMetadata customMetadataForUpload = new RemoteCustomMetadata(
+            customMetadata,
+            IndexGraveyard.TYPE,
+            METADATA_VERSION,
+            CLUSTER_UUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.writeAsync(
+            customMetadataForUpload.getType(),
+            customMetadataForUpload,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+        assertEquals(String.join(CUSTOM_DELIMITER, CUSTOM_METADATA, IndexGraveyard.TYPE), uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(5, pathTokens.length);
+        assertEquals(RemoteClusterStateUtils.encodeString(CLUSTER_NAME), pathTokens[0]);
+        assertEquals(CLUSTER_STATE_PATH_TOKEN, pathTokens[1]);
+        assertEquals(CLUSTER_UUID, pathTokens[2]);
+        assertEquals(GLOBAL_METADATA_PATH_TOKEN, pathTokens[3]);
+        String[] splitFileName = pathTokens[4].split(DELIMITER);
+        assertEquals(4, splitFileName.length);
+        assertEquals(String.join(CUSTOM_DELIMITER, CUSTOM_METADATA, IndexGraveyard.TYPE), splitFileName[0]);
+        assertEquals(RemoteStoreUtils.invertLong(METADATA_VERSION), splitFileName[1]);
+        assertEquals(GLOBAL_METADATA_CURRENT_CODEC_VERSION, Integer.parseInt(splitFileName[3]));
+    }
+
+    public void testGetAsyncReadRunnable_GlobalMetadata() throws Exception {
+        Metadata metadata = getGlobalMetadata();
+        String fileName = randomAlphaOfLength(10);
+        RemoteGlobalMetadata globalMetadataForDownload = new RemoteGlobalMetadata(fileName, CLUSTER_UUID, compressor, xContentRegistry);
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            GLOBAL_METADATA_FORMAT.serialize(metadata, fileName, compressor, FORMAT_PARAMS).streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.readAsync(GLOBAL_METADATA, globalMetadataForDownload, new LatchedActionListener<>(listener, latch));
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertTrue(isGlobalStateEquals(metadata, (Metadata) listener.getResult().getObj()));
+        assertEquals(GLOBAL_METADATA, listener.getResult().getComponent());
+        assertEquals(GLOBAL_METADATA, listener.getResult().getComponentName());
+    }
+
+    public void testGetAsyncReadRunnable_IOException() throws Exception {
+        String fileName = randomAlphaOfLength(10);
+        RemoteCoordinationMetadata coordinationMetadataForDownload = new RemoteCoordinationMetadata(
+            fileName,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        IOException ioException = new IOException("mock test exception");
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenThrow(ioException);
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.readAsync(
+            COORDINATION_METADATA,
+            coordinationMetadataForDownload,
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getResult());
+        assertNotNull(listener.getFailure());
+        assertEquals(ioException, listener.getFailure().getCause());
+        assertTrue(listener.getFailure() instanceof RemoteStateTransferException);
+    }
+
+    public void testGetAsyncWriteRunnable_IOException() throws Exception {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteCoordinationMetadata = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            CLUSTER_UUID,
+            compressor,
+            xContentRegistry
+        );
+        IOException ioException = new IOException("mock test exception");
+        doAnswer(invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onFailure(ioException);
+            return null;
+        }).when(blobStoreTransferService)
+            .uploadBlob(any(InputStream.class), anyIterable(), anyString(), eq(URGENT), any(ActionListener.class));
+
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        remoteGlobalMetadataManager.writeAsync(
+            COORDINATION_METADATA,
+            remoteCoordinationMetadata,
+            new LatchedActionListener<>(listener, latch)
+        );
+        assertNull(listener.getResult());
+        assertNotNull(listener.getFailure());
+        assertTrue(listener.getFailure() instanceof RemoteStateTransferException);
+        assertEquals(ioException, listener.getFailure().getCause());
+    }
+
+    public void testGetUpdatedCustoms() {
+        Map<String, Metadata.Custom> previousCustoms = Map.of(
+            CustomMetadata1.TYPE,
+            new CustomMetadata1("data1"),
+            CustomMetadata2.TYPE,
+            new CustomMetadata2("data2"),
+            CustomMetadata3.TYPE,
+            new CustomMetadata3("data3")
+        );
+        ClusterState previousState = ClusterState.builder(new ClusterName("test-cluster"))
+            .metadata(Metadata.builder().customs(previousCustoms))
+            .build();
+
+        Map<String, Metadata.Custom> currentCustoms = Map.of(
+            CustomMetadata2.TYPE,
+            new CustomMetadata2("data2"),
+            CustomMetadata3.TYPE,
+            new CustomMetadata3("data3-changed"),
+            CustomMetadata4.TYPE,
+            new CustomMetadata4("data4"),
+            CustomMetadata5.TYPE,
+            new CustomMetadata5("data5")
+        );
+        ClusterState currentState = ClusterState.builder(new ClusterName("test-cluster"))
+            .metadata(Metadata.builder().customs(currentCustoms))
+            .build();
+
+        DiffableUtils.MapDiff<String, Metadata.Custom, Map<String, Metadata.Custom>> customsDiff = remoteGlobalMetadataManager
+            .getCustomsDiff(currentState, previousState, true, false);
+        Map<String, Metadata.Custom> expectedUpserts = Map.of(
+            CustomMetadata2.TYPE,
+            new CustomMetadata2("data2"),
+            CustomMetadata3.TYPE,
+            new CustomMetadata3("data3-changed"),
+            CustomMetadata4.TYPE,
+            new CustomMetadata4("data4"),
+            IndexGraveyard.TYPE,
+            IndexGraveyard.builder().build()
+        );
+        assertThat(customsDiff.getUpserts(), is(expectedUpserts));
+        assertThat(customsDiff.getDeletes(), is(List.of()));
+
+        customsDiff = remoteGlobalMetadataManager.getCustomsDiff(currentState, previousState, false, false);
+        expectedUpserts = Map.of(
+            CustomMetadata3.TYPE,
+            new CustomMetadata3("data3-changed"),
+            CustomMetadata4.TYPE,
+            new CustomMetadata4("data4")
+        );
+        assertThat(customsDiff.getUpserts(), is(expectedUpserts));
+        assertThat(customsDiff.getDeletes(), is(List.of(CustomMetadata1.TYPE)));
+
+        customsDiff = remoteGlobalMetadataManager.getCustomsDiff(currentState, previousState, true, true);
+        expectedUpserts = Map.of(
+            CustomMetadata2.TYPE,
+            new CustomMetadata2("data2"),
+            CustomMetadata3.TYPE,
+            new CustomMetadata3("data3-changed"),
+            CustomMetadata4.TYPE,
+            new CustomMetadata4("data4"),
+            CustomMetadata5.TYPE,
+            new CustomMetadata5("data5"),
+            IndexGraveyard.TYPE,
+            IndexGraveyard.builder().build()
+        );
+        assertThat(customsDiff.getUpserts(), is(expectedUpserts));
+        assertThat(customsDiff.getDeletes(), is(List.of()));
+
+        customsDiff = remoteGlobalMetadataManager.getCustomsDiff(currentState, previousState, false, true);
+        expectedUpserts = Map.of(
+            CustomMetadata3.TYPE,
+            new CustomMetadata3("data3-changed"),
+            CustomMetadata4.TYPE,
+            new CustomMetadata4("data4"),
+            CustomMetadata5.TYPE,
+            new CustomMetadata5("data5")
+        );
+        assertThat(customsDiff.getUpserts(), is(expectedUpserts));
+        assertThat(customsDiff.getDeletes(), is(List.of(CustomMetadata1.TYPE)));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteIndexMetadataManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteIndexMetadataManagerTests.java
new file mode 100644
index 0000000000000..76c5792677ea0
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteIndexMetadataManagerTests.java
@@ -0,0 +1,198 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.Version;
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.metadata.AliasMetadata;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.Nullable;
+import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.BlobStore;
+import org.opensearch.common.blobstore.stream.write.WritePriority;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.TestCapturingListener;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.gateway.remote.model.RemoteIndexMetadata;
+import org.opensearch.gateway.remote.model.RemoteReadResult;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateService.FORMAT_PARAMS;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.PATH_DELIMITER;
+import static org.opensearch.gateway.remote.model.RemoteIndexMetadata.INDEX;
+import static org.opensearch.gateway.remote.model.RemoteIndexMetadata.INDEX_METADATA_FORMAT;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyIterable;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteIndexMetadataManagerTests extends OpenSearchTestCase {
+
+    private RemoteIndexMetadataManager remoteIndexMetadataManager;
+    private BlobStoreRepository blobStoreRepository;
+    private BlobStoreTransferService blobStoreTransferService;
+    private Compressor compressor;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("random-path");
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        blobStoreTransferService = mock(BlobStoreTransferService.class);
+        compressor = new NoneCompressor();
+        when(blobStoreRepository.getCompressor()).thenReturn(compressor);
+        remoteIndexMetadataManager = new RemoteIndexMetadataManager(
+            clusterSettings,
+            "test-cluster",
+            blobStoreRepository,
+            blobStoreTransferService,
+            threadPool
+        );
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testGetAsyncWriteRunnable_Success() throws Exception {
+        IndexMetadata indexMetadata = getIndexMetadata(randomAlphaOfLength(10), randomBoolean(), randomAlphaOfLength(10));
+        BlobContainer blobContainer = mock(AsyncMultiStreamBlobContainer.class);
+        BlobStore blobStore = mock(BlobStore.class);
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        String expectedFilePrefix = String.join(DELIMITER, "metadata", RemoteStoreUtils.invertLong(indexMetadata.getVersion()));
+
+        doAnswer((invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onResponse(null);
+            return null;
+        })).when(blobStoreTransferService).uploadBlob(any(), any(), any(), eq(WritePriority.URGENT), any(ActionListener.class));
+
+        remoteIndexMetadataManager.writeAsync(
+            INDEX,
+            new RemoteIndexMetadata(indexMetadata, "cluster-uuid", compressor, null),
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = listener.getResult();
+        assertEquals(INDEX + "--" + indexMetadata.getIndex().getName(), uploadedMetadata.getComponent());
+        String uploadedFileName = uploadedMetadata.getUploadedFilename();
+        String[] pathTokens = uploadedFileName.split(PATH_DELIMITER);
+        assertEquals(7, pathTokens.length);
+        assertEquals(INDEX, pathTokens[4]);
+        assertEquals(indexMetadata.getIndex().getUUID(), pathTokens[5]);
+        assertTrue(pathTokens[6].startsWith(expectedFilePrefix));
+    }
+
+    public void testGetAsyncWriteRunnable_IOFailure() throws Exception {
+        IndexMetadata indexMetadata = getIndexMetadata(randomAlphaOfLength(10), randomBoolean(), randomAlphaOfLength(10));
+        BlobContainer blobContainer = mock(AsyncMultiStreamBlobContainer.class);
+        BlobStore blobStore = mock(BlobStore.class);
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        TestCapturingListener<ClusterMetadataManifest.UploadedMetadata> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        doAnswer((invocationOnMock -> {
+            invocationOnMock.getArgument(4, ActionListener.class).onFailure(new IOException("failure"));
+            return null;
+        })).when(blobStoreTransferService).uploadBlob(any(), any(), any(), eq(WritePriority.URGENT), any(ActionListener.class));
+
+        remoteIndexMetadataManager.writeAsync(
+            INDEX,
+            new RemoteIndexMetadata(indexMetadata, "cluster-uuid", compressor, null),
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getResult());
+        assertNotNull(listener.getFailure());
+        assertTrue(listener.getFailure() instanceof RemoteStateTransferException);
+    }
+
+    public void testGetAsyncReadRunnable_Success() throws Exception {
+        IndexMetadata indexMetadata = getIndexMetadata(randomAlphaOfLength(10), randomBoolean(), randomAlphaOfLength(10));
+        String fileName = randomAlphaOfLength(10);
+        fileName = fileName + DELIMITER + '2';
+        when(blobStoreTransferService.downloadBlob(anyIterable(), anyString())).thenReturn(
+            INDEX_METADATA_FORMAT.serialize(indexMetadata, fileName, compressor, FORMAT_PARAMS).streamInput()
+        );
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteIndexMetadataManager.readAsync(
+            INDEX,
+            new RemoteIndexMetadata(fileName, "cluster-uuid", compressor, null),
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getFailure());
+        assertNotNull(listener.getResult());
+        assertEquals(indexMetadata, listener.getResult().getObj());
+    }
+
+    public void testGetAsyncReadRunnable_IOFailure() throws Exception {
+        String fileName = randomAlphaOfLength(10);
+        fileName = fileName + DELIMITER + '2';
+        Exception exception = new IOException("testing failure");
+        doThrow(exception).when(blobStoreTransferService).downloadBlob(anyIterable(), anyString());
+        TestCapturingListener<RemoteReadResult> listener = new TestCapturingListener<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        remoteIndexMetadataManager.readAsync(
+            INDEX,
+            new RemoteIndexMetadata(fileName, "cluster-uuid", compressor, null),
+            new LatchedActionListener<>(listener, latch)
+        );
+        latch.await();
+        assertNull(listener.getResult());
+        assertNotNull(listener.getFailure());
+        assertEquals(exception, listener.getFailure().getCause());
+        assertTrue(listener.getFailure() instanceof RemoteStateTransferException);
+    }
+
+    private IndexMetadata getIndexMetadata(String name, @Nullable Boolean writeIndex, String... aliases) {
+        IndexMetadata.Builder builder = IndexMetadata.builder(name)
+            .settings(
+                Settings.builder()
+                    .put("index.version.created", Version.CURRENT.id)
+                    .put("index.number_of_shards", 1)
+                    .put("index.number_of_replicas", 1)
+            );
+        for (String alias : aliases) {
+            builder.putAlias(AliasMetadata.builder(alias).writeIndex(writeIndex).build());
+        }
+        return builder.build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/RemoteManifestManagerTests.java b/server/src/test/java/org/opensearch/gateway/remote/RemoteManifestManagerTests.java
new file mode 100644
index 0000000000000..055bd94f5317b
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/RemoteManifestManagerTests.java
@@ -0,0 +1,129 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote;
+
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.BlobStore;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.DELIMITER;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteManifestManagerTests extends OpenSearchTestCase {
+    private RemoteManifestManager remoteManifestManager;
+    private ClusterSettings clusterSettings;
+    private BlobStoreRepository blobStoreRepository;
+    private BlobStore blobStore;
+    private BlobStoreTransferService blobStoreTransferService;
+    private ThreadPool threadPool;
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        blobStoreRepository = mock(BlobStoreRepository.class);
+        NamedXContentRegistry xContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+        blobStoreTransferService = mock(BlobStoreTransferService.class);
+        blobStore = mock(BlobStore.class);
+        when(blobStoreRepository.blobStore()).thenReturn(blobStore);
+        threadPool = new TestThreadPool("test");
+        Compressor compressor = new NoneCompressor();
+        when(blobStoreRepository.getCompressor()).thenReturn(compressor);
+        when(blobStoreRepository.getNamedXContentRegistry()).thenReturn(xContentRegistry);
+        remoteManifestManager = new RemoteManifestManager(
+            clusterSettings,
+            "test-cluster-name",
+            "test-node-id",
+            blobStoreRepository,
+            blobStoreTransferService,
+            threadPool
+        );
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testMetadataManifestUploadWaitTimeSetting() {
+        // verify default value
+        assertEquals(
+            RemoteManifestManager.METADATA_MANIFEST_UPLOAD_TIMEOUT_DEFAULT,
+            remoteManifestManager.getMetadataManifestUploadTimeout()
+        );
+
+        // verify update metadata manifest upload timeout
+        int metadataManifestUploadTimeout = randomIntBetween(1, 10);
+        Settings newSettings = Settings.builder()
+            .put("cluster.remote_store.state.metadata_manifest.upload_timeout", metadataManifestUploadTimeout + "s")
+            .build();
+        clusterSettings.applySettings(newSettings);
+        assertEquals(metadataManifestUploadTimeout, remoteManifestManager.getMetadataManifestUploadTimeout().seconds());
+    }
+
+    public void testReadLatestMetadataManifestFailedIOException() throws IOException {
+        final ClusterState clusterState = RemoteClusterStateServiceTests.generateClusterStateWithOneIndex()
+            .nodes(RemoteClusterStateServiceTests.nodesWithLocalNodeClusterManager())
+            .build();
+
+        BlobContainer blobContainer = mockBlobStoreObjects();
+        when(blobContainer.listBlobsByPrefixInSortedOrder("manifest" + DELIMITER, 1, BlobContainer.BlobNameSortOrder.LEXICOGRAPHIC))
+            .thenThrow(IOException.class);
+
+        Exception e = assertThrows(
+            IllegalStateException.class,
+            () -> remoteManifestManager.getLatestClusterMetadataManifest(
+                clusterState.getClusterName().value(),
+                clusterState.metadata().clusterUUID()
+            )
+        );
+        assertEquals(e.getMessage(), "Error while fetching latest manifest file for remote cluster state");
+    }
+
+    private BlobContainer mockBlobStoreObjects() {
+        final BlobPath blobPath = mock(BlobPath.class);
+        when((blobStoreRepository.basePath())).thenReturn(blobPath);
+        when(blobPath.add(anyString())).thenReturn(blobPath);
+        when(blobPath.buildAsString()).thenReturn("/blob/path/");
+        final BlobContainer blobContainer = mock(BlobContainer.class);
+        when(blobContainer.path()).thenReturn(blobPath);
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+        return blobContainer;
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/ClusterStateDiffManifestTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/ClusterStateDiffManifestTests.java
new file mode 100644
index 0000000000000..e716822939a58
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/ClusterStateDiffManifestTests.java
@@ -0,0 +1,310 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.IndexTemplateMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
+import org.opensearch.cluster.routing.StringKeyDiffProvider;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.common.transport.TransportAddress;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.gateway.remote.ClusterStateDiffManifest;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonList;
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.Version.CURRENT;
+import static org.opensearch.cluster.ClusterState.EMPTY_STATE;
+import static org.opensearch.core.common.transport.TransportAddress.META_ADDRESS;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V3;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V4;
+import static org.opensearch.gateway.remote.RemoteClusterStateServiceTests.generateClusterStateWithOneIndex;
+import static org.opensearch.gateway.remote.RemoteClusterStateServiceTests.nodesWithLocalNodeClusterManager;
+import static org.opensearch.gateway.remote.model.RemoteClusterBlocksTests.randomClusterBlocks;
+
+public class ClusterStateDiffManifestTests extends OpenSearchTestCase {
+
+    public void testClusterStateDiffManifest() {
+        ClusterState initialState = ClusterState.builder(EMPTY_STATE)
+            .metadata(
+                Metadata.builder()
+                    .put(
+                        IndexMetadata.builder("index-1")
+                            .settings(Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT))
+                            .numberOfShards(1)
+                            .numberOfReplicas(0)
+                    )
+            )
+            .build();
+        updateAndVerifyState(
+            initialState,
+            singletonList(
+                IndexMetadata.builder("index-2")
+                    .settings(Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT))
+                    .numberOfShards(1)
+                    .numberOfReplicas(0)
+                    .build()
+            ),
+            singletonList("index-1"),
+            emptyMap(),
+            emptyList(),
+            emptyMap(),
+            emptyList(),
+            randomBoolean(),
+            randomBoolean(),
+            randomBoolean(),
+            randomBoolean(),
+            randomBoolean(),
+            randomBoolean(),
+            randomBoolean()
+        );
+    }
+
+    public void testClusterStateDiffManifestXContent() throws IOException {
+        ClusterState initialState = ClusterState.builder(EMPTY_STATE)
+            .metadata(
+                Metadata.builder()
+                    .put(
+                        IndexMetadata.builder("index-1")
+                            .settings(Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT))
+                            .numberOfShards(1)
+                            .numberOfReplicas(0)
+                    )
+            )
+            .build();
+        ClusterStateDiffManifest diffManifest = updateAndVerifyState(
+            initialState,
+            emptyList(),
+            singletonList("index-1"),
+            emptyMap(),
+            emptyList(),
+            emptyMap(),
+            emptyList(),
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true
+        );
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        diffManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser, CODEC_V4);
+            assertEquals(diffManifest, parsedManifest);
+        }
+    }
+
+    public void testClusterStateWithRoutingTableDiffInDiffManifestXContent() throws IOException {
+        ClusterState initialState = generateClusterStateWithOneIndex("test-index", 5, 1, true).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterState updatedState = generateClusterStateWithOneIndex("test-index", 5, 2, false).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterStateDiffManifest diffManifest = verifyRoutingTableDiffManifest(initialState, updatedState, CODEC_V3);
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        diffManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser, CODEC_V3);
+            assertEquals(diffManifest, parsedManifest);
+        }
+    }
+
+    public void testClusterStateWithRoutingTableDiffInDiffManifestXContentWithDeletes() throws IOException {
+        ClusterState initialState = generateClusterStateWithOneIndex("test-index", 5, 1, true).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterState updatedState = generateClusterStateWithOneIndex("test-index-1", 5, 2, false).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterStateDiffManifest diffManifest = verifyRoutingTableDiffManifest(initialState, updatedState, CODEC_V3);
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        diffManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser, CODEC_V3);
+            assertEquals(diffManifest, parsedManifest);
+        }
+    }
+
+    public void testClusterStateWithRoutingTableDiffInDiffManifestXContentV4() throws IOException {
+        ClusterState initialState = generateClusterStateWithOneIndex("test-index", 5, 1, true).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterState updatedState = generateClusterStateWithOneIndex("test-index", 5, 2, false).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterStateDiffManifest diffManifest = verifyRoutingTableDiffManifest(initialState, updatedState, CODEC_V4);
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        diffManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser, CODEC_V4);
+            assertEquals(diffManifest, parsedManifest);
+        }
+    }
+
+    public void testClusterStateWithRoutingTableDiffInDiffManifestXContentWithDeletesV4() throws IOException {
+        ClusterState initialState = generateClusterStateWithOneIndex("test-index", 5, 1, true).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterState updatedState = generateClusterStateWithOneIndex("test-index-1", 5, 2, false).nodes(nodesWithLocalNodeClusterManager())
+            .build();
+
+        ClusterStateDiffManifest diffManifest = verifyRoutingTableDiffManifest(initialState, updatedState, CODEC_V4);
+        final XContentBuilder builder = JsonXContent.contentBuilder();
+        builder.startObject();
+        diffManifest.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder))) {
+            final ClusterStateDiffManifest parsedManifest = ClusterStateDiffManifest.fromXContent(parser, CODEC_V4);
+            assertEquals(diffManifest, parsedManifest);
+        }
+    }
+
+    private ClusterStateDiffManifest verifyRoutingTableDiffManifest(
+        ClusterState previousState,
+        ClusterState currentState,
+        int codecVersion
+    ) {
+        // Create initial and updated IndexRoutingTable maps
+        StringKeyDiffProvider<IndexRoutingTable> routingTableDiff = new RoutingTableIncrementalDiff(
+            previousState.getRoutingTable(),
+            currentState.getRoutingTable()
+        );
+        ClusterStateDiffManifest manifest = new ClusterStateDiffManifest(
+            currentState,
+            previousState,
+            codecVersion,
+            routingTableDiff,
+            "indicesRoutingDiffPath"
+        );
+        assertEquals("indicesRoutingDiffPath", manifest.getIndicesRoutingDiffPath());
+        return manifest;
+    }
+
+    private ClusterStateDiffManifest updateAndVerifyState(
+        ClusterState initialState,
+        List<IndexMetadata> indicesToAdd,
+        List<String> indicesToRemove,
+        Map<String, Metadata.Custom> customsToAdd,
+        List<String> customsToRemove,
+        Map<String, ClusterState.Custom> clusterStateCustomsToAdd,
+        List<String> clusterStateCustomsToRemove,
+        boolean updateCoordinationState,
+        boolean updatePersistentSettings,
+        boolean updateTemplates,
+        boolean updateTransientSettings,
+        boolean updateDiscoveryNodes,
+        boolean updateClusterBlocks,
+        boolean updateHashesOfConsistentSettings
+    ) {
+        ClusterState.Builder clusterStateBuilder = ClusterState.builder(initialState);
+        Metadata.Builder metadataBuilder = Metadata.builder(initialState.metadata());
+        for (IndexMetadata indexMetadata : indicesToAdd) {
+            metadataBuilder.put(indexMetadata, true);
+        }
+        indicesToRemove.forEach(metadataBuilder::remove);
+        for (String custom : customsToAdd.keySet()) {
+            metadataBuilder.putCustom(custom, customsToAdd.get(custom));
+        }
+        customsToRemove.forEach(metadataBuilder::removeCustom);
+        for (String custom : clusterStateCustomsToAdd.keySet()) {
+            clusterStateBuilder.putCustom(custom, clusterStateCustomsToAdd.get(custom));
+        }
+        clusterStateCustomsToRemove.forEach(clusterStateBuilder::removeCustom);
+        if (updateCoordinationState) {
+            metadataBuilder.coordinationMetadata(
+                CoordinationMetadata.builder(initialState.metadata().coordinationMetadata())
+                    .addVotingConfigExclusion(new CoordinationMetadata.VotingConfigExclusion("exlucdedNodeId", "excludedNodeName"))
+                    .build()
+            );
+        }
+        if (updatePersistentSettings) {
+            metadataBuilder.persistentSettings(Settings.builder().put("key", "value").build());
+        }
+        if (updateTemplates) {
+            metadataBuilder.templates(
+                TemplatesMetadata.builder()
+                    .put(
+                        IndexTemplateMetadata.builder("template" + randomAlphaOfLength(3))
+                            .patterns(asList("bar-*", "foo-*"))
+                            .settings(
+                                Settings.builder().put("random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build()
+                            )
+                            .build()
+                    )
+                    .build()
+            );
+        }
+        if (updateTransientSettings) {
+            metadataBuilder.transientSettings(Settings.builder().put("key", "value").build());
+        }
+        if (updateDiscoveryNodes) {
+            clusterStateBuilder.nodes(
+                DiscoveryNodes.builder(initialState.nodes())
+                    .add(new DiscoveryNode("new-cluster-manager", new TransportAddress(META_ADDRESS, 9200), CURRENT))
+                    .clusterManagerNodeId("new-cluster-manager")
+            );
+        }
+        if (updateHashesOfConsistentSettings) {
+            metadataBuilder.hashesOfConsistentSettings(Collections.singletonMap("key", "value"));
+        }
+        if (updateClusterBlocks) {
+            clusterStateBuilder.blocks(randomClusterBlocks());
+        }
+        ClusterState updatedClusterState = clusterStateBuilder.metadata(metadataBuilder.build()).build();
+
+        ClusterStateDiffManifest manifest = new ClusterStateDiffManifest(updatedClusterState, initialState, CODEC_V4, null, null);
+        assertEquals(indicesToAdd.stream().map(im -> im.getIndex().getName()).collect(toList()), manifest.getIndicesUpdated());
+        assertEquals(indicesToRemove, manifest.getIndicesDeleted());
+        assertEquals(new ArrayList<>(customsToAdd.keySet()), manifest.getCustomMetadataUpdated());
+        assertEquals(customsToRemove, manifest.getCustomMetadataDeleted());
+        assertEquals(new ArrayList<>(clusterStateCustomsToAdd.keySet()), manifest.getClusterStateCustomUpdated());
+        assertEquals(clusterStateCustomsToRemove, manifest.getClusterStateCustomDeleted());
+        assertEquals(updateCoordinationState, manifest.isCoordinationMetadataUpdated());
+        assertEquals(updatePersistentSettings, manifest.isSettingsMetadataUpdated());
+        assertEquals(updateTemplates, manifest.isTemplatesMetadataUpdated());
+        assertEquals(updateTransientSettings, manifest.isTransientSettingsMetadataUpdated());
+        assertEquals(updateDiscoveryNodes, manifest.isDiscoveryNodesUpdated());
+        assertEquals(updateClusterBlocks, manifest.isClusterBlocksUpdated());
+        assertEquals(updateHashesOfConsistentSettings, manifest.isHashesOfConsistentSettingsUpdated());
+        return manifest;
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterBlocksTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterBlocksTests.java
new file mode 100644
index 0000000000000..3c1e141b81360
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterBlocksTests.java
@@ -0,0 +1,155 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.block.ClusterBlocks;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.cluster.block.ClusterBlockTests.randomClusterBlock;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_EPHEMERAL_PATH_TOKEN;
+import static org.opensearch.gateway.remote.model.RemoteClusterBlocks.CLUSTER_BLOCKS;
+
+public class RemoteClusterBlocksTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long METADATA_VERSION = 3L;
+    private String clusterUUID;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+
+    @Before
+    public void setup() {
+        this.clusterUUID = "test-cluster-uuid";
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+    }
+
+    public void testClusterUUID() {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        RemoteClusterBlocks remoteObjectForUpload = new RemoteClusterBlocks(clusterBlocks, METADATA_VERSION, clusterUUID, compressor);
+        assertEquals(remoteObjectForUpload.clusterUUID(), clusterUUID);
+
+        RemoteClusterBlocks remoteObjectForDownload = new RemoteClusterBlocks(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertEquals(remoteObjectForDownload.clusterUUID(), clusterUUID);
+    }
+
+    public void testFullBlobName() {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        RemoteClusterBlocks remoteObjectForUpload = new RemoteClusterBlocks(clusterBlocks, METADATA_VERSION, clusterUUID, compressor);
+        assertNull(remoteObjectForUpload.getFullBlobName());
+
+        RemoteClusterBlocks remoteObjectForDownload = new RemoteClusterBlocks(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertEquals(remoteObjectForDownload.getFullBlobName(), TEST_BLOB_NAME);
+    }
+
+    public void testBlobFileName() {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        RemoteClusterBlocks remoteObjectForUpload = new RemoteClusterBlocks(clusterBlocks, METADATA_VERSION, clusterUUID, compressor);
+        assertNull(remoteObjectForUpload.getBlobFileName());
+
+        RemoteClusterBlocks remoteObjectForDownload = new RemoteClusterBlocks(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertEquals(remoteObjectForDownload.getBlobFileName(), TEST_BLOB_FILE_NAME);
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/cluster-blocks";
+        RemoteClusterBlocks remoteObjectForDownload = new RemoteClusterBlocks(uploadedFile, clusterUUID, compressor);
+        assertArrayEquals(remoteObjectForDownload.getBlobPathTokens(), new String[] { "user", "local", "opensearch", "cluster-blocks" });
+    }
+
+    public void testBlobPathParameters() {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        RemoteClusterBlocks remoteObjectForUpload = new RemoteClusterBlocks(clusterBlocks, METADATA_VERSION, clusterUUID, compressor);
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertEquals(params.getPathTokens(), List.of(CLUSTER_STATE_EPHEMERAL_PATH_TOKEN));
+        assertEquals(params.getFilePrefix(), CLUSTER_BLOCKS);
+    }
+
+    public void testGenerateBlobFileName() {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        RemoteClusterBlocks remoteObjectForUpload = new RemoteClusterBlocks(clusterBlocks, METADATA_VERSION, clusterUUID, compressor);
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertEquals(nameTokens[0], CLUSTER_BLOCKS);
+        assertEquals(RemoteStoreUtils.invertLong(nameTokens[1]), METADATA_VERSION);
+        assertTrue(RemoteStoreUtils.invertLong(nameTokens[2]) <= System.currentTimeMillis());
+        assertEquals(nameTokens[3], String.valueOf(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION));
+
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        RemoteClusterBlocks remoteObjectForUpload = new RemoteClusterBlocks(clusterBlocks, METADATA_VERSION, clusterUUID, compressor);
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+        remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+        assertEquals(uploadedMetadata.getComponent(), CLUSTER_BLOCKS);
+        assertEquals(uploadedMetadata.getUploadedFilename(), remoteObjectForUpload.getFullBlobName());
+    }
+
+    public void testSerDe() throws IOException {
+        ClusterBlocks clusterBlocks = randomClusterBlocks();
+        RemoteClusterBlocks remoteObjectForUpload = new RemoteClusterBlocks(clusterBlocks, METADATA_VERSION, clusterUUID, compressor);
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertTrue(inputStream.available() > 0);
+            ClusterBlocks readClusterBlocks = remoteObjectForUpload.deserialize(inputStream);
+            assertEquals(clusterBlocks.global(), readClusterBlocks.global());
+            assertEquals(clusterBlocks.indices().keySet(), readClusterBlocks.indices().keySet());
+            for (String index : clusterBlocks.indices().keySet()) {
+                assertEquals(clusterBlocks.indices().get(index), readClusterBlocks.indices().get(index));
+            }
+
+        }
+    }
+
+    public static ClusterBlocks randomClusterBlocks() {
+        ClusterBlocks.Builder builder = ClusterBlocks.builder();
+        int randomGlobalBlocks = randomIntBetween(1, 10);
+        for (int i = 0; i < randomGlobalBlocks; i++) {
+            builder.addGlobalBlock(randomClusterBlock());
+        }
+
+        int randomIndices = randomIntBetween(1, 10);
+        for (int i = 0; i < randomIndices; i++) {
+            int randomIndexBlocks = randomIntBetween(1, 10);
+            for (int j = 0; j < randomIndexBlocks; j++) {
+                builder.addIndexBlock("index-" + i, randomClusterBlock());
+            }
+        }
+        return builder.build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifestTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifestTests.java
new file mode 100644
index 0000000000000..f399dd2f3d7a5
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterMetadataManifestTests.java
@@ -0,0 +1,277 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadataAttribute;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V0;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.CODEC_V2;
+import static org.opensearch.gateway.remote.ClusterMetadataManifest.MANIFEST_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.model.RemoteClusterMetadataManifest.MANIFEST;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteClusterMetadataManifestTests extends OpenSearchTestCase {
+
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+
+    private static final long TERM = 2L;
+    private static final long VERSION = 5L;
+
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        ClusterMetadataManifest manifest = getClusterMetadataManifest();
+        RemoteClusterMetadataManifest remoteObjectForUpload = new RemoteClusterMetadataManifest(
+            manifest,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.clusterUUID(), is(clusterUUID));
+
+        RemoteClusterMetadataManifest remoteObjectForDownload = new RemoteClusterMetadataManifest(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.clusterUUID(), is(clusterUUID));
+    }
+
+    public void testFullBlobName() {
+        ClusterMetadataManifest manifest = getClusterMetadataManifest();
+        RemoteClusterMetadataManifest remoteObjectForUpload = new RemoteClusterMetadataManifest(
+            manifest,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+        RemoteClusterMetadataManifest remoteObjectForDownload = new RemoteClusterMetadataManifest(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        ClusterMetadataManifest manifest = getClusterMetadataManifest();
+        RemoteClusterMetadataManifest remoteObjectForUpload = new RemoteClusterMetadataManifest(
+            manifest,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+        RemoteClusterMetadataManifest remoteObjectForDownload = new RemoteClusterMetadataManifest(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/manifest";
+        RemoteClusterMetadataManifest remoteObjectForDownload = new RemoteClusterMetadataManifest(
+            uploadedFile,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "manifest" }));
+    }
+
+    public void testBlobPathParameters() {
+        ClusterMetadataManifest manifest = getClusterMetadataManifest();
+        RemoteClusterMetadataManifest remoteObjectForUpload = new RemoteClusterMetadataManifest(
+            manifest,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(MANIFEST)));
+        assertThat(params.getFilePrefix(), is(RemoteClusterMetadataManifest.MANIFEST));
+    }
+
+    public void testGenerateBlobFileName() {
+        ClusterMetadataManifest manifest = getClusterMetadataManifest();
+        RemoteClusterMetadataManifest remoteObjectForUpload = new RemoteClusterMetadataManifest(
+            manifest,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertThat(nameTokens[0], is(RemoteClusterMetadataManifest.MANIFEST));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[1]), is(TERM));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[2]), is(VERSION));
+        assertThat(nameTokens[3], is("C"));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[4]), lessThanOrEqualTo(System.currentTimeMillis()));
+        assertThat(nameTokens[5], is(String.valueOf(MANIFEST_CURRENT_CODEC_VERSION)));
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        ClusterMetadataManifest manifest = getClusterMetadataManifest();
+        RemoteClusterMetadataManifest remoteObjectForUpload = new RemoteClusterMetadataManifest(
+            manifest,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+            UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+            assertThat(uploadedMetadata.getComponent(), is(MANIFEST));
+            assertThat(uploadedMetadata.getUploadedFilename(), is(remoteObjectForUpload.getFullBlobName()));
+        }
+    }
+
+    public void testSerDe() throws IOException {
+        ClusterMetadataManifest manifest = getClusterMetadataManifest();
+        RemoteClusterMetadataManifest remoteObjectForUpload = new RemoteClusterMetadataManifest(
+            manifest,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertThat(inputStream.available(), greaterThan(0));
+            ClusterMetadataManifest readManifest = remoteObjectForUpload.deserialize(inputStream);
+            assertThat(readManifest, is(manifest));
+        }
+
+        String blobName = "/usr/local/manifest__1__2__3__4__5__6";
+        RemoteClusterMetadataManifest invalidRemoteObject = new RemoteClusterMetadataManifest(
+            blobName,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(IllegalArgumentException.class, () -> invalidRemoteObject.deserialize(new ByteArrayInputStream(new byte[0])));
+    }
+
+    public void testGetManifestCodecVersion() {
+        String manifestFileWithDelimiterInPath =
+            "123456789012_test-cluster/cluster-state/dsgYj10__Nkso7/manifest/manifest__9223372036854775806__9223372036854775804__C__9223370319103329556__2";
+        RemoteClusterMetadataManifest remoteManifestForDownload = new RemoteClusterMetadataManifest(
+            manifestFileWithDelimiterInPath,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertEquals(CODEC_V2, remoteManifestForDownload.getManifestCodecVersion());
+
+        String v0ManifestFileWithDelimiterInPath =
+            "123456789012_test-cluster/cluster-state/dsgYj10__Nkso7/manifest/manifest__9223372036854775806__9223372036854775804__C__9223370319103329556";
+        RemoteClusterMetadataManifest remoteManifestV0ForDownload = new RemoteClusterMetadataManifest(
+            v0ManifestFileWithDelimiterInPath,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertEquals(CODEC_V0, remoteManifestV0ForDownload.getManifestCodecVersion());
+    }
+
+    private ClusterMetadataManifest getClusterMetadataManifest() {
+        return ClusterMetadataManifest.builder()
+            .opensearchVersion(Version.CURRENT)
+            .codecVersion(MANIFEST_CURRENT_CODEC_VERSION)
+            .nodeId("test-node")
+            .clusterUUID("test-uuid")
+            .previousClusterUUID("_NA_")
+            .stateUUID("state-uuid")
+            .clusterTerm(TERM)
+            .stateVersion(VERSION)
+            .committed(true)
+            .coordinationMetadata(new UploadedMetadataAttribute("test-attr", "uploaded-file"))
+            .build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterStateCustomsTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterStateCustomsTests.java
new file mode 100644
index 0000000000000..1b020e13324a4
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteClusterStateCustomsTests.java
@@ -0,0 +1,260 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterState.Custom;
+import org.opensearch.cluster.SnapshotsInProgress;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.snapshots.Snapshot;
+import org.opensearch.snapshots.SnapshotId;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
+import static org.opensearch.Version.CURRENT;
+import static org.opensearch.cluster.SnapshotsInProgress.State.INIT;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CUSTOM_DELIMITER;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.model.RemoteClusterStateCustoms.CLUSTER_STATE_CUSTOM;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteClusterStateCustomsTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final String CUSTOM_TYPE = "test-custom";
+    private static final long STATE_VERSION = 3L;
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedWriteableRegistry namedWriteableRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedWriteableRegistry = writableRegistry();
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        Custom clusterStateCustoms = getClusterStateCustom();
+        RemoteClusterStateCustoms remoteObjectForUpload = new RemoteClusterStateCustoms(
+            clusterStateCustoms,
+            "test-custom",
+            STATE_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForUpload.clusterUUID(), is(clusterUUID));
+
+        RemoteClusterStateCustoms remoteObjectForDownload = new RemoteClusterStateCustoms(
+            TEST_BLOB_NAME,
+            "test-custom",
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForDownload.clusterUUID(), is(clusterUUID));
+    }
+
+    public void testFullBlobName() {
+        Custom clusterStateCustoms = getClusterStateCustom();
+        RemoteClusterStateCustoms remoteObjectForUpload = new RemoteClusterStateCustoms(
+            clusterStateCustoms,
+            "test-custom",
+            STATE_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+        RemoteClusterStateCustoms remoteObjectForDownload = new RemoteClusterStateCustoms(
+            TEST_BLOB_NAME,
+            "test-custom",
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        Custom clusterStateCustoms = getClusterStateCustom();
+        RemoteClusterStateCustoms remoteObjectForUpload = new RemoteClusterStateCustoms(
+            clusterStateCustoms,
+            "test-custom",
+            STATE_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+        RemoteClusterStateCustoms remoteObjectForDownload = new RemoteClusterStateCustoms(
+            TEST_BLOB_NAME,
+            "test-custom",
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/clusterStateCustoms";
+        RemoteClusterStateCustoms remoteObjectForDownload = new RemoteClusterStateCustoms(
+            uploadedFile,
+            "test-custom",
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "clusterStateCustoms" }));
+    }
+
+    public void testBlobPathParameters() {
+        Custom clusterStateCustoms = getClusterStateCustom();
+        RemoteClusterStateCustoms remoteObjectForUpload = new RemoteClusterStateCustoms(
+            clusterStateCustoms,
+            "test-custom",
+            STATE_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(RemoteClusterStateUtils.CLUSTER_STATE_EPHEMERAL_PATH_TOKEN)));
+        String expectedPrefix = String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, "test-custom");
+        assertThat(params.getFilePrefix(), is(expectedPrefix));
+    }
+
+    public void testGenerateBlobFileName() {
+        Custom clusterStateCustoms = getClusterStateCustom();
+        RemoteClusterStateCustoms remoteObjectForUpload = new RemoteClusterStateCustoms(
+            clusterStateCustoms,
+            "test-custom",
+            STATE_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        String expectedPrefix = String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, "test-custom");
+        assertThat(nameTokens[0], is(expectedPrefix));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[1]), is(STATE_VERSION));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[2]), lessThanOrEqualTo(System.currentTimeMillis()));
+        assertThat(nameTokens[3], is(String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)));
+
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        Custom clusterStateCustoms = getClusterStateCustom();
+        RemoteClusterStateCustoms remoteObjectForUpload = new RemoteClusterStateCustoms(
+            clusterStateCustoms,
+            "test-custom",
+            STATE_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+            UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+            String expectedPrefix = String.join(CUSTOM_DELIMITER, CLUSTER_STATE_CUSTOM, "test-custom");
+            assertThat(uploadedMetadata.getComponent(), is(expectedPrefix));
+            assertThat(uploadedMetadata.getUploadedFilename(), is(remoteObjectForUpload.getFullBlobName()));
+        }
+    }
+
+    public void testSerDe() throws IOException {
+        Custom clusterStateCustoms = getClusterStateCustom();
+        RemoteClusterStateCustoms remoteObjectForUpload = new RemoteClusterStateCustoms(
+            clusterStateCustoms,
+            SnapshotsInProgress.TYPE,
+            STATE_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertThat(inputStream.available(), greaterThan(0));
+            Custom readClusterStateCustoms = remoteObjectForUpload.deserialize(inputStream);
+            assertThat(readClusterStateCustoms, is(clusterStateCustoms));
+        }
+    }
+
+    public static SnapshotsInProgress getClusterStateCustom() {
+        return SnapshotsInProgress.of(
+            List.of(
+                new SnapshotsInProgress.Entry(
+                    new Snapshot("repo", new SnapshotId("test-snapshot", "test-snapshot-uuid")),
+                    false,
+                    false,
+                    INIT,
+                    emptyList(),
+                    emptyList(),
+                    0L,
+                    0L,
+                    emptyMap(),
+                    emptyMap(),
+                    CURRENT,
+                    false
+                )
+            )
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteCoordinationMetadataTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteCoordinationMetadataTests.java
new file mode 100644
index 0000000000000..63d6de05a737c
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteCoordinationMetadataTests.java
@@ -0,0 +1,240 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
+import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfiguration;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteCoordinationMetadataTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long TERM = 3L;
+    private static final long METADATA_VERSION = 3L;
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteObjectForUpload = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.clusterUUID(), is(clusterUUID));
+
+        RemoteCoordinationMetadata remoteObjectForDownload = new RemoteCoordinationMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.clusterUUID(), is(clusterUUID));
+    }
+
+    public void testFullBlobName() {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteObjectForUpload = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+        RemoteCoordinationMetadata remoteObjectForDownload = new RemoteCoordinationMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteObjectForUpload = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+        RemoteCoordinationMetadata remoteObjectForDownload = new RemoteCoordinationMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/coordinationMetadata";
+        RemoteCoordinationMetadata remoteObjectForDownload = new RemoteCoordinationMetadata(
+            uploadedFile,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "coordinationMetadata" }));
+    }
+
+    public void testBlobPathParameters() {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteObjectForUpload = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN)));
+        assertThat(params.getFilePrefix(), is(RemoteCoordinationMetadata.COORDINATION_METADATA));
+    }
+
+    public void testGenerateBlobFileName() {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteObjectForUpload = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertThat(nameTokens[0], is(RemoteCoordinationMetadata.COORDINATION_METADATA));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[1]), is(METADATA_VERSION));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[2]), lessThanOrEqualTo(System.currentTimeMillis()));
+        assertThat(nameTokens[3], is(String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)));
+
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteObjectForUpload = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+            UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+            assertThat(uploadedMetadata.getComponent(), is(RemoteCoordinationMetadata.COORDINATION_METADATA));
+            assertThat(uploadedMetadata.getUploadedFilename(), is(remoteObjectForUpload.getFullBlobName()));
+        }
+    }
+
+    public void testSerDe() throws IOException {
+        CoordinationMetadata coordinationMetadata = getCoordinationMetadata();
+        RemoteCoordinationMetadata remoteObjectForUpload = new RemoteCoordinationMetadata(
+            coordinationMetadata,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertThat(inputStream.available(), greaterThan(0));
+            CoordinationMetadata readcoordinationMetadata = remoteObjectForUpload.deserialize(inputStream);
+            assertThat(readcoordinationMetadata, is(coordinationMetadata));
+        }
+    }
+
+    public static CoordinationMetadata getCoordinationMetadata() {
+        return CoordinationMetadata.builder()
+            .term(TERM)
+            .lastAcceptedConfiguration(new VotingConfiguration(Set.of("node1")))
+            .lastCommittedConfiguration(new VotingConfiguration(Set.of("node1")))
+            .addVotingConfigExclusion(new VotingConfigExclusion("node2", " node-2"))
+            .build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteCustomMetadataTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteCustomMetadataTests.java
new file mode 100644
index 0000000000000..60cceb205f43d
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteCustomMetadataTests.java
@@ -0,0 +1,318 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.metadata.IndexGraveyard;
+import org.opensearch.cluster.metadata.Metadata.Custom;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry.Entry;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.persistent.PersistentTaskParams;
+import org.opensearch.persistent.PersistentTasksCustomMetadata;
+import org.opensearch.persistent.PersistentTasksCustomMetadata.Assignment;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Objects;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_DELIMITER;
+import static org.opensearch.gateway.remote.model.RemoteCustomMetadata.CUSTOM_METADATA;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteCustomMetadataTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final String CUSTOM_TYPE = "test-custom";
+    private static final long METADATA_VERSION = 3L;
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedWriteableRegistry namedWriteableRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedWriteableRegistry = writableRegistry();
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        Custom customMetadata = getCustomMetadata();
+        RemoteCustomMetadata remoteObjectForUpload = new RemoteCustomMetadata(
+            customMetadata,
+            "test-custom",
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForUpload.clusterUUID(), is(clusterUUID));
+
+        RemoteCustomMetadata remoteObjectForDownload = new RemoteCustomMetadata(
+            TEST_BLOB_NAME,
+            "test-custom",
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForDownload.clusterUUID(), is(clusterUUID));
+    }
+
+    public void testFullBlobName() {
+        Custom customMetadata = getCustomMetadata();
+        RemoteCustomMetadata remoteObjectForUpload = new RemoteCustomMetadata(
+            customMetadata,
+            "test-custom",
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+        RemoteCustomMetadata remoteObjectForDownload = new RemoteCustomMetadata(
+            TEST_BLOB_NAME,
+            "test-custom",
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        Custom customMetadata = getCustomMetadata();
+        RemoteCustomMetadata remoteObjectForUpload = new RemoteCustomMetadata(
+            customMetadata,
+            "test-custom",
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+        RemoteCustomMetadata remoteObjectForDownload = new RemoteCustomMetadata(
+            TEST_BLOB_NAME,
+            "test-custom",
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/customMetadata";
+        RemoteCustomMetadata remoteObjectForDownload = new RemoteCustomMetadata(
+            uploadedFile,
+            "test-custom",
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "customMetadata" }));
+    }
+
+    public void testBlobPathParameters() {
+        Custom customMetadata = getCustomMetadata();
+        RemoteCustomMetadata remoteObjectForUpload = new RemoteCustomMetadata(
+            customMetadata,
+            "test-custom",
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN)));
+        String expectedPrefix = CUSTOM_METADATA + CUSTOM_DELIMITER + CUSTOM_TYPE;
+        assertThat(params.getFilePrefix(), is(expectedPrefix));
+    }
+
+    public void testGenerateBlobFileName() {
+        Custom customMetadata = getCustomMetadata();
+        RemoteCustomMetadata remoteObjectForUpload = new RemoteCustomMetadata(
+            customMetadata,
+            "test-custom",
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        String expectedPrefix = CUSTOM_METADATA + CUSTOM_DELIMITER + CUSTOM_TYPE;
+        assertThat(nameTokens[0], is(expectedPrefix));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[1]), is(METADATA_VERSION));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[2]), lessThanOrEqualTo(System.currentTimeMillis()));
+        assertThat(nameTokens[3], is(String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)));
+
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        Custom customMetadata = getCustomMetadata();
+        RemoteCustomMetadata remoteObjectForUpload = new RemoteCustomMetadata(
+            customMetadata,
+            "test-custom",
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedWriteableRegistry
+        );
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+            UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+            String expectedPrefix = CUSTOM_METADATA + CUSTOM_DELIMITER + CUSTOM_TYPE;
+            assertThat(uploadedMetadata.getComponent(), is(expectedPrefix));
+            assertThat(uploadedMetadata.getUploadedFilename(), is(remoteObjectForUpload.getFullBlobName()));
+        }
+    }
+
+    public void testSerDe() throws IOException {
+        Custom customMetadata = getCustomMetadata();
+        verifySerDe(customMetadata, IndexGraveyard.TYPE);
+    }
+
+    public void testSerDeForPersistentTasks() throws IOException {
+        Custom customMetadata = getPersistentTasksMetadata();
+        verifySerDe(customMetadata, PersistentTasksCustomMetadata.TYPE);
+    }
+
+    private void verifySerDe(Custom objectToUpload, String objectType) throws IOException {
+        RemoteCustomMetadata remoteObjectForUpload = new RemoteCustomMetadata(
+            objectToUpload,
+            objectType,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            customWritableRegistry()
+        );
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertThat(inputStream.available(), greaterThan(0));
+            Custom readCustomMetadata = remoteObjectForUpload.deserialize(inputStream);
+            assertThat(readCustomMetadata, is(objectToUpload));
+        }
+    }
+
+    private NamedWriteableRegistry customWritableRegistry() {
+        List<Entry> entries = ClusterModule.getNamedWriteables();
+        entries.add(new Entry(PersistentTaskParams.class, TestPersistentTaskParams.PARAM_NAME, TestPersistentTaskParams::new));
+        return new NamedWriteableRegistry(entries);
+    }
+
+    public static Custom getCustomMetadata() {
+        return IndexGraveyard.builder().addTombstone(new Index("test-index", "3q2423")).build();
+    }
+
+    private static Custom getPersistentTasksMetadata() {
+        return PersistentTasksCustomMetadata.builder()
+            .addTask("_task_1", "testTaskName", new TestPersistentTaskParams("task param data"), new Assignment(null, "_reason"))
+            .build();
+    }
+
+    public static class TestPersistentTaskParams implements PersistentTaskParams {
+
+        private static final String PARAM_NAME = "testTaskName";
+
+        private final String data;
+
+        public TestPersistentTaskParams(String data) {
+            this.data = data;
+        }
+
+        public TestPersistentTaskParams(StreamInput in) throws IOException {
+            this(in.readString());
+        }
+
+        @Override
+        public String getWriteableName() {
+            return PARAM_NAME;
+        }
+
+        @Override
+        public Version getMinimalSupportedVersion() {
+            return Version.V_2_13_0;
+        }
+
+        @Override
+        public void writeTo(StreamOutput out) throws IOException {
+            out.writeString(data);
+        }
+
+        @Override
+        public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+            return builder.startObject().field("data_field", data);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            TestPersistentTaskParams that = (TestPersistentTaskParams) o;
+            return Objects.equals(data, that.data);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(data);
+        }
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteDiscoveryNodesTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteDiscoveryNodesTests.java
new file mode 100644
index 0000000000000..1b988ee1f37ec
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteDiscoveryNodesTests.java
@@ -0,0 +1,195 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_EPHEMERAL_PATH_TOKEN;
+import static org.opensearch.gateway.remote.model.RemoteDiscoveryNodes.DISCOVERY_NODES;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteDiscoveryNodesTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long METADATA_VERSION = 3L;
+    private String clusterUUID;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+
+    @Before
+    public void setup() {
+        this.clusterUUID = "test-cluster-uuid";
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+    }
+
+    public void testClusterUUID() {
+        DiscoveryNodes nodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteObjectForUpload = new RemoteDiscoveryNodes(nodes, METADATA_VERSION, clusterUUID, compressor);
+        assertEquals(remoteObjectForUpload.clusterUUID(), clusterUUID);
+
+        RemoteDiscoveryNodes remoteObjectForDownload = new RemoteDiscoveryNodes(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertEquals(remoteObjectForDownload.clusterUUID(), clusterUUID);
+    }
+
+    public void testFullBlobName() {
+        DiscoveryNodes nodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteObjectForUpload = new RemoteDiscoveryNodes(nodes, METADATA_VERSION, clusterUUID, compressor);
+        assertNull(remoteObjectForUpload.getFullBlobName());
+
+        RemoteDiscoveryNodes remoteObjectForDownload = new RemoteDiscoveryNodes(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertEquals(remoteObjectForDownload.getFullBlobName(), TEST_BLOB_NAME);
+    }
+
+    public void testBlobFileName() {
+        DiscoveryNodes nodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteObjectForUpload = new RemoteDiscoveryNodes(nodes, METADATA_VERSION, clusterUUID, compressor);
+        assertNull(remoteObjectForUpload.getBlobFileName());
+
+        RemoteClusterBlocks remoteObjectForDownload = new RemoteClusterBlocks(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertEquals(remoteObjectForDownload.getBlobFileName(), TEST_BLOB_FILE_NAME);
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/discovery-nodes";
+        RemoteDiscoveryNodes remoteObjectForDownload = new RemoteDiscoveryNodes(uploadedFile, clusterUUID, compressor);
+        assertArrayEquals(remoteObjectForDownload.getBlobPathTokens(), new String[] { "user", "local", "opensearch", "discovery-nodes" });
+    }
+
+    public void testBlobPathParameters() {
+        DiscoveryNodes nodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteObjectForUpload = new RemoteDiscoveryNodes(nodes, METADATA_VERSION, clusterUUID, compressor);
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertEquals(params.getPathTokens(), List.of(CLUSTER_STATE_EPHEMERAL_PATH_TOKEN));
+        assertEquals(params.getFilePrefix(), DISCOVERY_NODES);
+    }
+
+    public void testGenerateBlobFileName() {
+        DiscoveryNodes nodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteObjectForUpload = new RemoteDiscoveryNodes(nodes, METADATA_VERSION, clusterUUID, compressor);
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertEquals(nameTokens[0], DISCOVERY_NODES);
+        assertEquals(RemoteStoreUtils.invertLong(nameTokens[1]), METADATA_VERSION);
+        assertTrue(RemoteStoreUtils.invertLong(nameTokens[2]) <= System.currentTimeMillis());
+        assertEquals(nameTokens[3], String.valueOf(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION));
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        DiscoveryNodes nodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteObjectForUpload = new RemoteDiscoveryNodes(nodes, METADATA_VERSION, clusterUUID, compressor);
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+        remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+        assertEquals(uploadedMetadata.getComponent(), DISCOVERY_NODES);
+        assertEquals(uploadedMetadata.getUploadedFilename(), remoteObjectForUpload.getFullBlobName());
+    }
+
+    public void testSerDe() throws IOException {
+        DiscoveryNodes nodes = getDiscoveryNodes();
+        RemoteDiscoveryNodes remoteObjectForUpload = new RemoteDiscoveryNodes(nodes, METADATA_VERSION, clusterUUID, compressor);
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertTrue(inputStream.available() > 0);
+            DiscoveryNodes readDiscoveryNodes = remoteObjectForUpload.deserialize(inputStream);
+            assertEquals(nodes.getSize(), readDiscoveryNodes.getSize());
+            nodes.getNodes().forEach((nodeId, node) -> assertEquals(readDiscoveryNodes.get(nodeId), node));
+            assertEquals(nodes.getClusterManagerNodeId(), readDiscoveryNodes.getClusterManagerNodeId());
+        }
+    }
+
+    public void testExceptionDuringSerialization() throws IOException {
+        DiscoveryNodes nodes = mock(DiscoveryNodes.class);
+        RemoteDiscoveryNodes remoteObjectForUpload = new RemoteDiscoveryNodes(nodes, METADATA_VERSION, clusterUUID, compressor);
+        doThrow(new IOException("mock-exception")).when(nodes).writeToWithAttribute(any());
+        IOException iea = assertThrows(IOException.class, remoteObjectForUpload::serialize);
+    }
+
+    public void testExceptionDuringDeserialize() throws IOException {
+        DiscoveryNodes nodes = mock(DiscoveryNodes.class);
+        InputStream in = mock(InputStream.class);
+        when(in.read(any(byte[].class))).thenThrow(new IOException("mock-exception"));
+        String uploadedFile = "user/local/opensearch/discovery-nodes";
+        RemoteDiscoveryNodes remoteObjectForDownload = new RemoteDiscoveryNodes(uploadedFile, clusterUUID, compressor);
+        IOException ioe = assertThrows(IOException.class, () -> remoteObjectForDownload.deserialize(in));
+    }
+
+    public static DiscoveryNodes getDiscoveryNodes() {
+        return DiscoveryNodes.builder()
+            .add(
+                new DiscoveryNode(
+                    "name_" + 1,
+                    "node_" + 1,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    new HashSet<>(randomSubsetOf(DiscoveryNodeRole.BUILT_IN_ROLES)),
+                    Version.CURRENT
+                )
+            )
+            .add(
+                new DiscoveryNode(
+                    "name_" + 2,
+                    "node_" + 2,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    new HashSet<>(randomSubsetOf(DiscoveryNodeRole.BUILT_IN_ROLES)),
+                    Version.CURRENT
+                )
+            )
+            .add(
+                new DiscoveryNode(
+                    "name_" + 3,
+                    "node_" + 3,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    new HashSet<>(randomSubsetOf(DiscoveryNodeRole.BUILT_IN_ROLES)),
+                    Version.CURRENT
+                )
+            )
+            .localNodeId("name_1")
+            .clusterManagerNodeId("name_2")
+            .build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteGlobalMetadataTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteGlobalMetadataTests.java
new file mode 100644
index 0000000000000..23de485357547
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteGlobalMetadataTests.java
@@ -0,0 +1,209 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.coordination.CoordinationMetadata;
+import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfigExclusion;
+import org.opensearch.cluster.coordination.CoordinationMetadata.VotingConfiguration;
+import org.opensearch.cluster.metadata.IndexTemplateMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.model.RemoteGlobalMetadata.GLOBAL_METADATA_FORMAT;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteGlobalMetadataTests extends OpenSearchTestCase {
+
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long TERM = 3L;
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        RemoteGlobalMetadata remoteObjectForDownload = new RemoteGlobalMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.clusterUUID(), is(clusterUUID));
+    }
+
+    public void testFullBlobName() {
+        RemoteGlobalMetadata remoteObjectForDownload = new RemoteGlobalMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        RemoteGlobalMetadata remoteObjectForDownload = new RemoteGlobalMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/globalMetadata";
+        RemoteGlobalMetadata remoteObjectForDownload = new RemoteGlobalMetadata(
+            uploadedFile,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "globalMetadata" }));
+    }
+
+    public void testBlobPathParameters() {
+        RemoteGlobalMetadata remoteObjectForDownload = new RemoteGlobalMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(UnsupportedOperationException.class, remoteObjectForDownload::getBlobPathParameters);
+    }
+
+    public void testGenerateBlobFileName() {
+        RemoteGlobalMetadata remoteObjectForDownload = new RemoteGlobalMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(UnsupportedOperationException.class, remoteObjectForDownload::generateBlobFileName);
+    }
+
+    public void testGetUploadedMetadata() {
+        RemoteGlobalMetadata remoteObjectForDownload = new RemoteGlobalMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(UnsupportedOperationException.class, remoteObjectForDownload::getUploadedMetadata);
+    }
+
+    public void testSerDe() throws IOException {
+        Metadata globalMetadata = getGlobalMetadata();
+        try (
+            InputStream inputStream = GLOBAL_METADATA_FORMAT.serialize(
+                globalMetadata,
+                TEST_BLOB_FILE_NAME,
+                compressor,
+                RemoteClusterStateUtils.FORMAT_PARAMS
+            ).streamInput()
+        ) {
+            RemoteGlobalMetadata remoteObjectForDownload = new RemoteGlobalMetadata(
+                TEST_BLOB_NAME,
+                clusterUUID,
+                compressor,
+                namedXContentRegistry
+            );
+            assertThat(inputStream.available(), greaterThan(0));
+            Metadata readglobalMetadata = remoteObjectForDownload.deserialize(inputStream);
+            assertTrue(Metadata.isGlobalStateEquals(readglobalMetadata, globalMetadata));
+        }
+    }
+
+    public static Metadata getGlobalMetadata() {
+        return Metadata.builder()
+            .templates(
+                TemplatesMetadata.builder()
+                    .put(
+                        IndexTemplateMetadata.builder("template" + randomAlphaOfLength(3))
+                            .patterns(Arrays.asList("bar-*", "foo-*"))
+                            .settings(
+                                Settings.builder()
+                                    .put("index.random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5))
+                                    .build()
+                            )
+                            .build()
+                    )
+                    .build()
+            )
+            .coordinationMetadata(
+                CoordinationMetadata.builder()
+                    .term(TERM)
+                    .lastAcceptedConfiguration(new VotingConfiguration(Set.of("node1")))
+                    .lastCommittedConfiguration(new VotingConfiguration(Set.of("node1")))
+                    .addVotingConfigExclusion(new VotingConfigExclusion("node2", " node-2"))
+                    .build()
+            )
+            .build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteHashesOfConsistentSettingsTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteHashesOfConsistentSettingsTests.java
new file mode 100644
index 0000000000000..b931f24f98631
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteHashesOfConsistentSettingsTests.java
@@ -0,0 +1,193 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.metadata.DiffableStringMap;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.RemoteClusterStateAttributesManager.CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN;
+import static org.opensearch.gateway.remote.model.RemoteHashesOfConsistentSettings.HASHES_OF_CONSISTENT_SETTINGS;
+
+public class RemoteHashesOfConsistentSettingsTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long METADATA_VERSION = 3L;
+    private String clusterUUID;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+
+    @Before
+    public void setup() {
+        this.clusterUUID = "test-cluster-uuid";
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+    }
+
+    public void testClusterUUID() {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        RemoteHashesOfConsistentSettings remoteObjectForUpload = new RemoteHashesOfConsistentSettings(
+            hashesOfConsistentSettings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor
+        );
+        assertEquals(remoteObjectForUpload.clusterUUID(), clusterUUID);
+
+        RemoteHashesOfConsistentSettings remoteObjectForDownload = new RemoteHashesOfConsistentSettings(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor
+        );
+        assertEquals(remoteObjectForDownload.clusterUUID(), clusterUUID);
+    }
+
+    public void testFullBlobName() {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        RemoteHashesOfConsistentSettings remoteObjectForUpload = new RemoteHashesOfConsistentSettings(
+            hashesOfConsistentSettings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor
+        );
+        assertNull(remoteObjectForUpload.getFullBlobName());
+
+        RemoteHashesOfConsistentSettings remoteObjectForDownload = new RemoteHashesOfConsistentSettings(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor
+        );
+        assertEquals(remoteObjectForDownload.getFullBlobName(), TEST_BLOB_NAME);
+    }
+
+    public void testBlobFileName() {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        RemoteHashesOfConsistentSettings remoteObjectForUpload = new RemoteHashesOfConsistentSettings(
+            hashesOfConsistentSettings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor
+        );
+        assertNull(remoteObjectForUpload.getBlobFileName());
+
+        RemoteHashesOfConsistentSettings remoteObjectForDownload = new RemoteHashesOfConsistentSettings(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor
+        );
+        assertEquals(remoteObjectForDownload.getBlobFileName(), TEST_BLOB_FILE_NAME);
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/hashes-of-consistent-settings";
+        RemoteHashesOfConsistentSettings remoteObjectForDownload = new RemoteHashesOfConsistentSettings(
+            uploadedFile,
+            clusterUUID,
+            compressor
+        );
+        assertArrayEquals(
+            remoteObjectForDownload.getBlobPathTokens(),
+            new String[] { "user", "local", "opensearch", "hashes-of-consistent-settings" }
+        );
+    }
+
+    public void testBlobPathParameters() {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        RemoteHashesOfConsistentSettings remoteObjectForUpload = new RemoteHashesOfConsistentSettings(
+            hashesOfConsistentSettings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor
+        );
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertEquals(params.getPathTokens(), List.of(GLOBAL_METADATA_PATH_TOKEN));
+        assertEquals(params.getFilePrefix(), HASHES_OF_CONSISTENT_SETTINGS);
+    }
+
+    public void testGenerateBlobFileName() {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        RemoteHashesOfConsistentSettings remoteObjectForUpload = new RemoteHashesOfConsistentSettings(
+            hashesOfConsistentSettings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor
+        );
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertEquals(nameTokens[0], HASHES_OF_CONSISTENT_SETTINGS);
+        assertEquals(RemoteStoreUtils.invertLong(nameTokens[1]), METADATA_VERSION);
+        assertTrue(RemoteStoreUtils.invertLong(nameTokens[2]) <= System.currentTimeMillis());
+        assertEquals(nameTokens[3], String.valueOf(CLUSTER_STATE_ATTRIBUTES_CURRENT_CODEC_VERSION));
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        RemoteHashesOfConsistentSettings remoteObjectForUpload = new RemoteHashesOfConsistentSettings(
+            hashesOfConsistentSettings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor
+        );
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+        remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+        assertEquals(uploadedMetadata.getComponent(), HASHES_OF_CONSISTENT_SETTINGS);
+        assertEquals(uploadedMetadata.getUploadedFilename(), remoteObjectForUpload.getFullBlobName());
+    }
+
+    public void testSerDe() throws IOException {
+        DiffableStringMap hashesOfConsistentSettings = getHashesOfConsistentSettings();
+        RemoteHashesOfConsistentSettings remoteObjectForUpload = new RemoteHashesOfConsistentSettings(
+            hashesOfConsistentSettings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor
+        );
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertTrue(inputStream.available() > 0);
+            DiffableStringMap readHashesOfConsistentSettings = remoteObjectForUpload.deserialize(inputStream);
+            assertEquals(hashesOfConsistentSettings.entrySet(), readHashesOfConsistentSettings.entrySet());
+        }
+    }
+
+    public static DiffableStringMap getHashesOfConsistentSettings() {
+        Map<String, String> hashesOfConsistentSettings = new HashMap<>();
+        hashesOfConsistentSettings.put("secure-setting-key", "secure-setting-value");
+        return new DiffableStringMap(hashesOfConsistentSettings);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteIndexMetadataTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteIndexMetadataTests.java
new file mode 100644
index 0000000000000..7f9c3fdbae91b
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteIndexMetadataTests.java
@@ -0,0 +1,186 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.model.RemoteIndexMetadata.INDEX;
+import static org.opensearch.gateway.remote.model.RemoteIndexMetadata.INDEX_METADATA_CURRENT_CODEC_VERSION;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteIndexMetadataTests extends OpenSearchTestCase {
+
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long VERSION = 5L;
+
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        this.clusterName = "test-cluster-name";
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        RemoteIndexMetadata remoteObjectForUpload = new RemoteIndexMetadata(indexMetadata, clusterUUID, compressor, namedXContentRegistry);
+        assertThat(remoteObjectForUpload.clusterUUID(), is(clusterUUID));
+
+        RemoteIndexMetadata remoteObjectForDownload = new RemoteIndexMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.clusterUUID(), is(clusterUUID));
+    }
+
+    public void testFullBlobName() {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        RemoteIndexMetadata remoteObjectForUpload = new RemoteIndexMetadata(indexMetadata, clusterUUID, compressor, namedXContentRegistry);
+        assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+        RemoteIndexMetadata remoteObjectForDownload = new RemoteIndexMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        RemoteIndexMetadata remoteObjectForUpload = new RemoteIndexMetadata(indexMetadata, clusterUUID, compressor, namedXContentRegistry);
+        assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+        RemoteIndexMetadata remoteObjectForDownload = new RemoteIndexMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathParameters() {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        RemoteIndexMetadata remoteObjectForUpload = new RemoteIndexMetadata(indexMetadata, clusterUUID, compressor, namedXContentRegistry);
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(INDEX, indexMetadata.getIndexUUID())));
+        assertThat(params.getFilePrefix(), is("metadata"));
+    }
+
+    public void testGenerateBlobFileName() {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        RemoteIndexMetadata remoteObjectForUpload = new RemoteIndexMetadata(indexMetadata, clusterUUID, compressor, namedXContentRegistry);
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertThat(nameTokens[0], is("metadata"));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[1]), is(VERSION));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[2]), lessThanOrEqualTo(System.currentTimeMillis()));
+        assertThat(nameTokens[3], is(String.valueOf(INDEX_METADATA_CURRENT_CODEC_VERSION)));
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        RemoteIndexMetadata remoteObjectForUpload = new RemoteIndexMetadata(indexMetadata, clusterUUID, compressor, namedXContentRegistry);
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+        remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+        UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+        assertEquals(uploadedMetadata.getUploadedFilename(), remoteObjectForUpload.getFullBlobName());
+    }
+
+    public void testSerDe() throws IOException {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        RemoteIndexMetadata remoteObjectForUpload = new RemoteIndexMetadata(indexMetadata, clusterUUID, compressor, namedXContentRegistry);
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            assertThat(inputStream.available(), greaterThan(0));
+            IndexMetadata readIndexMetadata = remoteObjectForUpload.deserialize(inputStream);
+            assertThat(readIndexMetadata, is(indexMetadata));
+        }
+    }
+
+    private IndexMetadata getIndexMetadata() {
+        final Index index = new Index("test-index", "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+        return new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .version(VERSION)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemotePersistentSettingsMetadataTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemotePersistentSettingsMetadataTests.java
new file mode 100644
index 0000000000000..5e4d5d66ca1b7
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemotePersistentSettingsMetadataTests.java
@@ -0,0 +1,230 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemotePersistentSettingsMetadataTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long METADATA_VERSION = 3L;
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        Settings settings = getSettings();
+        RemotePersistentSettingsMetadata remoteObjectForUpload = new RemotePersistentSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.clusterUUID(), is(clusterUUID));
+
+        RemotePersistentSettingsMetadata remoteObjectForDownload = new RemotePersistentSettingsMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.clusterUUID(), is(clusterUUID));
+    }
+
+    public void testFullBlobName() {
+        Settings settings = getSettings();
+        RemotePersistentSettingsMetadata remoteObjectForUpload = new RemotePersistentSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+        RemotePersistentSettingsMetadata remoteObjectForDownload = new RemotePersistentSettingsMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        Settings settings = getSettings();
+        RemotePersistentSettingsMetadata remoteObjectForUpload = new RemotePersistentSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+        RemotePersistentSettingsMetadata remoteObjectForDownload = new RemotePersistentSettingsMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/settings";
+        RemotePersistentSettingsMetadata remoteObjectForDownload = new RemotePersistentSettingsMetadata(
+            uploadedFile,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "settings" }));
+    }
+
+    public void testBlobPathParameters() {
+        Settings settings = getSettings();
+        RemotePersistentSettingsMetadata remoteObjectForUpload = new RemotePersistentSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN)));
+        assertThat(params.getFilePrefix(), is(RemotePersistentSettingsMetadata.SETTING_METADATA));
+    }
+
+    public void testGenerateBlobFileName() {
+        Settings settings = getSettings();
+        RemotePersistentSettingsMetadata remoteObjectForUpload = new RemotePersistentSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertThat(nameTokens[0], is(RemotePersistentSettingsMetadata.SETTING_METADATA));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[1]), is(METADATA_VERSION));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[2]), lessThanOrEqualTo(System.currentTimeMillis()));
+        assertThat(nameTokens[3], is(String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)));
+
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        Settings settings = getSettings();
+        RemotePersistentSettingsMetadata remoteObjectForUpload = new RemotePersistentSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+            UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+            assertThat(uploadedMetadata.getComponent(), is(RemotePersistentSettingsMetadata.SETTING_METADATA));
+            assertThat(uploadedMetadata.getUploadedFilename(), is(remoteObjectForUpload.getFullBlobName()));
+        }
+    }
+
+    public void testSerDe() throws IOException {
+        Settings settings = getSettings();
+        RemotePersistentSettingsMetadata remoteObjectForUpload = new RemotePersistentSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertThat(inputStream.available(), greaterThan(0));
+            Settings readsettings = remoteObjectForUpload.deserialize(inputStream);
+            assertThat(readsettings, is(settings));
+        }
+    }
+
+    public static Settings getSettings() {
+        return Settings.builder().put("random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStoreTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStoreTests.java
new file mode 100644
index 0000000000000..a164408036cf6
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteRoutingTableBlobStoreTests.java
@@ -0,0 +1,133 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.CLUSTER_STATE_PATH_TOKEN;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_TABLE;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.HASHED_PREFIX;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteRoutingTableBlobStoreTests extends OpenSearchTestCase {
+
+    private RemoteRoutingTableBlobStore<IndexRoutingTable, RemoteIndexRoutingTable> remoteIndexRoutingTableStore;
+    ClusterSettings clusterSettings;
+    ThreadPool threadPool;
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        BlobStoreTransferService blobStoreTransferService = mock(BlobStoreTransferService.class);
+        BlobStoreRepository blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("base-path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+
+        threadPool = new TestThreadPool(getClass().getName());
+        this.remoteIndexRoutingTableStore = new RemoteRoutingTableBlobStore<>(
+            blobStoreTransferService,
+            blobStoreRepository,
+            "test-cluster",
+            threadPool,
+            ThreadPool.Names.REMOTE_STATE_READ,
+            clusterSettings
+        );
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+
+    }
+
+    public void testRemoteRoutingTablePathTypeSetting() {
+        // Assert the default is HASHED_PREFIX
+        assertEquals(HASHED_PREFIX.toString(), remoteIndexRoutingTableStore.getPathTypeSetting().toString());
+
+        Settings newSettings = Settings.builder()
+            .put("cluster.remote_store.routing_table.path_type", RemoteStoreEnums.PathType.FIXED.toString())
+            .build();
+        clusterSettings.applySettings(newSettings);
+        assertEquals(RemoteStoreEnums.PathType.FIXED.toString(), remoteIndexRoutingTableStore.getPathTypeSetting().toString());
+    }
+
+    public void testRemoteRoutingTableHashAlgoSetting() {
+        // Assert the default is FNV_1A_BASE64
+        assertEquals(FNV_1A_BASE64.toString(), remoteIndexRoutingTableStore.getPathHashAlgoSetting().toString());
+
+        Settings newSettings = Settings.builder()
+            .put("cluster.remote_store.routing_table.path_hash_algo", RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1.toString())
+            .build();
+        clusterSettings.applySettings(newSettings);
+        assertEquals(
+            RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1.toString(),
+            remoteIndexRoutingTableStore.getPathHashAlgoSetting().toString()
+        );
+    }
+
+    public void testGetBlobPathForUpload() {
+
+        Index index = new Index("test-idx", "index-uuid");
+        Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+
+        IndexMetadata indexMetadata = new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+
+        IndexRoutingTable indexRoutingTable = new IndexRoutingTable.Builder(index).initializeAsNew(indexMetadata).build();
+
+        RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+            indexRoutingTable,
+            "cluster-uuid",
+            new DeflateCompressor(),
+            2L,
+            3L
+        );
+        BlobPath blobPath = remoteIndexRoutingTableStore.getBlobPathForUpload(remoteObjectForUpload);
+        BlobPath expectedPath = HASHED_PREFIX.path(
+            RemoteStorePathStrategy.BasePathInput.builder()
+                .basePath(
+                    new BlobPath().add("base-path")
+                        .add(RemoteClusterStateUtils.encodeString("test-cluster"))
+                        .add(CLUSTER_STATE_PATH_TOKEN)
+                        .add("cluster-uuid")
+                        .add(INDEX_ROUTING_TABLE)
+                )
+                .indexUUID(index.getUUID())
+                .build(),
+            FNV_1A_BASE64
+        );
+        assertEquals(expectedPath, blobPath);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteTemplatesMetadataTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteTemplatesMetadataTests.java
new file mode 100644
index 0000000000000..ca978654c8825
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteTemplatesMetadataTests.java
@@ -0,0 +1,252 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.metadata.IndexTemplateMetadata;
+import org.opensearch.cluster.metadata.TemplatesMetadata;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest.UploadedMetadata;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteTemplatesMetadataTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long METADATA_VERSION = 3L;
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        TemplatesMetadata settings = getTemplatesMetadata();
+        RemoteTemplatesMetadata remoteObjectForUpload = new RemoteTemplatesMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.clusterUUID(), is(clusterUUID));
+
+        RemoteTemplatesMetadata remoteObjectForDownload = new RemoteTemplatesMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.clusterUUID(), is(clusterUUID));
+    }
+
+    public void testFullBlobName() {
+        TemplatesMetadata settings = getTemplatesMetadata();
+        RemoteTemplatesMetadata remoteObjectForUpload = new RemoteTemplatesMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+        RemoteTemplatesMetadata remoteObjectForDownload = new RemoteTemplatesMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        TemplatesMetadata settings = getTemplatesMetadata();
+        RemoteTemplatesMetadata remoteObjectForUpload = new RemoteTemplatesMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+        RemoteTemplatesMetadata remoteObjectForDownload = new RemoteTemplatesMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/settings";
+        RemoteTemplatesMetadata remoteObjectForDownload = new RemoteTemplatesMetadata(
+            uploadedFile,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "settings" }));
+    }
+
+    public void testBlobPathParameters() {
+        TemplatesMetadata settings = getTemplatesMetadata();
+        RemoteTemplatesMetadata remoteObjectForUpload = new RemoteTemplatesMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN)));
+        assertThat(params.getFilePrefix(), is(RemoteTemplatesMetadata.TEMPLATES_METADATA));
+    }
+
+    public void testGenerateBlobFileName() {
+        TemplatesMetadata settings = getTemplatesMetadata();
+        RemoteTemplatesMetadata remoteObjectForUpload = new RemoteTemplatesMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertThat(nameTokens[0], is(RemoteTemplatesMetadata.TEMPLATES_METADATA));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[1]), is(METADATA_VERSION));
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[2]), lessThanOrEqualTo(System.currentTimeMillis()));
+        assertThat(nameTokens[3], is(String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION)));
+
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        TemplatesMetadata settings = getTemplatesMetadata();
+        RemoteTemplatesMetadata remoteObjectForUpload = new RemoteTemplatesMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+            UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+            assertThat(uploadedMetadata.getComponent(), is(RemoteTemplatesMetadata.TEMPLATES_METADATA));
+            assertThat(uploadedMetadata.getUploadedFilename(), is(remoteObjectForUpload.getFullBlobName()));
+        }
+    }
+
+    public void testSerDe() throws IOException {
+        TemplatesMetadata settings = getTemplatesMetadata();
+        RemoteTemplatesMetadata remoteObjectForUpload = new RemoteTemplatesMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertThat(inputStream.available(), greaterThan(0));
+            TemplatesMetadata readsettings = remoteObjectForUpload.deserialize(inputStream);
+            assertThat(readsettings, is(settings));
+        }
+    }
+
+    public static TemplatesMetadata getTemplatesMetadata() {
+        return TemplatesMetadata.builder()
+            .put(
+                IndexTemplateMetadata.builder("template" + randomAlphaOfLength(3))
+                    .order(1234)
+                    .patterns(Arrays.asList("bar-*", "foo-*"))
+                    .settings(
+                        Settings.builder().put("index.random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build()
+                    )
+                    .build()
+            )
+            .put(
+                IndexTemplateMetadata.builder("template" + randomAlphaOfLength(3))
+                    .order(5678)
+                    .patterns(Arrays.asList("test-*"))
+                    .settings(
+                        Settings.builder().put("index.random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build()
+                    )
+                    .build()
+            )
+            .build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/model/RemoteTransientSettingsMetadataTests.java b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteTransientSettingsMetadataTests.java
new file mode 100644
index 0000000000000..4061ab4a6b5ef
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/model/RemoteTransientSettingsMetadataTests.java
@@ -0,0 +1,200 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.model;
+
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.network.NetworkModule;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.indices.IndicesModule;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.stream.Collectors.toList;
+import static org.opensearch.gateway.remote.RemoteClusterStateUtils.GLOBAL_METADATA_CURRENT_CODEC_VERSION;
+import static org.opensearch.gateway.remote.model.RemoteTransientSettingsMetadata.TRANSIENT_SETTING_METADATA;
+
+public class RemoteTransientSettingsMetadataTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long METADATA_VERSION = 3L;
+    private String clusterUUID;
+    private Compressor compressor;
+    private NamedXContentRegistry namedXContentRegistry;
+
+    @Before
+    public void setup() {
+        this.clusterUUID = "test-cluster-uuid";
+        compressor = new NoneCompressor();
+        namedXContentRegistry = new NamedXContentRegistry(
+            Stream.of(
+                NetworkModule.getNamedXContents().stream(),
+                IndicesModule.getNamedXContents().stream(),
+                ClusterModule.getNamedXWriteables().stream()
+            ).flatMap(Function.identity()).collect(toList())
+        );
+    }
+
+    public void testClusterUUID() {
+        Settings settings = getSettings();
+        RemoteTransientSettingsMetadata remoteObjectForUpload = new RemoteTransientSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertEquals(remoteObjectForUpload.clusterUUID(), clusterUUID);
+
+        RemoteTransientSettingsMetadata remoteObjectForDownload = new RemoteTransientSettingsMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertEquals(remoteObjectForDownload.clusterUUID(), clusterUUID);
+    }
+
+    public void testFullBlobName() {
+        Settings settings = getSettings();
+        RemoteTransientSettingsMetadata remoteObjectForUpload = new RemoteTransientSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertNull(remoteObjectForUpload.getFullBlobName());
+
+        RemoteTransientSettingsMetadata remoteObjectForDownload = new RemoteTransientSettingsMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertEquals(remoteObjectForDownload.getFullBlobName(), TEST_BLOB_NAME);
+    }
+
+    public void testBlobFileName() {
+        Settings settings = getSettings();
+        RemoteTransientSettingsMetadata remoteObjectForUpload = new RemoteTransientSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertNull(remoteObjectForUpload.getBlobFileName());
+
+        RemoteTransientSettingsMetadata remoteObjectForDownload = new RemoteTransientSettingsMetadata(
+            TEST_BLOB_NAME,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertEquals(remoteObjectForDownload.getBlobFileName(), TEST_BLOB_FILE_NAME);
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/settings";
+        RemoteTransientSettingsMetadata remoteObjectForDownload = new RemoteTransientSettingsMetadata(
+            uploadedFile,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertArrayEquals(remoteObjectForDownload.getBlobPathTokens(), new String[] { "user", "local", "opensearch", "settings" });
+    }
+
+    public void testBlobPathParameters() {
+        Settings settings = getSettings();
+        RemoteTransientSettingsMetadata remoteObjectForUpload = new RemoteTransientSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+        assertEquals(params.getPathTokens(), List.of(RemoteClusterStateUtils.GLOBAL_METADATA_PATH_TOKEN));
+        assertEquals(params.getFilePrefix(), TRANSIENT_SETTING_METADATA);
+    }
+
+    public void testGenerateBlobFileName() {
+        Settings settings = getSettings();
+        RemoteTransientSettingsMetadata remoteObjectForUpload = new RemoteTransientSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        String blobFileName = remoteObjectForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+        assertEquals(nameTokens[0], TRANSIENT_SETTING_METADATA);
+        assertEquals(RemoteStoreUtils.invertLong(nameTokens[1]), METADATA_VERSION);
+        assertTrue(RemoteStoreUtils.invertLong(nameTokens[2]) <= System.currentTimeMillis());
+        assertEquals(nameTokens[3], String.valueOf(GLOBAL_METADATA_CURRENT_CODEC_VERSION));
+
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        Settings settings = getSettings();
+        RemoteTransientSettingsMetadata remoteObjectForUpload = new RemoteTransientSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+            ClusterMetadataManifest.UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+            assertEquals(uploadedMetadata.getComponent(), TRANSIENT_SETTING_METADATA);
+            assertEquals(uploadedMetadata.getUploadedFilename(), remoteObjectForUpload.getFullBlobName());
+        }
+    }
+
+    public void testSerDe() throws IOException {
+        Settings settings = getSettings();
+        RemoteTransientSettingsMetadata remoteObjectForUpload = new RemoteTransientSettingsMetadata(
+            settings,
+            METADATA_VERSION,
+            clusterUUID,
+            compressor,
+            namedXContentRegistry
+        );
+        try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+            remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+            assertTrue(inputStream.available() > 0);
+            Settings readsettings = remoteObjectForUpload.deserialize(inputStream);
+            assertEquals(readsettings, settings);
+        }
+    }
+
+    private Settings getSettings() {
+        return Settings.builder().put("random_index_setting_" + randomAlphaOfLength(3), randomAlphaOfLength(5)).build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableDiffTests.java b/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableDiffTests.java
new file mode 100644
index 0000000000000..5dcc3127f2f5d
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableDiffTests.java
@@ -0,0 +1,263 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.routingtable;
+
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.Diff;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.RoutingTableIncrementalDiff;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.RemoteClusterStateServiceTests.generateClusterStateWithOneIndex;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_FILE;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_METADATA_PREFIX;
+import static org.opensearch.gateway.remote.routingtable.RemoteRoutingTableDiff.ROUTING_TABLE_DIFF_PATH_TOKEN;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteIndexRoutingTableDiffTests extends OpenSearchTestCase {
+
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long STATE_VERSION = 3L;
+    private static final long STATE_TERM = 2L;
+    private String clusterUUID;
+    private BlobStoreRepository blobStoreRepository;
+    private BlobStoreTransferService blobStoreTransferService;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+
+    private String clusterName;
+    private NamedWriteableRegistry namedWriteableRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedWriteableRegistry = writableRegistry();
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, 5, 1, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, 5, 2, true).build();
+
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(
+            previousState.getRoutingTable(),
+            currentState.getRoutingTable()
+        );
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+        assertEquals(remoteDiffForUpload.clusterUUID(), clusterUUID);
+
+        RemoteRoutingTableDiff remoteDiffForDownload = new RemoteRoutingTableDiff(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertEquals(remoteDiffForDownload.clusterUUID(), clusterUUID);
+    }
+
+    public void testFullBlobName() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, 5, 1, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, 5, 2, true).build();
+
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(
+            previousState.getRoutingTable(),
+            currentState.getRoutingTable()
+        );
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+        assertThat(remoteDiffForUpload.getFullBlobName(), nullValue());
+
+        RemoteRoutingTableDiff remoteDiffForDownload = new RemoteRoutingTableDiff(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertThat(remoteDiffForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+    }
+
+    public void testBlobFileName() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, 5, 1, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, 5, 2, true).build();
+
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(
+            previousState.getRoutingTable(),
+            currentState.getRoutingTable()
+        );
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+        assertThat(remoteDiffForUpload.getBlobFileName(), nullValue());
+
+        RemoteRoutingTableDiff remoteDiffForDownload = new RemoteRoutingTableDiff(TEST_BLOB_NAME, clusterUUID, compressor);
+        assertThat(remoteDiffForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+    }
+
+    public void testBlobPathParameters() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, 5, 1, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, 5, 2, true).build();
+
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(
+            previousState.getRoutingTable(),
+            currentState.getRoutingTable()
+        );
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+        assertThat(remoteDiffForUpload.getBlobFileName(), nullValue());
+
+        BlobPathParameters params = remoteDiffForUpload.getBlobPathParameters();
+        assertThat(params.getPathTokens(), is(List.of(ROUTING_TABLE_DIFF_PATH_TOKEN)));
+        String expectedPrefix = ROUTING_TABLE_DIFF_METADATA_PREFIX;
+        assertThat(params.getFilePrefix(), is(expectedPrefix));
+    }
+
+    public void testGenerateBlobFileName() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, 5, 1, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, 5, 2, true).build();
+
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(
+            previousState.getRoutingTable(),
+            currentState.getRoutingTable()
+        );
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+
+        String blobFileName = remoteDiffForUpload.generateBlobFileName();
+        String[] nameTokens = blobFileName.split("__");
+        assertEquals(ROUTING_TABLE_DIFF_METADATA_PREFIX, nameTokens[0]);
+        assertEquals(RemoteStoreUtils.invertLong(STATE_TERM), nameTokens[1]);
+        assertEquals(RemoteStoreUtils.invertLong(STATE_VERSION), nameTokens[2]);
+        assertThat(RemoteStoreUtils.invertLong(nameTokens[3]), lessThanOrEqualTo(System.currentTimeMillis()));
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, 5, 1, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, 5, 2, true).build();
+
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(
+            previousState.getRoutingTable(),
+            currentState.getRoutingTable()
+        );
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+
+        remoteDiffForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+        ClusterMetadataManifest.UploadedMetadata uploadedMetadataAttribute = remoteDiffForUpload.getUploadedMetadata();
+        assertEquals(ROUTING_TABLE_DIFF_FILE, uploadedMetadataAttribute.getComponent());
+    }
+
+    public void testStreamOperations() throws IOException {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+
+        ClusterState previousState = generateClusterStateWithOneIndex(indexName, numberOfShards, numberOfReplicas, false).build();
+        ClusterState currentState = generateClusterStateWithOneIndex(indexName, numberOfShards, numberOfReplicas + 1, true).build();
+
+        RoutingTableIncrementalDiff routingTableIncrementalDiff = new RoutingTableIncrementalDiff(
+            previousState.getRoutingTable(),
+            currentState.getRoutingTable()
+        );
+
+        RemoteRoutingTableDiff remoteDiffForUpload = new RemoteRoutingTableDiff(
+            routingTableIncrementalDiff,
+            clusterUUID,
+            compressor,
+            STATE_TERM,
+            STATE_VERSION
+        );
+
+        // Serialize the remote diff
+        InputStream inputStream = remoteDiffForUpload.serialize();
+
+        // Create a new instance for deserialization
+        RemoteRoutingTableDiff remoteDiffForDownload = new RemoteRoutingTableDiff(TEST_BLOB_NAME, clusterUUID, compressor);
+
+        // Deserialize the remote diff
+        Diff<RoutingTable> deserializedDiff = remoteDiffForDownload.deserialize(inputStream);
+
+        // Assert that the indices routing table created from routingTableIncrementalDiff and deserializedDiff is equal
+        assertEquals(
+            routingTableIncrementalDiff.apply(previousState.getRoutingTable()).getIndicesRouting(),
+            deserializedDiff.apply(previousState.getRoutingTable()).getIndicesRouting()
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableTests.java b/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableTests.java
new file mode 100644
index 0000000000000..29d4ffa978851
--- /dev/null
+++ b/server/src/test/java/org/opensearch/gateway/remote/routingtable/RemoteIndexRoutingTableTests.java
@@ -0,0 +1,320 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.gateway.remote.routingtable;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.remote.BlobPathParameters;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.io.stream.NamedWriteableRegistry;
+import org.opensearch.core.compress.Compressor;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.gateway.remote.ClusterMetadataManifest;
+import org.opensearch.gateway.remote.RemoteClusterStateUtils;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.translog.transfer.BlobStoreTransferService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_FILE;
+import static org.opensearch.gateway.remote.routingtable.RemoteIndexRoutingTable.INDEX_ROUTING_METADATA_PREFIX;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class RemoteIndexRoutingTableTests extends OpenSearchTestCase {
+
+    private static final String TEST_BLOB_NAME = "/test-path/test-blob-name";
+    private static final String TEST_BLOB_PATH = "test-path";
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final String INDEX_ROUTING_TABLE_TYPE = "test-index-routing-table";
+    private static final long STATE_VERSION = 3L;
+    private static final long STATE_TERM = 2L;
+    private String clusterUUID;
+    private BlobStoreTransferService blobStoreTransferService;
+    private BlobStoreRepository blobStoreRepository;
+    private String clusterName;
+    private ClusterSettings clusterSettings;
+    private Compressor compressor;
+    private NamedWriteableRegistry namedWriteableRegistry;
+    private final ThreadPool threadPool = new TestThreadPool(getClass().getName());
+
+    @Before
+    public void setup() {
+        clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        this.clusterUUID = "test-cluster-uuid";
+        this.blobStoreTransferService = mock(BlobStoreTransferService.class);
+        this.blobStoreRepository = mock(BlobStoreRepository.class);
+        BlobPath blobPath = new BlobPath().add("/path");
+        when(blobStoreRepository.basePath()).thenReturn(blobPath);
+        when(blobStoreRepository.getCompressor()).thenReturn(new DeflateCompressor());
+        compressor = new NoneCompressor();
+        namedWriteableRegistry = writableRegistry();
+        this.clusterName = "test-cluster-name";
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testClusterUUID() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+            assertEquals(remoteObjectForUpload.clusterUUID(), clusterUUID);
+
+            RemoteIndexRoutingTable remoteObjectForDownload = new RemoteIndexRoutingTable(TEST_BLOB_NAME, clusterUUID, compressor);
+            assertEquals(remoteObjectForDownload.clusterUUID(), clusterUUID);
+        });
+    }
+
+    public void testFullBlobName() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+            assertThat(remoteObjectForUpload.getFullBlobName(), nullValue());
+
+            RemoteIndexRoutingTable remoteObjectForDownload = new RemoteIndexRoutingTable(TEST_BLOB_NAME, clusterUUID, compressor);
+            assertThat(remoteObjectForDownload.getFullBlobName(), is(TEST_BLOB_NAME));
+        });
+    }
+
+    public void testBlobFileName() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+            assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+            RemoteIndexRoutingTable remoteObjectForDownload = new RemoteIndexRoutingTable(TEST_BLOB_NAME, clusterUUID, compressor);
+            assertThat(remoteObjectForDownload.getBlobFileName(), is(TEST_BLOB_FILE_NAME));
+        });
+    }
+
+    public void testBlobPathTokens() {
+        String uploadedFile = "user/local/opensearch/routingTable";
+        RemoteIndexRoutingTable remoteObjectForDownload = new RemoteIndexRoutingTable(uploadedFile, clusterUUID, compressor);
+        assertThat(remoteObjectForDownload.getBlobPathTokens(), is(new String[] { "user", "local", "opensearch", "routingTable" }));
+    }
+
+    public void testBlobPathParameters() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+            assertThat(remoteObjectForUpload.getBlobFileName(), nullValue());
+
+            BlobPathParameters params = remoteObjectForUpload.getBlobPathParameters();
+            assertThat(params.getPathTokens(), is(List.of(indexRoutingTable.getIndex().getUUID())));
+            String expectedPrefix = INDEX_ROUTING_FILE;
+            assertThat(params.getFilePrefix(), is(expectedPrefix));
+        });
+    }
+
+    public void testGenerateBlobFileName() {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+
+            String blobFileName = remoteObjectForUpload.generateBlobFileName();
+            String[] nameTokens = blobFileName.split(RemoteClusterStateUtils.DELIMITER);
+            assertEquals(nameTokens[0], INDEX_ROUTING_FILE);
+            assertEquals(nameTokens[1], RemoteStoreUtils.invertLong(STATE_TERM));
+            assertEquals(nameTokens[2], RemoteStoreUtils.invertLong(STATE_VERSION));
+            assertThat(RemoteStoreUtils.invertLong(nameTokens[3]), lessThanOrEqualTo(System.currentTimeMillis()));
+        });
+    }
+
+    public void testGetUploadedMetadata() throws IOException {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+
+            assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+            try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+                remoteObjectForUpload.setFullBlobName(new BlobPath().add(TEST_BLOB_PATH));
+                ClusterMetadataManifest.UploadedMetadata uploadedMetadata = remoteObjectForUpload.getUploadedMetadata();
+                String expectedPrefix = INDEX_ROUTING_METADATA_PREFIX + indexRoutingTable.getIndex().getName();
+                assertThat(uploadedMetadata.getComponent(), is(expectedPrefix));
+                assertThat(uploadedMetadata.getUploadedFilename(), is(remoteObjectForUpload.getFullBlobName()));
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    public void testSerDe() throws IOException {
+        String indexName = randomAlphaOfLength(randomIntBetween(1, 50));
+        int numberOfShards = randomIntBetween(1, 10);
+        int numberOfReplicas = randomIntBetween(1, 10);
+        Metadata metadata = Metadata.builder()
+            .put(
+                IndexMetadata.builder(indexName)
+                    .settings(settings(Version.CURRENT))
+                    .numberOfShards(numberOfShards)
+                    .numberOfReplicas(numberOfReplicas)
+            )
+            .build();
+
+        RoutingTable initialRoutingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        initialRoutingTable.getIndicesRouting().values().forEach(indexRoutingTable -> {
+            RemoteIndexRoutingTable remoteObjectForUpload = new RemoteIndexRoutingTable(
+                indexRoutingTable,
+                clusterUUID,
+                compressor,
+                STATE_TERM,
+                STATE_VERSION
+            );
+
+            assertThrows(AssertionError.class, remoteObjectForUpload::getUploadedMetadata);
+
+            try (InputStream inputStream = remoteObjectForUpload.serialize()) {
+                remoteObjectForUpload.setFullBlobName(BlobPath.cleanPath());
+                assertThat(inputStream.available(), greaterThan(0));
+                IndexRoutingTable readIndexRoutingTable = remoteObjectForUpload.deserialize(inputStream);
+                assertEquals(readIndexRoutingTable, indexRoutingTable);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+}
diff --git a/server/src/test/java/org/opensearch/identity/noop/NoopPluginSubjectTests.java b/server/src/test/java/org/opensearch/identity/noop/NoopPluginSubjectTests.java
new file mode 100644
index 0000000000000..79c26a7eb790d
--- /dev/null
+++ b/server/src/test/java/org/opensearch/identity/noop/NoopPluginSubjectTests.java
@@ -0,0 +1,58 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.identity.noop;
+
+import org.opensearch.common.settings.Settings;
+import org.opensearch.identity.IdentityService;
+import org.opensearch.identity.NamedPrincipal;
+import org.opensearch.identity.PluginSubject;
+import org.opensearch.plugins.IdentityAwarePlugin;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.util.List;
+
+import static org.hamcrest.Matchers.equalTo;
+
+public class NoopPluginSubjectTests extends OpenSearchTestCase {
+    public static class TestPlugin extends Plugin implements IdentityAwarePlugin {
+        private PluginSubject subject;
+
+        @Override
+        public void assignSubject(PluginSubject subject) {
+            this.subject = subject;
+        }
+
+        public PluginSubject getSubject() {
+            return subject;
+        }
+    }
+
+    public void testInitializeIdentityAwarePlugin() throws Exception {
+        ThreadPool threadPool = new TestThreadPool(getTestName());
+        IdentityService identityService = new IdentityService(Settings.EMPTY, threadPool, List.of());
+
+        TestPlugin testPlugin = new TestPlugin();
+        identityService.initializeIdentityAwarePlugins(List.of(testPlugin));
+
+        PluginSubject testPluginSubject = new NoopPluginSubject(threadPool);
+        assertThat(testPlugin.getSubject().getPrincipal().getName(), equalTo(NamedPrincipal.UNAUTHENTICATED.getName()));
+        assertThat(testPluginSubject.getPrincipal().getName(), equalTo(NamedPrincipal.UNAUTHENTICATED.getName()));
+        threadPool.getThreadContext().putHeader("test_header", "foo");
+        assertThat(threadPool.getThreadContext().getHeader("test_header"), equalTo("foo"));
+        testPluginSubject.runAs(() -> {
+            assertNull(threadPool.getThreadContext().getHeader("test_header"));
+            return null;
+        });
+        assertThat(threadPool.getThreadContext().getHeader("test_header"), equalTo("foo"));
+        terminate(threadPool);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/IndexModuleTests.java b/server/src/test/java/org/opensearch/index/IndexModuleTests.java
index 4593416bfc198..3138297eb8ebb 100644
--- a/server/src/test/java/org/opensearch/index/IndexModuleTests.java
+++ b/server/src/test/java/org/opensearch/index/IndexModuleTests.java
@@ -259,11 +259,12 @@ private IndexService newIndexService(IndexModule module) throws IOException {
             writableRegistry(),
             () -> false,
             null,
-            new RemoteSegmentStoreDirectoryFactory(() -> repositoriesService, threadPool),
+            new RemoteSegmentStoreDirectoryFactory(() -> repositoriesService, threadPool, ""),
             translogFactorySupplier,
             () -> IndexSettings.DEFAULT_REFRESH_INTERVAL,
             DefaultRecoverySettings.INSTANCE,
-            DefaultRemoteStoreSettings.INSTANCE
+            DefaultRemoteStoreSettings.INSTANCE,
+            s -> {}
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/index/IndexServiceTests.java b/server/src/test/java/org/opensearch/index/IndexServiceTests.java
index 00c8b52d30c55..f0bad0e653453 100644
--- a/server/src/test/java/org/opensearch/index/IndexServiceTests.java
+++ b/server/src/test/java/org/opensearch/index/IndexServiceTests.java
@@ -41,6 +41,7 @@
 import org.opensearch.common.compress.CompressedXContent;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
@@ -52,6 +53,7 @@
 import org.opensearch.index.shard.IndexShardTestCase;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.test.InternalSettingsPlugin;
 import org.opensearch.test.OpenSearchSingleNodeTestCase;
@@ -590,6 +592,57 @@ public void testIndexSortBackwardCompatible() {
         }
     }
 
+    public void testReplicationTask() throws Exception {
+        // create with docrep - task should not schedule
+        IndexService indexService = createIndex(
+            "docrep_index",
+            Settings.builder().put(IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.getKey(), ReplicationType.DOCUMENT).build()
+        );
+        final Index index = indexService.index();
+        ensureGreen(index.getName());
+        IndexService.AsyncReplicationTask task = indexService.getReplicationTask();
+        assertFalse(task.isScheduled());
+        assertFalse(task.mustReschedule());
+
+        // create for segrep - task should schedule
+        indexService = createIndex(
+            "segrep_index",
+            Settings.builder()
+                .put(IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.getKey(), ReplicationType.SEGMENT)
+                .put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), "5s")
+                .build()
+        );
+        final Index srIndex = indexService.index();
+        ensureGreen(srIndex.getName());
+        task = indexService.getReplicationTask();
+        assertTrue(task.isScheduled());
+        assertTrue(task.mustReschedule());
+        assertEquals(5000, task.getInterval().millis());
+
+        // test we can update the interval
+        client().admin()
+            .indices()
+            .prepareUpdateSettings("segrep_index")
+            .setSettings(Settings.builder().put(IndexSettings.INDEX_REFRESH_INTERVAL_SETTING.getKey(), "1s"))
+            .get();
+
+        IndexService.AsyncReplicationTask updatedTask = indexService.getReplicationTask();
+        assertNotSame(task, updatedTask);
+        assertFalse(task.isScheduled());
+        assertTrue(task.isClosed());
+        assertTrue(updatedTask.isScheduled());
+        assertTrue(updatedTask.mustReschedule());
+        assertEquals(1000, updatedTask.getInterval().millis());
+    }
+
+    @Override
+    protected Settings featureFlagSettings() {
+        return Settings.builder()
+            .put(super.featureFlagSettings())
+            .put(FeatureFlags.READER_WRITER_SPLIT_EXPERIMENTAL_SETTING.getKey(), true)
+            .build();
+    }
+
     private static String createTestMapping(String type) {
         return "  \"properties\": {\n"
             + "    \"test\": {\n"
diff --git a/server/src/test/java/org/opensearch/index/IndexingPressureServiceTests.java b/server/src/test/java/org/opensearch/index/IndexingPressureServiceTests.java
index 0b657c1c9745f..8db7c58bf9503 100644
--- a/server/src/test/java/org/opensearch/index/IndexingPressureServiceTests.java
+++ b/server/src/test/java/org/opensearch/index/IndexingPressureServiceTests.java
@@ -24,6 +24,7 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.stats.IndexingPressurePerShardStats;
 import org.opensearch.index.stats.IndexingPressureStats;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.junit.Before;
 
@@ -44,7 +45,7 @@ public class IndexingPressureServiceTests extends OpenSearchTestCase {
     @Before
     public void beforeTest() {
         clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-        clusterService = new ClusterService(settings, clusterSettings, null);
+        clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
     }
 
     public void testCoordinatingOperationForShardIndexingPressure() {
diff --git a/server/src/test/java/org/opensearch/index/ShardIndexingPressureConcurrentExecutionTests.java b/server/src/test/java/org/opensearch/index/ShardIndexingPressureConcurrentExecutionTests.java
index ce719a18898f8..c5ad1370ac75a 100644
--- a/server/src/test/java/org/opensearch/index/ShardIndexingPressureConcurrentExecutionTests.java
+++ b/server/src/test/java/org/opensearch/index/ShardIndexingPressureConcurrentExecutionTests.java
@@ -19,6 +19,7 @@
 import org.opensearch.index.stats.IndexingPressurePerShardStats;
 import org.opensearch.index.stats.IndexingPressureStats;
 import org.opensearch.index.stats.ShardIndexingPressureStats;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.hamcrest.Matcher;
 import org.hamcrest.MatcherAssert;
@@ -42,7 +43,7 @@ public class ShardIndexingPressureConcurrentExecutionTests extends OpenSearchTes
         .build();
 
     private final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-    private final ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+    private final ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
 
     public enum OperationType {
         COORDINATING,
diff --git a/server/src/test/java/org/opensearch/index/ShardIndexingPressureMemoryManagerTests.java b/server/src/test/java/org/opensearch/index/ShardIndexingPressureMemoryManagerTests.java
index 023063c7d6e03..31ecad7c8d701 100644
--- a/server/src/test/java/org/opensearch/index/ShardIndexingPressureMemoryManagerTests.java
+++ b/server/src/test/java/org/opensearch/index/ShardIndexingPressureMemoryManagerTests.java
@@ -8,11 +8,11 @@
 
 package org.opensearch.index;
 
-import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.concurrent.TimeUnit;
@@ -27,7 +27,7 @@ public class ShardIndexingPressureMemoryManagerTests extends OpenSearchTestCase
         .build();
     private final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
     private final ShardIndexingPressureSettings shardIndexingPressureSettings = new ShardIndexingPressureSettings(
-        new ClusterService(settings, clusterSettings, null),
+        ClusterServiceUtils.createClusterService(settings, clusterSettings, null),
         settings,
         IndexingPressure.MAX_INDEXING_BYTES.get(settings).getBytes()
     );
diff --git a/server/src/test/java/org/opensearch/index/ShardIndexingPressureSettingsTests.java b/server/src/test/java/org/opensearch/index/ShardIndexingPressureSettingsTests.java
index c555d8f9c489d..5e84a76b2250a 100644
--- a/server/src/test/java/org/opensearch/index/ShardIndexingPressureSettingsTests.java
+++ b/server/src/test/java/org/opensearch/index/ShardIndexingPressureSettingsTests.java
@@ -11,6 +11,7 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 
 public class ShardIndexingPressureSettingsTests extends OpenSearchTestCase {
@@ -24,7 +25,7 @@ public class ShardIndexingPressureSettingsTests extends OpenSearchTestCase {
         .build();
 
     final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-    final ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+    final ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
 
     public void testFromSettings() {
         ShardIndexingPressureSettings shardIndexingPressureSettings = new ShardIndexingPressureSettings(
diff --git a/server/src/test/java/org/opensearch/index/ShardIndexingPressureStoreTests.java b/server/src/test/java/org/opensearch/index/ShardIndexingPressureStoreTests.java
index 46f9801035ac3..d97eec4cc001d 100644
--- a/server/src/test/java/org/opensearch/index/ShardIndexingPressureStoreTests.java
+++ b/server/src/test/java/org/opensearch/index/ShardIndexingPressureStoreTests.java
@@ -8,10 +8,10 @@
 
 package org.opensearch.index;
 
-import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.junit.Before;
 
@@ -22,7 +22,7 @@ public class ShardIndexingPressureStoreTests extends OpenSearchTestCase {
     private final Settings settings = Settings.builder().put(ShardIndexingPressureStore.MAX_COLD_STORE_SIZE.getKey(), 200).build();
     private final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
     private final ShardIndexingPressureSettings shardIndexingPressureSettings = new ShardIndexingPressureSettings(
-        new ClusterService(settings, clusterSettings, null),
+        ClusterServiceUtils.createClusterService(settings, clusterSettings, null),
         settings,
         IndexingPressure.MAX_INDEXING_BYTES.get(settings).getBytes()
     );
diff --git a/server/src/test/java/org/opensearch/index/ShardIndexingPressureTests.java b/server/src/test/java/org/opensearch/index/ShardIndexingPressureTests.java
index e7600b1d4c41a..ddc3592511de4 100644
--- a/server/src/test/java/org/opensearch/index/ShardIndexingPressureTests.java
+++ b/server/src/test/java/org/opensearch/index/ShardIndexingPressureTests.java
@@ -17,6 +17,7 @@
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.stats.IndexingPressurePerShardStats;
 import org.opensearch.index.stats.IndexingPressureStats;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 
 public class ShardIndexingPressureTests extends OpenSearchTestCase {
@@ -30,7 +31,7 @@ public class ShardIndexingPressureTests extends OpenSearchTestCase {
         .build();
 
     final ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
-    final ClusterService clusterService = new ClusterService(settings, clusterSettings, null);
+    final ClusterService clusterService = ClusterServiceUtils.createClusterService(settings, clusterSettings, null);
 
     public void testMemoryBytesMarkedAndReleased() {
         ShardIndexingPressure shardIndexingPressure = new ShardIndexingPressure(settings, clusterService);
diff --git a/server/src/test/java/org/opensearch/index/codec/CodecTests.java b/server/src/test/java/org/opensearch/index/codec/CodecTests.java
index 57cc2bddd9184..353b6920f5568 100644
--- a/server/src/test/java/org/opensearch/index/codec/CodecTests.java
+++ b/server/src/test/java/org/opensearch/index/codec/CodecTests.java
@@ -48,6 +48,7 @@
 import org.opensearch.env.Environment;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.analysis.IndexAnalyzers;
+import org.opensearch.index.codec.composite.composite99.Composite99Codec;
 import org.opensearch.index.engine.EngineConfig;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.similarity.SimilarityService;
@@ -59,6 +60,8 @@
 import java.io.IOException;
 import java.util.Collections;
 
+import org.mockito.Mockito;
+
 import static org.opensearch.index.engine.EngineConfig.INDEX_CODEC_COMPRESSION_LEVEL_SETTING;
 import static org.hamcrest.Matchers.instanceOf;
 
@@ -76,23 +79,52 @@ public void testDefault() throws Exception {
         assertStoredFieldsCompressionEquals(Lucene99Codec.Mode.BEST_SPEED, codec);
     }
 
+    public void testDefaultWithCompositeIndex() throws Exception {
+        Codec codec = createCodecService(false, true).codec("default");
+        assertStoredFieldsCompressionEquals(Lucene99Codec.Mode.BEST_SPEED, codec);
+        assert codec instanceof Composite99Codec;
+    }
+
     public void testBestCompression() throws Exception {
         Codec codec = createCodecService(false).codec("best_compression");
         assertStoredFieldsCompressionEquals(Lucene99Codec.Mode.BEST_COMPRESSION, codec);
     }
 
+    public void testBestCompressionWithCompositeIndex() throws Exception {
+        Codec codec = createCodecService(false, true).codec("best_compression");
+        assertStoredFieldsCompressionEquals(Lucene99Codec.Mode.BEST_COMPRESSION, codec);
+        assert codec instanceof Composite99Codec;
+    }
+
     public void testLZ4() throws Exception {
         Codec codec = createCodecService(false).codec("lz4");
         assertStoredFieldsCompressionEquals(Lucene99Codec.Mode.BEST_SPEED, codec);
         assert codec instanceof PerFieldMappingPostingFormatCodec;
     }
 
+    public void testLZ4WithCompositeIndex() throws Exception {
+        Codec codec = createCodecService(false, true).codec("lz4");
+        assertStoredFieldsCompressionEquals(Lucene99Codec.Mode.BEST_SPEED, codec);
+        assert codec instanceof Composite99Codec;
+    }
+
     public void testZlib() throws Exception {
         Codec codec = createCodecService(false).codec("zlib");
         assertStoredFieldsCompressionEquals(Lucene99Codec.Mode.BEST_COMPRESSION, codec);
         assert codec instanceof PerFieldMappingPostingFormatCodec;
     }
 
+    public void testZlibWithCompositeIndex() throws Exception {
+        Codec codec = createCodecService(false, true).codec("zlib");
+        assertStoredFieldsCompressionEquals(Lucene99Codec.Mode.BEST_COMPRESSION, codec);
+        assert codec instanceof Composite99Codec;
+    }
+
+    public void testResolveDefaultCodecsWithCompositeIndex() throws Exception {
+        CodecService codecService = createCodecService(false, true);
+        assertThat(codecService.codec("default"), instanceOf(Composite99Codec.class));
+    }
+
     public void testBestCompressionWithCompressionLevel() {
         final Settings settings = Settings.builder()
             .put(INDEX_CODEC_COMPRESSION_LEVEL_SETTING.getKey(), randomIntBetween(1, 6))
@@ -174,10 +206,17 @@ private void assertStoredFieldsCompressionEquals(Lucene99Codec.Mode expected, Co
     }
 
     private CodecService createCodecService(boolean isMapperServiceNull) throws IOException {
+        return createCodecService(isMapperServiceNull, false);
+    }
+
+    private CodecService createCodecService(boolean isMapperServiceNull, boolean isCompositeIndexPresent) throws IOException {
         Settings nodeSettings = Settings.builder().put(Environment.PATH_HOME_SETTING.getKey(), createTempDir()).build();
         if (isMapperServiceNull) {
             return new CodecService(null, IndexSettingsModule.newIndexSettings("_na", nodeSettings), LogManager.getLogger("test"));
         }
+        if (isCompositeIndexPresent) {
+            return buildCodecServiceWithCompositeIndex(nodeSettings);
+        }
         return buildCodecService(nodeSettings);
     }
 
@@ -204,6 +243,14 @@ private MapperService getMapperService(IndexSettings indexSettings, Settings nod
         );
     }
 
+    private CodecService buildCodecServiceWithCompositeIndex(Settings nodeSettings) throws IOException {
+
+        IndexSettings indexSettings = IndexSettingsModule.newIndexSettings("_na", nodeSettings);
+        MapperService service = Mockito.mock(MapperService.class);
+        Mockito.when(service.isCompositeIndexPresent()).thenReturn(true);
+        return new CodecService(service, indexSettings, LogManager.getLogger("test"));
+    }
+
     private SegmentReader getSegmentReader(Codec codec) throws IOException {
         Directory dir = newDirectory();
         IndexWriterConfig iwc = newIndexWriterConfig(null);
diff --git a/server/src/test/java/org/opensearch/index/codec/composite/LuceneDocValuesConsumerFactoryTests.java b/server/src/test/java/org/opensearch/index/codec/composite/LuceneDocValuesConsumerFactoryTests.java
new file mode 100644
index 0000000000000..7fb8fe7f68f45
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/codec/composite/LuceneDocValuesConsumerFactoryTests.java
@@ -0,0 +1,85 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.Version;
+import org.opensearch.index.codec.composite.composite99.Composite99Codec;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.UUID;
+
+public class LuceneDocValuesConsumerFactoryTests extends OpenSearchTestCase {
+
+    private Directory directory;
+    private final String dataCodec = "data_codec";
+    private final String dataExtension = "data_extension";
+    private final String metaCodec = "meta_codec";
+    private final String metaExtension = "meta_extension";
+
+    @Before
+    public void setup() {
+        directory = newDirectory();
+    }
+
+    public void testGetDocValuesConsumerForCompositeCodec() throws IOException {
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            randomInt(),
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+        SegmentWriteState state = new SegmentWriteState(
+            InfoStream.getDefault(),
+            segmentInfo.dir,
+            segmentInfo,
+            new FieldInfos(new FieldInfo[0]),
+            null,
+            newIOContext(random())
+        );
+
+        DocValuesConsumer consumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            state,
+            dataCodec,
+            dataExtension,
+            metaCodec,
+            metaExtension
+        );
+
+        assertEquals("org.apache.lucene.codecs.lucene90.Lucene90DocValuesConsumer", consumer.getClass().getName());
+        assertEquals(CompositeCodecFactory.COMPOSITE_CODEC, Composite99Codec.COMPOSITE_INDEX_CODEC_NAME);
+        consumer.close();
+    }
+
+    @After
+    public void teardown() throws Exception {
+        super.tearDown();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/codec/composite/LuceneDocValuesProducerFactoryTests.java b/server/src/test/java/org/opensearch/index/codec/composite/LuceneDocValuesProducerFactoryTests.java
new file mode 100644
index 0000000000000..55d637dfb9cae
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/codec/composite/LuceneDocValuesProducerFactoryTests.java
@@ -0,0 +1,124 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentReadState;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.Version;
+import org.opensearch.index.codec.composite.composite99.Composite99Codec;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.UUID;
+
+import static org.mockito.Mockito.mock;
+
+public class LuceneDocValuesProducerFactoryTests extends OpenSearchTestCase {
+
+    private Directory directory;
+    private final String dataCodec = "data_codec";
+    private final String dataExtension = "data_extension";
+    private final String metaCodec = "meta_codec";
+    private final String metaExtension = "meta_extension";
+
+    @Before
+    public void setup() {
+        directory = newDirectory();
+    }
+
+    public void testGetDocValuesProducerForCompositeCodec99() throws IOException {
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            randomInt(),
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+
+        // open an consumer first in order for the producer to find the file
+        SegmentWriteState state = new SegmentWriteState(
+            InfoStream.getDefault(),
+            segmentInfo.dir,
+            segmentInfo,
+            new FieldInfos(new FieldInfo[0]),
+            null,
+            newIOContext(random())
+        );
+        DocValuesConsumer consumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            state,
+            dataCodec,
+            dataExtension,
+            metaCodec,
+            metaExtension
+        );
+        consumer.close();
+
+        SegmentReadState segmentReadState = new SegmentReadState(
+            segmentInfo.dir,
+            segmentInfo,
+            new FieldInfos(new FieldInfo[0]),
+            newIOContext(random())
+        );
+        DocValuesProducer producer = LuceneDocValuesProducerFactory.getDocValuesProducerForCompositeCodec(
+            Composite99Codec.COMPOSITE_INDEX_CODEC_NAME,
+            segmentReadState,
+            dataCodec,
+            dataExtension,
+            metaCodec,
+            metaExtension
+        );
+
+        assertNotNull(producer);
+        assertEquals("org.apache.lucene.codecs.lucene90.Lucene90DocValuesProducer", producer.getClass().getName());
+        producer.close();
+    }
+
+    public void testGetDocValuesProducerForCompositeCodec_InvalidCodec() {
+        SegmentReadState mockSegmentReadState = mock(SegmentReadState.class);
+
+        IllegalStateException exception = expectThrows(IllegalStateException.class, () -> {
+            LuceneDocValuesProducerFactory.getDocValuesProducerForCompositeCodec(
+                "invalid_codec",
+                mockSegmentReadState,
+                dataCodec,
+                dataExtension,
+                metaCodec,
+                metaExtension
+            );
+        });
+
+        assertNotNull(exception);
+        assertTrue(exception.getMessage().contains("Invalid composite codec"));
+    }
+
+    @After
+    public void teardown() throws Exception {
+        super.tearDown();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/codec/composite/SortedNumericDocValuesWriterWrapperTests.java b/server/src/test/java/org/opensearch/index/codec/composite/SortedNumericDocValuesWriterWrapperTests.java
new file mode 100644
index 0000000000000..54eead20ef354
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/codec/composite/SortedNumericDocValuesWriterWrapperTests.java
@@ -0,0 +1,94 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite;
+
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.index.SortedNumericDocValuesWriterWrapper;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.util.Counter;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.Collections;
+
+public class SortedNumericDocValuesWriterWrapperTests extends OpenSearchTestCase {
+
+    private SortedNumericDocValuesWriterWrapper wrapper;
+    private FieldInfo fieldInfo;
+    private Counter counter;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        fieldInfo = new FieldInfo(
+            "field",
+            1,
+            false,
+            false,
+            true,
+            IndexOptions.NONE,
+            DocValuesType.NONE,
+            -1,
+            Collections.emptyMap(),
+            0,
+            0,
+            0,
+            0,
+            VectorEncoding.FLOAT32,
+            VectorSimilarityFunction.EUCLIDEAN,
+            false,
+            false
+        );
+        counter = Counter.newCounter();
+        wrapper = new SortedNumericDocValuesWriterWrapper(fieldInfo, counter);
+    }
+
+    public void testAddValue() throws IOException {
+        wrapper.addValue(0, 10);
+        wrapper.addValue(1, 20);
+        wrapper.addValue(2, 30);
+
+        SortedNumericDocValues docValues = wrapper.getDocValues();
+        assertNotNull(docValues);
+
+        assertEquals(0, docValues.nextDoc());
+        assertEquals(10, docValues.nextValue());
+        assertEquals(1, docValues.nextDoc());
+        assertEquals(20, docValues.nextValue());
+        assertEquals(2, docValues.nextDoc());
+        assertEquals(30, docValues.nextValue());
+    }
+
+    public void testGetDocValues() {
+        SortedNumericDocValues docValues = wrapper.getDocValues();
+        assertNotNull(docValues);
+    }
+
+    public void testMultipleValues() throws IOException {
+        wrapper.addValue(0, 10);
+        wrapper.addValue(0, 20);
+        wrapper.addValue(1, 30);
+
+        SortedNumericDocValues docValues = wrapper.getDocValues();
+        assertNotNull(docValues);
+
+        assertEquals(0, docValues.nextDoc());
+        assertEquals(10, docValues.nextValue());
+        assertEquals(20, docValues.nextValue());
+        assertThrows(IllegalStateException.class, docValues::nextValue);
+
+        assertEquals(1, docValues.nextDoc());
+        assertEquals(30, docValues.nextValue());
+        assertThrows(IllegalStateException.class, docValues::nextValue);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/codec/composite99/datacube/startree/StarTreeDocValuesFormatTests.java b/server/src/test/java/org/opensearch/index/codec/composite99/datacube/startree/StarTreeDocValuesFormatTests.java
new file mode 100644
index 0000000000000..1c267c67e60ed
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/codec/composite99/datacube/startree/StarTreeDocValuesFormatTests.java
@@ -0,0 +1,289 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.codec.composite99.datacube.startree;
+
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.lucene.codecs.Codec;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.SortedNumericDocValuesField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.SegmentReader;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.tests.index.BaseDocValuesFormatTestCase;
+import org.apache.lucene.tests.index.RandomIndexWriter;
+import org.apache.lucene.tests.util.LuceneTestCase;
+import org.apache.lucene.tests.util.TestUtil;
+import org.opensearch.Version;
+import org.opensearch.cluster.ClusterModule;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.CheckedConsumer;
+import org.opensearch.common.lucene.Lucene;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.MapperTestUtils;
+import org.opensearch.index.codec.composite.CompositeIndexFieldInfo;
+import org.opensearch.index.codec.composite.CompositeIndexReader;
+import org.opensearch.index.codec.composite.composite99.Composite99Codec;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeTestUtils;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.indices.IndicesModule;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import static org.opensearch.common.util.FeatureFlags.STAR_TREE_INDEX;
+import static org.opensearch.index.compositeindex.datacube.startree.StarTreeTestUtils.assertStarTreeDocuments;
+
+/**
+ * Star tree doc values Lucene tests
+ */
+@LuceneTestCase.SuppressSysoutChecks(bugUrl = "we log a lot on purpose")
+public class StarTreeDocValuesFormatTests extends BaseDocValuesFormatTestCase {
+    MapperService mapperService = null;
+    StarTreeFieldConfiguration.StarTreeBuildMode buildMode;
+
+    public StarTreeDocValuesFormatTests(StarTreeFieldConfiguration.StarTreeBuildMode buildMode) {
+        this.buildMode = buildMode;
+    }
+
+    @ParametersFactory
+    public static Collection<Object[]> parameters() {
+        List<Object[]> parameters = new ArrayList<>();
+        parameters.add(new Object[] { StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP });
+        parameters.add(new Object[] { StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP });
+        return parameters;
+    }
+
+    @BeforeClass
+    public static void createMapper() throws Exception {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(STAR_TREE_INDEX, "true").build());
+    }
+
+    @AfterClass
+    public static void clearMapper() {
+        FeatureFlags.initializeFeatureFlags(Settings.EMPTY);
+    }
+
+    @After
+    public void teardown() throws IOException {
+        mapperService.close();
+    }
+
+    @Override
+    protected Codec getCodec() {
+        final Logger testLogger = LogManager.getLogger(StarTreeDocValuesFormatTests.class);
+
+        try {
+            createMapperService(getExpandedMapping());
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+        Codec codec = new Composite99Codec(Lucene99Codec.Mode.BEST_SPEED, mapperService, testLogger);
+        return codec;
+    }
+
+    public void testStarTreeDocValues() throws IOException {
+        Directory directory = newDirectory();
+        IndexWriterConfig conf = newIndexWriterConfig(null);
+        conf.setMergePolicy(newLogMergePolicy());
+        RandomIndexWriter iw = new RandomIndexWriter(random(), directory, conf);
+        Document doc = new Document();
+        doc.add(new SortedNumericDocValuesField("sndv", 1));
+        doc.add(new SortedNumericDocValuesField("dv", 1));
+        doc.add(new SortedNumericDocValuesField("field", -1));
+        iw.addDocument(doc);
+        doc = new Document();
+        doc.add(new SortedNumericDocValuesField("sndv", 1));
+        doc.add(new SortedNumericDocValuesField("dv", 1));
+        doc.add(new SortedNumericDocValuesField("field", -1));
+        iw.addDocument(doc);
+        doc = new Document();
+        iw.forceMerge(1);
+        doc.add(new SortedNumericDocValuesField("sndv", 2));
+        doc.add(new SortedNumericDocValuesField("dv", 2));
+        doc.add(new SortedNumericDocValuesField("field", -2));
+        iw.addDocument(doc);
+        doc = new Document();
+        doc.add(new SortedNumericDocValuesField("sndv", 2));
+        doc.add(new SortedNumericDocValuesField("dv", 2));
+        doc.add(new SortedNumericDocValuesField("field", -2));
+        iw.addDocument(doc);
+        iw.forceMerge(1);
+        iw.close();
+
+        DirectoryReader ir = maybeWrapWithMergingReader(DirectoryReader.open(directory));
+        TestUtil.checkReader(ir);
+        assertEquals(1, ir.leaves().size());
+
+        // Segment documents
+        /**
+         * sndv dv field
+         * [1,  1,   -1]
+         * [1,  1,   -1]
+         * [2,  2,   -2]
+         * [2,  2,   -2]
+         */
+        // Star tree docuements
+        /**
+         * sndv dv | [ sum, value_count, min, max[field]] , [ sum, value_count, min, max[sndv]], doc_count
+         * [1, 1] | [-2.0, 2.0, -1.0, -1.0, 2.0, 2.0, 1.0, 1.0, 2.0]
+         * [2, 2] | [-4.0, 2.0, -2.0, -2.0, 4.0, 2.0, 2.0, 2.0, 2.0]
+         * [null, 1] | [-2.0, 2.0, -1.0, -1.0, 2.0, 2.0, 1.0, 1.0, 2.0]
+         * [null, 2] | [-4.0, 2.0, -2.0, -2.0, 4.0, 2.0, 2.0, 2.0, 2.0]
+         */
+        StarTreeDocument[] expectedStarTreeDocuments = new StarTreeDocument[4];
+        expectedStarTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 1L, 1L },
+            new Double[] { -2.0, 2.0, -1.0, -1.0, 2.0, 2.0, 1.0, 1.0, 2.0 }
+        );
+        expectedStarTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 2L, 2L },
+            new Double[] { -4.0, 2.0, -2.0, -2.0, 4.0, 2.0, 2.0, 2.0, 2.0 }
+        );
+        expectedStarTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { null, 1L },
+            new Double[] { -2.0, 2.0, -1.0, -1.0, 2.0, 2.0, 1.0, 1.0, 2.0 }
+        );
+        expectedStarTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { null, 2L },
+            new Double[] { -4.0, 2.0, -2.0, -2.0, 4.0, 2.0, 2.0, 2.0, 2.0 }
+        );
+
+        for (LeafReaderContext context : ir.leaves()) {
+            SegmentReader reader = Lucene.segmentReader(context.reader());
+            CompositeIndexReader starTreeDocValuesReader = (CompositeIndexReader) reader.getDocValuesReader();
+            List<CompositeIndexFieldInfo> compositeIndexFields = starTreeDocValuesReader.getCompositeIndexFields();
+
+            for (CompositeIndexFieldInfo compositeIndexFieldInfo : compositeIndexFields) {
+                StarTreeValues starTreeValues = (StarTreeValues) starTreeDocValuesReader.getCompositeIndexValues(compositeIndexFieldInfo);
+                StarTreeDocument[] starTreeDocuments = StarTreeTestUtils.getSegmentsStarTreeDocuments(
+                    List.of(starTreeValues),
+                    List.of(
+                        NumberFieldMapper.NumberType.DOUBLE,
+                        NumberFieldMapper.NumberType.LONG,
+                        NumberFieldMapper.NumberType.DOUBLE,
+                        NumberFieldMapper.NumberType.DOUBLE,
+                        NumberFieldMapper.NumberType.DOUBLE,
+                        NumberFieldMapper.NumberType.LONG,
+                        NumberFieldMapper.NumberType.DOUBLE,
+                        NumberFieldMapper.NumberType.DOUBLE,
+                        NumberFieldMapper.NumberType.LONG
+                    ),
+                    reader.maxDoc()
+                );
+                assertStarTreeDocuments(starTreeDocuments, expectedStarTreeDocuments);
+            }
+        }
+        ir.close();
+        directory.close();
+    }
+
+    private XContentBuilder getExpandedMapping() throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+            b.field("max_leaf_docs", 1);
+            b.startArray("ordered_dimensions");
+            b.startObject();
+            b.field("name", "sndv");
+            b.endObject();
+            b.startObject();
+            b.field("name", "dv");
+            b.endObject();
+            b.endArray();
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", "field");
+            b.startArray("stats");
+            b.value("sum");
+            b.value("value_count");
+            b.value("avg");
+            b.value("min");
+            b.value("max");
+            b.endArray();
+            b.endObject();
+            b.startObject();
+            b.field("name", "sndv");
+            b.startArray("stats");
+            b.value("sum");
+            b.value("value_count");
+            b.value("avg");
+            b.value("min");
+            b.value("max");
+            b.endArray();
+            b.endObject();
+            b.endArray();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("sndv");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("dv");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("field");
+            b.field("type", "integer");
+            b.endObject();
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder topMapping(CheckedConsumer<XContentBuilder, IOException> buildFields) throws IOException {
+        XContentBuilder builder = XContentFactory.jsonBuilder().startObject().startObject("_doc");
+        buildFields.accept(builder);
+        return builder.endObject().endObject();
+    }
+
+    private void createMapperService(XContentBuilder builder) throws IOException {
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(512, ByteSizeUnit.MB))
+            .build();
+        IndexMetadata indexMetadata = IndexMetadata.builder("test").settings(settings).putMapping(builder.toString()).build();
+        IndicesModule indicesModule = new IndicesModule(Collections.emptyList());
+        mapperService = MapperTestUtils.newMapperServiceWithHelperAnalyzer(
+            new NamedXContentRegistry(ClusterModule.getNamedXWriteables()),
+            createTempDir(),
+            settings,
+            indicesModule,
+            "test"
+        );
+        mapperService.merge(indexMetadata, MapperService.MergeReason.INDEX_TEMPLATE);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeTestUtils.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeTestUtils.java
new file mode 100644
index 0000000000000..b7395b993f67b
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/StarTreeTestUtils.java
@@ -0,0 +1,321 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree;
+
+import org.apache.lucene.store.IndexInput;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.meta.StarTreeMetadata;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.compositeindex.datacube.startree.node.InMemoryTreeNode;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeFactory;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNode;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNodeType;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+import org.opensearch.index.mapper.FieldValueConverter;
+
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Queue;
+
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.COMPOSITE_FIELD_MARKER;
+import static org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter.VERSION_CURRENT;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
+import static org.opensearch.index.mapper.CompositeMappedFieldType.CompositeFieldType.STAR_TREE;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+public class StarTreeTestUtils {
+
+    public static StarTreeDocument[] getSegmentsStarTreeDocuments(
+        List<StarTreeValues> starTreeValuesSubs,
+        List<FieldValueConverter> fieldValueConverters,
+        int numDocs
+    ) throws IOException {
+        List<StarTreeDocument> starTreeDocuments = new ArrayList<>();
+        for (StarTreeValues starTreeValues : starTreeValuesSubs) {
+            List<Dimension> dimensionsSplitOrder = starTreeValues.getStarTreeField().getDimensionsOrder();
+            SequentialDocValuesIterator[] dimensionReaders = new SequentialDocValuesIterator[dimensionsSplitOrder.size()];
+
+            for (int i = 0; i < dimensionsSplitOrder.size(); i++) {
+                String dimension = dimensionsSplitOrder.get(i).getField();
+                dimensionReaders[i] = new SequentialDocValuesIterator(starTreeValues.getDimensionDocIdSetIterator(dimension));
+            }
+
+            List<SequentialDocValuesIterator> metricReaders = new ArrayList<>();
+            // get doc id set iterators for metrics
+            for (Metric metric : starTreeValues.getStarTreeField().getMetrics()) {
+                for (MetricStat metricStat : metric.getMetrics()) {
+                    if (metricStat.isDerivedMetric()) {
+                        continue;
+                    }
+                    String metricFullName = fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                        starTreeValues.getStarTreeField().getName(),
+                        metric.getField(),
+                        metricStat.getTypeName()
+                    );
+                    metricReaders.add(new SequentialDocValuesIterator(starTreeValues.getMetricDocIdSetIterator(metricFullName)));
+
+                }
+            }
+            int currentDocId = 0;
+            while (currentDocId < numDocs) {
+                starTreeDocuments.add(getStarTreeDocument(currentDocId, dimensionReaders, metricReaders, fieldValueConverters));
+                currentDocId++;
+            }
+        }
+        StarTreeDocument[] starTreeDocumentsArr = new StarTreeDocument[starTreeDocuments.size()];
+        return starTreeDocuments.toArray(starTreeDocumentsArr);
+    }
+
+    public static StarTreeDocument getStarTreeDocument(
+        int currentDocId,
+        SequentialDocValuesIterator[] dimensionReaders,
+        List<SequentialDocValuesIterator> metricReaders,
+        List<FieldValueConverter> fieldValueConverters
+    ) throws IOException {
+        Long[] dims = new Long[dimensionReaders.length];
+        int i = 0;
+        for (SequentialDocValuesIterator dimensionDocValueIterator : dimensionReaders) {
+            dimensionDocValueIterator.nextDoc(currentDocId);
+            Long val = dimensionDocValueIterator.value(currentDocId);
+            dims[i] = val;
+            i++;
+        }
+        i = 0;
+        Object[] metrics = new Object[metricReaders.size()];
+        for (SequentialDocValuesIterator metricDocValuesIterator : metricReaders) {
+            metricDocValuesIterator.nextDoc(currentDocId);
+            metrics[i] = toAggregatorValueType(metricDocValuesIterator.value(currentDocId), fieldValueConverters.get(i));
+            i++;
+        }
+        return new StarTreeDocument(dims, metrics);
+    }
+
+    public static Double toAggregatorValueType(Long value, FieldValueConverter fieldValueConverter) {
+        try {
+            return fieldValueConverter.toDoubleValue(value);
+        } catch (Exception e) {
+            throw new IllegalStateException("Cannot convert " + value + " to sortable aggregation type", e);
+        }
+    }
+
+    public static void assertStarTreeDocuments(StarTreeDocument[] starTreeDocuments, StarTreeDocument[] expectedStarTreeDocuments) {
+
+        assertNotNull(starTreeDocuments);
+        assertEquals(starTreeDocuments.length, expectedStarTreeDocuments.length);
+
+        for (int i = 0; i < starTreeDocuments.length; i++) {
+
+            StarTreeDocument resultStarTreeDocument = starTreeDocuments[i];
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocuments[i];
+
+            assertNotNull(resultStarTreeDocument.dimensions);
+            assertNotNull(resultStarTreeDocument.metrics);
+
+            assertEquals(expectedStarTreeDocument.dimensions.length, resultStarTreeDocument.dimensions.length);
+            assertEquals(expectedStarTreeDocument.metrics.length, resultStarTreeDocument.metrics.length);
+
+            for (int di = 0; di < resultStarTreeDocument.dimensions.length; di++) {
+                assertEquals(expectedStarTreeDocument.dimensions[di], resultStarTreeDocument.dimensions[di]);
+            }
+
+            for (int mi = 0; mi < resultStarTreeDocument.metrics.length; mi++) {
+                if (expectedStarTreeDocument.metrics[mi] instanceof Long) {
+                    assertEquals(((Long) expectedStarTreeDocument.metrics[mi]).doubleValue(), resultStarTreeDocument.metrics[mi]);
+                } else {
+                    assertEquals(expectedStarTreeDocument.metrics[mi], resultStarTreeDocument.metrics[mi]);
+                }
+            }
+        }
+    }
+
+    public static void validateFileFormats(
+        IndexInput dataIn,
+        IndexInput metaIn,
+        InMemoryTreeNode rootNode,
+        StarTreeMetadata expectedStarTreeMetadata
+    ) throws IOException {
+        long magicMarker = metaIn.readLong();
+        assertEquals(COMPOSITE_FIELD_MARKER, magicMarker);
+        int version = metaIn.readVInt();
+        assertEquals(VERSION_CURRENT, version);
+
+        String compositeFieldName = metaIn.readString();
+        assertEquals(expectedStarTreeMetadata.getStarTreeFieldName(), compositeFieldName);
+        CompositeMappedFieldType.CompositeFieldType compositeFieldType = CompositeMappedFieldType.CompositeFieldType.fromName(
+            metaIn.readString()
+        );
+        assertEquals(STAR_TREE, compositeFieldType);
+        StarTreeMetadata resultStarTreeMetadata = new StarTreeMetadata(metaIn, compositeFieldName, compositeFieldType, version);
+        assertStarTreeMetadata(expectedStarTreeMetadata, resultStarTreeMetadata);
+
+        IndexInput starTreeIndexInput = dataIn.slice(
+            "star-tree data slice for respective star-tree fields",
+            resultStarTreeMetadata.getDataStartFilePointer(),
+            resultStarTreeMetadata.getDataLength()
+        );
+
+        StarTreeNode starTreeNode = StarTreeFactory.createStarTree(starTreeIndexInput, resultStarTreeMetadata);
+        Queue<StarTreeNode> expectedTreeNodeQueue = new ArrayDeque<>();
+        Queue<InMemoryTreeNode> resultTreeNodeQueue = new ArrayDeque<>();
+
+        expectedTreeNodeQueue.add(starTreeNode);
+        resultTreeNodeQueue.add(rootNode);
+
+        while ((starTreeNode = expectedTreeNodeQueue.poll()) != null && (rootNode = resultTreeNodeQueue.poll()) != null) {
+
+            // verify the star node
+            assertStarTreeNode(starTreeNode, rootNode);
+
+            Iterator<? extends StarTreeNode> expectedChildrenIterator = starTreeNode.getChildrenIterator();
+
+            List<InMemoryTreeNode> sortedChildren = new ArrayList<>();
+            if (rootNode.getChildren() != null) {
+                sortedChildren = new ArrayList<>(rootNode.getChildren().values());
+            }
+
+            if (starTreeNode.getChildDimensionId() != -1) {
+                assertFalse(sortedChildren.isEmpty());
+                int childCount = 0;
+                boolean childStarNodeAsserted = false;
+                while (expectedChildrenIterator.hasNext()) {
+                    StarTreeNode child = expectedChildrenIterator.next();
+                    InMemoryTreeNode resultChildNode = null;
+                    if (!childStarNodeAsserted && rootNode.getChildStarNode() != null) {
+                        // check if star tree node exists
+                        resultChildNode = rootNode.getChildStarNode();
+                        assertNotNull(child);
+                        assertNotNull(starTreeNode.getChildStarNode());
+                        assertStarTreeNode(child, resultChildNode);
+                        childStarNodeAsserted = true;
+                    } else {
+                        resultChildNode = sortedChildren.get(childCount);
+                        assertNotNull(child);
+                        assertNotNull(resultChildNode);
+                        if (child.getStarTreeNodeType() != StarTreeNodeType.NULL.getValue()) {
+                            assertNotNull(starTreeNode.getChildForDimensionValue(child.getDimensionValue()));
+                        } else {
+                            assertNull(starTreeNode.getChildForDimensionValue(child.getDimensionValue()));
+                        }
+                        assertStarTreeNode(child, resultChildNode);
+                        assertNotEquals(child.getStarTreeNodeType(), StarTreeNodeType.STAR.getValue());
+                        childCount++;
+                    }
+
+                    expectedTreeNodeQueue.add(child);
+                    resultTreeNodeQueue.add(resultChildNode);
+                }
+
+                assertEquals(childCount, rootNode.getChildren().size());
+            } else {
+                assertTrue(rootNode.getChildren().isEmpty());
+            }
+        }
+
+        assertTrue(expectedTreeNodeQueue.isEmpty());
+        assertTrue(resultTreeNodeQueue.isEmpty());
+
+    }
+
+    public static void assertStarTreeNode(StarTreeNode starTreeNode, InMemoryTreeNode treeNode) throws IOException {
+        assertEquals(starTreeNode.getDimensionId(), treeNode.getDimensionId());
+        assertEquals(starTreeNode.getDimensionValue(), treeNode.getDimensionValue());
+        assertEquals(starTreeNode.getStartDocId(), treeNode.getStartDocId());
+        assertEquals(starTreeNode.getEndDocId(), treeNode.getEndDocId());
+        assertEquals(starTreeNode.getChildDimensionId(), treeNode.getChildDimensionId());
+        assertEquals(starTreeNode.getAggregatedDocId(), treeNode.getAggregatedDocId());
+
+        if (starTreeNode.getChildDimensionId() != -1) {
+            assertFalse(starTreeNode.isLeaf());
+            if (treeNode.getChildren() != null) {
+                assertEquals(
+                    starTreeNode.getNumChildren(),
+                    treeNode.getChildren().values().size() + (treeNode.getChildStarNode() != null ? 1 : 0)
+                );
+            }
+        } else {
+            assertTrue(starTreeNode.isLeaf());
+        }
+
+    }
+
+    public static void assertStarTreeMetadata(StarTreeMetadata expectedStarTreeMetadata, StarTreeMetadata resultStarTreeMetadata) {
+
+        assertEquals(expectedStarTreeMetadata.getCompositeFieldName(), resultStarTreeMetadata.getCompositeFieldName());
+        assertEquals(expectedStarTreeMetadata.getCompositeFieldType(), resultStarTreeMetadata.getCompositeFieldType());
+        assertEquals(expectedStarTreeMetadata.getDimensionFields().size(), resultStarTreeMetadata.getDimensionFields().size());
+        for (int i = 0; i < expectedStarTreeMetadata.getDimensionFields().size(); i++) {
+            assertEquals(expectedStarTreeMetadata.getDimensionFields().get(i), resultStarTreeMetadata.getDimensionFields().get(i));
+        }
+        assertEquals(expectedStarTreeMetadata.getMetrics().size(), resultStarTreeMetadata.getMetrics().size());
+
+        for (int i = 0; i < expectedStarTreeMetadata.getMetrics().size(); i++) {
+
+            Metric expectedMetric = expectedStarTreeMetadata.getMetrics().get(i);
+            Metric resultMetric = resultStarTreeMetadata.getMetrics().get(i);
+            assertEquals(expectedMetric.getField(), resultMetric.getField());
+            List<MetricStat> metricStats = new ArrayList<>();
+            for (MetricStat metricStat : expectedMetric.getMetrics()) {
+                if (metricStat.isDerivedMetric()) {
+                    continue;
+                }
+                metricStats.add(metricStat);
+            }
+            Metric expectedMetricWithoutDerivedMetrics = new Metric(expectedMetric.getField(), metricStats);
+            metricStats = new ArrayList<>();
+            for (MetricStat metricStat : resultMetric.getMetrics()) {
+                if (metricStat.isDerivedMetric()) {
+                    continue;
+                }
+                metricStats.add(metricStat);
+            }
+            Metric resultantMetricWithoutDerivedMetrics = new Metric(resultMetric.getField(), metricStats);
+
+            // assert base metrics are in order in metadata
+            for (int j = 0; j < expectedMetricWithoutDerivedMetrics.getMetrics().size(); j++) {
+                assertEquals(
+                    expectedMetricWithoutDerivedMetrics.getMetrics().get(j),
+                    resultantMetricWithoutDerivedMetrics.getMetrics().get(j)
+                );
+            }
+
+            // assert all metrics ( including derived metrics are present )
+            for (int j = 0; j < expectedMetric.getMetrics().size(); j++) {
+                assertTrue(resultMetric.getMetrics().contains(expectedMetric.getMetrics().get(j)));
+            }
+
+        }
+
+        assertEquals(expectedStarTreeMetadata.getSegmentAggregatedDocCount(), resultStarTreeMetadata.getSegmentAggregatedDocCount());
+        assertEquals(expectedStarTreeMetadata.getStarTreeDocCount(), resultStarTreeMetadata.getStarTreeDocCount());
+        assertEquals(expectedStarTreeMetadata.getMaxLeafDocs(), resultStarTreeMetadata.getMaxLeafDocs());
+        assertEquals(
+            expectedStarTreeMetadata.getSkipStarNodeCreationInDims().size(),
+            resultStarTreeMetadata.getSkipStarNodeCreationInDims().size()
+        );
+        for (String skipDimension : expectedStarTreeMetadata.getSkipStarNodeCreationInDims()) {
+            assertTrue(resultStarTreeMetadata.getSkipStarNodeCreationInDims().contains(skipDimension));
+        }
+        assertEquals(expectedStarTreeMetadata.getStarTreeBuildMode(), resultStarTreeMetadata.getStarTreeBuildMode());
+        assertEquals(expectedStarTreeMetadata.getDataStartFilePointer(), resultStarTreeMetadata.getDataStartFilePointer());
+        assertEquals(expectedStarTreeMetadata.getDataLength(), resultStarTreeMetadata.getDataLength());
+        assertEquals(0, (resultStarTreeMetadata.getDataLength()) % 33);
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/AbstractValueAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/AbstractValueAggregatorTests.java
new file mode 100644
index 0000000000000..00f9fcf0e269f
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/AbstractValueAggregatorTests.java
@@ -0,0 +1,71 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import com.carrotsearch.randomizedtesting.annotations.ParametersFactory;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public abstract class AbstractValueAggregatorTests extends OpenSearchTestCase {
+
+    private ValueAggregator aggregator;
+    protected FieldValueConverter fieldValueConverter;
+
+    public AbstractValueAggregatorTests(FieldValueConverter fieldValueConverter) {
+        this.fieldValueConverter = fieldValueConverter;
+    }
+
+    @Before
+    public void setup() {
+        aggregator = getValueAggregator(fieldValueConverter);
+    }
+
+    @ParametersFactory
+    public static Collection<Object[]> parameters() {
+        List<Object[]> parameters = new ArrayList<>();
+        for (FieldValueConverter fieldValueConverter : NumberFieldMapper.NumberType.values()) {
+            parameters.add(new Object[] { fieldValueConverter });
+        }
+        return parameters;
+    }
+
+    public abstract ValueAggregator getValueAggregator(FieldValueConverter fieldValueConverter);
+
+    public void testGetInitialAggregatedValueForSegmentDocNullValue() {
+        assertEquals(aggregator.getIdentityMetricValue(), aggregator.getInitialAggregatedValueForSegmentDocValue(null));
+    }
+
+    public void testMergeAggregatedNullValueAndSegmentNullValue() {
+        assertEquals(aggregator.getIdentityMetricValue(), aggregator.mergeAggregatedValueAndSegmentValue(null, null));
+    }
+
+    public void testMergeAggregatedNullValues() {
+        assertEquals(aggregator.getIdentityMetricValue(), aggregator.mergeAggregatedValues(null, null));
+    }
+
+    public void testGetInitialAggregatedNullValue() {
+        assertEquals(aggregator.getIdentityMetricValue(), aggregator.getInitialAggregatedValue(null));
+    }
+
+    public void testGetInitialAggregatedValueForSegmentDocValue() {
+        long randomLong = randomLong();
+        if (aggregator instanceof CountValueAggregator) {
+            assertEquals(CountValueAggregator.DEFAULT_INITIAL_VALUE, aggregator.getInitialAggregatedValueForSegmentDocValue(randomLong()));
+        } else {
+            assertEquals(fieldValueConverter.toDoubleValue(randomLong), aggregator.getInitialAggregatedValueForSegmentDocValue(randomLong));
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregatorTests.java
new file mode 100644
index 0000000000000..db22ee9af18e2
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/CountValueAggregatorTests.java
@@ -0,0 +1,65 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+
+public class CountValueAggregatorTests extends AbstractValueAggregatorTests {
+
+    private CountValueAggregator aggregator;
+
+    public CountValueAggregatorTests(FieldValueConverter fieldValueConverter) {
+        super(fieldValueConverter);
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue() {
+        long randomLong = randomLong();
+        assertEquals(randomLong + 1, aggregator.mergeAggregatedValueAndSegmentValue(randomLong, 3L), 0.0);
+    }
+
+    public void testMergeAggregatedValues() {
+        long randomLong1 = randomLong();
+        long randomLong2 = randomLong();
+        assertEquals(randomLong1 + randomLong2, aggregator.mergeAggregatedValues(randomLong1, randomLong2), 0.0);
+        assertEquals(randomLong1, aggregator.mergeAggregatedValues(randomLong1, null), 0.0);
+        assertEquals(randomLong2, aggregator.mergeAggregatedValues(null, randomLong2), 0.0);
+    }
+
+    @Override
+    public void testMergeAggregatedNullValueAndSegmentNullValue() {
+        assertThrows(AssertionError.class, () -> aggregator.mergeAggregatedValueAndSegmentValue(null, null));
+    }
+
+    public void testGetInitialAggregatedValue() {
+        long randomLong = randomLong();
+        assertEquals(randomLong, aggregator.getInitialAggregatedValue(randomLong), 0.0);
+    }
+
+    public void testToAggregatedValueType() {
+        long randomLong = randomLong();
+        assertEquals(randomLong, aggregator.toAggregatedValueType(randomLong), 0.0);
+        assertNull(aggregator.toAggregatedValueType(null));
+    }
+
+    public void testIdentityMetricValue() {
+        assertEquals(0L, aggregator.getIdentityMetricValue(), 0);
+    }
+
+    @Override
+    public ValueAggregator getValueAggregator(FieldValueConverter fieldValueConverter) {
+        aggregator = new CountValueAggregator();
+        return aggregator;
+    }
+
+    @Override
+    public void testGetInitialAggregatedValueForSegmentDocValue() {
+        long randomLong = randomLong();
+        assertEquals(CountValueAggregator.DEFAULT_INITIAL_VALUE, (long) aggregator.getInitialAggregatedValueForSegmentDocValue(randomLong));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/DocCountAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/DocCountAggregatorTests.java
new file mode 100644
index 0000000000000..3960412d65868
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/DocCountAggregatorTests.java
@@ -0,0 +1,75 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+
+/**
+ * Unit tests for {@link DocCountAggregator}.
+ */
+public class DocCountAggregatorTests extends AbstractValueAggregatorTests {
+
+    private DocCountAggregator aggregator;
+
+    public DocCountAggregatorTests(FieldValueConverter fieldValueConverter) {
+        super(fieldValueConverter);
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue() {
+        long randomLong = randomLong();
+        assertEquals(randomLong + 3L, (long) aggregator.mergeAggregatedValueAndSegmentValue(randomLong, 3L));
+    }
+
+    public void testMergeAggregatedValues() {
+        long randomLong1 = randomLong();
+        long randomLong2 = randomLong();
+        assertEquals(randomLong1 + randomLong2, (long) aggregator.mergeAggregatedValues(randomLong1, randomLong2));
+        assertEquals(randomLong1 + 1L, (long) aggregator.mergeAggregatedValues(randomLong1, null));
+        assertEquals(randomLong2 + 1L, (long) aggregator.mergeAggregatedValues(null, randomLong2));
+    }
+
+    @Override
+    public void testMergeAggregatedNullValueAndSegmentNullValue() {
+        assertThrows(AssertionError.class, () -> aggregator.mergeAggregatedValueAndSegmentValue(null, null));
+    }
+
+    @Override
+    public void testMergeAggregatedNullValues() {
+        assertEquals(
+            (aggregator.getIdentityMetricValue() + aggregator.getIdentityMetricValue()),
+            (long) aggregator.mergeAggregatedValues(null, null)
+        );
+    }
+
+    public void testGetInitialAggregatedValue() {
+        long randomLong = randomLong();
+        assertEquals(randomLong, (long) aggregator.getInitialAggregatedValue(randomLong));
+    }
+
+    public void testToAggregatedValueType() {
+        long randomLong = randomLong();
+        assertEquals(randomLong, (long) aggregator.toAggregatedValueType(randomLong));
+    }
+
+    public void testIdentityMetricValue() {
+        assertEquals(1L, (long) aggregator.getIdentityMetricValue());
+    }
+
+    @Override
+    public ValueAggregator getValueAggregator(FieldValueConverter fieldValueConverter) {
+        aggregator = new DocCountAggregator();
+        return aggregator;
+    }
+
+    @Override
+    public void testGetInitialAggregatedValueForSegmentDocValue() {
+        long randomLong = randomLong();
+        assertEquals(randomLong, (long) aggregator.getInitialAggregatedValueForSegmentDocValue(randomLong));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MaxValueAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MaxValueAggregatorTests.java
new file mode 100644
index 0000000000000..b713a47ed5f62
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MaxValueAggregatorTests.java
@@ -0,0 +1,65 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.NumberFieldMapper;
+
+public class MaxValueAggregatorTests extends AbstractValueAggregatorTests {
+
+    private MaxValueAggregator aggregator;
+
+    public MaxValueAggregatorTests(FieldValueConverter fieldValueConverter) {
+        super(fieldValueConverter);
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue() {
+        Long randomLong = randomLong();
+        double randomDouble = randomDouble();
+        assertEquals(
+            Math.max(fieldValueConverter.toDoubleValue(randomLong), randomDouble),
+            aggregator.mergeAggregatedValueAndSegmentValue(randomDouble, randomLong),
+            0.0
+        );
+        assertEquals(fieldValueConverter.toDoubleValue(randomLong), aggregator.mergeAggregatedValueAndSegmentValue(null, randomLong), 0.0);
+        assertEquals(randomDouble, aggregator.mergeAggregatedValueAndSegmentValue(randomDouble, null), 0.0);
+        assertEquals(Math.max(2.0, fieldValueConverter.toDoubleValue(3L)), aggregator.mergeAggregatedValueAndSegmentValue(2.0, 3L), 0.0);
+    }
+
+    public void testMergeAggregatedValues() {
+        double randomDouble = randomDouble();
+        assertEquals(randomDouble, aggregator.mergeAggregatedValues(Double.MIN_VALUE, randomDouble), 0.0);
+        assertEquals(randomDouble, aggregator.mergeAggregatedValues(null, randomDouble), 0.0);
+        assertEquals(randomDouble, aggregator.mergeAggregatedValues(randomDouble, null), 0.0);
+        assertEquals(3.0, aggregator.mergeAggregatedValues(2.0, 3.0), 0.0);
+    }
+
+    public void testGetInitialAggregatedValue() {
+        double randomDouble = randomDouble();
+        assertEquals(randomDouble, aggregator.getInitialAggregatedValue(randomDouble), 0.0);
+    }
+
+    public void testToAggregatedValueType() {
+        MaxValueAggregator aggregator = new MaxValueAggregator(NumberFieldMapper.NumberType.DOUBLE);
+        long randomLong = randomLong();
+        assertEquals(NumericUtils.sortableLongToDouble(randomLong), aggregator.toAggregatedValueType(randomLong), 0.0);
+    }
+
+    public void testIdentityMetricValue() {
+        assertNull(aggregator.getIdentityMetricValue());
+    }
+
+    @Override
+    public ValueAggregator getValueAggregator(FieldValueConverter fieldValueConverter) {
+        aggregator = new MaxValueAggregator(fieldValueConverter);
+        return aggregator;
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfoTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfoTests.java
new file mode 100644
index 0000000000000..5588cc1b366c9
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MetricAggregatorInfoTests.java
@@ -0,0 +1,110 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class MetricAggregatorInfoTests extends OpenSearchTestCase {
+
+    public void testConstructor() {
+        MetricAggregatorInfo pair = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        assertEquals(MetricStat.SUM, pair.getMetricStat());
+        assertEquals("column1", pair.getField());
+    }
+
+    public void testCountStarConstructor() {
+        MetricAggregatorInfo pair = new MetricAggregatorInfo(
+            MetricStat.VALUE_COUNT,
+            "anything",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        assertEquals(MetricStat.VALUE_COUNT, pair.getMetricStat());
+        assertEquals("anything", pair.getField());
+    }
+
+    public void testToFieldName() {
+        MetricAggregatorInfo pair = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column2",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        assertEquals("star_tree_field_column2_sum", pair.toFieldName());
+    }
+
+    public void testEquals() {
+        MetricAggregatorInfo pair1 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        MetricAggregatorInfo pair2 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        assertEquals(pair1, pair2);
+        assertNotEquals(
+            pair1,
+            new MetricAggregatorInfo(MetricStat.VALUE_COUNT, "column1", "star_tree_field", NumberFieldMapper.NumberType.DOUBLE)
+        );
+        assertNotEquals(pair1, new MetricAggregatorInfo(MetricStat.SUM, "column2", "star_tree_field", NumberFieldMapper.NumberType.DOUBLE));
+    }
+
+    public void testHashCode() {
+        MetricAggregatorInfo pair1 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        MetricAggregatorInfo pair2 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        assertEquals(pair1.hashCode(), pair2.hashCode());
+    }
+
+    public void testCompareTo() {
+        MetricAggregatorInfo pair1 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column1",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        MetricAggregatorInfo pair2 = new MetricAggregatorInfo(
+            MetricStat.SUM,
+            "column2",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        MetricAggregatorInfo pair3 = new MetricAggregatorInfo(
+            MetricStat.VALUE_COUNT,
+            "column1",
+            "star_tree_field",
+            NumberFieldMapper.NumberType.DOUBLE
+        );
+        assertTrue(pair1.compareTo(pair2) < 0);
+        assertTrue(pair2.compareTo(pair1) > 0);
+        assertTrue(pair1.compareTo(pair3) > 0);
+        assertTrue(pair3.compareTo(pair1) < 0);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MinValueAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MinValueAggregatorTests.java
new file mode 100644
index 0000000000000..ec406d71ff633
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/MinValueAggregatorTests.java
@@ -0,0 +1,64 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.NumberFieldMapper;
+
+public class MinValueAggregatorTests extends AbstractValueAggregatorTests {
+    private MinValueAggregator aggregator;
+
+    public MinValueAggregatorTests(FieldValueConverter fieldValueConverter) {
+        super(fieldValueConverter);
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue() {
+        Long randomLong = randomLong();
+        double randomDouble = randomDouble();
+        assertEquals(
+            Math.min(fieldValueConverter.toDoubleValue(randomLong), randomDouble),
+            aggregator.mergeAggregatedValueAndSegmentValue(randomDouble, randomLong),
+            0.0
+        );
+        assertEquals(fieldValueConverter.toDoubleValue(randomLong), aggregator.mergeAggregatedValueAndSegmentValue(null, randomLong), 0.0);
+        assertEquals(randomDouble, aggregator.mergeAggregatedValueAndSegmentValue(randomDouble, null), 0.0);
+        assertEquals(Math.min(2.0, fieldValueConverter.toDoubleValue(3L)), aggregator.mergeAggregatedValueAndSegmentValue(2.0, 3L), 0.0);
+    }
+
+    public void testMergeAggregatedValues() {
+        double randomDouble = randomDouble();
+        assertEquals(randomDouble, aggregator.mergeAggregatedValues(Double.MAX_VALUE, randomDouble), 0.0);
+        assertEquals(randomDouble, aggregator.mergeAggregatedValues(null, randomDouble), 0.0);
+        assertEquals(randomDouble, aggregator.mergeAggregatedValues(randomDouble, null), 0.0);
+        assertEquals(2.0, aggregator.mergeAggregatedValues(2.0, 3.0), 0.0);
+    }
+
+    public void testGetInitialAggregatedValue() {
+        double randomDouble = randomDouble();
+        assertEquals(randomDouble, aggregator.getInitialAggregatedValue(randomDouble), 0.0);
+    }
+
+    public void testToAggregatedValueType() {
+        MinValueAggregator aggregator = new MinValueAggregator(NumberFieldMapper.NumberType.DOUBLE);
+        long randomLong = randomLong();
+        assertEquals(NumericUtils.sortableLongToDouble(randomLong), aggregator.toAggregatedValueType(randomLong), 0.0);
+    }
+
+    public void testIdentityMetricValue() {
+        assertNull(aggregator.getIdentityMetricValue());
+    }
+
+    @Override
+    public ValueAggregator getValueAggregator(FieldValueConverter fieldValueConverter) {
+        aggregator = new MinValueAggregator(fieldValueConverter);
+        return aggregator;
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/StaticValueAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/StaticValueAggregatorTests.java
new file mode 100644
index 0000000000000..2ba29a1165dc8
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/StaticValueAggregatorTests.java
@@ -0,0 +1,133 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.search.aggregations.metrics.CompensatedSum;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class StaticValueAggregatorTests extends OpenSearchTestCase {
+
+    // tests the extreme case where normal sum will lose precision
+    public void testKahanSummation() {
+        double[] numbers = { 1e-16, 1, -1e-16 };
+        double expected = 1;
+
+        // initializing our sum aggregator to derive exact sum using kahan summation
+        double aggregatedValue = getAggregatedValue(numbers);
+        assertEquals(expected, aggregatedValue, 0);
+
+        // assert kahan summation plain logic with our aggregated value
+        double actual = kahanSum(numbers);
+        assertEquals(actual, aggregatedValue, 0);
+
+        // assert that normal sum fails for this case
+        double normalSum = normalSum(numbers);
+        assertNotEquals(expected, normalSum, 0);
+        assertNotEquals(actual, normalSum, 0);
+        assertNotEquals(aggregatedValue, normalSum, 0);
+
+    }
+
+    private static double getAggregatedValue(double[] numbers) {
+        // explicitly took double to test for most precision
+        // hard to run similar tests for different data types dynamically as inputs and precision vary
+        SumValueAggregator aggregator = new SumValueAggregator(NumberFieldMapper.NumberType.DOUBLE);
+        double aggregatedValue = aggregator.getInitialAggregatedValueForSegmentDocValue(NumericUtils.doubleToSortableLong(numbers[0]));
+        aggregatedValue = aggregator.mergeAggregatedValueAndSegmentValue(aggregatedValue, NumericUtils.doubleToSortableLong(numbers[1]));
+        aggregatedValue = aggregator.mergeAggregatedValueAndSegmentValue(aggregatedValue, NumericUtils.doubleToSortableLong(numbers[2]));
+        return aggregatedValue;
+    }
+
+    private double kahanSum(double[] numbers) {
+        CompensatedSum compensatedSum = new CompensatedSum(0, 0);
+        for (double num : numbers) {
+            compensatedSum.add(num);
+        }
+        return compensatedSum.value();
+    }
+
+    private double normalSum(double[] numbers) {
+        double sum = 0.0;
+        for (double num : numbers) {
+            sum += num;
+        }
+        return sum;
+    }
+
+    public void testMaxAggregatorExtremeValues() {
+        double[] numbers = { Double.MAX_VALUE, Double.MIN_VALUE, 0.0, Double.MAX_VALUE + 1 };
+        double expected = Double.MAX_VALUE + 1;
+        MaxValueAggregator aggregator = new MaxValueAggregator(NumberFieldMapper.NumberType.DOUBLE);
+        double aggregatedValue = aggregator.getInitialAggregatedValueForSegmentDocValue(NumericUtils.doubleToSortableLong(numbers[0]));
+        for (int i = 1; i < numbers.length; i++) {
+            aggregatedValue = aggregator.mergeAggregatedValueAndSegmentValue(
+                aggregatedValue,
+                NumericUtils.doubleToSortableLong(numbers[i])
+            );
+        }
+        assertEquals(expected, aggregatedValue, 0);
+    }
+
+    public void testMaxAggregatorExtremeValues_Infinity() {
+        double[] numbers = {
+            Double.MAX_VALUE,
+            Double.MIN_VALUE,
+            0.0,
+            Double.MAX_VALUE + 1,
+            Double.POSITIVE_INFINITY,
+            Double.NEGATIVE_INFINITY };
+        double expected = Double.POSITIVE_INFINITY;
+        MaxValueAggregator aggregator = new MaxValueAggregator(NumberFieldMapper.NumberType.DOUBLE);
+        double aggregatedValue = aggregator.getInitialAggregatedValueForSegmentDocValue(NumericUtils.doubleToSortableLong(numbers[0]));
+        for (int i = 1; i < numbers.length; i++) {
+            aggregatedValue = aggregator.mergeAggregatedValueAndSegmentValue(
+                aggregatedValue,
+                NumericUtils.doubleToSortableLong(numbers[i])
+            );
+        }
+        assertEquals(expected, aggregatedValue, 0);
+    }
+
+    public void testMinAggregatorExtremeValues() {
+        double[] numbers = { Double.MAX_VALUE, Double.MIN_VALUE - 1, 0.0, Double.MAX_VALUE + 1 };
+        double expected = Double.MIN_VALUE - 1;
+        MinValueAggregator aggregator = new MinValueAggregator(NumberFieldMapper.NumberType.DOUBLE);
+        double aggregatedValue = aggregator.getInitialAggregatedValueForSegmentDocValue(NumericUtils.doubleToSortableLong(numbers[0]));
+        for (int i = 1; i < numbers.length; i++) {
+            aggregatedValue = aggregator.mergeAggregatedValueAndSegmentValue(
+                aggregatedValue,
+                NumericUtils.doubleToSortableLong(numbers[i])
+            );
+        }
+        assertEquals(expected, aggregatedValue, 0);
+    }
+
+    public void testMinAggregatorExtremeValues_Infinity() {
+        double[] numbers = {
+            Double.MAX_VALUE,
+            Double.MIN_VALUE,
+            0.0,
+            Double.MAX_VALUE + 1,
+            Double.POSITIVE_INFINITY,
+            Double.NEGATIVE_INFINITY };
+        double expected = Double.NEGATIVE_INFINITY;
+        MinValueAggregator aggregator = new MinValueAggregator(NumberFieldMapper.NumberType.DOUBLE);
+        double aggregatedValue = aggregator.getInitialAggregatedValueForSegmentDocValue(NumericUtils.doubleToSortableLong(numbers[0]));
+        for (int i = 1; i < numbers.length; i++) {
+            aggregatedValue = aggregator.mergeAggregatedValueAndSegmentValue(
+                aggregatedValue,
+                NumericUtils.doubleToSortableLong(numbers[i])
+            );
+        }
+        assertEquals(expected, aggregatedValue, 0);
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregatorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregatorTests.java
new file mode 100644
index 0000000000000..ef328fe7eafc2
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/SumValueAggregatorTests.java
@@ -0,0 +1,78 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.mapper.FieldValueConverter;
+
+public class SumValueAggregatorTests extends AbstractValueAggregatorTests {
+
+    private SumValueAggregator aggregator;
+
+    public SumValueAggregatorTests(FieldValueConverter fieldValueConverter) {
+        super(fieldValueConverter);
+    }
+
+    @Override
+    public ValueAggregator getValueAggregator(FieldValueConverter fieldValueConverter) {
+        aggregator = new SumValueAggregator(fieldValueConverter);
+        return aggregator;
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue() {
+        double randomDouble = randomDouble();
+        Long randomLong = randomLong();
+        aggregator.getInitialAggregatedValue(randomDouble);
+        assertEquals(
+            randomDouble + fieldValueConverter.toDoubleValue(randomLong),
+            aggregator.mergeAggregatedValueAndSegmentValue(randomDouble, randomLong),
+            0.0
+        );
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue_nullSegmentDocValue() {
+        double randomDouble1 = randomDouble();
+        Long randomLong = randomLong();
+        aggregator.getInitialAggregatedValue(randomDouble1);
+        assertEquals(randomDouble1, aggregator.mergeAggregatedValueAndSegmentValue(randomDouble1, null), 0.0);
+        assertEquals(
+            randomDouble1 + fieldValueConverter.toDoubleValue(randomLong),
+            aggregator.mergeAggregatedValueAndSegmentValue(randomDouble1, randomLong),
+            0.0
+        );
+    }
+
+    public void testMergeAggregatedValueAndSegmentValue_nullInitialDocValue() {
+        Long randomLong = randomLong();
+        aggregator.getInitialAggregatedValue(null);
+        assertEquals(fieldValueConverter.toDoubleValue(randomLong), aggregator.mergeAggregatedValueAndSegmentValue(null, randomLong), 0.0);
+    }
+
+    public void testMergeAggregatedValues() {
+        double randomDouble1 = randomDouble();
+        double randomDouble2 = randomDouble();
+        aggregator.getInitialAggregatedValue(randomDouble1);
+        assertEquals(randomDouble1, aggregator.mergeAggregatedValues(null, randomDouble1), 0.0);
+        assertEquals(randomDouble1 + randomDouble2, aggregator.mergeAggregatedValues(randomDouble2, randomDouble1), 0.0);
+    }
+
+    public void testGetInitialAggregatedValue() {
+        double randomDouble = randomDouble();
+        assertEquals(randomDouble, aggregator.getInitialAggregatedValue(randomDouble), 0.0);
+    }
+
+    public void testToAggregatedValueType() {
+        long randomLong = randomLong();
+        assertEquals(aggregator.toAggregatedValueType(randomLong), aggregator.toAggregatedValueType(randomLong), 0.0);
+    }
+
+    public void testIdentityMetricValue() {
+        assertEquals(0.0, aggregator.getIdentityMetricValue(), 0);
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactoryTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactoryTests.java
new file mode 100644
index 0000000000000..96ab1b3a52e8b
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/aggregators/ValueAggregatorFactoryTests.java
@@ -0,0 +1,48 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.aggregators;
+
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+
+public class ValueAggregatorFactoryTests extends OpenSearchTestCase {
+
+    public void testGetValueAggregatorForSumType() {
+        ValueAggregator aggregator = ValueAggregatorFactory.getValueAggregator(MetricStat.SUM, NumberFieldMapper.NumberType.LONG);
+        assertNotNull(aggregator);
+        assertEquals(SumValueAggregator.class, aggregator.getClass());
+    }
+
+    public void testGetValueAggregatorForMinType() {
+        ValueAggregator aggregator = ValueAggregatorFactory.getValueAggregator(MetricStat.MIN, NumberFieldMapper.NumberType.LONG);
+        assertNotNull(aggregator);
+        assertEquals(MinValueAggregator.class, aggregator.getClass());
+    }
+
+    public void testGetValueAggregatorForMaxType() {
+        ValueAggregator aggregator = ValueAggregatorFactory.getValueAggregator(MetricStat.MAX, NumberFieldMapper.NumberType.LONG);
+        assertNotNull(aggregator);
+        assertEquals(MaxValueAggregator.class, aggregator.getClass());
+    }
+
+    public void testGetValueAggregatorForCountType() {
+        ValueAggregator aggregator = ValueAggregatorFactory.getValueAggregator(MetricStat.VALUE_COUNT, NumberFieldMapper.NumberType.LONG);
+        assertNotNull(aggregator);
+        assertEquals(CountValueAggregator.class, aggregator.getClass());
+    }
+
+    public void testGetValueAggregatorForAvgType() {
+        assertThrows(
+            IllegalStateException.class,
+            () -> ValueAggregatorFactory.getValueAggregator(MetricStat.AVG, NumberFieldMapper.NumberType.LONG)
+        );
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractStarTreeBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractStarTreeBuilderTests.java
new file mode 100644
index 0000000000000..65adc43ea8bea
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/AbstractStarTreeBuilderTests.java
@@ -0,0 +1,4463 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.EmptyDocValuesProducer;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.IndexFileNames;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentReadState;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.sandbox.document.HalfFloatPoint;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.NumericUtils;
+import org.apache.lucene.util.Version;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.codec.composite.LuceneDocValuesConsumerFactory;
+import org.opensearch.index.codec.composite.LuceneDocValuesProducerFactory;
+import org.opensearch.index.codec.composite.composite99.Composite99Codec;
+import org.opensearch.index.codec.composite.composite99.Composite99DocValuesFormat;
+import org.opensearch.index.compositeindex.CompositeIndexConstants;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.NumericDimension;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeTestUtils;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.meta.StarTreeMetadata;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.compositeindex.datacube.startree.node.InMemoryTreeNode;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNodeType;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils;
+import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.DocumentMapper;
+import org.opensearch.index.mapper.FieldValueConverter;
+import org.opensearch.index.mapper.Mapper;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.MappingLookup;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Queue;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Supplier;
+
+import static org.opensearch.index.compositeindex.datacube.startree.StarTreeTestUtils.validateFileFormats;
+import static org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter.VERSION_CURRENT;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeDimensionsDocValues;
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues;
+import static org.opensearch.index.mapper.CompositeMappedFieldType.CompositeFieldType.STAR_TREE;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public abstract class AbstractStarTreeBuilderTests extends OpenSearchTestCase {
+    protected MapperService mapperService;
+    protected List<Dimension> dimensionsOrder;
+    protected List<String> fields = List.of();
+    protected List<Metric> metrics;
+    protected Directory directory;
+    protected FieldInfo[] fieldsInfo;
+    protected StarTreeField compositeField;
+    protected Map<String, DocValuesProducer> fieldProducerMap;
+    protected SegmentWriteState writeState;
+    protected BaseStarTreeBuilder builder;
+    protected IndexOutput dataOut;
+    protected IndexOutput metaOut;
+    protected DocValuesConsumer docValuesConsumer;
+    protected String dataFileName;
+    protected String metaFileName;
+
+    @Before
+    public void setup() throws IOException {
+        fields = List.of("field1", "field2", "field3", "field4", "field5", "field6", "field7", "field8", "field9", "field10");
+
+        dimensionsOrder = List.of(
+            new NumericDimension("field1"),
+            new NumericDimension("field3"),
+            new NumericDimension("field5"),
+            new NumericDimension("field8")
+        );
+        metrics = List.of(
+            new Metric("field2", List.of(MetricStat.SUM)),
+            new Metric("field4", List.of(MetricStat.SUM)),
+            new Metric("field6", List.of(MetricStat.VALUE_COUNT)),
+            new Metric("field9", List.of(MetricStat.MIN)),
+            new Metric("field10", List.of(MetricStat.MAX)),
+            new Metric("_doc_count", List.of(MetricStat.DOC_COUNT))
+        );
+
+        DocValuesProducer docValuesProducer = mock(DocValuesProducer.class);
+
+        compositeField = new StarTreeField(
+            "test",
+            dimensionsOrder,
+            metrics,
+            new StarTreeFieldConfiguration(1, Set.of("field8"), getBuildMode())
+        );
+        directory = newFSDirectory(createTempDir());
+
+        fieldsInfo = new FieldInfo[fields.size()];
+        fieldProducerMap = new HashMap<>();
+        for (int i = 0; i < fieldsInfo.length; i++) {
+            fieldsInfo[i] = new FieldInfo(
+                fields.get(i),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+            fieldProducerMap.put(fields.get(i), docValuesProducer);
+        }
+        writeState = getWriteState(5, UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8));
+
+        dataFileName = IndexFileNames.segmentFileName(
+            writeState.segmentInfo.name,
+            writeState.segmentSuffix,
+            Composite99DocValuesFormat.DATA_EXTENSION
+        );
+        dataOut = writeState.directory.createOutput(dataFileName, writeState.context);
+
+        metaFileName = IndexFileNames.segmentFileName(
+            writeState.segmentInfo.name,
+            writeState.segmentSuffix,
+            Composite99DocValuesFormat.META_EXTENSION
+        );
+        metaOut = writeState.directory.createOutput(metaFileName, writeState.context);
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder("field6", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper4 = new NumberFieldMapper.Builder("field9", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper5 = new NumberFieldMapper.Builder("field10", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3, numberFieldMapper4, numberFieldMapper5),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+        docValuesConsumer = mock(DocValuesConsumer.class);
+    }
+
+    private SegmentReadState getReadState(int numDocs, List<String> dimensionFields, List<Metric> metrics) {
+
+        int numMetrics = 0;
+        for (Metric metric : metrics) {
+            numMetrics += metric.getBaseMetrics().size();
+        }
+
+        FieldInfo[] fields = new FieldInfo[dimensionFields.size() + numMetrics];
+
+        int i = 0;
+        for (String dimension : dimensionFields) {
+            fields[i] = new FieldInfo(
+                fullyQualifiedFieldNameForStarTreeDimensionsDocValues(compositeField.getName(), dimension),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+            i++;
+        }
+
+        for (Metric metric : metrics) {
+            for (MetricStat metricStat : metric.getBaseMetrics()) {
+                fields[i] = new FieldInfo(
+                    fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                        compositeField.getName(),
+                        metric.getField(),
+                        metricStat.getTypeName()
+                    ),
+                    i,
+                    false,
+                    false,
+                    true,
+                    IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                    DocValuesType.SORTED_NUMERIC,
+                    -1,
+                    Collections.emptyMap(),
+                    0,
+                    0,
+                    0,
+                    0,
+                    VectorEncoding.FLOAT32,
+                    VectorSimilarityFunction.EUCLIDEAN,
+                    false,
+                    false
+                );
+                i++;
+            }
+        }
+
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            numDocs,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            writeState.segmentInfo.getId(),
+            new HashMap<>(),
+            null
+        );
+        return new SegmentReadState(segmentInfo.dir, segmentInfo, new FieldInfos(fields), writeState.context);
+    }
+
+    private SegmentWriteState getWriteState(int numDocs, byte[] id) {
+        FieldInfos fieldInfos = new FieldInfos(fieldsInfo);
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            numDocs,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            id,
+            new HashMap<>(),
+            null
+        );
+        return new SegmentWriteState(InfoStream.getDefault(), segmentInfo.dir, segmentInfo, fieldInfos, null, newIOContext(random()));
+    }
+
+    public abstract BaseStarTreeBuilder getStarTreeBuilder(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        StarTreeField starTreeField,
+        SegmentWriteState segmentWriteState,
+        MapperService mapperService
+    ) throws IOException;
+
+    public void test_sortAndAggregateStarTreeDocuments() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 12.0, 10.0, randomDouble(), 8.0, 20.0, 10L }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 10.0, 6.0, randomDouble(), 12.0, 10.0, 10L }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 14.0, 12.0, randomDouble(), 6.0, 24.0, 10L }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 9.0, 4.0, randomDouble(), 9.0, 12.0, null }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 11.0, 16.0, randomDouble(), 8.0, 13.0, null }
+        );
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            Long metric6 = (Long) starTreeDocuments[i].metrics[5];
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Long[] { metric1, metric2, metric3, metric4, metric5, metric6 }
+            );
+        }
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L, 8.0, 20.0, 11L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 35.0, 34.0, 3L, 6.0, 24.0, 21L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+
+        int numOfAggregatedDocuments = 0;
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+            assertEquals(expectedStarTreeDocument.metrics[5], resultStarTreeDocument.metrics[5]);
+
+            numOfAggregatedDocuments++;
+        }
+
+        assertEquals(inorderStarTreeDocuments.size(), numOfAggregatedDocuments);
+    }
+
+    SequentialDocValuesIterator[] getDimensionIterators(StarTreeDocument[] starTreeDocuments) {
+        SequentialDocValuesIterator[] sequentialDocValuesIterators =
+            new SequentialDocValuesIterator[starTreeDocuments[0].dimensions.length];
+        for (int j = 0; j < starTreeDocuments[0].dimensions.length; j++) {
+            List<Long> dimList = new ArrayList<>();
+            List<Integer> docsWithField = new ArrayList<>();
+
+            for (int i = 0; i < starTreeDocuments.length; i++) {
+                if (starTreeDocuments[i].dimensions[j] != null) {
+                    dimList.add(starTreeDocuments[i].dimensions[j]);
+                    docsWithField.add(i);
+                }
+            }
+            sequentialDocValuesIterators[j] = new SequentialDocValuesIterator(getSortedNumericMock(dimList, docsWithField));
+        }
+        return sequentialDocValuesIterators;
+    }
+
+    List<SequentialDocValuesIterator> getMetricIterators(StarTreeDocument[] starTreeDocuments) {
+        List<SequentialDocValuesIterator> sequentialDocValuesIterators = new ArrayList<>();
+        for (int j = 0; j < starTreeDocuments[0].metrics.length; j++) {
+            List<Long> metricslist = new ArrayList<>();
+            List<Integer> docsWithField = new ArrayList<>();
+
+            for (int i = 0; i < starTreeDocuments.length; i++) {
+                if (starTreeDocuments[i].metrics[j] != null) {
+                    metricslist.add((long) starTreeDocuments[i].metrics[j]);
+                    docsWithField.add(i);
+                }
+            }
+            sequentialDocValuesIterators.add(new SequentialDocValuesIterator(getSortedNumericMock(metricslist, docsWithField)));
+        }
+        return sequentialDocValuesIterators;
+    }
+
+    public void test_sortAndAggregateStarTreeDocuments_nullMetric() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { 12.0, 10.0, randomDouble(), 8.0, 20.0 });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 10.0, 6.0, randomDouble(), 12.0, 10.0 });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 14.0, 12.0, randomDouble(), 6.0, 24.0 });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { 9.0, 4.0, randomDouble(), 9.0, 12.0 });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 11.0, null, randomDouble(), 8.0, 13.0 });
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L, 8.0, 20.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 35.0, 18.0, 3L, 6.0, 24.0, 3L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            Long metric2 = starTreeDocuments[i].metrics[1] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1])
+                : null;
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Object[] { metric1, metric2, metric3, metric4, metric5, null }
+            );
+        }
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+            assertEquals(expectedStarTreeDocument.metrics[5], resultStarTreeDocument.metrics[5]);
+        }
+    }
+
+    public void test_sortAndAggregateStarTreeDocuments_nullMetricField() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        // Setting second metric iterator as empty sorted numeric , indicating a metric field is null
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 12.0, null, randomDouble(), 8.0, 20.0, null }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 10.0, null, randomDouble(), 12.0, 10.0, null }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 14.0, null, randomDouble(), 6.0, 24.0, null }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 9.0, null, randomDouble(), 9.0, 12.0, 10L }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 11.0, null, randomDouble(), 8.0, 13.0, null }
+        );
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { 21.0, 0.0, 2L, 8.0, 20.0, 11L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 35.0, 0.0, 3L, 6.0, 24.0, 3L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            Long metric2 = starTreeDocuments[i].metrics[1] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1])
+                : null;
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            Long metric6 = starTreeDocuments[i].metrics[5] != null ? (Long) starTreeDocuments[i].metrics[5] : null;
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Object[] { metric1, metric2, metric3, metric4, metric5, metric6 }
+            );
+        }
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+            assertEquals(expectedStarTreeDocument.metrics[5], resultStarTreeDocument.metrics[5]);
+        }
+    }
+
+    public void test_sortAndAggregateStarTreeDocuments_nullAndMinusOneInDimensionField() throws IOException {
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        // Setting second metric iterator as empty sorted numeric , indicating a metric field is null
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 2L, null, 3L, 4L },
+            new Object[] { 12.0, null, randomDouble(), 8.0, 20.0, null }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { null, 4L, 2L, 1L },
+            new Object[] { 10.0, null, randomDouble(), 12.0, 10.0, null }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { null, 4L, 2L, 1L },
+            new Object[] { 14.0, null, randomDouble(), 6.0, 24.0, null }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { 2L, null, 3L, 4L },
+            new Object[] { 9.0, null, randomDouble(), 9.0, 12.0, 10L }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { -1L, 4L, 2L, 1L },
+            new Object[] { 11.0, null, randomDouble(), 8.0, 13.0, null }
+        );
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { -1L, 4L, 2L, 1L }, new Object[] { 11.0, 0.0, 1L, 8.0, 13.0, 1L }),
+            new StarTreeDocument(new Long[] { 2L, null, 3L, 4L }, new Object[] { 21.0, 0.0, 2L, 8.0, 20.0, 11L }),
+            new StarTreeDocument(new Long[] { null, 4L, 2L, 1L }, new Object[] { 24.0, 0.0, 2L, 6.0, 24.0, 2L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            Long metric2 = starTreeDocuments[i].metrics[1] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1])
+                : null;
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            Long metric6 = starTreeDocuments[i].metrics[5] != null ? (long) starTreeDocuments[i].metrics[5] : null;
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Object[] { metric1, metric2, metric3, metric4, metric5, metric6 }
+            );
+        }
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+
+        while (segmentStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+            assertEquals(expectedStarTreeDocument.metrics[5], resultStarTreeDocument.metrics[5]);
+        }
+
+        assertFalse(expectedStarTreeDocumentIterator.hasNext());
+
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        validateStarTree(builder.getRootNode(), 4, 1, builder.getStarTreeDocuments());
+    }
+
+    public void test_sortAndAggregateStarTreeDocuments_nullDimensionsAndNullMetrics() throws IOException {
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        // Setting second metric iterator as empty sorted numeric , indicating a metric field is null
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { null, null, null, null, null, null }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { null, null, null, null, null, null }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { null, null, null, null, null, null }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { null, null, null, null, null, null }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { null, null, null, null, null, null }
+        );
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { null, null, null, null }, new Object[] { 0.0, 0.0, 0L, null, null, 5L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            Long metric1 = starTreeDocuments[i].metrics[0] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0])
+                : null;
+            Long metric2 = starTreeDocuments[i].metrics[1] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1])
+                : null;
+            Long metric3 = starTreeDocuments[i].metrics[2] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2])
+                : null;
+            Long metric4 = starTreeDocuments[i].metrics[3] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3])
+                : null;
+            Long metric5 = starTreeDocuments[i].metrics[4] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4])
+                : null;
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Object[] { metric1, metric2, metric3, metric4, metric5, null }
+            );
+        }
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+            assertEquals(expectedStarTreeDocument.metrics[5], resultStarTreeDocument.metrics[5]);
+        }
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        validateStarTree(builder.getRootNode(), 4, 1, builder.getStarTreeDocuments());
+    }
+
+    public void test_sortAndAggregateStarTreeDocuments_nullDimensionsAndFewNullMetrics() throws IOException {
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        double sumValue = randomDouble();
+        double minValue = randomDouble();
+        double maxValue = randomDouble();
+
+        // Setting second metric iterator as empty sorted numeric , indicating a metric field is null
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { null, null, randomDouble(), null, maxValue }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { null, null, null, null }, new Object[] { null, null, null, null, null });
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { null, null, null, minValue, null }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { null, null, null, null }, new Object[] { null, null, null, null, null });
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { sumValue, null, randomDouble(), null, null }
+        );
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { null, null, null, null }, new Object[] { sumValue, 0.0, 2L, minValue, maxValue, 5L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            Long metric1 = starTreeDocuments[i].metrics[0] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0])
+                : null;
+            Long metric2 = starTreeDocuments[i].metrics[1] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1])
+                : null;
+            Long metric3 = starTreeDocuments[i].metrics[2] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2])
+                : null;
+            Long metric4 = starTreeDocuments[i].metrics[3] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3])
+                : null;
+            Long metric5 = starTreeDocuments[i].metrics[4] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4])
+                : null;
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Object[] { metric1, metric2, metric3, metric4, metric5, null }
+            );
+        }
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+            assertEquals(expectedStarTreeDocument.metrics[5], resultStarTreeDocument.metrics[5]);
+        }
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        validateStarTree(builder.getRootNode(), 4, 1, builder.getStarTreeDocuments());
+    }
+
+    public void test_sortAndAggregateStarTreeDocuments_emptyDimensions() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        // Setting second metric iterator as empty sorted numeric , indicating a metric field is null
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { 12.0, null, randomDouble(), 8.0, 20.0, 10L }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { 10.0, null, randomDouble(), 12.0, 10.0, 10L }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { 14.0, null, randomDouble(), 6.0, 24.0, 10L }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { 9.0, null, randomDouble(), 9.0, 12.0, 10L }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { null, null, null, null },
+            new Object[] { 11.0, null, randomDouble(), 8.0, 13.0, 10L }
+        );
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { null, null, null, null }, new Object[] { 56.0, 0.0, 5L, 6.0, 24.0, 50L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            Long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            Long metric2 = starTreeDocuments[i].metrics[1] != null
+                ? NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1])
+                : null;
+            Long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            Long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            Long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            Long metric6 = (Long) starTreeDocuments[i].metrics[5];
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Object[] { metric1, metric2, metric3, metric4, metric5, metric6 }
+            );
+        }
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+            assertEquals(expectedStarTreeDocument.metrics[5], resultStarTreeDocument.metrics[5]);
+        }
+    }
+
+    public void test_sortAndAggregateStarTreeDocument_longMaxAndLongMinDimensions() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { Long.MIN_VALUE, 4L, 3L, 4L },
+            new Object[] { 12.0, 10.0, randomDouble(), 8.0, 20.0 }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, Long.MAX_VALUE },
+            new Object[] { 10.0, 6.0, randomDouble(), 12.0, 10.0 }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, Long.MAX_VALUE },
+            new Object[] { 14.0, 12.0, randomDouble(), 6.0, 24.0 }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { Long.MIN_VALUE, 4L, 3L, 4L },
+            new Object[] { 9.0, 4.0, randomDouble(), 9.0, 12.0 }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, Long.MAX_VALUE },
+            new Object[] { 11.0, 16.0, randomDouble(), 8.0, 13.0 }
+        );
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { Long.MIN_VALUE, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L, 8.0, 20.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, Long.MAX_VALUE }, new Object[] { 35.0, 34.0, 3L, 6.0, 24.0, 3L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Long[] { metric1, metric2, metric3, metric4, metric5, null }
+            );
+        }
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+        int numOfAggregatedDocuments = 0;
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+            assertEquals(expectedStarTreeDocument.metrics[5], resultStarTreeDocument.metrics[5]);
+
+            numOfAggregatedDocuments++;
+        }
+
+        assertEquals(inorderStarTreeDocuments.size(), numOfAggregatedDocuments);
+
+    }
+
+    public void test_sortAndAggregateStarTreeDocument_DoubleMaxAndDoubleMinMetrics() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { Double.MAX_VALUE, 10.0, randomDouble(), 8.0, 20.0, 100L }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 10.0, 6.0, randomDouble(), 12.0, 10.0, 100L }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 14.0, Double.MIN_VALUE, randomDouble(), 6.0, 24.0, 100L }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 9.0, 4.0, randomDouble(), 9.0, 12.0, 100L }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 11.0, 16.0, randomDouble(), 8.0, 13.0, 100L }
+        );
+
+        List<StarTreeDocument> inorderStarTreeDocuments = List.of(
+            new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { Double.MAX_VALUE + 9, 14.0, 2L, 8.0, 20.0, 200L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 35.0, Double.MIN_VALUE + 22, 3L, 6.0, 24.0, 300L })
+        );
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = inorderStarTreeDocuments.iterator();
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            Long metric6 = (Long) starTreeDocuments[i].metrics[5];
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Long[] { metric1, metric2, metric3, metric4, metric5, metric6 }
+            );
+        }
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+        int numOfAggregatedDocuments = 0;
+        while (segmentStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = segmentStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+
+            numOfAggregatedDocuments++;
+        }
+
+        assertEquals(inorderStarTreeDocuments.size(), numOfAggregatedDocuments);
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        validateStarTree(builder.getRootNode(), 3, 1, builder.getStarTreeDocuments());
+
+    }
+
+    public void test_build_halfFloatMetrics() throws IOException {
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.HALF_FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.HALF_FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder("field6", NumberFieldMapper.NumberType.HALF_FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper4 = new NumberFieldMapper.Builder("field9", NumberFieldMapper.NumberType.HALF_FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper5 = new NumberFieldMapper.Builder(
+            "field10",
+            NumberFieldMapper.NumberType.HALF_FLOAT,
+            false,
+            true
+        ).build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3, numberFieldMapper4, numberFieldMapper5),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new HalfFloatPoint[] {
+                new HalfFloatPoint("hf1", 12),
+                new HalfFloatPoint("hf6", 10),
+                new HalfFloatPoint("field6", 10),
+                new HalfFloatPoint("field9", 8),
+                new HalfFloatPoint("field10", 20) }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new HalfFloatPoint[] {
+                new HalfFloatPoint("hf2", 10),
+                new HalfFloatPoint("hf7", 6),
+                new HalfFloatPoint("field6", 10),
+                new HalfFloatPoint("field9", 12),
+                new HalfFloatPoint("field10", 10) }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new HalfFloatPoint[] {
+                new HalfFloatPoint("hf3", 14),
+                new HalfFloatPoint("hf8", 12),
+                new HalfFloatPoint("field6", 10),
+                new HalfFloatPoint("field9", 6),
+                new HalfFloatPoint("field10", 24) }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new HalfFloatPoint[] {
+                new HalfFloatPoint("hf4", 9),
+                new HalfFloatPoint("hf9", 4),
+                new HalfFloatPoint("field6", 10),
+                new HalfFloatPoint("field9", 9),
+                new HalfFloatPoint("field10", 12) }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new HalfFloatPoint[] {
+                new HalfFloatPoint("hf5", 11),
+                new HalfFloatPoint("hf10", 16),
+                new HalfFloatPoint("field6", 10),
+                new HalfFloatPoint("field9", 8),
+                new HalfFloatPoint("field10", 13) }
+        );
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = HalfFloatPoint.halfFloatToSortableShort(
+                ((HalfFloatPoint) starTreeDocuments[i].metrics[0]).numericValue().floatValue()
+            );
+            long metric2 = HalfFloatPoint.halfFloatToSortableShort(
+                ((HalfFloatPoint) starTreeDocuments[i].metrics[1]).numericValue().floatValue()
+            );
+            long metric3 = HalfFloatPoint.halfFloatToSortableShort(
+                ((HalfFloatPoint) starTreeDocuments[i].metrics[2]).numericValue().floatValue()
+            );
+            long metric4 = HalfFloatPoint.halfFloatToSortableShort(
+                ((HalfFloatPoint) starTreeDocuments[i].metrics[3]).numericValue().floatValue()
+            );
+            long metric5 = HalfFloatPoint.halfFloatToSortableShort(
+                ((HalfFloatPoint) starTreeDocuments[i].metrics[4]).numericValue().floatValue()
+            );
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Long[] { metric1, metric2, metric3, metric4, metric5, null }
+            );
+        }
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator().iterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "test",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            2,
+            getExpectedStarTreeDocumentIterator().size(),
+            1,
+            Set.of("field8"),
+            getBuildMode(),
+            0,
+            330
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            getExpectedStarTreeDocumentIterator().size(),
+            starTreeMetadata,
+            getExpectedStarTreeDocumentIterator()
+        );
+    }
+
+    public void test_build_floatMetrics() throws IOException {
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder("field6", NumberFieldMapper.NumberType.FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper4 = new NumberFieldMapper.Builder("field9", NumberFieldMapper.NumberType.FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper5 = new NumberFieldMapper.Builder("field10", NumberFieldMapper.NumberType.FLOAT, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3, numberFieldMapper4, numberFieldMapper5),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 12.0F, 10.0F, randomFloat(), 8.0F, 20.0F, null }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 10.0F, 6.0F, randomFloat(), 12.0F, 10.0F, null }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 14.0F, 12.0F, randomFloat(), 6.0F, 24.0F, null }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 9.0F, 4.0F, randomFloat(), 9.0F, 12.0F, null }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 11.0F, 16.0F, randomFloat(), 8.0F, 13.0F, null }
+        );
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.floatToSortableInt((Float) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.floatToSortableInt((Float) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.floatToSortableInt((Float) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.floatToSortableInt((Float) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.floatToSortableInt((Float) starTreeDocuments[i].metrics[4]);
+            Long metric6 = (Long) starTreeDocuments[i].metrics[5];
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Long[] { metric1, metric2, metric3, metric4, metric5, metric6 }
+            );
+        }
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator().iterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "test",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            2,
+            getExpectedStarTreeDocumentIterator().size(),
+            1,
+            Set.of("field8"),
+            getBuildMode(),
+            0,
+            330
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            getExpectedStarTreeDocumentIterator().size(),
+            starTreeMetadata,
+            getExpectedStarTreeDocumentIterator()
+        );
+    }
+
+    abstract StarTreeFieldConfiguration.StarTreeBuildMode getBuildMode();
+
+    public void test_build_longMetrics() throws IOException {
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.LONG, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.LONG, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder("field6", NumberFieldMapper.NumberType.LONG, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper4 = new NumberFieldMapper.Builder("field9", NumberFieldMapper.NumberType.LONG, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper5 = new NumberFieldMapper.Builder("field10", NumberFieldMapper.NumberType.LONG, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3, numberFieldMapper4, numberFieldMapper5),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Long[] { 12L, 10L, randomLong(), 8L, 20L });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Long[] { 10L, 6L, randomLong(), 12L, 10L });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Long[] { 14L, 12L, randomLong(), 6L, 24L });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Long[] { 9L, 4L, randomLong(), 9L, 12L });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Long[] { 11L, 16L, randomLong(), 8L, 13L });
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = (Long) starTreeDocuments[i].metrics[0];
+            long metric2 = (Long) starTreeDocuments[i].metrics[1];
+            long metric3 = (Long) starTreeDocuments[i].metrics[2];
+            long metric4 = (Long) starTreeDocuments[i].metrics[3];
+            long metric5 = (Long) starTreeDocuments[i].metrics[4];
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Long[] { metric1, metric2, metric3, metric4, metric5, null }
+            );
+        }
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator().iterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "test",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            2,
+            getExpectedStarTreeDocumentIterator().size(),
+            1,
+            Set.of("field8"),
+            getBuildMode(),
+            0,
+            330
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            getExpectedStarTreeDocumentIterator().size(),
+            starTreeMetadata,
+            getExpectedStarTreeDocumentIterator()
+        );
+    }
+
+    private static List<StarTreeDocument> getExpectedStarTreeDocumentIterator() {
+        return List.of(
+            new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L, 8.0, 20.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Object[] { 35.0, 34.0, 3L, 6.0, 24.0, 3L }),
+            new StarTreeDocument(new Long[] { null, 4L, 2L, 1L }, new Object[] { 35.0, 34.0, 3L, 6.0, 24.0, 3L }),
+            new StarTreeDocument(new Long[] { null, 4L, 3L, 4L }, new Object[] { 21.0, 14.0, 2L, 8.0, 20.0, 2L }),
+            new StarTreeDocument(new Long[] { null, 4L, null, 1L }, new Object[] { 35.0, 34.0, 3L, 6.0, 24.0, 3L }),
+            new StarTreeDocument(new Long[] { null, 4L, null, 4L }, new Object[] { 21.0, 14.0, 2L, 8.0, 20.0, 2L }),
+            new StarTreeDocument(new Long[] { null, 4L, null, null }, new Object[] { 56.0, 48.0, 5L, 6.0, 24.0, 5L })
+        );
+    }
+
+    public void test_build_multipleStarTrees() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 12.0, 10.0, randomDouble(), 8.0, 20.0 });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 10.0, 6.0, randomDouble(), 12.0, 10.0 });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 14.0, 12.0, randomDouble(), 6.0, 24.0 });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 4L, 3L, 4L }, new Double[] { 9.0, 4.0, randomDouble(), 9.0, 12.0 });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 4L, 2L, 1L }, new Double[] { 11.0, 16.0, randomDouble(), 8.0, 13.0 });
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Long[] { metric1, metric2, metric3, metric4, metric5 }
+            );
+        }
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+
+        metrics = List.of(
+            new Metric("field2", List.of(MetricStat.SUM)),
+            new Metric("field4", List.of(MetricStat.SUM)),
+            new Metric("field6", List.of(MetricStat.VALUE_COUNT)),
+            new Metric("field9", List.of(MetricStat.MIN)),
+            new Metric("field10", List.of(MetricStat.MAX))
+        );
+
+        compositeField = new StarTreeField(
+            "test",
+            dimensionsOrder,
+            metrics,
+            new StarTreeFieldConfiguration(1, Set.of("field8"), getBuildMode())
+        );
+
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator().iterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+        builder.close();
+
+        // building another tree in the same file
+        fields = List.of("fieldC", "fieldB", "fieldL", "fieldI");
+
+        dimensionsOrder = List.of(new NumericDimension("fieldC"), new NumericDimension("fieldB"), new NumericDimension("fieldL"));
+        metrics = List.of(new Metric("fieldI", List.of(MetricStat.SUM)));
+
+        DocValuesProducer docValuesProducer = mock(DocValuesProducer.class);
+
+        compositeField = new StarTreeField("test", dimensionsOrder, metrics, new StarTreeFieldConfiguration(1, Set.of(), getBuildMode()));
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            7,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+
+        fieldsInfo = new FieldInfo[fields.size()];
+        fieldProducerMap = new HashMap<>();
+        for (int i = 0; i < fieldsInfo.length; i++) {
+            fieldsInfo[i] = new FieldInfo(
+                fields.get(i),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+            fieldProducerMap.put(fields.get(i), docValuesProducer);
+        }
+        FieldInfos fieldInfos = new FieldInfos(fieldsInfo);
+        writeState = new SegmentWriteState(InfoStream.getDefault(), segmentInfo.dir, segmentInfo, fieldInfos, null, newIOContext(random()));
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("fieldI", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+
+        InMemoryTreeNode rootNode1 = builder.getRootNode();
+
+        int noOfStarTreeDocuments2 = 7;
+        StarTreeDocument[] starTreeDocuments2 = new StarTreeDocument[noOfStarTreeDocuments2];
+        starTreeDocuments2[0] = new StarTreeDocument(new Long[] { 1L, 11L, 21L }, new Double[] { 400.0 });
+        starTreeDocuments2[1] = new StarTreeDocument(new Long[] { 1L, 12L, 22L }, new Double[] { 200.0 });
+        starTreeDocuments2[2] = new StarTreeDocument(new Long[] { 2L, 13L, 23L }, new Double[] { 300.0 });
+        starTreeDocuments2[3] = new StarTreeDocument(new Long[] { 2L, 13L, 21L }, new Double[] { 100.0 });
+        starTreeDocuments2[4] = new StarTreeDocument(new Long[] { 3L, 11L, 21L }, new Double[] { 600.0 });
+        starTreeDocuments2[5] = new StarTreeDocument(new Long[] { 3L, 12L, 23L }, new Double[] { 200.0 });
+        starTreeDocuments2[6] = new StarTreeDocument(new Long[] { 3L, 12L, 21L }, new Double[] { 400.0 });
+
+        StarTreeDocument[] segmentStarTreeDocuments2 = new StarTreeDocument[noOfStarTreeDocuments2];
+        for (int i = 0; i < noOfStarTreeDocuments2; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments2[i].metrics[0]);
+            segmentStarTreeDocuments2[i] = new StarTreeDocument(starTreeDocuments2[i].dimensions, new Long[] { metric1 });
+        }
+
+        SequentialDocValuesIterator[] dimsIterators2 = getDimensionIterators(segmentStarTreeDocuments2);
+        List<SequentialDocValuesIterator> metricsIterators2 = getMetricIterators(segmentStarTreeDocuments2);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator2 = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators2,
+            metricsIterators2
+        );
+        builder.build(segmentStarTreeDocumentIterator2, new AtomicInteger(), mock(DocValuesConsumer.class));
+        InMemoryTreeNode rootNode2 = builder.getRootNode();
+
+        metaOut.close();
+        dataOut.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "test",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3", "field5", "field8"),
+            List.of(
+                new Metric("field2", List.of(MetricStat.SUM)),
+                new Metric("field4", List.of(MetricStat.SUM)),
+                new Metric("field6", List.of(MetricStat.VALUE_COUNT)),
+                new Metric("field9", List.of(MetricStat.MIN)),
+                new Metric("field10", List.of(MetricStat.MAX))
+            ),
+            2,
+            getExpectedStarTreeDocumentIterator().size(),
+            1,
+            Set.of("field8"),
+            getBuildMode(),
+            0,
+            330
+        );
+
+        StarTreeMetadata starTreeMetadata2 = new StarTreeMetadata(
+            "test",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("fieldC", "fieldB", "fieldL"),
+            List.of(new Metric("fieldI", List.of(MetricStat.SUM))),
+            7,
+            27,
+            1,
+            Set.of(),
+            getBuildMode(),
+            330,
+            1287
+        );
+
+        List<String> totalDimensionFields = new ArrayList<>();
+        totalDimensionFields.addAll(starTreeMetadata.getDimensionFields());
+        totalDimensionFields.addAll(starTreeMetadata2.getDimensionFields());
+
+        List<Metric> metrics = new ArrayList<>();
+        metrics.addAll(starTreeMetadata.getMetrics());
+        metrics.addAll(starTreeMetadata2.getMetrics());
+
+        SegmentReadState readState = getReadState(3, totalDimensionFields, metrics);
+
+        IndexInput dataIn = readState.directory.openInput(dataFileName, IOContext.DEFAULT);
+        IndexInput metaIn = readState.directory.openInput(metaFileName, IOContext.DEFAULT);
+
+        validateFileFormats(dataIn, metaIn, rootNode1, starTreeMetadata);
+        validateFileFormats(dataIn, metaIn, rootNode2, starTreeMetadata2);
+
+        dataIn.close();
+        metaIn.close();
+
+    }
+
+    public void test_build() throws IOException {
+
+        int noOfStarTreeDocuments = 5;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+
+        starTreeDocuments[0] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 12.0, 10.0, randomDouble(), 8.0, 20.0, 1L }
+        );
+        starTreeDocuments[1] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 10.0, 6.0, randomDouble(), 12.0, 10.0, null }
+        );
+        starTreeDocuments[2] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 14.0, 12.0, randomDouble(), 6.0, 24.0, null }
+        );
+        starTreeDocuments[3] = new StarTreeDocument(
+            new Long[] { 2L, 4L, 3L, 4L },
+            new Object[] { 9.0, 4.0, randomDouble(), 9.0, 12.0, null }
+        );
+        starTreeDocuments[4] = new StarTreeDocument(
+            new Long[] { 3L, 4L, 2L, 1L },
+            new Object[] { 11.0, 16.0, randomDouble(), 8.0, 13.0, null }
+        );
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            long metric2 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[1]);
+            long metric3 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[2]);
+            long metric4 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[3]);
+            long metric5 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[4]);
+            Long metric6 = (Long) starTreeDocuments[i].metrics[5];
+            segmentStarTreeDocuments[i] = new StarTreeDocument(
+                starTreeDocuments[i].dimensions,
+                new Long[] { metric1, metric2, metric3, metric4, metric5, metric6 }
+            );
+        }
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+        docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(7, resultStarTreeDocuments.size());
+
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = getExpectedStarTreeDocumentIterator().iterator();
+        assertStarTreeDocuments(resultStarTreeDocuments, expectedStarTreeDocumentIterator);
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "test",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            2,
+            getExpectedStarTreeDocumentIterator().size(),
+            1,
+            Set.of("field8"),
+            getBuildMode(),
+            0,
+            330
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            getExpectedStarTreeDocumentIterator().size(),
+            starTreeMetadata,
+            getExpectedStarTreeDocumentIterator()
+        );
+    }
+
+    private void assertStarTreeDocuments(
+        List<StarTreeDocument> resultStarTreeDocuments,
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator
+    ) {
+        Iterator<StarTreeDocument> resultStarTreeDocumentIterator = resultStarTreeDocuments.iterator();
+        while (resultStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = resultStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.dimensions[3], resultStarTreeDocument.dimensions[3]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+            assertEquals(expectedStarTreeDocument.metrics[2], resultStarTreeDocument.metrics[2]);
+            assertEquals(expectedStarTreeDocument.metrics[3], resultStarTreeDocument.metrics[3]);
+            assertEquals(expectedStarTreeDocument.metrics[4], resultStarTreeDocument.metrics[4]);
+        }
+    }
+
+    public void test_build_starTreeDataset() throws IOException {
+
+        fields = List.of("fieldC", "fieldB", "fieldL", "fieldI");
+
+        dimensionsOrder = List.of(new NumericDimension("fieldC"), new NumericDimension("fieldB"), new NumericDimension("fieldL"));
+        metrics = List.of(new Metric("fieldI", List.of(MetricStat.SUM)), new Metric("_doc_count", List.of(MetricStat.DOC_COUNT)));
+
+        DocValuesProducer docValuesProducer = mock(DocValuesProducer.class);
+
+        compositeField = new StarTreeField("test", dimensionsOrder, metrics, new StarTreeFieldConfiguration(1, Set.of(), getBuildMode()));
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            7,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+
+        fieldsInfo = new FieldInfo[fields.size()];
+        fieldProducerMap = new HashMap<>();
+        for (int i = 0; i < fieldsInfo.length; i++) {
+            fieldsInfo[i] = new FieldInfo(
+                fields.get(i),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+            fieldProducerMap.put(fields.get(i), docValuesProducer);
+        }
+        FieldInfos fieldInfos = new FieldInfos(fieldsInfo);
+        writeState = new SegmentWriteState(InfoStream.getDefault(), segmentInfo.dir, segmentInfo, fieldInfos, null, newIOContext(random()));
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("fieldI", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+
+        int noOfStarTreeDocuments = 7;
+        StarTreeDocument[] starTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        starTreeDocuments[0] = new StarTreeDocument(new Long[] { 1L, 11L, 21L }, new Object[] { 400.0, null });
+        starTreeDocuments[1] = new StarTreeDocument(new Long[] { 1L, 12L, 22L }, new Object[] { 200.0, null });
+        starTreeDocuments[2] = new StarTreeDocument(new Long[] { 2L, 13L, 23L }, new Object[] { 300.0, null });
+        starTreeDocuments[3] = new StarTreeDocument(new Long[] { 2L, 13L, 21L }, new Object[] { 100.0, null });
+        starTreeDocuments[4] = new StarTreeDocument(new Long[] { 3L, 11L, 21L }, new Object[] { 600.0, null });
+        starTreeDocuments[5] = new StarTreeDocument(new Long[] { 3L, 12L, 23L }, new Object[] { 200.0, null });
+        starTreeDocuments[6] = new StarTreeDocument(new Long[] { 3L, 12L, 21L }, new Object[] { 400.0, null });
+
+        StarTreeDocument[] segmentStarTreeDocuments = new StarTreeDocument[noOfStarTreeDocuments];
+        for (int i = 0; i < noOfStarTreeDocuments; i++) {
+            long metric1 = NumericUtils.doubleToSortableLong((Double) starTreeDocuments[i].metrics[0]);
+            segmentStarTreeDocuments[i] = new StarTreeDocument(starTreeDocuments[i].dimensions, new Long[] { metric1, null });
+        }
+
+        SequentialDocValuesIterator[] dimsIterators = getDimensionIterators(segmentStarTreeDocuments);
+        List<SequentialDocValuesIterator> metricsIterators = getMetricIterators(segmentStarTreeDocuments);
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> segmentStarTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimsIterators,
+            metricsIterators
+        );
+        builder.build(segmentStarTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+
+        List<StarTreeDocument> resultStarTreeDocuments = builder.getStarTreeDocuments();
+        Iterator<StarTreeDocument> expectedStarTreeDocumentIterator = expectedStarTreeDocuments().iterator();
+        Iterator<StarTreeDocument> resultStarTreeDocumentIterator = resultStarTreeDocuments.iterator();
+        Map<Integer, Map<Long, Integer>> dimValueToDocIdMap = new HashMap<>();
+        builder.rootNode.setNodeType(StarTreeNodeType.STAR.getValue());
+        traverseStarTree(builder.rootNode, dimValueToDocIdMap, true);
+
+        Map<Integer, Map<Long, Double>> expectedDimToValueMap = getExpectedDimToValueMap();
+        for (Map.Entry<Integer, Map<Long, Integer>> entry : dimValueToDocIdMap.entrySet()) {
+            int dimId = entry.getKey();
+            if (dimId == -1) continue;
+            Map<Long, Double> map = expectedDimToValueMap.get(dimId);
+            for (Map.Entry<Long, Integer> dimValueToDocIdEntry : entry.getValue().entrySet()) {
+                long dimValue = dimValueToDocIdEntry.getKey();
+                int docId = dimValueToDocIdEntry.getValue();
+                if (map.get(dimValue) != null) {
+                    assertEquals(map.get(dimValue), resultStarTreeDocuments.get(docId).metrics[0]);
+                }
+            }
+        }
+
+        while (resultStarTreeDocumentIterator.hasNext() && expectedStarTreeDocumentIterator.hasNext()) {
+            StarTreeDocument resultStarTreeDocument = resultStarTreeDocumentIterator.next();
+            StarTreeDocument expectedStarTreeDocument = expectedStarTreeDocumentIterator.next();
+            assertEquals(expectedStarTreeDocument.dimensions[0], resultStarTreeDocument.dimensions[0]);
+            assertEquals(expectedStarTreeDocument.dimensions[1], resultStarTreeDocument.dimensions[1]);
+            assertEquals(expectedStarTreeDocument.dimensions[2], resultStarTreeDocument.dimensions[2]);
+            assertEquals(expectedStarTreeDocument.metrics[0], resultStarTreeDocument.metrics[0]);
+            assertEquals(expectedStarTreeDocument.metrics[1], resultStarTreeDocument.metrics[1]);
+        }
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        validateStarTree(builder.getRootNode(), 3, 1, builder.getStarTreeDocuments());
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "test",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            7,
+            27,
+            1,
+            Set.of(),
+            getBuildMode(),
+            0,
+            1287
+        );
+        validateStarTreeFileFormats(builder.getRootNode(), 27, starTreeMetadata, expectedStarTreeDocuments());
+    }
+
+    private List<String> getStarTreeDimensionNames(List<Dimension> dimensionsOrder) {
+
+        List<String> dimensionNames = new ArrayList<>();
+        for (Dimension dimension : dimensionsOrder) {
+            dimensionNames.add(dimension.getField());
+        }
+        return dimensionNames;
+
+    }
+
+    private void validateStarTreeFileFormats(
+        InMemoryTreeNode rootNode,
+        int numDocs,
+        StarTreeMetadata expectedStarTreeMetadata,
+        List<StarTreeDocument> expectedStarTreeDocuments
+    ) throws IOException {
+
+        assertNotNull(rootNode.getChildren());
+        assertFalse(rootNode.getChildren().isEmpty());
+        SegmentReadState readState = getReadState(
+            numDocs,
+            expectedStarTreeMetadata.getDimensionFields(),
+            expectedStarTreeMetadata.getMetrics()
+        );
+
+        DocValuesProducer compositeDocValuesProducer = LuceneDocValuesProducerFactory.getDocValuesProducerForCompositeCodec(
+            Composite99Codec.COMPOSITE_INDEX_CODEC_NAME,
+            readState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+
+        IndexInput dataIn = readState.directory.openInput(dataFileName, IOContext.DEFAULT);
+        IndexInput metaIn = readState.directory.openInput(metaFileName, IOContext.DEFAULT);
+
+        StarTreeValues starTreeValues = new StarTreeValues(expectedStarTreeMetadata, dataIn, compositeDocValuesProducer, readState);
+        assertEquals(expectedStarTreeMetadata.getStarTreeDocCount(), starTreeValues.getStarTreeDocumentCount());
+        List<FieldValueConverter> fieldValueConverters = new ArrayList<>();
+        builder.metricAggregatorInfos.forEach(
+            metricAggregatorInfo -> fieldValueConverters.add(metricAggregatorInfo.getValueAggregators().getAggregatedValueType())
+        );
+        StarTreeDocument[] starTreeDocuments = StarTreeTestUtils.getSegmentsStarTreeDocuments(
+            List.of(starTreeValues),
+            fieldValueConverters,
+            readState.segmentInfo.maxDoc()
+        );
+
+        StarTreeDocument[] expectedStarTreeDocumentsArray = expectedStarTreeDocuments.toArray(new StarTreeDocument[0]);
+        StarTreeTestUtils.assertStarTreeDocuments(starTreeDocuments, expectedStarTreeDocumentsArray);
+
+        validateFileFormats(dataIn, metaIn, rootNode, expectedStarTreeMetadata);
+
+        dataIn.close();
+        metaIn.close();
+        compositeDocValuesProducer.close();
+    }
+
+    private static Map<Integer, Map<Long, Double>> getExpectedDimToValueMap() {
+        Map<Integer, Map<Long, Double>> expectedDimToValueMap = new HashMap<>();
+        Map<Long, Double> dimValueMap = new HashMap<>();
+        dimValueMap.put(1L, 600.0);
+        dimValueMap.put(2L, 400.0);
+        dimValueMap.put(3L, 1200.0);
+        expectedDimToValueMap.put(0, dimValueMap);
+
+        dimValueMap = new HashMap<>();
+        dimValueMap.put(11L, 1000.0);
+        dimValueMap.put(12L, 800.0);
+        dimValueMap.put(13L, 400.0);
+        expectedDimToValueMap.put(1, dimValueMap);
+
+        dimValueMap = new HashMap<>();
+        dimValueMap.put(21L, 1500.0);
+        dimValueMap.put(22L, 200.0);
+        dimValueMap.put(23L, 500.0);
+        expectedDimToValueMap.put(2, dimValueMap);
+        return expectedDimToValueMap;
+    }
+
+    private List<StarTreeDocument> expectedStarTreeDocuments() {
+        return List.of(
+            new StarTreeDocument(new Long[] { 1L, 11L, 21L }, new Object[] { 400.0, 1L }),
+            new StarTreeDocument(new Long[] { 1L, 12L, 22L }, new Object[] { 200.0, 1L }),
+            new StarTreeDocument(new Long[] { 2L, 13L, 21L }, new Object[] { 100.0, 1L }),
+            new StarTreeDocument(new Long[] { 2L, 13L, 23L }, new Object[] { 300.0, 1L }),
+            new StarTreeDocument(new Long[] { 3L, 11L, 21L }, new Object[] { 600.0, 1L }),
+            new StarTreeDocument(new Long[] { 3L, 12L, 21L }, new Object[] { 400.0, 1L }),
+            new StarTreeDocument(new Long[] { 3L, 12L, 23L }, new Object[] { 200.0, 1L }),
+            new StarTreeDocument(new Long[] { null, 11L, 21L }, new Object[] { 1000.0, 2L }),
+            new StarTreeDocument(new Long[] { null, 12L, 21L }, new Object[] { 400.0, 1L }),
+            new StarTreeDocument(new Long[] { null, 12L, 22L }, new Object[] { 200.0, 1L }),
+            new StarTreeDocument(new Long[] { null, 12L, 23L }, new Object[] { 200.0, 1L }),
+            new StarTreeDocument(new Long[] { null, 13L, 21L }, new Object[] { 100.0, 1L }),
+            new StarTreeDocument(new Long[] { null, 13L, 23L }, new Object[] { 300.0, 1L }),
+            new StarTreeDocument(new Long[] { null, null, 21L }, new Object[] { 1500.0, 4L }),
+            new StarTreeDocument(new Long[] { null, null, 22L }, new Object[] { 200.0, 1L }),
+            new StarTreeDocument(new Long[] { null, null, 23L }, new Object[] { 500.0, 2L }),
+            new StarTreeDocument(new Long[] { null, null, null }, new Object[] { 2200.0, 7L }),
+            new StarTreeDocument(new Long[] { null, 12L, null }, new Object[] { 800.0, 3L }),
+            new StarTreeDocument(new Long[] { null, 13L, null }, new Object[] { 400.0, 2L }),
+            new StarTreeDocument(new Long[] { 1L, null, 21L }, new Object[] { 400.0, 1L }),
+            new StarTreeDocument(new Long[] { 1L, null, 22L }, new Object[] { 200.0, 1L }),
+            new StarTreeDocument(new Long[] { 1L, null, null }, new Object[] { 600.0, 2L }),
+            new StarTreeDocument(new Long[] { 2L, 13L, null }, new Object[] { 400.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, null, 21L }, new Object[] { 1000.0, 2L }),
+            new StarTreeDocument(new Long[] { 3L, null, 23L }, new Object[] { 200.0, 1L }),
+            new StarTreeDocument(new Long[] { 3L, null, null }, new Object[] { 1200.0, 3L }),
+            new StarTreeDocument(new Long[] { 3L, 12L, null }, new Object[] { 600.0, 2L })
+        );
+
+    }
+
+    public void testFlushFlow() throws IOException {
+        List<Long> dimList = List.of(0L, 1L, 3L, 4L, 5L);
+        List<Integer> docsWithField = List.of(0, 1, 3, 4, 5);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5);
+
+        List<Long> metricsList = List.of(
+            getLongFromDouble(0.0),
+            getLongFromDouble(10.0),
+            getLongFromDouble(20.0),
+            getLongFromDouble(30.0),
+            getLongFromDouble(40.0),
+            getLongFromDouble(50.0)
+        );
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5);
+
+        compositeField = getStarTreeFieldWithMultipleMetrics();
+        SortedNumericDocValues d1sndv = getSortedNumericMock(dimList, docsWithField);
+        SortedNumericDocValues d2sndv = getSortedNumericMock(dimList2, docsWithField2);
+        SortedNumericDocValues m1sndv = getSortedNumericMock(metricsList, metricsWithField);
+        SortedNumericDocValues m2sndv = getSortedNumericMock(metricsList, metricsWithField);
+
+        writeState = getWriteState(6, writeState.segmentInfo.getId());
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        SequentialDocValuesIterator[] dimDvs = { new SequentialDocValuesIterator(d1sndv), new SequentialDocValuesIterator(d2sndv) };
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimDvs,
+            List.of(new SequentialDocValuesIterator(m1sndv), new SequentialDocValuesIterator(m2sndv))
+        );
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Sum [metric], count [metric] ]
+         [0, 0] | [0.0, 1]
+         [1, 1] | [10.0, 1]
+         [3, 3] | [30.0, 1]
+         [4, 4] | [40.0, 1]
+         [5, 5] | [50.0, 1]
+         [null, 2] | [20.0, 1]
+         */
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        List<StarTreeDocument> starTreeDocuments = builder.getStarTreeDocuments();
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : starTreeDocuments) {
+            count++;
+            if (starTreeDocument.dimensions[1] != null) {
+                assertEquals(
+                    starTreeDocument.dimensions[0] == null
+                        ? starTreeDocument.dimensions[1] * 1 * 10.0
+                        : starTreeDocument.dimensions[0] * 10,
+                    starTreeDocument.metrics[0]
+                );
+                assertEquals(1L, starTreeDocument.metrics[1]);
+            } else {
+                assertEquals(150D, starTreeDocument.metrics[0]);
+                assertEquals(6L, starTreeDocument.metrics[1]);
+            }
+        }
+        assertEquals(13, count);
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            List.of(new Metric("field2", List.of(MetricStat.SUM, MetricStat.VALUE_COUNT, MetricStat.AVG))),
+            6,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            264
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+
+    }
+
+    public void testFlushFlowDimsReverse() throws IOException {
+        List<Long> dimList = List.of(5L, 4L, 3L, 2L, 1L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 3, 4);
+        List<Long> dimList2 = List.of(5L, 4L, 3L, 2L, 1L, 0L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5);
+
+        List<Long> metricsList = List.of(
+            getLongFromDouble(50.0),
+            getLongFromDouble(40.0),
+            getLongFromDouble(30.0),
+            getLongFromDouble(20.0),
+            getLongFromDouble(10.0),
+            getLongFromDouble(0.0)
+        );
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5);
+
+        compositeField = getStarTreeFieldWithMultipleMetrics();
+        SortedNumericDocValues d1sndv = getSortedNumericMock(dimList, docsWithField);
+        SortedNumericDocValues d2sndv = getSortedNumericMock(dimList2, docsWithField2);
+        SortedNumericDocValues m1sndv = getSortedNumericMock(metricsList, metricsWithField);
+        SortedNumericDocValues m2sndv = getSortedNumericMock(metricsList, metricsWithField);
+
+        writeState = getWriteState(6, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        SequentialDocValuesIterator[] dimDvs = { new SequentialDocValuesIterator(d1sndv), new SequentialDocValuesIterator(d2sndv) };
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.sortAndAggregateSegmentDocuments(
+            dimDvs,
+            List.of(new SequentialDocValuesIterator(m1sndv), new SequentialDocValuesIterator(m2sndv))
+        );
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Sum [metric], count [metric] ]
+         [1, 1] | [10.0, 1]
+         [2, 2] | [20.0, 1]
+         [3, 3] | [30.0, 1]
+         [4, 4] | [40.0, 1]
+         [5, 5] | [50.0, 1]
+         [null, 0] | [0.0, 1]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(6, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            if (count <= 6) {
+                count++;
+                if (starTreeDocument.dimensions[0] != null) {
+                    assertEquals(count, (long) starTreeDocument.dimensions[0]);
+                }
+                assertEquals(starTreeDocument.dimensions[1] * 10.0, starTreeDocument.metrics[0]);
+                assertEquals(1L, starTreeDocument.metrics[1]);
+            }
+        }
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            List.of(new Metric("field2", List.of(MetricStat.SUM, MetricStat.VALUE_COUNT, MetricStat.AVG))),
+            6,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            264
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testFlushFlowBuild() throws IOException {
+        List<Long> dimList = new ArrayList<>(100);
+        List<Integer> docsWithField = new ArrayList<>(100);
+        for (int i = 0; i < 100; i++) {
+            dimList.add((long) i);
+            docsWithField.add(i);
+        }
+
+        List<Long> dimList2 = new ArrayList<>(100);
+        List<Integer> docsWithField2 = new ArrayList<>(100);
+        for (int i = 0; i < 100; i++) {
+            dimList2.add((long) i);
+            docsWithField2.add(i);
+        }
+
+        List<Long> metricsList = new ArrayList<>(100);
+        List<Integer> metricsWithField = new ArrayList<>(100);
+        for (int i = 0; i < 100; i++) {
+            metricsList.add(getLongFromDouble(i * 10.0));
+            metricsWithField.add(i);
+        }
+
+        Dimension d1 = new NumericDimension("field1");
+        Dimension d2 = new NumericDimension("field3");
+        Metric m1 = new Metric("field2", List.of(MetricStat.SUM));
+        List<Dimension> dims = List.of(d1, d2);
+        List<Metric> metrics = List.of(m1);
+        StarTreeFieldConfiguration c = new StarTreeFieldConfiguration(1, new HashSet<>(), getBuildMode());
+        compositeField = new StarTreeField("sf", dims, metrics, c);
+        SortedNumericDocValues d1sndv = getSortedNumericMock(dimList, docsWithField);
+        SortedNumericDocValues d2sndv = getSortedNumericMock(dimList2, docsWithField2);
+        SortedNumericDocValues m1sndv = getSortedNumericMock(metricsList, metricsWithField);
+
+        writeState = getWriteState(100, writeState.segmentInfo.getId());
+        SegmentWriteState consumerWriteState = getWriteState(DocIdSetIterator.NO_MORE_DOCS, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            consumerWriteState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+
+        DocValuesProducer d1vp = getDocValuesProducer(d1sndv);
+        DocValuesProducer d2vp = getDocValuesProducer(d2sndv);
+        DocValuesProducer m1vp = getDocValuesProducer(m1sndv);
+        Map<String, DocValuesProducer> fieldProducerMap = Map.of("field1", d1vp, "field3", d2vp, "field2", m1vp);
+        builder.build(fieldProducerMap, new AtomicInteger(), docValuesConsumer);
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Sum [ metric] ]
+         [0, 0] | [0.0]
+         [1, 1] | [10.0]
+         [2, 2] | [20.0]
+         [3, 3] | [30.0]
+         [4, 4] | [40.0]
+         ....
+         [null, 0] | [0.0]
+         [null, 1] | [10.0]
+         ...
+         [null, null] | [49500.0]
+         */
+        List<StarTreeDocument> starTreeDocuments = builder.getStarTreeDocuments();
+        for (StarTreeDocument starTreeDocument : starTreeDocuments) {
+            assertEquals(
+                starTreeDocument.dimensions[1] != null ? starTreeDocument.dimensions[1] * 10.0 : 49500.0,
+                starTreeDocument.metrics[0]
+            );
+        }
+        validateStarTree(builder.getRootNode(), 2, 1, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            100,
+            builder.numStarTreeDocs,
+            1,
+            Set.of(),
+            getBuildMode(),
+            0,
+            6699
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    private static DocValuesProducer getDocValuesProducer(SortedNumericDocValues sndv) {
+        return new EmptyDocValuesProducer() {
+            @Override
+            public SortedNumericDocValues getSortedNumeric(FieldInfo field) throws IOException {
+                return sndv;
+            }
+        };
+    }
+
+    private StarTreeField getStarTreeFieldWithMultipleMetrics() {
+        Dimension d1 = new NumericDimension("field1");
+        Dimension d2 = new NumericDimension("field3");
+        Metric m1 = new Metric("field2", List.of(MetricStat.SUM));
+        Metric m2 = new Metric("field2", List.of(MetricStat.VALUE_COUNT));
+        Metric m3 = new Metric("field2", List.of(MetricStat.AVG));
+        List<Dimension> dims = List.of(d1, d2);
+        List<Metric> metrics = List.of(m1, m2, m3);
+        StarTreeFieldConfiguration c = new StarTreeFieldConfiguration(1000, new HashSet<>(), getBuildMode());
+        return new StarTreeField("sf", dims, metrics, c);
+    }
+
+    public void testMergeFlow_randomNumberTypes() throws Exception {
+
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder(
+            "field1",
+            randomFrom(NumberFieldMapper.NumberType.values()),
+            false,
+            true
+        ).build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder(
+            "field2",
+            randomFrom(NumberFieldMapper.NumberType.values()),
+            false,
+            true
+        ).build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper3 = new NumberFieldMapper.Builder(
+            "field3",
+            randomFrom(NumberFieldMapper.NumberType.values()),
+            false,
+            true
+        ).build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2, numberFieldMapper3),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+        testMergeFlowWithSum();
+    }
+
+    public void testMergeFlowWithSum() throws IOException {
+        List<Long> dimList = List.of(0L, 1L, 3L, 4L, 5L, 6L);
+        List<Integer> docsWithField = List.of(0, 1, 3, 4, 5, 6);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L, -1L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> metricsList = List.of(
+            getLongFromDouble(0.0),
+            getLongFromDouble(10.0),
+            getLongFromDouble(20.0),
+            getLongFromDouble(30.0),
+            getLongFromDouble(40.0),
+            getLongFromDouble(50.0),
+            getLongFromDouble(60.0)
+
+        );
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        compositeField = getStarTreeField(MetricStat.SUM);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+        writeState = getWriteState(6, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Sum [ metric] ]
+         * [0, 0] | [0.0]
+         * [1, 1] | [20.0]
+         * [3, 3] | [60.0]
+         * [4, 4] | [80.0]
+         * [5, 5] | [100.0]
+         * [null, 2] | [40.0]
+         * ------------------ We only take non star docs
+         * [6,-1] | [120.0]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(6, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 6) {
+                assertEquals(
+                    starTreeDocument.dimensions[0] != null ? starTreeDocument.dimensions[0] * 2 * 10.0 : 40.0,
+                    starTreeDocument.metrics[0]
+                );
+            }
+        }
+
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            6,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            264
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowWithCount() throws IOException {
+        List<Long> dimList = List.of(0L, 1L, 3L, 4L, 5L, 6L);
+        List<Integer> docsWithField = List.of(0, 1, 3, 4, 5, 6);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L, -1L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        compositeField = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+        writeState = getWriteState(6, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [0]
+         [1, 1] | [2]
+         [3, 3] | [6]
+         [4, 4] | [8]
+         [5, 5] | [10]
+         [null, 2] | [4]
+         ---------------
+         [6,-1] | [12]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(6, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 6) {
+                assertEquals(starTreeDocument.dimensions[0] != null ? starTreeDocument.dimensions[0] * 2 : 4, starTreeDocument.metrics[0]);
+            }
+        }
+
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            6,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            264
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+
+    }
+
+    private StarTreeValues getStarTreeValues(
+        SortedNumericDocValues dimList,
+        SortedNumericDocValues dimList2,
+        SortedNumericDocValues metricsList,
+        StarTreeField sf,
+        String number
+    ) {
+        SortedNumericDocValues d1sndv = dimList;
+        SortedNumericDocValues d2sndv = dimList2;
+        SortedNumericDocValues m1sndv = metricsList;
+        Map<String, Supplier<DocIdSetIterator>> dimDocIdSetIterators = Map.of("field1", () -> d1sndv, "field3", () -> d2sndv);
+
+        Map<String, Supplier<DocIdSetIterator>> metricDocIdSetIterators = new LinkedHashMap<>();
+        for (Metric metric : sf.getMetrics()) {
+            for (MetricStat metricStat : metric.getMetrics()) {
+                String metricFullName = fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                    sf.getName(),
+                    metric.getField(),
+                    metricStat.getTypeName()
+                );
+                metricDocIdSetIterators.put(metricFullName, () -> m1sndv);
+            }
+        }
+
+        StarTreeValues starTreeValues = new StarTreeValues(
+            sf,
+            null,
+            dimDocIdSetIterators,
+            metricDocIdSetIterators,
+            Map.of(CompositeIndexConstants.SEGMENT_DOCS_COUNT, number),
+            null
+        );
+        return starTreeValues;
+    }
+
+    public void testMergeFlowWithDifferentDocsFromSegments() throws IOException {
+        List<Long> dimList = List.of(0L, 1L, 3L, 4L, 5L, 6L);
+        List<Integer> docsWithField = List.of(0, 1, 3, 4, 5, 6);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L, -1L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> dimList3 = List.of(5L, 6L, 8L, -1L);
+        List<Integer> docsWithField3 = List.of(0, 1, 3, 4);
+        List<Long> dimList4 = List.of(5L, 6L, 7L, 8L, -1L);
+        List<Integer> docsWithField4 = List.of(0, 1, 2, 3, 4);
+
+        List<Long> metricsList2 = List.of(5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField2 = List.of(0, 1, 2, 3, 4);
+
+        compositeField = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList3, docsWithField3),
+            getSortedNumericMock(dimList4, docsWithField4),
+            getSortedNumericMock(metricsList2, metricsWithField2),
+            compositeField,
+            "4"
+        );
+        writeState = getWriteState(4, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [0]
+         [1, 1] | [1]
+         [3, 3] | [3]
+         [4, 4] | [4]
+         [5, 5] | [10]
+         [6, 6] | [6]
+         [8, 8] | [8]
+         [null, 2] | [2]
+         [null, 7] | [7]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(9, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 9) {
+                if (Objects.equals(starTreeDocument.dimensions[0], 5L)) {
+                    assertEquals(starTreeDocument.dimensions[0] * 2, starTreeDocument.metrics[0]);
+                } else {
+                    assertEquals(starTreeDocument.dimensions[1], starTreeDocument.metrics[0]);
+                }
+            }
+        }
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            9,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            330
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowNumSegmentsDocs() throws IOException {
+        List<Long> dimList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L, -1L, -1L, -1L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L, -1L, -1L, -1L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L, -1L, -1L, -1L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+
+        List<Long> dimList3 = List.of(5L, 6L, 7L, 8L, -1L);
+        List<Integer> docsWithField3 = List.of(0, 1, 2, 3, 4);
+        List<Long> dimList4 = List.of(5L, 6L, 7L, 8L, -1L);
+        List<Integer> docsWithField4 = List.of(0, 1, 2, 3, 4);
+
+        List<Long> metricsList2 = List.of(5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField2 = List.of(0, 1, 2, 3, 4);
+
+        StarTreeField sf = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            sf,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList3, docsWithField3),
+            getSortedNumericMock(dimList4, docsWithField4),
+            getSortedNumericMock(metricsList2, metricsWithField2),
+            sf,
+            "4"
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, sf, getWriteState(4, writeState.segmentInfo.getId()), mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [0]
+         [1, 1] | [1]
+         [2, 2] | [2]
+         [3, 3] | [3]
+         [4, 4] | [4]
+         [5, 5] | [10]
+         [6, 6] | [6]
+         [7, 7] | [7]
+         [8, 8] | [8]
+         */
+        int count = 0;
+        while (starTreeDocumentIterator.hasNext()) {
+            count++;
+            StarTreeDocument starTreeDocument = starTreeDocumentIterator.next();
+            if (Objects.equals(starTreeDocument.dimensions[0], 5L)) {
+                assertEquals(starTreeDocument.dimensions[0] * 2, starTreeDocument.metrics[0]);
+            } else {
+                assertEquals(starTreeDocument.dimensions[1], starTreeDocument.metrics[0]);
+            }
+        }
+        assertEquals(9, count);
+    }
+
+    public void testMergeFlowWithMissingDocs() throws IOException {
+        List<Long> dimList = List.of(0L, 1L, 2L, 3L, 4L, 6L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 3, 4, 6);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L, -1L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> dimList3 = List.of(5L, 6L, 8L, -1L);
+        List<Integer> docsWithField3 = List.of(0, 1, 3, 4);
+        List<Long> dimList4 = List.of(5L, 6L, 7L, 8L, -1L);
+        List<Integer> docsWithField4 = List.of(0, 1, 2, 3, 4);
+
+        List<Long> metricsList2 = List.of(5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField2 = List.of(0, 1, 2, 3, 4);
+
+        compositeField = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList3, docsWithField3),
+            getSortedNumericMock(dimList4, docsWithField4),
+            getSortedNumericMock(metricsList2, metricsWithField2),
+            compositeField,
+            "4"
+        );
+        writeState = getWriteState(4, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [0]
+         [1, 1] | [1]
+         [2, 2] | [2]
+         [3, 3] | [3]
+         [4, 4] | [4]
+         [5, 5] | [5]
+         [6, 6] | [6]
+         [8, 8] | [8]
+         [null, 5] | [5]
+         [null, 7] | [7]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(10, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 10) {
+                if (starTreeDocument.dimensions[0] == null) {
+                    assertTrue(List.of(5L, 7L).contains(starTreeDocument.dimensions[1]));
+                }
+                assertEquals(starTreeDocument.dimensions[1], starTreeDocument.metrics[0]);
+            }
+        }
+
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            10,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            363
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowWithMissingDocsWithZero() throws IOException {
+        List<Long> dimList = List.of(0L, 0L, 0L, 0L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 6);
+        List<Long> dimList2 = List.of(0L, 0L, 0L, 0L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 6);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> dimList3 = List.of(5L, 6L, 8L, -1L);
+        List<Integer> docsWithField3 = List.of(0, 1, 3, 4);
+        List<Long> dimList4 = List.of(5L, 6L, 7L, 8L, -1L);
+        List<Integer> docsWithField4 = List.of(0, 1, 2, 3, 4);
+
+        List<Long> metricsList2 = List.of(5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField2 = List.of(0, 1, 2, 3, 4);
+
+        compositeField = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "7"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList3, docsWithField3),
+            getSortedNumericMock(dimList4, docsWithField4),
+            getSortedNumericMock(metricsList2, metricsWithField2),
+            compositeField,
+            "4"
+        );
+        writeState = getWriteState(4, writeState.segmentInfo.getId());
+        SegmentWriteState consumerWriteState = getWriteState(DocIdSetIterator.NO_MORE_DOCS, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            consumerWriteState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [9]
+         [5, 5] | [5]
+         [6, 6] | [6]
+         [8, 8] | [8]
+         [null, 7] | [7]
+         [null, null] | [12]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(6, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 6) {
+                if (starTreeDocument.dimensions[0] == null && starTreeDocument.dimensions[1] == null) {
+                    assertEquals(12L, (long) starTreeDocument.metrics[0]);
+                } else if (starTreeDocument.dimensions[0] == null) {
+                    assertEquals(7L, starTreeDocument.metrics[0]);
+                } else if (starTreeDocument.dimensions[0] == 0) {
+                    assertEquals(9L, starTreeDocument.metrics[0]);
+                } else {
+                    assertEquals(starTreeDocument.dimensions[1], starTreeDocument.metrics[0]);
+                }
+            }
+        }
+
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            6,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            231
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowWithMissingDocsWithZeroComplexCase() throws IOException {
+        List<Long> dimList = List.of(0L, 0L, 0L, 0L, 0L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 6, 8);
+        List<Long> dimList2 = List.of(0L, 0L, 0L, 0L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 6);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+
+        List<Long> dimList3 = List.of(5L, 6L, 8L, -1L);
+        List<Integer> docsWithField3 = List.of(0, 1, 3, 4);
+        List<Long> dimList4 = List.of(5L, 6L, 7L, 8L, -1L);
+        List<Integer> docsWithField4 = List.of(0, 1, 2, 3, 4);
+
+        List<Long> metricsList2 = List.of(5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField2 = List.of(0, 1, 2, 3, 4);
+
+        compositeField = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "9"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList3, docsWithField3),
+            getSortedNumericMock(dimList4, docsWithField4),
+            getSortedNumericMock(metricsList2, metricsWithField2),
+            compositeField,
+            "4"
+        );
+        writeState = getWriteState(4, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [9]
+         [0, null] | [8]
+         [5, 5] | [5]
+         [6, 6] | [6]
+         [8, 8] | [8]
+         [null, 7] | [7]
+         [null, null] | [19]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(7, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 7) {
+                if (starTreeDocument.dimensions[0] == null && starTreeDocument.dimensions[1] == null) {
+                    assertEquals(19L, (long) starTreeDocument.metrics[0]);
+                    assertEquals(7, count);
+                } else if (starTreeDocument.dimensions[0] == null) {
+                    assertEquals(7L, starTreeDocument.metrics[0]);
+                } else if (starTreeDocument.dimensions[1] == null) {
+                    assertEquals(8L, starTreeDocument.metrics[0]);
+                } else if (starTreeDocument.dimensions[0] == 0) {
+                    assertEquals(9L, starTreeDocument.metrics[0]);
+                } else {
+                    assertEquals(starTreeDocument.dimensions[1], starTreeDocument.metrics[0]);
+                }
+            }
+        }
+
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            7,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            231
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowWithMissingDocsInSecondDim() throws IOException {
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 6L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 6);
+        List<Long> dimList = List.of(0L, 1L, 2L, 3L, 4L, 5L, -1L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> dimList3 = List.of(5L, 6L, 8L, -1L);
+        List<Integer> docsWithField3 = List.of(0, 1, 3, 4);
+        List<Long> dimList4 = List.of(5L, 6L, 7L, 8L, -1L);
+        List<Integer> docsWithField4 = List.of(0, 1, 2, 3, 4);
+
+        List<Long> metricsList2 = List.of(5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField2 = List.of(0, 1, 2, 3, 4);
+
+        compositeField = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList3, docsWithField3),
+            getSortedNumericMock(dimList4, docsWithField4),
+            getSortedNumericMock(metricsList2, metricsWithField2),
+            compositeField,
+            "4"
+        );
+        writeState = getWriteState(4, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [0]
+         [1, 1] | [1]
+         [2, 2] | [2]
+         [3, 3] | [3]
+         [4, 4] | [4]
+         [5, 5] | [5]
+         [5, null] | [5]
+         [6, 6] | [6]
+         [8, 8] | [8]
+         [null, 7] | [7]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(10, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 10) {
+                if (starTreeDocument.dimensions[0] != null && starTreeDocument.dimensions[0] == 5) {
+                    assertEquals(starTreeDocument.dimensions[0], starTreeDocument.metrics[0]);
+                } else {
+                    assertEquals(starTreeDocument.dimensions[1], starTreeDocument.metrics[0]);
+                }
+            }
+        }
+
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            10,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            363
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowWithDocsMissingAtTheEnd() throws IOException {
+        List<Long> dimList = List.of(0L, 1L, 2L, 3L, 4L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 3, 4);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L, -1L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> dimList3 = List.of(5L, 6L, 8L, -1L);
+        List<Integer> docsWithField3 = List.of(0, 1, 3, 4);
+        List<Long> dimList4 = List.of(5L, 6L, 7L, 8L, -1L);
+        List<Integer> docsWithField4 = List.of(0, 1, 2, 3, 4);
+
+        List<Long> metricsList2 = List.of(5L, 6L, 7L, 8L, 9L);
+        List<Integer> metricsWithField2 = List.of(0, 1, 2, 3, 4);
+
+        compositeField = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            getSortedNumericMock(dimList3, docsWithField3),
+            getSortedNumericMock(dimList4, docsWithField4),
+            getSortedNumericMock(metricsList2, metricsWithField2),
+            compositeField,
+            "4"
+        );
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [0]
+         [1, 1] | [1]
+         [2, 2] | [2]
+         [3, 3] | [3]
+         [4, 4] | [4]
+         [5, 5] | [5]
+         [6, 6] | [6]
+         [8, 8] | [8]
+         [null, 5] | [5]
+         [null, 7] | [7]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(10, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 10) {
+                if (starTreeDocument.dimensions[0] == null) {
+                    assertTrue(List.of(5L, 7L).contains(starTreeDocument.dimensions[1]));
+                }
+                assertEquals(starTreeDocument.dimensions[1], starTreeDocument.metrics[0]);
+            }
+        }
+
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            10,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            363
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowWithEmptyFieldsInOneSegment() throws IOException {
+        List<Long> dimList = List.of(0L, 1L, 2L, 3L, 4L);
+        List<Integer> docsWithField = List.of(0, 1, 2, 3, 4);
+        List<Long> dimList2 = List.of(0L, 1L, 2L, 3L, 4L, 5L, -1L);
+        List<Integer> docsWithField2 = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        List<Long> metricsList = List.of(0L, 1L, 2L, 3L, 4L, 5L, 6L);
+        List<Integer> metricsWithField = List.of(0, 1, 2, 3, 4, 5, 6);
+
+        compositeField = getStarTreeField(MetricStat.VALUE_COUNT);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            getSortedNumericMock(dimList, docsWithField),
+            getSortedNumericMock(dimList2, docsWithField2),
+            getSortedNumericMock(metricsList, metricsWithField),
+            compositeField,
+            "6"
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            DocValues.emptySortedNumeric(),
+            DocValues.emptySortedNumeric(),
+            DocValues.emptySortedNumeric(),
+            compositeField,
+            "0"
+        );
+        writeState = getWriteState(0, writeState.segmentInfo.getId());
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         * Asserting following dim / metrics [ dim1, dim2 / Count [ metric] ]
+         [0, 0] | [0]
+         [1, 1] | [1]
+         [2, 2] | [2]
+         [3, 3] | [3]
+         [4, 4] | [4]
+         [null, 5] | [5]
+         */
+        builder.appendDocumentsToStarTree(starTreeDocumentIterator);
+        assertEquals(6, builder.getStarTreeDocuments().size());
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+        int count = 0;
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            count++;
+            if (count <= 6) {
+                if (starTreeDocument.dimensions[0] == null) {
+                    assertEquals(5L, (long) starTreeDocument.dimensions[1]);
+                }
+                assertEquals(starTreeDocument.dimensions[1], starTreeDocument.metrics[0]);
+            }
+        }
+        validateStarTree(builder.getRootNode(), 2, 1000, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            List.of("field1", "field3"),
+            compositeField.getMetrics(),
+            6,
+            builder.numStarTreeDocs,
+            1000,
+            Set.of(),
+            getBuildMode(),
+            0,
+            264
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowWithDuplicateDimensionValues() throws IOException {
+        List<Long> dimList1 = new ArrayList<>(500);
+        List<Integer> docsWithField1 = new ArrayList<>(500);
+        for (int i = 0; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList1.add((long) i);
+                docsWithField1.add(i * 5 + j);
+            }
+        }
+
+        List<Long> dimList2 = new ArrayList<>(500);
+        List<Integer> docsWithField2 = new ArrayList<>(500);
+        for (int i = 0; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList2.add((long) i);
+                docsWithField2.add(i * 5 + j);
+            }
+        }
+
+        List<Long> dimList3 = new ArrayList<>(500);
+        List<Integer> docsWithField3 = new ArrayList<>(500);
+        for (int i = 0; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList3.add((long) i);
+                docsWithField3.add(i * 5 + j);
+            }
+        }
+
+        List<Long> dimList4 = new ArrayList<>(500);
+        List<Integer> docsWithField4 = new ArrayList<>(500);
+        for (int i = 0; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList4.add((long) i);
+                docsWithField4.add(i * 5 + j);
+            }
+        }
+
+        List<Long> metricsList = new ArrayList<>(100);
+        List<Integer> metricsWithField = new ArrayList<>(100);
+        for (int i = 0; i < 500; i++) {
+            metricsList.add(getLongFromDouble(i * 10.0));
+            metricsWithField.add(i);
+        }
+        List<Long> docCountMetricsList = new ArrayList<>(100);
+        List<Integer> docCountMetricsWithField = new ArrayList<>(100);
+        for (int i = 0; i < 500; i++) {
+            docCountMetricsList.add(i * 10L);
+            docCountMetricsWithField.add(i);
+        }
+
+        compositeField = getStarTreeFieldWithDocCount(1, true);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            dimList1,
+            docsWithField1,
+            dimList2,
+            docsWithField2,
+            dimList3,
+            docsWithField3,
+            dimList4,
+            docsWithField4,
+            metricsList,
+            metricsWithField,
+            docCountMetricsList,
+            docCountMetricsWithField,
+            compositeField
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            dimList1,
+            docsWithField1,
+            dimList2,
+            docsWithField2,
+            dimList3,
+            docsWithField3,
+            dimList4,
+            docsWithField4,
+            metricsList,
+            metricsWithField,
+            docCountMetricsList,
+            docCountMetricsWithField,
+            compositeField
+        );
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        builder.build(builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2)), new AtomicInteger(), docValuesConsumer);
+        List<StarTreeDocument> starTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(401, starTreeDocuments.size());
+        int count = 0;
+        double sum = 0;
+        /**
+         401 docs get generated
+         [0, 0, 0, 0] | [200.0, 10]
+         [1, 1, 1, 1] | [700.0, 10]
+         [2, 2, 2, 2] | [1200.0, 10]
+         [3, 3, 3, 3] | [1700.0, 10]
+         [4, 4, 4, 4] | [2200.0, 10]
+         .....
+         [null, null, null, 99] | [49700.0, 10]
+         [null, null, null, null] | [2495000.0, 1000]
+         */
+        for (StarTreeDocument starTreeDocument : starTreeDocuments) {
+            if (starTreeDocument.dimensions[3] == null) {
+                assertEquals(sum, starTreeDocument.metrics[0]);
+                assertEquals(2495000L, (long) starTreeDocument.metrics[1]);
+            } else {
+                if (starTreeDocument.dimensions[0] != null) {
+                    sum += (double) starTreeDocument.metrics[0];
+                }
+                assertEquals(starTreeDocument.dimensions[3] * 500 + 200.0, starTreeDocument.metrics[0]);
+                assertEquals(starTreeDocument.dimensions[3] * 500 + 200L, (long) starTreeDocument.metrics[1]);
+
+            }
+            count++;
+        }
+        assertEquals(401, count);
+        validateStarTree(builder.getRootNode(), 4, compositeField.getStarTreeConfig().maxLeafDocs(), builder.getStarTreeDocuments());
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            100,
+            builder.numStarTreeDocs,
+            1,
+            Set.of(),
+            getBuildMode(),
+            0,
+            13365
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public void testMergeFlowWithMaxLeafDocs() throws IOException {
+        List<Long> dimList1 = new ArrayList<>(500);
+        List<Integer> docsWithField1 = new ArrayList<>(500);
+
+        for (int i = 0; i < 20; i++) {
+            for (int j = 0; j < 20; j++) {
+                dimList1.add((long) i);
+                docsWithField1.add(i * 20 + j);
+            }
+        }
+        for (int i = 80; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList1.add((long) i);
+                docsWithField1.add(i * 5 + j);
+            }
+        }
+        List<Long> dimList3 = new ArrayList<>(500);
+        List<Integer> docsWithField3 = new ArrayList<>(500);
+        for (int i = 0; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList3.add((long) i);
+                docsWithField3.add(i * 5 + j);
+            }
+        }
+        List<Long> dimList2 = new ArrayList<>(500);
+        List<Integer> docsWithField2 = new ArrayList<>(500);
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 50; j++) {
+                dimList2.add((long) i);
+                docsWithField2.add(i * 50 + j);
+            }
+        }
+
+        List<Long> dimList4 = new ArrayList<>(500);
+        List<Integer> docsWithField4 = new ArrayList<>(500);
+        for (int i = 0; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList4.add((long) i);
+                docsWithField4.add(i * 5 + j);
+            }
+        }
+
+        List<Long> metricsList = new ArrayList<>(100);
+        List<Integer> metricsWithField = new ArrayList<>(100);
+        for (int i = 0; i < 500; i++) {
+            metricsList.add(getLongFromDouble(i * 10.0));
+            metricsWithField.add(i);
+        }
+
+        List<Long> metricsList1 = new ArrayList<>(100);
+        List<Integer> metricsWithField1 = new ArrayList<>(100);
+        for (int i = 0; i < 500; i++) {
+            metricsList1.add(1L);
+            metricsWithField1.add(i);
+        }
+
+        compositeField = getStarTreeFieldWithDocCount(3, true);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            dimList1,
+            docsWithField1,
+            dimList2,
+            docsWithField2,
+            dimList3,
+            docsWithField3,
+            dimList4,
+            docsWithField4,
+            metricsList,
+            metricsWithField,
+            metricsList1,
+            metricsWithField1,
+            compositeField
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            dimList1,
+            docsWithField1,
+            dimList2,
+            docsWithField2,
+            dimList3,
+            docsWithField3,
+            dimList4,
+            docsWithField4,
+            metricsList,
+            metricsWithField,
+            metricsList1,
+            metricsWithField1,
+            compositeField
+        );
+
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        builder.build(builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2)), new AtomicInteger(), docValuesConsumer);
+        List<StarTreeDocument> starTreeDocuments = builder.getStarTreeDocuments();
+        /**
+         635 docs get generated
+         [0, 0, 0, 0] | [200.0, 10]
+         [0, 0, 1, 1] | [700.0, 10]
+         [0, 0, 2, 2] | [1200.0, 10]
+         [0, 0, 3, 3] | [1700.0, 10]
+         [1, 0, 4, 4] | [2200.0, 10]
+         [1, 0, 5, 5] | [2700.0, 10]
+         [1, 0, 6, 6] | [3200.0, 10]
+         [1, 0, 7, 7] | [3700.0, 10]
+         [2, 0, 8, 8] | [4200.0, 10]
+         [2, 0, 9, 9] | [4700.0, 10]
+         [2, 1, 10, 10] | [5200.0, 10]
+         [2, 1, 11, 11] | [5700.0, 10]
+         .....
+         [18, 7, null, null] | [147800.0, 40]
+         ...
+         [7, 2, null, null] | [28900.0, 20]
+         ...
+         [null, null, null, 99] | [49700.0, 10]
+         .....
+         [null, null, null, null] | [2495000.0, 1000]
+         */
+        assertEquals(635, starTreeDocuments.size());
+        for (StarTreeDocument starTreeDocument : starTreeDocuments) {
+            if (starTreeDocument.dimensions[0] != null
+                && starTreeDocument.dimensions[1] != null
+                && starTreeDocument.dimensions[2] != null
+                && starTreeDocument.dimensions[3] != null) {
+                assertEquals(10L, starTreeDocument.metrics[1]);
+            } else if (starTreeDocument.dimensions[1] != null
+                && starTreeDocument.dimensions[2] != null
+                && starTreeDocument.dimensions[3] != null) {
+                    assertEquals(10L, starTreeDocument.metrics[1]);
+                } else if (starTreeDocument.dimensions[0] != null
+                    && starTreeDocument.dimensions[2] != null
+                    && starTreeDocument.dimensions[3] != null) {
+                        assertEquals(10L, starTreeDocument.metrics[1]);
+                    } else if (starTreeDocument.dimensions[0] != null
+                        && starTreeDocument.dimensions[1] != null
+                        && starTreeDocument.dimensions[3] != null) {
+                            assertEquals(10L, starTreeDocument.metrics[1]);
+                        } else if (starTreeDocument.dimensions[0] != null && starTreeDocument.dimensions[3] != null) {
+                            assertEquals(10L, starTreeDocument.metrics[1]);
+                        } else if (starTreeDocument.dimensions[0] != null && starTreeDocument.dimensions[1] != null) {
+                            assertTrue((long) starTreeDocument.metrics[1] == 20L || (long) starTreeDocument.metrics[1] == 40L);
+                        } else if (starTreeDocument.dimensions[1] != null && starTreeDocument.dimensions[3] != null) {
+                            assertEquals(10L, starTreeDocument.metrics[1]);
+                        } else if (starTreeDocument.dimensions[1] != null) {
+                            assertEquals(100L, starTreeDocument.metrics[1]);
+                        } else if (starTreeDocument.dimensions[0] != null) {
+                            assertEquals(40L, starTreeDocument.metrics[1]);
+                        }
+        }
+        validateStarTree(builder.getRootNode(), 4, compositeField.getStarTreeConfig().maxLeafDocs(), builder.getStarTreeDocuments());
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            100,
+            builder.numStarTreeDocs,
+            3,
+            Set.of(),
+            getBuildMode(),
+            0,
+            23199
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    private StarTreeValues getStarTreeValues(
+        List<Long> dimList1,
+        List<Integer> docsWithField1,
+        List<Long> dimList2,
+        List<Integer> docsWithField2,
+        List<Long> dimList3,
+        List<Integer> docsWithField3,
+        List<Long> dimList4,
+        List<Integer> docsWithField4,
+        List<Long> metricsList,
+        List<Integer> metricsWithField,
+        List<Long> metricsList1,
+        List<Integer> metricsWithField1,
+        StarTreeField sf
+    ) {
+        SortedNumericDocValues d1sndv = getSortedNumericMock(dimList1, docsWithField1);
+        SortedNumericDocValues d2sndv = getSortedNumericMock(dimList2, docsWithField2);
+        SortedNumericDocValues d3sndv = getSortedNumericMock(dimList3, docsWithField3);
+        SortedNumericDocValues d4sndv = getSortedNumericMock(dimList4, docsWithField4);
+        SortedNumericDocValues m1sndv = getSortedNumericMock(metricsList, metricsWithField);
+        SortedNumericDocValues m2sndv = getSortedNumericMock(metricsList1, metricsWithField1);
+        Map<String, Supplier<DocIdSetIterator>> dimDocIdSetIterators = Map.of(
+            "field1",
+            () -> d1sndv,
+            "field3",
+            () -> d2sndv,
+            "field5",
+            () -> d3sndv,
+            "field8",
+            () -> d4sndv
+        );
+
+        Map<String, Supplier<DocIdSetIterator>> metricDocIdSetIterators = new LinkedHashMap<>();
+
+        metricDocIdSetIterators.put(
+            fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                sf.getName(),
+                "field2",
+                sf.getMetrics().get(0).getMetrics().get(0).getTypeName()
+            ),
+            () -> m1sndv
+        );
+        metricDocIdSetIterators.put(
+            fullyQualifiedFieldNameForStarTreeMetricsDocValues(
+                sf.getName(),
+                "_doc_count",
+                sf.getMetrics().get(1).getMetrics().get(0).getTypeName()
+            ),
+            () -> m2sndv
+        );
+        // metricDocIdSetIterators.put("field2", () -> m1sndv);
+        // metricDocIdSetIterators.put("_doc_count", () -> m2sndv);
+        StarTreeValues starTreeValues = new StarTreeValues(
+            sf,
+            null,
+            dimDocIdSetIterators,
+            metricDocIdSetIterators,
+            getAttributes(500),
+            null
+        );
+        return starTreeValues;
+    }
+
+    public void testMergeFlowWithDuplicateDimensionValueWithMaxLeafDocs() throws IOException {
+        List<Long> dimList1 = new ArrayList<>(500);
+        List<Integer> docsWithField1 = new ArrayList<>(500);
+
+        for (int i = 0; i < 20; i++) {
+            for (int j = 0; j < 20; j++) {
+                dimList1.add((long) i);
+                docsWithField1.add(i * 20 + j);
+            }
+        }
+        for (int i = 80; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList1.add((long) i);
+                docsWithField1.add(i * 5 + j);
+            }
+        }
+        List<Long> dimList3 = new ArrayList<>(500);
+        List<Integer> docsWithField3 = new ArrayList<>(500);
+        for (int i = 0; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList3.add((long) i);
+                docsWithField3.add(i * 5 + j);
+            }
+        }
+        List<Long> dimList2 = new ArrayList<>(500);
+        List<Integer> docsWithField2 = new ArrayList<>(500);
+        for (int i = 0; i < 500; i++) {
+            dimList2.add((long) 1);
+            docsWithField2.add(i);
+        }
+
+        List<Long> dimList4 = new ArrayList<>(500);
+        List<Integer> docsWithField4 = new ArrayList<>(500);
+        for (int i = 0; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList4.add((long) i);
+                docsWithField4.add(i * 5 + j);
+            }
+        }
+
+        List<Long> metricsList = new ArrayList<>(100);
+        List<Integer> metricsWithField = new ArrayList<>(100);
+        for (int i = 0; i < 500; i++) {
+            metricsList.add(getLongFromDouble(i * 10.0));
+            metricsWithField.add(i);
+        }
+
+        List<Long> docCountMetricsList = new ArrayList<>(100);
+        List<Integer> docCountMetricsWithField = new ArrayList<>(100);
+        for (int i = 0; i < 500; i++) {
+            metricsList.add(getLongFromDouble(i * 2));
+            metricsWithField.add(i);
+        }
+
+        compositeField = getStarTreeFieldWithDocCount(3, true);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            dimList1,
+            docsWithField1,
+            dimList2,
+            docsWithField2,
+            dimList3,
+            docsWithField3,
+            dimList4,
+            docsWithField4,
+            metricsList,
+            metricsWithField,
+            docCountMetricsList,
+            docCountMetricsWithField,
+            compositeField
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            dimList1,
+            docsWithField1,
+            dimList2,
+            docsWithField2,
+            dimList3,
+            docsWithField3,
+            dimList4,
+            docsWithField4,
+            metricsList,
+            metricsWithField,
+            docCountMetricsList,
+            docCountMetricsWithField,
+            compositeField
+        );
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        builder.build(builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2)), new AtomicInteger(), docValuesConsumer);
+        List<StarTreeDocument> starTreeDocuments = builder.getStarTreeDocuments();
+        assertEquals(401, starTreeDocuments.size());
+        validateStarTree(builder.getRootNode(), 4, compositeField.getStarTreeConfig().maxLeafDocs(), builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            100,
+            builder.numStarTreeDocs,
+            compositeField.getStarTreeConfig().maxLeafDocs(),
+            Set.of(),
+            getBuildMode(),
+            0,
+            15345
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    public static long getLongFromDouble(double value) {
+        return Double.doubleToLongBits(value);
+    }
+
+    public void testMergeFlowWithMaxLeafDocsAndStarTreeNodesAssertion() throws IOException {
+        List<Long> dimList1 = new ArrayList<>(500);
+        List<Integer> docsWithField1 = new ArrayList<>(500);
+        Map<Integer, Map<Long, Double>> expectedDimToValueMap = new HashMap<>();
+        Map<Long, Double> dimValueMap = new HashMap<>();
+        for (int i = 0; i < 20; i++) {
+            for (int j = 0; j < 20; j++) {
+                dimList1.add((long) i);
+                docsWithField1.add(i * 20 + j);
+            }
+            // metric = no of docs * 10.0
+            dimValueMap.put((long) i, 200.0);
+        }
+        for (int i = 80; i < 100; i++) {
+            for (int j = 0; j < 5; j++) {
+                dimList1.add((long) i);
+                docsWithField1.add(i * 5 + j);
+            }
+            // metric = no of docs * 10.0
+            dimValueMap.put((long) i, 50.0);
+        }
+        dimValueMap.put(Long.MAX_VALUE, 5000.0);
+        expectedDimToValueMap.put(0, dimValueMap);
+        dimValueMap = new HashMap<>();
+        List<Long> dimList3 = new ArrayList<>(500);
+        List<Integer> docsWithField3 = new ArrayList<>(500);
+        for (int i = 0; i < 500; i++) {
+            dimList3.add((long) 1);
+            docsWithField3.add(i);
+            dimValueMap.put((long) i, 10.0);
+        }
+        dimValueMap.put(Long.MAX_VALUE, 5000.0);
+        expectedDimToValueMap.put(2, dimValueMap);
+        dimValueMap = new HashMap<>();
+        List<Long> dimList2 = new ArrayList<>(500);
+        List<Integer> docsWithField2 = new ArrayList<>(500);
+        for (int i = 0; i < 500; i++) {
+            dimList2.add((long) i);
+            docsWithField2.add(i);
+            dimValueMap.put((long) i, 10.0);
+        }
+        dimValueMap.put(Long.MAX_VALUE, 200.0);
+        expectedDimToValueMap.put(1, dimValueMap);
+        dimValueMap = new HashMap<>();
+        List<Long> dimList4 = new ArrayList<>(500);
+        List<Integer> docsWithField4 = new ArrayList<>(500);
+        for (int i = 0; i < 500; i++) {
+            dimList4.add((long) 1);
+            docsWithField4.add(i);
+            dimValueMap.put((long) i, 10.0);
+        }
+        dimValueMap.put(Long.MAX_VALUE, 5000.0);
+        expectedDimToValueMap.put(3, dimValueMap);
+        List<Long> metricsList = new ArrayList<>(100);
+        List<Integer> metricsWithField = new ArrayList<>(100);
+        for (int i = 0; i < 500; i++) {
+            metricsList.add(getLongFromDouble(10.0));
+            metricsWithField.add(i);
+        }
+        List<Long> metricsList1 = new ArrayList<>(100);
+        List<Integer> metricsWithField1 = new ArrayList<>(100);
+        for (int i = 0; i < 500; i++) {
+            metricsList.add(1L);
+            metricsWithField.add(i);
+        }
+        compositeField = getStarTreeFieldWithDocCount(10, true);
+        StarTreeValues starTreeValues = getStarTreeValues(
+            dimList1,
+            docsWithField1,
+            dimList2,
+            docsWithField2,
+            dimList3,
+            docsWithField3,
+            dimList4,
+            docsWithField4,
+            metricsList,
+            metricsWithField,
+            metricsList1,
+            metricsWithField1,
+            compositeField
+        );
+
+        StarTreeValues starTreeValues2 = getStarTreeValues(
+            dimList1,
+            docsWithField1,
+            dimList2,
+            docsWithField2,
+            dimList3,
+            docsWithField3,
+            dimList4,
+            docsWithField4,
+            metricsList,
+            metricsWithField,
+            metricsList1,
+            metricsWithField1,
+            compositeField
+        );
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        builder.build(builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2)), new AtomicInteger(), docValuesConsumer);
+        List<StarTreeDocument> starTreeDocuments = builder.getStarTreeDocuments();
+        Map<Integer, Map<Long, Integer>> dimValueToDocIdMap = new HashMap<>();
+        traverseStarTree(builder.rootNode, dimValueToDocIdMap, true);
+        for (Map.Entry<Integer, Map<Long, Integer>> entry : dimValueToDocIdMap.entrySet()) {
+            int dimId = entry.getKey();
+            if (dimId == -1) continue;
+            Map<Long, Double> map = expectedDimToValueMap.get(dimId);
+            for (Map.Entry<Long, Integer> dimValueToDocIdEntry : entry.getValue().entrySet()) {
+                long dimValue = dimValueToDocIdEntry.getKey();
+                int docId = dimValueToDocIdEntry.getValue();
+                assertEquals(map.get(dimValue) * 2, starTreeDocuments.get(docId).metrics[0]);
+            }
+        }
+        assertEquals(1041, starTreeDocuments.size());
+        validateStarTree(builder.getRootNode(), 4, compositeField.getStarTreeConfig().maxLeafDocs(), builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            500,
+            builder.numStarTreeDocs,
+            compositeField.getStarTreeConfig().maxLeafDocs(),
+            Set.of(),
+            getBuildMode(),
+            0,
+            31779
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    private StarTreeField getStarTreeFieldWithDocCount(int maxLeafDocs, boolean includeDocCountMetric) {
+        Dimension d1 = new NumericDimension("field1");
+        Dimension d2 = new NumericDimension("field3");
+        Dimension d3 = new NumericDimension("field5");
+        Dimension d4 = new NumericDimension("field8");
+        List<Dimension> dims = List.of(d1, d2, d3, d4);
+        Metric m1 = new Metric("field2", List.of(MetricStat.SUM));
+        Metric m2 = null;
+        if (includeDocCountMetric) {
+            m2 = new Metric("_doc_count", List.of(MetricStat.DOC_COUNT));
+        }
+        List<Metric> metrics = m2 == null ? List.of(m1) : List.of(m1, m2);
+        StarTreeFieldConfiguration c = new StarTreeFieldConfiguration(maxLeafDocs, new HashSet<>(), getBuildMode());
+        StarTreeField sf = new StarTreeField("sf", dims, metrics, c);
+        return sf;
+    }
+
+    private void traverseStarTree(InMemoryTreeNode root, Map<Integer, Map<Long, Integer>> dimValueToDocIdMap, boolean traverStarNodes) {
+        InMemoryTreeNode starTree = root;
+        // Use BFS to traverse the star tree
+        Queue<InMemoryTreeNode> queue = new ArrayDeque<>();
+        queue.add(starTree);
+        int currentDimensionId = -1;
+        InMemoryTreeNode starTreeNode;
+        List<Integer> docIds = new ArrayList<>();
+        while ((starTreeNode = queue.poll()) != null) {
+            int dimensionId = starTreeNode.getDimensionId();
+            if (dimensionId > currentDimensionId) {
+                currentDimensionId = dimensionId;
+            }
+
+            // store aggregated document of the node
+            int docId = starTreeNode.getAggregatedDocId();
+            Map<Long, Integer> map = dimValueToDocIdMap.getOrDefault(dimensionId, new HashMap<>());
+            if (starTreeNode.getNodeType() == StarTreeNodeType.STAR.getValue()) {
+                map.put(Long.MAX_VALUE, docId);
+            } else {
+                map.put(starTreeNode.getDimensionValue(), docId);
+            }
+            dimValueToDocIdMap.put(dimensionId, map);
+
+            if (starTreeNode.getChildren() != null
+                && (!traverStarNodes || starTreeNode.getNodeType() == StarTreeNodeType.STAR.getValue())) {
+                Iterator<InMemoryTreeNode> childrenIterator = starTreeNode.getChildren().values().iterator();
+                while (childrenIterator.hasNext()) {
+                    InMemoryTreeNode childNode = childrenIterator.next();
+                    queue.add(childNode);
+                }
+            }
+        }
+    }
+
+    public void testMergeFlow() throws IOException {
+        List<Long> dimList1 = new ArrayList<>(1000);
+        List<Integer> docsWithField1 = new ArrayList<>(1000);
+        for (int i = 0; i < 1000; i++) {
+            dimList1.add((long) i);
+            docsWithField1.add(i);
+        }
+
+        List<Long> dimList2 = new ArrayList<>(1000);
+        List<Integer> docsWithField2 = new ArrayList<>(1000);
+        for (int i = 0; i < 1000; i++) {
+            dimList2.add((long) i);
+            docsWithField2.add(i);
+        }
+
+        List<Long> dimList3 = new ArrayList<>(1000);
+        List<Integer> docsWithField3 = new ArrayList<>(1000);
+        for (int i = 0; i < 1000; i++) {
+            dimList3.add((long) i);
+            docsWithField3.add(i);
+        }
+
+        List<Long> dimList4 = new ArrayList<>(1000);
+        List<Integer> docsWithField4 = new ArrayList<>(1000);
+        for (int i = 0; i < 1000; i++) {
+            dimList4.add((long) i);
+            docsWithField4.add(i);
+        }
+
+        List<Long> dimList5 = new ArrayList<>(1000);
+        List<Integer> docsWithField5 = new ArrayList<>(1000);
+        for (int i = 0; i < 1000; i++) {
+            dimList5.add((long) i);
+            docsWithField5.add(i);
+        }
+
+        List<Long> metricsList = new ArrayList<>(1000);
+        List<Integer> metricsWithField = new ArrayList<>(1000);
+        for (int i = 0; i < 1000; i++) {
+            metricsList.add(getLongFromDouble(i * 10.0));
+            metricsWithField.add(i);
+        }
+
+        List<Long> metricsListValueCount = new ArrayList<>(1000);
+        List<Integer> metricsWithFieldValueCount = new ArrayList<>(1000);
+        for (int i = 0; i < 1000; i++) {
+            metricsListValueCount.add((long) i);
+            metricsWithFieldValueCount.add(i);
+        }
+
+        Dimension d1 = new NumericDimension("field1");
+        Dimension d2 = new NumericDimension("field3");
+        Dimension d3 = new NumericDimension("field5");
+        Dimension d4 = new NumericDimension("field8");
+        // Dimension d5 = new NumericDimension("field5");
+        Metric m1 = new Metric("field2", List.of(MetricStat.SUM, MetricStat.AVG, MetricStat.VALUE_COUNT));
+        Metric m2 = new Metric("_doc_count", List.of(MetricStat.DOC_COUNT));
+        List<Dimension> dims = List.of(d1, d2, d3, d4);
+        List<Metric> metrics = List.of(m1, m2);
+        StarTreeFieldConfiguration c = new StarTreeFieldConfiguration(1, new HashSet<>(), getBuildMode());
+        compositeField = new StarTreeField("sf", dims, metrics, c);
+        SortedNumericDocValues d1sndv = getSortedNumericMock(dimList1, docsWithField1);
+        SortedNumericDocValues d2sndv = getSortedNumericMock(dimList2, docsWithField2);
+        SortedNumericDocValues d3sndv = getSortedNumericMock(dimList3, docsWithField3);
+        SortedNumericDocValues d4sndv = getSortedNumericMock(dimList4, docsWithField4);
+        SortedNumericDocValues m1sndv = getSortedNumericMock(metricsList, metricsWithField);
+        SortedNumericDocValues valucountsndv = getSortedNumericMock(metricsListValueCount, metricsWithFieldValueCount);
+        SortedNumericDocValues m2sndv = DocValues.emptySortedNumeric();
+        Map<String, Supplier<DocIdSetIterator>> dimDocIdSetIterators = Map.of(
+            "field1",
+            () -> d1sndv,
+            "field3",
+            () -> d2sndv,
+            "field5",
+            () -> d3sndv,
+            "field8",
+            () -> d4sndv
+        );
+
+        Map<String, Supplier<DocIdSetIterator>> metricDocIdSetIterators = Map.of(
+            "sf_field2_sum_metric",
+            () -> m1sndv,
+            "sf_field2_value_count_metric",
+            () -> valucountsndv,
+            "sf__doc_count_doc_count_metric",
+            () -> m2sndv
+        );
+
+        StarTreeValues starTreeValues = new StarTreeValues(
+            compositeField,
+            null,
+            dimDocIdSetIterators,
+            metricDocIdSetIterators,
+            getAttributes(1000),
+            null
+        );
+
+        SortedNumericDocValues f2d1sndv = getSortedNumericMock(dimList1, docsWithField1);
+        SortedNumericDocValues f2d2sndv = getSortedNumericMock(dimList2, docsWithField2);
+        SortedNumericDocValues f2d3sndv = getSortedNumericMock(dimList3, docsWithField3);
+        SortedNumericDocValues f2d4sndv = getSortedNumericMock(dimList4, docsWithField4);
+        SortedNumericDocValues f2m1sndv = getSortedNumericMock(metricsList, metricsWithField);
+        SortedNumericDocValues f2valucountsndv = getSortedNumericMock(metricsListValueCount, metricsWithFieldValueCount);
+        SortedNumericDocValues f2m2sndv = DocValues.emptySortedNumeric();
+        Map<String, Supplier<DocIdSetIterator>> f2dimDocIdSetIterators = Map.of(
+            "field1",
+            () -> f2d1sndv,
+            "field3",
+            () -> f2d2sndv,
+            "field5",
+            () -> f2d3sndv,
+            "field8",
+            () -> f2d4sndv
+        );
+
+        Map<String, Supplier<DocIdSetIterator>> f2metricDocIdSetIterators = Map.of(
+            "sf_field2_sum_metric",
+            () -> f2m1sndv,
+            "sf_field2_value_count_metric",
+            () -> f2valucountsndv,
+            "sf__doc_count_doc_count_metric",
+            () -> f2m2sndv
+        );
+        StarTreeValues starTreeValues2 = new StarTreeValues(
+            compositeField,
+            null,
+            f2dimDocIdSetIterators,
+            f2metricDocIdSetIterators,
+            getAttributes(1000),
+            null
+        );
+
+        this.docValuesConsumer = LuceneDocValuesConsumerFactory.getDocValuesConsumerForCompositeCodec(
+            writeState,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.DATA_DOC_VALUES_EXTENSION,
+            Composite99DocValuesFormat.META_DOC_VALUES_CODEC,
+            Composite99DocValuesFormat.META_DOC_VALUES_EXTENSION
+        );
+        builder = getStarTreeBuilder(metaOut, dataOut, compositeField, writeState, mapperService);
+        Iterator<StarTreeDocument> starTreeDocumentIterator = builder.mergeStarTrees(List.of(starTreeValues, starTreeValues2));
+        /**
+         [0, 0, 0, 0] | [0.0, 2]
+         [1, 1, 1, 1] | [20.0, 2]
+         [2, 2, 2, 2] | [40.0, 2]
+         [3, 3, 3, 3] | [60.0, 2]
+         [4, 4, 4, 4] | [80.0, 2]
+         [5, 5, 5, 5] | [100.0, 2]
+         ...
+         [999, 999, 999, 999] | [19980.0]
+         */
+        for (StarTreeDocument starTreeDocument : builder.getStarTreeDocuments()) {
+            assertEquals(starTreeDocument.dimensions[0] * 20.0, starTreeDocument.metrics[0]);
+            assertEquals(2L, starTreeDocument.metrics[1]);
+        }
+        builder.build(starTreeDocumentIterator, new AtomicInteger(), docValuesConsumer);
+
+        // Validate the star tree structure
+        validateStarTree(builder.getRootNode(), 4, 1, builder.getStarTreeDocuments());
+
+        metaOut.close();
+        dataOut.close();
+        docValuesConsumer.close();
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(
+            "sf",
+            STAR_TREE,
+            mock(IndexInput.class),
+            VERSION_CURRENT,
+            builder.numStarTreeNodes,
+            getStarTreeDimensionNames(compositeField.getDimensionsOrder()),
+            compositeField.getMetrics(),
+            1000,
+            builder.numStarTreeDocs,
+            compositeField.getStarTreeConfig().maxLeafDocs(),
+            Set.of(),
+            getBuildMode(),
+            0,
+            132165
+        );
+
+        validateStarTreeFileFormats(
+            builder.getRootNode(),
+            builder.getStarTreeDocuments().size(),
+            starTreeMetadata,
+            builder.getStarTreeDocuments()
+        );
+    }
+
+    private void validateStarTree(
+        InMemoryTreeNode root,
+        int totalDimensions,
+        int maxLeafDocuments,
+        List<StarTreeDocument> starTreeDocuments
+    ) {
+        Queue<Object[]> queue = new LinkedList<>();
+        queue.offer(new Object[] { root, false });
+        while (!queue.isEmpty()) {
+            Object[] current = queue.poll();
+            InMemoryTreeNode node = (InMemoryTreeNode) current[0];
+            boolean currentIsStarNode = (boolean) current[1];
+
+            assertNotNull(node);
+
+            // assert dimensions
+            if (node.getDimensionId() != StarTreeUtils.ALL) {
+                assertTrue(node.getDimensionId() >= 0 && node.getDimensionId() < totalDimensions);
+            }
+
+            if (node.getChildren() != null && !node.getChildren().isEmpty()) {
+                assertEquals(node.getDimensionId() + 1, node.getChildDimensionId());
+                assertTrue(node.getChildDimensionId() < totalDimensions);
+                InMemoryTreeNode starNode = null;
+                Object[] nonStarNodeCumulativeMetrics = getMetrics(starTreeDocuments);
+                for (Map.Entry<Long, InMemoryTreeNode> entry : node.getChildren().entrySet()) {
+                    Long childDimensionValue = entry.getKey();
+                    InMemoryTreeNode child = entry.getValue();
+                    Object[] currMetrics = getMetrics(starTreeDocuments);
+                    if (child.getNodeType() != StarTreeNodeType.STAR.getValue()) {
+                        // Validate dimension values in documents
+                        for (int i = child.getStartDocId(); i < child.getEndDocId(); i++) {
+                            StarTreeDocument doc = starTreeDocuments.get(i);
+                            int j = 0;
+                            addMetrics(doc, currMetrics, j);
+                            if (child.getNodeType() != StarTreeNodeType.STAR.getValue()) {
+                                Long dimension = doc.dimensions[child.getDimensionId()];
+                                assertEquals(childDimensionValue, dimension);
+                                if (dimension != null) {
+                                    assertEquals(child.getDimensionValue(), (long) dimension);
+                                } else {
+                                    // TODO : fix this ?
+                                    assertEquals(child.getDimensionValue(), StarTreeUtils.ALL);
+                                }
+                            }
+                        }
+                        Object[] aggregatedMetrics = starTreeDocuments.get(child.getAggregatedDocId()).metrics;
+                        int j = 0;
+                        for (Object metric : currMetrics) {
+                            /*
+                             * TODO : refactor this to handle any data type
+                             */
+                            if (metric instanceof Double) {
+                                nonStarNodeCumulativeMetrics[j] = (double) nonStarNodeCumulativeMetrics[j] + (double) metric;
+                                assertEquals((Double) metric, (Double) aggregatedMetrics[j], 0);
+                            } else if (metric instanceof Long) {
+                                nonStarNodeCumulativeMetrics[j] = (long) nonStarNodeCumulativeMetrics[j] + (long) metric;
+                                assertEquals((long) metric, (long) aggregatedMetrics[j]);
+                            } else if (metric instanceof Float) {
+                                nonStarNodeCumulativeMetrics[j] = (float) nonStarNodeCumulativeMetrics[j] + (float) metric;
+                                assertEquals((float) metric, (float) aggregatedMetrics[j], 0);
+                            }
+                            j++;
+                        }
+                        queue.offer(new Object[] { child, false });
+                    } else {
+                        starNode = child;
+                    }
+                }
+                // Add star node to queue
+                if (starNode != null) {
+                    Object[] starNodeMetrics = getMetrics(starTreeDocuments);
+                    for (int i = starNode.getStartDocId(); i < starNode.getEndDocId(); i++) {
+                        StarTreeDocument doc = starTreeDocuments.get(i);
+                        int j = 0;
+                        addMetrics(doc, starNodeMetrics, j);
+                    }
+                    int j = 0;
+                    Object[] aggregatedMetrics = starTreeDocuments.get(starNode.getAggregatedDocId()).metrics;
+                    for (Object nonStarNodeCumulativeMetric : nonStarNodeCumulativeMetrics) {
+                        assertEquals(nonStarNodeCumulativeMetric, starNodeMetrics[j]);
+                        assertEquals(starNodeMetrics[j], aggregatedMetrics[j]);
+                        /*
+                         * TODO : refactor this to handle any data type
+                         */
+                        if (nonStarNodeCumulativeMetric instanceof Double) {
+                            assertEquals((double) nonStarNodeCumulativeMetric, (double) starNodeMetrics[j], 0);
+                            assertEquals((double) nonStarNodeCumulativeMetric, (double) aggregatedMetrics[j], 0);
+                        } else if (nonStarNodeCumulativeMetric instanceof Long) {
+                            assertEquals((long) nonStarNodeCumulativeMetric, (long) starNodeMetrics[j]);
+                            assertEquals((long) nonStarNodeCumulativeMetric, (long) aggregatedMetrics[j]);
+                        } else if (nonStarNodeCumulativeMetric instanceof Float) {
+                            assertEquals((float) nonStarNodeCumulativeMetric, (float) starNodeMetrics[j], 0);
+                            assertEquals((float) nonStarNodeCumulativeMetric, (float) aggregatedMetrics[j], 0);
+                        }
+
+                        j++;
+                    }
+                    assertEquals(-1L, starNode.getDimensionValue());
+                    queue.offer(new Object[] { starNode, true });
+                }
+            } else {
+                assertTrue(node.getEndDocId() - node.getStartDocId() <= maxLeafDocuments);
+            }
+
+            if (currentIsStarNode) {
+                StarTreeDocument prevDoc = null;
+                int docCount = 0;
+                int docId = node.getStartDocId();
+                int dimensionId = node.getDimensionId();
+
+                while (docId < node.getEndDocId()) {
+                    StarTreeDocument currentDoc = starTreeDocuments.get(docId);
+                    docCount++;
+
+                    // Verify that the dimension at 'dimensionId' is set to STAR_IN_DOC_VALUES_INDEX
+                    assertNull(currentDoc.dimensions[dimensionId]);
+
+                    // Verify sorting of documents
+                    if (prevDoc != null) {
+                        assertTrue(compareDocuments(prevDoc, currentDoc, dimensionId + 1, totalDimensions) <= 0);
+                    }
+                    prevDoc = currentDoc;
+                    docId++;
+                }
+
+                // Verify that the number of generated star documents matches the range in the star node
+                assertEquals(node.getEndDocId() - node.getStartDocId(), docCount);
+            }
+        }
+    }
+
+    /**
+     * TODO : refactor this to handle any data type
+     */
+    private static void addMetrics(StarTreeDocument doc, Object[] currMetrics, int j) {
+        for (Object metric : doc.metrics) {
+            if (metric instanceof Double) {
+                currMetrics[j] = (double) currMetrics[j] + (double) metric;
+            } else if (metric instanceof Long) {
+                currMetrics[j] = (long) currMetrics[j] + (long) metric;
+            } else if (metric instanceof Float) {
+                currMetrics[j] = (float) currMetrics[j] + (float) metric;
+            }
+            j++;
+        }
+    }
+
+    private static Object[] getMetrics(List<StarTreeDocument> starTreeDocuments) {
+        Object[] nonStarNodeCumulativeMetrics = new Object[starTreeDocuments.get(0).metrics.length];
+        for (int i = 0; i < nonStarNodeCumulativeMetrics.length; i++) {
+            if (starTreeDocuments.get(0).metrics[i] instanceof Long) {
+                nonStarNodeCumulativeMetrics[i] = 0L;
+            } else if (starTreeDocuments.get(0).metrics[i] instanceof Double) {
+                nonStarNodeCumulativeMetrics[i] = 0.0;
+            } else if (starTreeDocuments.get(0).metrics[i] instanceof Float) {
+                nonStarNodeCumulativeMetrics[i] = 0.0f;
+            }
+        }
+        return nonStarNodeCumulativeMetrics;
+    }
+
+    private int compareDocuments(StarTreeDocument doc1, StarTreeDocument doc2, int startDim, int endDim) {
+        for (int i = startDim; i < endDim; i++) {
+            Long val1 = doc1.dimensions[i];
+            Long val2 = doc2.dimensions[i];
+
+            if (!Objects.equals(val1, val2)) {
+                if (val1 == null) return 1;
+                if (val2 == null) return -1;
+                return Long.compare(val1, val2);
+            }
+        }
+        return 0;
+    }
+
+    Map<String, String> getAttributes(int numSegmentDocs) {
+        return Map.of(CompositeIndexConstants.SEGMENT_DOCS_COUNT, String.valueOf(numSegmentDocs));
+    }
+
+    private StarTreeField getStarTreeField(MetricStat count) {
+        Dimension d1 = new NumericDimension("field1");
+        Dimension d2 = new NumericDimension("field3");
+        Metric m1 = new Metric("field2", List.of(count));
+        List<Dimension> dims = List.of(d1, d2);
+        List<Metric> metrics = List.of(m1);
+        StarTreeFieldConfiguration c = new StarTreeFieldConfiguration(1000, new HashSet<>(), getBuildMode());
+        return new StarTreeField("sf", dims, metrics, c);
+    }
+
+    SortedNumericDocValues getSortedNumericMock(List<Long> dimList, List<Integer> docsWithField) {
+        return new SortedNumericDocValues() {
+            int index = -1;
+
+            @Override
+            public long nextValue() {
+                return dimList.get(index);
+            }
+
+            @Override
+            public int docValueCount() {
+                return 0;
+            }
+
+            @Override
+            public boolean advanceExact(int target) {
+                return false;
+            }
+
+            @Override
+            public int docID() {
+                return index;
+            }
+
+            @Override
+            public int nextDoc() {
+                if (index == docsWithField.size() - 1) {
+                    return NO_MORE_DOCS;
+                }
+                index++;
+                return docsWithField.get(index);
+            }
+
+            @Override
+            public int advance(int target) {
+                return 0;
+            }
+
+            @Override
+            public long cost() {
+                return 0;
+            }
+        };
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        if (builder != null) {
+            builder.close();
+        }
+        docValuesConsumer.close();
+        metaOut.close();
+        dataOut.close();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilderTests.java
new file mode 100644
index 0000000000000..8f750b09c75ee
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/BaseStarTreeBuilderTests.java
@@ -0,0 +1,256 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.IndexFileNames;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.Version;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.index.codec.composite.composite99.Composite99DocValuesFormat;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.NumericDimension;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeDocument;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+import org.opensearch.index.compositeindex.datacube.startree.index.StarTreeValues;
+import org.opensearch.index.compositeindex.datacube.startree.utils.SequentialDocValuesIterator;
+import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.DocumentMapper;
+import org.opensearch.index.mapper.Mapper;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.MappingLookup;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class BaseStarTreeBuilderTests extends OpenSearchTestCase {
+
+    private static BaseStarTreeBuilder builder;
+    private static MapperService mapperService;
+    private static List<Dimension> dimensionsOrder;
+    private static List<String> fields = List.of(
+        "field1",
+        "field2",
+        "field3",
+        "field4",
+        "field5",
+        "field6",
+        "field7",
+        "field8",
+        "field9",
+        "field10"
+    );
+    private static List<Metric> metrics;
+    private static Directory directory;
+    private static FieldInfo[] fieldsInfo;
+    private static SegmentWriteState writeState;
+    private static StarTreeField starTreeField;
+
+    private static IndexOutput dataOut;
+    private static IndexOutput metaOut;
+
+    @BeforeClass
+    public static void setup() throws IOException {
+
+        dimensionsOrder = List.of(
+            new NumericDimension("field1"),
+            new NumericDimension("field3"),
+            new NumericDimension("field5"),
+            new NumericDimension("field8")
+        );
+        metrics = List.of(new Metric("field2", List.of(MetricStat.SUM)), new Metric("field4", List.of(MetricStat.SUM)));
+
+        starTreeField = new StarTreeField(
+            "test",
+            dimensionsOrder,
+            metrics,
+            new StarTreeFieldConfiguration(1, Set.of("field8"), StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP)
+        );
+
+        DocValuesProducer docValuesProducer = mock(DocValuesProducer.class);
+        directory = newFSDirectory(createTempDir());
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            5,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+
+        fieldsInfo = new FieldInfo[fields.size()];
+        Map<String, DocValuesProducer> fieldProducerMap = new HashMap<>();
+        for (int i = 0; i < fieldsInfo.length; i++) {
+            fieldsInfo[i] = new FieldInfo(
+                fields.get(i),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+            fieldProducerMap.put(fields.get(i), docValuesProducer);
+        }
+        FieldInfos fieldInfos = new FieldInfos(fieldsInfo);
+        writeState = new SegmentWriteState(InfoStream.getDefault(), segmentInfo.dir, segmentInfo, fieldInfos, null, newIOContext(random()));
+
+        String dataFileName = IndexFileNames.segmentFileName(
+            writeState.segmentInfo.name,
+            writeState.segmentSuffix,
+            Composite99DocValuesFormat.DATA_EXTENSION
+        );
+        dataOut = writeState.directory.createOutput(dataFileName, writeState.context);
+
+        String metaFileName = IndexFileNames.segmentFileName(
+            writeState.segmentInfo.name,
+            writeState.segmentSuffix,
+            Composite99DocValuesFormat.META_EXTENSION
+        );
+        metaOut = writeState.directory.createOutput(metaFileName, writeState.context);
+
+        mapperService = mock(MapperService.class);
+        DocumentMapper documentMapper = mock(DocumentMapper.class);
+        when(mapperService.documentMapper()).thenReturn(documentMapper);
+        Settings settings = Settings.builder().put(settings(org.opensearch.Version.CURRENT).build()).build();
+        NumberFieldMapper numberFieldMapper1 = new NumberFieldMapper.Builder("field2", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        NumberFieldMapper numberFieldMapper2 = new NumberFieldMapper.Builder("field4", NumberFieldMapper.NumberType.DOUBLE, false, true)
+            .build(new Mapper.BuilderContext(settings, new ContentPath()));
+        MappingLookup fieldMappers = new MappingLookup(
+            Set.of(numberFieldMapper1, numberFieldMapper2),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0,
+            null
+        );
+        when(documentMapper.mappers()).thenReturn(fieldMappers);
+
+        builder = new BaseStarTreeBuilder(metaOut, dataOut, starTreeField, writeState, mapperService) {
+            @Override
+            public void build(
+                List<StarTreeValues> starTreeValuesSubs,
+                AtomicInteger fieldNumberAcrossStarTrees,
+                DocValuesConsumer starTreeDocValuesConsumer
+            ) throws IOException {}
+
+            @Override
+            public void appendStarTreeDocument(StarTreeDocument starTreeDocument) throws IOException {}
+
+            @Override
+            public StarTreeDocument getStarTreeDocument(int docId) throws IOException {
+                return null;
+            }
+
+            @Override
+            public List<StarTreeDocument> getStarTreeDocuments() {
+                return List.of();
+            }
+
+            @Override
+            public Long getDimensionValue(int docId, int dimensionId) throws IOException {
+                return 0l;
+            }
+
+            @Override
+            public Iterator<StarTreeDocument> sortAndAggregateSegmentDocuments(
+                SequentialDocValuesIterator[] dimensionReaders,
+                List<SequentialDocValuesIterator> metricReaders
+            ) throws IOException {
+                return null;
+            }
+
+            @Override
+            public Iterator<StarTreeDocument> generateStarTreeDocumentsForStarNode(int startDocId, int endDocId, int dimensionId)
+                throws IOException {
+                return null;
+            }
+
+            @Override
+            Iterator<StarTreeDocument> mergeStarTrees(List<StarTreeValues> starTreeValues) throws IOException {
+                return null;
+            }
+        };
+    }
+
+    public void test_generateMetricAggregatorInfos() throws IOException {
+        List<MetricAggregatorInfo> metricAggregatorInfos = builder.generateMetricAggregatorInfos(mapperService);
+        List<MetricAggregatorInfo> expectedMetricAggregatorInfos = List.of(
+            new MetricAggregatorInfo(MetricStat.SUM, "field2", starTreeField.getName(), NumberFieldMapper.NumberType.DOUBLE),
+            new MetricAggregatorInfo(MetricStat.SUM, "field4", starTreeField.getName(), NumberFieldMapper.NumberType.DOUBLE)
+        );
+        assertEquals(metricAggregatorInfos, expectedMetricAggregatorInfos);
+    }
+
+    public void test_reduceStarTreeDocuments() {
+        StarTreeDocument starTreeDocument1 = new StarTreeDocument(new Long[] { 1L, 3L, 5L, 8L }, new Double[] { 4.0, 8.0 });
+        StarTreeDocument starTreeDocument2 = new StarTreeDocument(new Long[] { 1L, 3L, 5L, 8L }, new Double[] { 10.0, 6.0 });
+
+        StarTreeDocument expectedeMergedStarTreeDocument = new StarTreeDocument(new Long[] { 1L, 3L, 5L, 8L }, new Double[] { 14.0, 14.0 });
+        StarTreeDocument mergedStarTreeDocument = builder.reduceStarTreeDocuments(null, starTreeDocument1);
+        StarTreeDocument resultStarTreeDocument = builder.reduceStarTreeDocuments(mergedStarTreeDocument, starTreeDocument2);
+
+        assertEquals(resultStarTreeDocument.metrics[0], expectedeMergedStarTreeDocument.metrics[0]);
+        assertEquals(resultStarTreeDocument.metrics[1], expectedeMergedStarTreeDocument.metrics[1]);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        dataOut.close();
+        metaOut.close();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilderTests.java
new file mode 100644
index 0000000000000..496558dbc2e83
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OffHeapStarTreeBuilderTests.java
@@ -0,0 +1,36 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.mapper.MapperService;
+
+import java.io.IOException;
+
+public class OffHeapStarTreeBuilderTests extends AbstractStarTreeBuilderTests {
+    @Override
+    public BaseStarTreeBuilder getStarTreeBuilder(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        StarTreeField starTreeField,
+        SegmentWriteState segmentWriteState,
+        MapperService mapperService
+    ) throws IOException {
+        return new OffHeapStarTreeBuilder(metaOut, dataOut, starTreeField, segmentWriteState, mapperService);
+    }
+
+    @Override
+    StarTreeFieldConfiguration.StarTreeBuildMode getBuildMode() {
+        return StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP;
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilderTests.java
new file mode 100644
index 0000000000000..55cf3bde3cea7
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/OnHeapStarTreeBuilderTests.java
@@ -0,0 +1,37 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.mapper.MapperService;
+
+import java.io.IOException;
+
+public class OnHeapStarTreeBuilderTests extends AbstractStarTreeBuilderTests {
+
+    @Override
+    public BaseStarTreeBuilder getStarTreeBuilder(
+        IndexOutput metaOut,
+        IndexOutput dataOut,
+        StarTreeField starTreeField,
+        SegmentWriteState segmentWriteState,
+        MapperService mapperService
+    ) throws IOException {
+        return new OnHeapStarTreeBuilder(metaOut, dataOut, starTreeField, segmentWriteState, mapperService);
+    }
+
+    @Override
+    StarTreeFieldConfiguration.StarTreeBuildMode getBuildMode() {
+        return StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP;
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilderTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilderTests.java
new file mode 100644
index 0000000000000..94fe148eab6b3
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/builder/StarTreesBuilderTests.java
@@ -0,0 +1,143 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.builder;
+
+import org.apache.lucene.codecs.DocValuesConsumer;
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.Version;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.mapper.StarTreeMapper;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+public class StarTreesBuilderTests extends OpenSearchTestCase {
+
+    private MapperService mapperService;
+    private SegmentWriteState segmentWriteState;
+    private DocValuesProducer docValuesProducer;
+    private StarTreeMapper.StarTreeFieldType starTreeFieldType;
+    private StarTreeField starTreeField;
+    private Map<String, DocValuesProducer> fieldProducerMap;
+    private Directory directory;
+    private IndexOutput dataOut;
+    private IndexOutput metaOut;
+
+    public void setUp() throws Exception {
+        super.setUp();
+        metaOut = mock(IndexOutput.class);
+        dataOut = mock(IndexOutput.class);
+        mapperService = mock(MapperService.class);
+        directory = newFSDirectory(createTempDir());
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            5,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+        FieldInfos fieldInfos = new FieldInfos(new FieldInfo[0]);
+        segmentWriteState = new SegmentWriteState(
+            InfoStream.getDefault(),
+            segmentInfo.dir,
+            segmentInfo,
+            fieldInfos,
+            null,
+            newIOContext(random())
+        );
+        docValuesProducer = mock(DocValuesProducer.class);
+        StarTreeFieldConfiguration starTreeFieldConfiguration = new StarTreeFieldConfiguration(
+            1,
+            new HashSet<>(),
+            StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP
+        );
+        starTreeField = new StarTreeField("star_tree", new ArrayList<>(), new ArrayList<>(), starTreeFieldConfiguration);
+        starTreeFieldType = new StarTreeMapper.StarTreeFieldType("star_tree", starTreeField);
+        fieldProducerMap = new HashMap<>();
+        fieldProducerMap.put("field1", docValuesProducer);
+    }
+
+    public void test_buildWithNoStarTreeFields() throws IOException {
+        when(mapperService.getCompositeFieldTypes()).thenReturn(new HashSet<>());
+
+        StarTreesBuilder starTreesBuilder = new StarTreesBuilder(segmentWriteState, mapperService, new AtomicInteger());
+        starTreesBuilder.build(metaOut, dataOut, fieldProducerMap, mock(DocValuesConsumer.class));
+
+        verifyNoInteractions(docValuesProducer);
+    }
+
+    public void test_getStarTreeBuilder() throws IOException {
+        when(mapperService.getCompositeFieldTypes()).thenReturn(Set.of(starTreeFieldType));
+        StarTreesBuilder starTreesBuilder = new StarTreesBuilder(segmentWriteState, mapperService, new AtomicInteger());
+        StarTreeBuilder starTreeBuilder = starTreesBuilder.getStarTreeBuilder(metaOut, dataOut, starTreeField, segmentWriteState, mapperService);
+        assertTrue(starTreeBuilder instanceof OnHeapStarTreeBuilder);
+    }
+
+    public void test_getStarTreeBuilder_illegalArgument() throws IOException {
+        when(mapperService.getCompositeFieldTypes()).thenReturn(Set.of(starTreeFieldType));
+        StarTreeFieldConfiguration starTreeFieldConfiguration = new StarTreeFieldConfiguration(1, new HashSet<>(), StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP);
+        StarTreeField starTreeField = new StarTreeField("star_tree", new ArrayList<>(), new ArrayList<>(), starTreeFieldConfiguration);
+        StarTreesBuilder starTreesBuilder = new StarTreesBuilder(segmentWriteState, mapperService, new AtomicInteger());
+        StarTreeBuilder starTreeBuilder = starTreesBuilder.getStarTreeBuilder(metaOut, dataOut, starTreeField, segmentWriteState, mapperService);
+        assertTrue(starTreeBuilder instanceof OffHeapStarTreeBuilder);
+        starTreeBuilder.close();
+    }
+
+    public void test_closeWithNoStarTreeFields() throws IOException {
+        StarTreeFieldConfiguration starTreeFieldConfiguration = new StarTreeFieldConfiguration(
+            1,
+            new HashSet<>(),
+            StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP
+        );
+        StarTreeField starTreeField = new StarTreeField("star_tree", new ArrayList<>(), new ArrayList<>(), starTreeFieldConfiguration);
+        starTreeFieldType = new StarTreeMapper.StarTreeFieldType("star_tree", starTreeField);
+        when(mapperService.getCompositeFieldTypes()).thenReturn(Set.of(starTreeFieldType));
+        StarTreesBuilder starTreesBuilder = new StarTreesBuilder(segmentWriteState, mapperService, new AtomicInteger());
+        starTreesBuilder.close();
+
+        verifyNoInteractions(docValuesProducer);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        metaOut.close();
+        dataOut.close();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/StarTreeFileFormatsTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/StarTreeFileFormatsTests.java
new file mode 100644
index 0000000000000..4d2aa5eaf78cf
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/data/StarTreeFileFormatsTests.java
@@ -0,0 +1,198 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.data;
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.meta.StarTreeMetadata;
+import org.opensearch.index.compositeindex.datacube.startree.node.InMemoryTreeNode;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeFactory;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNode;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeNodeType;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.ArrayDeque;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Queue;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class StarTreeFileFormatsTests extends OpenSearchTestCase {
+
+    private IndexOutput dataOut;
+    private IndexInput dataIn;
+    private Directory directory;
+    private Integer maxLevels;
+    private static Integer dimensionValue;
+
+    @Before
+    public void setup() throws IOException {
+        directory = newFSDirectory(createTempDir());
+        maxLevels = randomIntBetween(2, 5);
+        dimensionValue = 0;
+    }
+
+    public void test_StarTreeNode() throws IOException {
+
+        dataOut = directory.createOutput("star-tree-data", IOContext.DEFAULT);
+        Map<Long, InMemoryTreeNode> inMemoryTreeNodeMap = new LinkedHashMap<>();
+        InMemoryTreeNode root = generateSampleTree(inMemoryTreeNodeMap);
+        StarTreeWriter starTreeWriter = new StarTreeWriter();
+        long starTreeDataLength = starTreeWriter.writeStarTree(dataOut, root, inMemoryTreeNodeMap.size(), "star-tree");
+
+        // asserting on the actual length of the star tree data file
+        assertEquals(starTreeDataLength, (inMemoryTreeNodeMap.size() * 33L));
+        dataOut.close();
+
+        dataIn = directory.openInput("star-tree-data", IOContext.READONCE);
+
+        StarTreeMetadata starTreeMetadata = mock(StarTreeMetadata.class);
+        when(starTreeMetadata.getDataLength()).thenReturn(starTreeDataLength);
+        when(starTreeMetadata.getDataStartFilePointer()).thenReturn(0L);
+
+        StarTreeNode starTreeNode = StarTreeFactory.createStarTree(dataIn, starTreeMetadata);
+        Queue<StarTreeNode> queue = new ArrayDeque<>();
+        queue.add(starTreeNode);
+
+        while ((starTreeNode = queue.poll()) != null) {
+
+            // verify the star node
+            assertStarTreeNode(starTreeNode, inMemoryTreeNodeMap.get(starTreeNode.getDimensionValue()));
+
+            Iterator<? extends StarTreeNode> childrenIterator = starTreeNode.getChildrenIterator();
+
+            if (starTreeNode.getChildDimensionId() != -1) {
+                while (childrenIterator.hasNext()) {
+                    StarTreeNode child = childrenIterator.next();
+                    if (child.getStarTreeNodeType() == StarTreeNodeType.DEFAULT.getValue()) {
+                        assertStarTreeNode(
+                            starTreeNode.getChildForDimensionValue(child.getDimensionValue()),
+                            inMemoryTreeNodeMap.get(child.getDimensionValue())
+                        );
+                        assertNull(starTreeNode.getChildStarNode());
+                    }
+
+                    queue.add(child);
+                }
+            } else {
+                assertTrue(starTreeNode.isLeaf());
+            }
+        }
+
+        dataIn.close();
+
+    }
+
+    public void test_starTreeSearch() throws IOException {
+
+        dataOut = directory.createOutput("star-tree-data", IOContext.DEFAULT);
+        Map<Long, InMemoryTreeNode> inMemoryTreeNodeMap = new LinkedHashMap<>();
+        InMemoryTreeNode root = generateSampleTree(inMemoryTreeNodeMap);
+        StarTreeWriter starTreeWriter = new StarTreeWriter();
+        long starTreeDataLength = starTreeWriter.writeStarTree(dataOut, root, inMemoryTreeNodeMap.size(), "star-tree");
+
+        // asserting on the actual length of the star tree data file
+        assertEquals(starTreeDataLength, (inMemoryTreeNodeMap.size() * 33L));
+        dataOut.close();
+
+        dataIn = directory.openInput("star-tree-data", IOContext.READONCE);
+
+        StarTreeMetadata starTreeMetadata = mock(StarTreeMetadata.class);
+        when(starTreeMetadata.getDataLength()).thenReturn(starTreeDataLength);
+        when(starTreeMetadata.getDataStartFilePointer()).thenReturn(0L);
+
+        StarTreeNode starTreeNode = StarTreeFactory.createStarTree(dataIn, starTreeMetadata);
+        InMemoryTreeNode inMemoryTreeNode = inMemoryTreeNodeMap.get(starTreeNode.getDimensionValue());
+        assertNotNull(inMemoryTreeNode);
+
+        for (int i = 0; i < maxLevels - 1; i++) {
+            InMemoryTreeNode randomChildNode = randomFrom(inMemoryTreeNode.getChildren().values());
+            StarTreeNode randomStarTreeChildNode = starTreeNode.getChildForDimensionValue(randomChildNode.getDimensionValue());
+
+            assertNotNull(randomStarTreeChildNode);
+            assertStarTreeNode(randomStarTreeChildNode, randomChildNode);
+
+            starTreeNode = randomStarTreeChildNode;
+            inMemoryTreeNode = randomChildNode;
+
+        }
+        dataIn.close();
+    }
+
+    private void assertStarTreeNode(StarTreeNode starTreeNode, InMemoryTreeNode treeNode) throws IOException {
+        assertEquals(starTreeNode.getDimensionId(), treeNode.getDimensionId());
+        assertEquals(starTreeNode.getDimensionValue(), treeNode.getDimensionValue());
+        assertEquals(starTreeNode.getStartDocId(), treeNode.getStartDocId());
+        assertEquals(starTreeNode.getEndDocId(), treeNode.getEndDocId());
+        assertEquals(starTreeNode.getChildDimensionId(), treeNode.getChildDimensionId());
+        assertEquals(starTreeNode.getAggregatedDocId(), treeNode.getAggregatedDocId());
+        assertEquals(starTreeNode.getStarTreeNodeType(), treeNode.getNodeType());
+
+        if (starTreeNode.getChildDimensionId() != -1) {
+            assertFalse(starTreeNode.isLeaf());
+            if (treeNode.getChildren() != null) {
+                assertEquals(starTreeNode.getNumChildren(), treeNode.getChildren().values().size());
+            }
+        } else {
+            assertTrue(starTreeNode.isLeaf());
+        }
+
+    }
+
+    public InMemoryTreeNode generateSampleTree(Map<Long, InMemoryTreeNode> inMemoryTreeNodeMap) {
+        // Create the root node
+        InMemoryTreeNode root = new InMemoryTreeNode(0, randomInt(), randomInt(), (byte) 0, -1);
+        root.setChildDimensionId(1);
+        root.setAggregatedDocId(randomInt());
+
+        inMemoryTreeNodeMap.put(root.getDimensionValue(), root);
+
+        // Generate the tree recursively
+        generateTreeRecursively(root, 1, inMemoryTreeNodeMap);
+
+        return root;
+    }
+
+    private void generateTreeRecursively(InMemoryTreeNode parent, int currentLevel, Map<Long, InMemoryTreeNode> inMemoryTreeNodeMap) {
+        if (currentLevel >= this.maxLevels) {
+            return; // Maximum level reached, stop generating children
+        }
+
+        int numChildren = randomIntBetween(1, 10);
+
+        for (int i = 0; i < numChildren; i++) {
+            dimensionValue++;
+            InMemoryTreeNode child = new InMemoryTreeNode(currentLevel, randomInt(), randomInt(), (byte) 0, dimensionValue);
+
+            child.setChildDimensionId((currentLevel == this.maxLevels - 1) ? -1 : (currentLevel + 1));
+            child.setAggregatedDocId(randomInt());
+
+            parent.addChildNode(child, child.getDimensionValue());
+            inMemoryTreeNodeMap.put(child.getDimensionValue(), child);
+
+            generateTreeRecursively(child, currentLevel + 1, inMemoryTreeNodeMap);
+        }
+    }
+
+    public void tearDown() throws Exception {
+        super.tearDown();
+        dataIn.close();
+        dataOut.close();
+        directory.close();
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataTests.java
new file mode 100644
index 0000000000000..2127eeb9636d3
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/meta/StarTreeMetadataTests.java
@@ -0,0 +1,227 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.meta;
+
+import org.apache.lucene.codecs.lucene99.Lucene99Codec;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.FieldInfos;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SegmentInfo;
+import org.apache.lucene.index.SegmentWriteState;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.util.InfoStream;
+import org.apache.lucene.util.Version;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.NumericDimension;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.aggregators.MetricAggregatorInfo;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter;
+import org.opensearch.index.mapper.CompositeMappedFieldType;
+import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.opensearch.index.compositeindex.CompositeIndexConstants.COMPOSITE_FIELD_MARKER;
+import static org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter.VERSION_CURRENT;
+import static org.opensearch.index.mapper.CompositeMappedFieldType.CompositeFieldType.STAR_TREE;
+
+public class StarTreeMetadataTests extends OpenSearchTestCase {
+
+    private IndexOutput metaOut;
+    private IndexInput metaIn;
+    private StarTreeField starTreeField;
+    private SegmentWriteState writeState;
+    private Directory directory;
+    private FieldInfo[] fieldsInfo;
+    private List<Dimension> dimensionsOrder;
+    private List<String> fields = List.of();
+    private List<Metric> metrics;
+    private List<MetricAggregatorInfo> metricAggregatorInfos = new ArrayList<>();
+    private int segmentDocumentCount;
+    private int numStarTreeDocs;
+    private long dataFilePointer;
+    private long dataFileLength;
+
+    @Before
+    public void setup() throws IOException {
+        fields = List.of("field1", "field2", "field3", "field4", "field5", "field6", "field7", "field8", "field9", "field10");
+        directory = newFSDirectory(createTempDir());
+        SegmentInfo segmentInfo = new SegmentInfo(
+            directory,
+            Version.LATEST,
+            Version.LUCENE_9_11_0,
+            "test_segment",
+            6,
+            false,
+            false,
+            new Lucene99Codec(),
+            new HashMap<>(),
+            UUID.randomUUID().toString().substring(0, 16).getBytes(StandardCharsets.UTF_8),
+            new HashMap<>(),
+            null
+        );
+
+        fieldsInfo = new FieldInfo[fields.size()];
+        for (int i = 0; i < fieldsInfo.length; i++) {
+            fieldsInfo[i] = new FieldInfo(
+                fields.get(i),
+                i,
+                false,
+                false,
+                true,
+                IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS,
+                DocValuesType.SORTED_NUMERIC,
+                -1,
+                Collections.emptyMap(),
+                0,
+                0,
+                0,
+                0,
+                VectorEncoding.FLOAT32,
+                VectorSimilarityFunction.EUCLIDEAN,
+                false,
+                false
+            );
+        }
+        FieldInfos fieldInfos = new FieldInfos(fieldsInfo);
+        writeState = new SegmentWriteState(InfoStream.getDefault(), segmentInfo.dir, segmentInfo, fieldInfos, null, newIOContext(random()));
+    }
+
+    public void test_starTreeMetadata() throws IOException {
+        dimensionsOrder = List.of(
+            new NumericDimension("field1"),
+            new NumericDimension("field3"),
+            new NumericDimension("field5"),
+            new NumericDimension("field8")
+        );
+        metrics = List.of(
+            new Metric("field2", List.of(MetricStat.SUM)),
+            new Metric("field4", List.of(MetricStat.SUM)),
+            new Metric("field6", List.of(MetricStat.VALUE_COUNT))
+        );
+        int maxLeafDocs = randomInt(Integer.MAX_VALUE);
+        StarTreeFieldConfiguration starTreeFieldConfiguration = new StarTreeFieldConfiguration(
+            maxLeafDocs,
+            Set.of("field10"),
+            StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP
+        );
+        starTreeField = new StarTreeField("star_tree", dimensionsOrder, metrics, starTreeFieldConfiguration);
+
+        for (Metric metric : metrics) {
+            for (MetricStat metricType : metric.getMetrics()) {
+                MetricAggregatorInfo metricAggregatorInfo = new MetricAggregatorInfo(
+                    metricType,
+                    metric.getField(),
+                    starTreeField.getName(),
+                    NumberFieldMapper.NumberType.DOUBLE
+                );
+                metricAggregatorInfos.add(metricAggregatorInfo);
+            }
+        }
+
+        dataFileLength = randomNonNegativeLong();
+        dataFilePointer = randomNonNegativeLong();
+        segmentDocumentCount = randomInt(Integer.MAX_VALUE);
+        numStarTreeDocs = randomInt(Integer.MAX_VALUE);
+        metaOut = directory.createOutput("star-tree-metadata", IOContext.DEFAULT);
+        StarTreeWriter starTreeWriter = new StarTreeWriter();
+        int numberOfNodes = randomInt(Integer.MAX_VALUE);
+        starTreeWriter.writeStarTreeMetadata(
+            metaOut,
+            starTreeField,
+            metricAggregatorInfos,
+            numberOfNodes,
+            segmentDocumentCount,
+            numStarTreeDocs,
+            dataFilePointer,
+            dataFileLength
+        );
+        metaOut.close();
+
+        // reading and asserting the metadata
+        metaIn = directory.openInput("star-tree-metadata", IOContext.READONCE);
+        assertEquals(COMPOSITE_FIELD_MARKER, metaIn.readLong());
+        assertEquals(VERSION_CURRENT, metaIn.readVInt());
+
+        String compositeFieldName = metaIn.readString();
+        CompositeMappedFieldType.CompositeFieldType compositeFieldType = CompositeMappedFieldType.CompositeFieldType.fromName(
+            metaIn.readString()
+        );
+
+        StarTreeMetadata starTreeMetadata = new StarTreeMetadata(metaIn, compositeFieldName, compositeFieldType, VERSION_CURRENT);
+        assertEquals(starTreeField.getName(), starTreeMetadata.getStarTreeFieldName());
+        assertEquals(starTreeField.getName(), starTreeMetadata.getCompositeFieldName());
+        assertEquals(STAR_TREE, starTreeMetadata.getCompositeFieldType());
+        assertEquals(STAR_TREE.getName(), starTreeMetadata.getStarTreeFieldType());
+        assertEquals(starTreeMetadata.getVersion(), VERSION_CURRENT);
+        assertEquals(starTreeMetadata.getNumberOfNodes(), numberOfNodes);
+        assertNotNull(starTreeMetadata);
+
+        for (int i = 0; i < dimensionsOrder.size(); i++) {
+            assertEquals(dimensionsOrder.get(i).getField(), starTreeMetadata.getDimensionFields().get(i));
+        }
+
+        assertEquals(starTreeField.getMetrics().size(), starTreeMetadata.getMetrics().size());
+
+        for (int i = 0; i < starTreeField.getMetrics().size(); i++) {
+
+            Metric expectedMetric = starTreeField.getMetrics().get(i);
+            Metric resultMetric = starTreeMetadata.getMetrics().get(i);
+
+            assertEquals(expectedMetric.getField(), resultMetric.getField());
+            assertEquals(expectedMetric.getMetrics().size(), resultMetric.getMetrics().size());
+
+            for (int j = 0; j < resultMetric.getMetrics().size(); j++) {
+                assertEquals(expectedMetric.getMetrics().get(j), resultMetric.getMetrics().get(j));
+            }
+        }
+        assertEquals(segmentDocumentCount, starTreeMetadata.getSegmentAggregatedDocCount(), 0);
+        assertEquals(maxLeafDocs, starTreeMetadata.getMaxLeafDocs(), 0);
+        assertEquals(
+            starTreeFieldConfiguration.getSkipStarNodeCreationInDims().size(),
+            starTreeMetadata.getSkipStarNodeCreationInDims().size()
+        );
+        for (String skipStarNodeCreationInDims : starTreeField.getStarTreeConfig().getSkipStarNodeCreationInDims()) {
+            assertTrue(starTreeMetadata.getSkipStarNodeCreationInDims().contains(skipStarNodeCreationInDims));
+        }
+        assertEquals(starTreeFieldConfiguration.getBuildMode(), starTreeMetadata.getStarTreeBuildMode());
+        assertEquals(dataFileLength, starTreeMetadata.getDataLength());
+        assertEquals(dataFilePointer, starTreeMetadata.getDataStartFilePointer());
+
+        metaIn.close();
+
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        metaOut.close();
+        metaIn.close();
+        directory.close();
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/FixedLengthStarTreeNodeTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/FixedLengthStarTreeNodeTests.java
new file mode 100644
index 0000000000000..08815d5ef55f5
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/fileformats/node/FixedLengthStarTreeNodeTests.java
@@ -0,0 +1,236 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.fileformats.node;
+
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeTestUtils;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.StarTreeWriter;
+import org.opensearch.index.compositeindex.datacube.startree.fileformats.meta.StarTreeMetadata;
+import org.opensearch.index.compositeindex.datacube.startree.node.InMemoryTreeNode;
+import org.opensearch.index.compositeindex.datacube.startree.node.StarTreeFactory;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.Iterator;
+
+import static org.opensearch.index.compositeindex.datacube.startree.utils.StarTreeUtils.ALL;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class FixedLengthStarTreeNodeTests extends OpenSearchTestCase {
+
+    private IndexOutput dataOut;
+    private IndexInput dataIn;
+    private Directory directory;
+    InMemoryTreeNode node;
+    InMemoryTreeNode starChild;
+    InMemoryTreeNode nullChild;
+    InMemoryTreeNode childWithMinus1;
+    FixedLengthStarTreeNode starTreeNode;
+
+    @Before
+    public void setup() throws IOException {
+        directory = newFSDirectory(createTempDir());
+
+        dataOut = directory.createOutput("star-tree-data", IOContext.DEFAULT);
+        StarTreeWriter starTreeWriter = new StarTreeWriter();
+
+        node = new InMemoryTreeNode(0, randomInt(), randomInt(), randomFrom((byte) 0, (byte) -1, (byte) 1), -1);
+        node.setChildDimensionId(1);
+        node.setAggregatedDocId(randomInt());
+
+        starChild = new InMemoryTreeNode(node.getDimensionId() + 1, randomInt(), randomInt(), (byte) -1, -1);
+        starChild.setChildDimensionId(-1);
+        starChild.setAggregatedDocId(randomInt());
+        node.addChildNode(starChild, (long) ALL);
+
+        childWithMinus1 = new InMemoryTreeNode(node.getDimensionId() + 1, randomInt(), randomInt(), (byte) 0, -1);
+        childWithMinus1.setChildDimensionId(-1);
+        childWithMinus1.setAggregatedDocId(randomInt());
+        node.addChildNode(childWithMinus1, -1L);
+
+        for (int i = 1; i < randomIntBetween(2, 5); i++) {
+            InMemoryTreeNode child = new InMemoryTreeNode(
+                node.getDimensionId() + 1,
+                randomInt(),
+                randomInt(),
+                (byte) 0,
+                node.getDimensionValue() + i
+            );
+            child.setChildDimensionId(-1);
+            child.setAggregatedDocId(randomInt());
+            node.addChildNode(child, child.getDimensionValue());
+        }
+
+        nullChild = new InMemoryTreeNode(node.getDimensionId() + 1, randomInt(), randomInt(), (byte) 1, -1);
+        nullChild.setChildDimensionId(-1);
+        nullChild.setAggregatedDocId(randomInt());
+        node.addChildNode(nullChild, null);
+
+        long starTreeDataLength = starTreeWriter.writeStarTree(dataOut, node, 2 + node.getChildren().size(), "star-tree");
+
+        // asserting on the actual length of the star tree data file
+        assertEquals(starTreeDataLength, 33L * node.getChildren().size() + 2 * 33);
+        dataOut.close();
+
+        dataIn = directory.openInput("star-tree-data", IOContext.READONCE);
+        StarTreeMetadata starTreeMetadata = mock(StarTreeMetadata.class);
+        when(starTreeMetadata.getDataLength()).thenReturn(starTreeDataLength);
+        when(starTreeMetadata.getDataStartFilePointer()).thenReturn(0L);
+
+        starTreeNode = (FixedLengthStarTreeNode) StarTreeFactory.createStarTree(dataIn, starTreeMetadata);
+
+    }
+
+    public void testOffsets() {
+        assertEquals(0, FixedLengthStarTreeNode.DIMENSION_ID_OFFSET);
+        assertEquals(4, FixedLengthStarTreeNode.DIMENSION_VALUE_OFFSET);
+        assertEquals(12, FixedLengthStarTreeNode.START_DOC_ID_OFFSET);
+        assertEquals(16, FixedLengthStarTreeNode.END_DOC_ID_OFFSET);
+        assertEquals(20, FixedLengthStarTreeNode.AGGREGATE_DOC_ID_OFFSET);
+        assertEquals(24, FixedLengthStarTreeNode.STAR_NODE_TYPE_OFFSET);
+        assertEquals(25, FixedLengthStarTreeNode.FIRST_CHILD_ID_OFFSET);
+        assertEquals(29, FixedLengthStarTreeNode.LAST_CHILD_ID_OFFSET);
+    }
+
+    public void testSerializableDataSize() {
+        assertEquals(33, FixedLengthStarTreeNode.SERIALIZABLE_DATA_SIZE_IN_BYTES);
+    }
+
+    public void testGetDimensionId() throws IOException {
+        assertEquals(node.getDimensionId(), starTreeNode.getDimensionId());
+    }
+
+    public void testGetDimensionValue() throws IOException {
+        assertEquals(node.getDimensionValue(), starTreeNode.getDimensionValue());
+    }
+
+    public void testGetStartDocId() throws IOException {
+        assertEquals(node.getStartDocId(), starTreeNode.getStartDocId());
+    }
+
+    public void testGetEndDocId() throws IOException {
+        assertEquals(node.getEndDocId(), starTreeNode.getEndDocId());
+    }
+
+    public void testGetAggregatedDocId() throws IOException {
+        assertEquals(node.getAggregatedDocId(), starTreeNode.getAggregatedDocId());
+    }
+
+    public void testGetNumChildren() throws IOException {
+        assertEquals(node.getChildren().size(), starTreeNode.getNumChildren() - 1);
+    }
+
+    public void testIsLeaf() {
+        assertFalse(starTreeNode.isLeaf());
+    }
+
+    public void testGetStarTreeNodeType() throws IOException {
+        assertEquals(node.getNodeType(), starTreeNode.getStarTreeNodeType());
+    }
+
+    public void testGetChildForDimensionValue() throws IOException {
+        long dimensionValue = randomIntBetween(-1, node.getChildren().size() - 3);
+        FixedLengthStarTreeNode childNode = (FixedLengthStarTreeNode) starTreeNode.getChildForDimensionValue(dimensionValue);
+        assertNotNull(childNode);
+        assertEquals(dimensionValue, childNode.getDimensionValue());
+    }
+
+    public void testGetChildrenIterator() throws IOException {
+        Iterator<FixedLengthStarTreeNode> iterator = starTreeNode.getChildrenIterator();
+        int count = 0;
+        while (iterator.hasNext()) {
+            FixedLengthStarTreeNode child = iterator.next();
+            assertNotNull(child);
+            count++;
+        }
+        assertEquals(starTreeNode.getNumChildren(), count);
+    }
+
+    public void testChildrenOrder() throws IOException {
+        Iterator<FixedLengthStarTreeNode> iterator = starTreeNode.getChildrenIterator();
+        int count = 0;
+        while (iterator.hasNext()) {
+            FixedLengthStarTreeNode child = iterator.next();
+            count++;
+            if (count == 1) {
+                StarTreeTestUtils.assertStarTreeNode(child, starChild);
+            } else if (count == 2) {
+                StarTreeTestUtils.assertStarTreeNode(child, childWithMinus1);
+            } else if (count == starTreeNode.getNumChildren()) {
+                StarTreeTestUtils.assertStarTreeNode(child, nullChild);
+            } else {
+                StarTreeTestUtils.assertStarTreeNode(child, node.getChildren().get(child.getDimensionValue()));
+            }
+            assertNotNull(child);
+        }
+        assertEquals(starTreeNode.getNumChildren(), count);
+    }
+
+    public void testGetChildForStarNode() throws IOException {
+        // Assuming the first child is a star node in our test data
+        FixedLengthStarTreeNode starNode = (FixedLengthStarTreeNode) starTreeNode.getChildStarNode();
+        assertNotNull(starNode);
+        assertEquals(ALL, starNode.getDimensionValue());
+    }
+
+    public void testGetChildForNullNode() throws IOException {
+        FixedLengthStarTreeNode nullNode = (FixedLengthStarTreeNode) starTreeNode.getChildForDimensionValue(null);
+        assertNull(nullNode);
+    }
+
+    public void testGetChildForInvalidDimensionValue() throws IOException {
+        long invalidDimensionValue = Long.MAX_VALUE;
+        assertNull(starTreeNode.getChildForDimensionValue(invalidDimensionValue));
+    }
+
+    public void testOnlyRootNodePresent() throws IOException {
+
+        Directory directory = newFSDirectory(createTempDir());
+
+        IndexOutput dataOut = directory.createOutput("star-tree-data-1", IOContext.DEFAULT);
+        StarTreeWriter starTreeWriter = new StarTreeWriter();
+
+        InMemoryTreeNode node = new InMemoryTreeNode(0, randomInt(), randomInt(), randomFrom((byte) 0, (byte) -1, (byte) 2), -1);
+        node.setChildDimensionId(1);
+        node.setAggregatedDocId(randomInt());
+
+        long starTreeDataLength = starTreeWriter.writeStarTree(dataOut, node, 1, "star-tree");
+
+        // asserting on the actual length of the star tree data file
+        assertEquals(starTreeDataLength, 33);
+        dataOut.close();
+
+        IndexInput dataIn = directory.openInput("star-tree-data-1", IOContext.READONCE);
+        StarTreeMetadata starTreeMetadata = mock(StarTreeMetadata.class);
+        when(starTreeMetadata.getDataLength()).thenReturn(starTreeDataLength);
+        when(starTreeMetadata.getDataStartFilePointer()).thenReturn(0L);
+
+        FixedLengthStarTreeNode starTreeNode = (FixedLengthStarTreeNode) StarTreeFactory.createStarTree(dataIn, starTreeMetadata);
+
+        assertEquals(starTreeNode.getNumChildren(), 0);
+        assertNull(starTreeNode.getChildForDimensionValue(randomLong()));
+        assertThrows(IllegalArgumentException.class, () -> starTreeNode.getChildrenIterator().next());
+        assertThrows(UnsupportedOperationException.class, () -> starTreeNode.getChildrenIterator().remove());
+
+        dataIn.close();
+        directory.close();
+    }
+
+    public void tearDown() throws Exception {
+        super.tearDown();
+        dataIn.close();
+        dataOut.close();
+        directory.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNodeTypeTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNodeTypeTests.java
new file mode 100644
index 0000000000000..f1034e5d1d033
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/node/StarTreeNodeTypeTests.java
@@ -0,0 +1,58 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.node;
+
+import org.opensearch.test.OpenSearchTestCase;
+
+public class StarTreeNodeTypeTests extends OpenSearchTestCase {
+
+    public void testStarNodeType() {
+        assertEquals("star", StarTreeNodeType.STAR.getName());
+        assertEquals((byte) -1, StarTreeNodeType.STAR.getValue());
+    }
+
+    public void testNullNodeType() {
+        assertEquals("null", StarTreeNodeType.NULL.getName());
+        assertEquals((byte) 1, StarTreeNodeType.NULL.getValue());
+    }
+
+    public void testDefaultNodeType() {
+        assertEquals("default", StarTreeNodeType.DEFAULT.getName());
+        assertEquals((byte) 0, StarTreeNodeType.DEFAULT.getValue());
+    }
+
+    public void testFromValue() {
+        assertEquals(StarTreeNodeType.STAR, StarTreeNodeType.fromValue((byte) -1));
+        assertEquals(StarTreeNodeType.NULL, StarTreeNodeType.fromValue((byte) 1));
+        assertEquals(StarTreeNodeType.DEFAULT, StarTreeNodeType.fromValue((byte) 0));
+    }
+
+    public void testFromValueInvalid() {
+        IllegalStateException exception = expectThrows(IllegalStateException.class, () -> StarTreeNodeType.fromValue((byte) 2));
+        assertEquals("Unrecognized value byte to determine star-tree node type: [2]", exception.getMessage());
+    }
+
+    public void testEnumValues() {
+        StarTreeNodeType[] values = StarTreeNodeType.values();
+        assertEquals(3, values.length);
+        assertArrayEquals(new StarTreeNodeType[] { StarTreeNodeType.STAR, StarTreeNodeType.DEFAULT, StarTreeNodeType.NULL }, values);
+    }
+
+    public void testEnumValueOf() {
+        assertEquals(StarTreeNodeType.STAR, StarTreeNodeType.valueOf("STAR"));
+        assertEquals(StarTreeNodeType.NULL, StarTreeNodeType.valueOf("NULL"));
+        assertEquals(StarTreeNodeType.DEFAULT, StarTreeNodeType.valueOf("DEFAULT"));
+    }
+
+    public void testEnumValueOfInvalid() {
+        IllegalArgumentException exception = expectThrows(IllegalArgumentException.class, () -> StarTreeNodeType.valueOf("INVALID"));
+        assertTrue(exception.getMessage().contains("No enum constant"));
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIteratorTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIteratorTests.java
new file mode 100644
index 0000000000000..f56f7d9906ae1
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/SequentialDocValuesIteratorTests.java
@@ -0,0 +1,131 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.codecs.DocValuesProducer;
+import org.apache.lucene.index.BinaryDocValues;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.util.BytesRef;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.BeforeClass;
+
+import java.io.IOException;
+import java.util.Collections;
+
+import org.mockito.Mockito;
+
+import static org.mockito.Mockito.when;
+
+public class SequentialDocValuesIteratorTests extends OpenSearchTestCase {
+
+    private static FieldInfo mockFieldInfo;
+
+    @BeforeClass
+    public static void setup() {
+        mockFieldInfo = new FieldInfo(
+            "field",
+            1,
+            false,
+            false,
+            true,
+            IndexOptions.NONE,
+            DocValuesType.NONE,
+            -1,
+            Collections.emptyMap(),
+            0,
+            0,
+            0,
+            0,
+            VectorEncoding.FLOAT32,
+            VectorSimilarityFunction.EUCLIDEAN,
+            false,
+            false
+        );
+    }
+
+    public void testCreateIterator_SortedNumeric() throws IOException {
+        DocValuesProducer producer = Mockito.mock(DocValuesProducer.class);
+        SortedNumericDocValues iterator = Mockito.mock(SortedNumericDocValues.class);
+        when(producer.getSortedNumeric(mockFieldInfo)).thenReturn(iterator);
+        SequentialDocValuesIterator result = new SequentialDocValuesIterator(producer.getSortedNumeric(mockFieldInfo));
+        assertEquals(iterator.getClass(), result.getDocIdSetIterator().getClass());
+    }
+
+    public void testCreateIterator_UnsupportedType() throws IOException {
+        DocValuesProducer producer = Mockito.mock(DocValuesProducer.class);
+        BinaryDocValues iterator = Mockito.mock(BinaryDocValues.class);
+        when(producer.getBinary(mockFieldInfo)).thenReturn(iterator);
+        SequentialDocValuesIterator result = new SequentialDocValuesIterator(producer.getBinary(mockFieldInfo));
+        assertEquals(iterator.getClass(), result.getDocIdSetIterator().getClass());
+        when(iterator.nextDoc()).thenReturn(0);
+        when(iterator.binaryValue()).thenReturn(new BytesRef("123"));
+
+        IllegalStateException exception = expectThrows(IllegalStateException.class, () -> {
+            result.nextDoc(0);
+            result.value(0);
+        });
+        assertEquals("Unsupported Iterator requested for SequentialDocValuesIterator", exception.getMessage());
+    }
+
+    public void testGetNextValue_SortedNumeric() throws IOException {
+        SortedNumericDocValues iterator = Mockito.mock(SortedNumericDocValues.class);
+        when(iterator.nextDoc()).thenReturn(0);
+        when(iterator.nextValue()).thenReturn(123L);
+        SequentialDocValuesIterator sequentialDocValuesIterator = new SequentialDocValuesIterator(iterator);
+        sequentialDocValuesIterator.nextDoc(0);
+        long result = sequentialDocValuesIterator.value(0);
+        assertEquals(123L, result);
+    }
+
+    public void testGetNextValue_UnsupportedIterator() {
+        DocIdSetIterator iterator = Mockito.mock(DocIdSetIterator.class);
+        SequentialDocValuesIterator sequentialDocValuesIterator = new SequentialDocValuesIterator(iterator);
+
+        IllegalStateException exception = expectThrows(IllegalStateException.class, () -> { sequentialDocValuesIterator.value(0); });
+        assertEquals("Unsupported Iterator requested for SequentialDocValuesIterator", exception.getMessage());
+    }
+
+    public void testNextDoc() throws IOException {
+        SortedNumericDocValues iterator = Mockito.mock(SortedNumericDocValues.class);
+        SequentialDocValuesIterator sequentialDocValuesIterator = new SequentialDocValuesIterator(iterator);
+        when(iterator.nextDoc()).thenReturn(5);
+
+        int result = sequentialDocValuesIterator.nextDoc(5);
+        assertEquals(5, result);
+    }
+
+    public void test_multipleCoordinatedDocumentReader() throws IOException {
+        SortedNumericDocValues iterator1 = Mockito.mock(SortedNumericDocValues.class);
+        SortedNumericDocValues iterator2 = Mockito.mock(SortedNumericDocValues.class);
+
+        SequentialDocValuesIterator sequentialDocValuesIterator1 = new SequentialDocValuesIterator(iterator1);
+        SequentialDocValuesIterator sequentialDocValuesIterator2 = new SequentialDocValuesIterator(iterator2);
+
+        when(iterator1.nextDoc()).thenReturn(0);
+        when(iterator2.nextDoc()).thenReturn(1);
+
+        when(iterator1.nextValue()).thenReturn(9L);
+        when(iterator2.nextValue()).thenReturn(9L);
+
+        sequentialDocValuesIterator1.nextDoc(0);
+        sequentialDocValuesIterator2.nextDoc(0);
+        assertEquals(0, sequentialDocValuesIterator1.getDocId());
+        assertEquals(9L, (long) sequentialDocValuesIterator1.value(0));
+        assertNull(sequentialDocValuesIterator2.value(0));
+        assertNotEquals(0, sequentialDocValuesIterator2.getDocId());
+        assertEquals(1, sequentialDocValuesIterator2.getDocId());
+        assertEquals(9L, (long) sequentialDocValuesIterator2.value(1));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentBitSetUtilTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentBitSetUtilTests.java
new file mode 100644
index 0000000000000..7d1bd37246fae
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentBitSetUtilTests.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.store.FSDirectory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.apache.lucene.store.RandomAccessInput;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.function.Function;
+
+/**
+ * Unit tests for {@link StarTreeDocumentBitSetUtil}
+ */
+public class StarTreeDocumentBitSetUtilTests extends OpenSearchTestCase {
+
+    public void testWriteAndReadNullBitSets() throws IOException {
+        for (int k = 0; k < 10; k++) {
+            int randomArraySize = randomIntBetween(2, 256);
+            Long[] dims = new Long[randomArraySize];
+            for (int i = 0; i < randomArraySize; i++) {
+                dims[i] = randomLong();
+            }
+            testNullBasedOnBitset(dims);
+        }
+    }
+
+    void testNullBasedOnBitset(Long[] dims) throws IOException {
+        Long[] dims1 = Arrays.copyOf(dims, dims.length);
+        int randomNullIndex1 = randomIntBetween(0, dims.length - 1);
+        int randomNullIndex2 = randomIntBetween(0, dims.length - 1);
+        dims[randomNullIndex1] = null;
+        dims[randomNullIndex2] = null;
+        Path basePath = createTempDir("OffHeapTests");
+        FSDirectory fsDirectory = FSDirectory.open(basePath);
+        String TEST_FILE = "test_file";
+        IndexOutput indexOutput = fsDirectory.createOutput(TEST_FILE, IOContext.DEFAULT);
+        StarTreeDocumentBitSetUtil.writeBitSet(dims, indexOutput);
+        indexOutput.close();
+
+        // test null value on read
+        IndexInput in = fsDirectory.openInput(TEST_FILE, IOContext.DEFAULT);
+        RandomAccessInput randomAccessInput = in.randomAccessSlice(0, in.length());
+        Function<Integer, Object> identityValueSupplier = i -> null;
+        StarTreeDocumentBitSetUtil.readBitSet(randomAccessInput, 0, dims1, identityValueSupplier);
+        assertNull(dims1[randomNullIndex1]);
+        assertNull(dims1[randomNullIndex2]);
+        in.close();
+
+        // test identity value on read
+        long randomLong = randomLong();
+        identityValueSupplier = i -> randomLong;
+        in = fsDirectory.openInput(TEST_FILE, IOContext.DEFAULT);
+
+        randomAccessInput = in.randomAccessSlice(0, in.length());
+        StarTreeDocumentBitSetUtil.readBitSet(randomAccessInput, 0, dims1, identityValueSupplier);
+        assertEquals(randomLong, (long) dims1[randomNullIndex1]);
+        assertEquals(randomLong, (long) dims1[randomNullIndex2]);
+        in.close();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentsSorterTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentsSorterTests.java
new file mode 100644
index 0000000000000..b485ea1a4fe3e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeDocumentsSorterTests.java
@@ -0,0 +1,201 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.opensearch.common.Randomness;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Random;
+
+/**
+ * Tests for {@link StarTreeDocumentsSorter}.
+ */
+public class StarTreeDocumentsSorterTests extends OpenSearchTestCase {
+    private Map<Integer, Long[]> testData;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        testData = new HashMap<>();
+        testData.put(0, new Long[] { -1L, 2L, 3L });
+        testData.put(1, new Long[] { 1L, 2L, 2L });
+        testData.put(2, new Long[] { -1L, -1L, 3L });
+        testData.put(3, new Long[] { 1L, 2L, null });
+        testData.put(4, new Long[] { 1L, null, 3L });
+    }
+
+    public void testSortDocumentsOffHeap_FirstDimension() {
+        int[] sortedDocIds = { 0, 1, 2, 3, 4 };
+        int dimensionId = -1;
+        int numDocs = 5;
+
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, i -> testData.get(sortedDocIds[i]));
+
+        assertArrayEquals(new int[] { 2, 0, 1, 3, 4 }, sortedDocIds);
+    }
+
+    public void testSortDocumentsOffHeap_ThirdDimension() {
+        int[] sortedDocIds = { 0, 1, 2, 3, 4 };
+        int dimensionId = 1;
+        int numDocs = 5;
+
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, i -> testData.get(sortedDocIds[i]));
+
+        assertArrayEquals(new int[] { 1, 0, 2, 4, 3 }, sortedDocIds);
+    }
+
+    public void testSortDocumentsOffHeap_SingleElement() {
+        int[] sortedDocIds = { 0 };
+        int dimensionId = -1;
+        int numDocs = 1;
+
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, i -> testData.get(sortedDocIds[i]));
+
+        assertArrayEquals(new int[] { 0 }, sortedDocIds);
+    }
+
+    public void testSortDocumentsOffHeap_EmptyArray() {
+        int[] sortedDocIds = {};
+        int dimensionId = -1;
+        int numDocs = 0;
+
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, i -> testData.get(sortedDocIds[i]));
+
+        assertArrayEquals(new int[] {}, sortedDocIds);
+    }
+
+    public void testSortDocumentsOffHeap_SecondDimensionId() {
+        int[] sortedDocIds = { 0, 1, 2, 3, 4 };
+        int dimensionId = 0;
+        int numDocs = 5;
+
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, i -> testData.get(sortedDocIds[i]));
+
+        assertArrayEquals(new int[] { 2, 1, 0, 3, 4 }, sortedDocIds);
+    }
+
+    public void testSortDocumentsOffHeap_AllNulls() {
+        Map<Integer, Long[]> testData = new HashMap<>();
+        testData.put(0, new Long[] { null, null, null });
+        testData.put(1, new Long[] { null, null, null });
+        testData.put(2, new Long[] { null, null, null });
+
+        int[] sortedDocIds = { 0, 1, 2 };
+        int dimensionId = -1;
+        int numDocs = 3;
+
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, i -> testData.get(sortedDocIds[i]));
+
+        // The order should remain unchanged as all elements are equal (null)
+        assertArrayEquals(new int[] { 0, 1, 2 }, sortedDocIds);
+    }
+
+    public void testSortDocumentsOffHeap_Negatives() {
+        Map<Integer, Long[]> testData = new HashMap<>();
+        testData.put(0, new Long[] { -10L, 0L });
+        testData.put(1, new Long[] { -9L, 0L });
+        testData.put(2, new Long[] { -8L, 0L });
+        testData.put(3, new Long[] { -7L, -0L });
+        testData.put(4, new Long[] { -15L, -0L });
+
+        int[] sortedDocIds = { 0, 1, 2, 3, 4 };
+        int dimensionId = -1;
+        int numDocs = 5;
+
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, i -> testData.get(sortedDocIds[i]));
+
+        // The order should remain unchanged as all elements are equal (null)
+        assertArrayEquals(new int[] { 4, 0, 1, 2, 3 }, sortedDocIds);
+    }
+
+    public void testRandomSort() {
+        int i = 0;
+        while (i < 10) {
+            testRandomizedSort();
+            i++;
+        }
+    }
+
+    private void testRandomizedSort() {
+
+        int numDocs = randomIntBetween(0, 1000);
+        Random random = Randomness.get();
+        // skew more towards realistic number of dimensions
+        int numDimensions = random.nextBoolean() ? randomIntBetween(2, 10) : randomIntBetween(2, 100);
+        List<Long[]> testData = new ArrayList<>();
+        // Generate random test data
+        for (int i = 0; i < numDocs; i++) {
+            Long[] dimensions = new Long[numDimensions];
+            for (int j = 0; j < numDimensions; j++) {
+                if (random.nextFloat() < 0.5) {
+                    dimensions[j] = random.nextBoolean() ? Long.valueOf(0L) : random.nextBoolean() ? -1L : null;
+                } else {
+                    dimensions[j] = random.nextLong();
+                }
+            }
+            testData.add(dimensions);
+        }
+
+        int[] sortedDocIds = new int[numDocs];
+        for (int i = 0; i < numDocs; i++) {
+            sortedDocIds[i] = i;
+        }
+        // sort dimensionId + 1 to numDimensions
+        // for example to start from dimension in 0th index, we need to pass -1 to sort method
+        int dimensionId = random.nextInt(numDimensions) - 1;
+
+        // Sort using StarTreeDocumentsSorter
+        StarTreeDocumentsSorter.sort(sortedDocIds, dimensionId, numDocs, i -> testData.get(sortedDocIds[i]));
+
+        // Verify the sorting
+        for (int i = 1; i < numDocs; i++) {
+            Long[] prev = testData.get(sortedDocIds[i - 1]);
+            Long[] curr = testData.get(sortedDocIds[i]);
+            boolean isCorrectOrder = true;
+            for (int j = dimensionId + 1; j < numDimensions; j++) {
+                int comparison = compareLongs(prev[j], curr[j]);
+                if (comparison < 0) {
+                    break;
+                } else if (comparison > 0) {
+                    isCorrectOrder = false;
+                    break;
+                }
+            }
+            assertTrue(
+                "Sorting error when sorting from dimension index "
+                    + dimensionId
+                    + " Prev : "
+                    + Arrays.toString(prev)
+                    + " :: Curr : "
+                    + Arrays.toString(curr),
+                isCorrectOrder
+            );
+        }
+    }
+
+    private int compareLongs(Long a, Long b) {
+        if (!Objects.equals(a, b)) {
+            if (a == null) {
+                return 1;
+            } else if (b == null) {
+                return -1;
+            } else {
+                return a.compareTo(b);
+            }
+        }
+        return 0;
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeUtilsTests.java b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeUtilsTests.java
new file mode 100644
index 0000000000000..9cca0b04e9ea4
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/compositeindex/datacube/startree/utils/StarTreeUtilsTests.java
@@ -0,0 +1,78 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.compositeindex.datacube.startree.utils;
+
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.FieldInfo;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.VectorEncoding;
+import org.apache.lucene.index.VectorSimilarityFunction;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
+
+public class StarTreeUtilsTests extends OpenSearchTestCase {
+
+    public void testFullyQualifiedFieldNameForStarTreeDimensionsDocValues() {
+        String starTreeFieldName = "myStarTreeField";
+        String dimensionName = "dimension1";
+        String expectedFieldName = "myStarTreeField_dimension1_dim";
+
+        String actualFieldName = StarTreeUtils.fullyQualifiedFieldNameForStarTreeDimensionsDocValues(starTreeFieldName, dimensionName);
+        assertEquals(expectedFieldName, actualFieldName);
+    }
+
+    public void testFullyQualifiedFieldNameForStarTreeMetricsDocValues() {
+        String starTreeFieldName = "myStarTreeField";
+        String fieldName = "myField";
+        String metricName = "metric1";
+        String expectedFieldName = "myStarTreeField_myField_metric1_metric";
+
+        String actualFieldName = StarTreeUtils.fullyQualifiedFieldNameForStarTreeMetricsDocValues(starTreeFieldName, fieldName, metricName);
+        assertEquals(expectedFieldName, actualFieldName);
+    }
+
+    public void testGetFieldInfoList() {
+        List<String> fieldNames = Arrays.asList("field1", "field2", "field3");
+        FieldInfo[] actualFieldInfos = StarTreeUtils.getFieldInfoList(fieldNames);
+        for (int i = 0; i < fieldNames.size(); i++) {
+            assertFieldInfos(actualFieldInfos[i], fieldNames.get(i), i);
+        }
+    }
+
+    public void testGetFieldInfo() {
+        String fieldName = UUID.randomUUID().toString();
+        int fieldNumber = randomInt();
+        assertFieldInfos(StarTreeUtils.getFieldInfo(fieldName, DocValuesType.SORTED_NUMERIC, fieldNumber), fieldName, fieldNumber);
+
+    }
+
+    private void assertFieldInfos(FieldInfo actualFieldInfo, String fieldName, Integer fieldNumber) {
+        assertEquals(fieldName, actualFieldInfo.name);
+        assertEquals(fieldNumber, actualFieldInfo.number, 0);
+        assertFalse(actualFieldInfo.hasVectorValues());
+        assertTrue(actualFieldInfo.hasNorms());
+        assertFalse(actualFieldInfo.hasVectors());
+        assertEquals(IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS, actualFieldInfo.getIndexOptions());
+        assertEquals(DocValuesType.SORTED_NUMERIC, actualFieldInfo.getDocValuesType());
+        assertEquals(-1, actualFieldInfo.getDocValuesGen());
+        assertEquals(Collections.emptyMap(), actualFieldInfo.attributes());
+        assertEquals(0, actualFieldInfo.getPointDimensionCount());
+        assertEquals(0, actualFieldInfo.getPointIndexDimensionCount());
+        assertEquals(0, actualFieldInfo.getPointNumBytes());
+        assertEquals(0, actualFieldInfo.getVectorDimension());
+        assertEquals(VectorEncoding.FLOAT32, actualFieldInfo.getVectorEncoding());
+        assertEquals(VectorSimilarityFunction.EUCLIDEAN, actualFieldInfo.getVectorSimilarityFunction());
+        assertFalse(actualFieldInfo.isSoftDeletesField());
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/engine/InternalEngineTests.java b/server/src/test/java/org/opensearch/index/engine/InternalEngineTests.java
index a41deac296648..11ad355e22afd 100644
--- a/server/src/test/java/org/opensearch/index/engine/InternalEngineTests.java
+++ b/server/src/test/java/org/opensearch/index/engine/InternalEngineTests.java
@@ -1873,7 +1873,7 @@ public void testForceMergeWithSoftDeletesRetentionAndRecoverySource() throws Exc
         try (
             Store store = createStore();
             InternalEngine engine = createEngine(
-                config(indexSettings, store, createTempDir(), newMergePolicy(), null, null, globalCheckpoint::get)
+                config(indexSettings, store, createTempDir(), newMergePolicy(random(), false), null, null, globalCheckpoint::get)
             )
         ) {
             int numDocs = scaledRandomIntBetween(10, 100);
diff --git a/server/src/test/java/org/opensearch/index/get/GetResultTests.java b/server/src/test/java/org/opensearch/index/get/GetResultTests.java
index 64b14744a40d2..ef8c48f2753c7 100644
--- a/server/src/test/java/org/opensearch/index/get/GetResultTests.java
+++ b/server/src/test/java/org/opensearch/index/get/GetResultTests.java
@@ -35,12 +35,16 @@
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.document.DocumentField;
 import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.common.xcontent.LoggingDeprecationHandler;
 import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.ParsingException;
 import org.opensearch.core.common.Strings;
 import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.xcontent.MediaType;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.mapper.IdFieldMapper;
@@ -220,6 +224,22 @@ public void testEqualsAndHashcode() {
         );
     }
 
+    public void testFromXContentEmbeddedFoundParsingException() throws IOException {
+        String json = "{\"_index\":\"foo\",\"_id\":\"bar\"}";
+        try (
+            XContentParser parser = JsonXContent.jsonXContent.createParser(
+                NamedXContentRegistry.EMPTY,
+                LoggingDeprecationHandler.INSTANCE,
+                json
+            )
+        ) {
+            ensureExpectedToken(XContentParser.Token.START_OBJECT, parser.nextToken(), parser);
+            ParsingException parsingException = assertThrows(ParsingException.class, () -> GetResult.fromXContentEmbedded(parser));
+            assertEquals("Missing required field [found]", parsingException.getMessage());
+        }
+
+    }
+
     public static GetResult copyGetResult(GetResult getResult) {
         return new GetResult(
             getResult.getIndex(),
diff --git a/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java
index 65dd3b6447663..e9d0b6d826ade 100644
--- a/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldMapperTests.java
@@ -105,6 +105,14 @@ public void testMissingDefaultIndexMapper() throws Exception {
         assertThat(e.getMessage(), containsString("Field [field] is missing required parameter [value]"));
     }
 
+    public void testBuilderToXContent() throws IOException {
+        ConstantKeywordFieldMapper.Builder builder = new ConstantKeywordFieldMapper.Builder("name", "value1");
+        XContentBuilder xContentBuilder = JsonXContent.contentBuilder().startObject();
+        builder.toXContent(xContentBuilder, false);
+        xContentBuilder.endObject();
+        assertEquals("{\"value\":\"value1\"}", xContentBuilder.toString());
+    }
+
     private final SourceToParse source(CheckedConsumer<XContentBuilder, IOException> build) throws IOException {
         XContentBuilder builder = JsonXContent.contentBuilder().startObject();
         build.accept(builder);
diff --git a/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldTypeTests.java
index 235811539a299..266d79fb8e8b8 100644
--- a/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/ConstantKeywordFieldTypeTests.java
@@ -10,6 +10,8 @@
 
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.MatchNoDocsQuery;
+import org.apache.lucene.search.MultiTermQuery;
+import org.apache.lucene.search.Query;
 import org.opensearch.Version;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.regex.Regex;
@@ -61,6 +63,58 @@ public void testExistsQuery() {
         assertEquals(new MatchAllDocsQuery(), ft.existsQuery(createContext()));
     }
 
+    public void testRangeQuery() {
+        Query actual = ft.rangeQuery("default", null, true, false, null, null, null, MOCK_QSC);
+        assertEquals(new MatchAllDocsQuery(), actual);
+
+        actual = ft.rangeQuery("default", null, false, false, null, null, null, MOCK_QSC);
+        assertEquals(new MatchNoDocsQuery(), actual);
+
+        actual = ft.rangeQuery(null, "default", true, true, null, null, null, MOCK_QSC);
+        assertEquals(new MatchAllDocsQuery(), actual);
+
+        actual = ft.rangeQuery(null, "default", false, false, null, null, null, MOCK_QSC);
+        assertEquals(new MatchNoDocsQuery(), actual);
+
+        actual = ft.rangeQuery("default", "default", false, true, null, null, null, MOCK_QSC);
+        assertEquals(new MatchNoDocsQuery(), actual);
+
+        actual = ft.rangeQuery("default", "default", true, false, null, null, null, MOCK_QSC);
+        assertEquals(new MatchNoDocsQuery(), actual);
+
+        actual = ft.rangeQuery(null, null, false, false, null, null, null, MOCK_QSC);
+        assertEquals(new MatchAllDocsQuery(), actual);
+
+        actual = ft.rangeQuery("default", "default", true, true, null, null, null, MOCK_QSC);
+        assertEquals(new MatchAllDocsQuery(), actual);
+
+        actual = ft.rangeQuery("defaul", "default1", true, true, null, null, null, MOCK_QSC);
+        assertEquals(new MatchAllDocsQuery(), actual);
+    }
+
+    public void testRegexpQuery() {
+        final ConstantKeywordFieldMapper.ConstantKeywordFieldType ft = new ConstantKeywordFieldMapper.ConstantKeywordFieldType(
+            "field",
+            "d3efault"
+        );
+        // test .*
+        Query query = ft.regexpQuery("d.*", 0, 0, 10, MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE, MOCK_QSC);
+        assertEquals(new MatchAllDocsQuery(), query);
+        // test \d and ?
+        query = ft.regexpQuery("d\\defau[a-z]?t", 0, 0, 10, MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE, MOCK_QSC);
+        assertEquals(new MatchAllDocsQuery(), query);
+
+        // test \d and ?
+        query = ft.regexpQuery("d\\defa[a-z]?t", 0, 0, 10, MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE, MOCK_QSC);
+        assertEquals(new MatchNoDocsQuery(), query);
+        // \w{m,n}
+        query = ft.regexpQuery("d3efa[a-z]{3,3}", 0, 0, 10, MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE, MOCK_QSC);
+        assertEquals(new MatchAllDocsQuery(), query);
+        // \w{m,n}
+        query = ft.regexpQuery("d3efa[a-z]{4,4}", 0, 0, 10, MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE, MOCK_QSC);
+        assertEquals(new MatchNoDocsQuery(), query);
+    }
+
     private QueryShardContext createContext() {
         IndexMetadata indexMetadata = IndexMetadata.builder("index")
             .settings(Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT))
diff --git a/server/src/test/java/org/opensearch/index/mapper/CopyToMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/CopyToMapperTests.java
index b274cf28429e8..7a8c4ffe35021 100644
--- a/server/src/test/java/org/opensearch/index/mapper/CopyToMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/CopyToMapperTests.java
@@ -247,6 +247,46 @@ public void testCopyToStrictDynamicInnerObjectParsing() throws Exception {
         assertThat(e.getMessage(), startsWith("mapping set to strict, dynamic introduction of [very] within [_doc] is not allowed"));
     }
 
+    public void testCopyToStrictAllowTemplatesDynamicInnerObjectParsing() throws Exception {
+        DocumentMapper docMapper = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("match", "test");
+                        b.startObject("mapping").field("type", "object").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+            b.startObject("properties");
+            {
+                b.startObject("copy_test");
+                {
+                    b.field("type", "text");
+                    b.field("copy_to", "very.inner.field");
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+
+        MapperParsingException e = expectThrows(
+            MapperParsingException.class,
+            () -> docMapper.parse(source(b -> b.field("copy_test", "foo")))
+        );
+
+        assertThat(
+            e.getMessage(),
+            startsWith("mapping set to strict_allow_templates, dynamic introduction of [very] within [_doc] is not allowed")
+        );
+    }
+
     public void testCopyToInnerStrictDynamicInnerObjectParsing() throws Exception {
 
         DocumentMapper docMapper = createDocumentMapper(mapping(b -> {
diff --git a/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
index 7ed2ca2d150d6..df800067143e4 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DateFieldTypeTests.java
@@ -41,7 +41,6 @@
 import org.apache.lucene.index.MultiReader;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.search.DocIdSetIterator;
-import org.apache.lucene.search.IndexOrDocValuesQuery;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.IndexSortSortedNumericDocValuesRangeQuery;
 import org.apache.lucene.search.Query;
@@ -53,6 +52,7 @@
 import org.opensearch.common.time.DateFormatters;
 import org.opensearch.common.time.DateMathParser;
 import org.opensearch.common.util.BigArrays;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.fielddata.IndexNumericFieldData;
@@ -65,6 +65,8 @@
 import org.opensearch.index.query.DateRangeIncludingNowQuery;
 import org.opensearch.index.query.QueryRewriteContext;
 import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.search.approximate.ApproximateIndexOrDocValuesQuery;
+import org.opensearch.search.approximate.ApproximatePointRangeQuery;
 import org.joda.time.DateTimeZone;
 
 import java.io.IOException;
@@ -72,6 +74,10 @@
 import java.time.ZoneOffset;
 import java.util.Collections;
 
+import static org.hamcrest.CoreMatchers.is;
+import static org.apache.lucene.document.LongPoint.pack;
+import static org.junit.Assume.assumeThat;
+
 public class DateFieldTypeTests extends FieldTypeTestCase {
 
     private static final long nowInMillis = 0;
@@ -207,10 +213,26 @@ public void testTermQuery() {
         MappedFieldType ft = new DateFieldType("field");
         String date = "2015-10-12T14:10:55";
         long instant = DateFormatters.from(DateFieldMapper.getDefaultDateTimeFormatter().parse(date)).toInstant().toEpochMilli();
-        Query expected = new IndexOrDocValuesQuery(
+        Query expected = new ApproximateIndexOrDocValuesQuery(
             LongPoint.newRangeQuery("field", instant, instant + 999),
+            new ApproximatePointRangeQuery(
+                "field",
+                pack(new long[] { instant }).bytes,
+                pack(new long[] { instant + 999 }).bytes,
+                new long[] { instant }.length
+            ) {
+                @Override
+                protected String toString(int dimension, byte[] value) {
+                    return Long.toString(LongPoint.decodeDimension(value, 0));
+                }
+            },
             SortedNumericDocValuesField.newSlowRangeQuery("field", instant, instant + 999)
         );
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
         assertEquals(expected, ft.termQuery(date, context));
 
         MappedFieldType unsearchable = new DateFieldType(
@@ -257,10 +279,26 @@ public void testRangeQuery() throws IOException {
         String date2 = "2016-04-28T11:33:52";
         long instant1 = DateFormatters.from(DateFieldMapper.getDefaultDateTimeFormatter().parse(date1)).toInstant().toEpochMilli();
         long instant2 = DateFormatters.from(DateFieldMapper.getDefaultDateTimeFormatter().parse(date2)).toInstant().toEpochMilli() + 999;
-        Query expected = new IndexOrDocValuesQuery(
+        Query expected = new ApproximateIndexOrDocValuesQuery(
             LongPoint.newRangeQuery("field", instant1, instant2),
+            new ApproximatePointRangeQuery(
+                "field",
+                pack(new long[] { instant1 }).bytes,
+                pack(new long[] { instant2 }).bytes,
+                new long[] { instant1 }.length
+            ) {
+                @Override
+                protected String toString(int dimension, byte[] value) {
+                    return Long.toString(LongPoint.decodeDimension(value, 0));
+                }
+            },
             SortedNumericDocValuesField.newSlowRangeQuery("field", instant1, instant2)
         );
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
         assertEquals(
             expected,
             ft.rangeQuery(date1, date2, true, true, null, null, null, context).rewrite(new IndexSearcher(new MultiReader()))
@@ -269,11 +307,27 @@ public void testRangeQuery() throws IOException {
         instant1 = nowInMillis;
         instant2 = instant1 + 100;
         expected = new DateRangeIncludingNowQuery(
-            new IndexOrDocValuesQuery(
+            new ApproximateIndexOrDocValuesQuery(
                 LongPoint.newRangeQuery("field", instant1, instant2),
+                new ApproximatePointRangeQuery(
+                    "field",
+                    pack(new long[] { instant1 }).bytes,
+                    pack(new long[] { instant2 }).bytes,
+                    new long[] { instant1 }.length
+                ) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return Long.toString(LongPoint.decodeDimension(value, 0));
+                    }
+                },
                 SortedNumericDocValuesField.newSlowRangeQuery("field", instant1, instant2)
             )
         );
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
         assertEquals(expected, ft.rangeQuery("now", instant2, true, true, null, null, null, context));
 
         MappedFieldType unsearchable = new DateFieldType(
@@ -330,13 +384,31 @@ public void testRangeQueryWithIndexSort() {
         long instant1 = DateFormatters.from(DateFieldMapper.getDefaultDateTimeFormatter().parse(date1)).toInstant().toEpochMilli();
         long instant2 = DateFormatters.from(DateFieldMapper.getDefaultDateTimeFormatter().parse(date2)).toInstant().toEpochMilli() + 999;
 
-        Query pointQuery = LongPoint.newRangeQuery("field", instant1, instant2);
         Query dvQuery = SortedNumericDocValuesField.newSlowRangeQuery("field", instant1, instant2);
         Query expected = new IndexSortSortedNumericDocValuesRangeQuery(
             "field",
             instant1,
             instant2,
-            new IndexOrDocValuesQuery(pointQuery, dvQuery)
+            new ApproximateIndexOrDocValuesQuery(
+                LongPoint.newRangeQuery("field", instant1, instant2),
+                new ApproximatePointRangeQuery(
+                    "field",
+                    pack(new long[] { instant1 }).bytes,
+                    pack(new long[] { instant2 }).bytes,
+                    new long[] { instant1 }.length
+                ) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return Long.toString(LongPoint.decodeDimension(value, 0));
+                    }
+                },
+                dvQuery
+            )
+        );
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
         );
         assertEquals(expected, ft.rangeQuery(date1, date2, true, true, null, null, null, context));
     }
diff --git a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperQueryTests.java b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperQueryTests.java
index 1307028dd27b0..c744f2592e24f 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperQueryTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldMapperQueryTests.java
@@ -15,16 +15,22 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.queryparser.classic.ParseException;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.TopDocs;
 import org.apache.lucene.store.Directory;
+import org.opensearch.OpenSearchParseException;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.lucene.Lucene;
 import org.opensearch.core.index.Index;
 import org.opensearch.geometry.Rectangle;
+import org.opensearch.index.query.MatchPhrasePrefixQueryBuilder;
+import org.opensearch.index.query.MultiMatchQueryBuilder;
 import org.opensearch.index.query.QueryBuilders;
 import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.index.query.TermQueryBuilder;
+import org.opensearch.index.search.QueryStringQueryParser;
 import org.opensearch.script.DerivedFieldScript;
 
 import java.io.IOException;
@@ -35,6 +41,7 @@
 import org.mockito.Mockito;
 
 import static org.opensearch.index.query.QueryBuilders.geoShapeQuery;
+import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.when;
 
 public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
@@ -50,7 +57,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "GET",
             1.5,
             1500L,
-            new Tuple<>(10.0, 20.0) },
+            new Tuple<>(10.0, 20.0),
+            "{ "
+                + "\"float_field\": 1.5,"
+                + "\"boolean_field\": true,"
+                + "\"long_field\": 1500,"
+                + "\"date_field\": \"2024-03-20T08:30:45\","
+                + "\"keyword_field\": \"GET\","
+                + "\"array_field\": [1, 2, 3],"
+                + "\"text_field\": \"document number 1\","
+                + "\"nested_field\": { \"sub_field_1\": \"GET\"}"
+                + "}" },
         {
             "232.0.0.0 GET /images/hm_bg.jpg?size=2.3KB HTTP/1.0 400 2024-03-20T09:15:20 2300",
             false,
@@ -59,7 +76,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "GET",
             2.3,
             2300L,
-            new Tuple<>(20.0, 30.0) },
+            new Tuple<>(20.0, 30.0),
+            "{ "
+                + "\"float_field\": 2.3,"
+                + "\"boolean_field\": false,"
+                + "\"long_field\": 2300,"
+                + "\"date_field\": \"2024-03-20T09:15:20\","
+                + "\"keyword_field\": \"GET\","
+                + "\"array_field\": [4, 5, 6],"
+                + "\"text_field\": \"document number 2\","
+                + "\"nested_field\": { \"sub_field_1\": \"GET\"}"
+                + "}" },
         {
             "26.1.0.0 DELETE /images/hm_bg.jpg?size=3.7KB HTTP/1.0 200 2024-03-20T10:05:55 3700",
             true,
@@ -68,7 +95,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "DELETE",
             3.7,
             3700L,
-            new Tuple<>(30.0, 40.0) },
+            new Tuple<>(30.0, 40.0),
+            "{ "
+                + "\"float_field\": 3.7,"
+                + "\"boolean_field\": true,"
+                + "\"long_field\": 3700,"
+                + "\"date_field\": \"2024-03-20T10:05:55\","
+                + "\"array_field\": [7, 8, 9],"
+                + "\"keyword_field\": \"DELETE\","
+                + "\"text_field\": \"document number 3\","
+                + "\"nested_field\": { \"sub_field_1\": \"DELETE\"}"
+                + "}" },
         {
             "247.37.0.0 GET /french/splash_inet.html?size=4.1KB HTTP/1.0 400 2024-03-20T11:20:10 4100",
             false,
@@ -77,7 +114,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "GET",
             4.1,
             4100L,
-            new Tuple<>(40.0, 50.0) },
+            new Tuple<>(40.0, 50.0),
+            "{ "
+                + "\"float_field\": 4.1,"
+                + "\"boolean_field\": false,"
+                + "\"long_field\": 4100,"
+                + "\"date_field\": \"2024-03-20T11:20:10\","
+                + "\"keyword_field\": \"GET\","
+                + "\"array_field\": [10, 11, 12],"
+                + "\"text_field\": \"document number 4\","
+                + "\"nested_field\": { \"sub_field_1\": \"GET\"}"
+                + "}" },
         {
             "247.37.0.0 DELETE /french/splash_inet.html?size=5.8KB HTTP/1.0 400 2024-03-20T12:45:30 5800",
             false,
@@ -86,7 +133,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "DELETE",
             5.8,
             5800L,
-            new Tuple<>(50.0, 60.0) },
+            new Tuple<>(50.0, 60.0),
+            "{ "
+                + "\"float_field\": 5.8,"
+                + "\"boolean_field\": false,"
+                + "\"long_field\": 5800,"
+                + "\"date_field\": \"2024-03-20T12:45:30\","
+                + "\"keyword_field\": \"DELETE\","
+                + "\"array_field\": [13, 14, 15],"
+                + "\"text_field\": \"document number 5\","
+                + "\"nested_field\": { \"sub_field_1\": \"DELETE\"}"
+                + "}" },
         {
             "10.20.30.40 GET /path/to/resource?size=6.3KB HTTP/1.0 200 2024-03-20T13:10:15 6300",
             true,
@@ -95,7 +152,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "GET",
             6.3,
             6300L,
-            new Tuple<>(60.0, 70.0) },
+            new Tuple<>(60.0, 70.0),
+            "{ "
+                + "\"float_field\": 6.3,"
+                + "\"boolean_field\": true,"
+                + "\"long_field\": 6300,"
+                + "\"date_field\": \"2024-03-20T13:10:15\","
+                + "\"keyword_field\": \"GET\","
+                + "\"array_field\": [16, 17, 18],"
+                + "\"text_field\": \"document number 6\","
+                + "\"nested_field\": { \"sub_field_1\": \"GET\"}"
+                + "}" },
         {
             "50.60.70.80 GET /path/to/resource?size=7.2KB HTTP/1.0 404 2024-03-20T14:20:50 7200",
             false,
@@ -104,7 +171,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "GET",
             7.2,
             7200L,
-            new Tuple<>(70.0, 80.0) },
+            new Tuple<>(70.0, 80.0),
+            "{ "
+                + "\"float_field\": 7.2,"
+                + "\"boolean_field\": false,"
+                + "\"long_field\": 7200,"
+                + "\"date_field\": \"2024-03-20T14:20:50\","
+                + "\"keyword_field\": \"GET\","
+                + "\"array_field\": [19, 20, 21],"
+                + "\"text_field\": \"document number 7\","
+                + "\"nested_field\": { \"sub_field_1\": \"GET\"}"
+                + "}" },
         {
             "127.0.0.1 PUT /path/to/resource?size=8.9KB HTTP/1.0 500 2024-03-20T15:30:25 8900",
             false,
@@ -113,7 +190,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "PUT",
             8.9,
             8900L,
-            new Tuple<>(80.0, 90.0) },
+            new Tuple<>(80.0, 90.0),
+            "{ "
+                + "\"float_field\": 8.9,"
+                + "\"boolean_field\": false,"
+                + "\"long_field\": 8900,"
+                + "\"date_field\": \"2024-03-20T15:30:25\","
+                + "\"keyword_field\": \"PUT\","
+                + "\"array_field\": [22, 23, 24],"
+                + "\"text_field\": \"document number 8\","
+                + "\"nested_field\": { \"sub_field_1\": \"PUT\"}"
+                + "}" },
         {
             "127.0.0.1 GET /path/to/resource?size=9.4KB HTTP/1.0 200 2024-03-20T16:40:15 9400",
             true,
@@ -122,7 +209,17 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "GET",
             9.4,
             9400L,
-            new Tuple<>(85.0, 90.0) },
+            new Tuple<>(85.0, 90.0),
+            "{ "
+                + "\"float_field\": 9.4,"
+                + "\"boolean_field\": true,"
+                + "\"long_field\": 9400,"
+                + "\"date_field\": \"2024-03-20T16:40:15\","
+                + "\"keyword_field\": \"GET\","
+                + "\"array_field\": [25, 26, 27],"
+                + "\"text_field\": \"document number 9\","
+                + "\"nested_field\": { \"sub_field_1\": \"GET\"}"
+                + "}" },
         {
             "192.168.1.1 GET /path/to/resource?size=10.7KB HTTP/1.0 400 2024-03-20T17:50:40 10700",
             false,
@@ -131,7 +228,39 @@ public class DerivedFieldMapperQueryTests extends MapperServiceTestCase {
             "GET",
             10.7,
             10700L,
-            new Tuple<>(90.0, 90.0) } };
+            new Tuple<>(90.0, 90.0),
+            "{ "
+                + "\"float_field\": 10.7,"
+                + "\"boolean_field\": false,"
+                + "\"long_field\": 10700,"
+                + "\"date_field\": \"2024-03-20T17:50:40\","
+                + "\"keyword_field\": \"GET\","
+                + "\"array_field\": [28, 29, 30],"
+                + "\"text_field\": \"document number 10\","
+                + "\"invalid_field\": {},"
+                + "\"nested_field\": { \"sub_field_1\": \"GET\"}"
+                + "}" },
+        // malformed json
+        {
+            "192.168.1.1 GET /path/to/resource?size=10.7KB HTTP/1.0 400 2024-03-20T17:50:40 10700",
+            false,
+            -1L,
+            "192.169.1.1",
+            "JKJ",
+            -1,
+            -1,
+            new Tuple<>(-1.0, -1.0),
+            "{ "
+                + "\"float_field\": 10.7,"
+                + "\"boolean_field\": false,"
+                + "\"long_field\": 10700,"
+                + "\"date_field\": \"2024-03-20T17:50:40\","
+                + "\"keyword_field\": \"GET\","
+                + "\"array_field\": [28, 29, 30],"
+                + "\"text_field\": \"document number 10\","
+                + "\"invalid_field\": {},"
+                + "\"nested_field\": { \"sub_field_1\": \"GET\"}"
+                + "" } };
 
     public void testAllPossibleQueriesOnDerivedFields() throws IOException {
         MapperService mapperService = createMapperService(topMapping(b -> {
@@ -156,6 +285,7 @@ public void testAllPossibleQueriesOnDerivedFields() throws IOException {
                 {
                     b.field("type", "date");
                     b.field("script", "");
+                    b.field("format", "yyyy-MM-dd");
                 }
                 b.endObject();
                 b.startObject("client_ip");
@@ -188,6 +318,12 @@ public void testAllPossibleQueriesOnDerivedFields() throws IOException {
                     b.field("script", "");
                 }
                 b.endObject();
+                b.startObject("object_field");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                }
+                b.endObject();
             }
             b.endObject();
         }));
@@ -302,4 +438,530 @@ public void execute() {
             }
         }
     }
+
+    public void testObjectDerivedFields() throws IOException, ParseException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("raw_message");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("object_field");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.field("ignore_malformed", "true");
+                }
+                b.endObject();
+                b.startObject("object_field_without_ignored_malformed");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+
+        List<Document> docs = new ArrayList<>();
+        for (Object[] request : raw_requests) {
+            Document document = new Document();
+            document.add(new TextField("raw_message", (String) request[0], Field.Store.YES));
+            docs.add(document);
+        }
+
+        int[] scriptIndex = { 8 };
+
+        // Mock DerivedFieldScript.Factory
+        DerivedFieldScript.Factory factory = (params, lookup) -> (DerivedFieldScript.LeafFactory) ctx -> new DerivedFieldScript(
+            params,
+            lookup,
+            ctx
+        ) {
+            int docId = 0;
+
+            @Override
+            public void setDocument(int docId) {
+                super.setDocument(docId);
+                this.docId = docId;
+            }
+
+            @Override
+            public void execute() {
+                addEmittedValue(raw_requests[docId][scriptIndex[0]]);
+            }
+        };
+
+        // Index and Search
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            for (Document d : docs) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+                when(queryShardContext.compile(Mockito.any(), Mockito.any())).thenReturn(factory);
+                when(queryShardContext.sourcePath("raw_message")).thenReturn(Set.of("raw_message"));
+                when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+                when(queryShardContext.getIndexReader()).thenReturn(reader);
+                when(queryShardContext.fieldMapper(anyString())).thenAnswer(inv -> {
+                    MappedFieldType res = mapperService.fieldType(inv.getArguments()[0].toString());
+                    if (res == null) {
+                        DerivedFieldResolver derivedFieldResolver = DerivedFieldResolverFactory.createResolver(
+                            queryShardContext,
+                            null,
+                            null,
+                            true
+                        );
+                        res = derivedFieldResolver.resolve(inv.getArguments()[0].toString());
+                    }
+                    return res;
+                });
+                IndexSearcher searcher = new IndexSearcher(reader);
+
+                // NOTE: object_field.keyword_field will be resolved to a text field for nested field as that's the default behaviour in
+                // dynamic mappings too
+                TermQueryBuilder termQueryBuilder = new TermQueryBuilder("object_field.keyword_field", "GET");
+                termQueryBuilder.caseInsensitive(true);
+                Query query = termQueryBuilder.toQuery(queryShardContext);
+                TopDocs topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                // since last doc has a malformed json, if ignore_malformed isn't set or set as false, the query should fail
+                termQueryBuilder = new TermQueryBuilder("object_field_without_ignored_malformed.keyword_field", "GET");
+                termQueryBuilder.caseInsensitive(true);
+                query = termQueryBuilder.toQuery(queryShardContext);
+                Query finalQuery = query;
+                assertThrows(OpenSearchParseException.class, () -> searcher.search(finalQuery, 10));
+
+                query = QueryBuilders.matchPhraseQuery("object_field.text_field", "document number 1").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(1, topDocs.totalHits.value);
+
+                query = QueryBuilders.matchPhraseQuery("object_field.text_field", "document number 11").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(0, topDocs.totalHits.value);
+
+                query = new MatchPhrasePrefixQueryBuilder("object_field.text_field", "document number").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(0, topDocs.totalHits.value);
+
+                // Multi Phrase Query
+                query = QueryBuilders.multiMatchQuery("GET", "object_field.nested_field.sub_field_1", "object_field.keyword_field")
+                    .type(MultiMatchQueryBuilder.Type.PHRASE)
+                    .toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                // Range queries of types - date, long and double
+                query = QueryBuilders.rangeQuery("object_field.date_field").from("2024-03-20T14:20:50").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(4, topDocs.totalHits.value);
+
+                query = QueryBuilders.rangeQuery("object_field.float_field").from("4.1").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                query = QueryBuilders.rangeQuery("object_field.long_field").from("5800").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(6, topDocs.totalHits.value);
+
+                // Prefix Query
+                query = QueryBuilders.prefixQuery("object_field.keyword_field", "de").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+
+                query = QueryBuilders.wildcardQuery("object_field.keyword_field", "g*").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                QueryStringQueryParser queryParser = new QueryStringQueryParser(queryShardContext, "object_field.keyword_field");
+                queryParser.parse("GE?");
+                topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                // Regexp Query
+                query = QueryBuilders.regexpQuery("object_field.keyword_field", ".*let.*").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+
+                // tested deep nested field
+                query = QueryBuilders.regexpQuery("object_field.nested_field.sub_field_1", ".*let.*").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+
+                // Test nested array field
+                query = QueryBuilders.rangeQuery("object_field.array_field").from("1").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(10, topDocs.totalHits.value);
+
+                query = QueryBuilders.rangeQuery("object_field.array_field").from("3").to("6").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+
+                query = QueryBuilders.rangeQuery("object_field.array_field").from("9").to("9").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(1, topDocs.totalHits.value);
+
+                query = QueryBuilders.rangeQuery("object_field.array_field").from("10").to("12").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(1, topDocs.totalHits.value);
+
+                query = QueryBuilders.rangeQuery("object_field.array_field").from("31").to("50").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(0, topDocs.totalHits.value);
+
+                // tested missing nested field
+                query = QueryBuilders.regexpQuery("object_field.invalid_field.sub_field", ".*let.*").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(0, topDocs.totalHits.value);
+            }
+        }
+    }
+
+    public void testObjectDerivedFieldsWithPrefilterField() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("raw_message");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+                b.startObject("long_field");
+                {
+                    b.field("type", "long");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("regular_derived_field");
+                {
+                    b.field("type", "text");
+                    b.field("script", "");
+                    b.field("ignore_malformed", true);
+                    b.field("prefilter_field", "raw_message");
+                }
+                b.endObject();
+                b.startObject("regular_derived_field_without_prefilter_field");
+                {
+                    b.field("type", "text");
+                    b.field("script", "");
+                    b.field("ignore_malformed", true);
+                }
+                b.endObject();
+                b.startObject("object_field");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.field("ignore_malformed", true);
+                }
+                b.endObject();
+                b.startObject("object_field_2");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.startObject("properties");
+                    {
+                        b.field("keyword_field", "keyword");
+                    }
+                    b.endObject();
+                    b.field("prefilter_field", "raw_message");
+                    b.field("ignore_malformed", true);
+                }
+                b.endObject();
+                b.startObject("invalid_object");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.startObject("properties");
+                    {
+                        b.field("keyword_field", "keyword");
+                    }
+                    b.endObject();
+                    b.field("prefilter_field", "invalid_field");
+                    b.field("ignore_malformed", true);
+                }
+                b.endObject();
+                b.startObject("long_prefilter_field_object");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.startObject("properties");
+                    {
+                        b.field("keyword_field", "keyword");
+                    }
+                    b.endObject();
+                    b.field("prefilter_field", "long_field");
+                    b.field("ignore_malformed", true);
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+
+        List<Document> docs = new ArrayList<>();
+        for (Object[] request : raw_requests) {
+            Document document = new Document();
+            document.add(new TextField("raw_message", (String) request[0], Field.Store.YES));
+            docs.add(document);
+        }
+
+        int[] scriptIndex = { 8 };
+        int[] docsEvaluated = { 0 };
+
+        // Mock DerivedFieldScript.Factory
+        DerivedFieldScript.Factory factory = (params, lookup) -> (DerivedFieldScript.LeafFactory) ctx -> new DerivedFieldScript(
+            params,
+            lookup,
+            ctx
+        ) {
+            int docId = 0;
+
+            @Override
+            public void setDocument(int docId) {
+                docsEvaluated[0]++;
+                super.setDocument(docId);
+                this.docId = docId;
+            }
+
+            @Override
+            public void execute() {
+                addEmittedValue(raw_requests[docId][scriptIndex[0]]);
+            }
+        };
+
+        // Index and Search
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            for (Document d : docs) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+                when(queryShardContext.compile(Mockito.any(), Mockito.any())).thenReturn(factory);
+                when(queryShardContext.sourcePath("raw_message")).thenReturn(Set.of("raw_message"));
+                when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+                when(queryShardContext.getIndexReader()).thenReturn(reader);
+                when(queryShardContext.fieldMapper(anyString())).thenAnswer(inv -> {
+                    MappedFieldType res = mapperService.fieldType(inv.getArguments()[0].toString());
+                    if (res == null) {
+                        DerivedFieldResolver derivedFieldResolver = DerivedFieldResolverFactory.createResolver(
+                            queryShardContext,
+                            null,
+                            null,
+                            true
+                        );
+                        res = derivedFieldResolver.resolve(inv.getArguments()[0].toString());
+                    }
+                    return res;
+                });
+                IndexSearcher searcher = new IndexSearcher(reader);
+
+                // NOTE: object_field.keyword_field will be resolved to a text field for nested field as that's the default behaviour in
+                // dynamic mappings too
+                TermQueryBuilder termQueryBuilder = new TermQueryBuilder("object_field.keyword_field", "GET");
+                termQueryBuilder.caseInsensitive(true);
+                Query query = termQueryBuilder.toQuery(queryShardContext);
+                TopDocs topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                // test object_field_2
+                docsEvaluated[0] = 0;
+                termQueryBuilder = new TermQueryBuilder("object_field_2.keyword_field", "GET");
+                termQueryBuilder.caseInsensitive(true);
+                query = termQueryBuilder.toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                // since we have prefilter_field set to "raw_message", it should not evaluate all documents
+                assertEquals(8, docsEvaluated[0]);
+
+                termQueryBuilder = new TermQueryBuilder("invalid_object.keyword_field", "GET");
+                termQueryBuilder.caseInsensitive(true);
+                TermQueryBuilder finalTermQueryBuilder = termQueryBuilder;
+                assertThrows(MapperException.class, () -> finalTermQueryBuilder.toQuery(queryShardContext));
+
+                termQueryBuilder = new TermQueryBuilder("long_prefilter_field_object.keyword_field", "GET");
+                termQueryBuilder.caseInsensitive(true);
+                TermQueryBuilder finalTermQueryBuilder2 = termQueryBuilder;
+                assertThrows(MapperException.class, () -> finalTermQueryBuilder2.toQuery(queryShardContext));
+
+                // when nested field is of numeric type or date, the range queries should still work irrespective of invalid
+                // prefilter_field
+                query = QueryBuilders.rangeQuery("invalid_object.date_field").from("2024-03-20T14:20:50").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(4, topDocs.totalHits.value);
+
+                query = QueryBuilders.rangeQuery("long_prefilter_field_object.date_field")
+                    .from("2024-03-20T14:20:50")
+                    .toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(4, topDocs.totalHits.value);
+
+                // test regular_derived_field
+                docsEvaluated[0] = 0;
+                scriptIndex[0] = 4;
+                query = QueryBuilders.termQuery("regular_derived_field", "delete").caseInsensitive(true).toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+                assertEquals(2, docsEvaluated[0]);
+
+                // test regular_derived_field_without_prefilter_field
+                docsEvaluated[0] = 0;
+                scriptIndex[0] = 4;
+                query = QueryBuilders.termQuery("regular_derived_field_without_prefilter_field", "delete")
+                    .caseInsensitive(true)
+                    .toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(2, topDocs.totalHits.value);
+                assertEquals(11, docsEvaluated[0]);
+            }
+        }
+    }
+
+    public void testObjectDerivedFieldsWithIgnoreMalformed() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("raw_message");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+                b.startObject("long_field");
+                {
+                    b.field("type", "long");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("object_field");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.field("ignore_malformed", true);
+                }
+                b.endObject();
+                b.startObject("object_field_2");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.startObject("properties");
+                    {
+                        b.field("keyword_field", "date");
+                    }
+                    b.endObject();
+                    b.field("prefilter_field", "raw_message");
+                    b.field("ignore_malformed", true);
+                }
+                b.endObject();
+                b.startObject("object_field_3");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.startObject("properties");
+                    {
+                        b.field("keyword_field", "date");
+                    }
+                    b.endObject();
+                    b.field("prefilter_field", "raw_message");
+                    b.field("ignore_malformed", false);
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+
+        List<Document> docs = new ArrayList<>();
+        for (Object[] request : raw_requests) {
+            Document document = new Document();
+            document.add(new TextField("raw_message", (String) request[0], Field.Store.YES));
+            docs.add(document);
+        }
+
+        int[] scriptIndex = { 8 };
+        int[] docsEvaluated = { 0 };
+
+        // Mock DerivedFieldScript.Factory
+        DerivedFieldScript.Factory factory = (params, lookup) -> (DerivedFieldScript.LeafFactory) ctx -> new DerivedFieldScript(
+            params,
+            lookup,
+            ctx
+        ) {
+            int docId = 0;
+
+            @Override
+            public void setDocument(int docId) {
+                docsEvaluated[0]++;
+                super.setDocument(docId);
+                this.docId = docId;
+            }
+
+            @Override
+            public void execute() {
+                addEmittedValue(raw_requests[docId][scriptIndex[0]]);
+            }
+        };
+
+        // Index and Search
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            for (Document d : docs) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+                when(queryShardContext.compile(Mockito.any(), Mockito.any())).thenReturn(factory);
+                when(queryShardContext.sourcePath("raw_message")).thenReturn(Set.of("raw_message"));
+                when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+                when(queryShardContext.getIndexReader()).thenReturn(reader);
+                when(queryShardContext.fieldMapper(anyString())).thenAnswer(inv -> {
+                    MappedFieldType res = mapperService.fieldType(inv.getArguments()[0].toString());
+                    if (res == null) {
+                        DerivedFieldResolver derivedFieldResolver = DerivedFieldResolverFactory.createResolver(
+                            queryShardContext,
+                            null,
+                            null,
+                            true
+                        );
+                        res = derivedFieldResolver.resolve(inv.getArguments()[0].toString());
+                    }
+                    return res;
+                });
+                IndexSearcher searcher = new IndexSearcher(reader);
+
+                // NOTE: object_field.keyword_field will be resolved to a text field for nested field as that's the default behaviour in
+                // dynamic mappings too
+                TermQueryBuilder termQueryBuilder = new TermQueryBuilder("object_field.keyword_field", "GET");
+                termQueryBuilder.caseInsensitive(true);
+                Query query = termQueryBuilder.toQuery(queryShardContext);
+                TopDocs topDocs = searcher.search(query, 10);
+                assertEquals(7, topDocs.totalHits.value);
+
+                // check if ignoreMalformed is set to false, the query fails on malformed values
+                query = QueryBuilders.rangeQuery("object_field_3.keyword_field").from("2024-03-20T14:20:50").toQuery(queryShardContext);
+                Query finalQuery = query;
+                assertThrows(IllegalArgumentException.class, () -> searcher.search(finalQuery, 10));
+
+                // check if ignoreMalformed is set to true, the query passes with 0 results
+                query = QueryBuilders.rangeQuery("object_field_2.keyword_field").from("2024-03-20T14:20:50").toQuery(queryShardContext);
+                topDocs = searcher.search(query, 10);
+                assertEquals(0, topDocs.totalHits.value);
+            }
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldResolverTests.java b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldResolverTests.java
new file mode 100644
index 0000000000000..b2a7cfc4359da
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldResolverTests.java
@@ -0,0 +1,537 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.document.Document;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.store.Directory;
+import org.opensearch.OpenSearchException;
+import org.opensearch.common.lucene.Lucene;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.Script;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class DerivedFieldResolverTests extends MapperServiceTestCase {
+    public void testResolutionFromIndexMapping() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("indexed_field");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("derived_text");
+                {
+                    b.field("type", "keyword");
+                    b.field("script", "");
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        DefaultDerivedFieldResolver resolver = (DefaultDerivedFieldResolver) DerivedFieldResolverFactory.createResolver(
+            queryShardContext,
+            null,
+            null,
+            true
+        );
+        assertEquals("keyword", resolver.resolve("derived_text").getType());
+        assertEqualDerivedField(new DerivedField("derived_text", "keyword", new Script("")), resolver.resolve("derived_text").derivedField);
+    }
+
+    public void testResolutionFromSearchRequest() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        DefaultDerivedFieldResolver resolver = (DefaultDerivedFieldResolver) DerivedFieldResolverFactory.createResolver(
+            queryShardContext,
+            createDerivedFieldsObject(),
+            createDerivedFields(),
+            true
+        );
+        assertEquals("text", resolver.resolve("derived_text").getType());
+        assertEqualDerivedField(new DerivedField("derived_text", "text", new Script("")), resolver.resolve("derived_text").derivedField);
+        assertEquals("object", resolver.resolve("derived_object").getType());
+        assertEqualDerivedField(
+            new DerivedField("derived_object", "object", new Script("")),
+            resolver.resolve("derived_object").derivedField
+        );
+        assertEquals("keyword", resolver.resolve("derived_keyword").getType());
+        assertEqualDerivedField(
+            new DerivedField("derived_keyword", "keyword", new Script("")),
+            resolver.resolve("derived_keyword").derivedField
+        );
+    }
+
+    public void testEmpty() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        DefaultDerivedFieldResolver resolver = (DefaultDerivedFieldResolver) DerivedFieldResolverFactory.createResolver(
+            queryShardContext,
+            null,
+            null,
+            true
+        );
+        assertNull(resolver.resolve("derived_keyword"));
+    }
+
+    public void testResolutionPrecedence() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("indexed_field");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("derived_text");
+                {
+                    b.field("type", "keyword");
+                    b.field("script", "");
+                }
+                b.endObject();
+                b.startObject("derived_2");
+                {
+                    b.field("type", "keyword");
+                    b.field("script", "");
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        DefaultDerivedFieldResolver resolver = (DefaultDerivedFieldResolver) DerivedFieldResolverFactory.createResolver(
+            queryShardContext,
+            createDerivedFieldsObject(),
+            createDerivedFields(),
+            true
+        );
+
+        // precedence given to search definition; derived_text is present in both -
+        // search definition uses type text, whereas index definition uses the type keyword
+
+        assertEquals("text", resolver.resolve("derived_text").getType());
+        assertEqualDerivedField(new DerivedField("derived_text", "text", new Script("")), resolver.resolve("derived_text").derivedField);
+
+        assertEquals("keyword", resolver.resolve("derived_2").getType());
+        assertEqualDerivedField(new DerivedField("derived_2", "keyword", new Script("")), resolver.resolve("derived_2").derivedField);
+    }
+
+    public void testNestedWithParentDefinedInIndexMapping() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("indexed_field");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("derived_obj");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                }
+                b.endObject();
+                b.startObject("derived_obj_2");
+                {
+                    b.field("type", "object");
+                    b.field("script", "");
+                    b.field("format", "yyyy-MM-dd");
+
+                    b.startObject("properties");
+                    {
+                        b.field("sub_field1", "long");
+                        b.field("sub_field2", "date");
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            Document d = new Document();
+            for (int i = 0; i < 10; i++) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                TestDerivedFieldResolver resolver = new TestDerivedFieldResolver(queryShardContext, null, null, typeInference);
+                assertEquals("text", resolver.resolve("derived_obj.sub_field1").getType());
+                assertEqualDerivedField(
+                    new DerivedField("derived_obj.sub_field1", "text", new Script("")),
+                    resolver.resolve("derived_obj.sub_field1").derivedField
+                );
+                assertEquals("text", resolver.resolve("derived_obj.sub_field1.sub_field2").getType());
+                assertEqualDerivedField(
+                    new DerivedField("derived_obj.sub_field1.sub_field2", "text", new Script("")),
+                    resolver.resolve("derived_obj.sub_field1.sub_field2").derivedField
+                );
+                // when explicit type is set in properties
+                DerivedField expectedDerivedField1 = new DerivedField("derived_obj_2.sub_field1", "long", new Script(""));
+                expectedDerivedField1.setProperties(Map.of("sub_field1", "long", "sub_field2", "date"));
+                expectedDerivedField1.setFormat("yyyy-MM-dd");
+                assertEqualDerivedField(expectedDerivedField1, resolver.resolve("derived_obj_2.sub_field1").derivedField);
+                DerivedField expectedDerivedField2 = new DerivedField("derived_obj_2.sub_field2", "date", new Script(""));
+                expectedDerivedField2.setProperties(Map.of("sub_field1", "long", "sub_field2", "date"));
+                expectedDerivedField2.setFormat("yyyy-MM-dd");
+                assertEqualDerivedField(expectedDerivedField2, resolver.resolve("derived_obj_2.sub_field2").derivedField);
+            }
+        }
+    }
+
+    public void testNestedWithParentDefinedInSearchRequest() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            Document d = new Document();
+            for (int i = 0; i < 10; i++) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                TestDerivedFieldResolver resolver = new TestDerivedFieldResolver(
+                    queryShardContext,
+                    createDerivedFieldsObject(),
+                    createDerivedFields(),
+                    typeInference
+                );
+                assertEquals("text", resolver.resolve("derived_object.sub_field1").getType());
+                assertEqualDerivedField(
+                    new DerivedField("derived_object.sub_field1", "text", new Script("")),
+                    resolver.resolve("derived_object.sub_field1").derivedField
+                );
+                assertEquals("text", resolver.resolve("derived_object.sub_field1.sub_field2").getType());
+                assertEqualDerivedField(
+                    new DerivedField("derived_object.sub_field1.sub_field2", "text", new Script("")),
+                    resolver.resolve("derived_object.sub_field1.sub_field2").derivedField
+                );
+                assertEquals(2, resolver.cnt);
+
+            }
+        }
+    }
+
+    public void testNestedWithParentUndefined() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            Document d = new Document();
+            for (int i = 0; i < 10; i++) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                TestDerivedFieldResolver resolver = new TestDerivedFieldResolver(queryShardContext, null, null, typeInference);
+                assertNull(resolver.resolve("derived_object.sub_field1"));
+            }
+        }
+    }
+
+    public void testInferredTypeNull() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            Document d = new Document();
+            for (int i = 0; i < 10; i++) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                TestDerivedFieldResolver resolver = new TestDerivedFieldResolver(
+                    queryShardContext,
+                    createDerivedFieldsObject(),
+                    createDerivedFields(),
+                    typeInference,
+                    true
+                );
+                assertNull(resolver.resolve("derived_object.field"));
+            }
+        }
+    }
+
+    public void testInferThrowsIOException() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        FieldTypeInference typeInferenceMock = mock(FieldTypeInference.class);
+        when(typeInferenceMock.infer(any())).thenThrow(new IOException("Simulated IOException"));
+        TestDerivedFieldResolver resolver = new TestDerivedFieldResolver(
+            queryShardContext,
+            createDerivedFieldsObject(),
+            createDerivedFields(),
+            typeInferenceMock,
+            true
+        );
+        assertNull(resolver.resolve("derived_object.field"));
+    }
+
+    public void testRegularFieldTypesAreNotResolved() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("indexed_field");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+                b.startObject("indexed_field_2.sub_field");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("derived_text");
+                {
+                    b.field("type", "keyword");
+                    b.field("script", "");
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        DefaultDerivedFieldResolver resolver = (DefaultDerivedFieldResolver) DerivedFieldResolverFactory.createResolver(
+            queryShardContext,
+            null,
+            null,
+            true
+        );
+        assertNull(resolver.resolve("indexed_field"));
+        assertNull(resolver.resolve("indexed_field_2.sub_field"));
+    }
+
+    public void testResolutionCaching() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            Document d = new Document();
+            for (int i = 0; i < 10; i++) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                TestDerivedFieldResolver resolver = new TestDerivedFieldResolver(
+                    queryShardContext,
+                    createDerivedFieldsObject(),
+                    createDerivedFields(),
+                    typeInference
+                );
+                assertEquals("text", resolver.resolve("derived_object.sub_field1").getType());
+                assertEquals("text", resolver.resolve("derived_object.sub_field1").getType());
+                assertEquals(1, resolver.cnt);
+            }
+        }
+    }
+
+    public void testResolutionDisabled() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("indexed_field");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+                b.startObject("indexed_field_2.sub_field");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("derived_text");
+                {
+                    b.field("type", "keyword");
+                    b.field("script", "");
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        DerivedFieldResolver resolver = DerivedFieldResolverFactory.createResolver(queryShardContext, null, null, false);
+        assertTrue(resolver instanceof NoOpDerivedFieldResolver);
+        assertNull(resolver.resolve("derived_text"));
+        assertEquals(0, resolver.resolvePattern("*").size());
+        assertNull(resolver.resolve("indexed_field"));
+        assertNull(resolver.resolve("indexed_field_2.sub_field"));
+
+        assertThrows(
+            OpenSearchException.class,
+            () -> DerivedFieldResolverFactory.createResolver(queryShardContext, createDerivedFieldsObject(), createDerivedFields(), false)
+        );
+
+        when(queryShardContext.allowExpensiveQueries()).thenReturn(false);
+
+        assertThrows(
+            OpenSearchException.class,
+            () -> DerivedFieldResolverFactory.createResolver(queryShardContext, createDerivedFieldsObject(), createDerivedFields(), true)
+        );
+    }
+
+    public void testResolvePattern() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {
+            b.startObject("properties");
+            {
+                b.startObject("indexed_field");
+                {
+                    b.field("type", "text");
+                }
+                b.endObject();
+            }
+            b.endObject();
+            b.startObject("derived");
+            {
+                b.startObject("derived_text");
+                {
+                    b.field("type", "keyword");
+                    b.field("script", "");
+                }
+                b.endObject();
+                b.startObject("derived_2");
+                {
+                    b.field("type", "keyword");
+                    b.field("script", "");
+                }
+                b.endObject();
+            }
+            b.endObject();
+        }));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        DefaultDerivedFieldResolver resolver = (DefaultDerivedFieldResolver) DerivedFieldResolverFactory.createResolver(
+            queryShardContext,
+            createDerivedFieldsObject(),
+            createDerivedFields(),
+            true
+        );
+        assertEquals(4, resolver.resolvePattern("derived_*").size());
+        assertEquals(4, resolver.resolvePattern("*").size()); // should not include regular field indexed_field
+    }
+
+    private void assertEqualDerivedField(DerivedField expected, DerivedField actual) {
+        assertEquals(expected, actual);
+    }
+
+    private Map<String, Object> createDerivedFieldsObject() {
+        return new HashMap<>() {
+            {
+                put("derived_text", new HashMap<String, Object>() {
+                    {
+                        put("type", "text");
+                        put("script", "");
+                    }
+                });
+                put("derived_object", new HashMap<String, Object>() {
+                    {
+                        put("type", "object");
+                        put("script", "");
+                    }
+                });
+            }
+        };
+    }
+
+    private static class TestDerivedFieldResolver extends DefaultDerivedFieldResolver {
+        private final boolean error;
+        private int cnt;
+
+        public TestDerivedFieldResolver(
+            QueryShardContext queryShardContext,
+            Map<String, Object> derivedFieldsObject,
+            List<DerivedField> derivedFields,
+            FieldTypeInference typeInference
+        ) {
+            this(queryShardContext, derivedFieldsObject, derivedFields, typeInference, false);
+        }
+
+        public TestDerivedFieldResolver(
+            QueryShardContext queryShardContext,
+            Map<String, Object> derivedFieldsObject,
+            List<DerivedField> derivedFields,
+            FieldTypeInference typeInference,
+            boolean error
+        ) {
+            super(queryShardContext, derivedFieldsObject, derivedFields, typeInference);
+            this.error = error;
+            this.cnt = 0;
+        }
+
+        @Override
+        ValueFetcher getValueFetcher(String fieldName, Script script, boolean ignoreMalFormed) {
+            cnt++;
+            if (!error) {
+                return lookup -> List.of("text field content");
+            } else {
+                return lookup -> null;
+            }
+        }
+    }
+
+    private List<DerivedField> createDerivedFields() {
+        DerivedField derivedField = new DerivedField("derived_keyword", "keyword", new Script(""));
+        return Collections.singletonList(derivedField);
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldTypeTests.java
index 897848008fd5f..7da8c9eb1efa0 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldTypeTests.java
@@ -15,12 +15,31 @@
 import org.apache.lucene.document.LatLonPoint;
 import org.apache.lucene.document.LongField;
 import org.apache.lucene.document.LongPoint;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.memory.MemoryIndex;
+import org.apache.lucene.queries.spans.SpanMultiTermQueryWrapper;
+import org.apache.lucene.util.BytesRef;
+import org.opensearch.OpenSearchException;
 import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.network.InetAddresses;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.AggregationScript;
 import org.opensearch.script.Script;
+import org.opensearch.search.lookup.LeafSearchLookup;
+import org.opensearch.search.lookup.SearchLookup;
+import org.opensearch.search.lookup.SourceLookup;
 
+import java.io.IOException;
 import java.util.List;
 
+import static org.apache.lucene.index.IndexOptions.NONE;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 public class DerivedFieldTypeTests extends FieldTypeTestCase {
@@ -30,64 +49,142 @@ private DerivedFieldType createDerivedFieldType(String type) {
         when(context.path()).thenReturn(new ContentPath());
         return new DerivedFieldType(
             new DerivedField(type + " _derived_field", type, new Script("")),
-            DerivedFieldSupportedTypes.getFieldMapperFromType(type, type + "_derived_field", context),
-            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(type, type + "_derived_field")
+            DerivedFieldSupportedTypes.getFieldMapperFromType(type, type + "_derived_field", context, null),
+            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(type, type + "_derived_field"),
+            null
         );
     }
 
     public void testBooleanType() {
         DerivedFieldType dft = createDerivedFieldType("boolean");
-        assertTrue(dft.typeFieldMapper instanceof BooleanFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(true) instanceof Field);
-        assertTrue(dft.indexableFieldGenerator.apply(false) instanceof Field);
+        assertTrue(dft.getFieldMapper() instanceof BooleanFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(true) instanceof Field);
+        assertTrue(dft.getIndexableFieldGenerator().apply(false) instanceof Field);
+        assertEquals("derived", dft.typeName());
     }
 
     public void testDateType() {
         DerivedFieldType dft = createDerivedFieldType("date");
-        assertTrue(dft.typeFieldMapper instanceof DateFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(System.currentTimeMillis()) instanceof LongPoint);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply("blah"));
+        assertTrue(dft.getFieldMapper() instanceof DateFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(System.currentTimeMillis()) instanceof LongPoint);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply("blah"));
     }
 
     public void testGeoPointType() {
         DerivedFieldType dft = createDerivedFieldType("geo_point");
-        assertTrue(dft.typeFieldMapper instanceof GeoPointFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(new Tuple<>(10.0, 20.0)) instanceof LatLonPoint);
-        expectThrows(ClassCastException.class, () -> dft.indexableFieldGenerator.apply(List.of(10.0)));
-        expectThrows(ClassCastException.class, () -> dft.indexableFieldGenerator.apply(List.of()));
-        expectThrows(ClassCastException.class, () -> dft.indexableFieldGenerator.apply(List.of("10")));
-        expectThrows(ClassCastException.class, () -> dft.indexableFieldGenerator.apply(List.of(10.0, 20.0, 30.0)));
+        assertTrue(dft.getFieldMapper() instanceof GeoPointFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(new Tuple<>(10.0, 20.0)) instanceof LatLonPoint);
+        expectThrows(ClassCastException.class, () -> dft.getIndexableFieldGenerator().apply(List.of(10.0)));
+        expectThrows(ClassCastException.class, () -> dft.getIndexableFieldGenerator().apply(List.of()));
+        expectThrows(ClassCastException.class, () -> dft.getIndexableFieldGenerator().apply(List.of("10")));
+        expectThrows(ClassCastException.class, () -> dft.getIndexableFieldGenerator().apply(List.of(10.0, 20.0, 30.0)));
     }
 
     public void testIPType() {
         DerivedFieldType dft = createDerivedFieldType("ip");
-        assertTrue(dft.typeFieldMapper instanceof IpFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply("127.0.0.1") instanceof InetAddressPoint);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply("blah"));
+        assertTrue(dft.getFieldMapper() instanceof IpFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply("127.0.0.1") instanceof InetAddressPoint);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply("blah"));
     }
 
     public void testKeywordType() {
         DerivedFieldType dft = createDerivedFieldType("keyword");
-        assertTrue(dft.typeFieldMapper instanceof KeywordFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply("test_keyword") instanceof KeywordField);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply(10));
+        assertTrue(dft.getFieldMapper() instanceof KeywordFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply("test_keyword") instanceof KeywordField);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply(10));
     }
 
     public void testLongType() {
         DerivedFieldType dft = createDerivedFieldType("long");
-        assertTrue(dft.typeFieldMapper instanceof NumberFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(10) instanceof LongField);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply(10.0));
+        assertTrue(dft.getFieldMapper() instanceof NumberFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(10) instanceof LongField);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply(10.0));
     }
 
     public void testDoubleType() {
         DerivedFieldType dft = createDerivedFieldType("double");
-        assertTrue(dft.typeFieldMapper instanceof NumberFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(10.0) instanceof DoubleField);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply(""));
+        assertTrue(dft.getFieldMapper() instanceof NumberFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(10.0) instanceof DoubleField);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply(""));
+    }
+
+    public void testObjectType() {
+        DerivedFieldType dft = createDerivedFieldType("object");
+        assertTrue(dft.getFieldMapper() instanceof KeywordFieldMapper);
+        assertEquals(dft.getFieldMapper().fieldType.indexOptions(), NONE);
+        assertThrows(OpenSearchException.class, () -> dft.getIndexableFieldGenerator().apply(""));
     }
 
     public void testUnsupportedType() {
         expectThrows(IllegalArgumentException.class, () -> createDerivedFieldType("match_only_text"));
     }
+
+    public void testGetAggregationScript_keyword() throws IOException {
+        DerivedFieldType dft = spy(createDerivedFieldType("keyword"));
+        assertTrue(dft.isAggregatable());
+        QueryShardContext mockContext = mock(QueryShardContext.class);
+        List<Object> expected = List.of("foo");
+        mockValueFetcherForAggs(mockContext, dft, expected);
+
+        AggregationScript.LeafFactory aggregationScript = dft.getAggregationScript(mockContext);
+        // have to use a memoryIndex because we can't mock leafReaderContext
+        MemoryIndex index = new MemoryIndex();
+        LeafReaderContext leafReaderContext = index.createSearcher().getIndexReader().leaves().get(0);
+        AggregationScript script = aggregationScript.newInstance(leafReaderContext);
+
+        Object result = script.execute();
+        assertEquals(expected, result);
+    }
+
+    public void testGetAggregationScript_ip() throws IOException {
+        DerivedFieldType dft = spy(createDerivedFieldType("ip"));
+        assertTrue(dft.isAggregatable());
+        QueryShardContext mockContext = mock(QueryShardContext.class);
+        List<Object> expected = List.of("192.168.0.1");
+        LeafSearchLookup leafSearchLookup = mockValueFetcherForAggs(mockContext, dft, expected);
+        SourceLookup sourceLookup = mock(SourceLookup.class);
+        when(leafSearchLookup.source()).thenReturn(sourceLookup);
+        AggregationScript.LeafFactory aggregationScript = dft.getAggregationScript(mockContext);
+        assertFalse(aggregationScript.needs_score());
+        // have to use a memoryIndex because we can't mock leafReaderContext
+        MemoryIndex index = new MemoryIndex();
+        LeafReaderContext leafReaderContext = index.createSearcher().getIndexReader().leaves().get(0);
+        AggregationScript script = aggregationScript.newInstance(leafReaderContext);
+
+        // test setDocument
+        int docid = 1;
+        script.setDocument(docid);
+        verify(sourceLookup, times(1)).setSegmentAndDocument(any(), eq(docid));
+
+        // test execute
+        List<Object> result = (List<Object>) script.execute();
+        assertEquals(new BytesRef(InetAddressPoint.encode(InetAddresses.forString((String) expected.get(0)))), result.get(0));
+    }
+
+    public void testDerivedFieldValueFetcherDoesNotSupportCustomFormats() {
+        DerivedFieldType dft = createDerivedFieldType("boolean");
+        expectThrows(
+            IllegalArgumentException.class,
+            () -> dft.valueFetcher(mock(QueryShardContext.class), mock(SearchLookup.class), "yyyy-MM-dd")
+        );
+    }
+
+    public void testSpanPrefixQueryNotSupported() {
+        DerivedFieldType dft = createDerivedFieldType("boolean");
+        expectThrows(
+            IllegalArgumentException.class,
+            () -> dft.spanPrefixQuery("value", mock(SpanMultiTermQueryWrapper.SpanRewriteMethod.class), mock(QueryShardContext.class))
+        );
+    }
+
+    private static LeafSearchLookup mockValueFetcherForAggs(QueryShardContext mockContext, DerivedFieldType dft, List<Object> expected) {
+        SearchLookup searchLookup = mock(SearchLookup.class);
+        LeafSearchLookup leafLookup = mock(LeafSearchLookup.class);
+        when(searchLookup.getLeafSearchLookup(any())).thenReturn(leafLookup);
+        when(mockContext.lookup()).thenReturn(searchLookup);
+        DerivedFieldValueFetcher valueFetcher = mock(DerivedFieldValueFetcher.class);
+        when(valueFetcher.fetchValuesInternal(any())).thenReturn(expected);
+        doReturn(valueFetcher).when(dft).valueFetcher(any(), any(), any());
+        return leafLookup;
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/mapper/DocumentParserTests.java b/server/src/test/java/org/opensearch/index/mapper/DocumentParserTests.java
index ecab9da8c6b6c..c9763d634979b 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DocumentParserTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DocumentParserTests.java
@@ -878,6 +878,340 @@ public void testDynamicStrictDottedFieldNameLong() throws Exception {
         assertEquals("mapping set to strict, dynamic introduction of [foo] within [_doc] is not allowed", exception.getMessage());
     }
 
+    public void testDynamicStrictAllowTemplatesDottedFieldNameLong() throws Exception {
+        DocumentMapper documentMapper = createDocumentMapper(topMapping(b -> b.field("dynamic", "strict_allow_templates")));
+        StrictDynamicMappingException exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> documentMapper.parse(source(b -> b.field("foo.bar.baz", 0)))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [foo] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+
+        DocumentMapper documentMapperWithDynamicTemplates = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("path_match", "foo.bar.baz");
+                        b.startObject("mapping").field("type", "long").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        }));
+        exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> documentMapperWithDynamicTemplates.parse(source(b -> b.field("foo.bar.baz", 0)))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [foo] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("match", "foo");
+                        b.field("match_mapping_type", "object");
+                        b.startObject("mapping").field("type", "object").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            {
+                b.startObject();
+                {
+                    b.startObject("test1");
+                    {
+                        b.field("match", "bar");
+                        b.field("match_mapping_type", "object");
+                        b.startObject("mapping").field("type", "object").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            {
+                b.startObject();
+                {
+                    b.startObject("test2");
+                    {
+                        b.field("path_match", "foo.bar.baz");
+                        b.startObject("mapping").field("type", "long").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        }));
+
+        ParsedDocument doc = mapper.parse(source(b -> b.field("foo.bar.baz", 0)));
+        assertEquals(2, doc.rootDoc().getFields("foo.bar.baz").length);
+    }
+
+    public void testDynamicAllowTemplatesStrictLongArray() throws Exception {
+        DocumentMapper documentMapper = createDocumentMapper(topMapping(b -> b.field("dynamic", "strict_allow_templates")));
+        StrictDynamicMappingException exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> documentMapper.parse(source(b -> b.startArray("foo").value(0).value(1).endArray()))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [foo] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+
+        DocumentMapper documentMapperWithDynamicTemplates = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("match", "test");
+                        b.startObject("mapping").field("type", "long").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        }));
+        exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> documentMapperWithDynamicTemplates.parse(source(b -> b.startArray("foo").value(0).value(1).endArray()))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [foo] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("match", "foo");
+                        b.startObject("mapping").field("type", "long").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        }));
+
+        ParsedDocument doc = mapper.parse(source(b -> b.startArray("foo").value(0).value(1).endArray()));
+        assertEquals(4, doc.rootDoc().getFields("foo").length);
+    }
+
+    public void testDynamicStrictAllowTemplatesDottedFieldNameObject() throws Exception {
+        DocumentMapper documentMapper = createDocumentMapper(topMapping(b -> b.field("dynamic", "strict_allow_templates")));
+        StrictDynamicMappingException exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> documentMapper.parse(source(b -> b.startObject("foo.bar.baz").field("a", 0).endObject()))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [foo] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+
+        DocumentMapper documentMapperWithDynamicTemplates = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("match", "test");
+                        b.startObject("mapping").field("type", "long").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        }));
+        exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> documentMapperWithDynamicTemplates.parse(source(b -> b.startObject("foo.bar.baz").field("a", 0).endObject()))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [foo] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("match", "foo");
+                        b.field("match_mapping_type", "object");
+                        b.startObject("mapping").field("type", "object").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            {
+                b.startObject();
+                {
+                    b.startObject("test1");
+                    {
+                        b.field("match", "bar");
+                        b.field("match_mapping_type", "object");
+                        b.startObject("mapping").field("type", "object").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            {
+                b.startObject();
+                {
+                    b.startObject("test2");
+                    {
+                        b.field("match", "baz");
+                        b.field("match_mapping_type", "object");
+                        b.startObject("mapping").field("type", "object").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            {
+                b.startObject();
+                {
+                    b.startObject("test3");
+                    {
+                        b.field("path_match", "foo.bar.baz.a");
+                        b.startObject("mapping").field("type", "long").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        }));
+
+        ParsedDocument doc = mapper.parse(source(b -> b.startObject("foo.bar.baz").field("a", 0).endObject()));
+        assertEquals(2, doc.rootDoc().getFields("foo.bar.baz.a").length);
+    }
+
+    public void testDynamicStrictAllowTemplatesObject() throws Exception {
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("match", "test");
+                        b.field("match_mapping_type", "object");
+                        b.startObject("mapping").field("type", "object").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            {
+                b.startObject();
+                {
+                    b.startObject("test1");
+                    {
+                        b.field("match", "test1");
+                        b.startObject("mapping").field("type", "keyword").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        }
+
+        ));
+        StrictDynamicMappingException exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> mapper.parse(source(b -> b.startObject("foo").field("bar", "baz").endObject()))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [foo] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+
+        ParsedDocument doc = mapper.parse(source(b -> b.startObject("test").field("test1", "baz").endObject()));
+        assertEquals(2, doc.rootDoc().getFields("test.test1").length);
+    }
+
+    public void testDynamicStrictAllowTemplatesValue() throws Exception {
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> {
+            b.field("dynamic", "strict_allow_templates");
+            b.startArray("dynamic_templates");
+            {
+                b.startObject();
+                {
+                    b.startObject("test");
+                    {
+                        b.field("match", "test*");
+                        b.field("match_mapping_type", "string");
+                        b.startObject("mapping").field("type", "keyword").endObject();
+                    }
+                    b.endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        }
+
+        ));
+        StrictDynamicMappingException exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> mapper.parse(source(b -> b.field("bar", "baz")))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [bar] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+
+        ParsedDocument doc = mapper.parse(source(b -> b.field("test1", "baz")));
+        assertEquals(2, doc.rootDoc().getFields("test1").length);
+    }
+
+    public void testDynamicStrictAllowTemplatesNull() throws Exception {
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> b.field("dynamic", "strict_allow_templates")));
+        StrictDynamicMappingException exception = expectThrows(
+            StrictDynamicMappingException.class,
+            () -> mapper.parse(source(b -> b.nullField("bar")))
+        );
+        assertEquals(
+            "mapping set to strict_allow_templates, dynamic introduction of [bar] within [_doc] is not allowed",
+            exception.getMessage()
+        );
+    }
+
     public void testDynamicDottedFieldNameObject() throws Exception {
         DocumentMapper mapper = createDocumentMapper(mapping(b -> {}));
         ParsedDocument doc = mapper.parse(source(b -> b.startObject("foo.bar.baz").field("a", 0).endObject()));
@@ -1366,6 +1700,38 @@ public void testDynamicFieldsStartingAndEndingWithDot() throws Exception {
         );
     }
 
+    public void testDynamicFieldsWithOnlyDot() throws Exception {
+        DocumentMapper mapper = createDocumentMapper(mapping(b -> {}));
+
+        MapperParsingException e = expectThrows(MapperParsingException.class, () -> mapper.parse(source(b -> {
+            b.startArray("top");
+            {
+                b.startObject();
+                {
+                    b.startObject("inner").field(".", 2).endObject();
+                }
+                b.endObject();
+            }
+            b.endArray();
+        })));
+
+        assertThat(e.getCause(), notNullValue());
+        assertThat(e.getCause().getMessage(), containsString("field name cannot contain only the character [.]"));
+
+        e = expectThrows(
+            MapperParsingException.class,
+            () -> mapper.parse(source(b -> { b.startObject("..").field("foo", 2).endObject(); }))
+        );
+
+        assertThat(e.getCause(), notNullValue());
+        assertThat(e.getCause().getMessage(), containsString("field name cannot contain only the character [.]"));
+
+        e = expectThrows(MapperParsingException.class, () -> mapper.parse(source(b -> b.field(".", "1234"))));
+
+        assertThat(e.getCause(), notNullValue());
+        assertThat(e.getCause().getMessage(), containsString("field name cannot contain only the character [.]"));
+    }
+
     public void testDynamicFieldsEmptyName() throws Exception {
 
         DocumentMapper mapper = createDocumentMapper(mapping(b -> {}));
diff --git a/server/src/test/java/org/opensearch/index/mapper/FieldTypeInferenceTests.java b/server/src/test/java/org/opensearch/index/mapper/FieldTypeInferenceTests.java
new file mode 100644
index 0000000000000..807d0e96ce5e3
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/FieldTypeInferenceTests.java
@@ -0,0 +1,210 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.document.Document;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.store.Directory;
+import org.opensearch.common.lucene.Lucene;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.search.lookup.SourceLookup;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.Mockito.when;
+
+public class FieldTypeInferenceTests extends MapperServiceTestCase {
+
+    private static final Map<String, List<Object>> documentMap;
+    static {
+        List<Object> listWithNull = new ArrayList<>();
+        listWithNull.add(null);
+        documentMap = new HashMap<>();
+        documentMap.put("text_field", List.of("The quick brown fox jumps over the lazy dog."));
+        documentMap.put("int_field", List.of(789));
+        documentMap.put("float_field", List.of(123.45));
+        documentMap.put("date_field_1", List.of("2024-05-12T15:45:00Z"));
+        documentMap.put("date_field_2", List.of("2024-05-12"));
+        documentMap.put("boolean_field", List.of(true));
+        documentMap.put("null_field", listWithNull);
+        documentMap.put("array_field_int", List.of(100, 200, 300, 400, 500));
+        documentMap.put("array_field_text", List.of("100", "200"));
+        documentMap.put("object_type", List.of(Map.of("foo", Map.of("bar", 10))));
+    }
+
+    public void testJsonSupportedTypes() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        int totalDocs = 10000;
+        int docsPerLeafCount = 1000;
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            Document d = new Document();
+            for (int i = 0; i < totalDocs; i++) {
+                iw.addDocument(d);
+                if ((i + 1) % docsPerLeafCount == 0) {
+                    iw.commit();
+                }
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                String[] fieldName = { "text_field" };
+                Mapper mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("text", mapper.typeName());
+
+                fieldName[0] = "int_field";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("long", mapper.typeName());
+
+                fieldName[0] = "float_field";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("float", mapper.typeName());
+
+                fieldName[0] = "date_field_1";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("date", mapper.typeName());
+
+                fieldName[0] = "date_field_2";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("date", mapper.typeName());
+
+                fieldName[0] = "boolean_field";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("boolean", mapper.typeName());
+
+                fieldName[0] = "array_field_int";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("long", mapper.typeName());
+
+                fieldName[0] = "array_field_text";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("text", mapper.typeName());
+
+                fieldName[0] = "object_type";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertEquals("object", mapper.typeName());
+
+                fieldName[0] = "null_field";
+                mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertNull(mapper);
+
+                // If field is missing ensure that sample docIDs generated for inference are ordered and are in bounds
+                fieldName[0] = "missing_field";
+                List<List<Integer>> docsEvaluated = new ArrayList<>();
+                int[] totalDocsEvaluated = { 0 };
+                typeInference.setSampleSize(50);
+                mapper = typeInference.infer(new ValueFetcher() {
+                    @Override
+                    public List<Object> fetchValues(SourceLookup lookup) throws IOException {
+                        docsEvaluated.get(docsEvaluated.size() - 1).add(lookup.docId());
+                        totalDocsEvaluated[0]++;
+                        return documentMap.get(fieldName[0]);
+                    }
+
+                    @Override
+                    public void setNextReader(LeafReaderContext leafReaderContext) {
+                        docsEvaluated.add(new ArrayList<>());
+                    }
+                });
+                assertNull(mapper);
+                assertEquals(typeInference.getSampleSize(), totalDocsEvaluated[0]);
+                for (List<Integer> docsPerLeaf : docsEvaluated) {
+                    for (int j = 0; j < docsPerLeaf.size() - 1; j++) {
+                        assertTrue(docsPerLeaf.get(j) < docsPerLeaf.get(j + 1));
+                    }
+                    if (!docsPerLeaf.isEmpty()) {
+                        assertTrue(docsPerLeaf.get(0) >= 0 && docsPerLeaf.get(docsPerLeaf.size() - 1) < docsPerLeafCount);
+                    }
+                }
+            }
+        }
+    }
+
+    public void testDeleteAllDocs() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        int totalDocs = 10000;
+        int docsPerLeafCount = 1000;
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            Document d = new Document();
+            for (int i = 0; i < totalDocs; i++) {
+                iw.addDocument(d);
+                if ((i + 1) % docsPerLeafCount == 0) {
+                    iw.commit();
+                }
+            }
+            iw.deleteAll();
+            iw.commit();
+
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                String[] fieldName = { "text_field" };
+                Mapper mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertNull(mapper);
+            }
+        }
+    }
+
+    public void testZeroDoc() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                String[] fieldName = { "text_field" };
+                Mapper mapper = typeInference.infer(lookup -> documentMap.get(fieldName[0]));
+                assertNull(mapper);
+            }
+        }
+    }
+
+    public void testSampleGeneration() throws IOException {
+        MapperService mapperService = createMapperService(topMapping(b -> {}));
+        QueryShardContext queryShardContext = createQueryShardContext(mapperService);
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        int totalDocs = 10000;
+        int docsPerLeafCount = 1000;
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            Document d = new Document();
+            for (int i = 0; i < totalDocs; i++) {
+                iw.addDocument(d);
+                if ((i + 1) % docsPerLeafCount == 0) {
+                    iw.commit();
+                }
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                FieldTypeInference typeInference = new FieldTypeInference("test_index", queryShardContext.getMapperService(), reader);
+                typeInference.setSampleSize(1000 - 1);
+                typeInference.infer(lookup -> documentMap.get("unknown_field"));
+                assertThrows(IllegalArgumentException.class, () -> typeInference.setSampleSize(1000 + 1));
+                typeInference.setSampleSize(1000);
+                typeInference.infer(lookup -> documentMap.get("unknown_field"));
+            }
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/FlatObjectFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/FlatObjectFieldMapperTests.java
index 637072c8886c1..94d1f501bee51 100644
--- a/server/src/test/java/org/opensearch/index/mapper/FlatObjectFieldMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/FlatObjectFieldMapperTests.java
@@ -25,7 +25,6 @@
 
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.core.IsEqual.equalTo;
-import static org.hamcrest.core.StringContains.containsString;
 
 public class FlatObjectFieldMapperTests extends MapperTestCase {
     private static final String FIELD_TYPE = "flat_object";
@@ -133,9 +132,258 @@ public void testDefaults() throws Exception {
 
     public void testNullValue() throws IOException {
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
-        MapperParsingException e = expectThrows(MapperParsingException.class, () -> mapper.parse(source(b -> b.nullField("field"))));
-        assertThat(e.getMessage(), containsString("object mapping for [_doc] tried to parse field [field] as object"));
+        ParsedDocument parsedDocument = mapper.parse(source(b -> b.nullField("field")));
+        assertEquals(1, parsedDocument.docs().size());
+        IndexableField[] fields = parsedDocument.rootDoc().getFields("field");
+        assertEquals(0, fields.length);
+        ParsedDocument doc;
+        String json;
+        IndexableField[] fieldValues;
+        IndexableField[] fieldValueAndPaths;
 
+        {
+            // test1: {"field":null}
+            doc = mapper.parse(source(b -> b.nullField("field")));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_SUFFIX));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX));
+
+            // test2: {"field":{"age":3, "name": null}}
+            json = "{\"field\":{\"age\":3, \"name\": null}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(2, fields.length);
+            assertEquals(new BytesRef("field.age"), fields[0].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(2, fieldValues.length);
+            assertEquals(new BytesRef("3"), fieldValues[0].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(2, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.age=3"), fieldValueAndPaths[0].binaryValue());
+
+            // test3: {"field":{"name":null, "age":"5", "name1":null}}
+            json = "{\"field\":{\"name\":null, \"age\":\"5\", \"name1\":null}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(2, fields.length);
+            assertEquals(new BytesRef("field.age"), fields[0].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(2, fieldValues.length);
+            assertEquals(new BytesRef("5"), fieldValues[0].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(2, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.age=5"), fieldValueAndPaths[0].binaryValue());
+
+            // test4: {"field":{"name": {"name1": {"name2":null}}}}
+            json = "{\"field\":{\"name\": {\"name1\": {\"name2\":null}}}}";
+            doc = mapper.parse(source(json));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_SUFFIX));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX));
+
+        }
+
+        {
+            // test5: {"field":[null]}
+            doc = mapper.parse(source(b -> b.array("field", (String[]) null)));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_SUFFIX));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX));
+
+            // test6: {"field":{"labels": [null]}}
+            json = "{\"field\":{\"labels\": [null]}}";
+            doc = mapper.parse(source(json));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_SUFFIX));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX));
+
+            // test7: {"field":{"r1": {"labels": [null]}}}
+            json = "{\"field\":{\"r1\": {\"labels\": [null]}}}";
+            doc = mapper.parse(source(json));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_SUFFIX));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX));
+
+            // test8: {"field":{"r1": {"name": null,"labels": [null]}}}
+            json = "{\"field\":{\"r1\": {\"name\": null,\"labels\": [null]}}}";
+            doc = mapper.parse(source(json));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_SUFFIX));
+            assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX));
+
+            // test9: {"field":{"name": [null,3],"age":4}}
+            json = "{\"field\":{\"name\": [null,3],\"age\":4}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(4, fields.length);
+            assertEquals(new BytesRef("field.name"), fields[0].binaryValue());
+            assertEquals(new BytesRef("field.age"), fields[2].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(4, fieldValues.length);
+            assertEquals(new BytesRef("3"), fieldValues[0].binaryValue());
+            assertEquals(new BytesRef("4"), fieldValues[2].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(4, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.age=4"), fieldValueAndPaths[0].binaryValue());
+            assertEquals(new BytesRef("field.name=3"), fieldValueAndPaths[2].binaryValue());
+
+            // test10: {"field":{"age": 4,"name": [null,"3"]}}
+            json = "{\"field\":{\"age\": 4,\"name\": [null,\"3\"]}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(4, fields.length);
+            assertEquals(new BytesRef("field.name"), fields[0].binaryValue());
+            assertEquals(new BytesRef("field.age"), fields[2].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(4, fieldValues.length);
+            assertEquals(new BytesRef("3"), fieldValues[0].binaryValue());
+            assertEquals(new BytesRef("4"), fieldValues[2].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(4, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.age=4"), fieldValueAndPaths[0].binaryValue());
+            assertEquals(new BytesRef("field.name=3"), fieldValueAndPaths[2].binaryValue());
+
+            // test11: {"field":{"age":"4","labels": [null]}}
+            json = "{\"field\":{\"age\":\"4\",\"labels\": [null]}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(2, fields.length);
+            assertEquals(new BytesRef("field.age"), fields[0].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(2, fieldValues.length);
+            assertEquals(new BytesRef("4"), fieldValues[0].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(2, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.age=4"), fieldValueAndPaths[0].binaryValue());
+
+            // test12: {"field":{"labels": [null], "age":"4"}}
+            json = "{\"field\":{\"labels\": [null], \"age\":\"4\"}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(2, fields.length);
+            assertEquals(new BytesRef("field.age"), fields[0].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(2, fieldValues.length);
+            assertEquals(new BytesRef("4"), fieldValues[0].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(2, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.age=4"), fieldValueAndPaths[0].binaryValue());
+
+            // test13: {"field":{"name": [null, {"d":{"name":"dsds"}}]}}
+            json = "{\"field\":{\"name\": [null, {\"d\":{\"name\":\"dsds\"}}]}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(4, fields.length);
+            assertEquals(new BytesRef("field.d"), fields[0].binaryValue());
+            assertEquals(new BytesRef("field.name"), fields[2].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(2, fieldValues.length);
+            assertEquals(new BytesRef("dsds"), fieldValues[0].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(2, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.name.d.name=dsds"), fieldValueAndPaths[0].binaryValue());
+
+            // test14: {"field":{"name": [{"d":{"name":"dsds"}}, null]}}
+            json = "{\"field\":{\"name\": [{\"d\":{\"name\":\"dsds\"}}, null]}}";
+            doc = mapper.parse(source(json));
+            IndexableField[] fields1 = doc.rootDoc().getFields("field");
+            assertEquals(fields1.length, fields.length);
+            for (int i = 0; i < fields1.length; i++) {
+                assertEquals(fields[i].toString(), fields1[i].toString());
+            }
+            assertEquals(4, fields.length);
+            assertEquals(new BytesRef("field.d"), fields[0].binaryValue());
+            assertEquals(new BytesRef("field.name"), fields[2].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(2, fieldValues.length);
+            assertEquals(new BytesRef("dsds"), fieldValues[0].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(2, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.name.d.name=dsds"), fieldValueAndPaths[0].binaryValue());
+
+            // test15: {"field":{"name": [{"name":"age1"}, null, {"d":{"name":"dsds"}}]}}
+            json = "{\"field\":{\"name\": [{\"name\":\"age1\"}, null, {\"d\":{\"name\":\"dsds\"}}]}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(4, fields.length);
+            assertEquals(new BytesRef("field.d"), fields[0].binaryValue());
+            assertEquals(new BytesRef("field.name"), fields[2].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(4, fieldValues.length);
+            assertEquals(new BytesRef("dsds"), fieldValues[0].binaryValue());
+            assertEquals(new BytesRef("age1"), fieldValues[2].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(4, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.name.name=age1"), fieldValueAndPaths[0].binaryValue());
+            assertEquals(new BytesRef("field.name.d.name=dsds"), fieldValueAndPaths[2].binaryValue());
+
+            // test16: {"field":{"name": {"name1": [null,"dsdsdsd"]}}}
+            json = "{\"field\":{\"name\": {\"name1\": [null,\"dsdsdsd\"]}}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(4, fields.length);
+            assertEquals(new BytesRef("field.name"), fields[0].binaryValue());
+            assertEquals(new BytesRef("field.name1"), fields[2].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(2, fieldValues.length);
+            assertEquals(new BytesRef("dsdsdsd"), fieldValues[0].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(2, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.name.name1=dsdsdsd"), fieldValueAndPaths[0].binaryValue());
+
+            // test17: {"field":{"name": {"name1": [[],["dsdsdsd", null]]}}}
+            json = "{\"field\":{\"name\": {\"name1\": [[],[\"dsdsdsd\", null]]}}}";
+            doc = mapper.parse(source(json));
+            fields = doc.rootDoc().getFields("field");
+            assertEquals(4, fields.length);
+            assertEquals(new BytesRef("field.name"), fields[0].binaryValue());
+            assertEquals(new BytesRef("field.name1"), fields[2].binaryValue());
+            fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+            assertEquals(2, fieldValues.length);
+            assertEquals(new BytesRef("dsdsdsd"), fieldValues[0].binaryValue());
+            fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+            assertEquals(2, fieldValueAndPaths.length);
+            assertEquals(new BytesRef("field.name.name1=dsdsdsd"), fieldValueAndPaths[0].binaryValue());
+        }
+    }
+
+    public void testInfiniteLoopWithNullValue() throws IOException {
+        DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
+        // test2: {"field":{"name": null,"age":3}}
+        String json = "{\"field\":{\"name\": null,\"age\":3}}";
+        ParsedDocument doc = mapper.parse(source(json));
+        IndexableField[] fields = doc.rootDoc().getFields("field");
+        assertEquals(2, fields.length);
+        assertEquals(new BytesRef("field.age"), fields[0].binaryValue());
+        IndexableField[] fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+        assertEquals(2, fieldValues.length);
+        assertEquals(new BytesRef("3"), fieldValues[0].binaryValue());
+        IndexableField[] fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+        assertEquals(2, fieldValueAndPaths.length);
+        assertEquals(new BytesRef("field.age=3"), fieldValueAndPaths[0].binaryValue());
+    }
+
+    // test deduplicationValue of keyList, valueList, valueAndPathList
+    public void testDeduplicationValue() throws IOException {
+        DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
+
+        // test: {"field":{"age": 3,"labels": [null,"3"], "abc":{"abc":{"labels":"n"}}}}
+        String json = "{\"field\":{\"age\": 3,\"labels\": [null,\"3\"], \"abc\":{\"abc\":{\"labels\":\"n\"}}}}";
+        ParsedDocument doc = mapper.parse(source(json));
+        IndexableField[] fields = doc.rootDoc().getFields("field");
+        assertEquals(6, fields.length);
+        assertEquals(new BytesRef("field.abc"), fields[0].binaryValue());
+        assertEquals(new BytesRef("field.age"), fields[2].binaryValue());
+        assertEquals(new BytesRef("field.labels"), fields[4].binaryValue());
+        IndexableField[] fieldValues = doc.rootDoc().getFields("field" + VALUE_SUFFIX);
+        assertEquals(4, fieldValues.length);
+        assertEquals(new BytesRef("3"), fieldValues[0].binaryValue());
+        assertEquals(new BytesRef("n"), fieldValues[2].binaryValue());
+        IndexableField[] fieldValueAndPaths = doc.rootDoc().getFields("field" + VALUE_AND_PATH_SUFFIX);
+        assertEquals(6, fieldValueAndPaths.length);
+        assertEquals(new BytesRef("field.abc.abc.labels=n"), fieldValueAndPaths[0].binaryValue());
+        assertEquals(new BytesRef("field.age=3"), fieldValueAndPaths[2].binaryValue());
+        assertEquals(new BytesRef("field.labels=3"), fieldValueAndPaths[4].binaryValue());
     }
 
     @Override
diff --git a/server/src/test/java/org/opensearch/index/mapper/KeywordFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/KeywordFieldTypeTests.java
index 393c448330142..b10035f54a0c0 100644
--- a/server/src/test/java/org/opensearch/index/mapper/KeywordFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/KeywordFieldTypeTests.java
@@ -263,8 +263,11 @@ public void testRegexpQuery() {
     public void testFuzzyQuery() {
         MappedFieldType ft = new KeywordFieldType("field");
         assertEquals(
-            new FuzzyQuery(new Term("field", "foo"), 2, 1, 50, true),
-            ft.fuzzyQuery("foo", Fuzziness.fromEdits(2), 1, 50, true, MOCK_QSC)
+            new IndexOrDocValuesQuery(
+                new FuzzyQuery(new Term("field", "foo"), 2, 1, 50, true),
+                new FuzzyQuery(new Term("field", "foo"), 2, 1, 50, true, MultiTermQuery.DOC_VALUES_REWRITE)
+            ),
+            ft.fuzzyQuery("foo", Fuzziness.fromEdits(2), 1, 50, true, null, MOCK_QSC)
         );
 
         Query indexExpected = new FuzzyQuery(new Term("field", "foo"), 2, 1, 50, true);
diff --git a/server/src/test/java/org/opensearch/index/mapper/MapperServiceTests.java b/server/src/test/java/org/opensearch/index/mapper/MapperServiceTests.java
index 6ba7ded3e2cb1..986d5b8dcb3d4 100644
--- a/server/src/test/java/org/opensearch/index/mapper/MapperServiceTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/MapperServiceTests.java
@@ -52,6 +52,7 @@
 import org.opensearch.index.mapper.KeywordFieldMapper.KeywordFieldType;
 import org.opensearch.index.mapper.MapperService.MergeReason;
 import org.opensearch.index.mapper.NumberFieldMapper.NumberFieldType;
+import org.opensearch.indices.IndicesModule;
 import org.opensearch.indices.InvalidTypeNameException;
 import org.opensearch.indices.analysis.AnalysisModule.AnalysisProvider;
 import org.opensearch.plugins.AnalysisPlugin;
@@ -87,6 +88,11 @@ public void testTypeValidation() {
         MapperService.validateTypeName("_doc"); // no exception
     }
 
+    public void testGetMetadataFieldsReturnsExpectedSet() throws Throwable {
+        final MapperService mapperService = createIndex("test1").mapperService();
+        assertEquals(mapperService.getMetadataFields(), IndicesModule.getBuiltInMetadataFields());
+    }
+
     public void testPreflightUpdateDoesNotChangeMapping() throws Throwable {
         final MapperService mapperService = createIndex("test1").mapperService();
         final CompressedXContent mapping = createMappingSpecifyingNumberOfFields(1);
diff --git a/server/src/test/java/org/opensearch/index/mapper/NumberFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/NumberFieldTypeTests.java
index af852b12e7a30..b27ef49303205 100644
--- a/server/src/test/java/org/opensearch/index/mapper/NumberFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/NumberFieldTypeTests.java
@@ -62,6 +62,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.common.util.io.IOUtils;
+import org.opensearch.core.common.bytes.BytesArray;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.IndexSettings;
@@ -73,19 +74,24 @@
 import org.opensearch.index.mapper.NumberFieldMapper.NumberType;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.search.MultiValueMode;
+import org.opensearch.search.query.BitmapDocValuesQuery;
 import org.junit.Before;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Supplier;
 
+import org.roaringbitmap.RoaringBitmap;
+
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.either;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
 
@@ -673,9 +679,11 @@ public void doTestDocValueRangeQueries(NumberType type, Supplier<Number> valueSu
                 true,
                 MOCK_QSC
             );
-            assertThat(query, instanceOf(IndexOrDocValuesQuery.class));
-            IndexOrDocValuesQuery indexOrDvQuery = (IndexOrDocValuesQuery) query;
-            assertEquals(searcher.count(indexOrDvQuery.getIndexQuery()), searcher.count(indexOrDvQuery.getRandomAccessQuery()));
+            assertThat(query, either(instanceOf(IndexOrDocValuesQuery.class)).or(instanceOf(MatchNoDocsQuery.class)));
+            if (query instanceof IndexOrDocValuesQuery) {
+                IndexOrDocValuesQuery indexOrDvQuery = (IndexOrDocValuesQuery) query;
+                assertEquals(searcher.count(indexOrDvQuery.getIndexQuery()), searcher.count(indexOrDvQuery.getRandomAccessQuery()));
+            }
         }
         reader.close();
         dir.close();
@@ -944,4 +952,33 @@ public void testFetchSourceValue() throws IOException {
         assertEquals(Collections.singletonList(2.71f), fetchSourceValue(nullValueMapper, ""));
         assertEquals(Collections.singletonList(2.71f), fetchSourceValue(nullValueMapper, null));
     }
+
+    public void testBitmapQuery() throws IOException {
+        RoaringBitmap r = new RoaringBitmap();
+        byte[] array = new byte[r.serializedSizeInBytes()];
+        r.serialize(ByteBuffer.wrap(array));
+        BytesArray bitmap = new BytesArray(array);
+
+        NumberFieldType ft = new NumberFieldMapper.NumberFieldType("field", NumberType.INTEGER);
+        assertEquals(
+            new IndexOrDocValuesQuery(NumberType.bitmapIndexQuery("field", r), new BitmapDocValuesQuery("field", r)),
+            ft.bitmapQuery(bitmap)
+        );
+
+        ft = new NumberFieldType("field", NumberType.INTEGER, false, false, true, true, null, Collections.emptyMap());
+        assertEquals(new BitmapDocValuesQuery("field", r), ft.bitmapQuery(bitmap));
+
+        Directory dir = newDirectory();
+        IndexWriter w = new IndexWriter(dir, new IndexWriterConfig());
+        DirectoryReader reader = DirectoryReader.open(w);
+        assertEquals(new MatchNoDocsQuery(), ft.bitmapQuery(bitmap).rewrite(newSearcher(reader)));
+        reader.close();
+        w.close();
+        dir.close();
+
+        NumberType type = randomValueOtherThan(NumberType.INTEGER, () -> randomFrom(NumberType.values()));
+        ft = new NumberFieldMapper.NumberFieldType("field", type);
+        NumberFieldType finalFt = ft;
+        assertThrows(IllegalArgumentException.class, () -> finalFt.bitmapQuery(bitmap));
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
index b10a7d8155056..cb06bf23d9cbe 100644
--- a/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/ObjectMapperTests.java
@@ -33,9 +33,15 @@
 package org.opensearch.index.mapper;
 
 import org.opensearch.common.compress.CompressedXContent;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.common.unit.ByteSizeValue;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
 import org.opensearch.index.mapper.MapperService.MergeReason;
 import org.opensearch.index.mapper.ObjectMapper.Dynamic;
 import org.opensearch.plugins.Plugin;
@@ -46,6 +52,7 @@
 import java.io.IOException;
 import java.util.Collection;
 
+import static org.opensearch.common.util.FeatureFlags.STAR_TREE_INDEX;
 import static org.hamcrest.Matchers.containsString;
 
 public class ObjectMapperTests extends OpenSearchSingleNodeTestCase {
@@ -487,6 +494,80 @@ public void testDerivedFields() throws Exception {
         assertEquals("date", mapper.typeName());
     }
 
+    public void testCompositeFields() throws Exception {
+        String mapping = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("tweet")
+            .startObject("composite")
+            .startObject("startree")
+            .field("type", "star_tree")
+            .startObject("config")
+            .startArray("ordered_dimensions")
+            .startObject()
+            .field("name", "node")
+            .endObject()
+            .startObject()
+            .field("name", "status")
+            .endObject()
+            .endArray()
+            .startArray("metrics")
+            .startObject()
+            .field("name", "status")
+            .endObject()
+            .startObject()
+            .field("name", "metric_field")
+            .endObject()
+            .endArray()
+            .endObject()
+            .endObject()
+            .endObject()
+            .startObject("properties")
+            .startObject("node")
+            .field("type", "integer")
+            .endObject()
+            .startObject("status")
+            .field("type", "integer")
+            .endObject()
+            .startObject("metric_field")
+            .field("type", "integer")
+            .endObject()
+            .endObject()
+            .endObject()
+            .endObject()
+            .toString();
+
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> createIndex("invalid").mapperService().documentMapperParser().parse("tweet", new CompressedXContent(mapping))
+        );
+        assertEquals(
+            "star tree index is under an experimental feature and can be activated only by enabling opensearch.experimental.feature.composite_index.star_tree.enabled feature flag in the JVM options",
+            ex.getMessage()
+        );
+
+        final Settings starTreeEnabledSettings = Settings.builder().put(STAR_TREE_INDEX, "true").build();
+        FeatureFlags.initializeFeatureFlags(starTreeEnabledSettings);
+
+        Settings settings = Settings.builder()
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .put(IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(512, ByteSizeUnit.MB))
+            .build();
+        DocumentMapper documentMapper = createIndex("test", settings).mapperService()
+            .documentMapperParser()
+            .parse("tweet", new CompressedXContent(mapping));
+
+        Mapper mapper = documentMapper.root().getMapper("startree");
+        assertTrue(mapper instanceof StarTreeMapper);
+        StarTreeMapper starTreeMapper = (StarTreeMapper) mapper;
+        assertEquals("star_tree", starTreeMapper.fieldType().typeName());
+        // Check that field in properties was parsed correctly as well
+        mapper = documentMapper.root().getMapper("node");
+        assertNotNull(mapper);
+        assertEquals("integer", mapper.typeName());
+
+        FeatureFlags.initializeFeatureFlags(Settings.EMPTY);
+    }
+
     @Override
     protected Collection<Class<? extends Plugin>> getPlugins() {
         return pluginList(InternalSettingsPlugin.class);
diff --git a/server/src/test/java/org/opensearch/index/mapper/RangeFieldQueryStringQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/mapper/RangeFieldQueryStringQueryBuilderTests.java
index 9dea7e13ac45e..7a8ac829bdd97 100644
--- a/server/src/test/java/org/opensearch/index/mapper/RangeFieldQueryStringQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/RangeFieldQueryStringQueryBuilderTests.java
@@ -47,15 +47,21 @@
 import org.opensearch.common.compress.CompressedXContent;
 import org.opensearch.common.network.InetAddresses;
 import org.opensearch.common.time.DateMathParser;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.index.query.QueryStringQueryBuilder;
+import org.opensearch.search.approximate.ApproximateIndexOrDocValuesQuery;
+import org.opensearch.search.approximate.ApproximatePointRangeQuery;
 import org.opensearch.test.AbstractQueryTestCase;
 
 import java.io.IOException;
 import java.net.InetAddress;
 
+import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.Matchers.either;
 import static org.hamcrest.core.IsInstanceOf.instanceOf;
+import static org.apache.lucene.document.LongPoint.pack;
+import static org.junit.Assume.assumeThat;
 
 public class RangeFieldQueryStringQueryBuilderTests extends AbstractQueryTestCase<QueryStringQueryBuilder> {
 
@@ -173,18 +179,39 @@ public void testDateRangeQuery() throws Exception {
         DateFieldMapper.DateFieldType dateType = (DateFieldMapper.DateFieldType) context.fieldMapper(DATE_FIELD_NAME);
         parser = dateType.dateMathParser;
         Query queryOnDateField = new QueryStringQueryBuilder(DATE_FIELD_NAME + ":[2010-01-01 TO 2018-01-01]").toQuery(createShardContext());
-        Query controlQuery = LongPoint.newRangeQuery(
-            DATE_FIELD_NAME,
-            new long[] { parser.parse(lowerBoundExact, () -> 0).toEpochMilli() },
-            new long[] { parser.parse(upperBoundExact, () -> 0).toEpochMilli() }
-        );
 
         Query controlDv = SortedNumericDocValuesField.newSlowRangeQuery(
             DATE_FIELD_NAME,
             parser.parse(lowerBoundExact, () -> 0).toEpochMilli(),
             parser.parse(upperBoundExact, () -> 0).toEpochMilli()
         );
-        assertEquals(new IndexOrDocValuesQuery(controlQuery, controlDv), queryOnDateField);
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
+        assertEquals(
+            new ApproximateIndexOrDocValuesQuery(
+                LongPoint.newRangeQuery(
+                    DATE_FIELD_NAME,
+                    parser.parse(lowerBoundExact, () -> 0).toEpochMilli(),
+                    parser.parse(upperBoundExact, () -> 0).toEpochMilli()
+                ),
+                new ApproximatePointRangeQuery(
+                    DATE_FIELD_NAME,
+                    pack(new long[] { parser.parse(lowerBoundExact, () -> 0).toEpochMilli() }).bytes,
+                    pack(new long[] { parser.parse(upperBoundExact, () -> 0).toEpochMilli() }).bytes,
+                    new long[] { parser.parse(lowerBoundExact, () -> 0).toEpochMilli() }.length
+                ) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return Long.toString(LongPoint.decodeDimension(value, 0));
+                    }
+                },
+                controlDv
+            ),
+            queryOnDateField
+        );
     }
 
     public void testIPRangeQuery() throws Exception {
diff --git a/server/src/test/java/org/opensearch/index/mapper/RangeFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/RangeFieldTypeTests.java
index 49bf227e5073c..b157c43e45451 100644
--- a/server/src/test/java/org/opensearch/index/mapper/RangeFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/RangeFieldTypeTests.java
@@ -57,6 +57,7 @@
 import org.opensearch.index.mapper.RangeFieldMapper.RangeFieldType;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.index.query.QueryShardException;
+import org.opensearch.search.approximate.ApproximateIndexOrDocValuesQuery;
 import org.opensearch.test.IndexSettingsModule;
 import org.joda.time.DateTime;
 import org.junit.Before;
@@ -285,7 +286,15 @@ public void testDateRangeQueryUsingMappingFormatLegacy() {
         // compare lower and upper bounds with what we would get on a `date` field
         DateFieldType dateFieldType = new DateFieldType("field", DateFieldMapper.Resolution.MILLISECONDS, formatter);
         final Query queryOnDateField = dateFieldType.rangeQuery(from, to, true, true, relation, null, fieldType.dateMathParser(), context);
-        assertEquals("field:[1465975790000 TO 1466062190999]", ((IndexOrDocValuesQuery) queryOnDateField).getIndexQuery().toString());
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
+        assertEquals(
+            "field:[1465975790000 TO 1466062190999]",
+            ((IndexOrDocValuesQuery) ((ApproximateIndexOrDocValuesQuery) queryOnDateField).getOriginalQuery()).getIndexQuery().toString()
+        );
     }
 
     public void testDateRangeQueryUsingMappingFormat() {
diff --git a/server/src/test/java/org/opensearch/index/mapper/SourceFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/SourceFieldMapperTests.java
index 83d42fd423f08..4f3a4530b5475 100644
--- a/server/src/test/java/org/opensearch/index/mapper/SourceFieldMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/SourceFieldMapperTests.java
@@ -90,7 +90,8 @@ public void testNoFormat() throws Exception {
                 XContentType.SMILE
             )
         );
-
+        final IndexableField recoverySourceIndexableField = doc.rootDoc().getField("_recovery_source");
+        assertNull(recoverySourceIndexableField);
         assertThat(MediaTypeRegistry.xContentType(doc.source()), equalTo(XContentType.SMILE));
     }
 
@@ -128,6 +129,52 @@ public void testIncludes() throws Exception {
             )
         );
 
+        IndexableField sourceField = doc.rootDoc().getField("_source");
+        Map<String, Object> sourceAsMap;
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, new BytesArray(sourceField.binaryValue()))) {
+            sourceAsMap = parser.map();
+        }
+        final IndexableField recoverySourceIndexableField = doc.rootDoc().getField("_recovery_source");
+        assertNotNull(recoverySourceIndexableField);
+        assertThat(sourceAsMap.containsKey("path1"), equalTo(true));
+        assertThat(sourceAsMap.containsKey("path2"), equalTo(false));
+    }
+
+    public void testIncludesForRecoverySource() throws Exception {
+        String mapping = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("type")
+            .startObject("_source")
+            .array("includes", new String[] { "path1*" })
+            .array("recovery_source_includes", new String[] { "path2*" })
+            .endObject()
+            .endObject()
+            .endObject()
+            .toString();
+
+        DocumentMapper documentMapper = createIndex("test").mapperService()
+            .documentMapperParser()
+            .parse("type", new CompressedXContent(mapping));
+
+        ParsedDocument doc = documentMapper.parse(
+            new SourceToParse(
+                "test",
+                "1",
+                BytesReference.bytes(
+                    XContentFactory.jsonBuilder()
+                        .startObject()
+                        .startObject("path1")
+                        .field("field1", "value1")
+                        .endObject()
+                        .startObject("path2")
+                        .field("field2", "value2")
+                        .endObject()
+                        .endObject()
+                ),
+                MediaTypeRegistry.JSON
+            )
+        );
+
         IndexableField sourceField = doc.rootDoc().getField("_source");
         Map<String, Object> sourceAsMap;
         try (XContentParser parser = createParser(JsonXContent.jsonXContent, new BytesArray(sourceField.binaryValue()))) {
@@ -135,6 +182,39 @@ public void testIncludes() throws Exception {
         }
         assertThat(sourceAsMap.containsKey("path1"), equalTo(true));
         assertThat(sourceAsMap.containsKey("path2"), equalTo(false));
+
+        final IndexableField recoverySourceIndexableField = doc.rootDoc().getField("_recovery_source");
+        assertNotNull(recoverySourceIndexableField);
+        Map<String, Object> recoverySourceAsMap;
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, new BytesArray(recoverySourceIndexableField.binaryValue()))) {
+            recoverySourceAsMap = parser.map();
+        }
+
+        assertThat(recoverySourceAsMap.containsKey("path1"), equalTo(false));
+        assertThat(recoverySourceAsMap.containsKey("path2"), equalTo(true));
+    }
+
+    public void testNoRecoverySourceAndNoSource_whenBothAreDisabled() throws Exception {
+        String mapping = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("type")
+            .startObject("_source")
+            .field("enabled", "false")
+            .field("recovery_source_enabled", "false")
+            .endObject()
+            .endObject()
+            .endObject()
+            .toString();
+
+        DocumentMapperParser parser = createIndex("test").mapperService().documentMapperParser();
+        DocumentMapper documentMapper = parser.parse("type", new CompressedXContent(mapping));
+        BytesReference source = BytesReference.bytes(XContentFactory.jsonBuilder().startObject().field("field", "value").endObject());
+        ParsedDocument doc = documentMapper.parse(new SourceToParse("test", "1", source, MediaTypeRegistry.JSON));
+
+        final IndexableField sourceIndexableField = doc.rootDoc().getField("_source");
+        final IndexableField recoverySourceIndexableField = doc.rootDoc().getField("_recovery_source");
+        assertNull(recoverySourceIndexableField);
+        assertNull(sourceIndexableField);
     }
 
     public void testExcludes() throws Exception {
@@ -171,6 +251,52 @@ public void testExcludes() throws Exception {
             )
         );
 
+        IndexableField sourceField = doc.rootDoc().getField("_source");
+        Map<String, Object> sourceAsMap;
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, new BytesArray(sourceField.binaryValue()))) {
+            sourceAsMap = parser.map();
+        }
+        final IndexableField recoverySourceIndexableField = doc.rootDoc().getField("_recovery_source");
+        assertNotNull(recoverySourceIndexableField);
+        assertThat(sourceAsMap.containsKey("path1"), equalTo(false));
+        assertThat(sourceAsMap.containsKey("path2"), equalTo(true));
+    }
+
+    public void testExcludesForRecoverySource() throws Exception {
+        String mapping = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("type")
+            .startObject("_source")
+            .array("excludes", "path1*")
+            .array("recovery_source_excludes", "path2*")
+            .endObject()
+            .endObject()
+            .endObject()
+            .toString();
+
+        DocumentMapper documentMapper = createIndex("test").mapperService()
+            .documentMapperParser()
+            .parse("type", new CompressedXContent(mapping));
+
+        ParsedDocument doc = documentMapper.parse(
+            new SourceToParse(
+                "test",
+                "1",
+                BytesReference.bytes(
+                    XContentFactory.jsonBuilder()
+                        .startObject()
+                        .startObject("path1")
+                        .field("field1", "value1")
+                        .endObject()
+                        .startObject("path2")
+                        .field("field2", "value2")
+                        .endObject()
+                        .endObject()
+                ),
+                MediaTypeRegistry.JSON
+            )
+        );
+
         IndexableField sourceField = doc.rootDoc().getField("_source");
         Map<String, Object> sourceAsMap;
         try (XContentParser parser = createParser(JsonXContent.jsonXContent, new BytesArray(sourceField.binaryValue()))) {
@@ -178,6 +304,15 @@ public void testExcludes() throws Exception {
         }
         assertThat(sourceAsMap.containsKey("path1"), equalTo(false));
         assertThat(sourceAsMap.containsKey("path2"), equalTo(true));
+
+        final IndexableField recoverySourceIndexableField = doc.rootDoc().getField("_recovery_source");
+        assertNotNull(recoverySourceIndexableField);
+        Map<String, Object> recoverySourceAsMap;
+        try (XContentParser parser = createParser(JsonXContent.jsonXContent, new BytesArray(recoverySourceIndexableField.binaryValue()))) {
+            recoverySourceAsMap = parser.map();
+        }
+        assertThat(recoverySourceAsMap.containsKey("path1"), equalTo(true));
+        assertThat(recoverySourceAsMap.containsKey("path2"), equalTo(false));
     }
 
     public void testEnabledNotUpdateable() throws Exception {
diff --git a/server/src/test/java/org/opensearch/index/mapper/StarTreeMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/StarTreeMapperTests.java
new file mode 100644
index 0000000000000..daa9fda7a5a3b
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/StarTreeMapperTests.java
@@ -0,0 +1,1039 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.common.CheckedConsumer;
+import org.opensearch.common.Rounding;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.FeatureFlags;
+import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.common.unit.ByteSizeValue;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.compositeindex.CompositeIndexSettings;
+import org.opensearch.index.compositeindex.CompositeIndexValidator;
+import org.opensearch.index.compositeindex.datacube.DateDimension;
+import org.opensearch.index.compositeindex.datacube.Dimension;
+import org.opensearch.index.compositeindex.datacube.Metric;
+import org.opensearch.index.compositeindex.datacube.MetricStat;
+import org.opensearch.index.compositeindex.datacube.NumericDimension;
+import org.opensearch.index.compositeindex.datacube.ReadDimension;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeField;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeFieldConfiguration;
+import org.opensearch.index.compositeindex.datacube.startree.StarTreeIndexSettings;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
+import static org.opensearch.index.IndexSettings.INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING;
+import static org.opensearch.index.compositeindex.CompositeIndexSettings.COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING;
+import static org.hamcrest.Matchers.containsString;
+
+/**
+ * Tests for {@link StarTreeMapper}.
+ */
+public class StarTreeMapperTests extends MapperTestCase {
+
+    @Before
+    public void setup() {
+        FeatureFlags.initializeFeatureFlags(Settings.builder().put(FeatureFlags.STAR_TREE_INDEX, true).build());
+    }
+
+    @After
+    public void teardown() {
+        FeatureFlags.initializeFeatureFlags(Settings.EMPTY);
+    }
+
+    @Override
+    protected Settings getIndexSettings() {
+        return Settings.builder()
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .put(INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), new ByteSizeValue(512, ByteSizeUnit.MB))
+            .put(SETTINGS)
+            .build();
+    }
+
+    public void testValidStarTree() throws IOException {
+
+        MapperService mapperService = createMapperService(getExpandedMappingWithJustAvg("status", "size"));
+        Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
+        for (CompositeMappedFieldType type : compositeFieldTypes) {
+            StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
+            assertEquals(2, starTreeFieldType.getDimensions().size());
+            assertEquals("node", starTreeFieldType.getDimensions().get(0).getField());
+            assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
+            assertEquals(2, starTreeFieldType.getMetrics().size());
+            assertEquals("size", starTreeFieldType.getMetrics().get(0).getField());
+
+            // Assert COUNT and SUM gets added when AVG is defined
+            List<MetricStat> expectedMetrics = Arrays.asList(MetricStat.AVG, MetricStat.VALUE_COUNT, MetricStat.SUM);
+            assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+            assertEquals(100, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+            assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
+            assertEquals(
+                new HashSet<>(Arrays.asList("node", "status")),
+                starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims()
+            );
+        }
+    }
+
+    public void testCompositeIndexWithArraysInCompositeField() throws IOException {
+        DocumentMapper mapper = createDocumentMapper(getExpandedMappingWithJustAvg("status", "status"));
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> mapper.parse(source(b -> b.startArray("status").value(0).value(1).endArray()))
+        );
+        assertEquals(
+            "object mapping for [_doc] with array for [status] cannot be accepted as field is also part of composite index mapping which does not accept arrays",
+            ex.getMessage()
+        );
+        ParsedDocument doc = mapper.parse(source(b -> b.startArray("size").value(0).value(1).endArray()));
+        // 1 intPoint , 1 SNDV field for each value , so 4 in total
+        assertEquals(4, doc.rootDoc().getFields("size").length);
+    }
+
+    public void testValidValueForFlushTresholdSizeWithoutCompositeIndex() {
+        Settings settings = Settings.builder()
+            .put(INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "256mb")
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), false)
+            .build();
+
+        assertEquals(new ByteSizeValue(256, ByteSizeUnit.MB), INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.get(settings));
+    }
+
+    public void testValidValueForCompositeIndex() {
+        Settings settings = Settings.builder()
+            .put(INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "256mb")
+            .put(StarTreeIndexSettings.IS_COMPOSITE_INDEX_SETTING.getKey(), true)
+            .put(COMPOSITE_INDEX_MAX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.getKey(), "512mb")
+            .build();
+
+        assertEquals(new ByteSizeValue(256, ByteSizeUnit.MB), INDEX_TRANSLOG_FLUSH_THRESHOLD_SIZE_SETTING.get(settings));
+    }
+
+    public void testMetricsWithJustSum() throws IOException {
+        MapperService mapperService = createMapperService(getExpandedMappingWithJustSum("status", "size"));
+        Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
+        for (CompositeMappedFieldType type : compositeFieldTypes) {
+            StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
+            assertEquals("node", starTreeFieldType.getDimensions().get(0).getField());
+            assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
+            assertEquals("size", starTreeFieldType.getMetrics().get(0).getField());
+
+            // Assert AVG gets added when both of its base metrics is already present
+            List<MetricStat> expectedMetrics = List.of(MetricStat.SUM);
+            assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+            assertEquals(100, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+            assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
+            assertEquals(
+                new HashSet<>(Arrays.asList("node", "status")),
+                starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims()
+            );
+        }
+    }
+
+    public void testMetricsWithCountAndSum() throws IOException {
+        MapperService mapperService = createMapperService(getExpandedMappingWithSumAndCount("status", "size"));
+        Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
+        for (CompositeMappedFieldType type : compositeFieldTypes) {
+            StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
+            assertEquals("node", starTreeFieldType.getDimensions().get(0).getField());
+            assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
+            assertEquals("size", starTreeFieldType.getMetrics().get(0).getField());
+
+            // Assert AVG gets added when both of its base metrics is already present
+            List<MetricStat> expectedMetrics = List.of(MetricStat.SUM, MetricStat.VALUE_COUNT, MetricStat.AVG);
+            assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+
+            Metric metric = starTreeFieldType.getMetrics().get(1);
+            assertEquals("_doc_count", metric.getField());
+            assertEquals(List.of(MetricStat.DOC_COUNT), metric.getMetrics());
+
+            assertEquals(100, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+            assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
+            assertEquals(
+                new HashSet<>(Arrays.asList("node", "status")),
+                starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims()
+            );
+        }
+    }
+
+    public void testValidStarTreeDefaults() throws IOException {
+        MapperService mapperService = createMapperService(getMinMapping());
+        Set<CompositeMappedFieldType> compositeFieldTypes = mapperService.getCompositeFieldTypes();
+        for (CompositeMappedFieldType type : compositeFieldTypes) {
+            StarTreeMapper.StarTreeFieldType starTreeFieldType = (StarTreeMapper.StarTreeFieldType) type;
+            assertEquals("node", starTreeFieldType.getDimensions().get(0).getField());
+            assertEquals("status", starTreeFieldType.getDimensions().get(1).getField());
+            assertEquals(3, starTreeFieldType.getMetrics().size());
+            assertEquals("status", starTreeFieldType.getMetrics().get(0).getField());
+            List<MetricStat> expectedMetrics = Arrays.asList(MetricStat.VALUE_COUNT, MetricStat.SUM, MetricStat.AVG);
+            assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(0).getMetrics());
+
+            assertEquals("metric_field", starTreeFieldType.getMetrics().get(1).getField());
+            expectedMetrics = Arrays.asList(MetricStat.VALUE_COUNT, MetricStat.SUM, MetricStat.AVG);
+            assertEquals(expectedMetrics, starTreeFieldType.getMetrics().get(1).getMetrics());
+            Metric metric = starTreeFieldType.getMetrics().get(2);
+            assertEquals("_doc_count", metric.getField());
+            assertEquals(List.of(MetricStat.DOC_COUNT), metric.getMetrics());
+            assertEquals(10000, starTreeFieldType.getStarTreeConfig().maxLeafDocs());
+            assertEquals(StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP, starTreeFieldType.getStarTreeConfig().getBuildMode());
+            assertEquals(Collections.emptySet(), starTreeFieldType.getStarTreeConfig().getSkipStarNodeCreationInDims());
+        }
+    }
+
+    public void testInvalidDim() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getExpandedMappingWithJustAvg("invalid", "size"))
+        );
+        assertEquals("Failed to parse mapping [_doc]: unknown dimension field [invalid]", ex.getMessage());
+    }
+
+    public void testInvalidMetric() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getExpandedMappingWithJustAvg("status", "invalid"))
+        );
+        assertEquals("Failed to parse mapping [_doc]: unknown metric field [invalid]", ex.getMessage());
+    }
+
+    public void testNoMetrics() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getMinMapping(false, true, false, false))
+        );
+        assertThat(
+            ex.getMessage(),
+            containsString("Failed to parse mapping [_doc]: metrics section is required for star tree field [startree]")
+        );
+    }
+
+    public void testInvalidParam() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getInvalidMapping(false, false, false, false, true, false))
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: Star tree mapping definition has unsupported parameters:  [invalid : {invalid=invalid}]",
+            ex.getMessage()
+        );
+    }
+
+    public void testNoDims() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getMinMapping(true, false, false, false))
+        );
+        assertThat(
+            ex.getMessage(),
+            containsString("Failed to parse mapping [_doc]: ordered_dimensions is required for star tree field [startree]")
+        );
+    }
+
+    public void testMissingDims() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getMinMapping(false, false, true, false))
+        );
+        assertThat(ex.getMessage(), containsString("Failed to parse mapping [_doc]: unknown dimension field [node]"));
+    }
+
+    public void testMissingMetrics() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getMinMapping(false, false, false, true))
+        );
+        assertThat(ex.getMessage(), containsString("Failed to parse mapping [_doc]: unknown metric field [metric_field]"));
+    }
+
+    public void testInvalidMetricType() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getInvalidMapping(false, false, false, true))
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: non-numeric field type is associated with star tree metric [startree]",
+            ex.getMessage()
+        );
+    }
+
+    public void testInvalidMetricTypeWithDocCount() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getInvalidMapping(false, false, false, false, false, true))
+        );
+        assertEquals("Failed to parse mapping [_doc]: Invalid metric stat: _doc_count", ex.getMessage());
+    }
+
+    public void testInvalidDimType() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getInvalidMapping(false, false, true, false))
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: unsupported field type associated with dimension [node] as part of star tree field [startree]",
+            ex.getMessage()
+        );
+    }
+
+    public void testInvalidSkipDim() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getInvalidMapping(false, true, false, false))
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: [invalid] in skip_star_node_creation_for_dimensions should be part of ordered_dimensions",
+            ex.getMessage()
+        );
+    }
+
+    public void testInvalidSingleDim() {
+        MapperParsingException ex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getInvalidMapping(true, false, false, false))
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: Atleast two dimensions are required to build star tree index field [startree]",
+            ex.getMessage()
+        );
+    }
+
+    public void testDuplicateDimensions() {
+        XContentBuilder finalMapping = getMappingWithDuplicateFields(true, false);
+        MapperParsingException ex = expectThrows(MapperParsingException.class, () -> createMapperService(finalMapping));
+        assertEquals(
+            "Failed to parse mapping [_doc]: Duplicate dimension [numeric_dv] present as part star tree index field [startree-1]",
+            ex.getMessage()
+        );
+    }
+
+    public void testDuplicateMetrics() {
+        XContentBuilder finalMapping = getMappingWithDuplicateFields(false, true);
+        MapperParsingException ex = expectThrows(MapperParsingException.class, () -> createMapperService(finalMapping));
+        assertEquals(
+            "Failed to parse mapping [_doc]: Duplicate metrics [numeric_dv] present as part star tree index field [startree-1]",
+            ex.getMessage()
+        );
+    }
+
+    public void testMetric() {
+        List<MetricStat> m1 = new ArrayList<>();
+        m1.add(MetricStat.MAX);
+        Metric metric1 = new Metric("name", m1);
+        Metric metric2 = new Metric("name", m1);
+        assertEquals(metric1, metric2);
+        List<MetricStat> m2 = new ArrayList<>();
+        m2.add(MetricStat.MAX);
+        m2.add(MetricStat.VALUE_COUNT);
+        metric2 = new Metric("name", m2);
+        assertNotEquals(metric1, metric2);
+
+        assertEquals(MetricStat.VALUE_COUNT, MetricStat.fromTypeName("value_count"));
+        assertEquals(MetricStat.MAX, MetricStat.fromTypeName("max"));
+        assertEquals(MetricStat.MIN, MetricStat.fromTypeName("min"));
+        assertEquals(MetricStat.SUM, MetricStat.fromTypeName("sum"));
+        assertEquals(MetricStat.AVG, MetricStat.fromTypeName("avg"));
+
+        assertEquals(List.of(MetricStat.VALUE_COUNT, MetricStat.SUM), MetricStat.AVG.getBaseMetrics());
+
+        IllegalArgumentException ex = expectThrows(IllegalArgumentException.class, () -> MetricStat.fromTypeName("invalid"));
+        assertEquals("Invalid metric stat: invalid", ex.getMessage());
+    }
+
+    public void testDimensions() {
+        List<Rounding.DateTimeUnit> d1CalendarIntervals = new ArrayList<>();
+        d1CalendarIntervals.add(Rounding.DateTimeUnit.HOUR_OF_DAY);
+        DateDimension d1 = new DateDimension("name", d1CalendarIntervals);
+        DateDimension d2 = new DateDimension("name", d1CalendarIntervals);
+        assertEquals(d1, d2);
+        d2 = new DateDimension("name1", d1CalendarIntervals);
+        assertNotEquals(d1, d2);
+        List<Rounding.DateTimeUnit> d2CalendarIntervals = new ArrayList<>();
+        d2CalendarIntervals.add(Rounding.DateTimeUnit.HOUR_OF_DAY);
+        d2CalendarIntervals.add(Rounding.DateTimeUnit.HOUR_OF_DAY);
+        d2 = new DateDimension("name", d2CalendarIntervals);
+        assertNotEquals(d1, d2);
+        NumericDimension n1 = new NumericDimension("name");
+        NumericDimension n2 = new NumericDimension("name");
+        assertEquals(n1, n2);
+        n2 = new NumericDimension("name1");
+        assertNotEquals(n1, n2);
+    }
+
+    public void testReadDimensions() {
+        ReadDimension r1 = new ReadDimension("name");
+        ReadDimension r2 = new ReadDimension("name");
+        assertEquals(r1, r2);
+        r2 = new ReadDimension("name1");
+        assertNotEquals(r1, r2);
+    }
+
+    public void testStarTreeField() {
+        List<MetricStat> m1 = new ArrayList<>();
+        m1.add(MetricStat.MAX);
+        Metric metric1 = new Metric("name", m1);
+        List<Rounding.DateTimeUnit> d1CalendarIntervals = new ArrayList<>();
+        d1CalendarIntervals.add(Rounding.DateTimeUnit.HOUR_OF_DAY);
+        DateDimension d1 = new DateDimension("name", d1CalendarIntervals);
+        NumericDimension n1 = new NumericDimension("numeric");
+        NumericDimension n2 = new NumericDimension("name1");
+
+        List<Metric> metrics = List.of(metric1);
+        List<Dimension> dims = List.of(d1, n2);
+        StarTreeFieldConfiguration config = new StarTreeFieldConfiguration(
+            100,
+            Set.of("name"),
+            StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP
+        );
+
+        StarTreeField field1 = new StarTreeField("starTree", dims, metrics, config);
+        StarTreeField field2 = new StarTreeField("starTree", dims, metrics, config);
+        assertEquals(field1, field2);
+
+        dims = List.of(d1, n2, n1);
+        field2 = new StarTreeField("starTree", dims, metrics, config);
+        assertNotEquals(field1, field2);
+
+        dims = List.of(d1, n2);
+        metrics = List.of(metric1, metric1);
+        field2 = new StarTreeField("starTree", dims, metrics, config);
+        assertNotEquals(field1, field2);
+
+        dims = List.of(d1, n2);
+        metrics = List.of(metric1);
+        StarTreeFieldConfiguration config1 = new StarTreeFieldConfiguration(
+            1000,
+            Set.of("name"),
+            StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP
+        );
+        field2 = new StarTreeField("starTree", dims, metrics, config1);
+        assertNotEquals(field1, field2);
+
+        config1 = new StarTreeFieldConfiguration(100, Set.of("name", "field2"), StarTreeFieldConfiguration.StarTreeBuildMode.OFF_HEAP);
+        field2 = new StarTreeField("starTree", dims, metrics, config1);
+        assertNotEquals(field1, field2);
+
+        config1 = new StarTreeFieldConfiguration(100, Set.of("name"), StarTreeFieldConfiguration.StarTreeBuildMode.ON_HEAP);
+        field2 = new StarTreeField("starTree", dims, metrics, config1);
+        assertNotEquals(field1, field2);
+
+        field2 = new StarTreeField("starTree", dims, metrics, config);
+        assertEquals(field1, field2);
+    }
+
+    public void testValidations() throws IOException {
+        MapperService mapperService = createMapperService(getExpandedMappingWithJustAvg("status", "size"));
+        Settings settings = Settings.builder().put(CompositeIndexSettings.STAR_TREE_INDEX_ENABLED_SETTING.getKey(), true).build();
+        CompositeIndexSettings enabledCompositeIndexSettings = new CompositeIndexSettings(
+            settings,
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
+        CompositeIndexValidator.validate(mapperService, enabledCompositeIndexSettings, mapperService.getIndexSettings());
+        settings = Settings.builder().put(CompositeIndexSettings.STAR_TREE_INDEX_ENABLED_SETTING.getKey(), false).build();
+        CompositeIndexSettings compositeIndexSettings = new CompositeIndexSettings(
+            settings,
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
+        MapperService finalMapperService = mapperService;
+        IllegalArgumentException ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> CompositeIndexValidator.validate(finalMapperService, compositeIndexSettings, finalMapperService.getIndexSettings())
+        );
+        assertEquals(
+            "star tree index cannot be created, enable it using [indices.composite_index.star_tree.enabled] setting",
+            ex.getMessage()
+        );
+
+        MapperService mapperServiceInvalid = createMapperService(getInvalidMappingWithDv(false, false, false, true));
+        ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> CompositeIndexValidator.validate(
+                mapperServiceInvalid,
+                enabledCompositeIndexSettings,
+                mapperServiceInvalid.getIndexSettings()
+            )
+        );
+        assertEquals(
+            "Aggregations not supported for the metrics field [metric_field] with field type [integer] as part of star tree field",
+            ex.getMessage()
+        );
+
+        MapperService mapperServiceInvalidDim = createMapperService(getInvalidMappingWithDv(false, false, true, false));
+        ex = expectThrows(
+            IllegalArgumentException.class,
+            () -> CompositeIndexValidator.validate(
+                mapperServiceInvalidDim,
+                enabledCompositeIndexSettings,
+                mapperServiceInvalidDim.getIndexSettings()
+            )
+        );
+        assertEquals(
+            "Aggregations not supported for the dimension field [node] with field type [integer] as part of star tree field",
+            ex.getMessage()
+        );
+
+        MapperParsingException mapperParsingExceptionex = expectThrows(
+            MapperParsingException.class,
+            () -> createMapperService(getMinMappingWith2StarTrees())
+        );
+        assertEquals(
+            "Failed to parse mapping [_doc]: Composite fields cannot have more than [1] fields",
+            mapperParsingExceptionex.getMessage()
+        );
+    }
+
+    private XContentBuilder getExpandedMappingWithJustAvg(String dim, String metric) throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+            b.field("max_leaf_docs", 100);
+            b.startArray("skip_star_node_creation_for_dimensions");
+            {
+                b.value("node");
+                b.value("status");
+            }
+            b.endArray();
+            b.startArray("ordered_dimensions");
+            b.startObject();
+            b.field("name", "node");
+            b.endObject();
+            b.startObject();
+            b.field("name", dim);
+            b.endObject();
+            b.endArray();
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", metric);
+            b.startArray("stats");
+            b.value("avg");
+            b.endArray();
+            b.endObject();
+            b.endArray();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("node");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("size");
+            b.field("type", "integer");
+            b.endObject();
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder getMappingWithDuplicateFields(boolean isDuplicateDim, boolean isDuplicateMetric) {
+        XContentBuilder mapping = null;
+        try {
+            mapping = jsonBuilder().startObject()
+                .startObject("composite")
+                .startObject("startree-1")
+                .field("type", "star_tree")
+                .startObject("config")
+                .startArray("ordered_dimensions")
+                .startObject()
+                .field("name", "node")
+                .endObject()
+                .startObject()
+                .field("name", "numeric_dv")
+                .endObject()
+                .startObject()
+                .field("name", isDuplicateDim ? "numeric_dv" : "numeric_dv1")  // Duplicate dimension
+                .endObject()
+                .endArray()
+                .startArray("metrics")
+                .startObject()
+                .field("name", "numeric_dv")
+                .endObject()
+                .startObject()
+                .field("name", isDuplicateMetric ? "numeric_dv" : "numeric_dv1")  // Duplicate metric
+                .endObject()
+                .endArray()
+                .endObject()
+                .endObject()
+                .endObject()
+                .startObject("properties")
+                .startObject("node")
+                .field("type", "integer")
+                .endObject()
+                .startObject("numeric_dv")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .startObject("numeric_dv1")
+                .field("type", "integer")
+                .field("doc_values", true)
+                .endObject()
+                .endObject()
+                .endObject();
+        } catch (IOException e) {
+            fail("Failed to create mapping: " + e.getMessage());
+        }
+        return mapping;
+    }
+
+    private XContentBuilder getExpandedMappingWithJustSum(String dim, String metric) throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+            b.field("max_leaf_docs", 100);
+            b.startArray("skip_star_node_creation_for_dimensions");
+            {
+                b.value("node");
+                b.value("status");
+            }
+            b.endArray();
+            b.startArray("ordered_dimensions");
+            b.startObject();
+            b.field("name", "node");
+            b.endObject();
+            b.startObject();
+            b.field("name", dim);
+            b.endObject();
+            b.endArray();
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", metric);
+            b.startArray("stats");
+            b.value("sum");
+            b.endArray();
+            b.endObject();
+            b.endArray();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("node");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("size");
+            b.field("type", "integer");
+            b.endObject();
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder getExpandedMappingWithSumAndCount(String dim, String metric) throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+            b.field("max_leaf_docs", 100);
+            b.startArray("skip_star_node_creation_for_dimensions");
+            {
+                b.value("node");
+                b.value("status");
+            }
+            b.endArray();
+            b.startArray("ordered_dimensions");
+            b.startObject();
+            b.field("name", "node");
+            b.endObject();
+            b.startObject();
+            b.field("name", dim);
+            b.endObject();
+            b.endArray();
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", metric);
+            b.startArray("stats");
+            b.value("sum");
+            b.value("value_count");
+            b.endArray();
+            b.endObject();
+            b.endArray();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("node");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("size");
+            b.field("type", "integer");
+            b.endObject();
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder getMinMapping() throws IOException {
+        return getMinMapping(false, false, false, false);
+    }
+
+    private XContentBuilder getMinMapping(boolean isEmptyDims, boolean isEmptyMetrics, boolean missingDim, boolean missingMetric)
+        throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+            if (!isEmptyDims) {
+                b.startArray("ordered_dimensions");
+                b.startObject();
+                b.field("name", "node");
+                b.endObject();
+                b.startObject();
+                b.field("name", "status");
+                b.endObject();
+                b.endArray();
+            }
+            if (!isEmptyMetrics) {
+                b.startArray("metrics");
+                b.startObject();
+                b.field("name", "status");
+                b.endObject();
+                b.startObject();
+                b.field("name", "metric_field");
+                b.endObject();
+                b.endArray();
+            }
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            if (!missingDim) {
+                b.startObject("node");
+                b.field("type", "integer");
+                b.endObject();
+            }
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            if (!missingMetric) {
+                b.startObject("metric_field");
+                b.field("type", "integer");
+                b.endObject();
+            }
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder getMinMappingWith2StarTrees() throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+
+            b.startArray("ordered_dimensions");
+            b.startObject();
+            b.field("name", "@timestamp");
+            b.endObject();
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.endArray();
+
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.startObject();
+            b.field("name", "metric_field");
+            b.endObject();
+            b.endArray();
+
+            b.endObject();
+            b.endObject();
+
+            b.startObject("startree1");
+            b.field("type", "star_tree");
+            b.startObject("config");
+
+            b.startArray("ordered_dimensions");
+            b.startObject();
+            b.field("name", "@timestamp");
+            b.endObject();
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.endArray();
+
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.startObject();
+            b.field("name", "metric_field");
+            b.endObject();
+            b.endArray();
+
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("@timestamp");
+            b.field("type", "date");
+            b.endObject();
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("metric_field");
+            b.field("type", "integer");
+            b.endObject();
+
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder getInvalidMapping(
+        boolean singleDim,
+        boolean invalidSkipDims,
+        boolean invalidDimType,
+        boolean invalidMetricType,
+        boolean invalidParam,
+        boolean invalidDocCountMetricType
+    ) throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+
+            b.startArray("skip_star_node_creation_for_dimensions");
+            {
+                if (invalidSkipDims) {
+                    b.value("invalid");
+                }
+                b.value("status");
+            }
+            b.endArray();
+            if (invalidParam) {
+                b.startObject("invalid");
+                b.field("invalid", "invalid");
+                b.endObject();
+            }
+            b.startArray("ordered_dimensions");
+            if (!singleDim) {
+                b.startObject();
+                b.field("name", "node");
+                b.endObject();
+            }
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.endArray();
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.startObject();
+            b.field("name", "metric_field");
+            if (invalidDocCountMetricType) {
+                b.startArray("stats");
+                b.value("_doc_count");
+                b.value("avg");
+                b.endArray();
+            }
+            b.endObject();
+            b.endArray();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("node");
+            if (!invalidDimType) {
+                b.field("type", "integer");
+            } else {
+                b.field("type", "keyword");
+            }
+            b.endObject();
+
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("metric_field");
+            if (invalidMetricType) {
+                b.field("type", "date");
+            } else {
+                b.field("type", "integer");
+            }
+            b.endObject();
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder getInvalidMappingWithDv(
+        boolean singleDim,
+        boolean invalidSkipDims,
+        boolean invalidDimType,
+        boolean invalidMetricType
+    ) throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            b.field("type", "star_tree");
+            b.startObject("config");
+
+            b.startArray("skip_star_node_creation_for_dimensions");
+            {
+                if (invalidSkipDims) {
+                    b.value("invalid");
+                }
+                b.value("status");
+            }
+            b.endArray();
+            b.startArray("ordered_dimensions");
+            if (!singleDim) {
+                b.startObject();
+                b.field("name", "node");
+                b.endObject();
+            }
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.endArray();
+            b.startArray("metrics");
+            b.startObject();
+            b.field("name", "status");
+            b.endObject();
+            b.startObject();
+            b.field("name", "metric_field");
+            b.endObject();
+            b.endArray();
+            b.endObject();
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("node");
+            if (!invalidDimType) {
+                b.field("type", "integer");
+                b.field("doc_values", "true");
+            } else {
+                b.field("type", "integer");
+                b.field("doc_values", "false");
+            }
+            b.endObject();
+
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("metric_field");
+            if (invalidMetricType) {
+                b.field("type", "integer");
+                b.field("doc_values", "false");
+            } else {
+                b.field("type", "integer");
+                b.field("doc_values", "true");
+            }
+            b.endObject();
+            b.endObject();
+        });
+    }
+
+    private XContentBuilder getInvalidMapping(boolean singleDim, boolean invalidSkipDims, boolean invalidDimType, boolean invalidMetricType)
+        throws IOException {
+        return getInvalidMapping(singleDim, invalidSkipDims, invalidDimType, invalidMetricType, false, false);
+    }
+
+    protected boolean supportsOrIgnoresBoost() {
+        return false;
+    }
+
+    protected boolean supportsMeta() {
+        return false;
+    }
+
+    @Override
+    protected void assertExistsQuery(MapperService mapperService) {}
+
+    // Overriding fieldMapping to make it create composite mappings by default.
+    // This way, the parent tests are checking the right behavior for this Mapper.
+    @Override
+    protected final XContentBuilder fieldMapping(CheckedConsumer<XContentBuilder, IOException> buildField) throws IOException {
+        return topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("startree");
+            buildField.accept(b);
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("size");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            b.endObject();
+        });
+    }
+
+    @Override
+    public void testEmptyName() {
+        MapperParsingException e = expectThrows(MapperParsingException.class, () -> createMapperService(topMapping(b -> {
+            b.startObject("composite");
+            b.startObject("");
+            minimalMapping(b);
+            b.endObject();
+            b.endObject();
+            b.startObject("properties");
+            b.startObject("size");
+            b.field("type", "integer");
+            b.endObject();
+            b.startObject("status");
+            b.field("type", "integer");
+            b.endObject();
+            b.endObject();
+        })));
+        assertThat(e.getMessage(), containsString("name cannot be empty string"));
+        assertParseMinimalWarnings();
+    }
+
+    @Override
+    protected void minimalMapping(XContentBuilder b) throws IOException {
+        b.field("type", "star_tree");
+        b.startObject("config");
+        b.startArray("ordered_dimensions");
+        b.startObject();
+        b.field("name", "size");
+        b.endObject();
+        b.startObject();
+        b.field("name", "status");
+        b.endObject();
+        b.endArray();
+        b.startArray("metrics");
+        b.startObject();
+        b.field("name", "status");
+        b.endObject();
+        b.endArray();
+        b.endObject();
+    }
+
+    @Override
+    protected void writeFieldValue(XContentBuilder builder) throws IOException {}
+
+    @Override
+    protected void registerParameters(ParameterChecker checker) throws IOException {
+
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/TextFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/TextFieldMapperTests.java
index a22bfa5e845b1..0253caea9759d 100644
--- a/server/src/test/java/org/opensearch/index/mapper/TextFieldMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/TextFieldMapperTests.java
@@ -380,6 +380,57 @@ public void testIndexOptions() throws IOException {
         }
     }
 
+    public void testPositionIncrementGapOnIndexPrefixField() throws IOException {
+        // test default position_increment_gap
+        MapperService mapperService = createMapperService(
+            fieldMapping(b -> b.field("type", "text").field("analyzer", "default").startObject("index_prefixes").endObject())
+        );
+        ParsedDocument doc = mapperService.documentMapper().parse(source(b -> b.array("field", new String[] { "a", "b 12" })));
+
+        withLuceneIndex(mapperService, iw -> iw.addDocument(doc.rootDoc()), reader -> {
+            TermsEnum terms = getOnlyLeafReader(reader).terms("field").iterator();
+            assertTrue(terms.seekExact(new BytesRef("12")));
+            PostingsEnum postings = terms.postings(null, PostingsEnum.POSITIONS);
+            assertEquals(0, postings.nextDoc());
+            assertEquals(TextFieldMapper.Defaults.POSITION_INCREMENT_GAP + 2, postings.nextPosition());
+        });
+
+        withLuceneIndex(mapperService, iw -> iw.addDocument(doc.rootDoc()), reader -> {
+            TermsEnum terms = getOnlyLeafReader(reader).terms("field._index_prefix").iterator();
+            assertTrue(terms.seekExact(new BytesRef("12")));
+            PostingsEnum postings = terms.postings(null, PostingsEnum.POSITIONS);
+            assertEquals(0, postings.nextDoc());
+            assertEquals(TextFieldMapper.Defaults.POSITION_INCREMENT_GAP + 2, postings.nextPosition());
+        });
+
+        // test custom position_increment_gap
+        final int positionIncrementGap = randomIntBetween(1, 1000);
+        MapperService mapperService2 = createMapperService(
+            fieldMapping(
+                b -> b.field("type", "text")
+                    .field("position_increment_gap", positionIncrementGap)
+                    .field("analyzer", "default")
+                    .startObject("index_prefixes")
+                    .endObject()
+            )
+        );
+        ParsedDocument doc2 = mapperService2.documentMapper().parse(source(b -> b.array("field", new String[] { "a", "b 12" })));
+        withLuceneIndex(mapperService2, iw -> iw.addDocument(doc2.rootDoc()), reader -> {
+            TermsEnum terms = getOnlyLeafReader(reader).terms("field").iterator();
+            assertTrue(terms.seekExact(new BytesRef("12")));
+            PostingsEnum postings = terms.postings(null, PostingsEnum.POSITIONS);
+            assertEquals(0, postings.nextDoc());
+            assertEquals(positionIncrementGap + 2, postings.nextPosition());
+        });
+        withLuceneIndex(mapperService2, iw -> iw.addDocument(doc2.rootDoc()), reader -> {
+            TermsEnum terms = getOnlyLeafReader(reader).terms("field._index_prefix").iterator();
+            assertTrue(terms.seekExact(new BytesRef("12")));
+            PostingsEnum postings = terms.postings(null, PostingsEnum.POSITIONS);
+            assertEquals(0, postings.nextDoc());
+            assertEquals(positionIncrementGap + 2, postings.nextPosition());
+        });
+    }
+
     public void testDefaultPositionIncrementGap() throws IOException {
         MapperService mapperService = createMapperService(fieldMapping(this::minimalMapping));
         ParsedDocument doc = mapperService.documentMapper().parse(source(b -> b.array("field", new String[] { "a", "b" })));
diff --git a/server/src/test/java/org/opensearch/index/mapper/TextFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/TextFieldTypeTests.java
index 9c177bbec61fd..e672f94819541 100644
--- a/server/src/test/java/org/opensearch/index/mapper/TextFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/TextFieldTypeTests.java
@@ -167,6 +167,7 @@ public void testFuzzyQuery() {
 
     public void testIndexPrefixes() {
         TextFieldType ft = createFieldType(true);
+        ft.setIndexAnalyzer(Lucene.STANDARD_ANALYZER);
         ft.setPrefixFieldType(new TextFieldMapper.PrefixFieldType(ft, "field._index_prefix", 2, 10));
 
         Query q = ft.prefixQuery("goin", CONSTANT_SCORE_REWRITE, false, randomMockShardContext());
diff --git a/server/src/test/java/org/opensearch/index/mapper/WildcardFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/WildcardFieldMapperTests.java
new file mode 100644
index 0000000000000..a93f6b2d47e4f
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/WildcardFieldMapperTests.java
@@ -0,0 +1,333 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.analysis.TokenStream;
+import org.apache.lucene.analysis.Tokenizer;
+import org.apache.lucene.analysis.core.LowerCaseFilter;
+import org.apache.lucene.analysis.core.WhitespaceTokenizer;
+import org.apache.lucene.analysis.standard.StandardAnalyzer;
+import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.DocValuesType;
+import org.apache.lucene.index.IndexOptions;
+import org.apache.lucene.index.IndexableField;
+import org.apache.lucene.index.IndexableFieldType;
+import org.apache.lucene.util.BytesRef;
+import org.opensearch.Version;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.analysis.AnalyzerScope;
+import org.opensearch.index.analysis.CharFilterFactory;
+import org.opensearch.index.analysis.CustomAnalyzer;
+import org.opensearch.index.analysis.IndexAnalyzers;
+import org.opensearch.index.analysis.LowercaseNormalizer;
+import org.opensearch.index.analysis.NamedAnalyzer;
+import org.opensearch.index.analysis.TokenFilterFactory;
+import org.opensearch.index.analysis.TokenizerFactory;
+
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static java.util.Collections.singletonMap;
+import static org.opensearch.index.mapper.FieldTypeTestCase.fetchSourceValue;
+
+public class WildcardFieldMapperTests extends MapperTestCase {
+
+    @Override
+    protected void minimalMapping(XContentBuilder b) throws IOException {
+        b.field("type", "wildcard");
+    }
+
+    @Override
+    protected void writeFieldValue(XContentBuilder builder) throws IOException {
+        builder.value("value");
+    }
+
+    @Override
+    protected void registerParameters(ParameterChecker checker) throws IOException {
+        checker.registerConflictCheck("normalizer", b -> b.field("normalizer", "lowercase"));
+        checker.registerConflictCheck("doc_values", b -> b.field("doc_values", true));
+        checker.registerConflictCheck("null_value", b -> b.field("null_value", "foo"));
+        checker.registerUpdateCheck(b -> b.field("ignore_above", 256), m -> assertEquals(256, ((WildcardFieldMapper) m).ignoreAbove()));
+    }
+
+    public void testTokenizer() throws IOException {
+        List<String> terms = new ArrayList<>();
+        try (Tokenizer tokenizer = new WildcardFieldMapper.WildcardFieldTokenizer()) {
+            tokenizer.setReader(new StringReader("pickle"));
+            tokenizer.reset();
+            CharTermAttribute charTermAttribute = tokenizer.getAttribute(CharTermAttribute.class);
+            while (tokenizer.incrementToken()) {
+                terms.add(charTermAttribute.toString());
+            }
+        }
+        assertEquals(
+            List.of(
+                WildcardFieldTypeTests.prefixAnchored("p"),
+                WildcardFieldTypeTests.prefixAnchored("pi"),
+                "p",
+                "pi",
+                "pic",
+                "i",
+                "ic",
+                "ick",
+                "c",
+                "ck",
+                "ckl",
+                "k",
+                "kl",
+                "kle",
+                "l",
+                "le",
+                WildcardFieldTypeTests.suffixAnchored("le"),
+                "e",
+                WildcardFieldTypeTests.suffixAnchored("e")
+            ),
+            terms
+        );
+        terms.clear();
+        try (Tokenizer tokenizer = new WildcardFieldMapper.WildcardFieldTokenizer()) {
+            tokenizer.setReader(new StringReader("a"));
+            tokenizer.reset();
+            CharTermAttribute charTermAttribute = tokenizer.getAttribute(CharTermAttribute.class);
+            while (tokenizer.incrementToken()) {
+                terms.add(charTermAttribute.toString());
+            }
+        }
+        assertEquals(List.of(WildcardFieldTypeTests.prefixAnchored("a"), "a", WildcardFieldTypeTests.suffixAnchored("a")), terms);
+    }
+
+    public void testEnableDocValues() throws IOException {
+        DocumentMapper mapper = createDocumentMapper(fieldMapping(b -> b.field("type", "wildcard").field("doc_values", true)));
+        ParsedDocument doc = mapper.parse(source(b -> b.field("field", "1234")));
+        IndexableField[] fields = doc.rootDoc().getFields("field");
+        assertEquals(2, fields.length);
+        assertEquals(DocValuesType.NONE, fields[0].fieldType().docValuesType());
+        assertEquals(DocValuesType.SORTED_SET, fields[1].fieldType().docValuesType());
+
+        mapper = createDocumentMapper(fieldMapping(b -> b.field("type", "wildcard")));
+        doc = mapper.parse(source(b -> b.field("field", "1234")));
+        fields = doc.rootDoc().getFields("field");
+        assertEquals(1, fields.length);
+        assertEquals(DocValuesType.NONE, fields[0].fieldType().docValuesType());
+    }
+
+    @Override
+    protected IndexAnalyzers createIndexAnalyzers(IndexSettings indexSettings) {
+        return new IndexAnalyzers(
+            singletonMap("default", new NamedAnalyzer("default", AnalyzerScope.INDEX, new StandardAnalyzer())),
+            Map.of(
+                "lowercase",
+                new NamedAnalyzer("lowercase", AnalyzerScope.INDEX, new LowercaseNormalizer()),
+                "other_lowercase",
+                new NamedAnalyzer("other_lowercase", AnalyzerScope.INDEX, new LowercaseNormalizer())
+            ),
+            singletonMap(
+                "lowercase",
+                new NamedAnalyzer(
+                    "lowercase",
+                    AnalyzerScope.INDEX,
+                    new CustomAnalyzer(
+                        TokenizerFactory.newFactory("lowercase", WhitespaceTokenizer::new),
+                        new CharFilterFactory[0],
+                        new TokenFilterFactory[] { new TokenFilterFactory() {
+
+                            @Override
+                            public String name() {
+                                return "lowercase";
+                            }
+
+                            @Override
+                            public TokenStream create(TokenStream tokenStream) {
+                                return new LowerCaseFilter(tokenStream);
+                            }
+                        } }
+                    )
+                )
+            )
+        );
+    }
+
+    public void testNormalizer() throws IOException {
+        DocumentMapper mapper = createDocumentMapper(
+            fieldMapping(b -> b.field("type", "wildcard").field("normalizer", "lowercase").field("doc_values", true))
+        );
+        ParsedDocument doc = mapper.parse(source(b -> b.field("field", "AbC")));
+
+        IndexableField[] fields = doc.rootDoc().getFields("field");
+        assertEquals(2, fields.length);
+
+        assertTrue(fields[0] instanceof Field);
+        Field textField = (Field) fields[0];
+        List<String> terms = new ArrayList<>();
+        try (TokenStream tokenStream = textField.tokenStreamValue()) {
+            tokenStream.reset();
+            CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
+            while (tokenStream.incrementToken()) {
+                terms.add(charTermAttribute.toString());
+            }
+        }
+        assertEquals(
+            List.of(
+                WildcardFieldTypeTests.prefixAnchored("a"),
+                WildcardFieldTypeTests.prefixAnchored("ab"),
+                "a",
+                "ab",
+                "abc",
+                "b",
+                "bc",
+                WildcardFieldTypeTests.suffixAnchored("bc"),
+                "c",
+                WildcardFieldTypeTests.suffixAnchored("c")
+            ),
+            terms
+        );
+        IndexableFieldType fieldType = fields[0].fieldType();
+        assertTrue(fieldType.omitNorms());
+        assertTrue(fieldType.tokenized());
+        assertFalse(fieldType.stored());
+        assertEquals(IndexOptions.DOCS, fieldType.indexOptions());
+        assertFalse(fieldType.storeTermVectors());
+        assertFalse(fieldType.storeTermVectorOffsets());
+        assertFalse(fieldType.storeTermVectorPositions());
+        assertFalse(fieldType.storeTermVectorPayloads());
+        assertEquals(DocValuesType.NONE, fieldType.docValuesType());
+
+        assertEquals(new BytesRef("abc"), fields[1].binaryValue());
+        fieldType = fields[1].fieldType();
+        assertEquals(IndexOptions.NONE, fieldType.indexOptions());
+        assertEquals(DocValuesType.SORTED_SET, fieldType.docValuesType());
+    }
+
+    public void testNullValue() throws IOException {
+        DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
+        ParsedDocument doc = mapper.parse(source(b -> b.nullField("field")));
+        assertArrayEquals(new IndexableField[0], doc.rootDoc().getFields("field"));
+
+        mapper = createDocumentMapper(fieldMapping(b -> b.field("type", "wildcard").field("null_value", "uri").field("doc_values", true)));
+        doc = mapper.parse(source(b -> {}));
+        IndexableField[] fields = doc.rootDoc().getFields("field");
+        assertEquals(0, fields.length);
+        doc = mapper.parse(source(b -> b.nullField("field")));
+        fields = doc.rootDoc().getFields("field");
+        assertEquals(2, fields.length);
+        assertTrue(fields[0] instanceof Field);
+        Field textField = (Field) fields[0];
+        List<String> terms = new ArrayList<>();
+        try (TokenStream tokenStream = textField.tokenStreamValue()) {
+            tokenStream.reset();
+            CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
+            while (tokenStream.incrementToken()) {
+                terms.add(charTermAttribute.toString());
+            }
+        }
+        assertEquals(
+            List.of(
+                WildcardFieldTypeTests.prefixAnchored("u"),
+                WildcardFieldTypeTests.prefixAnchored("ur"),
+                "u",
+                "ur",
+                "uri",
+                "r",
+                "ri",
+                WildcardFieldTypeTests.suffixAnchored("ri"),
+                "i",
+                WildcardFieldTypeTests.suffixAnchored("i")
+            ),
+            terms
+        );
+        assertEquals(new BytesRef("uri"), fields[1].binaryValue());
+        assertEquals(IndexOptions.NONE, fields[1].fieldType().indexOptions());
+        assertEquals(DocValuesType.SORTED_SET, fields[1].fieldType().docValuesType());
+    }
+
+    public void testDefaults() throws Exception {
+        XContentBuilder mapping = fieldMapping(this::minimalMapping);
+        DocumentMapper mapper = createDocumentMapper(mapping);
+        assertEquals(mapping.toString(), mapper.mappingSource().toString());
+
+        ParsedDocument doc = mapper.parse(source(b -> b.field("field", "1234")));
+        IndexableField[] fields = doc.rootDoc().getFields("field");
+        assertEquals(1, fields.length);
+
+        assertTrue(fields[0] instanceof Field);
+        Field textField = (Field) fields[0];
+        List<String> terms = new ArrayList<>();
+        try (TokenStream tokenStream = textField.tokenStreamValue()) {
+            tokenStream.reset();
+            CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
+            while (tokenStream.incrementToken()) {
+                terms.add(charTermAttribute.toString());
+            }
+        }
+        assertEquals(
+            List.of(
+                WildcardFieldTypeTests.prefixAnchored("1"),
+                WildcardFieldTypeTests.prefixAnchored("12"),
+                "1",
+                "12",
+                "123",
+                "2",
+                "23",
+                "234",
+                "3",
+                "34",
+                WildcardFieldTypeTests.suffixAnchored("34"),
+                "4",
+                WildcardFieldTypeTests.suffixAnchored("4")
+            ),
+            terms
+        );
+        IndexableFieldType fieldType = fields[0].fieldType();
+        assertTrue(fieldType.omitNorms());
+        assertTrue(fieldType.tokenized());
+        assertFalse(fieldType.stored());
+        assertEquals(IndexOptions.DOCS, fieldType.indexOptions());
+        assertFalse(fieldType.storeTermVectors());
+        assertFalse(fieldType.storeTermVectorOffsets());
+        assertFalse(fieldType.storeTermVectorPositions());
+        assertFalse(fieldType.storeTermVectorPayloads());
+        assertEquals(DocValuesType.NONE, fieldType.docValuesType());
+    }
+
+    public void testFetchSourceValue() throws IOException {
+        Settings settings = Settings.builder().put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT.id).build();
+        Mapper.BuilderContext context = new Mapper.BuilderContext(settings, new ContentPath());
+
+        MappedFieldType mapper = new WildcardFieldMapper.Builder("field").build(context).fieldType();
+        assertEquals(Collections.singletonList("value"), fetchSourceValue(mapper, "value"));
+        assertEquals(Collections.singletonList("42"), fetchSourceValue(mapper, 42L));
+        assertEquals(Collections.singletonList("true"), fetchSourceValue(mapper, true));
+
+        IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> fetchSourceValue(mapper, "value", "format"));
+        assertEquals("Field [field] of type [wildcard] doesn't support formats.", e.getMessage());
+
+        MappedFieldType ignoreAboveMapper = new WildcardFieldMapper.Builder("field").ignoreAbove(4).build(context).fieldType();
+        assertEquals(Collections.emptyList(), fetchSourceValue(ignoreAboveMapper, "value"));
+        assertEquals(Collections.singletonList("42"), fetchSourceValue(ignoreAboveMapper, 42L));
+        assertEquals(Collections.singletonList("true"), fetchSourceValue(ignoreAboveMapper, true));
+
+        MappedFieldType normalizerMapper = new WildcardFieldMapper.Builder("field", createIndexAnalyzers(null)).normalizer("lowercase")
+            .build(context)
+            .fieldType();
+        assertEquals(Collections.singletonList("value"), fetchSourceValue(normalizerMapper, "VALUE"));
+        assertEquals(Collections.singletonList("42"), fetchSourceValue(normalizerMapper, 42L));
+        assertEquals(Collections.singletonList("value"), fetchSourceValue(normalizerMapper, "value"));
+
+        MappedFieldType nullValueMapper = new WildcardFieldMapper.Builder("field").nullValue("NULL").build(context).fieldType();
+        assertEquals(Collections.singletonList("NULL"), fetchSourceValue(nullValueMapper, null));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/WildcardFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/WildcardFieldTypeTests.java
new file mode 100644
index 0000000000000..cd2a23cf94c37
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/WildcardFieldTypeTests.java
@@ -0,0 +1,176 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TermQuery;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class WildcardFieldTypeTests extends FieldTypeTestCase {
+
+    static String prefixAnchored(String val) {
+        return (char) 0 + val;
+    }
+
+    static String suffixAnchored(String val) {
+        return val + (char) 0;
+    }
+
+    public void testTermQuery() {
+        MappedFieldType ft = new WildcardFieldMapper.WildcardFieldType("field");
+        Set<String> expectedTerms = new HashSet<>();
+        expectedTerms.add(prefixAnchored("ap"));
+        expectedTerms.add("app");
+        expectedTerms.add("ppl");
+        expectedTerms.add("ple");
+        expectedTerms.add(suffixAnchored("le"));
+        BooleanQuery.Builder builder = new BooleanQuery.Builder();
+        for (String term : expectedTerms) {
+            builder.add(new TermQuery(new Term("field", term)), BooleanClause.Occur.FILTER);
+        }
+        Query actual = ft.termQuery("apple", null);
+        assertEquals(new WildcardFieldMapper.WildcardMatchingQuery("field", builder.build(), "apple"), actual);
+        WildcardFieldMapper.WildcardMatchingQuery actualTermQuery = (WildcardFieldMapper.WildcardMatchingQuery) actual;
+        assertTrue(actualTermQuery.getSecondPhaseMatcher().test("apple"));
+        assertFalse(actualTermQuery.getSecondPhaseMatcher().test("Apple"));
+        assertFalse(actualTermQuery.getSecondPhaseMatcher().test("flapple"));
+        assertFalse(actualTermQuery.getSecondPhaseMatcher().test("apples"));
+    }
+
+    public void testWildcardQuery() {
+        MappedFieldType ft = new WildcardFieldMapper.WildcardFieldType("field");
+        Set<String> expectedTerms = new HashSet<>();
+        expectedTerms.add(prefixAnchored("ap"));
+        expectedTerms.add("app");
+        expectedTerms.add("ppl");
+        expectedTerms.add("ple");
+        expectedTerms.add(suffixAnchored("le"));
+
+        BooleanQuery.Builder builder = new BooleanQuery.Builder();
+        for (String term : expectedTerms) {
+            builder.add(new TermQuery(new Term("field", term)), BooleanClause.Occur.FILTER);
+        }
+
+        assertEquals(
+            new WildcardFieldMapper.WildcardMatchingQuery("field", builder.build(), "apple"),
+            ft.wildcardQuery("apple", null, null)
+        );
+
+        expectedTerms.remove(prefixAnchored("ap"));
+        builder = new BooleanQuery.Builder();
+        for (String term : expectedTerms) {
+            builder.add(new TermQuery(new Term("field", term)), BooleanClause.Occur.FILTER);
+        }
+        assertEquals(
+            new WildcardFieldMapper.WildcardMatchingQuery("field", builder.build(), "*apple"),
+            ft.wildcardQuery("*apple", null, null)
+        );
+
+        expectedTerms.remove(suffixAnchored("le"));
+        builder = new BooleanQuery.Builder();
+        for (String term : expectedTerms) {
+            builder.add(new TermQuery(new Term("field", term)), BooleanClause.Occur.FILTER);
+        }
+        assertEquals(
+            new WildcardFieldMapper.WildcardMatchingQuery("field", builder.build(), "*apple*"),
+            ft.wildcardQuery("*apple*", null, null)
+        );
+    }
+
+    public void testMultipleWildcardsInQuery() {
+        final String pattern = "a?cd*efg?h";
+        MappedFieldType ft = new WildcardFieldMapper.WildcardFieldType("field");
+        Set<String> expectedTerms = new HashSet<>();
+        expectedTerms.add(prefixAnchored("a"));
+        expectedTerms.add("cd");
+        expectedTerms.add("efg");
+        expectedTerms.add(suffixAnchored("h"));
+        BooleanQuery.Builder builder = new BooleanQuery.Builder();
+        for (String term : expectedTerms) {
+            builder.add(new TermQuery(new Term("field", term)), BooleanClause.Occur.FILTER);
+        }
+
+        Query actual = ft.wildcardQuery(pattern, null, null);
+        assertEquals(new WildcardFieldMapper.WildcardMatchingQuery("field", builder.build(), pattern), actual);
+        WildcardFieldMapper.WildcardMatchingQuery actualMatchingQuery = (WildcardFieldMapper.WildcardMatchingQuery) actual;
+        assertTrue(actualMatchingQuery.getSecondPhaseMatcher().test("abcdzzzefgqh"));
+        assertFalse(actualMatchingQuery.getSecondPhaseMatcher().test("abcdzzzefgqqh"));
+    }
+
+    public void testRegexpQuery() {
+        String pattern = ".*apple.*";
+        MappedFieldType ft = new WildcardFieldMapper.WildcardFieldType("field");
+
+        Set<String> expectedTerms = new HashSet<>();
+        expectedTerms.add("app");
+        expectedTerms.add("ppl");
+        expectedTerms.add("ple");
+        BooleanQuery.Builder builder = new BooleanQuery.Builder();
+        for (String term : expectedTerms) {
+            builder.add(new TermQuery(new Term("field", term)), BooleanClause.Occur.FILTER);
+        }
+
+        Query actual = ft.regexpQuery(pattern, 0, 0, 1000, null, null);
+        assertEquals(new WildcardFieldMapper.WildcardMatchingQuery("field", builder.build(), "/" + pattern + "/"), actual);
+        WildcardFieldMapper.WildcardMatchingQuery actualMatchingQuery = (WildcardFieldMapper.WildcardMatchingQuery) actual;
+        assertTrue(actualMatchingQuery.getSecondPhaseMatcher().test("foo_apple_foo"));
+        assertFalse(actualMatchingQuery.getSecondPhaseMatcher().test("foo_apply_foo"));
+
+        pattern = "ab(zz|cd|ef.*)(hi|jk)";
+        builder = new BooleanQuery.Builder();
+        builder.add(new TermQuery(new Term("field", "ab")), BooleanClause.Occur.FILTER);
+        builder.add(
+            new BooleanQuery.Builder().add(new TermQuery(new Term("field", "zz")), BooleanClause.Occur.SHOULD)
+                .add(new TermQuery(new Term("field", "cd")), BooleanClause.Occur.SHOULD)
+                .add(new TermQuery(new Term("field", "ef")), BooleanClause.Occur.SHOULD)
+                .build(),
+            BooleanClause.Occur.FILTER
+        );
+        builder.add(
+            new BooleanQuery.Builder().add(new TermQuery(new Term("field", "hi")), BooleanClause.Occur.SHOULD)
+                .add(new TermQuery(new Term("field", "jk")), BooleanClause.Occur.SHOULD)
+                .build(),
+            BooleanClause.Occur.FILTER
+        );
+        actual = ft.regexpQuery(pattern, 0, 0, 1000, null, null);
+        assertEquals(new WildcardFieldMapper.WildcardMatchingQuery("field", builder.build(), "/" + pattern + "/"), actual);
+        actualMatchingQuery = (WildcardFieldMapper.WildcardMatchingQuery) actual;
+        assertTrue(actualMatchingQuery.getSecondPhaseMatcher().test("abcdjk"));
+        assertTrue(actualMatchingQuery.getSecondPhaseMatcher().test("abefqwertyhi"));
+    }
+
+    public void testWildcardMatchAll() {
+        String pattern = "???";
+        MappedFieldType ft = new WildcardFieldMapper.WildcardFieldType("field");
+        Query actual = ft.wildcardQuery(pattern, null, null);
+        assertEquals(new WildcardFieldMapper.WildcardMatchingQuery("field", ft.existsQuery(null), "???"), actual);
+
+        pattern = "*";
+        actual = ft.wildcardQuery(pattern, null, null);
+        assertEquals(ft.existsQuery(null), actual);
+    }
+
+    public void testRegexpMatchAll() {
+        // The following matches any string of length exactly 3. We do need to evaluate the predicate.
+        String pattern = "...";
+        MappedFieldType ft = new WildcardFieldMapper.WildcardFieldType("field");
+        Query actual = ft.regexpQuery(pattern, 0, 0, 1000, null, null);
+        assertEquals(new WildcardFieldMapper.WildcardMatchingQuery("field", ft.existsQuery(null), "/.../"), actual);
+
+        // The following pattern has a predicate that matches everything. We can just return the field exists query.
+        pattern = ".*";
+        actual = ft.regexpQuery(pattern, 0, 0, 1000, null, null);
+        assertEquals(ft.existsQuery(null), actual);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java b/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
index 5a11ebebb312e..bed2d22125810 100644
--- a/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
+++ b/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
@@ -16,6 +16,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.IndexableField;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.TermQuery;
@@ -34,6 +35,7 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
 
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -45,7 +47,8 @@ public class DerivedFieldQueryTests extends OpenSearchTestCase {
         { "232.0.0.0 GET /images/hm_bg.jpg HTTP/1.0", "400", "232.0.0.0" },
         { "26.1.0.0 GET /images/hm_bg.jpg HTTP/1.0", "200", "26.1.0.0" },
         { "247.37.0.0 GET /french/splash_inet.html HTTP/1.0", "400", "247.37.0.0" },
-        { "247.37.0.0 GET /french/splash_inet.html HTTP/1.0", "400", "247.37.0.0" } };
+        { "247.37.0.0 GET /french/splash_inet.html HTTP/1.0", "400", "247.37.0.0" },
+        { "247.37.0.0 GET /french/splash_inet.html HTTP/1.0", "200", "247.37.0.0" } };
 
     public void testDerivedField() throws IOException {
         // Create lucene documents
@@ -76,18 +79,20 @@ public void execute() {
 
         // Create ValueFetcher from mocked DerivedFieldScript.Factory
         DerivedFieldScript.LeafFactory leafFactory = factory.newFactory((new Script("")).getParams(), searchLookup);
-        DerivedFieldValueFetcher valueFetcher = new DerivedFieldValueFetcher(
-            leafFactory,
-            null,
-            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType("keyword", "ip_from_raw_request")
+        Function<Object, IndexableField> indexableFieldFunction = DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(
+            "keyword",
+            "ip_from_raw_request"
         );
+        DerivedFieldValueFetcher valueFetcher = new DerivedFieldValueFetcher(leafFactory, null);
 
         // Create DerivedFieldQuery
         DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
             new TermQuery(new Term("ip_from_raw_request", "247.37.0.0")),
-            valueFetcher,
+            () -> valueFetcher,
             searchLookup,
-            Lucene.STANDARD_ANALYZER
+            Lucene.STANDARD_ANALYZER,
+            indexableFieldFunction,
+            true
         );
 
         // Index and Search
@@ -101,7 +106,78 @@ public void execute() {
                 iw.close();
                 IndexSearcher searcher = new IndexSearcher(reader);
                 TopDocs topDocs = searcher.search(derivedFieldQuery, 10);
-                assertEquals(2, topDocs.totalHits.value);
+                assertEquals(3, topDocs.totalHits.value);
+            }
+        }
+    }
+
+    public void testDerivedFieldWithIgnoreMalformed() throws IOException {
+        // Create lucene documents
+        List<Document> docs = new ArrayList<>();
+        for (String[] request : raw_requests) {
+            Document document = new Document();
+            document.add(new TextField("raw_request", request[0], Field.Store.YES));
+            document.add(new KeywordField("status", request[1], Field.Store.YES));
+            docs.add(document);
+        }
+
+        // Mock SearchLookup
+        SearchLookup searchLookup = mock(SearchLookup.class);
+        SourceLookup sourceLookup = new SourceLookup();
+        LeafSearchLookup leafLookup = mock(LeafSearchLookup.class);
+        when(leafLookup.source()).thenReturn(sourceLookup);
+
+        // Mock DerivedFieldScript.Factory
+        DerivedFieldScript.Factory factory = (params, lookup) -> (DerivedFieldScript.LeafFactory) ctx -> {
+            when(searchLookup.getLeafSearchLookup(ctx)).thenReturn(leafLookup);
+            return new DerivedFieldScript(params, lookup, ctx) {
+                @Override
+                public void execute() {
+                    addEmittedValue(raw_requests[sourceLookup.docId()][2]);
+                }
+            };
+        };
+
+        // Create ValueFetcher from mocked DerivedFieldScript.Factory
+        DerivedFieldScript.LeafFactory leafFactory = factory.newFactory((new Script("")).getParams(), searchLookup);
+        Function<Object, IndexableField> badIndexableFieldFunction = DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(
+            "date",
+            "ip_from_raw_request"
+        );
+        DerivedFieldValueFetcher valueFetcher = new DerivedFieldValueFetcher(leafFactory, null);
+        // Index and Search
+        try (Directory dir = newDirectory()) {
+            IndexWriter iw = new IndexWriter(dir, new IndexWriterConfig(Lucene.STANDARD_ANALYZER));
+            for (Document d : docs) {
+                iw.addDocument(d);
+            }
+            try (IndexReader reader = DirectoryReader.open(iw)) {
+                iw.close();
+                IndexSearcher searcher = new IndexSearcher(reader);
+                // Create DerivedFieldQuery
+                DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
+                    new TermQuery(new Term("ip_from_raw_request", "247.37.0.0")),
+                    () -> valueFetcher,
+                    searchLookup,
+                    Lucene.STANDARD_ANALYZER,
+                    badIndexableFieldFunction,
+                    false
+                );
+                DerivedFieldQuery finalDerivedFieldQuery = derivedFieldQuery;
+                assertThrows(ClassCastException.class, () -> searcher.search(finalDerivedFieldQuery, 10));
+
+                // set ignore_malformed as true, query should pass
+                derivedFieldQuery = new DerivedFieldQuery(
+                    new TermQuery(new Term("ip_from_raw_request", "247.37.0.0")),
+                    () -> valueFetcher,
+                    searchLookup,
+                    Lucene.STANDARD_ANALYZER,
+                    badIndexableFieldFunction,
+                    true
+                );
+                searcher.search(derivedFieldQuery, 10);
+                TopDocs topDocs = searcher.search(derivedFieldQuery, 10);
+                assertEquals(0, topDocs.totalHits.value);
             }
         }
     }
diff --git a/server/src/test/java/org/opensearch/index/query/MatchPhraseQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/query/MatchPhraseQueryBuilderTests.java
index f8d5d2ce3d062..ddf58073a5206 100644
--- a/server/src/test/java/org/opensearch/index/query/MatchPhraseQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/query/MatchPhraseQueryBuilderTests.java
@@ -42,6 +42,7 @@
 import org.apache.lucene.search.TermQuery;
 import org.opensearch.core.common.ParsingException;
 import org.opensearch.index.search.MatchQuery.ZeroTermsQuery;
+import org.opensearch.search.approximate.ApproximateIndexOrDocValuesQuery;
 import org.opensearch.test.AbstractQueryTestCase;
 
 import java.io.IOException;
@@ -130,6 +131,7 @@ protected void doAssertLuceneQuery(MatchPhraseQueryBuilder queryBuilder, Query q
                 .or(instanceOf(PointRangeQuery.class))
                 .or(instanceOf(IndexOrDocValuesQuery.class))
                 .or(instanceOf(MatchNoDocsQuery.class))
+                .or(instanceOf(ApproximateIndexOrDocValuesQuery.class))
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/index/query/NestedQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/query/NestedQueryBuilderTests.java
index 385623555e60a..6957d9908069f 100644
--- a/server/src/test/java/org/opensearch/index/query/NestedQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/query/NestedQueryBuilderTests.java
@@ -59,8 +59,10 @@
 import org.hamcrest.Matchers;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
@@ -311,6 +313,43 @@ public void testInlineLeafInnerHitsNestedQuery() throws Exception {
         assertThat(innerHitBuilders.get(leafInnerHits.getName()), Matchers.notNullValue());
     }
 
+    public void testParentFilterFromInlineLeafInnerHitsNestedQuery() throws Exception {
+        QueryShardContext queryShardContext = createShardContext();
+        SearchContext searchContext = mock(SearchContext.class);
+        when(searchContext.getQueryShardContext()).thenReturn(queryShardContext);
+
+        MapperService mapperService = mock(MapperService.class);
+        IndexSettings settings = new IndexSettings(newIndexMeta("index", Settings.EMPTY), Settings.EMPTY);
+        when(mapperService.getIndexSettings()).thenReturn(settings);
+        when(searchContext.mapperService()).thenReturn(mapperService);
+
+        InnerHitBuilder leafInnerHits = randomNestedInnerHits();
+        // Set null for values not related with this test case
+        leafInnerHits.setScriptFields(null);
+        leafInnerHits.setHighlightBuilder(null);
+        leafInnerHits.setSorts(null);
+
+        QueryBuilder innerQueryBuilder = spy(new MatchAllQueryBuilder());
+        when(innerQueryBuilder.toQuery(queryShardContext)).thenAnswer(invoke -> {
+            QueryShardContext context = invoke.getArgument(0);
+            if (context.getParentFilter() == null) {
+                throw new Exception("Expect parent filter to be non-null");
+            }
+            return invoke.callRealMethod();
+        });
+        NestedQueryBuilder query = new NestedQueryBuilder("nested1", innerQueryBuilder, ScoreMode.None);
+        query.innerHit(leafInnerHits);
+        final Map<String, InnerHitContextBuilder> innerHitBuilders = new HashMap<>();
+        final InnerHitsContext innerHitsContext = new InnerHitsContext();
+        query.extractInnerHitBuilders(innerHitBuilders);
+        assertThat(innerHitBuilders.size(), Matchers.equalTo(1));
+        assertTrue(innerHitBuilders.containsKey(leafInnerHits.getName()));
+        assertNull(queryShardContext.getParentFilter());
+        innerHitBuilders.get(leafInnerHits.getName()).build(searchContext, innerHitsContext);
+        assertNull(queryShardContext.getParentFilter());
+        verify(innerQueryBuilder).toQuery(queryShardContext);
+    }
+
     public void testInlineLeafInnerHitsNestedQueryViaBoolQuery() {
         InnerHitBuilder leafInnerHits = randomNestedInnerHits();
         NestedQueryBuilder nestedQueryBuilder = new NestedQueryBuilder("path", new MatchAllQueryBuilder(), ScoreMode.None).innerHit(
@@ -528,4 +567,13 @@ void doWithDepth(int depth, ThrowingConsumer<QueryShardContext> test) throws Exc
                 );
         }
     }
+
+    public void testVisit() {
+        NestedQueryBuilder builder = new NestedQueryBuilder("path", new MatchAllQueryBuilder(), ScoreMode.None);
+
+        List<QueryBuilder> visitedQueries = new ArrayList<>();
+        builder.visit(createTestVisitor(visitedQueries));
+
+        assertEquals(2, visitedQueries.size());
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/query/QueryShapeVisitorTests.java b/server/src/test/java/org/opensearch/index/query/QueryShapeVisitorTests.java
deleted file mode 100644
index 18b814aec61c2..0000000000000
--- a/server/src/test/java/org/opensearch/index/query/QueryShapeVisitorTests.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * SPDX-License-Identifier: Apache-2.0
- *
- * The OpenSearch Contributors require contributions made to
- * this file be licensed under the Apache-2.0 license or a
- * compatible open source license.
- */
-
-package org.opensearch.index.query;
-
-import org.opensearch.test.OpenSearchTestCase;
-
-import static org.junit.Assert.assertEquals;
-
-public final class QueryShapeVisitorTests extends OpenSearchTestCase {
-    public void testQueryShapeVisitor() {
-        QueryBuilder builder = new BoolQueryBuilder().must(new TermQueryBuilder("foo", "bar"))
-            .filter(new ConstantScoreQueryBuilder(new RangeQueryBuilder("timestamp").from("12345677").to("2345678")))
-            .should(
-                new BoolQueryBuilder().must(new MatchQueryBuilder("text", "this is some text"))
-                    .mustNot(new RegexpQueryBuilder("color", "red.*"))
-            )
-            .must(new TermsQueryBuilder("genre", "action", "drama", "romance"));
-        QueryShapeVisitor shapeVisitor = new QueryShapeVisitor();
-        builder.visit(shapeVisitor);
-        assertEquals(
-            "{\"type\":\"bool\",\"must\"[{\"type\":\"term\"},{\"type\":\"terms\"}],\"filter\"[{\"type\":\"constant_score\",\"filter\"[{\"type\":\"range\"}]}],\"should\"[{\"type\":\"bool\",\"must\"[{\"type\":\"match\"}],\"must_not\"[{\"type\":\"regexp\"}]}]}",
-            shapeVisitor.toJson()
-        );
-    }
-}
diff --git a/server/src/test/java/org/opensearch/index/query/QueryShardContextTests.java b/server/src/test/java/org/opensearch/index/query/QueryShardContextTests.java
index 6a7bf10835ddd..12677edc8efa7 100644
--- a/server/src/test/java/org/opensearch/index/query/QueryShardContextTests.java
+++ b/server/src/test/java/org/opensearch/index/query/QueryShardContextTests.java
@@ -31,7 +31,6 @@
 
 package org.opensearch.index.query;
 
-import org.apache.lucene.analysis.standard.StandardAnalyzer;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.document.StringField;
 import org.apache.lucene.index.DirectoryReader;
@@ -64,17 +63,12 @@
 import org.opensearch.index.fielddata.LeafFieldData;
 import org.opensearch.index.fielddata.ScriptDocValues;
 import org.opensearch.index.fielddata.plain.AbstractLeafOrdinalsFieldData;
-import org.opensearch.index.mapper.ContentPath;
-import org.opensearch.index.mapper.DerivedField;
-import org.opensearch.index.mapper.DerivedFieldMapper;
-import org.opensearch.index.mapper.DocumentMapper;
+import org.opensearch.index.mapper.DerivedFieldResolver;
+import org.opensearch.index.mapper.DerivedFieldType;
 import org.opensearch.index.mapper.IndexFieldMapper;
 import org.opensearch.index.mapper.MappedFieldType;
-import org.opensearch.index.mapper.Mapper;
 import org.opensearch.index.mapper.MapperService;
-import org.opensearch.index.mapper.MappingLookup;
 import org.opensearch.index.mapper.TextFieldMapper;
-import org.opensearch.script.Script;
 import org.opensearch.search.lookup.LeafDocLookup;
 import org.opensearch.search.lookup.LeafSearchLookup;
 import org.opensearch.search.lookup.SearchLookup;
@@ -85,7 +79,6 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 import java.util.function.BiFunction;
 import java.util.function.Supplier;
 
@@ -129,24 +122,14 @@ public void testFailIfFieldMappingNotFound() {
 
     public void testDerivedFieldMapping() {
         QueryShardContext context = createQueryShardContext(IndexMetadata.INDEX_UUID_NA_VALUE, null);
-        assertNull(context.failIfFieldMappingNotFound("test_derived", null));
-        context.setDerivedFieldTypes(null);
-        assertNull(context.failIfFieldMappingNotFound("test_derived", null));
-        DocumentMapper documentMapper = mock(DocumentMapper.class);
-        Mapper.BuilderContext builderContext = new Mapper.BuilderContext(Settings.EMPTY, new ContentPath(0));
-        DerivedFieldMapper derivedFieldMapper = new DerivedFieldMapper.Builder(new DerivedField("test_derived", "keyword", new Script("")))
-            .build(builderContext);
-        MappingLookup mappingLookup = new MappingLookup(
-            Collections.singletonList(derivedFieldMapper),
-            Collections.emptyList(),
-            Collections.emptyList(),
-            0,
-            new StandardAnalyzer()
-        );
-        when(documentMapper.mappers()).thenReturn(mappingLookup);
-        context.setDerivedFieldTypes(Map.of("test_derived", derivedFieldMapper.fieldType()));
-        context.setAllowUnmappedFields(false);
-        assertEquals(derivedFieldMapper.fieldType(), context.failIfFieldMappingNotFound("test_derived", null));
+        assertNull(context.failIfFieldMappingNotFound("derived_field_search_req", null));
+        DerivedFieldResolver derivedFieldResolver = mock(DerivedFieldResolver.class);
+        context.setDerivedFieldResolver(derivedFieldResolver);
+        DerivedFieldType mockDerivedFieldType = mock(DerivedFieldType.class);
+        when(derivedFieldResolver.resolve("derived_field_search_req")).thenReturn(mockDerivedFieldType);
+        assertEquals(mockDerivedFieldType, context.failIfFieldMappingNotFound("derived_field_search_req", null));
+        when(derivedFieldResolver.resolve("field_missing")).thenReturn(null);
+        assertNull(context.failIfFieldMappingNotFound("field_missing", null));
     }
 
     public void testToQueryFails() {
diff --git a/server/src/test/java/org/opensearch/index/query/QueryStringQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/query/QueryStringQueryBuilderTests.java
index af4a34aa98116..5b030df20e889 100644
--- a/server/src/test/java/org/opensearch/index/query/QueryStringQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/query/QueryStringQueryBuilderTests.java
@@ -47,7 +47,6 @@
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.DisjunctionMaxQuery;
 import org.apache.lucene.search.FuzzyQuery;
-import org.apache.lucene.search.IndexOrDocValuesQuery;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.MatchNoDocsQuery;
 import org.apache.lucene.search.MultiTermQuery;
@@ -71,11 +70,14 @@
 import org.opensearch.common.compress.CompressedXContent;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.Fuzziness;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.common.xcontent.json.JsonXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.mapper.FieldNamesFieldMapper;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.search.QueryStringQueryParser;
+import org.opensearch.search.approximate.ApproximateIndexOrDocValuesQuery;
+import org.opensearch.search.approximate.ApproximatePointRangeQuery;
 import org.opensearch.test.AbstractQueryTestCase;
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matchers;
@@ -98,6 +100,9 @@
 import static org.hamcrest.CoreMatchers.hasItems;
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
+import static org.apache.lucene.document.LongPoint.pack;
+import static org.junit.Assume.assumeThat;
 
 public class QueryStringQueryBuilderTests extends AbstractQueryTestCase<QueryStringQueryBuilder> {
 
@@ -853,7 +858,12 @@ public void testToQueryDateWithTimeZone() throws Exception {
         QueryStringQueryBuilder qsq = queryStringQuery(DATE_FIELD_NAME + ":1970-01-01");
         QueryShardContext context = createShardContext();
         Query query = qsq.toQuery(context);
-        assertThat(query, instanceOf(IndexOrDocValuesQuery.class));
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
+        assertThat(query, instanceOf(ApproximateIndexOrDocValuesQuery.class));
         long lower = 0; // 1970-01-01T00:00:00.999 UTC
         long upper = 86399999;  // 1970-01-01T23:59:59.999 UTC
         assertEquals(calculateExpectedDateQuery(lower, upper), query);
@@ -862,10 +872,22 @@ public void testToQueryDateWithTimeZone() throws Exception {
         assertEquals(calculateExpectedDateQuery(lower + msPerHour, upper + msPerHour), qsq.timeZone("-01:00").toQuery(context));
     }
 
-    private IndexOrDocValuesQuery calculateExpectedDateQuery(long lower, long upper) {
-        Query query = LongPoint.newRangeQuery(DATE_FIELD_NAME, lower, upper);
-        Query dv = SortedNumericDocValuesField.newSlowRangeQuery(DATE_FIELD_NAME, lower, upper);
-        return new IndexOrDocValuesQuery(query, dv);
+    private ApproximateIndexOrDocValuesQuery calculateExpectedDateQuery(long lower, long upper) {
+        return new ApproximateIndexOrDocValuesQuery(
+            LongPoint.newRangeQuery(DATE_FIELD_NAME, lower, upper),
+            new ApproximatePointRangeQuery(
+                DATE_FIELD_NAME,
+                pack(new long[] { lower }).bytes,
+                pack(new long[] { upper }).bytes,
+                new long[] { lower }.length
+            ) {
+                @Override
+                protected String toString(int dimension, byte[] value) {
+                    return Long.toString(LongPoint.decodeDimension(value, 0));
+                }
+            },
+            SortedNumericDocValuesField.newSlowRangeQuery(DATE_FIELD_NAME, lower, upper)
+        );
     }
 
     public void testFuzzyNumeric() throws Exception {
diff --git a/server/src/test/java/org/opensearch/index/query/RangeQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/query/RangeQueryBuilderTests.java
index 64b3eea029bd1..601a66d229131 100644
--- a/server/src/test/java/org/opensearch/index/query/RangeQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/query/RangeQueryBuilderTests.java
@@ -34,6 +34,7 @@
 
 import org.apache.lucene.document.IntPoint;
 import org.apache.lucene.document.LongPoint;
+import org.apache.lucene.document.SortedNumericDocValuesField;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.DocValuesFieldExistsQuery;
@@ -47,12 +48,16 @@
 import org.opensearch.OpenSearchParseException;
 import org.opensearch.common.geo.ShapeRelation;
 import org.opensearch.common.lucene.BytesRefs;
+import org.opensearch.common.util.FeatureFlags;
 import org.opensearch.core.common.ParsingException;
 import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.mapper.FieldNamesFieldMapper;
 import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.index.mapper.MappedFieldType.Relation;
 import org.opensearch.index.mapper.MapperService;
+import org.opensearch.search.approximate.ApproximateIndexOrDocValuesQuery;
+import org.opensearch.search.approximate.ApproximatePointRangeQuery;
+import org.opensearch.search.approximate.ApproximateQuery;
 import org.opensearch.test.AbstractQueryTestCase;
 import org.joda.time.DateTime;
 import org.joda.time.chrono.ISOChronology;
@@ -65,9 +70,12 @@
 import java.util.Map;
 
 import static org.opensearch.index.query.QueryBuilders.rangeQuery;
+import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.sameInstance;
+import static org.apache.lucene.document.LongPoint.pack;
+import static org.junit.Assume.assumeThat;
 
 public class RangeQueryBuilderTests extends AbstractQueryTestCase<RangeQueryBuilder> {
     @Override
@@ -183,9 +191,16 @@ protected void doAssertLuceneQuery(RangeQueryBuilder queryBuilder, Query query,
                 assertThat(termRangeQuery.includesLower(), equalTo(queryBuilder.includeLower()));
                 assertThat(termRangeQuery.includesUpper(), equalTo(queryBuilder.includeUpper()));
             } else if (expectedFieldName.equals(DATE_FIELD_NAME)) {
-                assertThat(query, instanceOf(IndexOrDocValuesQuery.class));
-                query = ((IndexOrDocValuesQuery) query).getIndexQuery();
-                assertThat(query, instanceOf(PointRangeQuery.class));
+                assumeThat(
+                    "Using Approximate Range Query as default",
+                    FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+                    is(true)
+                );
+                assertThat(query, instanceOf(ApproximateIndexOrDocValuesQuery.class));
+                Query approximationQuery = ((ApproximateIndexOrDocValuesQuery) query).getApproximationQuery();
+                assertThat(approximationQuery, instanceOf(ApproximateQuery.class));
+                Query originalQuery = ((ApproximateIndexOrDocValuesQuery) query).getOriginalQuery();
+                assertThat(originalQuery, instanceOf(IndexOrDocValuesQuery.class));
                 MapperService mapperService = context.getMapperService();
                 MappedFieldType mappedFieldType = mapperService.fieldType(expectedFieldName);
                 final Long fromInMillis;
@@ -234,7 +249,24 @@ protected void doAssertLuceneQuery(RangeQueryBuilder queryBuilder, Query query,
                         maxLong--;
                     }
                 }
-                assertEquals(LongPoint.newRangeQuery(DATE_FIELD_NAME, minLong, maxLong), query);
+                assertEquals(
+                    new ApproximateIndexOrDocValuesQuery(
+                        LongPoint.newRangeQuery(DATE_FIELD_NAME, minLong, maxLong),
+                        new ApproximatePointRangeQuery(
+                            DATE_FIELD_NAME,
+                            pack(new long[] { minLong }).bytes,
+                            pack(new long[] { maxLong }).bytes,
+                            new long[] { minLong }.length
+                        ) {
+                            @Override
+                            protected String toString(int dimension, byte[] value) {
+                                return Long.toString(LongPoint.decodeDimension(value, 0));
+                            }
+                        },
+                        SortedNumericDocValuesField.newSlowRangeQuery(DATE_FIELD_NAME, minLong, maxLong)
+                    ),
+                    query
+                );
             } else if (expectedFieldName.equals(INT_FIELD_NAME)) {
                 assertThat(query, instanceOf(IndexOrDocValuesQuery.class));
                 query = ((IndexOrDocValuesQuery) query).getIndexQuery();
@@ -299,15 +331,33 @@ public void testDateRangeQueryFormat() throws IOException {
             + "    }\n"
             + "}";
         Query parsedQuery = parseQuery(query).toQuery(createShardContext());
-        assertThat(parsedQuery, instanceOf(IndexOrDocValuesQuery.class));
-        parsedQuery = ((IndexOrDocValuesQuery) parsedQuery).getIndexQuery();
-        assertThat(parsedQuery, instanceOf(PointRangeQuery.class));
-
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
+        assertThat(parsedQuery, instanceOf(ApproximateIndexOrDocValuesQuery.class));
+        Query approximationQuery = ((ApproximateIndexOrDocValuesQuery) parsedQuery).getApproximationQuery();
+        assertThat(approximationQuery, instanceOf(ApproximateQuery.class));
+        Query originalQuery = ((ApproximateIndexOrDocValuesQuery) parsedQuery).getOriginalQuery();
+        assertThat(originalQuery, instanceOf(IndexOrDocValuesQuery.class));
+        long lower = DateTime.parse("2012-01-01T00:00:00.000+00").getMillis();
+        long upper = DateTime.parse("2030-01-01T00:00:00.000+00").getMillis() - 1;
         assertEquals(
-            LongPoint.newRangeQuery(
-                DATE_FIELD_NAME,
-                DateTime.parse("2012-01-01T00:00:00.000+00").getMillis(),
-                DateTime.parse("2030-01-01T00:00:00.000+00").getMillis() - 1
+            new ApproximateIndexOrDocValuesQuery(
+                LongPoint.newRangeQuery(DATE_FIELD_NAME, lower, upper),
+                new ApproximatePointRangeQuery(
+                    DATE_FIELD_NAME,
+                    pack(new long[] { lower }).bytes,
+                    pack(new long[] { upper }).bytes,
+                    new long[] { lower }.length
+                ) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return Long.toString(LongPoint.decodeDimension(value, 0));
+                    }
+                },
+                SortedNumericDocValuesField.newSlowRangeQuery(DATE_FIELD_NAME, lower, upper)
             ),
             parsedQuery
         );
@@ -339,15 +389,33 @@ public void testDateRangeBoundaries() throws IOException {
             + "    }\n"
             + "}\n";
         Query parsedQuery = parseQuery(query).toQuery(createShardContext());
-        assertThat(parsedQuery, instanceOf(IndexOrDocValuesQuery.class));
-        parsedQuery = ((IndexOrDocValuesQuery) parsedQuery).getIndexQuery();
-        assertThat(parsedQuery, instanceOf(PointRangeQuery.class));
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
+        assertThat(parsedQuery, instanceOf(ApproximateIndexOrDocValuesQuery.class));
+
+        long lower = DateTime.parse("2014-11-01T00:00:00.000+00").getMillis();
+        long upper = DateTime.parse("2014-12-08T23:59:59.999+00").getMillis();
         assertEquals(
-            LongPoint.newRangeQuery(
-                DATE_FIELD_NAME,
-                DateTime.parse("2014-11-01T00:00:00.000+00").getMillis(),
-                DateTime.parse("2014-12-08T23:59:59.999+00").getMillis()
-            ),
+            new ApproximateIndexOrDocValuesQuery(
+                LongPoint.newRangeQuery(DATE_FIELD_NAME, lower, upper),
+                new ApproximatePointRangeQuery(
+                    DATE_FIELD_NAME,
+                    pack(new long[] { lower }).bytes,
+                    pack(new long[] { upper }).bytes,
+                    new long[] { lower }.length
+                ) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return Long.toString(LongPoint.decodeDimension(value, 0));
+                    }
+                },
+                SortedNumericDocValuesField.newSlowRangeQuery(DATE_FIELD_NAME, lower, upper)
+            )
+
+            ,
             parsedQuery
         );
 
@@ -362,15 +430,27 @@ public void testDateRangeBoundaries() throws IOException {
             + "    }\n"
             + "}";
         parsedQuery = parseQuery(query).toQuery(createShardContext());
-        assertThat(parsedQuery, instanceOf(IndexOrDocValuesQuery.class));
-        parsedQuery = ((IndexOrDocValuesQuery) parsedQuery).getIndexQuery();
-        assertThat(parsedQuery, instanceOf(PointRangeQuery.class));
+        assertThat(parsedQuery, instanceOf(ApproximateIndexOrDocValuesQuery.class));
+        lower = DateTime.parse("2014-11-30T23:59:59.999+00").getMillis() + 1;
+        upper = DateTime.parse("2014-12-08T00:00:00.000+00").getMillis() - 1;
         assertEquals(
-            LongPoint.newRangeQuery(
-                DATE_FIELD_NAME,
-                DateTime.parse("2014-11-30T23:59:59.999+00").getMillis() + 1,
-                DateTime.parse("2014-12-08T00:00:00.000+00").getMillis() - 1
-            ),
+            new ApproximateIndexOrDocValuesQuery(
+                LongPoint.newRangeQuery(DATE_FIELD_NAME, lower, upper),
+                new ApproximatePointRangeQuery(
+                    DATE_FIELD_NAME,
+                    pack(new long[] { lower }).bytes,
+                    pack(new long[] { upper }).bytes,
+                    new long[] { lower }.length
+                ) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return Long.toString(LongPoint.decodeDimension(value, 0));
+                    }
+                },
+                SortedNumericDocValuesField.newSlowRangeQuery(DATE_FIELD_NAME, lower, upper)
+            )
+
+            ,
             parsedQuery
         );
     }
@@ -391,9 +471,14 @@ public void testDateRangeQueryTimezone() throws IOException {
         Query parsedQuery = parseQuery(query).toQuery(context);
         assertThat(parsedQuery, instanceOf(DateRangeIncludingNowQuery.class));
         parsedQuery = ((DateRangeIncludingNowQuery) parsedQuery).getQuery();
-        assertThat(parsedQuery, instanceOf(IndexOrDocValuesQuery.class));
-        parsedQuery = ((IndexOrDocValuesQuery) parsedQuery).getIndexQuery();
-        assertThat(parsedQuery, instanceOf(PointRangeQuery.class));
+        assumeThat(
+            "Using Approximate Range Query as default",
+            FeatureFlags.isEnabled(FeatureFlags.APPROXIMATE_POINT_RANGE_QUERY),
+            is(true)
+        );
+        assertThat(parsedQuery, instanceOf(ApproximateIndexOrDocValuesQuery.class));
+        parsedQuery = ((ApproximateIndexOrDocValuesQuery) parsedQuery).getApproximationQuery();
+        assertThat(parsedQuery, instanceOf(ApproximateQuery.class));
         // TODO what else can we assert
 
         query = "{\n"
diff --git a/server/src/test/java/org/opensearch/index/query/TermsQueryBuilderTests.java b/server/src/test/java/org/opensearch/index/query/TermsQueryBuilderTests.java
index 7b45308a523c8..ce3eeb0e3bf69 100644
--- a/server/src/test/java/org/opensearch/index/query/TermsQueryBuilderTests.java
+++ b/server/src/test/java/org/opensearch/index/query/TermsQueryBuilderTests.java
@@ -46,6 +46,7 @@
 import org.opensearch.OpenSearchException;
 import org.opensearch.action.get.GetRequest;
 import org.opensearch.action.get.GetResponse;
+import org.opensearch.common.document.DocumentField;
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.xcontent.XContentFactory;
 import org.opensearch.core.common.ParsingException;
@@ -59,15 +60,20 @@
 import org.junit.Before;
 
 import java.io.IOException;
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import org.roaringbitmap.RoaringBitmap;
+
 import static org.hamcrest.Matchers.containsString;
 import static org.hamcrest.Matchers.either;
 import static org.hamcrest.Matchers.instanceOf;
@@ -120,10 +126,9 @@ protected TermsQueryBuilder doCreateTestQueryBuilder() {
     }
 
     private TermsLookup randomTermsLookup() {
-        // Randomly choose between a typeless terms lookup and one with an explicit type to make sure we are
         TermsLookup lookup = new TermsLookup(randomAlphaOfLength(10), randomAlphaOfLength(10), termsPath);
-        // testing both cases.
         lookup.routing(randomBoolean() ? randomAlphaOfLength(10) : null);
+        lookup.store(randomBoolean());
         return lookup;
     }
 
@@ -245,7 +250,17 @@ public GetResponse executeGet(GetRequest getRequest) {
         } catch (IOException ex) {
             throw new OpenSearchException("boom", ex);
         }
-        return new GetResponse(new GetResult(getRequest.index(), getRequest.id(), 0, 1, 0, true, new BytesArray(json), null, null));
+        Map<String, DocumentField> documentField = new HashMap<>();
+        List<Object> nonNullTerms = new ArrayList<>();
+        for (Object obj : randomTerms) {
+            if (obj != null) {
+                nonNullTerms.add(obj);
+            }
+        }
+        documentField.put(termsPath, new DocumentField(termsPath, nonNullTerms));
+        return new GetResponse(
+            new GetResult(getRequest.index(), getRequest.id(), 0, 1, 0, true, new BytesArray(json), documentField, null)
+        );
     }
 
     public void testNumeric() throws IOException {
@@ -388,4 +403,50 @@ protected QueryBuilder parseQuery(XContentParser parser) throws IOException {
         }
     }
 
+    public void testFromJsonWithValueType() throws IOException {
+        String json = "{\n"
+            + "    \"terms\": {\n"
+            + "        \"student_id\": [\"OjAAAAEAAAAAAAEAEAAAAG8A3gA=\"],\n"
+            + "        \"boost\" : 1.0,\n"
+            + "        \"value_type\": \"bitmap\"\n"
+            + "    }\n"
+            + "}";
+
+        TermsQueryBuilder parsed = (TermsQueryBuilder) parseQuery(json);
+        checkGeneratedJson(json, parsed);
+        assertEquals(json, 1, parsed.values().size());
+    }
+
+    public void testFromJsonWithValueTypeFail() {
+        String json = "{\n"
+            + "    \"terms\": {\n"
+            + "        \"student_id\": [\"OjAAAAEAAAAAAAEAEAAAAG8A3gA=\", \"2\"],\n"
+            + "        \"boost\" : 1.0,\n"
+            + "        \"value_type\": \"bitmap\"\n"
+            + "    }\n"
+            + "}";
+
+        IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> parseQuery(json));
+        assertEquals(
+            "Invalid value for bitmap type: Expected a single-element array with a base64 encoded serialized bitmap.",
+            e.getMessage()
+        );
+    }
+
+    public void testTermsLookupBitmap() throws IOException {
+        RoaringBitmap bitmap = new RoaringBitmap();
+        bitmap.add(111);
+        bitmap.add(333);
+        byte[] array = new byte[bitmap.serializedSizeInBytes()];
+        bitmap.serialize(ByteBuffer.wrap(array));
+        randomTerms = List.of(new BytesArray(array)); // this will be fetched back by terms lookup
+
+        TermsQueryBuilder query = new TermsQueryBuilder(INT_FIELD_NAME, randomTermsLookup().store(true)).valueType(
+            TermsQueryBuilder.ValueType.BITMAP
+        );
+        QueryShardContext context = createShardContext();
+        QueryBuilder rewritten = rewriteQuery(query, new QueryShardContext(context));
+        Query luceneQuery = rewritten.toQuery(context);
+        assertTrue(luceneQuery instanceof IndexOrDocValuesQuery);
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteIndexPathTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteIndexPathTests.java
index 8ddbd383756e7..2351d165b369f 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteIndexPathTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteIndexPathTests.java
@@ -9,12 +9,16 @@
 package org.opensearch.index.remote;
 
 import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.core.xcontent.MediaTypeRegistry;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.indices.DefaultRemoteStoreSettings;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
@@ -40,7 +44,8 @@ public void testToXContentWithSegmentRepo() throws IOException {
             new BlobPath().add("djsd878ndjh").add("hcs87cj8"),
             PathType.HASHED_PREFIX,
             PathHashAlgorithm.FNV_1A_BASE64,
-            RemoteIndexPath.SEGMENT_PATH
+            RemoteIndexPath.SEGMENT_PATH,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         XContentBuilder xContentBuilder = MediaTypeRegistry.contentBuilder(MediaTypeRegistry.JSON);
         xContentBuilder.startObject();
@@ -49,6 +54,28 @@ public void testToXContentWithSegmentRepo() throws IOException {
         String expected =
             "{\"version\":\"1\",\"index_uuid\":\"djjsid73he8yd7usduh\",\"shard_count\":2,\"path_type\":\"HASHED_PREFIX\",\"path_hash_algorithm\":\"FNV_1A_BASE64\",\"path_creation_map\":{\"segments\":[\"data\",\"metadata\",\"lock_files\"]},\"paths\":[\"9BmBinD5HYs/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/segments/data/\",\"ExCNOD8_5ew/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/segments/data/\",\"z8wtf0yr2l4/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/segments/metadata/\",\"VheHVwFlExE/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/segments/metadata/\",\"IgFKbsDeUpQ/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/segments/lock_files/\",\"pA3gy_GZtns/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/segments/lock_files/\"]}";
         assertEquals(expected, xContentBuilder.toString());
+
+        // Fixed prefix
+        Settings settings = Settings.builder().put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.getKey(), ".").build();
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(settings, clusterSettings);
+        indexPath = new RemoteIndexPath(
+            "djjsid73he8yd7usduh",
+            2,
+            new BlobPath().add("djsd878ndjh").add("hcs87cj8"),
+            PathType.HASHED_PREFIX,
+            PathHashAlgorithm.FNV_1A_BASE64,
+            RemoteIndexPath.SEGMENT_PATH,
+            remoteStoreSettings
+        );
+        xContentBuilder = MediaTypeRegistry.contentBuilder(MediaTypeRegistry.JSON);
+        xContentBuilder.startObject();
+        xContentBuilder = indexPath.toXContent(xContentBuilder, ToXContent.EMPTY_PARAMS);
+        xContentBuilder.endObject();
+        expected =
+            "{\"version\":\"1\",\"index_uuid\":\"djjsid73he8yd7usduh\",\"shard_count\":2,\"path_type\":\"HASHED_PREFIX\",\"path_hash_algorithm\":\"FNV_1A_BASE64\",\"path_creation_map\":{\"segments\":[\"data\",\"metadata\",\"lock_files\"]},\"paths\":[\".9BmBinD5HYs/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/segments/data/\",\".ExCNOD8_5ew/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/segments/data/\",\".z8wtf0yr2l4/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/segments/metadata/\",\".VheHVwFlExE/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/segments/metadata/\",\".IgFKbsDeUpQ/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/segments/lock_files/\",\".pA3gy_GZtns/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/segments/lock_files/\"]}";
+        assertEquals(expected, xContentBuilder.toString());
+
     }
 
     /**
@@ -61,7 +88,8 @@ public void testToXContentForTranslogRepoOnly() throws IOException {
             new BlobPath().add("djsd878ndjh").add("hcs87cj8"),
             PathType.HASHED_PREFIX,
             PathHashAlgorithm.FNV_1A_BASE64,
-            RemoteIndexPath.TRANSLOG_PATH
+            RemoteIndexPath.TRANSLOG_PATH,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         XContentBuilder xContentBuilder = MediaTypeRegistry.contentBuilder(MediaTypeRegistry.JSON);
         xContentBuilder.startObject();
@@ -70,6 +98,27 @@ public void testToXContentForTranslogRepoOnly() throws IOException {
         String expected =
             "{\"version\":\"1\",\"index_uuid\":\"djjsid73he8yd7usduh\",\"shard_count\":2,\"path_type\":\"HASHED_PREFIX\",\"path_hash_algorithm\":\"FNV_1A_BASE64\",\"path_creation_map\":{\"translog\":[\"data\",\"metadata\"]},\"paths\":[\"2EaVODaKBck/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/translog/data/\",\"dTS2VqEOUNo/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/translog/data/\",\"PVNKNGonmZw/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/translog/metadata/\",\"NXmt0Y6NjA8/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/translog/metadata/\"]}";
         assertEquals(expected, xContentBuilder.toString());
+
+        // Fixed prefix
+        Settings settings = Settings.builder().put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.getKey(), ".").build();
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(settings, clusterSettings);
+        indexPath = new RemoteIndexPath(
+            "djjsid73he8yd7usduh",
+            2,
+            new BlobPath().add("djsd878ndjh").add("hcs87cj8"),
+            PathType.HASHED_PREFIX,
+            PathHashAlgorithm.FNV_1A_BASE64,
+            RemoteIndexPath.TRANSLOG_PATH,
+            remoteStoreSettings
+        );
+        xContentBuilder = MediaTypeRegistry.contentBuilder(MediaTypeRegistry.JSON);
+        xContentBuilder.startObject();
+        xContentBuilder = indexPath.toXContent(xContentBuilder, ToXContent.EMPTY_PARAMS);
+        xContentBuilder.endObject();
+        expected =
+            "{\"version\":\"1\",\"index_uuid\":\"djjsid73he8yd7usduh\",\"shard_count\":2,\"path_type\":\"HASHED_PREFIX\",\"path_hash_algorithm\":\"FNV_1A_BASE64\",\"path_creation_map\":{\"translog\":[\"data\",\"metadata\"]},\"paths\":[\".2EaVODaKBck/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/translog/data/\",\".dTS2VqEOUNo/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/translog/data/\",\".PVNKNGonmZw/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/0/translog/metadata/\",\".NXmt0Y6NjA8/djsd878ndjh/hcs87cj8/djjsid73he8yd7usduh/1/translog/metadata/\"]}";
+        assertEquals(expected, xContentBuilder.toString());
     }
 
     /**
@@ -85,7 +134,8 @@ public void testToXContentForBothRepos() throws IOException {
             new BlobPath().add("nxf9yv0").add("c3ejoi"),
             PathType.HASHED_PREFIX,
             PathHashAlgorithm.FNV_1A_BASE64,
-            pathCreationMap
+            pathCreationMap,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         XContentBuilder xContentBuilder = MediaTypeRegistry.contentBuilder(MediaTypeRegistry.JSON);
         xContentBuilder.startObject();
@@ -94,9 +144,42 @@ public void testToXContentForBothRepos() throws IOException {
         String expected =
             "{\"version\":\"1\",\"index_uuid\":\"csbdqiu8a7sdnjdks\",\"shard_count\":3,\"path_type\":\"HASHED_PREFIX\",\"path_hash_algorithm\":\"FNV_1A_BASE64\",\"path_creation_map\":{\"translog\":[\"data\",\"metadata\"],\"segments\":[\"data\",\"metadata\",\"lock_files\"]},\"paths\":[\"Cjo0F6kNjYk/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/segments/data/\",\"kpayyhxct1I/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/segments/data/\",\"p2RlgnHeIgc/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/segments/data/\",\"gkPIurBtB1w/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/segments/metadata/\",\"Y4YhlbxAB1c/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/segments/metadata/\",\"HYc8fyVPouI/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/segments/metadata/\",\"igzyZCz1ysI/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/segments/lock_files/\",\"uEluEiYmptk/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/segments/lock_files/\",\"TfAD8f06_7A/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/segments/lock_files/\",\"QqKEpasbEGs/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/translog/data/\",\"sNyoimoe1Bw/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/translog/data/\",\"d4YQtONfq50/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/translog/data/\",\"zLr4UXjK8T4/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/translog/metadata/\",\"_s8i7ZmlXGE/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/translog/metadata/\",\"tvtD3-k5ISg/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/translog/metadata/\"]}";
         assertEquals(expected, xContentBuilder.toString());
+
+        // Fixed prefix
+        Settings settings = Settings.builder()
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.getKey(), ".")
+            .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.getKey(), ".")
+            .build();
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(settings, clusterSettings);
+        indexPath = new RemoteIndexPath(
+            "csbdqiu8a7sdnjdks",
+            3,
+            new BlobPath().add("nxf9yv0").add("c3ejoi"),
+            PathType.HASHED_PREFIX,
+            PathHashAlgorithm.FNV_1A_BASE64,
+            pathCreationMap,
+            remoteStoreSettings
+        );
+        xContentBuilder = MediaTypeRegistry.contentBuilder(MediaTypeRegistry.JSON);
+        xContentBuilder.startObject();
+        xContentBuilder = indexPath.toXContent(xContentBuilder, ToXContent.EMPTY_PARAMS);
+        xContentBuilder.endObject();
+        expected =
+            "{\"version\":\"1\",\"index_uuid\":\"csbdqiu8a7sdnjdks\",\"shard_count\":3,\"path_type\":\"HASHED_PREFIX\",\"path_hash_algorithm\":\"FNV_1A_BASE64\",\"path_creation_map\":{\"translog\":[\"data\",\"metadata\"],\"segments\":[\"data\",\"metadata\",\"lock_files\"]},\"paths\":[\".Cjo0F6kNjYk/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/segments/data/\",\".kpayyhxct1I/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/segments/data/\",\".p2RlgnHeIgc/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/segments/data/\",\".gkPIurBtB1w/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/segments/metadata/\",\".Y4YhlbxAB1c/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/segments/metadata/\",\".HYc8fyVPouI/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/segments/metadata/\",\".igzyZCz1ysI/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/segments/lock_files/\",\".uEluEiYmptk/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/segments/lock_files/\",\".TfAD8f06_7A/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/segments/lock_files/\",\".QqKEpasbEGs/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/translog/data/\",\".sNyoimoe1Bw/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/translog/data/\",\".d4YQtONfq50/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/translog/data/\",\".zLr4UXjK8T4/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/0/translog/metadata/\",\"._s8i7ZmlXGE/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/1/translog/metadata/\",\".tvtD3-k5ISg/nxf9yv0/c3ejoi/csbdqiu8a7sdnjdks/2/translog/metadata/\"]}";
+        assertEquals(expected, xContentBuilder.toString());
     }
 
-    public void testRemoteIndexPathWithInvalidPathCreationMap() throws IOException {
+    public void testRemoteIndexPathWithInvalidPathCreationMap() {
+        Settings.Builder builder = Settings.builder();
+        if (randomBoolean()) {
+            builder.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.getKey(), ".");
+        }
+        if (randomBoolean()) {
+            builder.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.getKey(), ".");
+        }
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(builder.build(), clusterSettings);
         IllegalArgumentException ex = assertThrows(
             IllegalArgumentException.class,
             () -> new RemoteIndexPath(
@@ -105,7 +188,8 @@ public void testRemoteIndexPathWithInvalidPathCreationMap() throws IOException {
                 new BlobPath().add("djsd878ndjh").add("hcs87cj8"),
                 PathType.HASHED_PREFIX,
                 PathHashAlgorithm.FNV_1A_BASE64,
-                new HashMap<>()
+                new HashMap<>(),
+                remoteStoreSettings
             )
         );
         assertEquals(
@@ -124,6 +208,15 @@ public void testFromXContent() {
     }
 
     public void testInvalidPathCreationMap() {
+        Settings.Builder builder = Settings.builder();
+        if (randomBoolean()) {
+            builder.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.getKey(), ".");
+        }
+        if (randomBoolean()) {
+            builder.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.getKey(), ".");
+        }
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(builder.build(), clusterSettings);
         IllegalArgumentException ex = assertThrows(
             IllegalArgumentException.class,
             () -> new RemoteIndexPath(
@@ -132,7 +225,8 @@ public void testInvalidPathCreationMap() {
                 new BlobPath().add("djsd878ndjh").add("hcs87cj8"),
                 PathType.HASHED_PREFIX,
                 PathHashAlgorithm.FNV_1A_BASE64,
-                Map.of(TRANSLOG, List.of(LOCK_FILES))
+                Map.of(TRANSLOG, List.of(LOCK_FILES)),
+                remoteStoreSettings
             )
         );
         assertEquals("pathCreationMap={TRANSLOG=[LOCK_FILES]} is having illegal combination of category and type", ex.getMessage());
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteIndexPathUploaderTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteIndexPathUploaderTests.java
index e539b382a5f3b..d6519d9db8ee6 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteIndexPathUploaderTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteIndexPathUploaderTests.java
@@ -22,9 +22,10 @@
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.gateway.remote.RemoteClusterStateService;
-import org.opensearch.gateway.remote.RemoteClusterStateService.RemoteStateTransferException;
+import org.opensearch.gateway.remote.RemoteStateTransferException;
 import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.indices.DefaultRemoteStoreSettings;
 import org.opensearch.node.Node;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
 import org.opensearch.repositories.RepositoriesService;
@@ -46,6 +47,7 @@
 
 import org.mockito.Mockito;
 
+import static org.opensearch.gateway.remote.RemoteGlobalMetadataManager.GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING;
 import static org.opensearch.index.remote.RemoteStoreEnums.PathType.FIXED;
 import static org.opensearch.index.remote.RemoteStoreEnums.PathType.HASHED_INFIX;
 import static org.opensearch.index.remote.RemoteStoreEnums.PathType.HASHED_PREFIX;
@@ -130,7 +132,8 @@ public void testInterceptWithNoRemoteDataAttributes() {
             threadPool,
             settings,
             () -> repositoriesService,
-            clusterSettings
+            clusterSettings,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         List<IndexMetadata> indexMetadataList = Mockito.<List>mock(List.class);
         ActionListener<Void> actionListener = ActionListener.wrap(
@@ -148,7 +151,8 @@ public void testInterceptWithEmptyIndexMetadataList() {
             threadPool,
             settings,
             () -> repositoriesService,
-            clusterSettings
+            clusterSettings,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         remoteIndexPathUploader.start();
         ActionListener<Void> actionListener = ActionListener.wrap(
@@ -165,7 +169,8 @@ public void testInterceptWithEmptyEligibleIndexMetadataList() {
             threadPool,
             settings,
             () -> repositoriesService,
-            clusterSettings
+            clusterSettings,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         remoteIndexPathUploader.start();
         ActionListener<Void> actionListener = ActionListener.wrap(
@@ -227,7 +232,8 @@ public void testInterceptWithSameRepo() throws IOException {
             threadPool,
             settings,
             () -> repositoriesService,
-            clusterSettings
+            clusterSettings,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         remoteIndexPathUploader.start();
         ActionListener<Void> actionListener = ActionListener.wrap(
@@ -250,7 +256,8 @@ public void testInterceptWithDifferentRepo() throws IOException {
             threadPool,
             settings,
             () -> repositoriesService,
-            clusterSettings
+            clusterSettings,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         remoteIndexPathUploader.start();
         ActionListener<Void> actionListener = ActionListener.wrap(
@@ -270,13 +277,14 @@ public void testInterceptWithLatchAwaitTimeout() throws IOException {
             threadPool,
             settings,
             () -> repositoriesService,
-            clusterSettings
+            clusterSettings,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         remoteIndexPathUploader.start();
 
         Settings settings = Settings.builder()
             .put(this.settings)
-            .put(RemoteClusterStateService.INDEX_METADATA_UPLOAD_TIMEOUT_SETTING.getKey(), TimeValue.ZERO)
+            .put(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING.getKey(), TimeValue.ZERO)
             .build();
         clusterSettings.applySettings(settings);
         SetOnce<Exception> exceptionSetOnce = new SetOnce<>();
@@ -301,12 +309,13 @@ public void testInterceptWithInterruptedExceptionDuringLatchAwait() throws Excep
             threadPool,
             settings,
             () -> repositoriesService,
-            clusterSettings
+            clusterSettings,
+            DefaultRemoteStoreSettings.INSTANCE
         );
         remoteIndexPathUploader.start();
         Settings settings = Settings.builder()
             .put(this.settings)
-            .put(RemoteClusterStateService.INDEX_METADATA_UPLOAD_TIMEOUT_SETTING.getKey(), TimeValue.timeValueSeconds(1))
+            .put(GLOBAL_METADATA_UPLOAD_TIMEOUT_SETTING.getKey(), TimeValue.timeValueSeconds(1))
             .build();
         clusterSettings.applySettings(settings);
         SetOnce<Exception> exceptionSetOnce = new SetOnce<>();
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteSegmentTransferTrackerTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteSegmentTransferTrackerTests.java
index ccdd1fe4ab609..f4101cb054687 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteSegmentTransferTrackerTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteSegmentTransferTrackerTests.java
@@ -15,6 +15,7 @@
 import org.opensearch.core.common.io.stream.StreamInput;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.store.DirectoryFileTransferTracker;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -42,7 +43,7 @@ public class RemoteSegmentTransferTrackerTests extends OpenSearchTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("remote_refresh_segment_pressure_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
@@ -151,15 +152,18 @@ public void testComputeTimeLagOnUpdate() throws InterruptedException {
         transferTracker.updateLocalRefreshTimeMs(currentTimeMsUsingSystemNanos());
 
         transferTracker.updateLatestLocalFileNameLengthMap(List.of("test"), k -> 1L);
-        // Sleep for 100ms and then the lag should be within 100ms +/- 20ms
-        Thread.sleep(100);
-        assertTrue(Math.abs(transferTracker.getTimeMsLag() - 100) <= 20);
+        // Sleep for 100ms and then the lag should not be shorter
+        long span = 100;
+        Thread.sleep(span);
+        long lag = transferTracker.getTimeMsLag();
+        assertTrue("Actual lag [" + lag + "ms] is not expected to be shorter than span [" + span + "ms]", lag >= span);
 
         transferTracker.updateRemoteRefreshTimeMs(transferTracker.getLocalRefreshTimeMs());
         transferTracker.updateLocalRefreshTimeMs(currentTimeMsUsingSystemNanos());
-        long random = randomIntBetween(50, 200);
-        Thread.sleep(random);
-        assertTrue(Math.abs(transferTracker.getTimeMsLag() - random) <= 20);
+        long randomSpan = randomIntBetween(50, 200);
+        Thread.sleep(randomSpan);
+        lag = transferTracker.getTimeMsLag();
+        assertTrue("Actual lag [" + lag + "ms] is not expected to be shorter than span [" + randomSpan + "ms]", lag >= randomSpan);
     }
 
     public void testAddUploadBytesStarted() {
@@ -570,13 +574,9 @@ public void testStatsObjectCreationViaStream() throws IOException {
                 assertEquals((int) deserializedStats.uploadBytesStarted, (int) transferTrackerStats.uploadBytesStarted);
                 assertEquals((int) deserializedStats.uploadBytesSucceeded, (int) transferTrackerStats.uploadBytesSucceeded);
                 assertEquals((int) deserializedStats.uploadBytesFailed, (int) transferTrackerStats.uploadBytesFailed);
-                assertEquals((int) deserializedStats.uploadBytesMovingAverage, transferTrackerStats.uploadBytesMovingAverage, 0);
-                assertEquals(
-                    (int) deserializedStats.uploadBytesPerSecMovingAverage,
-                    transferTrackerStats.uploadBytesPerSecMovingAverage,
-                    0
-                );
-                assertEquals((int) deserializedStats.uploadTimeMovingAverage, transferTrackerStats.uploadTimeMovingAverage, 0);
+                assertEquals(deserializedStats.uploadBytesMovingAverage, transferTrackerStats.uploadBytesMovingAverage, 0);
+                assertEquals(deserializedStats.uploadBytesPerSecMovingAverage, transferTrackerStats.uploadBytesPerSecMovingAverage, 0);
+                assertEquals(deserializedStats.uploadTimeMovingAverage, transferTrackerStats.uploadTimeMovingAverage, 0);
                 assertEquals((int) deserializedStats.totalUploadsStarted, (int) transferTrackerStats.totalUploadsStarted);
                 assertEquals((int) deserializedStats.totalUploadsSucceeded, (int) transferTrackerStats.totalUploadsSucceeded);
                 assertEquals((int) deserializedStats.totalUploadsFailed, (int) transferTrackerStats.totalUploadsFailed);
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStoreCustomMetadataResolverTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStoreCustomMetadataResolverTests.java
index 7e702ad3773e8..331ebd0e3fcd4 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStoreCustomMetadataResolverTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStoreCustomMetadataResolverTests.java
@@ -187,7 +187,7 @@ public void testTranslogMetadataAllowedTrueWithMinVersionNewer() {
         when(blobStoreMock.isBlobMetadataEnabled()).thenReturn(true);
         RemoteStoreCustomMetadataResolver resolver = new RemoteStoreCustomMetadataResolver(
             remoteStoreSettings,
-            () -> Version.CURRENT,
+            () -> Version.V_2_15_0,
             () -> repositoriesService,
             settings
         );
@@ -200,7 +200,7 @@ public void testTranslogMetadataAllowedFalseWithMinVersionNewer() {
         RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(settings, clusterSettings);
         RemoteStoreCustomMetadataResolver resolver = new RemoteStoreCustomMetadataResolver(
             remoteStoreSettings,
-            () -> Version.CURRENT,
+            () -> Version.V_2_15_0,
             () -> repositoriesService,
             settings
         );
@@ -220,4 +220,50 @@ public void testTranslogMetadataAllowedMinVersionOlder() {
         assertFalse(resolver.isTranslogMetadataEnabled());
     }
 
+    public void testTranslogPathFixedPathSetting() {
+
+        // Default settings
+        Settings settings = Settings.builder().build();
+        ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(settings, clusterSettings);
+        assertEquals("", remoteStoreSettings.getTranslogPathFixedPrefix());
+
+        // Any other random value
+        String randomPrefix = randomAlphaOfLengthBetween(2, 5);
+        settings = Settings.builder().put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.getKey(), randomPrefix).build();
+        remoteStoreSettings = new RemoteStoreSettings(settings, clusterSettings);
+        assertEquals(randomPrefix, remoteStoreSettings.getTranslogPathFixedPrefix());
+
+        // Set any other random value, the setting still points to the old value
+        clusterSettings.applySettings(
+            Settings.builder()
+                .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.getKey(), randomAlphaOfLengthBetween(2, 5))
+                .build()
+        );
+        assertEquals(randomPrefix, remoteStoreSettings.getTranslogPathFixedPrefix());
+    }
+
+    public void testSegmentsPathFixedPathSetting() {
+
+        // Default settings
+        Settings settings = Settings.builder().build();
+        ClusterSettings clusterSettings = new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(settings, clusterSettings);
+        assertEquals("", remoteStoreSettings.getSegmentsPathFixedPrefix());
+
+        // Any other random value
+        String randomPrefix = randomAlphaOfLengthBetween(2, 5);
+        settings = Settings.builder().put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.getKey(), randomPrefix).build();
+        remoteStoreSettings = new RemoteStoreSettings(settings, clusterSettings);
+        assertEquals(randomPrefix, remoteStoreSettings.getSegmentsPathFixedPrefix());
+
+        // Set any other random value, the setting still points to the old value
+        clusterSettings.applySettings(
+            Settings.builder()
+                .put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.getKey(), randomAlphaOfLengthBetween(2, 5))
+                .build()
+        );
+        assertEquals(randomPrefix, remoteStoreSettings.getSegmentsPathFixedPrefix());
+
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStoreEnumsTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStoreEnumsTests.java
index 575b397382f24..6bae163533404 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStoreEnumsTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStoreEnumsTests.java
@@ -14,6 +14,7 @@
 import org.opensearch.index.remote.RemoteStoreEnums.DataType;
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.remote.RemoteStorePathStrategy.PathInput;
+import org.opensearch.index.remote.RemoteStorePathStrategy.SnapshotShardPathInput;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.ArrayList;
@@ -92,17 +93,6 @@ public void testGeneratePathForFixedType() {
         result = FIXED.path(pathInput, null);
         assertEquals(basePath + dataCategory.getName() + SEPARATOR + dataType.getName() + SEPARATOR, result.buildAsString());
 
-        // Translog Lock files - This is a negative case where the assertion will trip.
-        dataType = LOCK_FILES;
-        PathInput finalPathInput = PathInput.builder()
-            .basePath(blobPath)
-            .indexUUID(indexUUID)
-            .shardId(shardId)
-            .dataCategory(dataCategory)
-            .dataType(dataType)
-            .build();
-        assertThrows(AssertionError.class, () -> FIXED.path(finalPathInput, null));
-
         // Segment Data
         dataCategory = SEGMENTS;
         dataType = DATA;
@@ -152,6 +142,7 @@ public void testGeneratePathForHashedPrefixType() {
         String shardId = String.valueOf(randomInt(100));
         DataCategory dataCategory = TRANSLOG;
         DataType dataType = DATA;
+        String fixedPrefix = ".";
 
         String basePath = getPath(pathList) + indexUUID + SEPARATOR + shardId;
         // Translog Data
@@ -161,11 +152,20 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         BlobPath result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
         assertTrue(
             result.buildAsString()
-                .startsWith(String.join(SEPARATOR, FNV_1A_BASE64.hash(pathInput), basePath, dataCategory.getName(), dataType.getName()))
+                .startsWith(
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_BASE64.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
+                )
         );
 
         // assert with exact value for known base path
@@ -178,9 +178,10 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
-        assertEquals("DgSI70IciXs/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/translog/data/", result.buildAsString());
+        assertEquals(".DgSI70IciXs/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/translog/data/", result.buildAsString());
 
         // Translog Metadata
         dataType = METADATA;
@@ -190,11 +191,20 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
         assertTrue(
             result.buildAsString()
-                .startsWith(String.join(SEPARATOR, FNV_1A_BASE64.hash(pathInput), basePath, dataCategory.getName(), dataType.getName()))
+                .startsWith(
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_BASE64.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
+                )
         );
 
         // assert with exact value for known base path
@@ -204,30 +214,10 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
-        assertEquals("oKU5SjILiy4/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/translog/metadata/", result.buildAsString());
-
-        // Translog Lock files - This is a negative case where the assertion will trip.
-        dataType = LOCK_FILES;
-        PathInput finalPathInput = PathInput.builder()
-            .basePath(blobPath)
-            .indexUUID(indexUUID)
-            .shardId(shardId)
-            .dataCategory(dataCategory)
-            .dataType(dataType)
-            .build();
-        assertThrows(AssertionError.class, () -> HASHED_PREFIX.path(finalPathInput, null));
-
-        // assert with exact value for known base path
-        pathInput = PathInput.builder()
-            .basePath(fixedBlobPath)
-            .indexUUID(fixedIndexUUID)
-            .shardId(fixedShardId)
-            .dataCategory(dataCategory)
-            .dataType(dataType)
-            .build();
-        assertThrows(AssertionError.class, () -> HASHED_PREFIX.path(finalPathInput, null));
+        assertEquals(".oKU5SjILiy4/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/translog/metadata/", result.buildAsString());
 
         // Segment Data
         dataCategory = SEGMENTS;
@@ -238,11 +228,20 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
         assertTrue(
             result.buildAsString()
-                .startsWith(String.join(SEPARATOR, FNV_1A_BASE64.hash(pathInput), basePath, dataCategory.getName(), dataType.getName()))
+                .startsWith(
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_BASE64.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
+                )
         );
 
         // assert with exact value for known base path
@@ -252,9 +251,10 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
-        assertEquals("AUBRfCIuWdk/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/data/", result.buildAsString());
+        assertEquals(".AUBRfCIuWdk/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/data/", result.buildAsString());
 
         // Segment Metadata
         dataType = METADATA;
@@ -264,11 +264,20 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
         assertTrue(
             result.buildAsString()
-                .startsWith(String.join(SEPARATOR, FNV_1A_BASE64.hash(pathInput), basePath, dataCategory.getName(), dataType.getName()))
+                .startsWith(
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_BASE64.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
+                )
         );
 
         // assert with exact value for known base path
@@ -278,9 +287,10 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
-        assertEquals("erwR-G735Uw/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/metadata/", result.buildAsString());
+        assertEquals(".erwR-G735Uw/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/metadata/", result.buildAsString());
 
         // Segment Lockfiles
         dataType = LOCK_FILES;
@@ -290,11 +300,20 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
         assertTrue(
             result.buildAsString()
-                .startsWith(String.join(SEPARATOR, FNV_1A_BASE64.hash(pathInput), basePath, dataCategory.getName(), dataType.getName()))
+                .startsWith(
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_BASE64.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
+                )
         );
 
         // assert with exact value for known base path
@@ -304,12 +323,14 @@ public void testGeneratePathForHashedPrefixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
-        assertEquals("KeYDIk0mJXI/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/lock_files/", result.buildAsString());
+        assertEquals(".KeYDIk0mJXI/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/lock_files/", result.buildAsString());
     }
 
     public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
+        String fixedPrefix = ".";
         BlobPath blobPath = new BlobPath();
         List<String> pathList = getPathList();
         for (String path : pathList) {
@@ -329,12 +350,19 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         BlobPath result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         assertTrue(
             result.buildAsString()
                 .startsWith(
-                    String.join(SEPARATOR, FNV_1A_COMPOSITE_1.hash(pathInput), basePath, dataCategory.getName(), dataType.getName())
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_COMPOSITE_1.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
                 )
         );
 
@@ -348,9 +376,10 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
-        assertEquals("D10000001001000/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/translog/data/", result.buildAsString());
+        assertEquals(".D10000001001000/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/translog/data/", result.buildAsString());
 
         // Translog Metadata
         dataType = METADATA;
@@ -360,12 +389,19 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         assertTrue(
             result.buildAsString()
                 .startsWith(
-                    String.join(SEPARATOR, FNV_1A_COMPOSITE_1.hash(pathInput), basePath, dataCategory.getName(), dataType.getName())
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_COMPOSITE_1.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
                 )
         );
 
@@ -376,34 +412,14 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         assertEquals(
-            "o00101001010011/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/translog/metadata/",
+            ".o00101001010011/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/translog/metadata/",
             result.buildAsString()
         );
 
-        // Translog Lock files - This is a negative case where the assertion will trip.
-        dataType = LOCK_FILES;
-        PathInput finalPathInput = PathInput.builder()
-            .basePath(blobPath)
-            .indexUUID(indexUUID)
-            .shardId(shardId)
-            .dataCategory(dataCategory)
-            .dataType(dataType)
-            .build();
-        assertThrows(AssertionError.class, () -> HASHED_PREFIX.path(finalPathInput, null));
-
-        // assert with exact value for known base path
-        pathInput = PathInput.builder()
-            .basePath(fixedBlobPath)
-            .indexUUID(fixedIndexUUID)
-            .shardId(fixedShardId)
-            .dataCategory(dataCategory)
-            .dataType(dataType)
-            .build();
-        assertThrows(AssertionError.class, () -> HASHED_PREFIX.path(finalPathInput, null));
-
         // Segment Data
         dataCategory = SEGMENTS;
         dataType = DATA;
@@ -413,12 +429,19 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         assertTrue(
             result.buildAsString()
                 .startsWith(
-                    String.join(SEPARATOR, FNV_1A_COMPOSITE_1.hash(pathInput), basePath, dataCategory.getName(), dataType.getName())
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_COMPOSITE_1.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
                 )
         );
 
@@ -429,9 +452,10 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
-        assertEquals("A01010000000101/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/data/", result.buildAsString());
+        assertEquals(".A01010000000101/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/data/", result.buildAsString());
 
         // Segment Metadata
         dataType = METADATA;
@@ -441,12 +465,19 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         assertTrue(
             result.buildAsString()
                 .startsWith(
-                    String.join(SEPARATOR, FNV_1A_COMPOSITE_1.hash(pathInput), basePath, dataCategory.getName(), dataType.getName())
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_COMPOSITE_1.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
                 )
         );
 
@@ -457,10 +488,11 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         assertEquals(
-            "e10101111000001/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/metadata/",
+            ".e10101111000001/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/metadata/",
             result.buildAsString()
         );
 
@@ -472,12 +504,19 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         assertTrue(
             result.buildAsString()
                 .startsWith(
-                    String.join(SEPARATOR, FNV_1A_COMPOSITE_1.hash(pathInput), basePath, dataCategory.getName(), dataType.getName())
+                    String.join(
+                        SEPARATOR,
+                        fixedPrefix + FNV_1A_COMPOSITE_1.hash(pathInput),
+                        basePath,
+                        dataCategory.getName(),
+                        dataType.getName()
+                    )
                 )
         );
 
@@ -488,10 +527,11 @@ public void testGeneratePathForHashedPrefixTypeAndFNVCompositeHashAlgorithm() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
         assertEquals(
-            "K01111001100000/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/lock_files/",
+            ".K01111001100000/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/k2ijhe877d7yuhx7/10/segments/lock_files/",
             result.buildAsString()
         );
     }
@@ -507,9 +547,10 @@ public void testGeneratePathForHashedInfixType() {
         String shardId = String.valueOf(randomInt(100));
         DataCategory dataCategory = TRANSLOG;
         DataType dataType = DATA;
+        String fixedPrefix = ".";
 
         String basePath = getPath(pathList);
-        basePath = basePath.length() == 0 ? basePath : basePath.substring(0, basePath.length() - 1);
+        basePath = basePath.isEmpty() ? basePath : basePath.substring(0, basePath.length() - 1);
         // Translog Data
         PathInput pathInput = PathInput.builder()
             .basePath(blobPath)
@@ -517,9 +558,10 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         BlobPath result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        String expected = derivePath(basePath, pathInput);
+        String expected = derivePath(basePath, pathInput, fixedPrefix);
         String actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
@@ -533,9 +575,10 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/DgSI70IciXs/k2ijhe877d7yuhx7/10/translog/data/";
+        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/.DgSI70IciXs/k2ijhe877d7yuhx7/10/translog/data/";
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
@@ -547,10 +590,11 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
 
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = derivePath(basePath, pathInput);
+        expected = derivePath(basePath, pathInput, fixedPrefix);
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
@@ -561,33 +605,13 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/oKU5SjILiy4/k2ijhe877d7yuhx7/10/translog/metadata/";
+        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/.oKU5SjILiy4/k2ijhe877d7yuhx7/10/translog/metadata/";
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
-        // Translog Lock files - This is a negative case where the assertion will trip.
-        dataType = LOCK_FILES;
-        PathInput finalPathInput = PathInput.builder()
-            .basePath(blobPath)
-            .indexUUID(indexUUID)
-            .shardId(shardId)
-            .dataCategory(dataCategory)
-            .dataType(dataType)
-            .build();
-        assertThrows(AssertionError.class, () -> HASHED_INFIX.path(finalPathInput, null));
-
-        // assert with exact value for known base path
-        pathInput = PathInput.builder()
-            .basePath(fixedBlobPath)
-            .indexUUID(fixedIndexUUID)
-            .shardId(fixedShardId)
-            .dataCategory(dataCategory)
-            .dataType(dataType)
-            .build();
-        assertThrows(AssertionError.class, () -> HASHED_INFIX.path(finalPathInput, null));
-
         // Segment Data
         dataCategory = SEGMENTS;
         dataType = DATA;
@@ -597,9 +621,10 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = derivePath(basePath, pathInput);
+        expected = derivePath(basePath, pathInput, fixedPrefix);
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
@@ -610,9 +635,10 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/AUBRfCIuWdk/k2ijhe877d7yuhx7/10/segments/data/";
+        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/.AUBRfCIuWdk/k2ijhe877d7yuhx7/10/segments/data/";
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
@@ -624,9 +650,10 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = derivePath(basePath, pathInput);
+        expected = derivePath(basePath, pathInput, fixedPrefix);
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
@@ -637,9 +664,10 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/erwR-G735Uw/k2ijhe877d7yuhx7/10/segments/metadata/";
+        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/.erwR-G735Uw/k2ijhe877d7yuhx7/10/segments/metadata/";
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
@@ -651,9 +679,10 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = derivePath(basePath, pathInput);
+        expected = derivePath(basePath, pathInput, fixedPrefix);
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
 
@@ -664,18 +693,62 @@ public void testGeneratePathForHashedInfixType() {
             .shardId(fixedShardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
-        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/KeYDIk0mJXI/k2ijhe877d7yuhx7/10/segments/lock_files/";
+        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/.KeYDIk0mJXI/k2ijhe877d7yuhx7/10/segments/lock_files/";
         actual = result.buildAsString();
         assertTrue(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual.startsWith(expected));
     }
 
-    private String derivePath(String basePath, PathInput pathInput) {
+    public void testGeneratePathForSnapshotShardPathInput() {
+        String fixedPrefix = "snap";
+        BlobPath blobPath = BlobPath.cleanPath().add("xjsdhj").add("ddjsha").add("yudy7sd").add("32hdhua7").add("89jdij");
+        String indexUUID = "dsdkjsu8832njn";
+        String shardId = "10";
+        SnapshotShardPathInput pathInput = SnapshotShardPathInput.builder()
+            .basePath(blobPath)
+            .indexUUID(indexUUID)
+            .shardId(shardId)
+            .fixedPrefix(fixedPrefix)
+            .build();
+
+        // FIXED PATH
+        BlobPath result = FIXED.path(pathInput, null);
+        String expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/indices/dsdkjsu8832njn/10/";
+        String actual = result.buildAsString();
+        assertEquals(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual, expected);
+
+        // HASHED_PREFIX - FNV_1A_COMPOSITE_1
+        result = HASHED_PREFIX.path(pathInput, FNV_1A_COMPOSITE_1);
+        expected = "snap_11001000010110/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/indices/dsdkjsu8832njn/10/";
+        actual = result.buildAsString();
+        assertEquals(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual, expected);
+
+        // HASHED_PREFIX - FNV_1A_BASE64
+        result = HASHED_PREFIX.path(pathInput, FNV_1A_BASE64);
+        expected = "snap_yFiSl_VGGM/xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/indices/dsdkjsu8832njn/10/";
+        actual = result.buildAsString();
+        assertEquals(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual, expected);
+
+        // HASHED_INFIX - FNV_1A_COMPOSITE_1
+        result = HASHED_INFIX.path(pathInput, FNV_1A_COMPOSITE_1);
+        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/snap_11001000010110/indices/dsdkjsu8832njn/10/";
+        actual = result.buildAsString();
+        assertEquals(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual, expected);
+
+        // HASHED_INFIX - FNV_1A_BASE64
+        result = HASHED_INFIX.path(pathInput, FNV_1A_BASE64);
+        expected = "xjsdhj/ddjsha/yudy7sd/32hdhua7/89jdij/snap_yFiSl_VGGM/indices/dsdkjsu8832njn/10/";
+        actual = result.buildAsString();
+        assertEquals(new ParameterizedMessage("expected={} actual={}", expected, actual).getFormattedMessage(), actual, expected);
+    }
+
+    private String derivePath(String basePath, PathInput pathInput, String fixedPrefix) {
         return "".equals(basePath)
             ? String.join(
                 SEPARATOR,
-                FNV_1A_BASE64.hash(pathInput),
+                fixedPrefix + FNV_1A_BASE64.hash(pathInput),
                 pathInput.indexUUID(),
                 pathInput.shardId(),
                 pathInput.dataCategory().getName(),
@@ -684,7 +757,7 @@ private String derivePath(String basePath, PathInput pathInput) {
             : String.join(
                 SEPARATOR,
                 basePath,
-                FNV_1A_BASE64.hash(pathInput),
+                fixedPrefix + FNV_1A_BASE64.hash(pathInput),
                 pathInput.indexUUID(),
                 pathInput.shardId(),
                 pathInput.dataCategory().getName(),
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStorePathStrategyTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStorePathStrategyTests.java
new file mode 100644
index 0000000000000..e4c64e16fb5be
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStorePathStrategyTests.java
@@ -0,0 +1,127 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.remote;
+
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.TRANSLOG;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.DATA;
+import static org.opensearch.index.remote.RemoteStoreEnums.DataType.LOCK_FILES;
+
+public class RemoteStorePathStrategyTests extends OpenSearchTestCase {
+
+    private static final BlobPath BASE_PATH = BlobPath.cleanPath().add("base-path");
+    private static final String INDEX_UUID = "indexUUID";
+    private static final String SHARD_ID = "shardId";
+
+    public void testBasePathInput() {
+        assertThrows(NullPointerException.class, () -> RemoteStorePathStrategy.BasePathInput.builder().build());
+        assertThrows(NullPointerException.class, () -> RemoteStorePathStrategy.BasePathInput.builder().basePath(BASE_PATH).build());
+        assertThrows(NullPointerException.class, () -> RemoteStorePathStrategy.BasePathInput.builder().indexUUID(INDEX_UUID).build());
+        RemoteStorePathStrategy.BasePathInput input = RemoteStorePathStrategy.BasePathInput.builder()
+            .basePath(BASE_PATH)
+            .indexUUID(INDEX_UUID)
+            .build();
+        assertEquals(BASE_PATH, input.basePath());
+        assertEquals(INDEX_UUID, input.indexUUID());
+    }
+
+    public void testPathInput() {
+        assertThrows(NullPointerException.class, () -> RemoteStorePathStrategy.PathInput.builder().build());
+        assertThrows(NullPointerException.class, () -> RemoteStorePathStrategy.PathInput.builder().shardId(SHARD_ID).build());
+        assertThrows(
+            NullPointerException.class,
+            () -> RemoteStorePathStrategy.PathInput.builder().shardId(SHARD_ID).dataCategory(TRANSLOG).build()
+        );
+
+        // Translog Lock files - This is a negative case where the assertion will trip.
+        assertThrows(
+            AssertionError.class,
+            () -> RemoteStorePathStrategy.PathInput.builder()
+                .basePath(BASE_PATH)
+                .indexUUID(INDEX_UUID)
+                .shardId(SHARD_ID)
+                .dataCategory(TRANSLOG)
+                .dataType(LOCK_FILES)
+                .build()
+        );
+
+        RemoteStorePathStrategy.PathInput input = RemoteStorePathStrategy.PathInput.builder()
+            .basePath(BASE_PATH)
+            .indexUUID(INDEX_UUID)
+            .shardId(SHARD_ID)
+            .dataCategory(TRANSLOG)
+            .dataType(DATA)
+            .build();
+        assertEquals(BASE_PATH, input.basePath());
+        assertEquals(INDEX_UUID, input.indexUUID());
+        assertEquals(SHARD_ID, input.shardId());
+        assertEquals(DATA, input.dataType());
+        assertEquals(TRANSLOG, input.dataCategory());
+    }
+
+    public void testFixedSubPath() {
+        RemoteStorePathStrategy.BasePathInput input = RemoteStorePathStrategy.BasePathInput.builder()
+            .basePath(BASE_PATH)
+            .indexUUID(INDEX_UUID)
+            .build();
+        assertEquals(BlobPath.cleanPath().add(INDEX_UUID), input.fixedSubPath());
+
+        RemoteStorePathStrategy.PathInput input2 = RemoteStorePathStrategy.PathInput.builder()
+            .basePath(BASE_PATH)
+            .indexUUID(INDEX_UUID)
+            .shardId(SHARD_ID)
+            .dataCategory(TRANSLOG)
+            .dataType(DATA)
+            .build();
+        assertEquals(BlobPath.cleanPath().add(INDEX_UUID).add(SHARD_ID).add(TRANSLOG.getName()).add(DATA.getName()), input2.fixedSubPath());
+    }
+
+    public void testSnapshotShardPathInput() {
+        assertThrows(NullPointerException.class, () -> RemoteStorePathStrategy.SnapshotShardPathInput.builder().build());
+        assertThrows(
+            NullPointerException.class,
+            () -> RemoteStorePathStrategy.SnapshotShardPathInput.builder().basePath(BASE_PATH).build()
+        );
+        assertThrows(
+            NullPointerException.class,
+            () -> RemoteStorePathStrategy.SnapshotShardPathInput.builder().indexUUID(INDEX_UUID).build()
+        );
+        assertThrows(NullPointerException.class, () -> RemoteStorePathStrategy.SnapshotShardPathInput.builder().shardId(SHARD_ID).build());
+
+        RemoteStorePathStrategy.SnapshotShardPathInput input = RemoteStorePathStrategy.SnapshotShardPathInput.builder()
+            .basePath(BASE_PATH)
+            .indexUUID(INDEX_UUID)
+            .shardId(SHARD_ID)
+            .build();
+        assertEquals(BASE_PATH, input.basePath());
+        assertEquals(INDEX_UUID, input.indexUUID());
+        assertEquals(SHARD_ID, input.shardId());
+    }
+
+    public void testSnapshotShardPathInputFixedSubPath() {
+        RemoteStorePathStrategy.SnapshotShardPathInput input = RemoteStorePathStrategy.SnapshotShardPathInput.builder()
+            .basePath(BASE_PATH)
+            .indexUUID(INDEX_UUID)
+            .shardId(SHARD_ID)
+            .build();
+        assertEquals(BlobPath.cleanPath().add("indices").add(INDEX_UUID).add(SHARD_ID), input.fixedSubPath());
+    }
+
+    public void testSnapshotShardPathInputHashPath() {
+        RemoteStorePathStrategy.SnapshotShardPathInput input = RemoteStorePathStrategy.SnapshotShardPathInput.builder()
+            .basePath(BASE_PATH)
+            .indexUUID(INDEX_UUID)
+            .shardId(SHARD_ID)
+            .build();
+        assertEquals(BlobPath.cleanPath().add(SHARD_ID).add(INDEX_UUID), input.hashPath());
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStorePressureServiceTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStorePressureServiceTests.java
index 9d00cf9f2be46..18d18f2dc30b1 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStorePressureServiceTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStorePressureServiceTests.java
@@ -14,6 +14,7 @@
 import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -45,7 +46,7 @@ public class RemoteStorePressureServiceTests extends OpenSearchTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("remote_refresh_segment_pressure_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStorePressureSettingsTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStorePressureSettingsTests.java
index 064c6c10eba02..7c1ef0de91887 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStorePressureSettingsTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStorePressureSettingsTests.java
@@ -11,6 +11,7 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -27,7 +28,7 @@ public class RemoteStorePressureSettingsTests extends OpenSearchTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("remote_refresh_segment_pressure_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStoreStatsTrackerFactoryTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStoreStatsTrackerFactoryTests.java
index c300f316ac633..2bc4792a9c31c 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStoreStatsTrackerFactoryTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStoreStatsTrackerFactoryTests.java
@@ -13,6 +13,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -39,7 +40,11 @@ public void setUp() throws Exception {
                 RemoteStoreStatsTrackerFactory.Defaults.MOVING_AVERAGE_WINDOW_SIZE_MIN_VALUE
             )
             .build();
-        clusterService = new ClusterService(settings, new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS), threadPool);
+        clusterService = ClusterServiceUtils.createClusterService(
+            settings,
+            new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+            threadPool
+        );
         remoteStoreStatsTrackerFactory = new RemoteStoreStatsTrackerFactory(clusterService, settings);
     }
 
@@ -85,7 +90,11 @@ public void testInvalidMovingAverageWindowSize() {
             "Failed to parse value",
             IllegalArgumentException.class,
             () -> new RemoteStoreStatsTrackerFactory(
-                new ClusterService(settings, new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS), threadPool),
+                ClusterServiceUtils.createClusterService(
+                    settings,
+                    new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                    threadPool
+                ),
                 settings
             )
         );
@@ -107,7 +116,11 @@ public void testUpdateAfterGetConfiguredSettings() {
 
     public void testGetDefaultSettings() {
         remoteStoreStatsTrackerFactory = new RemoteStoreStatsTrackerFactory(
-            new ClusterService(Settings.EMPTY, new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS), threadPool),
+            ClusterServiceUtils.createClusterService(
+                Settings.EMPTY,
+                new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
+                threadPool
+            ),
             Settings.EMPTY
         );
         // Check moving average window size updated
diff --git a/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java b/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
index 59c3d3dccdd0f..2a34dd3580948 100644
--- a/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
+++ b/server/src/test/java/org/opensearch/index/remote/RemoteStoreUtilsTests.java
@@ -9,30 +9,54 @@
 package org.opensearch.index.remote;
 
 import org.opensearch.Version;
+import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.IndexRoutingTable;
+import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.ShardRoutingState;
+import org.opensearch.cluster.routing.TestShardRouting;
+import org.opensearch.common.UUIDs;
 import org.opensearch.common.blobstore.BlobMetadata;
 import org.opensearch.common.blobstore.support.PlainBlobMetadata;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.index.shard.IndexShardTestUtils;
 import org.opensearch.index.store.RemoteSegmentStoreDirectory;
 import org.opensearch.index.translog.transfer.TranslogTransferMetadata;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.math.BigInteger;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
 import java.util.stream.Collectors;
 
 import static org.opensearch.cluster.metadata.IndexMetadata.REMOTE_STORE_CUSTOM_KEY;
+import static org.opensearch.index.remote.RemoteMigrationIndexMetadataUpdaterTests.createIndexMetadataWithDocrepSettings;
 import static org.opensearch.index.remote.RemoteStoreUtils.URL_BASE64_CHARSET;
 import static org.opensearch.index.remote.RemoteStoreUtils.determineTranslogMetadataEnabled;
+import static org.opensearch.index.remote.RemoteStoreUtils.finalizeMigration;
+import static org.opensearch.index.remote.RemoteStoreUtils.isSwitchToStrictCompatibilityMode;
 import static org.opensearch.index.remote.RemoteStoreUtils.longToCompositeBase64AndBinaryEncoding;
 import static org.opensearch.index.remote.RemoteStoreUtils.longToUrlBase64;
 import static org.opensearch.index.remote.RemoteStoreUtils.urlBase64ToLong;
@@ -42,6 +66,11 @@
 import static org.opensearch.index.store.RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX;
 import static org.opensearch.index.store.RemoteSegmentStoreDirectory.MetadataFilenameUtils.SEPARATOR;
 import static org.opensearch.index.translog.transfer.TranslogTransferMetadata.METADATA_SEPARATOR;
+import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
+import static org.opensearch.node.remotestore.RemoteStoreNodeService.REMOTE_STORE_COMPATIBILITY_MODE_SETTING;
 
 public class RemoteStoreUtilsTests extends OpenSearchTestCase {
 
@@ -373,7 +402,7 @@ private static Metadata createIndexMetadataWithRemoteStoreSettings(String indexN
             Settings.builder()
                 .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
                 .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
-                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+                .put(IndexMetadata.SETTING_VERSION_CREATED, Version.V_2_15_0)
                 .put(IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.getKey(), true)
                 .put(IndexMetadata.INDEX_REMOTE_TRANSLOG_REPOSITORY_SETTING.getKey(), "dummy-tlog-repo")
                 .put(IndexMetadata.INDEX_REMOTE_SEGMENT_STORE_REPOSITORY_SETTING.getKey(), "dummy-segment-repo")
@@ -398,4 +427,660 @@ private static Map<String, String> getCustomDataMap(int option) {
         );
     }
 
+    public void testFinalizeMigrationWithAllRemoteNodes() {
+        String migratedIndex = "migrated-index";
+        Settings mockSettings = Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "strict").build();
+        DiscoveryNode remoteNode1 = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            getRemoteStoreNodeAttributes(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        DiscoveryNode remoteNode2 = new DiscoveryNode(
+            UUIDs.base64UUID(),
+            buildNewFakeTransportAddress(),
+            getRemoteStoreNodeAttributes(),
+            DiscoveryNodeRole.BUILT_IN_ROLES,
+            Version.CURRENT
+        );
+        DiscoveryNodes discoveryNodes = DiscoveryNodes.builder()
+            .add(remoteNode1)
+            .localNodeId(remoteNode1.getId())
+            .add(remoteNode2)
+            .localNodeId(remoteNode2.getId())
+            .build();
+        Metadata docrepIdxMetadata = createIndexMetadataWithDocrepSettings(migratedIndex);
+        assertDocrepSettingsApplied(docrepIdxMetadata.index(migratedIndex));
+        Metadata remoteIndexMd = Metadata.builder(docrepIdxMetadata).persistentSettings(mockSettings).build();
+        ClusterState clusterStateWithDocrepIndexSettings = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(remoteIndexMd)
+            .nodes(discoveryNodes)
+            .routingTable(createRoutingTableAllShardsStarted(migratedIndex, 1, 1, remoteNode1, remoteNode2))
+            .build();
+        Metadata mutatedMetadata = finalizeMigration(clusterStateWithDocrepIndexSettings, logger).metadata();
+        assertTrue(mutatedMetadata.index(migratedIndex).getVersion() > docrepIdxMetadata.index(migratedIndex).getVersion());
+        assertRemoteSettingsApplied(mutatedMetadata.index(migratedIndex));
+    }
+
+    public void testFinalizeMigrationWithAllDocrepNodes() {
+        String docrepIndex = "docrep-index";
+        Settings mockSettings = Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "strict").build();
+        DiscoveryNode docrepNode1 = new DiscoveryNode(UUIDs.base64UUID(), buildNewFakeTransportAddress(), Version.CURRENT);
+        DiscoveryNode docrepNode2 = new DiscoveryNode(UUIDs.base64UUID(), buildNewFakeTransportAddress(), Version.CURRENT);
+        DiscoveryNodes discoveryNodes = DiscoveryNodes.builder()
+            .add(docrepNode1)
+            .localNodeId(docrepNode1.getId())
+            .add(docrepNode2)
+            .localNodeId(docrepNode2.getId())
+            .build();
+        Metadata docrepIdxMetadata = createIndexMetadataWithDocrepSettings(docrepIndex);
+        assertDocrepSettingsApplied(docrepIdxMetadata.index(docrepIndex));
+        Metadata remoteIndexMd = Metadata.builder(docrepIdxMetadata).persistentSettings(mockSettings).build();
+        ClusterState clusterStateWithDocrepIndexSettings = ClusterState.builder(ClusterName.DEFAULT)
+            .metadata(remoteIndexMd)
+            .nodes(discoveryNodes)
+            .routingTable(createRoutingTableAllShardsStarted(docrepIndex, 1, 1, docrepNode1, docrepNode2))
+            .build();
+        Metadata mutatedMetadata = finalizeMigration(clusterStateWithDocrepIndexSettings, logger).metadata();
+        assertEquals(docrepIdxMetadata.index(docrepIndex).getVersion(), mutatedMetadata.index(docrepIndex).getVersion());
+        assertDocrepSettingsApplied(mutatedMetadata.index(docrepIndex));
+    }
+
+    public void testIsSwitchToStrictCompatibilityMode() {
+        Settings mockSettings = Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "strict").build();
+        ClusterUpdateSettingsRequest request = new ClusterUpdateSettingsRequest();
+        request.persistentSettings(mockSettings);
+        assertTrue(isSwitchToStrictCompatibilityMode(request));
+
+        mockSettings = Settings.builder().put(REMOTE_STORE_COMPATIBILITY_MODE_SETTING.getKey(), "mixed").build();
+        request.persistentSettings(mockSettings);
+        assertFalse(isSwitchToStrictCompatibilityMode(request));
+    }
+
+    private void assertRemoteSettingsApplied(IndexMetadata indexMetadata) {
+        assertTrue(IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.get(indexMetadata.getSettings()));
+        assertTrue(IndexMetadata.INDEX_REMOTE_TRANSLOG_REPOSITORY_SETTING.exists(indexMetadata.getSettings()));
+        assertTrue(IndexMetadata.INDEX_REMOTE_SEGMENT_STORE_REPOSITORY_SETTING.exists(indexMetadata.getSettings()));
+        assertEquals(ReplicationType.SEGMENT, IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.get(indexMetadata.getSettings()));
+    }
+
+    private void assertDocrepSettingsApplied(IndexMetadata indexMetadata) {
+        assertFalse(IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.get(indexMetadata.getSettings()));
+        assertFalse(IndexMetadata.INDEX_REMOTE_TRANSLOG_REPOSITORY_SETTING.exists(indexMetadata.getSettings()));
+        assertFalse(IndexMetadata.INDEX_REMOTE_SEGMENT_STORE_REPOSITORY_SETTING.exists(indexMetadata.getSettings()));
+        assertEquals(ReplicationType.DOCUMENT, IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.get(indexMetadata.getSettings()));
+    }
+
+    private RoutingTable createRoutingTableAllShardsStarted(
+        String indexName,
+        int numberOfShards,
+        int numberOfReplicas,
+        DiscoveryNode primaryHostingNode,
+        DiscoveryNode replicaHostingNode
+    ) {
+        RoutingTable.Builder builder = RoutingTable.builder();
+        Index index = new Index(indexName, UUID.randomUUID().toString());
+
+        IndexRoutingTable.Builder indexRoutingTableBuilder = IndexRoutingTable.builder(index);
+        for (int i = 0; i < numberOfShards; i++) {
+            ShardId shardId = new ShardId(index, i);
+            IndexShardRoutingTable.Builder indexShardRoutingTable = new IndexShardRoutingTable.Builder(shardId);
+            indexShardRoutingTable.addShard(
+                TestShardRouting.newShardRouting(shardId, primaryHostingNode.getId(), true, ShardRoutingState.STARTED)
+            );
+            for (int j = 0; j < numberOfReplicas; j++) {
+                indexShardRoutingTable.addShard(
+                    TestShardRouting.newShardRouting(shardId, replicaHostingNode.getId(), false, ShardRoutingState.STARTED)
+                );
+            }
+            indexRoutingTableBuilder.addIndexShard(indexShardRoutingTable.build());
+        }
+        return builder.add(indexRoutingTableBuilder.build()).build();
+    }
+
+    private Map<String, String> getRemoteStoreNodeAttributes() {
+        Map<String, String> remoteStoreNodeAttributes = new HashMap<>();
+        remoteStoreNodeAttributes.put(REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-cluster-repo-1");
+        remoteStoreNodeAttributes.put(REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-segment-repo-1");
+        remoteStoreNodeAttributes.put(REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, "my-translog-repo-1");
+        return remoteStoreNodeAttributes;
+    }
+
+    private void setupRemotePinnedTimestampFeature(boolean enabled) {
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(
+            Settings.builder().put(CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), enabled).build(),
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
+    }
+
+    public void testGetPinnedTimestampLockedFilesFeatureDisabled() {
+        setupRemotePinnedTimestampFeature(false);
+        // Pinned timestamps 800, 900, 1000, 2000
+        // Metadata with timestamp 990, 995, 1000, 1001
+        // Metadata timestamp 1000 <= Pinned Timestamp 1000
+        // Metadata timestamp 1001 <= Pinned Timestamp 2000
+        Map<Long, String> metadataFilePinnedTimestampCache = new HashMap<>();
+        Tuple<Map<Long, String>, Set<String>> metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L, 995L, 1000L, 1001L),
+            Set.of(800L, 900L, 1000L, 2000L),
+            metadataFilePinnedTimestampCache
+        );
+        Map<Long, String> metadataFiles = metadataAndLocks.v1();
+        Set<String> implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(0, implicitLockedFiles.size());
+        assertEquals(0, metadataFilePinnedTimestampCache.size());
+    }
+
+    public void testGetPinnedTimestampLockedFilesWithEmptyMetadataFiles() {
+        setupRemotePinnedTimestampFeature(true);
+        List<String> metadataFiles = Collections.emptyList();
+        Set<Long> pinnedTimestampSet = new HashSet<>(Arrays.asList(1L, 2L, 3L));
+        Set<String> implicitLockedFiles = RemoteStoreUtils.getPinnedTimestampLockedFiles(
+            metadataFiles,
+            pinnedTimestampSet,
+            new HashMap<>(),
+            RemoteSegmentStoreDirectory.MetadataFilenameUtils::getTimestamp,
+            RemoteSegmentStoreDirectory.MetadataFilenameUtils::getNodeIdByPrimaryTermAndGen
+        );
+        assertTrue(implicitLockedFiles.isEmpty());
+    }
+
+    public void testGetPinnedTimestampLockedFilesWithNoPinnedTimestamps() {
+        setupRemotePinnedTimestampFeature(true);
+        List<String> metadataFiles = Arrays.asList("file1.txt", "file2.txt", "file3.txt");
+        Set<Long> pinnedTimestampSet = Collections.emptySet();
+        Set<String> implicitLockedFiles = RemoteStoreUtils.getPinnedTimestampLockedFiles(
+            metadataFiles,
+            pinnedTimestampSet,
+            new HashMap<>(),
+            RemoteSegmentStoreDirectory.MetadataFilenameUtils::getTimestamp,
+            RemoteSegmentStoreDirectory.MetadataFilenameUtils::getNodeIdByPrimaryTermAndGen
+        );
+        assertTrue(implicitLockedFiles.isEmpty());
+    }
+
+    public void testGetPinnedTimestampLockedFilesWithNullMetadataFiles() {
+        setupRemotePinnedTimestampFeature(true);
+        List<String> metadataFiles = null;
+        Set<Long> pinnedTimestampSet = new HashSet<>(Arrays.asList(1L, 2L, 3L));
+        Set<String> implicitLockedFiles = RemoteStoreUtils.getPinnedTimestampLockedFiles(
+            metadataFiles,
+            pinnedTimestampSet,
+            new HashMap<>(),
+            RemoteSegmentStoreDirectory.MetadataFilenameUtils::getTimestamp,
+            RemoteSegmentStoreDirectory.MetadataFilenameUtils::getNodeIdByPrimaryTermAndGen
+        );
+        assertTrue(implicitLockedFiles.isEmpty());
+    }
+
+    public void testGetPinnedTimestampLockedFilesWithNullPinnedTimestampSet() {
+        setupRemotePinnedTimestampFeature(true);
+        List<String> metadataFiles = Arrays.asList("file1.txt", "file2.txt", "file3.txt");
+        Set<Long> pinnedTimestampSet = null;
+        Set<String> implicitLockedFiles = RemoteStoreUtils.getPinnedTimestampLockedFiles(
+            metadataFiles,
+            pinnedTimestampSet,
+            new HashMap<>(),
+            RemoteSegmentStoreDirectory.MetadataFilenameUtils::getTimestamp,
+            RemoteSegmentStoreDirectory.MetadataFilenameUtils::getNodeIdByPrimaryTermAndGen
+        );
+        assertTrue(implicitLockedFiles.isEmpty());
+    }
+
+    private Tuple<Map<Long, String>, Set<String>> testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+        List<Long> metadataFileTimestamps,
+        Set<Long> pinnedTimetamps,
+        Map<Long, String> metadataFilePinnedTimestampCache
+    ) {
+        String metadataPrefix = "metadata__1__2__3__4__5__";
+        Map<Long, String> metadataFiles = new HashMap<>();
+        for (Long metadataFileTimestamp : metadataFileTimestamps) {
+            metadataFiles.put(metadataFileTimestamp, metadataPrefix + RemoteStoreUtils.invertLong(metadataFileTimestamp));
+        }
+        return new Tuple<>(
+            metadataFiles,
+            RemoteStoreUtils.getPinnedTimestampLockedFiles(
+                new ArrayList<>(metadataFiles.values()),
+                pinnedTimetamps,
+                metadataFilePinnedTimestampCache,
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils::getTimestamp,
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils::getNodeIdByPrimaryTermAndGen
+            )
+        );
+    }
+
+    private Tuple<Map<Long, String>, Set<String>> testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+        Map<Long, Long> metadataFileTimestampsPrimaryTermMap,
+        Set<Long> pinnedTimetamps,
+        Map<Long, String> metadataFilePinnedTimestampCache
+    ) {
+        setupRemotePinnedTimestampFeature(true);
+        Map<Long, String> metadataFiles = new HashMap<>();
+        for (Map.Entry<Long, Long> metadataFileTimestampPrimaryTerm : metadataFileTimestampsPrimaryTermMap.entrySet()) {
+            String primaryTerm = RemoteStoreUtils.invertLong(metadataFileTimestampPrimaryTerm.getValue());
+            String metadataPrefix = "metadata__" + primaryTerm + "__2__3__4__5__";
+            long metadataFileTimestamp = metadataFileTimestampPrimaryTerm.getKey();
+            metadataFiles.put(metadataFileTimestamp, metadataPrefix + RemoteStoreUtils.invertLong(metadataFileTimestamp));
+        }
+        return new Tuple<>(
+            metadataFiles,
+            RemoteStoreUtils.getPinnedTimestampLockedFiles(
+                new ArrayList<>(metadataFiles.values()),
+                pinnedTimetamps,
+                metadataFilePinnedTimestampCache,
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils::getTimestamp,
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils::getNodeIdByPrimaryTermAndGen
+            )
+        );
+    }
+
+    public void testGetPinnedTimestampLockedFilesWithPinnedTimestamps() {
+        setupRemotePinnedTimestampFeature(true);
+
+        Map<Long, String> metadataFilePinnedTimestampCache = new HashMap<>();
+
+        // Pinned timestamps 800, 900
+        // Metadata with timestamp 990
+        // No metadata matches the timestamp
+        Tuple<Map<Long, String>, Set<String>> metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L),
+            Set.of(800L, 900L),
+            metadataFilePinnedTimestampCache
+        );
+        Map<Long, String> metadataFiles = metadataAndLocks.v1();
+        Set<String> implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(0, implicitLockedFiles.size());
+        assertEquals(0, metadataFilePinnedTimestampCache.size());
+
+        // Pinned timestamps 800, 900, 1000
+        // Metadata with timestamp 990
+        // Metadata timestamp 990 <= Pinned Timestamp 1000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L),
+            Set.of(800L, 900L, 1000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(1, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(990L)));
+        // This is still 0 as we don't cache the latest metadata file as it can change (explained in the next test case)
+        assertEquals(0, metadataFilePinnedTimestampCache.size());
+
+        // Pinned timestamps 800, 900, 1000
+        // Metadata with timestamp 990, 995
+        // Metadata timestamp 995 <= Pinned Timestamp 1000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L, 995L),
+            Set.of(800L, 900L, 1000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(1, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(995L)));
+        // This is still 0 as we don't cache the latest metadata file as it can change
+        assertEquals(0, metadataFilePinnedTimestampCache.size());
+
+        // Pinned timestamps 800, 900, 1000
+        // Metadata with timestamp 990, 995, 1000
+        // Metadata timestamp 1000 <= Pinned Timestamp 1000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L, 995L, 1000L),
+            Set.of(800L, 900L, 1000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(1, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1000L)));
+        // This is still 0 as we don't cache the latest metadata file as it can change
+        assertEquals(0, metadataFilePinnedTimestampCache.size());
+
+        // Pinned timestamps 800, 900, 1000, 2000
+        // Metadata with timestamp 990, 995, 1000, 1001
+        // Metadata timestamp 1000 <= Pinned Timestamp 1000
+        // Metadata timestamp 1001 <= Pinned Timestamp 2000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L, 995L, 1000L, 1001L),
+            Set.of(800L, 900L, 1000L, 2000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(2, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1000L)));
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1001L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(1, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(1000L), metadataFilePinnedTimestampCache.get(1000L));
+
+        // Pinned timestamps 800, 900, 1000, 2000, 3000, 4000, 5000
+        // Metadata with timestamp 990, 995, 1000, 1001
+        // Metadata timestamp 1000 <= Pinned Timestamp 1000
+        // Metadata timestamp 1001 <= Pinned Timestamp 2000
+        // Metadata timestamp 1001 <= Pinned Timestamp 3000
+        // Metadata timestamp 1001 <= Pinned Timestamp 4000
+        // Metadata timestamp 1001 <= Pinned Timestamp 5000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L, 995L, 1000L, 1001L),
+            Set.of(800L, 900L, 1000L, 2000L, 3000L, 4000L, 5000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(2, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1000L)));
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1001L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(1, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(1000L), metadataFilePinnedTimestampCache.get(1000L));
+
+        // Pinned timestamps 800, 900, 1000, 2000, 3000, 4000, 5000
+        // Metadata with timestamp 990, 995, 1000, 1001, 1900, 2300
+        // Metadata timestamp 1000 <= Pinned Timestamp 1000
+        // Metadata timestamp 1900 <= Pinned Timestamp 2000
+        // Metadata timestamp 2300 <= Pinned Timestamp 3000
+        // Metadata timestamp 2300 <= Pinned Timestamp 4000
+        // Metadata timestamp 2300 <= Pinned Timestamp 5000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L, 995L, 1000L, 1001L, 1900L, 2300L),
+            Set.of(800L, 900L, 1000L, 2000L, 3000L, 4000L, 5000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(3, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1000L)));
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1900L)));
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(2300L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(2, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(1000L), metadataFilePinnedTimestampCache.get(1000L));
+        assertEquals(metadataFiles.get(1900L), metadataFilePinnedTimestampCache.get(2000L));
+
+        // Pinned timestamps 2000, 3000, 4000, 5000
+        // Metadata with timestamp 990, 995, 1000, 1001, 1900, 2300
+        // Metadata timestamp 1900 <= Pinned Timestamp 2000
+        // Metadata timestamp 2300 <= Pinned Timestamp 3000
+        // Metadata timestamp 2300 <= Pinned Timestamp 4000
+        // Metadata timestamp 2300 <= Pinned Timestamp 5000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(990L, 995L, 1000L, 1001L, 1900L, 2300L),
+            Set.of(2000L, 3000L, 4000L, 5000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(2, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1900L)));
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(2300L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(1, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(1900L), metadataFilePinnedTimestampCache.get(2000L));
+
+        // Pinned timestamps 2000, 3000, 4000, 5000
+        // Metadata with timestamp 1001, 1900, 2300, 3000, 3001, 5500, 6000
+        // Metadata timestamp 1900 <= Pinned Timestamp 2000
+        // Metadata timestamp 3000 <= Pinned Timestamp 3000
+        // Metadata timestamp 3001 <= Pinned Timestamp 4000
+        // Metadata timestamp 3001 <= Pinned Timestamp 5000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(1001L, 1900L, 2300L, 3000L, 3001L, 5500L, 6000L),
+            Set.of(2000L, 3000L, 4000L, 5000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(3, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(1900L)));
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(3000L)));
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(3001L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(4, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(1900L), metadataFilePinnedTimestampCache.get(2000L));
+        assertEquals(metadataFiles.get(3000L), metadataFilePinnedTimestampCache.get(3000L));
+        assertEquals(metadataFiles.get(3001L), metadataFilePinnedTimestampCache.get(4000L));
+        assertEquals(metadataFiles.get(3001L), metadataFilePinnedTimestampCache.get(5000L));
+
+        // Pinned timestamps 4000, 5000, 6000, 7000
+        // Metadata with timestamp 2300, 3000, 3001, 5500, 6000
+        // Metadata timestamp 3001 <= Pinned Timestamp 4000
+        // Metadata timestamp 3001 <= Pinned Timestamp 5000
+        // Metadata timestamp 6000 <= Pinned Timestamp 6000
+        // Metadata timestamp 6000 <= Pinned Timestamp 7000
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            List.of(2300L, 3000L, 3001L, 5500L, 6000L),
+            Set.of(4000L, 5000L, 6000L, 7000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(2, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(3001L)));
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(6000L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(2, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(3001L), metadataFilePinnedTimestampCache.get(4000L));
+        assertEquals(metadataFiles.get(3001L), metadataFilePinnedTimestampCache.get(5000L));
+    }
+
+    public void testGetPinnedTimestampLockedFilesWithPinnedTimestampsDifferentPrefix() {
+        setupRemotePinnedTimestampFeature(true);
+
+        Map<Long, String> metadataFilePinnedTimestampCache = new HashMap<>();
+
+        // Pinned timestamp 7000
+        // Primary Term - Timestamp in md file
+        // 6 - 7002
+        // 6 - 6998
+        // 5 - 6995
+        // 5 - 6990
+        Tuple<Map<Long, String>, Set<String>> metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            Map.of(7002L, 6L, 6998L, 6L, 6995L, 5L, 6990L, 5L),
+            Set.of(4000L, 5000L, 6000L, 7000L),
+            metadataFilePinnedTimestampCache
+        );
+        Map<Long, String> metadataFiles = metadataAndLocks.v1();
+        Set<String> implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(1, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(6998L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(1, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(6998L), metadataFilePinnedTimestampCache.get(7000L));
+
+        // Pinned timestamp 7000
+        // Primary Term - Timestamp in md file
+        // 6 - 7002
+        // 5 - 6998
+        // 5 - 6995
+        // 5 - 6990
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            Map.of(7002L, 6L, 6998L, 5L, 6995L, 5L, 6990L, 5L),
+            Set.of(4000L, 5000L, 6000L, 7000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(1, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(6998L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(1, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(6998L), metadataFilePinnedTimestampCache.get(7000L));
+
+        // Pinned timestamp 7000
+        // Primary Term - Timestamp in md file
+        // 6 - 7002
+        // 6 - 6998
+        // 5 - 7001
+        // 5 - 6990
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            Map.of(7002L, 6L, 6998L, 6L, 7001L, 5L, 6990L, 5L),
+            Set.of(4000L, 5000L, 6000L, 7000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(1, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(6998L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(1, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(6998L), metadataFilePinnedTimestampCache.get(7000L));
+
+        // Pinned timestamp 7000
+        // Primary Term - Timestamp in md file
+        // 6 - 7002
+        // 5 - 7005
+        // 5 - 6990
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            Map.of(7002L, 6L, 7005L, 5L, 6990L, 5L),
+            Set.of(4000L, 5000L, 6000L, 7000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(1, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(6990L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(1, metadataFilePinnedTimestampCache.size());
+        assertEquals(metadataFiles.get(6990L), metadataFilePinnedTimestampCache.get(7000L));
+
+        // Pinned timestamp 7000
+        // Primary Term - Timestamp in md file
+        // 6 - 6999
+        // 5 - 7005
+        // 5 - 6990
+        metadataFilePinnedTimestampCache = new HashMap<>();
+        metadataAndLocks = testGetPinnedTimestampLockedFilesWithPinnedTimestamps(
+            Map.of(6999L, 6L, 7005L, 5L, 6990L, 5L),
+            Set.of(4000L, 5000L, 6000L, 7000L),
+            metadataFilePinnedTimestampCache
+        );
+        metadataFiles = metadataAndLocks.v1();
+        implicitLockedFiles = metadataAndLocks.v2();
+
+        assertEquals(1, implicitLockedFiles.size());
+        assertTrue(implicitLockedFiles.contains(metadataFiles.get(6999L)));
+        // Now we cache all the matches except the last one.
+        assertEquals(0, metadataFilePinnedTimestampCache.size());
+    }
+
+    public void testFilterOutMetadataFilesBasedOnAgeFeatureDisabled() {
+        setupRemotePinnedTimestampFeature(false);
+        List<String> metadataFiles = new ArrayList<>();
+
+        for (int i = 0; i < randomIntBetween(5, 10); i++) {
+            metadataFiles.add((System.currentTimeMillis() - randomIntBetween(-150000, 150000)) + "_file" + i + ".txt");
+        }
+
+        List<String> result = RemoteStoreUtils.filterOutMetadataFilesBasedOnAge(
+            metadataFiles,
+            file -> Long.valueOf(file.split("_")[0]),
+            System.currentTimeMillis()
+        );
+        assertEquals(metadataFiles, result);
+    }
+
+    public void testFilterOutMetadataFilesBasedOnAge_AllFilesOldEnough() {
+        setupRemotePinnedTimestampFeature(true);
+
+        List<String> metadataFiles = Arrays.asList(
+            (System.currentTimeMillis() - 150000) + "_file1.txt",
+            (System.currentTimeMillis() - 300000) + "_file2.txt",
+            (System.currentTimeMillis() - 450000) + "_file3.txt"
+        );
+
+        List<String> result = RemoteStoreUtils.filterOutMetadataFilesBasedOnAge(
+            metadataFiles,
+            file -> Long.valueOf(file.split("_")[0]),
+            System.currentTimeMillis()
+        );
+        assertEquals(metadataFiles, result);
+    }
+
+    public void testFilterOutMetadataFilesBasedOnAge_SomeFilesTooNew() {
+        setupRemotePinnedTimestampFeature(true);
+
+        String file1 = (System.currentTimeMillis() - 150000) + "_file1.txt";
+        String file2 = (System.currentTimeMillis() - 300000) + "_file2.txt";
+        String file3 = (System.currentTimeMillis() + 450000) + "_file3.txt";
+
+        List<String> metadataFiles = Arrays.asList(file1, file2, file3);
+
+        List<String> result = RemoteStoreUtils.filterOutMetadataFilesBasedOnAge(
+            metadataFiles,
+            file -> Long.valueOf(file.split("_")[0]),
+            System.currentTimeMillis()
+        );
+        List<String> expected = Arrays.asList(file1, file2);
+        assertEquals(expected, result);
+    }
+
+    public void testFilterOutMetadataFilesBasedOnAge_AllFilesTooNew() {
+        setupRemotePinnedTimestampFeature(true);
+
+        String file1 = (System.currentTimeMillis() + 150000) + "_file1.txt";
+        String file2 = (System.currentTimeMillis() + 300000) + "_file2.txt";
+        String file3 = (System.currentTimeMillis() + 450000) + "_file3.txt";
+
+        List<String> metadataFiles = Arrays.asList(file1, file2, file3);
+
+        List<String> result = RemoteStoreUtils.filterOutMetadataFilesBasedOnAge(
+            metadataFiles,
+            file -> Long.valueOf(file.split("_")[0]),
+            System.currentTimeMillis()
+        );
+        assertTrue(result.isEmpty());
+    }
+
+    public void testFilterOutMetadataFilesBasedOnAge_EmptyInputList() {
+        setupRemotePinnedTimestampFeature(true);
+
+        List<String> metadataFiles = Arrays.asList();
+
+        List<String> result = RemoteStoreUtils.filterOutMetadataFilesBasedOnAge(
+            metadataFiles,
+            file -> Long.valueOf(file.split("_")[0]),
+            System.currentTimeMillis()
+        );
+        assertTrue(result.isEmpty());
+    }
+
+    public void testIsPinnedTimestampStateStaleFeatureDisabled() {
+        setupRemotePinnedTimestampFeature(false);
+        assertFalse(RemoteStoreUtils.isPinnedTimestampStateStale());
+    }
+
+    public void testIsPinnedTimestampStateStaleFeatureEnabled() {
+        setupRemotePinnedTimestampFeature(true);
+        assertTrue(RemoteStoreUtils.isPinnedTimestampStateStale());
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
index b2b8b3ce52176..732d1172c5e0f 100644
--- a/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/IndexShardTests.java
@@ -2834,9 +2834,9 @@ public void testSyncSegmentsFromGivenRemoteSegmentStore() throws IOException {
             RecoverySource.ExistingStoreRecoverySource.INSTANCE
         );
         routing = ShardRoutingHelper.newWithRestoreSource(routing, new RecoverySource.EmptyStoreRecoverySource());
-
         target = reinitShard(target, routing);
-
+        DiscoveryNode localNode = new DiscoveryNode("foo", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
+        target.markAsRecovering("from snapshot", new RecoveryState(routing, localNode, null));
         target.syncSegmentsFromGivenRemoteSegmentStore(false, tempRemoteSegmentDirectory, primaryTerm, commitGeneration);
         RemoteSegmentStoreDirectory remoteStoreDirectory = ((RemoteSegmentStoreDirectory) ((FilterDirectory) ((FilterDirectory) target
             .remoteStore()
@@ -2894,6 +2894,14 @@ public void testRestoreShardFromRemoteStore(boolean performFlush) throws IOExcep
             )
         );
 
+        // Make sure to drain refreshes from the shard. Otherwise, if the refresh is in-progress, it overlaps with
+        // deletion of segment files in the subsequent code block.
+        for (ReferenceManager.RefreshListener refreshListener : target.getEngine().config().getInternalRefreshListener()) {
+            if (refreshListener instanceof ReleasableRetryableRefreshListener) {
+                ((ReleasableRetryableRefreshListener) refreshListener).drainRefreshes();
+            }
+        }
+
         // Delete files in store directory to restore from remote directory
         Directory storeDirectory = target.store().directory();
 
diff --git a/server/src/test/java/org/opensearch/index/shard/RemoteStoreRefreshListenerTests.java b/server/src/test/java/org/opensearch/index/shard/RemoteStoreRefreshListenerTests.java
index e0ee58cbfdb22..94269de9349fe 100644
--- a/server/src/test/java/org/opensearch/index/shard/RemoteStoreRefreshListenerTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/RemoteStoreRefreshListenerTests.java
@@ -16,6 +16,7 @@
 import org.apache.lucene.tests.store.BaseDirectoryWrapper;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.routing.IndexShardRoutingTable;
+import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.collect.Tuple;
@@ -37,8 +38,10 @@
 import org.opensearch.index.store.lockmanager.RemoteStoreLockManager;
 import org.opensearch.indices.DefaultRemoteStoreSettings;
 import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.indices.recovery.RecoveryState;
 import org.opensearch.indices.replication.checkpoint.SegmentReplicationCheckpointPublisher;
 import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.threadpool.ThreadPool;
 import org.junit.After;
 
@@ -47,6 +50,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
 
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_REPLICATION_TYPE;
@@ -84,7 +88,7 @@ public void setup(boolean primary, int numberOfDocs) throws IOException {
             indexShard.refresh("test");
         }
 
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
@@ -124,6 +128,52 @@ public void tearDown() throws Exception {
         super.tearDown();
     }
 
+    public void testIsLowPriorityUpload() throws IOException {
+        setup(true, 3);
+
+        // Mocking the IndexShard methods and dependent classes.
+        IndexShard shard = mock(IndexShard.class);
+        Store store = mock(Store.class);
+        ShardId shardId = new ShardId("index1", "_na_", 1);
+        ShardRouting shardRouting = mock(ShardRouting.class);
+        shard.shardRouting = shardRouting;
+        when(shard.shouldSeedRemoteStore()).thenReturn(true);
+        when(shard.state()).thenReturn(IndexShardState.RECOVERING);
+        when(shardRouting.primary()).thenReturn(true);
+        when(shard.shardId()).thenReturn(shardId);
+        when(shard.store()).thenReturn(store);
+        when(shard.routingEntry()).thenReturn(shardRouting);
+        when(shard.getThreadPool()).thenReturn(mock(ThreadPool.class));
+        RecoveryState recoveryState = mock(RecoveryState.class);
+        when(recoveryState.getRecoverySource()).thenReturn(RecoverySource.PeerRecoverySource.INSTANCE);
+        when(shard.recoveryState()).thenReturn(recoveryState);
+
+        // Mock the Store, Directory and RemoteSegmentStoreDirectory classes
+        Store remoteStore = mock(Store.class);
+        when(shard.remoteStore()).thenReturn(remoteStore);
+        RemoteDirectory remoteMetadataDirectory = mock(RemoteDirectory.class);
+        RemoteSegmentStoreDirectory remoteSegmentStoreDirectory = new RemoteSegmentStoreDirectory(
+            mock(RemoteDirectory.class),
+            remoteMetadataDirectory,
+            mock(RemoteStoreLockManager.class),
+            mock(ThreadPool.class),
+            shardId
+        );
+        FilterDirectory remoteStoreFilterDirectory = new RemoteStoreRefreshListenerTests.TestFilterDirectory(
+            new RemoteStoreRefreshListenerTests.TestFilterDirectory(remoteSegmentStoreDirectory)
+        );
+        when(remoteStore.directory()).thenReturn(remoteStoreFilterDirectory);
+
+        RemoteStoreRefreshListener remoteStoreRefreshListener = new RemoteStoreRefreshListener(
+            shard,
+            SegmentReplicationCheckpointPublisher.EMPTY,
+            mock(RemoteSegmentTransferTracker.class),
+            DefaultRemoteStoreSettings.INSTANCE
+        );
+        assertTrue(remoteStoreRefreshListener.isLocalOrSnapshotRecoveryOrSeeding());
+        assertTrue(remoteStoreRefreshListener.isLowPriorityUpload());
+    }
+
     public void testRemoteDirectoryInitThrowsException() throws IOException {
         // Methods used in the constructor of RemoteSegmentTrackerListener have been mocked to reproduce specific exceptions
         // to test the failure modes possible during construction of RemoteSegmentTrackerListener object.
@@ -469,6 +519,25 @@ public void testRefreshPersistentFailure() throws Exception {
         assertFalse("remote store should not in sync", tuple.v1().isRemoteSegmentStoreInSync());
     }
 
+    public void testRefreshPersistentFailureAndIndexShardClosed() throws Exception {
+        int succeedOnAttempt = 3;
+        int closeShardOnAttempt = 1;
+        CountDownLatch refreshCountLatch = new CountDownLatch(1);
+        CountDownLatch successLatch = new CountDownLatch(10);
+        Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> tuple = mockIndexShardWithRetryAndScheduleRefresh(
+            succeedOnAttempt,
+            refreshCountLatch,
+            successLatch,
+            true,
+            closeShardOnAttempt
+        );
+        // Giving 10ms for some iterations of remote refresh upload
+        Thread.sleep(TimeUnit.SECONDS.toMillis(2));
+        RemoteStoreRefreshListener listener = tuple.v1();
+        assertFalse("remote store should not in sync", listener.isRemoteSegmentStoreInSync());
+        assertFalse(listener.getRetryScheduledStatus());
+    }
+
     private void assertNoLagAndTotalUploadsFailed(RemoteSegmentTransferTracker segmentTracker, long totalUploadsFailed) throws Exception {
         assertBusy(() -> {
             assertEquals(0, segmentTracker.getBytesLag());
@@ -547,6 +616,49 @@ private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIn
         return mockIndexShardWithRetryAndScheduleRefresh(succeedOnAttempt, refreshCountLatch, successLatch, 1, noOpLatch);
     }
 
+    private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIndexShardWithRetryAndScheduleRefresh(
+        int totalAttempt,
+        CountDownLatch refreshCountLatch,
+        CountDownLatch successLatch,
+        int checkpointPublishSucceedOnAttempt,
+        CountDownLatch reachedCheckpointPublishLatch,
+        boolean mockPrimaryTerm,
+        boolean testUploadTimeout
+    ) throws IOException {
+        return mockIndexShardWithRetryAndScheduleRefresh(
+            totalAttempt,
+            refreshCountLatch,
+            successLatch,
+            checkpointPublishSucceedOnAttempt,
+            reachedCheckpointPublishLatch,
+            mockPrimaryTerm,
+            testUploadTimeout,
+            false,
+            0
+        );
+    }
+
+    private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIndexShardWithRetryAndScheduleRefresh(
+        int succeedOnAttempt,
+        CountDownLatch refreshCountLatch,
+        CountDownLatch successLatch,
+        boolean closedShard,
+        int closeShardAfterAttempt
+    ) throws IOException {
+        CountDownLatch noOpLatch = new CountDownLatch(0);
+        return mockIndexShardWithRetryAndScheduleRefresh(
+            succeedOnAttempt,
+            refreshCountLatch,
+            successLatch,
+            1,
+            noOpLatch,
+            true,
+            false,
+            closedShard,
+            closeShardAfterAttempt
+        );
+    }
+
     private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIndexShardWithRetryAndScheduleRefresh(
         int succeedOnAttempt,
         CountDownLatch refreshCountLatch,
@@ -561,7 +673,9 @@ private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIn
             succeedCheckpointPublishOnAttempt,
             reachedCheckpointPublishLatch,
             true,
-            false
+            false,
+            false,
+            0
         );
     }
 
@@ -572,7 +686,9 @@ private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIn
         int succeedCheckpointPublishOnAttempt,
         CountDownLatch reachedCheckpointPublishLatch,
         boolean mockPrimaryTerm,
-        boolean testUploadTimeout
+        boolean testUploadTimeout,
+        boolean closeShard,
+        int closeShardAfterAttempt
     ) throws IOException {
         // Create index shard that we will be using to mock different methods in IndexShard for the unit test
         indexShard = newStartedShard(
@@ -600,7 +716,6 @@ private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIn
         IndexShard shard = mock(IndexShard.class);
         Store store = mock(Store.class);
         when(shard.store()).thenReturn(store);
-        when(shard.state()).thenReturn(IndexShardState.STARTED);
         when(store.directory()).thenReturn(indexShard.store().directory());
 
         // Mock (RemoteSegmentStoreDirectory) ((FilterDirectory) ((FilterDirectory) indexShard.remoteStore().directory())
@@ -662,6 +777,14 @@ private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIn
             return indexShard.getLatestReplicationCheckpoint();
         })).when(shard).computeReplicationCheckpoint(any());
 
+        doAnswer((invocationOnMock -> {
+            if (closeShard && counter.get() == closeShardAfterAttempt) {
+                logger.info("Closing shard...");
+                return IndexShardState.CLOSED;
+            }
+            return IndexShardState.STARTED;
+        })).when(shard).state();
+
         doAnswer(invocation -> {
             if (Objects.nonNull(successLatch)) {
                 successLatch.countDown();
@@ -682,7 +805,7 @@ private Tuple<RemoteStoreRefreshListener, RemoteStoreStatsTrackerFactory> mockIn
             return null;
         }).when(emptyCheckpointPublisher).publish(any(), any());
 
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/index/shard/SearchOperationListenerTests.java b/server/src/test/java/org/opensearch/index/shard/SearchOperationListenerTests.java
index c61c13eecf2c3..b00307920e875 100644
--- a/server/src/test/java/org/opensearch/index/shard/SearchOperationListenerTests.java
+++ b/server/src/test/java/org/opensearch/index/shard/SearchOperationListenerTests.java
@@ -56,6 +56,9 @@ public void testListenersAreExecuted() {
         AtomicInteger preQuery = new AtomicInteger();
         AtomicInteger failedQuery = new AtomicInteger();
         AtomicInteger onQuery = new AtomicInteger();
+        AtomicInteger preSlice = new AtomicInteger();
+        AtomicInteger failedSlice = new AtomicInteger();
+        AtomicInteger onSlice = new AtomicInteger();
         AtomicInteger onFetch = new AtomicInteger();
         AtomicInteger preFetch = new AtomicInteger();
         AtomicInteger failedFetch = new AtomicInteger();
@@ -86,6 +89,24 @@ public void onQueryPhase(SearchContext searchContext, long tookInNanos) {
                 onQuery.incrementAndGet();
             }
 
+            @Override
+            public void onPreSliceExecution(SearchContext searchContext) {
+                assertNotNull(searchContext);
+                preSlice.incrementAndGet();
+            }
+
+            @Override
+            public void onFailedSliceExecution(SearchContext searchContext) {
+                assertNotNull(searchContext);
+                failedSlice.incrementAndGet();
+            }
+
+            @Override
+            public void onSliceExecution(SearchContext searchContext) {
+                assertNotNull(searchContext);
+                onSlice.incrementAndGet();
+            }
+
             @Override
             public void onPreFetchPhase(SearchContext searchContext) {
                 assertNotNull(searchContext);
@@ -167,10 +188,30 @@ public void onSearchIdleReactivation() {
         compositeListener.onQueryPhase(ctx, timeInNanos.get());
         assertEquals(0, preFetch.get());
         assertEquals(0, preQuery.get());
+        assertEquals(0, preSlice.get());
+        assertEquals(0, failedFetch.get());
+        assertEquals(0, failedQuery.get());
+        assertEquals(0, failedSlice.get());
+        assertEquals(2, onQuery.get());
+        assertEquals(0, onFetch.get());
+        assertEquals(0, onSlice.get());
+        assertEquals(0, newContext.get());
+        assertEquals(0, newScrollContext.get());
+        assertEquals(0, freeContext.get());
+        assertEquals(0, freeScrollContext.get());
+        assertEquals(0, searchIdleReactivateCount.get());
+        assertEquals(0, validateSearchContext.get());
+
+        compositeListener.onSliceExecution(ctx);
+        assertEquals(0, preFetch.get());
+        assertEquals(0, preQuery.get());
+        assertEquals(0, preSlice.get());
         assertEquals(0, failedFetch.get());
         assertEquals(0, failedQuery.get());
+        assertEquals(0, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(0, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(0, newContext.get());
         assertEquals(0, newScrollContext.get());
         assertEquals(0, freeContext.get());
@@ -181,10 +222,13 @@ public void onSearchIdleReactivation() {
         compositeListener.onFetchPhase(ctx, timeInNanos.get());
         assertEquals(0, preFetch.get());
         assertEquals(0, preQuery.get());
+        assertEquals(0, preSlice.get());
         assertEquals(0, failedFetch.get());
         assertEquals(0, failedQuery.get());
+        assertEquals(0, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(0, newContext.get());
         assertEquals(0, newScrollContext.get());
         assertEquals(0, freeContext.get());
@@ -195,10 +239,30 @@ public void onSearchIdleReactivation() {
         compositeListener.onPreQueryPhase(ctx);
         assertEquals(0, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(0, preSlice.get());
         assertEquals(0, failedFetch.get());
         assertEquals(0, failedQuery.get());
+        assertEquals(0, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
+        assertEquals(0, newContext.get());
+        assertEquals(0, newScrollContext.get());
+        assertEquals(0, freeContext.get());
+        assertEquals(0, freeScrollContext.get());
+        assertEquals(0, searchIdleReactivateCount.get());
+        assertEquals(0, validateSearchContext.get());
+
+        compositeListener.onPreSliceExecution(ctx);
+        assertEquals(0, preFetch.get());
+        assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
+        assertEquals(0, failedFetch.get());
+        assertEquals(0, failedQuery.get());
+        assertEquals(0, failedSlice.get());
+        assertEquals(2, onQuery.get());
+        assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(0, newContext.get());
         assertEquals(0, newScrollContext.get());
         assertEquals(0, freeContext.get());
@@ -209,10 +273,13 @@ public void onSearchIdleReactivation() {
         compositeListener.onPreFetchPhase(ctx);
         assertEquals(2, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
         assertEquals(0, failedFetch.get());
         assertEquals(0, failedQuery.get());
+        assertEquals(0, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(0, newContext.get());
         assertEquals(0, newScrollContext.get());
         assertEquals(0, freeContext.get());
@@ -223,10 +290,13 @@ public void onSearchIdleReactivation() {
         compositeListener.onFailedFetchPhase(ctx);
         assertEquals(2, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
         assertEquals(2, failedFetch.get());
         assertEquals(0, failedQuery.get());
+        assertEquals(0, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(0, newContext.get());
         assertEquals(0, newScrollContext.get());
         assertEquals(0, freeContext.get());
@@ -237,10 +307,30 @@ public void onSearchIdleReactivation() {
         compositeListener.onFailedQueryPhase(ctx);
         assertEquals(2, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
+        assertEquals(2, failedFetch.get());
+        assertEquals(2, failedQuery.get());
+        assertEquals(0, failedSlice.get());
+        assertEquals(2, onQuery.get());
+        assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
+        assertEquals(0, newContext.get());
+        assertEquals(0, newScrollContext.get());
+        assertEquals(0, freeContext.get());
+        assertEquals(0, freeScrollContext.get());
+        assertEquals(0, searchIdleReactivateCount.get());
+        assertEquals(0, validateSearchContext.get());
+
+        compositeListener.onFailedSliceExecution(ctx);
+        assertEquals(2, preFetch.get());
+        assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
         assertEquals(2, failedFetch.get());
         assertEquals(2, failedQuery.get());
+        assertEquals(2, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(0, newContext.get());
         assertEquals(0, newScrollContext.get());
         assertEquals(0, freeContext.get());
@@ -251,10 +341,13 @@ public void onSearchIdleReactivation() {
         compositeListener.onNewReaderContext(mock(ReaderContext.class));
         assertEquals(2, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
         assertEquals(2, failedFetch.get());
         assertEquals(2, failedQuery.get());
+        assertEquals(2, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(2, newContext.get());
         assertEquals(0, newScrollContext.get());
         assertEquals(0, freeContext.get());
@@ -265,10 +358,13 @@ public void onSearchIdleReactivation() {
         compositeListener.onNewScrollContext(mock(ReaderContext.class));
         assertEquals(2, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
         assertEquals(2, failedFetch.get());
         assertEquals(2, failedQuery.get());
+        assertEquals(2, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(2, newContext.get());
         assertEquals(2, newScrollContext.get());
         assertEquals(0, freeContext.get());
@@ -279,10 +375,13 @@ public void onSearchIdleReactivation() {
         compositeListener.onFreeReaderContext(mock(ReaderContext.class));
         assertEquals(2, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
         assertEquals(2, failedFetch.get());
         assertEquals(2, failedQuery.get());
+        assertEquals(2, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(2, newContext.get());
         assertEquals(2, newScrollContext.get());
         assertEquals(2, freeContext.get());
@@ -293,10 +392,13 @@ public void onSearchIdleReactivation() {
         compositeListener.onFreeScrollContext(mock(ReaderContext.class));
         assertEquals(2, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
         assertEquals(2, failedFetch.get());
         assertEquals(2, failedQuery.get());
+        assertEquals(2, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(2, newContext.get());
         assertEquals(2, newScrollContext.get());
         assertEquals(2, freeContext.get());
@@ -307,10 +409,13 @@ public void onSearchIdleReactivation() {
         compositeListener.onSearchIdleReactivation();
         assertEquals(2, preFetch.get());
         assertEquals(2, preQuery.get());
+        assertEquals(2, preSlice.get());
         assertEquals(2, failedFetch.get());
         assertEquals(2, failedQuery.get());
+        assertEquals(2, failedSlice.get());
         assertEquals(2, onQuery.get());
         assertEquals(2, onFetch.get());
+        assertEquals(2, onSlice.get());
         assertEquals(2, newContext.get());
         assertEquals(2, newScrollContext.get());
         assertEquals(2, freeContext.get());
diff --git a/server/src/test/java/org/opensearch/index/store/BaseRemoteSegmentStoreDirectoryTests.java b/server/src/test/java/org/opensearch/index/store/BaseRemoteSegmentStoreDirectoryTests.java
new file mode 100644
index 0000000000000..2c55d26261fe0
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/store/BaseRemoteSegmentStoreDirectoryTests.java
@@ -0,0 +1,150 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store;
+
+import org.apache.lucene.index.SegmentInfos;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.util.concurrent.OpenSearchExecutors;
+import org.opensearch.index.engine.NRTReplicationEngineFactory;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.shard.IndexShardTestCase;
+import org.opensearch.index.store.lockmanager.RemoteStoreMetadataLockManager;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.After;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+
+import static org.opensearch.index.store.RemoteSegmentStoreDirectory.METADATA_FILES_TO_FETCH;
+import static org.opensearch.test.RemoteStoreTestUtils.createMetadataFileBytes;
+import static org.opensearch.test.RemoteStoreTestUtils.getDummyMetadata;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class BaseRemoteSegmentStoreDirectoryTests extends IndexShardTestCase {
+
+    protected RemoteDirectory remoteDataDirectory;
+    protected RemoteDirectory remoteMetadataDirectory;
+    protected RemoteStoreMetadataLockManager mdLockManager;
+    protected RemoteSegmentStoreDirectory remoteSegmentStoreDirectory;
+    protected TestUploadListener testUploadTracker;
+    protected IndexShard indexShard;
+    protected SegmentInfos segmentInfos;
+    protected ThreadPool threadPool;
+
+    protected String metadataFilename = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(12, 23, 34, 1, 1, "node-1");
+
+    protected String metadataFilenameDup = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
+        12,
+        23,
+        34,
+        2,
+        1,
+        "node-2"
+    );
+    protected String metadataFilename2 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(12, 13, 34, 1, 1, "node-1");
+    protected String metadataFilename3 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(10, 38, 34, 1, 1, "node-1");
+    protected String metadataFilename4 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(10, 36, 34, 1, 1, "node-1");
+
+    public void setupRemoteSegmentStoreDirectory() throws IOException {
+        remoteDataDirectory = mock(RemoteDirectory.class);
+        remoteMetadataDirectory = mock(RemoteDirectory.class);
+        mdLockManager = mock(RemoteStoreMetadataLockManager.class);
+        threadPool = mock(ThreadPool.class);
+        testUploadTracker = new TestUploadListener();
+
+        Settings indexSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, org.opensearch.Version.CURRENT)
+            .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+            .build();
+        ExecutorService executorService = OpenSearchExecutors.newDirectExecutorService();
+
+        indexShard = newStartedShard(false, indexSettings, new NRTReplicationEngineFactory());
+        remoteSegmentStoreDirectory = new RemoteSegmentStoreDirectory(
+            remoteDataDirectory,
+            remoteMetadataDirectory,
+            mdLockManager,
+            threadPool,
+            indexShard.shardId()
+        );
+        try (Store store = indexShard.store()) {
+            segmentInfos = store.readLastCommittedSegmentsInfo();
+        }
+
+        when(threadPool.executor(ThreadPool.Names.REMOTE_PURGE)).thenReturn(executorService);
+        when(threadPool.executor(ThreadPool.Names.REMOTE_RECOVERY)).thenReturn(executorService);
+        when(threadPool.executor(ThreadPool.Names.SAME)).thenReturn(executorService);
+    }
+
+    protected Map<String, Map<String, String>> populateMetadata() throws IOException {
+        List<String> metadataFiles = new ArrayList<>();
+
+        metadataFiles.add(metadataFilename);
+        metadataFiles.add(metadataFilename2);
+        metadataFiles.add(metadataFilename3);
+
+        when(
+            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX,
+                METADATA_FILES_TO_FETCH
+            )
+        ).thenReturn(List.of(metadataFilename));
+        when(
+            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX,
+                Integer.MAX_VALUE
+            )
+        ).thenReturn(metadataFiles);
+
+        Map<String, Map<String, String>> metadataFilenameContentMapping = Map.of(
+            metadataFilename,
+            getDummyMetadata("_0", 1),
+            metadataFilename2,
+            getDummyMetadata("_0", 1),
+            metadataFilename3,
+            getDummyMetadata("_0", 1)
+        );
+
+        when(remoteMetadataDirectory.getBlobStream(metadataFilename)).thenAnswer(
+            I -> createMetadataFileBytes(
+                metadataFilenameContentMapping.get(metadataFilename),
+                indexShard.getLatestReplicationCheckpoint(),
+                segmentInfos
+            )
+        );
+        when(remoteMetadataDirectory.getBlobStream(metadataFilename2)).thenAnswer(
+            I -> createMetadataFileBytes(
+                metadataFilenameContentMapping.get(metadataFilename2),
+                indexShard.getLatestReplicationCheckpoint(),
+                segmentInfos
+            )
+        );
+        when(remoteMetadataDirectory.getBlobStream(metadataFilename3)).thenAnswer(
+            I -> createMetadataFileBytes(
+                metadataFilenameContentMapping.get(metadataFilename3),
+                indexShard.getLatestReplicationCheckpoint(),
+                segmentInfos
+            )
+        );
+
+        return metadataFilenameContentMapping;
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        indexShard.close("test tearDown", true, false);
+        super.tearDown();
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/index/store/CompositeDirectoryTests.java b/server/src/test/java/org/opensearch/index/store/CompositeDirectoryTests.java
new file mode 100644
index 0000000000000..d5628cfab9ee7
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/store/CompositeDirectoryTests.java
@@ -0,0 +1,202 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store;
+
+import com.carrotsearch.randomizedtesting.annotations.ThreadLeakFilters;
+
+import org.apache.lucene.store.AlreadyClosedException;
+import org.apache.lucene.store.FSDirectory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.core.common.breaker.CircuitBreaker;
+import org.opensearch.core.common.breaker.NoopCircuitBreaker;
+import org.opensearch.index.store.remote.file.CleanerDaemonThreadLeakFilter;
+import org.opensearch.index.store.remote.file.OnDemandBlockSnapshotIndexInput;
+import org.opensearch.index.store.remote.filecache.FileCache;
+import org.opensearch.index.store.remote.filecache.FileCacheFactory;
+import org.opensearch.index.store.remote.filecache.FileCachedIndexInput;
+import org.opensearch.index.store.remote.utils.FileTypeUtils;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+
+@ThreadLeakFilters(filters = CleanerDaemonThreadLeakFilter.class)
+public class CompositeDirectoryTests extends BaseRemoteSegmentStoreDirectoryTests {
+    private FileCache fileCache;
+    private FSDirectory localDirectory;
+    private CompositeDirectory compositeDirectory;
+
+    private final static String[] LOCAL_FILES = new String[] { "_1.cfe", "_2.cfe", "_0.cfe_block_7", "_0.cfs_block_7", "temp_file.tmp" };
+    private final static String FILE_PRESENT_LOCALLY = "_1.cfe";
+    private final static String FILE_PRESENT_IN_REMOTE_ONLY = "_0.si";
+    private final static String NON_EXISTENT_FILE = "non_existent_file";
+    private final static String NEW_FILE = "new_file";
+    private final static String TEMP_FILE = "temp_file.tmp";
+    private final static int FILE_CACHE_CAPACITY = 10000;
+
+    @Before
+    public void setup() throws IOException {
+        setupRemoteSegmentStoreDirectory();
+        populateMetadata();
+        remoteSegmentStoreDirectory.init();
+        localDirectory = FSDirectory.open(createTempDir());
+        removeExtraFSFiles();
+        fileCache = FileCacheFactory.createConcurrentLRUFileCache(FILE_CACHE_CAPACITY, new NoopCircuitBreaker(CircuitBreaker.REQUEST));
+        compositeDirectory = new CompositeDirectory(localDirectory, remoteSegmentStoreDirectory, fileCache);
+        addFilesToDirectory(LOCAL_FILES);
+    }
+
+    public void testListAll() throws IOException {
+        String[] actualFileNames = compositeDirectory.listAll();
+        String[] expectedFileNames = new String[] { "_0.cfe", "_0.cfs", "_0.si", "_1.cfe", "_2.cfe", "segments_1", "temp_file.tmp" };
+        assertArrayEquals(expectedFileNames, actualFileNames);
+    }
+
+    public void testDeleteFile() throws IOException {
+        assertTrue(existsInCompositeDirectory(FILE_PRESENT_LOCALLY));
+        // Delete the file and assert that it no more is a part of the directory
+        compositeDirectory.deleteFile(FILE_PRESENT_LOCALLY);
+        assertFalse(existsInCompositeDirectory(FILE_PRESENT_LOCALLY));
+        // Reading deleted file from directory should result in NoSuchFileException
+        assertThrows(NoSuchFileException.class, () -> compositeDirectory.openInput(FILE_PRESENT_LOCALLY, IOContext.DEFAULT));
+    }
+
+    public void testFileLength() throws IOException {
+        // File present locally
+        assertTrue(existsInLocalDirectory(FILE_PRESENT_LOCALLY));
+        assertFalse(existsInRemoteDirectory(FILE_PRESENT_LOCALLY));
+        assertEquals(compositeDirectory.fileLength(FILE_PRESENT_LOCALLY), localDirectory.fileLength(FILE_PRESENT_LOCALLY));
+
+        // File not present locally - present in Remote
+        assertFalse(existsInLocalDirectory(FILE_PRESENT_IN_REMOTE_ONLY));
+        assertTrue(existsInRemoteDirectory(FILE_PRESENT_IN_REMOTE_ONLY));
+        assertEquals(
+            compositeDirectory.fileLength(FILE_PRESENT_IN_REMOTE_ONLY),
+            remoteSegmentStoreDirectory.fileLength(FILE_PRESENT_IN_REMOTE_ONLY)
+        );
+
+        // File not present in both local and remote
+        assertFalse(Arrays.asList(compositeDirectory.listAll()).contains(NON_EXISTENT_FILE));
+        assertThrows(NoSuchFileException.class, () -> compositeDirectory.fileLength(NON_EXISTENT_FILE));
+    }
+
+    public void testCreateOutput() throws IOException {
+        try (IndexOutput indexOutput = compositeDirectory.createOutput(NEW_FILE, IOContext.DEFAULT)) {
+            // File not present in FileCache until the indexOutput is Closed
+            assertNull(fileCache.get(localDirectory.getDirectory().resolve(NEW_FILE)));
+        }
+        // File present in FileCache after the indexOutput is Closed
+        assertNotNull(fileCache.get(localDirectory.getDirectory().resolve(NEW_FILE)));
+    }
+
+    public void testSync() throws IOException {
+        // All the files in the below list are present either locally or on remote, so sync should work as expected
+        Collection<String> names = List.of("_0.cfe", "_0.cfs", "_0.si", "_1.cfe", "_2.cfe", "segments_1");
+        compositeDirectory.sync(names);
+        // Below list contains a non-existent file, hence will throw an error
+        Collection<String> names1 = List.of("_0.cfe", "_0.cfs", "_0.si", "_1.cfe", "_2.cfe", "segments_1", "non_existent_file");
+        assertThrows(NoSuchFileException.class, () -> compositeDirectory.sync(names1));
+    }
+
+    public void testRename() throws IOException {
+        // Rename should work as expected for file present in directory
+        assertTrue(existsInCompositeDirectory(FILE_PRESENT_LOCALLY));
+        compositeDirectory.rename(FILE_PRESENT_LOCALLY, "_1_new.cfe");
+        // Should throw error for file not present
+        assertThrows(NoSuchFileException.class, () -> compositeDirectory.rename(NON_EXISTENT_FILE, "_1_new.cfe"));
+    }
+
+    public void testOpenInput() throws IOException {
+        // File not present in Directory
+        assertFalse(existsInCompositeDirectory(NON_EXISTENT_FILE));
+        assertThrows(NoSuchFileException.class, () -> compositeDirectory.openInput(NON_EXISTENT_FILE, IOContext.DEFAULT));
+
+        // Temp file, read directly form local directory
+        assertTrue(existsInLocalDirectory(TEMP_FILE) && FileTypeUtils.isTempFile(TEMP_FILE));
+        assertEquals(
+            compositeDirectory.openInput(TEMP_FILE, IOContext.DEFAULT).toString(),
+            localDirectory.openInput(TEMP_FILE, IOContext.DEFAULT).toString()
+        );
+
+        // File present in file cache
+        assertNotNull(fileCache.get(getFilePath(FILE_PRESENT_LOCALLY)));
+        assertTrue(compositeDirectory.openInput(FILE_PRESENT_LOCALLY, IOContext.DEFAULT) instanceof FileCachedIndexInput);
+
+        // File present in Remote
+        assertFalse(existsInLocalDirectory(FILE_PRESENT_IN_REMOTE_ONLY));
+        assertTrue(existsInRemoteDirectory(FILE_PRESENT_IN_REMOTE_ONLY));
+        assertTrue(compositeDirectory.openInput(FILE_PRESENT_IN_REMOTE_ONLY, IOContext.DEFAULT) instanceof OnDemandBlockSnapshotIndexInput);
+    }
+
+    public void testClose() throws IOException {
+        // Similar to delete, when close is called existing openInput should be able to function properly but new requests should not be
+        // served
+        IndexInput indexInput = compositeDirectory.openInput(FILE_PRESENT_LOCALLY, IOContext.DEFAULT);
+        compositeDirectory.close();
+        // Any operations after close will throw AlreadyClosedException
+        assertThrows(AlreadyClosedException.class, () -> compositeDirectory.openInput(FILE_PRESENT_LOCALLY, IOContext.DEFAULT));
+        // Existing open IndexInputs will be served
+        indexInput.getFilePointer();
+        indexInput.close();
+        assertThrows(RuntimeException.class, indexInput::getFilePointer);
+        assertThrows(AlreadyClosedException.class, () -> compositeDirectory.close());
+    }
+
+    public void testAfterSyncToRemote() throws IOException {
+        // File will be present locally until uploaded to Remote
+        assertTrue(existsInLocalDirectory(FILE_PRESENT_LOCALLY));
+        compositeDirectory.afterSyncToRemote(FILE_PRESENT_LOCALLY);
+        fileCache.prune();
+        // After uploading to Remote, refCount will be decreased by 1 making it 0 and will be evicted if cache is pruned
+        assertFalse(existsInLocalDirectory(FILE_PRESENT_LOCALLY));
+        // Asserting file is not present in FileCache
+        assertNull(fileCache.get(getFilePath(FILE_PRESENT_LOCALLY)));
+    }
+
+    private void addFilesToDirectory(String[] files) throws IOException {
+        for (String file : files) {
+            IndexOutput indexOutput = compositeDirectory.createOutput(file, IOContext.DEFAULT);
+            indexOutput.close();
+        }
+    }
+
+    private void removeExtraFSFiles() throws IOException {
+        HashSet<String> allFiles = new HashSet<>(Arrays.asList(localDirectory.listAll()));
+        allFiles.stream().filter(FileTypeUtils::isExtraFSFile).forEach(file -> {
+            try {
+                localDirectory.deleteFile(file);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    private boolean existsInLocalDirectory(String name) throws IOException {
+        return Arrays.asList(localDirectory.listAll()).contains(name);
+    }
+
+    private boolean existsInRemoteDirectory(String name) throws IOException {
+        return Arrays.asList(remoteSegmentStoreDirectory.listAll()).contains(name);
+    }
+
+    private boolean existsInCompositeDirectory(String name) throws IOException {
+        return Arrays.asList(compositeDirectory.listAll()).contains(name);
+    }
+
+    private Path getFilePath(String name) {
+        return localDirectory.getDirectory().resolve(name);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/store/RemoteDirectoryTests.java b/server/src/test/java/org/opensearch/index/store/RemoteDirectoryTests.java
index ee81369725e6f..ed79a2b0bd8e4 100644
--- a/server/src/test/java/org/opensearch/index/store/RemoteDirectoryTests.java
+++ b/server/src/test/java/org/opensearch/index/store/RemoteDirectoryTests.java
@@ -20,7 +20,9 @@
 import org.opensearch.common.blobstore.BlobMetadata;
 import org.opensearch.common.blobstore.stream.write.WriteContext;
 import org.opensearch.common.blobstore.support.PlainBlobMetadata;
+import org.opensearch.common.lucene.store.ByteArrayIndexInput;
 import org.opensearch.core.action.ActionListener;
+import org.opensearch.index.store.remote.utils.BlockIOContext;
 import org.opensearch.test.OpenSearchTestCase;
 import org.junit.Before;
 
@@ -216,6 +218,17 @@ public void testOpenInput() throws IOException {
         assertTrue(indexInput instanceof RemoteIndexInput);
         assertEquals(100, indexInput.length());
         verify(blobContainer).listBlobsByPrefixInSortedOrder("segment_1", 1, LEXICOGRAPHIC);
+
+        BlockIOContext blockIOContextInvalidValues = new BlockIOContext(IOContext.DEFAULT, 10, 1000);
+        assertThrows(IllegalArgumentException.class, () -> remoteDirectory.openInput("segment_1", blockIOContextInvalidValues));
+
+        BlockIOContext blockIOContext = new BlockIOContext(IOContext.DEFAULT, 10, 50);
+        when(blobContainer.readBlob("segment_1", 10, 50)).thenReturn(mockInputStream);
+        byte[] bytes = new byte[(int) blockIOContext.getBlockSize()];
+        when(mockInputStream.readAllBytes()).thenReturn(bytes);
+        indexInput = remoteDirectory.openInput("segment_1", blockIOContext);
+        assertTrue(indexInput instanceof ByteArrayIndexInput);
+        assertEquals(blockIOContext.getBlockSize(), indexInput.length());
     }
 
     public void testOpenInputWithLength() throws IOException {
diff --git a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactoryTests.java b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactoryTests.java
index cad5e47531cc6..95b5d4456baf6 100644
--- a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactoryTests.java
+++ b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryFactoryTests.java
@@ -57,7 +57,7 @@ public void setup() {
         repositoriesService = mock(RepositoriesService.class);
         threadPool = mock(ThreadPool.class);
         when(repositoriesServiceSupplier.get()).thenReturn(repositoriesService);
-        remoteSegmentStoreDirectoryFactory = new RemoteSegmentStoreDirectoryFactory(repositoriesServiceSupplier, threadPool);
+        remoteSegmentStoreDirectoryFactory = new RemoteSegmentStoreDirectoryFactory(repositoriesServiceSupplier, threadPool, "");
     }
 
     public void testNewDirectory() throws IOException {
diff --git a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryTests.java b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryTests.java
index 567199cf64cd8..336d4bafd4b66 100644
--- a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryTests.java
+++ b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryTests.java
@@ -10,7 +10,6 @@
 
 import org.apache.logging.log4j.Level;
 import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.apache.lucene.codecs.CodecUtil;
 import org.apache.lucene.index.CorruptIndexException;
 import org.apache.lucene.index.IndexFormatTooNewException;
@@ -23,34 +22,25 @@
 import org.apache.lucene.store.OutputStreamIndexOutput;
 import org.apache.lucene.tests.util.LuceneTestCase;
 import org.apache.lucene.util.Version;
-import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
 import org.opensearch.common.blobstore.stream.write.WriteContext;
 import org.opensearch.common.io.VersionedCodecStreamWrapper;
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.lucene.store.ByteArrayIndexInput;
-import org.opensearch.common.settings.Settings;
-import org.opensearch.common.util.concurrent.OpenSearchExecutors;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.bytes.BytesReference;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
-import org.opensearch.index.engine.NRTReplicationEngineFactory;
 import org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm;
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.remote.RemoteStoreUtils;
-import org.opensearch.index.shard.IndexShard;
-import org.opensearch.index.shard.IndexShardTestCase;
-import org.opensearch.index.store.lockmanager.RemoteStoreMetadataLockManager;
 import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadata;
 import org.opensearch.index.store.remote.metadata.RemoteSegmentMetadataHandler;
-import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.test.MockLogAppender;
 import org.opensearch.test.junit.annotations.TestLogging;
 import org.opensearch.threadpool.ThreadPool;
-import org.junit.After;
 import org.junit.Before;
 
 import java.io.ByteArrayInputStream;
@@ -64,7 +54,6 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
@@ -87,95 +76,11 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-public class RemoteSegmentStoreDirectoryTests extends IndexShardTestCase {
-    private static final Logger logger = LogManager.getLogger(RemoteSegmentStoreDirectoryTests.class);
-    private RemoteDirectory remoteDataDirectory;
-    private RemoteDirectory remoteMetadataDirectory;
-    private RemoteStoreMetadataLockManager mdLockManager;
-
-    private RemoteSegmentStoreDirectory remoteSegmentStoreDirectory;
-    private TestUploadListener testUploadTracker;
-    private IndexShard indexShard;
-    private SegmentInfos segmentInfos;
-    private ThreadPool threadPool;
-
-    private final String metadataFilename = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
-        12,
-        23,
-        34,
-        1,
-        1,
-        "node-1"
-    );
-
-    private final String metadataFilenameDup = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
-        12,
-        23,
-        34,
-        2,
-        1,
-        "node-2"
-    );
-    private final String metadataFilename2 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
-        12,
-        13,
-        34,
-        1,
-        1,
-        "node-1"
-    );
-    private final String metadataFilename3 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
-        10,
-        38,
-        34,
-        1,
-        1,
-        "node-1"
-    );
-    private final String metadataFilename4 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
-        10,
-        36,
-        34,
-        1,
-        1,
-        "node-1"
-    );
+public class RemoteSegmentStoreDirectoryTests extends BaseRemoteSegmentStoreDirectoryTests {
 
     @Before
     public void setup() throws IOException {
-        remoteDataDirectory = mock(RemoteDirectory.class);
-        remoteMetadataDirectory = mock(RemoteDirectory.class);
-        mdLockManager = mock(RemoteStoreMetadataLockManager.class);
-        threadPool = mock(ThreadPool.class);
-        testUploadTracker = new TestUploadListener();
-
-        Settings indexSettings = Settings.builder()
-            .put(IndexMetadata.SETTING_VERSION_CREATED, org.opensearch.Version.CURRENT)
-            .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
-            .build();
-        ExecutorService executorService = OpenSearchExecutors.newDirectExecutorService();
-
-        indexShard = newStartedShard(false, indexSettings, new NRTReplicationEngineFactory());
-        remoteSegmentStoreDirectory = new RemoteSegmentStoreDirectory(
-            remoteDataDirectory,
-            remoteMetadataDirectory,
-            mdLockManager,
-            threadPool,
-            indexShard.shardId()
-        );
-        try (Store store = indexShard.store()) {
-            segmentInfos = store.readLastCommittedSegmentsInfo();
-        }
-
-        when(threadPool.executor(ThreadPool.Names.REMOTE_PURGE)).thenReturn(executorService);
-        when(threadPool.executor(ThreadPool.Names.REMOTE_RECOVERY)).thenReturn(executorService);
-        when(threadPool.executor(ThreadPool.Names.SAME)).thenReturn(executorService);
-    }
-
-    @After
-    public void tearDown() throws Exception {
-        indexShard.close("test tearDown", true, false);
-        super.tearDown();
+        setupRemoteSegmentStoreDirectory();
     }
 
     public void testUploadedSegmentMetadataToString() {
@@ -256,60 +161,6 @@ public void testInitMultipleMetadataFile() throws IOException {
         assertThrows(IllegalStateException.class, () -> remoteSegmentStoreDirectory.init());
     }
 
-    private Map<String, Map<String, String>> populateMetadata() throws IOException {
-        List<String> metadataFiles = new ArrayList<>();
-
-        metadataFiles.add(metadataFilename);
-        metadataFiles.add(metadataFilename2);
-        metadataFiles.add(metadataFilename3);
-
-        when(
-            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
-                RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX,
-                METADATA_FILES_TO_FETCH
-            )
-        ).thenReturn(List.of(metadataFilename));
-        when(
-            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
-                RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX,
-                Integer.MAX_VALUE
-            )
-        ).thenReturn(metadataFiles);
-
-        Map<String, Map<String, String>> metadataFilenameContentMapping = Map.of(
-            metadataFilename,
-            getDummyMetadata("_0", 1),
-            metadataFilename2,
-            getDummyMetadata("_0", 1),
-            metadataFilename3,
-            getDummyMetadata("_0", 1)
-        );
-
-        when(remoteMetadataDirectory.getBlobStream(metadataFilename)).thenAnswer(
-            I -> createMetadataFileBytes(
-                metadataFilenameContentMapping.get(metadataFilename),
-                indexShard.getLatestReplicationCheckpoint(),
-                segmentInfos
-            )
-        );
-        when(remoteMetadataDirectory.getBlobStream(metadataFilename2)).thenAnswer(
-            I -> createMetadataFileBytes(
-                metadataFilenameContentMapping.get(metadataFilename2),
-                indexShard.getLatestReplicationCheckpoint(),
-                segmentInfos
-            )
-        );
-        when(remoteMetadataDirectory.getBlobStream(metadataFilename3)).thenAnswer(
-            I -> createMetadataFileBytes(
-                metadataFilenameContentMapping.get(metadataFilename3),
-                indexShard.getLatestReplicationCheckpoint(),
-                segmentInfos
-            )
-        );
-
-        return metadataFilenameContentMapping;
-    }
-
     public void testInit() throws IOException {
         populateMetadata();
 
@@ -1290,6 +1141,62 @@ public void testMetadataFileNameOrder() {
         assertEquals(14, count);
     }
 
+    public void testInitializeToSpecificTimestampNoMetadataFiles() throws IOException {
+        when(
+            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX,
+                Integer.MAX_VALUE
+            )
+        ).thenReturn(new ArrayList<>());
+        assertNull(remoteSegmentStoreDirectory.initializeToSpecificTimestamp(1234L));
+    }
+
+    public void testInitializeToSpecificTimestampNoMdMatchingTimestamp() throws IOException {
+        String metadataPrefix = "metadata__1__2__3__4__5__";
+        List<String> metadataFiles = new ArrayList<>();
+        metadataFiles.add(metadataPrefix + RemoteStoreUtils.invertLong(2000));
+        metadataFiles.add(metadataPrefix + RemoteStoreUtils.invertLong(3000));
+        metadataFiles.add(metadataPrefix + RemoteStoreUtils.invertLong(4000));
+
+        when(
+            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX,
+                Integer.MAX_VALUE
+            )
+        ).thenReturn(metadataFiles);
+        assertNull(remoteSegmentStoreDirectory.initializeToSpecificTimestamp(1234L));
+    }
+
+    public void testInitializeToSpecificTimestampMatchingMdFile() throws IOException {
+        String metadataPrefix = "metadata__1__2__3__4__5__";
+        List<String> metadataFiles = new ArrayList<>();
+        metadataFiles.add(metadataPrefix + RemoteStoreUtils.invertLong(1000));
+        metadataFiles.add(metadataPrefix + RemoteStoreUtils.invertLong(2000));
+        metadataFiles.add(metadataPrefix + RemoteStoreUtils.invertLong(3000));
+
+        Map<String, String> metadata = new HashMap<>();
+        metadata.put("_0.cfe", "_0.cfe::_0.cfe__" + UUIDs.base64UUID() + "::1234::512::" + Version.LATEST.major);
+        metadata.put("_0.cfs", "_0.cfs::_0.cfs__" + UUIDs.base64UUID() + "::2345::1024::" + Version.LATEST.major);
+
+        when(
+            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+                RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX,
+                Integer.MAX_VALUE
+            )
+        ).thenReturn(metadataFiles);
+        when(remoteMetadataDirectory.getBlobStream(metadataPrefix + RemoteStoreUtils.invertLong(1000))).thenReturn(
+            createMetadataFileBytes(metadata, indexShard.getLatestReplicationCheckpoint(), segmentInfos)
+        );
+
+        RemoteSegmentMetadata remoteSegmentMetadata = remoteSegmentStoreDirectory.initializeToSpecificTimestamp(1234L);
+        assertNotNull(remoteSegmentMetadata);
+        Map<String, RemoteSegmentStoreDirectory.UploadedSegmentMetadata> uploadedSegments = remoteSegmentStoreDirectory
+            .getSegmentsUploadedToRemoteStore();
+        assertEquals(2, uploadedSegments.size());
+        assertTrue(uploadedSegments.containsKey("_0.cfe"));
+        assertTrue(uploadedSegments.containsKey("_0.cfs"));
+    }
+
     private static class WrapperIndexOutput extends IndexOutput {
         public IndexOutput indexOutput;
 
diff --git a/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryWithPinnedTimestampTests.java b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryWithPinnedTimestampTests.java
new file mode 100644
index 0000000000000..e71023125d4cd
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/store/RemoteSegmentStoreDirectoryWithPinnedTimestampTests.java
@@ -0,0 +1,216 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store;
+
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.BlobStore;
+import org.opensearch.common.blobstore.support.PlainBlobMetadata;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.node.Node;
+import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import org.mockito.Mockito;
+
+import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED;
+import static org.hamcrest.CoreMatchers.is;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+public class RemoteSegmentStoreDirectoryWithPinnedTimestampTests extends RemoteSegmentStoreDirectoryTests {
+
+    Runnable updatePinnedTimstampTask;
+    BlobContainer blobContainer;
+    RemoteStorePinnedTimestampService remoteStorePinnedTimestampServiceSpy;
+
+    @Before
+    public void setupPinnedTimestamp() throws IOException {
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(
+            Settings.builder().put(CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true).build(),
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
+
+        Supplier<RepositoriesService> repositoriesServiceSupplier = mock(Supplier.class);
+        Settings settings = Settings.builder()
+            .put(Node.NODE_ATTRIBUTES.getKey() + RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "remote-repo")
+            .build();
+        RepositoriesService repositoriesService = mock(RepositoriesService.class);
+        when(repositoriesServiceSupplier.get()).thenReturn(repositoriesService);
+        BlobStoreRepository blobStoreRepository = mock(BlobStoreRepository.class);
+        when(repositoriesService.repository("remote-repo")).thenReturn(blobStoreRepository);
+
+        when(threadPool.schedule(any(), any(), any())).then(invocationOnMock -> {
+            updatePinnedTimstampTask = invocationOnMock.getArgument(0);
+            updatePinnedTimstampTask.run();
+            return null;
+        }).then(subsequentInvocationsOnMock -> null);
+
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = new RemoteStorePinnedTimestampService(
+            repositoriesServiceSupplier,
+            settings,
+            threadPool,
+            clusterService
+        );
+        remoteStorePinnedTimestampServiceSpy = Mockito.spy(remoteStorePinnedTimestampService);
+
+        BlobStore blobStore = mock(BlobStore.class);
+        when(blobStoreRepository.blobStore()).thenReturn(blobStore);
+        when(blobStoreRepository.basePath()).thenReturn(new BlobPath());
+        blobContainer = mock(BlobContainer.class);
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+
+        when(blobContainer.listBlobs()).thenReturn(new HashMap<>());
+
+        remoteStorePinnedTimestampServiceSpy.start();
+
+        metadataWithOlderTimestamp();
+    }
+
+    private void metadataWithOlderTimestamp() {
+        metadataFilename = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
+            12,
+            23,
+            34,
+            1,
+            1,
+            "node-1",
+            System.currentTimeMillis() - 300000
+        );
+        metadataFilename2 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
+            12,
+            13,
+            34,
+            1,
+            1,
+            "node-1",
+            System.currentTimeMillis() - 400000
+        );
+        metadataFilename3 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
+            10,
+            38,
+            34,
+            1,
+            1,
+            "node-1",
+            System.currentTimeMillis() - 500000
+        );
+        metadataFilename4 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
+            10,
+            36,
+            34,
+            1,
+            1,
+            "node-1",
+            System.currentTimeMillis() - 600000
+        );
+    }
+
+    public void testDeleteStaleCommitsNoPinnedTimestampMdFilesLatest() throws Exception {
+        metadataFilename = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
+            12,
+            23,
+            34,
+            1,
+            1,
+            "node-1",
+            System.currentTimeMillis()
+        );
+        metadataFilename2 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
+            12,
+            13,
+            34,
+            1,
+            1,
+            "node-1",
+            System.currentTimeMillis()
+        );
+        metadataFilename3 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getMetadataFilename(
+            10,
+            38,
+            34,
+            1,
+            1,
+            "node-1",
+            System.currentTimeMillis()
+        );
+
+        when(
+            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+                eq(RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX),
+                anyInt()
+            )
+        ).thenReturn(List.of(metadataFilename, metadataFilename2, metadataFilename3));
+
+        populateMetadata();
+        remoteSegmentStoreDirectory.init();
+
+        // populateMetadata() adds stub to return 3 metadata files
+        // We are passing lastNMetadataFilesToKeep=2 here so that oldest 1 metadata file will be deleted
+        // But as the oldest metadata file's timestamp is within time threshold since last successful fetch,
+        // GC will skip deleting any data or metadata files.
+        remoteSegmentStoreDirectory.deleteStaleSegmentsAsync(2);
+
+        assertBusy(() -> assertThat(remoteSegmentStoreDirectory.canDeleteStaleCommits.get(), is(true)));
+        verify(remoteDataDirectory, times(0)).deleteFile(any());
+        verify(remoteMetadataDirectory, times(0)).deleteFile(any());
+    }
+
+    public void testDeleteStaleCommitsPinnedTimestampMdFile() throws Exception {
+        when(
+            remoteMetadataDirectory.listFilesByPrefixInLexicographicOrder(
+                eq(RemoteSegmentStoreDirectory.MetadataFilenameUtils.METADATA_PREFIX),
+                anyInt()
+            )
+        ).thenReturn(List.of(metadataFilename, metadataFilename2, metadataFilename3));
+
+        long pinnedTimestampMatchingMetadataFilename2 = RemoteSegmentStoreDirectory.MetadataFilenameUtils.getTimestamp(metadataFilename2) + 10;
+        String blobName = "snapshot1__" + pinnedTimestampMatchingMetadataFilename2;
+        when(blobContainer.listBlobs()).thenReturn(Map.of(blobName, new PlainBlobMetadata(blobName, 100)));
+
+        final Map<String, Map<String, String>> metadataFilenameContentMapping = populateMetadata();
+        final List<String> filesToBeDeleted = metadataFilenameContentMapping.get(metadataFilename3)
+            .values()
+            .stream()
+            .map(metadata -> metadata.split(RemoteSegmentStoreDirectory.UploadedSegmentMetadata.SEPARATOR)[1])
+            .collect(Collectors.toList());
+
+        updatePinnedTimstampTask.run();
+
+        remoteSegmentStoreDirectory.init();
+
+        // popluateMetadata() adds stub to return 3 metadata files
+        // We are passing lastNMetadataFilesToKeep=2 here so that oldest 1 metadata file will be deleted
+        remoteSegmentStoreDirectory.deleteStaleSegmentsAsync(1);
+
+        for (final String file : filesToBeDeleted) {
+            verify(remoteDataDirectory).deleteFile(file);
+        }
+        assertBusy(() -> assertThat(remoteSegmentStoreDirectory.canDeleteStaleCommits.get(), is(true)));
+        verify(remoteMetadataDirectory).deleteFile(metadataFilename3);
+        verify(remoteMetadataDirectory, times(0)).deleteFile(metadataFilename2);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactoryTests.java b/server/src/test/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactoryTests.java
index de3dfbdaa4778..37ae0484d5ee1 100644
--- a/server/src/test/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactoryTests.java
+++ b/server/src/test/java/org/opensearch/index/store/lockmanager/RemoteStoreLockManagerFactoryTests.java
@@ -42,7 +42,7 @@ public void setup() throws IOException {
         repositoriesServiceSupplier = mock(Supplier.class);
         repositoriesService = mock(RepositoriesService.class);
         when(repositoriesServiceSupplier.get()).thenReturn(repositoriesService);
-        remoteStoreLockManagerFactory = new RemoteStoreLockManagerFactory(repositoriesServiceSupplier);
+        remoteStoreLockManagerFactory = new RemoteStoreLockManagerFactory(repositoriesServiceSupplier, "");
     }
 
     public void testNewLockManager() throws IOException {
diff --git a/server/src/test/java/org/opensearch/index/store/remote/file/OnDemandBlockSnapshotIndexInputTests.java b/server/src/test/java/org/opensearch/index/store/remote/file/OnDemandBlockSnapshotIndexInputTests.java
index a135802c5f49c..c7d0cc0c5b96e 100644
--- a/server/src/test/java/org/opensearch/index/store/remote/file/OnDemandBlockSnapshotIndexInputTests.java
+++ b/server/src/test/java/org/opensearch/index/store/remote/file/OnDemandBlockSnapshotIndexInputTests.java
@@ -207,7 +207,7 @@ private void initBlockFiles(int blockSize, FSDirectory fsDirectory) {
             // write 48, -80 alternatively
             for (int i = 0; i < numOfBlocks; i++) {
                 // create normal blocks
-                String blockName = BLOCK_FILE_PREFIX + "." + i;
+                String blockName = BLOCK_FILE_PREFIX + "_block_" + i;
                 IndexOutput output = fsDirectory.createOutput(blockName, null);
                 // since block size is always even number, safe to do division
                 for (int j = 0; j < blockSize / 2; j++) {
@@ -221,7 +221,7 @@ private void initBlockFiles(int blockSize, FSDirectory fsDirectory) {
 
             if (numOfBlocks > 1 && sizeOfLastBlock != 0) {
                 // create last block
-                String lastBlockName = BLOCK_FILE_PREFIX + "." + numOfBlocks;
+                String lastBlockName = BLOCK_FILE_PREFIX + "_block_" + numOfBlocks;
                 IndexOutput output = fsDirectory.createOutput(lastBlockName, null);
                 for (int i = 0; i < sizeOfLastBlock; i++) {
                     if ((i & 1) == 0) {
diff --git a/server/src/test/java/org/opensearch/index/store/remote/filecache/FileCachedIndexInputTests.java b/server/src/test/java/org/opensearch/index/store/remote/filecache/FileCachedIndexInputTests.java
new file mode 100644
index 0000000000000..258bc2db4c5d0
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/store/remote/filecache/FileCachedIndexInputTests.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.filecache;
+
+import org.apache.lucene.store.FSDirectory;
+import org.apache.lucene.store.IOContext;
+import org.apache.lucene.store.IndexInput;
+import org.apache.lucene.store.IndexOutput;
+import org.opensearch.core.common.breaker.CircuitBreaker;
+import org.opensearch.core.common.breaker.NoopCircuitBreaker;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+public class FileCachedIndexInputTests extends OpenSearchTestCase {
+
+    protected FileCache fileCache;
+    protected Path filePath;
+    protected IndexInput underlyingIndexInput;
+    private FileCachedIndexInput fileCachedIndexInput;
+
+    protected static final int FILE_CACHE_CAPACITY = 1000;
+    protected static final String TEST_FILE = "test_file";
+    protected static final String SLICE_DESC = "slice_description";
+
+    @Before
+    public void setup() throws IOException {
+        Path basePath = createTempDir("FileCachedIndexInputTests");
+        FSDirectory fsDirectory = FSDirectory.open(basePath);
+        IndexOutput indexOutput = fsDirectory.createOutput(TEST_FILE, IOContext.DEFAULT);
+        // Writing to the file so that it's size is not zero
+        indexOutput.writeInt(100);
+        indexOutput.close();
+        filePath = basePath.resolve(TEST_FILE);
+        underlyingIndexInput = fsDirectory.openInput(TEST_FILE, IOContext.DEFAULT);
+        fileCache = FileCacheFactory.createConcurrentLRUFileCache(FILE_CACHE_CAPACITY, new NoopCircuitBreaker(CircuitBreaker.REQUEST));
+    }
+
+    protected void setupIndexInputAndAddToFileCache() {
+        fileCachedIndexInput = new FileCachedIndexInput(fileCache, filePath, underlyingIndexInput);
+        fileCache.put(filePath, new CachedFullFileIndexInput(fileCache, filePath, fileCachedIndexInput));
+    }
+
+    public void testClone() throws IOException {
+        setupIndexInputAndAddToFileCache();
+
+        // Since the file ia already in cache and has refCount 1, activeUsage and totalUsage will be same
+        assertTrue(isActiveAndTotalUsageSame());
+
+        // Decrementing the refCount explicitly on the file which will make it inactive (as refCount will drop to 0)
+        fileCache.decRef(filePath);
+        assertFalse(isActiveAndTotalUsageSame());
+
+        // After cloning the refCount will increase again and activeUsage and totalUsage will be same again
+        FileCachedIndexInput clonedFileCachedIndexInput = fileCachedIndexInput.clone();
+        assertTrue(isActiveAndTotalUsageSame());
+
+        // Closing the clone will again decrease the refCount making it 0
+        clonedFileCachedIndexInput.close();
+        assertFalse(isActiveAndTotalUsageSame());
+    }
+
+    public void testSlice() throws IOException {
+        setupIndexInputAndAddToFileCache();
+        assertThrows(UnsupportedOperationException.class, () -> fileCachedIndexInput.slice(SLICE_DESC, 10, 100));
+    }
+
+    protected boolean isActiveAndTotalUsageSame() {
+        return fileCache.usage().activeUsage() == fileCache.usage().usage();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/store/remote/filecache/FullFileCachedIndexInputTests.java b/server/src/test/java/org/opensearch/index/store/remote/filecache/FullFileCachedIndexInputTests.java
new file mode 100644
index 0000000000000..7fb7a03584e20
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/store/remote/filecache/FullFileCachedIndexInputTests.java
@@ -0,0 +1,79 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.filecache;
+
+import org.apache.lucene.store.AlreadyClosedException;
+import org.apache.lucene.store.IndexInput;
+
+import java.io.IOException;
+
+public class FullFileCachedIndexInputTests extends FileCachedIndexInputTests {
+    private FullFileCachedIndexInput fullFileCachedIndexInput;
+
+    @Override
+    protected void setupIndexInputAndAddToFileCache() {
+        fullFileCachedIndexInput = new FullFileCachedIndexInput(fileCache, filePath, underlyingIndexInput);
+        fileCache.put(filePath, new CachedFullFileIndexInput(fileCache, filePath, fullFileCachedIndexInput));
+    }
+
+    @Override
+    public void testClone() throws IOException {
+        setupIndexInputAndAddToFileCache();
+
+        // Since the file is already in cache and has refCount 1, activeUsage and totalUsage will be same
+        assertTrue(isActiveAndTotalUsageSame());
+
+        // Getting the file cache entry (which wil increase the ref count, hence doing dec ref immediately afterwards)
+        CachedIndexInput cachedIndexInput = fileCache.get(filePath);
+        fileCache.decRef(filePath);
+
+        // Decrementing the refCount explicitly on the file which will make it inactive (as refCount will drop to 0)
+        fileCache.decRef(filePath);
+        assertFalse(isActiveAndTotalUsageSame());
+
+        // After cloning the refCount will increase again and activeUsage and totalUsage will be same again
+        FileCachedIndexInput clonedFileCachedIndexInput1 = fullFileCachedIndexInput.clone();
+        FileCachedIndexInput clonedFileCachedIndexInput2 = clonedFileCachedIndexInput1.clone();
+        FileCachedIndexInput clonedFileCachedIndexInput3 = clonedFileCachedIndexInput2.clone();
+        assertTrue(isActiveAndTotalUsageSame());
+
+        // closing the first level clone will close all subsequent level clones and reduce ref count to 0
+        clonedFileCachedIndexInput1.close();
+        assertFalse(isActiveAndTotalUsageSame());
+
+        fileCache.prune();
+
+        // since the file cache entry was evicted the corresponding CachedIndexInput will be closed and will throw exception when trying to
+        // read the index input
+        assertThrows(AlreadyClosedException.class, cachedIndexInput::getIndexInput);
+    }
+
+    @Override
+    public void testSlice() throws IOException {
+        setupIndexInputAndAddToFileCache();
+
+        // Throw IllegalArgumentException if offset is negative
+        assertThrows(IllegalArgumentException.class, () -> fullFileCachedIndexInput.slice(SLICE_DESC, -1, 10));
+
+        // Throw IllegalArgumentException if length is negative
+        assertThrows(IllegalArgumentException.class, () -> fullFileCachedIndexInput.slice(SLICE_DESC, 5, -1));
+
+        // Decrementing the refCount explicitly on the file which will make it inactive (as refCount will drop to 0)
+        fileCache.decRef(filePath);
+        assertFalse(isActiveAndTotalUsageSame());
+
+        // Creating a slice will increase the refCount
+        IndexInput slicedFileCachedIndexInput = fullFileCachedIndexInput.slice(SLICE_DESC, 1, 2);
+        assertTrue(isActiveAndTotalUsageSame());
+
+        // Closing the parent will close all the slices as well decreasing the refCount to 0
+        fullFileCachedIndexInput.close();
+        assertFalse(isActiveAndTotalUsageSame());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerBlobContainerReaderTests.java b/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerBlobContainerReaderTests.java
new file mode 100644
index 0000000000000..24e57cde3ffda
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerBlobContainerReaderTests.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.utils;
+
+import org.opensearch.common.blobstore.BlobContainer;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+
+public class TransferManagerBlobContainerReaderTests extends TransferManagerTestCase {
+    private BlobContainer blobContainer;
+
+    @Override
+    protected void initializeTransferManager() throws IOException {
+        blobContainer = mock(BlobContainer.class);
+        doAnswer(i -> new ByteArrayInputStream(createData())).when(blobContainer).readBlob(eq("blob"), anyLong(), anyLong());
+        transferManager = new TransferManager(blobContainer::readBlob, fileCache);
+    }
+
+    protected void mockExceptionWhileReading() throws IOException {
+        doThrow(new IOException("Expected test exception")).when(blobContainer).readBlob(eq("failure-blob"), anyLong(), anyLong());
+    }
+
+    protected void mockWaitForLatchReader(CountDownLatch latch) throws IOException {
+        doAnswer(i -> {
+            latch.await();
+            return new ByteArrayInputStream(createData());
+        }).when(blobContainer).readBlob(eq("blocking-blob"), anyLong(), anyLong());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerRemoteDirectoryReaderTests.java b/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerRemoteDirectoryReaderTests.java
new file mode 100644
index 0000000000000..e777a287bf10f
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerRemoteDirectoryReaderTests.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.store.remote.utils;
+
+import org.apache.lucene.store.IOContext;
+import org.opensearch.common.lucene.store.ByteArrayIndexInput;
+import org.opensearch.common.lucene.store.InputStreamIndexInput;
+import org.opensearch.index.store.RemoteDirectory;
+
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+
+public class TransferManagerRemoteDirectoryReaderTests extends TransferManagerTestCase {
+    private RemoteDirectory remoteDirectory;
+
+    @Override
+    protected void initializeTransferManager() throws IOException {
+        remoteDirectory = mock(RemoteDirectory.class);
+        doAnswer(i -> new ByteArrayIndexInput("blob", createData())).when(remoteDirectory).openInput(eq("blob"), any());
+        transferManager = new TransferManager(
+            (name, position, length) -> new InputStreamIndexInput(
+                remoteDirectory.openInput(name, new BlockIOContext(IOContext.DEFAULT, position, length)),
+                length
+            ),
+            fileCache
+        );
+    }
+
+    protected void mockExceptionWhileReading() throws IOException {
+        doThrow(new IOException("Expected test exception")).when(remoteDirectory).openInput(eq("failure-blob"), any());
+    }
+
+    protected void mockWaitForLatchReader(CountDownLatch latch) throws IOException {
+        doAnswer(i -> {
+            latch.await();
+            return new ByteArrayIndexInput("blocking-blob", createData());
+        }).when(remoteDirectory).openInput(eq("blocking-blob"), any());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerTests.java b/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerTestCase.java
similarity index 87%
rename from server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerTests.java
rename to server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerTestCase.java
index 7ae3944eb6944..810a4c336fdf7 100644
--- a/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerTests.java
+++ b/server/src/test/java/org/opensearch/index/store/remote/utils/TransferManagerTestCase.java
@@ -13,7 +13,6 @@
 import org.apache.lucene.store.IndexInput;
 import org.apache.lucene.store.MMapDirectory;
 import org.apache.lucene.store.SimpleFSLockFactory;
-import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.core.common.breaker.CircuitBreaker;
 import org.opensearch.core.common.breaker.NoopCircuitBreaker;
 import org.opensearch.index.store.remote.file.CleanerDaemonThreadLeakFilter;
@@ -24,7 +23,6 @@
 import org.junit.After;
 import org.junit.Before;
 
-import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
@@ -36,31 +34,23 @@
 
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
 
 @ThreadLeakFilters(filters = CleanerDaemonThreadLeakFilter.class)
-public class TransferManagerTests extends OpenSearchTestCase {
-    private static final int EIGHT_MB = 1024 * 1024 * 8;
-    private final FileCache fileCache = FileCacheFactory.createConcurrentLRUFileCache(
+public abstract class TransferManagerTestCase extends OpenSearchTestCase {
+    protected static final int EIGHT_MB = 1024 * 1024 * 8;
+    protected final FileCache fileCache = FileCacheFactory.createConcurrentLRUFileCache(
         EIGHT_MB * 2,
         1,
         new NoopCircuitBreaker(CircuitBreaker.REQUEST)
     );
-    private MMapDirectory directory;
-    private BlobContainer blobContainer;
-    private TransferManager transferManager;
+    protected MMapDirectory directory;
+    protected TransferManager transferManager;
 
     @Before
     public void setUp() throws Exception {
         super.setUp();
         directory = new MMapDirectory(createTempDir(), SimpleFSLockFactory.INSTANCE);
-        blobContainer = mock(BlobContainer.class);
-        doAnswer(i -> new ByteArrayInputStream(createData())).when(blobContainer).readBlob(eq("blob"), anyLong(), anyLong());
-        transferManager = new TransferManager(blobContainer, fileCache);
+        initializeTransferManager();
     }
 
     @After
@@ -68,7 +58,7 @@ public void tearDown() throws Exception {
         super.tearDown();
     }
 
-    private static byte[] createData() {
+    protected static byte[] createData() {
         final byte[] data = new byte[EIGHT_MB];
         data[EIGHT_MB - 1] = 7;
         return data;
@@ -162,7 +152,7 @@ public void testUsageExceedsCapacity() throws Exception {
     }
 
     public void testDownloadFails() throws Exception {
-        doThrow(new IOException("Expected test exception")).when(blobContainer).readBlob(eq("failure-blob"), anyLong(), anyLong());
+        mockExceptionWhileReading();
         List<BlobFetchRequest.BlobPart> blobParts = new ArrayList<>();
         blobParts.add(new BlobFetchRequest.BlobPart("failure-blob", 0, EIGHT_MB));
         expectThrows(
@@ -177,10 +167,7 @@ public void testFetchesToDifferentBlobsDoNotBlockOnEachOther() throws Exception
         // Mock a call for a blob that will block until the latch is released,
         // then start the fetch for that blob on a separate thread
         final CountDownLatch latch = new CountDownLatch(1);
-        doAnswer(i -> {
-            latch.await();
-            return new ByteArrayInputStream(createData());
-        }).when(blobContainer).readBlob(eq("blocking-blob"), anyLong(), anyLong());
+        mockWaitForLatchReader(latch);
         List<BlobFetchRequest.BlobPart> blobParts = new ArrayList<>();
         blobParts.add(new BlobFetchRequest.BlobPart("blocking-blob", 0, EIGHT_MB));
 
@@ -206,6 +193,12 @@ public void testFetchesToDifferentBlobsDoNotBlockOnEachOther() throws Exception
         assertFalse(blockingThread.isAlive());
     }
 
+    protected abstract void initializeTransferManager() throws IOException;
+
+    protected abstract void mockExceptionWhileReading() throws IOException;
+
+    protected abstract void mockWaitForLatchReader(CountDownLatch latch) throws IOException;
+
     private IndexInput fetchBlobWithName(String blobname) throws IOException {
         List<BlobFetchRequest.BlobPart> blobParts = new ArrayList<>();
         blobParts.add(new BlobFetchRequest.BlobPart("blob", 0, EIGHT_MB));
diff --git a/server/src/test/java/org/opensearch/index/store/remote/utils/cache/RefCountedCacheTestCase.java b/server/src/test/java/org/opensearch/index/store/remote/utils/cache/RefCountedCacheTestCase.java
index b11740b53e11f..97e9fb288136d 100644
--- a/server/src/test/java/org/opensearch/index/store/remote/utils/cache/RefCountedCacheTestCase.java
+++ b/server/src/test/java/org/opensearch/index/store/remote/utils/cache/RefCountedCacheTestCase.java
@@ -211,6 +211,15 @@ public void testComputeStats() {
         assertEquals(1, refCountedCache.stats().removeCount());
     }
 
+    public void testClear() {
+        refCountedCache.put("1", 10L);
+        refCountedCache.put("2", 10L);
+        refCountedCache.put("3", 10L);
+        assertEquals(30L, refCountedCache.usage().usage());
+        refCountedCache.clear();
+        assertEquals(0L, refCountedCache.usage().usage());
+    }
+
     private void assertUsage(long usage, long activeUsage) {
         assertEquals(usage, refCountedCache.usage().usage());
         assertEquals(activeUsage, refCountedCache.usage().activeUsage());
diff --git a/server/src/test/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslogTests.java b/server/src/test/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslogTests.java
new file mode 100644
index 0000000000000..1f82dd9d7e641
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/translog/RemoteFsTimestampAwareTranslogTests.java
@@ -0,0 +1,862 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.translog;
+
+import org.apache.lucene.tests.util.LuceneTestCase;
+import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.metadata.RepositoryMetadata;
+import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobMetadata;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.BlobStore;
+import org.opensearch.common.blobstore.support.PlainBlobMetadata;
+import org.opensearch.common.collect.Tuple;
+import org.opensearch.common.lease.Releasable;
+import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.index.remote.RemoteStoreUtils;
+import org.opensearch.index.remote.RemoteTranslogTransferTracker;
+import org.opensearch.index.seqno.SequenceNumbers;
+import org.opensearch.index.translog.transfer.TranslogTransferManager;
+import org.opensearch.index.translog.transfer.TranslogTransferMetadata;
+import org.opensearch.index.translog.transfer.TranslogUploadFailedException;
+import org.opensearch.indices.DefaultRemoteStoreSettings;
+import org.opensearch.indices.RemoteStoreSettings;
+import org.opensearch.node.Node;
+import org.opensearch.node.remotestore.RemoteStoreNodeAttribute;
+import org.opensearch.node.remotestore.RemoteStorePinnedTimestampService;
+import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.blobstore.BlobStoreTestUtil;
+import org.opensearch.repositories.fs.FsRepository;
+import org.opensearch.threadpool.ThreadPool;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.CountDownLatch;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.LongStream;
+
+import org.mockito.Mockito;
+
+import static org.opensearch.index.translog.TranslogDeletionPolicies.createTranslogDeletionPolicy;
+import static org.opensearch.index.translog.transfer.TranslogTransferMetadata.METADATA_SEPARATOR;
+import static org.opensearch.indices.RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@LuceneTestCase.SuppressFileSystems("ExtrasFS")
+public class RemoteFsTimestampAwareTranslogTests extends RemoteFsTranslogTests {
+
+    Runnable updatePinnedTimstampTask;
+    BlobContainer blobContainer;
+    RemoteStorePinnedTimestampService remoteStorePinnedTimestampServiceSpy;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+
+        RemoteStoreSettings remoteStoreSettings = new RemoteStoreSettings(
+            Settings.builder().put(CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), true).build(),
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
+
+        Supplier<RepositoriesService> repositoriesServiceSupplier = mock(Supplier.class);
+        Settings settings = Settings.builder()
+            .put(Node.NODE_ATTRIBUTES.getKey() + RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, "remote-repo")
+            .build();
+        RepositoriesService repositoriesService = mock(RepositoriesService.class);
+        when(repositoriesServiceSupplier.get()).thenReturn(repositoriesService);
+        BlobStoreRepository blobStoreRepository = mock(BlobStoreRepository.class);
+        when(repositoriesService.repository("remote-repo")).thenReturn(blobStoreRepository);
+
+        ThreadPool threadPool = mock(ThreadPool.class);
+        when(threadPool.schedule(any(), any(), any())).then(invocationOnMock -> {
+            Runnable updateTask = invocationOnMock.getArgument(0);
+            updatePinnedTimstampTask = () -> {
+                long currentTime = System.currentTimeMillis();
+                while (RemoteStorePinnedTimestampService.getPinnedTimestamps().v1() < currentTime) {
+                    updateTask.run();
+                }
+            };
+            return null;
+        }).then(subsequentInvocationsOnMock -> null);
+
+        RepositoryMetadata repositoryMetadata = new RepositoryMetadata(randomAlphaOfLength(10), FsRepository.TYPE, settings);
+        final ClusterService clusterService = BlobStoreTestUtil.mockClusterService(repositoryMetadata);
+
+        RemoteStorePinnedTimestampService remoteStorePinnedTimestampService = new RemoteStorePinnedTimestampService(
+            repositoriesServiceSupplier,
+            settings,
+            threadPool,
+            clusterService
+        );
+        remoteStorePinnedTimestampServiceSpy = Mockito.spy(remoteStorePinnedTimestampService);
+
+        BlobStore blobStore = mock(BlobStore.class);
+        when(blobStoreRepository.blobStore()).thenReturn(blobStore);
+        when(blobStoreRepository.basePath()).thenReturn(new BlobPath());
+        blobContainer = mock(BlobContainer.class);
+        when(blobStore.blobContainer(any())).thenReturn(blobContainer);
+
+        when(blobContainer.listBlobs()).thenReturn(new HashMap<>());
+
+        remoteStorePinnedTimestampServiceSpy.start();
+    }
+
+    @Override
+    protected RemoteFsTranslog createTranslogInstance(
+        TranslogConfig translogConfig,
+        String translogUUID,
+        TranslogDeletionPolicy deletionPolicy
+    ) throws IOException {
+        return new RemoteFsTimestampAwareTranslog(
+            translogConfig,
+            translogUUID,
+            deletionPolicy,
+            () -> globalCheckpoint.get(),
+            primaryTerm::get,
+            getPersistedSeqNoConsumer(),
+            repository,
+            threadPool,
+            primaryMode::get,
+            new RemoteTranslogTransferTracker(shardId, 10),
+            DefaultRemoteStoreSettings.INSTANCE
+        );
+    }
+
+    @Override
+    public void testSyncUpAlwaysFailure() throws IOException {
+        int translogOperations = randomIntBetween(1, 20);
+        int count = 0;
+        fail.failAlways();
+        for (int op = 0; op < translogOperations; op++) {
+            translog.add(
+                new Translog.Index(String.valueOf(op), count, primaryTerm.get(), Integer.toString(count).getBytes(StandardCharsets.UTF_8))
+            );
+            try {
+                translog.sync();
+                fail("io exception expected");
+            } catch (TranslogUploadFailedException e) {
+                assertTrue("at least one operation pending", translog.syncNeeded());
+            }
+        }
+        assertTrue(translog.isOpen());
+        fail.failNever();
+        translog.sync();
+    }
+
+    public void testGetMinMaxTranslogGenerationFromFilename() throws Exception {
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+        ArrayList<Translog.Operation> ops = new ArrayList<>();
+
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("0", 0, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("1", 1, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("2", 2, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("3", 3, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("4", 4, primaryTerm.get(), new byte[] { 1 }));
+
+        CountDownLatch latch = new CountDownLatch(1);
+        blobStoreTransferService.listAllInSortedOrder(
+            getTranslogDirectory().add(METADATA_DIR),
+            "metadata",
+            Integer.MAX_VALUE,
+            new LatchedActionListener<>(new ActionListener<List<BlobMetadata>>() {
+                @Override
+                public void onResponse(List<BlobMetadata> blobMetadataList) {
+                    Long minGen = 1L;
+                    Long maxGen = 6L;
+                    for (BlobMetadata blobMetadata : blobMetadataList) {
+                        Tuple<Long, Long> minMaxGen = TranslogTransferMetadata.getMinMaxTranslogGenerationFromFilename(blobMetadata.name());
+                        assertEquals(minGen, minMaxGen.v1());
+                        assertEquals(maxGen, minMaxGen.v2());
+                        maxGen -= 1;
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    // This means test failure
+                    fail();
+                }
+            }, latch)
+        );
+        latch.await();
+
+        // Old format metadata file
+        String oldFormatMdFilename = "metadata__9223372036438563903__9223372036854774799__9223370311919910393__31__1";
+        assertNull(TranslogTransferMetadata.getMinMaxTranslogGenerationFromFilename(oldFormatMdFilename));
+
+        // Node id containing separator
+        String nodeIdWithSeparator =
+            "metadata__9223372036438563903__9223372036854774799__9223370311919910393__node__1__9223372036438563958__1";
+        Tuple<Long, Long> minMaxGen = TranslogTransferMetadata.getMinMaxTranslogGenerationFromFilename(nodeIdWithSeparator);
+        Long minGen = Long.MAX_VALUE - 9223372036438563958L;
+        assertEquals(minGen, minMaxGen.v1());
+
+        // Malformed md filename
+        String malformedMdFileName = "metadata__9223372036438563903__9223372036854774799__9223370311919910393__node1__xyz__1";
+        assertNull(TranslogTransferMetadata.getMinMaxTranslogGenerationFromFilename(malformedMdFileName));
+    }
+
+    public void testIndexDeletionWithNoPinnedTimestampNoRecentMdFiles() throws Exception {
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+        ArrayList<Translog.Operation> ops = new ArrayList<>();
+
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("0", 0, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("1", 1, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("2", 2, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("3", 3, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("4", 4, primaryTerm.get(), new byte[] { 1 }));
+
+        assertBusy(() -> {
+            assertEquals(5, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size());
+            assertEquals(
+                12,
+                blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
+            );
+        });
+
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+        updatePinnedTimstampTask.run();
+        ((RemoteFsTimestampAwareTranslog) translog).trimUnreferencedReaders(true, false);
+
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+
+        assertBusy(() -> {
+            assertEquals(0, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size());
+            assertEquals(
+                0,
+                blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
+            );
+        });
+    }
+
+    public void testIndexDeletionWithNoPinnedTimestampButRecentFiles() throws Exception {
+        ArrayList<Translog.Operation> ops = new ArrayList<>();
+
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("0", 0, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("1", 1, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("2", 2, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("3", 3, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("4", 4, primaryTerm.get(), new byte[] { 1 }));
+
+        updatePinnedTimstampTask.run();
+        ((RemoteFsTimestampAwareTranslog) translog).trimUnreferencedReaders(true, false);
+
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+        assertBusy(() -> {
+            assertEquals(5, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size());
+            assertEquals(
+                12,
+                blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
+            );
+        });
+    }
+
+    @Override
+    public void testSimpleOperationsUpload() throws Exception {
+        ArrayList<Translog.Operation> ops = new ArrayList<>();
+
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("0", 0, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("1", 1, primaryTerm.get(), new byte[] { 1 }));
+
+        // First reader is created at the init of translog
+        assertEquals(3, translog.readers.size());
+        assertEquals(2, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size());
+        assertBusy(() -> {
+            assertEquals(6, translog.allUploaded().size());
+            assertEquals(
+                6,
+                blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
+            );
+        });
+
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("2", 2, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("3", 3, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("4", 4, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("5", 5, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("6", 6, primaryTerm.get(), new byte[] { 1 }));
+
+        assertBusy(() -> {
+            assertEquals(
+                16,
+                blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
+            );
+        });
+
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+        // Fetch pinned timestamps so that it won't be stale
+        updatePinnedTimstampTask.run();
+
+        translog.setMinSeqNoToKeep(4);
+        translog.trimUnreferencedReaders();
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("7", 7, primaryTerm.get(), new byte[] { 1 }));
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index("8", 8, primaryTerm.get(), new byte[] { 1 }));
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+
+        // Fetch pinned timestamps so that it won't be stale
+        updatePinnedTimstampTask.run();
+        translog.trimUnreferencedReaders();
+
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+        assertEquals(5, translog.readers.size());
+        assertBusy(() -> {
+            assertEquals(1, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size());
+            assertEquals(10, translog.allUploaded().size());
+            assertEquals(
+                10,
+                blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
+            );
+        });
+    }
+
+    @Override
+    public void testMetadataFileDeletion() throws Exception {
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+        ArrayList<Translog.Operation> ops = new ArrayList<>();
+        // Test deletion of metadata files
+        int numDocs = randomIntBetween(6, 10);
+        for (int i = 0; i < numDocs; i++) {
+            addToTranslogAndListAndUpload(translog, ops, new Translog.Index(String.valueOf(i), i, primaryTerm.get(), new byte[] { 1 }));
+            translog.setMinSeqNoToKeep(i);
+            // Fetch pinned timestamps so that it won't be stale
+            updatePinnedTimstampTask.run();
+            translog.trimUnreferencedReaders();
+            assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+            assertEquals(1, translog.readers.size());
+        }
+        assertBusy(() -> assertEquals(2, translog.allUploaded().size()));
+        addToTranslogAndListAndUpload(
+            translog,
+            ops,
+            new Translog.Index(String.valueOf(numDocs), numDocs, primaryTerm.get(), new byte[] { 1 })
+        );
+        addToTranslogAndListAndUpload(
+            translog,
+            ops,
+            new Translog.Index(String.valueOf(numDocs + 1), numDocs + 1, primaryTerm.get(), new byte[] { 1 })
+        );
+        updatePinnedTimstampTask.run();
+        translog.trimUnreferencedReaders();
+        assertBusy(() -> { assertEquals(1, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size()); });
+    }
+
+    public void testMetadataFileDeletionWithPinnedTimestamps() throws Exception {
+        ArrayList<Translog.Operation> ops = new ArrayList<>();
+        // Test deletion of metadata files
+        int numDocs = randomIntBetween(16, 20);
+        for (int i = 0; i < numDocs; i++) {
+            addToTranslogAndListAndUpload(translog, ops, new Translog.Index(String.valueOf(i), i, primaryTerm.get(), new byte[] { 1 }));
+            translog.setMinSeqNoToKeep(i);
+            assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+            translog.trimUnreferencedReaders();
+            // This is just to make sure that each metadata is at least 1ms apart
+            Thread.sleep(1);
+        }
+
+        CountDownLatch latch = new CountDownLatch(1);
+        blobStoreTransferService.listAllInSortedOrder(
+            getTranslogDirectory().add(METADATA_DIR),
+            "metadata",
+            Integer.MAX_VALUE,
+            new LatchedActionListener<>(new ActionListener<>() {
+                @Override
+                public void onResponse(List<BlobMetadata> blobMetadataList) {
+                    List<String> pinnedTimestampMatchingMetadataFiles = new ArrayList<>();
+                    List<Long> pinnedTimestamps = new ArrayList<>();
+                    for (BlobMetadata blobMetadata : blobMetadataList) {
+                        String metadataFilename = blobMetadata.name();
+                        if (randomBoolean()) {
+                            long timestamp = RemoteStoreUtils.invertLong(metadataFilename.split(METADATA_SEPARATOR)[3]);
+                            pinnedTimestamps.add(timestamp);
+                            pinnedTimestampMatchingMetadataFiles.add(metadataFilename);
+                        }
+                    }
+
+                    Map<String, BlobMetadata> pinnedTimestampsMap = new HashMap<>();
+                    pinnedTimestamps.forEach(ts -> pinnedTimestampsMap.put(randomInt(1000) + "__" + ts, new PlainBlobMetadata("x", 100)));
+
+                    try {
+
+                        when(blobContainer.listBlobs()).thenReturn(pinnedTimestampsMap);
+
+                        Set<String> dataFilesBeforeTrim = blobStoreTransferService.listAll(
+                            getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))
+                        );
+
+                        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+                        updatePinnedTimstampTask.run();
+                        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+                        translog.trimUnreferencedReaders();
+                        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+
+                        Set<String> metadataFilesAfterTrim = blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR));
+                        Set<String> dataFilesAfterTrim = blobStoreTransferService.listAll(
+                            getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))
+                        );
+
+                        // If non pinned generations are within, minRemoteGenReferenced - 1 - indexSettings().getRemoteTranslogExtraKeep()
+                        // we will not delete them
+                        if (dataFilesAfterTrim.equals(dataFilesBeforeTrim) == false) {
+                            // We check for number of pinned timestamp or +1 due to latest metadata.
+                            assertTrue(
+                                metadataFilesAfterTrim.size() == pinnedTimestamps.size()
+                                    || metadataFilesAfterTrim.size() == pinnedTimestamps.size() + 1
+                            );
+                        }
+
+                        for (String md : pinnedTimestampMatchingMetadataFiles) {
+                            assertTrue(metadataFilesAfterTrim.contains(md));
+                            Tuple<Long, Long> minMaXGen = TranslogTransferMetadata.getMinMaxTranslogGenerationFromFilename(md);
+                            for (long i = minMaXGen.v1(); i <= minMaXGen.v2(); i++) {
+                                assertTrue(dataFilesAfterTrim.contains(Translog.getFilename(i)));
+                            }
+                        }
+                    } catch (Exception e) {
+                        fail();
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    fail();
+                }
+            }, latch)
+        );
+
+        latch.await();
+    }
+
+    @Override
+    public void testDrainSync() throws Exception {
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+
+        // This test checks following scenarios -
+        // 1. During ongoing uploads, the available permits are 0.
+        // 2. During an upload, if drainSync is called, it will wait for it to acquire and available permits are 0.
+        // 3. After drainSync, if trimUnreferencedReaders is attempted, we do not delete from remote store.
+        // 4. After drainSync, if an upload is an attempted, we do not upload to remote store.
+        ArrayList<Translog.Operation> ops = new ArrayList<>();
+        assertEquals(0, translog.allUploaded().size());
+        assertEquals(1, translog.readers.size());
+
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index(String.valueOf(0), 0, primaryTerm.get(), new byte[] { 1 }));
+        assertEquals(4, translog.allUploaded().size());
+        assertEquals(2, translog.readers.size());
+        assertBusy(() -> assertEquals(1, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size()));
+
+        translog.setMinSeqNoToKeep(0);
+        // Fetch pinned timestamps so that it won't be stale
+        updatePinnedTimstampTask.run();
+        translog.trimUnreferencedReaders();
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+        assertEquals(1, translog.readers.size());
+
+        // Case 1 - During ongoing uploads, the available permits are 0.
+        slowDown.setSleepSeconds(2);
+        CountDownLatch latch = new CountDownLatch(1);
+        Thread thread1 = new Thread(() -> {
+            try {
+                addToTranslogAndListAndUpload(translog, ops, new Translog.Index(String.valueOf(1), 1, primaryTerm.get(), new byte[] { 1 }));
+                assertEquals(2, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size());
+                latch.countDown();
+            } catch (IOException e) {
+                throw new AssertionError(e);
+            }
+        });
+        thread1.start();
+        assertBusy(() -> assertEquals(0, translog.availablePermits()));
+        // Case 2 - During an upload, if drainSync is called, it will wait for it to acquire and available permits are 0.
+        Releasable releasable = translog.drainSync();
+        assertBusy(() -> assertEquals(0, latch.getCount()));
+        assertEquals(0, translog.availablePermits());
+        slowDown.setSleepSeconds(0);
+        assertEquals(4, translog.allUploaded().size());
+        assertEquals(2, translog.readers.size());
+        Set<String> mdFiles = blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR));
+
+        // Case 3 - After drainSync, if trimUnreferencedReaders is attempted, we do not delete from remote store.
+        translog.setMinSeqNoToKeep(1);
+        // Fetch pinned timestamps so that it won't be stale
+        updatePinnedTimstampTask.run();
+        translog.trimUnreferencedReaders();
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+        assertEquals(1, translog.readers.size());
+        assertEquals(2, translog.allUploaded().size());
+        assertEquals(mdFiles, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)));
+
+        // Case 4 - After drainSync, if an upload is an attempted, we do not upload to remote store.
+        Translog.Location loc = addToTranslogAndListAndUpload(
+            translog,
+            ops,
+            new Translog.Index(String.valueOf(2), 2, primaryTerm.get(), new byte[] { 1 })
+        );
+        assertEquals(1, translog.readers.size());
+        assertEquals(2, translog.allUploaded().size());
+        assertEquals(mdFiles, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)));
+
+        // Refill the permits back
+        Releasables.close(releasable);
+        addToTranslogAndListAndUpload(translog, ops, new Translog.Index(String.valueOf(3), 3, primaryTerm.get(), new byte[] { 1 }));
+        assertEquals(2, translog.readers.size());
+        assertEquals(4, translog.allUploaded().size());
+        assertEquals(3, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size());
+
+        translog.setMinSeqNoToKeep(3);
+        // Fetch pinned timestamps so that it won't be stale
+        updatePinnedTimstampTask.run();
+        translog.trimUnreferencedReaders();
+        assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+        assertEquals(1, translog.readers.size());
+        assertBusy(() -> assertEquals(2, translog.allUploaded().size()));
+        assertBusy(() -> assertEquals(1, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size()));
+    }
+
+    @Override
+    public void testExtraGenToKeep() throws Exception {
+        RemoteStoreSettings.setPinnedTimestampsLookbackInterval(TimeValue.ZERO);
+
+        TranslogConfig config = getConfig(1);
+        ChannelFactory channelFactory = getChannelFactory();
+        final Set<Long> persistedSeqNos = new HashSet<>();
+        String translogUUID = Translog.createEmptyTranslog(
+            config.getTranslogPath(),
+            SequenceNumbers.NO_OPS_PERFORMED,
+            shardId,
+            channelFactory,
+            primaryTerm.get()
+        );
+        TranslogDeletionPolicy deletionPolicy = createTranslogDeletionPolicy(config.getIndexSettings());
+        ArrayList<Translog.Operation> ops = new ArrayList<>();
+        try (
+            RemoteFsTranslog translog = new RemoteFsTranslog(
+                config,
+                translogUUID,
+                deletionPolicy,
+                () -> SequenceNumbers.NO_OPS_PERFORMED,
+                primaryTerm::get,
+                persistedSeqNos::add,
+                repository,
+                threadPool,
+                () -> Boolean.TRUE,
+                new RemoteTranslogTransferTracker(shardId, 10),
+                DefaultRemoteStoreSettings.INSTANCE
+            ) {
+                @Override
+                ChannelFactory getChannelFactory() {
+                    return channelFactory;
+                }
+            }
+        ) {
+            addToTranslogAndListAndUpload(translog, ops, new Translog.Index("1", 0, primaryTerm.get(), new byte[] { 1 }));
+            addToTranslogAndListAndUpload(translog, ops, new Translog.Index("2", 1, primaryTerm.get(), new byte[] { 1 }));
+            addToTranslogAndListAndUpload(translog, ops, new Translog.Index("3", 2, primaryTerm.get(), new byte[] { 1 }));
+
+            // expose the new checkpoint (simulating a commit), before we trim the translog
+            translog.setMinSeqNoToKeep(2);
+
+            // Trims from local
+            // Fetch pinned timestamps so that it won't be stale
+            updatePinnedTimstampTask.run();
+            translog.trimUnreferencedReaders();
+            assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+
+            addToTranslogAndListAndUpload(translog, ops, new Translog.Index("4", 3, primaryTerm.get(), new byte[] { 1 }));
+            addToTranslogAndListAndUpload(translog, ops, new Translog.Index("5", 4, primaryTerm.get(), new byte[] { 1 }));
+            // Trims from remote now
+            // Fetch pinned timestamps so that it won't be stale
+            updatePinnedTimstampTask.run();
+            translog.trimUnreferencedReaders();
+            assertBusy(() -> assertTrue(translog.isRemoteGenerationDeletionPermitsAvailable()));
+            assertEquals(
+                8,
+                blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
+            );
+        }
+    }
+
+    public void testGetGenerationsToBeDeletedEmptyMetadataFilesNotToBeDeleted() throws IOException {
+        List<String> metadataFilesNotToBeDeleted = new ArrayList<>();
+        List<String> metadataFilesToBeDeleted = List.of(
+            // 4 to 7
+            "metadata__9223372036438563903__9223372036854775800__9223370311919910398__31__9223372036854775803__1",
+            // 17 to 37
+            "metadata__9223372036438563903__9223372036854775770__9223370311919910398__31__9223372036854775790__1",
+            // 27 to 42
+            "metadata__9223372036438563903__9223372036854775765__9223370311919910403__31__9223372036854775780__1"
+        );
+        Set<Long> generations = ((RemoteFsTimestampAwareTranslog) translog).getGenerationsToBeDeleted(
+            metadataFilesNotToBeDeleted,
+            metadataFilesToBeDeleted,
+            true
+        );
+        Set<Long> md1Generations = LongStream.rangeClosed(4, 7).boxed().collect(Collectors.toSet());
+        Set<Long> md2Generations = LongStream.rangeClosed(17, 37).boxed().collect(Collectors.toSet());
+        Set<Long> md3Generations = LongStream.rangeClosed(27, 42).boxed().collect(Collectors.toSet());
+        assertTrue(generations.containsAll(md1Generations));
+        assertTrue(generations.containsAll(md2Generations));
+        assertTrue(generations.containsAll(md3Generations));
+
+        generations.removeAll(md1Generations);
+        generations.removeAll(md2Generations);
+        generations.removeAll(md3Generations);
+        assertTrue(generations.isEmpty());
+    }
+
+    public void testGetGenerationsToBeDeleted() throws IOException {
+        List<String> metadataFilesNotToBeDeleted = List.of(
+            // 1 to 4
+            "metadata__9223372036438563903__9223372036854775803__9223370311919910398__31__9223372036854775806__1",
+            // 26 to 30
+            "metadata__9223372036438563903__9223372036854775777__9223370311919910398__31__9223372036854775781__1",
+            // 42 to 100
+            "metadata__9223372036438563903__9223372036854775707__9223370311919910403__31__9223372036854775765__1"
+        );
+        List<String> metadataFilesToBeDeleted = List.of(
+            // 4 to 7
+            "metadata__9223372036438563903__9223372036854775800__9223370311919910398__31__9223372036854775803__1",
+            // 17 to 37
+            "metadata__9223372036438563903__9223372036854775770__9223370311919910398__31__9223372036854775790__1",
+            // 27 to 42
+            "metadata__9223372036438563903__9223372036854775765__9223370311919910403__31__9223372036854775780__1"
+        );
+        Set<Long> generations = ((RemoteFsTimestampAwareTranslog) translog).getGenerationsToBeDeleted(
+            metadataFilesNotToBeDeleted,
+            metadataFilesToBeDeleted,
+            true
+        );
+        Set<Long> md1Generations = LongStream.rangeClosed(5, 7).boxed().collect(Collectors.toSet());
+        Set<Long> md2Generations = LongStream.rangeClosed(17, 25).boxed().collect(Collectors.toSet());
+        Set<Long> md3Generations = LongStream.rangeClosed(31, 41).boxed().collect(Collectors.toSet());
+        assertTrue(generations.containsAll(md1Generations));
+        assertTrue(generations.containsAll(md2Generations));
+        assertTrue(generations.containsAll(md3Generations));
+
+        generations.removeAll(md1Generations);
+        generations.removeAll(md2Generations);
+        generations.removeAll(md3Generations);
+        assertTrue(generations.isEmpty());
+    }
+
+    public void testGetMetadataFilesToBeDeletedNoExclusion() {
+        updatePinnedTimstampTask.run();
+
+        List<String> metadataFiles = List.of(
+            "metadata__9223372036438563903__9223372036854774799__9223370311919910393__31__9223372036854775106__1",
+            "metadata__9223372036438563903__9223372036854775800__9223370311919910398__31__9223372036854775803__1",
+            "metadata__9223372036438563903__9223372036854775701__9223370311919910403__31__9223372036854775701__1"
+        );
+
+        assertEquals(metadataFiles, ((RemoteFsTimestampAwareTranslog) translog).getMetadataFilesToBeDeleted(metadataFiles));
+    }
+
+    public void testGetMetadataFilesToBeDeletedExclusionBasedOnAgeOnly() {
+        updatePinnedTimstampTask.run();
+        long currentTimeInMillis = System.currentTimeMillis();
+        String md1Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis - 200000);
+        String md2Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis + 30000);
+        String md3Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis + 60000);
+
+        List<String> metadataFiles = List.of(
+            "metadata__9223372036438563903__9223372036854774799__" + md1Timestamp + "__31__9223372036854775106__1",
+            "metadata__9223372036438563903__9223372036854775800__" + md2Timestamp + "__31__9223372036854775803__1",
+            "metadata__9223372036438563903__9223372036854775701__" + md3Timestamp + "__31__9223372036854775701__1"
+        );
+
+        List<String> metadataFilesToBeDeleted = ((RemoteFsTimestampAwareTranslog) translog).getMetadataFilesToBeDeleted(metadataFiles);
+        assertEquals(1, metadataFilesToBeDeleted.size());
+        assertEquals(metadataFiles.get(0), metadataFilesToBeDeleted.get(0));
+    }
+
+    public void testGetMetadataFilesToBeDeletedExclusionBasedOnPinningOnly() throws IOException {
+        long currentTimeInMillis = System.currentTimeMillis();
+        String md1Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis - 200000);
+        String md2Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis - 300000);
+        String md3Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis - 600000);
+
+        long pinnedTimestamp = RemoteStoreUtils.invertLong(md2Timestamp) + 10000;
+        when(blobContainer.listBlobs()).thenReturn(Map.of(randomInt(100) + "__" + pinnedTimestamp, new PlainBlobMetadata("xyz", 100)));
+
+        updatePinnedTimstampTask.run();
+
+        List<String> metadataFiles = List.of(
+            "metadata__9223372036438563903__9223372036854774799__" + md1Timestamp + "__31__9223372036854775106__1",
+            "metadata__9223372036438563903__9223372036854775600__" + md2Timestamp + "__31__9223372036854775803__1",
+            "metadata__9223372036438563903__9223372036854775701__" + md3Timestamp + "__31__9223372036854775701__1"
+        );
+
+        List<String> metadataFilesToBeDeleted = ((RemoteFsTimestampAwareTranslog) translog).getMetadataFilesToBeDeleted(metadataFiles);
+        assertEquals(2, metadataFilesToBeDeleted.size());
+        assertEquals(metadataFiles.get(0), metadataFilesToBeDeleted.get(0));
+        assertEquals(metadataFiles.get(2), metadataFilesToBeDeleted.get(1));
+    }
+
+    public void testGetMetadataFilesToBeDeletedExclusionBasedOnAgeAndPinning() throws IOException {
+        long currentTimeInMillis = System.currentTimeMillis();
+        String md1Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis + 100000);
+        String md2Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis - 300000);
+        String md3Timestamp = RemoteStoreUtils.invertLong(currentTimeInMillis - 600000);
+
+        long pinnedTimestamp = RemoteStoreUtils.invertLong(md2Timestamp) + 10000;
+        when(blobContainer.listBlobs()).thenReturn(Map.of(randomInt(100) + "__" + pinnedTimestamp, new PlainBlobMetadata("xyz", 100)));
+
+        updatePinnedTimstampTask.run();
+
+        List<String> metadataFiles = List.of(
+            "metadata__9223372036438563903__9223372036854774799__" + md1Timestamp + "__31__9223372036854775106__1",
+            "metadata__9223372036438563903__9223372036854775600__" + md2Timestamp + "__31__9223372036854775803__1",
+            "metadata__9223372036438563903__9223372036854775701__" + md3Timestamp + "__31__9223372036854775701__1"
+        );
+
+        List<String> metadataFilesToBeDeleted = ((RemoteFsTimestampAwareTranslog) translog).getMetadataFilesToBeDeleted(metadataFiles);
+        assertEquals(1, metadataFilesToBeDeleted.size());
+        assertEquals(metadataFiles.get(2), metadataFilesToBeDeleted.get(0));
+    }
+
+    public void testIsGenerationPinned() {
+        TreeSet<Tuple<Long, Long>> pinnedGenerations = new TreeSet<>(new TreeSet<>((o1, o2) -> {
+            if (Objects.equals(o1.v1(), o2.v1()) == false) {
+                return o1.v1().compareTo(o2.v1());
+            } else {
+                return o1.v2().compareTo(o2.v2());
+            }
+        }));
+
+        pinnedGenerations.add(new Tuple<>(12L, 34L));
+        pinnedGenerations.add(new Tuple<>(121L, 140L));
+        pinnedGenerations.add(new Tuple<>(142L, 160L));
+        pinnedGenerations.add(new Tuple<>(12L, 120L));
+        pinnedGenerations.add(new Tuple<>(12L, 78L));
+        pinnedGenerations.add(new Tuple<>(142L, 170L));
+        pinnedGenerations.add(new Tuple<>(1L, 1L));
+        pinnedGenerations.add(new Tuple<>(12L, 56L));
+        pinnedGenerations.add(new Tuple<>(142L, 180L));
+        pinnedGenerations.add(new Tuple<>(4L, 9L));
+
+        RemoteFsTimestampAwareTranslog translog = (RemoteFsTimestampAwareTranslog) this.translog;
+
+        assertFalse(translog.isGenerationPinned(3, pinnedGenerations));
+        assertFalse(translog.isGenerationPinned(10, pinnedGenerations));
+        assertFalse(translog.isGenerationPinned(141, pinnedGenerations));
+        assertFalse(translog.isGenerationPinned(181, pinnedGenerations));
+        assertFalse(translog.isGenerationPinned(5000, pinnedGenerations));
+        assertFalse(translog.isGenerationPinned(0, pinnedGenerations));
+
+        assertTrue(translog.isGenerationPinned(1, pinnedGenerations));
+        assertTrue(translog.isGenerationPinned(120, pinnedGenerations));
+        assertTrue(translog.isGenerationPinned(121, pinnedGenerations));
+        assertTrue(translog.isGenerationPinned(156, pinnedGenerations));
+        assertTrue(translog.isGenerationPinned(12, pinnedGenerations));
+    }
+
+    public void testGetMinMaxTranslogGenerationFromMetadataFile() throws IOException {
+        TranslogTransferManager translogTransferManager = mock(TranslogTransferManager.class);
+
+        RemoteFsTimestampAwareTranslog translog = (RemoteFsTimestampAwareTranslog) this.translog;
+
+        // Fetch generations directly from the filename
+        assertEquals(
+            new Tuple<>(701L, 1008L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854774799__9223370311919910393__31__9223372036854775106__1",
+                translogTransferManager
+            )
+        );
+        assertEquals(
+            new Tuple<>(4L, 7L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854775800__9223370311919910398__31__9223372036854775803__1",
+                translogTransferManager
+            )
+        );
+        assertEquals(
+            new Tuple<>(106L, 106L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854775701__9223370311919910403__31__9223372036854775701__1",
+                translogTransferManager
+            )
+        );
+        assertEquals(
+            new Tuple<>(4573L, 99964L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854675843__9223370311919910408__31__9223372036854771234__1",
+                translogTransferManager
+            )
+        );
+        assertEquals(
+            new Tuple<>(1L, 4L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854775803__9223370311919910413__31__9223372036854775806__1",
+                translogTransferManager
+            )
+        );
+        assertEquals(
+            new Tuple<>(2474L, 3462L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854772345__9223370311919910429__31__9223372036854773333__1",
+                translogTransferManager
+            )
+        );
+        assertEquals(
+            new Tuple<>(5807L, 7917L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854767890__9223370311919910434__31__9223372036854770000__1",
+                translogTransferManager
+            )
+        );
+
+        // For older md filenames, it needs to read the content
+        TranslogTransferMetadata md1 = mock(TranslogTransferMetadata.class);
+        when(md1.getMinTranslogGeneration()).thenReturn(701L);
+        when(md1.getGeneration()).thenReturn(1008L);
+        when(translogTransferManager.readMetadata("metadata__9223372036438563903__9223372036854774799__9223370311919910393__31__1"))
+            .thenReturn(md1);
+        assertEquals(
+            new Tuple<>(701L, 1008L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854774799__9223370311919910393__31__1",
+                translogTransferManager
+            )
+        );
+        TranslogTransferMetadata md2 = mock(TranslogTransferMetadata.class);
+        when(md2.getMinTranslogGeneration()).thenReturn(4L);
+        when(md2.getGeneration()).thenReturn(7L);
+        when(translogTransferManager.readMetadata("metadata__9223372036438563903__9223372036854775800__9223370311919910398__31__1"))
+            .thenReturn(md2);
+        assertEquals(
+            new Tuple<>(4L, 7L),
+            translog.getMinMaxTranslogGenerationFromMetadataFile(
+                "metadata__9223372036438563903__9223372036854775800__9223370311919910398__31__1",
+                translogTransferManager
+            )
+        );
+
+        verify(translogTransferManager).readMetadata("metadata__9223372036438563903__9223372036854774799__9223370311919910393__31__1");
+        verify(translogTransferManager).readMetadata("metadata__9223372036438563903__9223372036854775800__9223370311919910398__31__1");
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/translog/RemoteFsTranslogTests.java b/server/src/test/java/org/opensearch/index/translog/RemoteFsTranslogTests.java
index 6bf35cc1eac9b..339d876274557 100644
--- a/server/src/test/java/org/opensearch/index/translog/RemoteFsTranslogTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/RemoteFsTranslogTests.java
@@ -118,15 +118,15 @@ public class RemoteFsTranslogTests extends OpenSearchTestCase {
     protected final ShardId shardId = new ShardId("index", "_na_", 1);
 
     protected RemoteFsTranslog translog;
-    private AtomicLong globalCheckpoint;
+    protected AtomicLong globalCheckpoint;
     protected Path translogDir;
     // A default primary term is used by translog instances created in this test.
-    private final AtomicLong primaryTerm = new AtomicLong();
-    private final AtomicBoolean primaryMode = new AtomicBoolean(true);
+    protected final AtomicLong primaryTerm = new AtomicLong();
+    protected final AtomicBoolean primaryMode = new AtomicBoolean(true);
     private final AtomicReference<LongConsumer> persistedSeqNoConsumer = new AtomicReference<>();
-    private ThreadPool threadPool;
-    private final static String METADATA_DIR = "metadata";
-    private final static String DATA_DIR = "data";
+    protected ThreadPool threadPool;
+    protected final static String METADATA_DIR = "metadata";
+    protected final static String DATA_DIR = "data";
     AtomicInteger writeCalls = new AtomicInteger();
     BlobStoreRepository repository;
 
@@ -136,7 +136,7 @@ public class RemoteFsTranslogTests extends OpenSearchTestCase {
 
     TestTranslog.SlowDownWriteSwitch slowDown;
 
-    private LongConsumer getPersistedSeqNoConsumer() {
+    protected LongConsumer getPersistedSeqNoConsumer() {
         return seqNo -> {
             final LongConsumer consumer = persistedSeqNoConsumer.get();
             if (consumer != null) {
@@ -167,7 +167,7 @@ public void tearDown() throws Exception {
         }
     }
 
-    private RemoteFsTranslog create(Path path) throws IOException {
+    protected RemoteFsTranslog create(Path path) throws IOException {
         final String translogUUID = Translog.createEmptyTranslog(path, SequenceNumbers.NO_OPS_PERFORMED, shardId, primaryTerm.get());
         return create(path, createRepository(), translogUUID, 0);
     }
@@ -179,6 +179,14 @@ private RemoteFsTranslog create(Path path, BlobStoreRepository repository, Strin
         final TranslogDeletionPolicy deletionPolicy = createTranslogDeletionPolicy(translogConfig.getIndexSettings());
         threadPool = new TestThreadPool(getClass().getName());
         blobStoreTransferService = new BlobStoreTransferService(repository.blobStore(), threadPool);
+        return createTranslogInstance(translogConfig, translogUUID, deletionPolicy);
+    }
+
+    protected RemoteFsTranslog createTranslogInstance(
+        TranslogConfig translogConfig,
+        String translogUUID,
+        TranslogDeletionPolicy deletionPolicy
+    ) throws IOException {
         return new RemoteFsTranslog(
             translogConfig,
             translogUUID,
@@ -277,7 +285,7 @@ private Translog.Location addToTranslogAndList(Translog translog, List<Translog.
         return loc;
     }
 
-    private Translog.Location addToTranslogAndListAndUpload(Translog translog, List<Translog.Operation> list, Translog.Operation op)
+    protected Translog.Location addToTranslogAndListAndUpload(Translog translog, List<Translog.Operation> list, Translog.Operation op)
         throws IOException {
         Translog.Location loc = translog.add(op);
         translog.ensureSynced(loc);
@@ -390,7 +398,7 @@ public void testSimpleOperations() throws IOException {
 
     }
 
-    private TranslogConfig getConfig(int gensToKeep) {
+    protected TranslogConfig getConfig(int gensToKeep) {
         Path tempDir = createTempDir();
         final TranslogConfig temp = getTranslogConfig(tempDir, gensToKeep);
         final TranslogConfig config = new TranslogConfig(
@@ -405,7 +413,7 @@ private TranslogConfig getConfig(int gensToKeep) {
         return config;
     }
 
-    private ChannelFactory getChannelFactory() {
+    protected ChannelFactory getChannelFactory() {
         writeCalls = new AtomicInteger();
         final ChannelFactory channelFactory = (file, openOption) -> {
             FileChannel delegate = FileChannel.open(file, openOption);
@@ -493,8 +501,8 @@ ChannelFactory getChannelFactory() {
                 6,
                 blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
             );
-
         }
+
     }
 
     public void testReadLocation() throws IOException {
@@ -761,7 +769,6 @@ public void testSimpleOperationsUpload() throws Exception {
                 blobStoreTransferService.listAll(getTranslogDirectory().add(DATA_DIR).add(String.valueOf(primaryTerm.get()))).size()
             );
         });
-
     }
 
     public void testMetadataFileDeletion() throws Exception {
@@ -910,7 +917,7 @@ public void testDrainSync() throws Exception {
         assertBusy(() -> assertEquals(1, blobStoreTransferService.listAll(getTranslogDirectory().add(METADATA_DIR)).size()));
     }
 
-    private BlobPath getTranslogDirectory() {
+    protected BlobPath getTranslogDirectory() {
         return repository.basePath().add(shardId.getIndex().getUUID()).add(String.valueOf(shardId.id())).add(TRANSLOG.getName());
     }
 
@@ -1688,13 +1695,13 @@ public void testDownloadWithRetries() throws IOException {
 
         TranslogTransferManager mockTransfer = mock(TranslogTransferManager.class);
         RemoteTranslogTransferTracker remoteTranslogTransferTracker = mock(RemoteTranslogTransferTracker.class);
-        when(mockTransfer.readMetadata()).thenReturn(translogTransferMetadata);
+        when(mockTransfer.readMetadata(0)).thenReturn(translogTransferMetadata);
         when(mockTransfer.getRemoteTranslogTransferTracker()).thenReturn(remoteTranslogTransferTracker);
 
         // Always File not found
         when(mockTransfer.downloadTranslog(any(), any(), any())).thenThrow(new NoSuchFileException("File not found"));
         TranslogTransferManager finalMockTransfer = mockTransfer;
-        assertThrows(NoSuchFileException.class, () -> RemoteFsTranslog.download(finalMockTransfer, location, logger, false));
+        assertThrows(NoSuchFileException.class, () -> RemoteFsTranslog.download(finalMockTransfer, location, logger, false, 0));
 
         // File not found in first attempt . File found in second attempt.
         mockTransfer = mock(TranslogTransferManager.class);
@@ -1715,7 +1722,7 @@ public void testDownloadWithRetries() throws IOException {
         }).when(mockTransfer).downloadTranslog(any(), any(), any());
 
         // no exception thrown
-        RemoteFsTranslog.download(mockTransfer, location, logger, false);
+        RemoteFsTranslog.download(mockTransfer, location, logger, false, 0);
     }
 
     // No translog data in local as well as remote, we skip creating empty translog
@@ -1728,7 +1735,7 @@ public void testDownloadWithNoTranslogInLocalAndRemote() throws IOException {
         when(mockTransfer.getRemoteTranslogTransferTracker()).thenReturn(remoteTranslogTransferTracker);
 
         Path[] filesBeforeDownload = FileSystemUtils.files(location);
-        RemoteFsTranslog.download(mockTransfer, location, logger, false);
+        RemoteFsTranslog.download(mockTransfer, location, logger, false, 0);
         assertEquals(filesBeforeDownload, FileSystemUtils.files(location));
     }
 
@@ -1748,7 +1755,7 @@ public void testDownloadWithTranslogOnlyInLocal() throws IOException {
         Checkpoint existingCheckpoint = Translog.readCheckpoint(location);
 
         TranslogTransferManager finalMockTransfer = mockTransfer;
-        RemoteFsTranslog.download(finalMockTransfer, location, logger, false);
+        RemoteFsTranslog.download(finalMockTransfer, location, logger, false, 0);
 
         Path[] filesPostDownload = FileSystemUtils.files(location);
         assertEquals(2, filesPostDownload.length);
@@ -1784,11 +1791,11 @@ public void testDownloadWithEmptyTranslogOnlyInLocal() throws IOException {
         TranslogTransferManager finalMockTransfer = mockTransfer;
 
         // download first time will ensure creating empty translog
-        RemoteFsTranslog.download(finalMockTransfer, location, logger, false);
+        RemoteFsTranslog.download(finalMockTransfer, location, logger, false, 0);
         Path[] filesPostFirstDownload = FileSystemUtils.files(location);
 
         // download on empty translog should be a no-op
-        RemoteFsTranslog.download(finalMockTransfer, location, logger, false);
+        RemoteFsTranslog.download(finalMockTransfer, location, logger, false, 0);
         Path[] filesPostSecondDownload = FileSystemUtils.files(location);
 
         assertArrayEquals(filesPostFirstDownload, filesPostSecondDownload);
diff --git a/server/src/test/java/org/opensearch/index/translog/transfer/BlobStoreTransferServiceTests.java b/server/src/test/java/org/opensearch/index/translog/transfer/BlobStoreTransferServiceTests.java
index 3ed90c0837663..10e4cc6cfb1ef 100644
--- a/server/src/test/java/org/opensearch/index/translog/transfer/BlobStoreTransferServiceTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/transfer/BlobStoreTransferServiceTests.java
@@ -8,19 +8,35 @@
 
 package org.opensearch.index.translog.transfer;
 
+import org.opensearch.Version;
 import org.opensearch.action.LatchedActionListener;
+import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.blobstore.AsyncMultiStreamBlobContainer;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobPath;
+import org.opensearch.common.blobstore.BlobStore;
+import org.opensearch.common.blobstore.fs.FsBlobContainer;
+import org.opensearch.common.blobstore.fs.FsBlobStore;
+import org.opensearch.common.blobstore.stream.read.ReadContext;
+import org.opensearch.common.blobstore.stream.write.WriteContext;
 import org.opensearch.common.blobstore.stream.write.WritePriority;
+import org.opensearch.common.blobstore.transfer.RemoteTransferContainer;
+import org.opensearch.common.blobstore.transfer.stream.OffsetRangeInputStream;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.compress.NoneCompressor;
+import org.opensearch.core.index.Index;
+import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.env.Environment;
 import org.opensearch.env.TestEnvironment;
 import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.blobstore.BlobStoreRepository;
 import org.opensearch.repositories.blobstore.BlobStoreTestUtil;
+import org.opensearch.repositories.blobstore.ChecksumBlobStoreFormat;
 import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
@@ -29,6 +45,7 @@
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.Serializable;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -39,7 +56,14 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
 import static org.opensearch.index.translog.transfer.TranslogTransferManager.CHECKPOINT_FILE_DATA_KEY;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 public class BlobStoreTransferServiceTests extends OpenSearchTestCase {
 
@@ -110,6 +134,90 @@ public void onFailure(Exception e) {
         assertTrue(succeeded.get());
     }
 
+    public void testUploadBlobFromInputStreamSyncFSRepo() throws IOException, InterruptedException {
+        TransferService transferService = new BlobStoreTransferService(repository.blobStore(), threadPool);
+        uploadBlobFromInputStream(transferService);
+    }
+
+    public void testUploadBlobFromInputStreamAsyncFSRepo() throws IOException, InterruptedException {
+        BlobStore blobStore = createTestBlobStore();
+        MockAsyncFsContainer mockAsyncFsContainer = new MockAsyncFsContainer((FsBlobStore) blobStore, BlobPath.cleanPath(), null);
+        FsBlobStore fsBlobStore = mock(FsBlobStore.class);
+        when(fsBlobStore.blobContainer(any())).thenReturn(mockAsyncFsContainer);
+
+        BlobStoreTransferService transferServiceSpy = Mockito.spy(new BlobStoreTransferService(fsBlobStore, threadPool));
+        uploadBlobFromInputStream(transferServiceSpy);
+
+        ArgumentCaptor<RemoteTransferContainer.OffsetRangeInputStreamSupplier> inputStreamCaptor = ArgumentCaptor.forClass(
+            RemoteTransferContainer.OffsetRangeInputStreamSupplier.class
+        );
+        verify(transferServiceSpy).uploadBlobAsyncInternal(
+            Mockito.anyString(),
+            Mockito.anyString(),
+            Mockito.anyLong(),
+            Mockito.any(),
+            Mockito.any(),
+            inputStreamCaptor.capture(),
+            Mockito.anyLong(),
+            Mockito.any(),
+            Mockito.any()
+        );
+        RemoteTransferContainer.OffsetRangeInputStreamSupplier inputStreamSupplier = inputStreamCaptor.getValue();
+        OffsetRangeInputStream inputStream1 = inputStreamSupplier.get(1, 0);
+        OffsetRangeInputStream inputStream2 = inputStreamSupplier.get(1, 2);
+        assertNotEquals(inputStream1, inputStream2);
+        assertNotEquals(inputStream1.getFilePointer(), inputStream2.getFilePointer());
+    }
+
+    private IndexMetadata getIndexMetadata() {
+        final Index index = new Index("test-index", "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+        return new IndexMetadata.Builder(index.getName()).settings(idxSettings).version(5L).numberOfShards(1).numberOfReplicas(0).build();
+    }
+
+    private void uploadBlobFromInputStream(TransferService transferService) throws IOException, InterruptedException {
+        TestClass testObject = new TestClass("field1", "value1");
+        AtomicBoolean succeeded = new AtomicBoolean(false);
+        ChecksumBlobStoreFormat<IndexMetadata> blobStoreFormat = new ChecksumBlobStoreFormat<>(
+            "coordination",
+            "%s",
+            IndexMetadata::fromXContent
+        );
+        IndexMetadata indexMetadata = getIndexMetadata();
+        try (
+            InputStream inputStream = blobStoreFormat.serialize(
+                indexMetadata,
+                "index-metadata",
+                new NoneCompressor(),
+                new ToXContent.MapParams(Map.of())
+            ).streamInput()
+        ) {
+            CountDownLatch latch = new CountDownLatch(1);
+            ActionListener<TestClass> listener = new LatchedActionListener<>(new ActionListener<>() {
+                @Override
+                public void onResponse(TestClass testObject) {
+                    assert succeeded.compareAndSet(false, true);
+                    assert testObject.name.equals("field1");
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    throw new AssertionError("Failed to perform uploadBlobAsync", e);
+                }
+            }, latch);
+            ActionListener<Void> completionListener = ActionListener.wrap(
+                resp -> listener.onResponse(testObject),
+                ex -> listener.onFailure(ex)
+            );
+            transferService.uploadBlob(inputStream, repository.basePath(), "test-object", WritePriority.URGENT, completionListener);
+            assertTrue(latch.await(1000, TimeUnit.MILLISECONDS));
+            assertTrue(succeeded.get());
+        }
+    }
+
     @Override
     public void tearDown() throws Exception {
         super.tearDown();
@@ -141,6 +249,10 @@ protected void assertSnapshotOrGenericThread() {
         return repository;
     }
 
+    private BlobStore createTestBlobStore() throws IOException {
+        return new FsBlobStore(randomIntBetween(1, 8) * 1024, createTempDir(), false);
+    }
+
     /** Create a {@link Environment} with random path.home and path.repo **/
     private Environment createEnvironment() {
         Path home = createTempDir();
@@ -184,4 +296,49 @@ public void testBuildTransferFileMetadata_SmallInputStreamOptimization() throws
         assertEquals(expectedBase64String, metadata.get(CHECKPOINT_FILE_DATA_KEY));
     }
 
+    private static class TestClass implements Serializable {
+        private TestClass(String name, String value) {
+            this.name = name;
+            this.value = value;
+        }
+
+        private final String name;
+        private final String value;
+
+        @Override
+        public String toString() {
+            return "TestClass{ name: " + name + ", value: " + value + " }";
+        }
+    }
+
+    private static class MockAsyncFsContainer extends FsBlobContainer implements AsyncMultiStreamBlobContainer {
+
+        private BlobContainer delegate;
+
+        public MockAsyncFsContainer(FsBlobStore blobStore, BlobPath blobPath, Path path) {
+            super(blobStore, blobPath, path);
+            delegate = blobStore.blobContainer(BlobPath.cleanPath());
+        }
+
+        @Override
+        public void asyncBlobUpload(WriteContext writeContext, ActionListener<Void> completionListener) throws IOException {
+            InputStream inputStream = writeContext.getStreamProvider(Integer.MAX_VALUE).provideStream(0).getInputStream();
+            delegate.writeBlob(writeContext.getFileName(), inputStream, writeContext.getFileSize(), true);
+            completionListener.onResponse(null);
+        }
+
+        @Override
+        public void readBlobAsync(String blobName, ActionListener<ReadContext> listener) {
+            throw new RuntimeException("read not supported");
+        }
+
+        @Override
+        public boolean remoteIntegrityCheckSupported() {
+            return false;
+        }
+
+        public BlobContainer getDelegate() {
+            return delegate;
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java b/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
index c6f9838ad2d52..2426a14c0c93b 100644
--- a/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
+++ b/server/src/test/java/org/opensearch/index/translog/transfer/TranslogTransferManagerTests.java
@@ -23,6 +23,7 @@
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
+import org.opensearch.index.remote.RemoteStoreUtils;
 import org.opensearch.index.remote.RemoteTranslogTransferTracker;
 import org.opensearch.index.translog.Translog;
 import org.opensearch.index.translog.transfer.FileSnapshot.CheckpointFileSnapshot;
@@ -51,7 +52,10 @@
 import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
 
 import org.mockito.Mockito;
 
@@ -623,7 +627,7 @@ public void testMetadataConflict() throws InterruptedException {
         String mdFilename = tm.getFileName();
         long count = mdFilename.chars().filter(ch -> ch == METADATA_SEPARATOR.charAt(0)).count();
         // There should not be any `_` in mdFile name as it is used a separator .
-        assertEquals(10, count);
+        assertEquals(12, count);
         Thread.sleep(1);
         TranslogTransferMetadata tm2 = new TranslogTransferMetadata(1, 1, 1, 2, "node--2");
         String mdFilename2 = tm2.getFileName();
@@ -753,4 +757,121 @@ private void assertTlogCkpDownloadStatsWithMetadata() {
         // Expect delay for both tlog and ckp file
         assertTrue(remoteTranslogTransferTracker.getTotalDownloadTimeInMillis() >= delayForBlobDownload);
     }
+
+    public void testlistTranslogMetadataFilesAsync() throws Exception {
+        String tm1 = new TranslogTransferMetadata(1, 1, 1, 2).getFileName();
+        String tm2 = new TranslogTransferMetadata(1, 2, 1, 2).getFileName();
+        String tm3 = new TranslogTransferMetadata(2, 3, 1, 2).getFileName();
+        doAnswer(invocation -> {
+            ActionListener<List<BlobMetadata>> actionListener = invocation.getArgument(4);
+            List<BlobMetadata> bmList = new LinkedList<>();
+            bmList.add(new PlainBlobMetadata(tm1, 1));
+            bmList.add(new PlainBlobMetadata(tm2, 1));
+            bmList.add(new PlainBlobMetadata(tm3, 1));
+            actionListener.onResponse(bmList);
+            return null;
+        }).when(transferService)
+            .listAllInSortedOrderAsync(
+                eq(ThreadPool.Names.REMOTE_PURGE),
+                any(BlobPath.class),
+                eq(TranslogTransferMetadata.METADATA_PREFIX),
+                anyInt(),
+                any(ActionListener.class)
+            );
+        AtomicBoolean fetchCompleted = new AtomicBoolean(false);
+        translogTransferManager.listTranslogMetadataFilesAsync(new ActionListener<>() {
+            @Override
+            public void onResponse(List<BlobMetadata> blobMetadata) {
+                assertEquals(3, blobMetadata.size());
+                assertEquals(blobMetadata.stream().map(BlobMetadata::name).collect(Collectors.toList()), List.of(tm1, tm2, tm3));
+                fetchCompleted.set(true);
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                fetchCompleted.set(true);
+                throw new RuntimeException(e);
+            }
+        });
+        assertBusy(() -> assertTrue(fetchCompleted.get()));
+    }
+
+    public void testReadMetadataForGivenTimestampNoFile() throws IOException {
+        doAnswer(invocation -> {
+            LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
+            List<BlobMetadata> bmList = new LinkedList<>();
+            latchedActionListener.onResponse(bmList);
+            return null;
+        }).when(transferService)
+            .listAllInSortedOrder(any(BlobPath.class), eq(TranslogTransferMetadata.METADATA_PREFIX), anyInt(), any(ActionListener.class));
+
+        assertNull(translogTransferManager.readMetadata(1234L));
+        assertNoDownloadStats(false);
+    }
+
+    public void testReadMetadataForGivenTimestampNoMatchingFile() throws IOException {
+        doAnswer(invocation -> {
+            LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
+            String timestamp1 = RemoteStoreUtils.invertLong(2345L);
+            BlobMetadata bm1 = new PlainBlobMetadata("metadata__1__12__" + timestamp1 + "__node1__1", 1);
+            String timestamp2 = RemoteStoreUtils.invertLong(3456L);
+            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1);
+            List<BlobMetadata> bmList = List.of(bm1, bm2);
+            latchedActionListener.onResponse(bmList);
+            return null;
+        }).when(transferService)
+            .listAllInSortedOrder(any(BlobPath.class), eq(TranslogTransferMetadata.METADATA_PREFIX), anyInt(), any(ActionListener.class));
+
+        assertNull(translogTransferManager.readMetadata(1234L));
+        assertNoDownloadStats(false);
+    }
+
+    public void testReadMetadataForGivenTimestampFile() throws IOException {
+        AtomicReference<String> mdFilename1 = new AtomicReference<>();
+        String timestamp1 = RemoteStoreUtils.invertLong(2345L);
+        mdFilename1.set("metadata__1__12__" + timestamp1 + "__node1__1");
+        doAnswer(invocation -> {
+            LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
+            BlobMetadata bm1 = new PlainBlobMetadata(mdFilename1.get(), 1);
+            String timestamp2 = RemoteStoreUtils.invertLong(3456L);
+            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1);
+            List<BlobMetadata> bmList = List.of(bm1, bm2);
+            latchedActionListener.onResponse(bmList);
+            return null;
+        }).when(transferService)
+            .listAllInSortedOrder(any(BlobPath.class), eq(TranslogTransferMetadata.METADATA_PREFIX), anyInt(), any(ActionListener.class));
+
+        TranslogTransferMetadata metadata = createTransferSnapshot().getTranslogTransferMetadata();
+        long delayForMdDownload = 1;
+        when(transferService.downloadBlob(any(BlobPath.class), eq(mdFilename1.get()))).thenAnswer(invocation -> {
+            Thread.sleep(delayForMdDownload);
+            return new ByteArrayInputStream(translogTransferManager.getMetadataBytes(metadata));
+        });
+
+        assertEquals(metadata, translogTransferManager.readMetadata(3000L));
+
+        assertEquals(translogTransferManager.getMetadataBytes(metadata).length, remoteTranslogTransferTracker.getDownloadBytesSucceeded());
+        assertTrue(remoteTranslogTransferTracker.getTotalDownloadTimeInMillis() >= delayForMdDownload);
+    }
+
+    public void testReadMetadataForGivenTimestampException() throws IOException {
+        AtomicReference<String> mdFilename1 = new AtomicReference<>();
+        String timestamp1 = RemoteStoreUtils.invertLong(2345L);
+        mdFilename1.set("metadata__1__12__" + timestamp1 + "__node1__1");
+        doAnswer(invocation -> {
+            LatchedActionListener<List<BlobMetadata>> latchedActionListener = invocation.getArgument(3);
+            BlobMetadata bm1 = new PlainBlobMetadata(mdFilename1.get(), 1);
+            String timestamp2 = RemoteStoreUtils.invertLong(3456L);
+            BlobMetadata bm2 = new PlainBlobMetadata("metadata__1__12__" + timestamp2 + "__node1__1", 1);
+            List<BlobMetadata> bmList = List.of(bm1, bm2);
+            latchedActionListener.onResponse(bmList);
+            return null;
+        }).when(transferService)
+            .listAllInSortedOrder(any(BlobPath.class), eq(TranslogTransferMetadata.METADATA_PREFIX), anyInt(), any(ActionListener.class));
+
+        when(transferService.downloadBlob(any(BlobPath.class), eq(mdFilename1.get()))).thenThrow(new IOException("Something went wrong"));
+
+        assertThrows(IOException.class, () -> translogTransferManager.readMetadata(3000L));
+        assertNoDownloadStats(true);
+    }
 }
diff --git a/server/src/test/java/org/opensearch/indices/IndicesRequestCacheTests.java b/server/src/test/java/org/opensearch/indices/IndicesRequestCacheTests.java
index dcddd9f3d1318..10688de3ab0ae 100644
--- a/server/src/test/java/org/opensearch/indices/IndicesRequestCacheTests.java
+++ b/server/src/test/java/org/opensearch/indices/IndicesRequestCacheTests.java
@@ -95,16 +95,18 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.HashMap;
+import java.util.ConcurrentModificationException;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.Phaser;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import static java.util.Collections.emptyMap;
@@ -488,7 +490,8 @@ public void testStaleCount_OnRemovalNotificationOfStaleKey_DecrementsStaleCount(
             indexShard.hashCode()
         );
         // test the mapping
-        ConcurrentMap<ShardId, HashMap<String, Integer>> cleanupKeyToCountMap = cache.cacheCleanupManager.getCleanupKeyToCountMap();
+        ConcurrentHashMap<ShardId, ConcurrentHashMap<String, Integer>> cleanupKeyToCountMap = cache.cacheCleanupManager
+            .getCleanupKeyToCountMap();
         // shard id should exist
         assertTrue(cleanupKeyToCountMap.containsKey(shardId));
         // reader CacheKeyId should NOT exist
@@ -551,7 +554,8 @@ public void testStaleCount_OnRemovalNotificationOfNonStaleKey_DoesNotDecrementsS
         );
 
         // test the mapping
-        ConcurrentMap<ShardId, HashMap<String, Integer>> cleanupKeyToCountMap = cache.cacheCleanupManager.getCleanupKeyToCountMap();
+        ConcurrentHashMap<ShardId, ConcurrentHashMap<String, Integer>> cleanupKeyToCountMap = cache.cacheCleanupManager
+            .getCleanupKeyToCountMap();
         // shard id should exist
         assertTrue(cleanupKeyToCountMap.containsKey(shardId));
         // reader CacheKeyId should NOT exist
@@ -719,7 +723,8 @@ public void testCleanupKeyToCountMapAreSetAppropriately() throws Exception {
         cache.getOrCompute(getEntity(indexShard), getLoader(reader), reader, getTermBytes());
         assertEquals(1, cache.count());
         // test the mappings
-        ConcurrentMap<ShardId, HashMap<String, Integer>> cleanupKeyToCountMap = cache.cacheCleanupManager.getCleanupKeyToCountMap();
+        ConcurrentHashMap<ShardId, ConcurrentHashMap<String, Integer>> cleanupKeyToCountMap = cache.cacheCleanupManager
+            .getCleanupKeyToCountMap();
         assertEquals(1, (int) cleanupKeyToCountMap.get(shardId).get(getReaderCacheKeyId(reader)));
 
         cache.getOrCompute(getEntity(indexShard), getLoader(secondReader), secondReader, getTermBytes());
@@ -792,27 +797,75 @@ public void testCleanupKeyToCountMapAreSetAppropriately() throws Exception {
         IOUtils.close(secondReader);
     }
 
-    private DirectoryReader getReader(IndexWriter writer, ShardId shardId) throws IOException {
-        return OpenSearchDirectoryReader.wrap(DirectoryReader.open(writer), shardId);
+    // test adding to cleanupKeyToCountMap with multiple threads
+    public void testAddingToCleanupKeyToCountMapWorksAppropriatelyWithMultipleThreads() throws Exception {
+        threadPool = getThreadPool();
+        Settings settings = Settings.builder().put(INDICES_REQUEST_CACHE_STALENESS_THRESHOLD_SETTING.getKey(), "51%").build();
+        cache = getIndicesRequestCache(settings);
+
+        int numberOfThreads = 10;
+        int numberOfIterations = 1000;
+        Phaser phaser = new Phaser(numberOfThreads + 1); // +1 for the main thread
+        AtomicBoolean concurrentModificationExceptionDetected = new AtomicBoolean(false);
+
+        ExecutorService executorService = Executors.newFixedThreadPool(numberOfThreads);
+
+        for (int i = 0; i < numberOfThreads; i++) {
+            executorService.submit(() -> {
+                phaser.arriveAndAwaitAdvance(); // Ensure all threads start at the same time
+                try {
+                    for (int j = 0; j < numberOfIterations; j++) {
+                        cache.cacheCleanupManager.addToCleanupKeyToCountMap(indexShard.shardId(), UUID.randomUUID().toString());
+                    }
+                } catch (ConcurrentModificationException e) {
+                    logger.error("ConcurrentModificationException detected in thread : " + e.getMessage());
+                    concurrentModificationExceptionDetected.set(true); // Set flag if exception is detected
+                }
+            });
+        }
+        phaser.arriveAndAwaitAdvance(); // Start all threads
+
+        // Main thread iterates over the map
+        executorService.submit(() -> {
+            try {
+                for (int j = 0; j < numberOfIterations; j++) {
+                    cache.cacheCleanupManager.getCleanupKeyToCountMap().forEach((k, v) -> {
+                        v.forEach((k1, v1) -> {
+                            // Accessing the map to create contention
+                            v.get(k1);
+                        });
+                    });
+                }
+            } catch (ConcurrentModificationException e) {
+                logger.error("ConcurrentModificationException detected in main thread : " + e.getMessage());
+                concurrentModificationExceptionDetected.set(true); // Set flag if exception is detected
+            }
+        });
+
+        executorService.shutdown();
+        assertTrue(executorService.awaitTermination(60, TimeUnit.SECONDS));
+        assertEquals(
+            numberOfThreads * numberOfIterations,
+            cache.cacheCleanupManager.getCleanupKeyToCountMap().get(indexShard.shardId()).size()
+        );
+        assertFalse(concurrentModificationExceptionDetected.get());
     }
 
     private IndicesRequestCache getIndicesRequestCache(Settings settings) {
         IndicesService indicesService = getInstanceFromNode(IndicesService.class);
-        return new IndicesRequestCache(settings, (shardId -> {
-            IndexService indexService = null;
-            try {
-                indexService = indicesService.indexServiceSafe(shardId.getIndex());
-            } catch (IndexNotFoundException ex) {
-                return Optional.empty();
-            }
-            return Optional.of(new IndicesService.IndexShardCacheEntity(indexService.getShard(shardId.id())));
-        }),
+        return new IndicesRequestCache(
+            settings,
+            indicesService.indicesRequestCache.cacheEntityLookup,
             new CacheModule(new ArrayList<>(), Settings.EMPTY).getCacheService(),
             threadPool,
             ClusterServiceUtils.createClusterService(threadPool)
         );
     }
 
+    private DirectoryReader getReader(IndexWriter writer, ShardId shardId) throws IOException {
+        return OpenSearchDirectoryReader.wrap(DirectoryReader.open(writer), shardId);
+    }
+
     private Loader getLoader(DirectoryReader reader) {
         return new Loader(reader, 0);
     }
@@ -1419,6 +1472,55 @@ public void testDeleteAndCreateIndexShardOnSameNodeAndVerifyStats() throws Excep
         IOUtils.close(reader, writer, dir, cache);
     }
 
+    public void testIndexShardClosedAndVerifyCacheCleanUpWorksSuccessfully() throws Exception {
+        threadPool = getThreadPool();
+        String indexName = "test1";
+        // Create a shard
+        IndexService indexService = createIndex(
+            indexName,
+            Settings.builder().put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1).put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 0).build()
+        );
+        IndexShard indexShard = indexService.getShard(0);
+        Directory dir = newDirectory();
+        IndexWriter writer = new IndexWriter(dir, newIndexWriterConfig());
+        writer.addDocument(newDoc(0, "foo"));
+        writer.addDocument(newDoc(1, "hack"));
+        DirectoryReader reader = OpenSearchDirectoryReader.wrap(DirectoryReader.open(writer), indexShard.shardId());
+        Loader loader = new Loader(reader, 0);
+
+        // Set clean interval to a high value as we will do it manually here.
+        IndicesRequestCache cache = getIndicesRequestCache(
+            Settings.builder()
+                .put(IndicesRequestCache.INDICES_REQUEST_CACHE_CLEANUP_INTERVAL_SETTING_KEY, TimeValue.timeValueMillis(100000))
+                .build()
+        );
+        IndicesService.IndexShardCacheEntity cacheEntity = new IndicesService.IndexShardCacheEntity(indexShard);
+        TermQueryBuilder termQuery = new TermQueryBuilder("id", "bar");
+
+        // Cache some values for indexShard
+        BytesReference value = cache.getOrCompute(cacheEntity, loader, reader, getTermBytes());
+
+        // Verify response and stats.
+        assertEquals("foo", value.streamInput().readString());
+        RequestCacheStats stats = indexShard.requestCache().stats();
+        assertEquals("foo", value.streamInput().readString());
+        assertEquals(1, cache.count());
+        assertEquals(1, stats.getMissCount());
+        assertTrue(stats.getMemorySizeInBytes() > 0);
+
+        // Remove the shard making its cache entries stale
+        IOUtils.close(reader, writer, dir);
+        indexService.removeShard(0, "force");
+
+        assertBusy(() -> { assertEquals(IndexShardState.CLOSED, indexShard.state()); }, 1, TimeUnit.SECONDS);
+
+        // Trigger clean up of cache. Should not throw any exception.
+        cache.cacheCleanupManager.cleanCache();
+        // Verify all cleared up.
+        assertEquals(0, cache.count());
+        IOUtils.close(cache);
+    }
+
     public static String generateString(int length) {
         String characters = "abcdefghijklmnopqrstuvwxyz";
         StringBuilder sb = new StringBuilder(length);
diff --git a/server/src/test/java/org/opensearch/indices/IndicesServiceTests.java b/server/src/test/java/org/opensearch/indices/IndicesServiceTests.java
index 1601f137954e2..de9c75869b7df 100644
--- a/server/src/test/java/org/opensearch/indices/IndicesServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/IndicesServiceTests.java
@@ -31,12 +31,15 @@
 
 package org.opensearch.indices;
 
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.search.similarities.BM25Similarity;
 import org.apache.lucene.search.similarities.Similarity;
 import org.apache.lucene.store.AlreadyClosedException;
 import org.opensearch.Version;
 import org.opensearch.action.admin.indices.stats.CommonStatsFlags;
 import org.opensearch.action.admin.indices.stats.IndexShardStats;
+import org.opensearch.action.search.SearchType;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.metadata.IndexGraveyard;
@@ -44,6 +47,7 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.UUIDs;
+import org.opensearch.common.lucene.index.OpenSearchDirectoryReader.DelegatingCacheHelper;
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
@@ -77,8 +81,11 @@
 import org.opensearch.plugins.EnginePlugin;
 import org.opensearch.plugins.MapperPlugin;
 import org.opensearch.plugins.Plugin;
+import org.opensearch.search.internal.ContextIndexSearcher;
+import org.opensearch.search.internal.ShardSearchRequest;
 import org.opensearch.test.IndexSettingsModule;
 import org.opensearch.test.OpenSearchSingleNodeTestCase;
+import org.opensearch.test.TestSearchContext;
 import org.opensearch.test.VersionUtils;
 import org.opensearch.test.hamcrest.RegexMatcher;
 
@@ -636,4 +643,32 @@ public void testClusterRemoteTranslogBufferIntervalDefault() {
             indicesService.getRemoteStoreSettings().getClusterRemoteTranslogBufferInterval()
         );
     }
+
+    public void testDirectoryReaderWithoutDelegatingCacheHelperNotCacheable() throws IOException {
+        IndicesService indicesService = getIndicesService();
+        final IndexService indexService = createIndex("test");
+        ShardSearchRequest request = mock(ShardSearchRequest.class);
+        when(request.requestCache()).thenReturn(true);
+
+        TestSearchContext context = new TestSearchContext(indexService.getBigArrays(), indexService) {
+            @Override
+            public SearchType searchType() {
+                return SearchType.QUERY_THEN_FETCH;
+            }
+        };
+
+        ContextIndexSearcher searcher = mock(ContextIndexSearcher.class);
+        context.setSearcher(searcher);
+        DirectoryReader reader = mock(DirectoryReader.class);
+        when(searcher.getDirectoryReader()).thenReturn(reader);
+        when(searcher.getIndexReader()).thenReturn(reader);
+        IndexReader.CacheHelper notDelegatingCacheHelper = mock(IndexReader.CacheHelper.class);
+        DelegatingCacheHelper delegatingCacheHelper = mock(DelegatingCacheHelper.class);
+
+        for (boolean useDelegatingCacheHelper : new boolean[] { true, false }) {
+            IndexReader.CacheHelper cacheHelper = useDelegatingCacheHelper ? delegatingCacheHelper : notDelegatingCacheHelper;
+            when(reader.getReaderCacheHelper()).thenReturn(cacheHelper);
+            assertEquals(useDelegatingCacheHelper, indicesService.canCache(request, context));
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/indices/RemoteStoreSettingsDynamicUpdateTests.java b/server/src/test/java/org/opensearch/indices/RemoteStoreSettingsDynamicUpdateTests.java
index f89fd3df6e340..cc9096ee41315 100644
--- a/server/src/test/java/org/opensearch/indices/RemoteStoreSettingsDynamicUpdateTests.java
+++ b/server/src/test/java/org/opensearch/indices/RemoteStoreSettingsDynamicUpdateTests.java
@@ -116,4 +116,15 @@ public void testMaxRemoteReferencedTranslogFiles() {
         );
         assertEquals(500, remoteStoreSettings.getMaxRemoteTranslogReaders());
     }
+
+    public void testDisableMaxRemoteReferencedTranslogFiles() {
+        // Test default value
+        assertEquals(1000, remoteStoreSettings.getMaxRemoteTranslogReaders());
+
+        // Test override with valid value
+        clusterSettings.applySettings(
+            Settings.builder().put(RemoteStoreSettings.CLUSTER_REMOTE_MAX_TRANSLOG_READERS.getKey(), "-1").build()
+        );
+        assertEquals(-1, remoteStoreSettings.getMaxRemoteTranslogReaders());
+    }
 }
diff --git a/server/src/test/java/org/opensearch/indices/ShardLimitValidatorTests.java b/server/src/test/java/org/opensearch/indices/ShardLimitValidatorTests.java
index 040632ea3ed8d..0b1ec8fd85ae5 100644
--- a/server/src/test/java/org/opensearch/indices/ShardLimitValidatorTests.java
+++ b/server/src/test/java/org/opensearch/indices/ShardLimitValidatorTests.java
@@ -214,6 +214,25 @@ public void testNonSystemIndexCreationFailsWithMaxShardLimitOnCluster() {
         );
     }
 
+    public void testComputedMaxShardsOfClusterIntOverFlow() {
+        final int maxShardLimitPerNode = 500_000_000;
+        ClusterState state = createClusterForShardLimitTest(15, 1, 1);
+        Optional<String> errorMessage = ShardLimitValidator.checkShardLimit(2, state, maxShardLimitPerNode, -1);
+        assertFalse(errorMessage.isPresent());
+
+        errorMessage = ShardLimitValidator.checkShardLimit(Integer.MAX_VALUE - 1, state, maxShardLimitPerNode, -1);
+        assertEquals(
+            "this action would add ["
+                + (Integer.MAX_VALUE - 1)
+                + "] total shards, but this cluster currently has ["
+                + 2
+                + "]/["
+                + Integer.MAX_VALUE
+                + "] maximum shards open",
+            errorMessage.get()
+        );
+    }
+
     public void testNonSystemIndexCreationPassesWithMaxShardLimitOnCluster() {
         final int maxShardLimitOnCluster = 5;
         Settings limitOnlySettings = Settings.builder()
diff --git a/server/src/test/java/org/opensearch/indices/SystemIndicesTests.java b/server/src/test/java/org/opensearch/indices/SystemIndicesTests.java
index 2b40c01c61242..ca9370645dec3 100644
--- a/server/src/test/java/org/opensearch/indices/SystemIndicesTests.java
+++ b/server/src/test/java/org/opensearch/indices/SystemIndicesTests.java
@@ -32,13 +32,20 @@
 
 package org.opensearch.indices;
 
+import org.opensearch.common.settings.Settings;
+import org.opensearch.plugins.Plugin;
+import org.opensearch.plugins.SystemIndexPlugin;
 import org.opensearch.tasks.TaskResultsService;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.singletonList;
@@ -67,7 +74,7 @@ public void testBasicOverlappingPatterns() {
 
         IllegalStateException exception = expectThrows(
             IllegalStateException.class,
-            () -> SystemIndices.checkForOverlappingPatterns(descriptors)
+            () -> SystemIndexRegistry.checkForOverlappingPatterns(descriptors)
         );
         assertThat(
             exception.getMessage(),
@@ -104,7 +111,7 @@ public void testComplexOverlappingPatterns() {
 
         IllegalStateException exception = expectThrows(
             IllegalStateException.class,
-            () -> SystemIndices.checkForOverlappingPatterns(descriptors)
+            () -> SystemIndexRegistry.checkForOverlappingPatterns(descriptors)
         );
         assertThat(
             exception.getMessage(),
@@ -133,4 +140,154 @@ public void testPluginCannotOverrideBuiltInSystemIndex() {
         IllegalArgumentException e = expectThrows(IllegalArgumentException.class, () -> new SystemIndices(pluginMap));
         assertThat(e.getMessage(), containsString("plugin or module attempted to define the same source"));
     }
+
+    public void testSystemIndexMatching() {
+        SystemIndexPlugin plugin1 = new SystemIndexPlugin1();
+        SystemIndexPlugin plugin2 = new SystemIndexPlugin2();
+        SystemIndexPlugin plugin3 = new SystemIndexPatternPlugin();
+        SystemIndices pluginSystemIndices = new SystemIndices(
+            Map.of(
+                SystemIndexPlugin1.class.getCanonicalName(),
+                plugin1.getSystemIndexDescriptors(Settings.EMPTY),
+                SystemIndexPlugin2.class.getCanonicalName(),
+                plugin2.getSystemIndexDescriptors(Settings.EMPTY),
+                SystemIndexPatternPlugin.class.getCanonicalName(),
+                plugin3.getSystemIndexDescriptors(Settings.EMPTY)
+            )
+        );
+
+        assertThat(
+            SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".system-index1", ".system-index2")),
+            equalTo(Set.of(SystemIndexPlugin1.SYSTEM_INDEX_1, SystemIndexPlugin2.SYSTEM_INDEX_2))
+        );
+        assertThat(
+            SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".system-index1")),
+            equalTo(Set.of(SystemIndexPlugin1.SYSTEM_INDEX_1))
+        );
+        assertThat(
+            SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".system-index2")),
+            equalTo(Set.of(SystemIndexPlugin2.SYSTEM_INDEX_2))
+        );
+        assertThat(
+            SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".system-index-pattern1")),
+            equalTo(Set.of(".system-index-pattern1"))
+        );
+        assertThat(
+            SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".system-index-pattern-sub*")),
+            equalTo(Set.of(".system-index-pattern-sub*"))
+        );
+        assertThat(
+            SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".system-index-pattern1", ".system-index-pattern2")),
+            equalTo(Set.of(".system-index-pattern1", ".system-index-pattern2"))
+        );
+        assertThat(
+            SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".system-index1", ".system-index-pattern1")),
+            equalTo(Set.of(".system-index1", ".system-index-pattern1"))
+        );
+        assertThat(
+            SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".system-index1", ".system-index-pattern1", ".not-system")),
+            equalTo(Set.of(".system-index1", ".system-index-pattern1"))
+        );
+        assertThat(SystemIndexRegistry.matchesSystemIndexPattern(Set.of(".not-system")), equalTo(Collections.emptySet()));
+    }
+
+    public void testRegisteredSystemIndexGetAllDescriptors() {
+        SystemIndexPlugin plugin1 = new SystemIndexPlugin1();
+        SystemIndexPlugin plugin2 = new SystemIndexPlugin2();
+        SystemIndices pluginSystemIndices = new SystemIndices(
+            Map.of(
+                SystemIndexPlugin1.class.getCanonicalName(),
+                plugin1.getSystemIndexDescriptors(Settings.EMPTY),
+                SystemIndexPlugin2.class.getCanonicalName(),
+                plugin2.getSystemIndexDescriptors(Settings.EMPTY)
+            )
+        );
+        assertEquals(
+            SystemIndexRegistry.getAllDescriptors()
+                .stream()
+                .map(SystemIndexDescriptor::getIndexPattern)
+                .collect(Collectors.toUnmodifiableList()),
+            List.of(SystemIndexPlugin1.SYSTEM_INDEX_1, SystemIndexPlugin2.SYSTEM_INDEX_2, TASK_INDEX + "*")
+        );
+    }
+
+    public void testRegisteredSystemIndexMatching() {
+        SystemIndexPlugin plugin1 = new SystemIndexPlugin1();
+        SystemIndexPlugin plugin2 = new SystemIndexPlugin2();
+        SystemIndices pluginSystemIndices = new SystemIndices(
+            Map.of(
+                SystemIndexPlugin1.class.getCanonicalName(),
+                plugin1.getSystemIndexDescriptors(Settings.EMPTY),
+                SystemIndexPlugin2.class.getCanonicalName(),
+                plugin2.getSystemIndexDescriptors(Settings.EMPTY)
+            )
+        );
+        Set<String> systemIndices = SystemIndexRegistry.matchesSystemIndexPattern(
+            Set.of(SystemIndexPlugin1.SYSTEM_INDEX_1, SystemIndexPlugin2.SYSTEM_INDEX_2)
+        );
+        assertEquals(2, systemIndices.size());
+        assertTrue(systemIndices.containsAll(Set.of(SystemIndexPlugin1.SYSTEM_INDEX_1, SystemIndexPlugin2.SYSTEM_INDEX_2)));
+    }
+
+    public void testRegisteredSystemIndexMatchingForPlugin() {
+        SystemIndexPlugin plugin1 = new SystemIndexPlugin1();
+        SystemIndexPlugin plugin2 = new SystemIndexPlugin2();
+        SystemIndices pluginSystemIndices = new SystemIndices(
+            Map.of(
+                SystemIndexPlugin1.class.getCanonicalName(),
+                plugin1.getSystemIndexDescriptors(Settings.EMPTY),
+                SystemIndexPlugin2.class.getCanonicalName(),
+                plugin2.getSystemIndexDescriptors(Settings.EMPTY)
+            )
+        );
+        Set<String> systemIndicesForPlugin1 = SystemIndexRegistry.matchesPluginSystemIndexPattern(
+            SystemIndexPlugin1.class.getCanonicalName(),
+            Set.of(SystemIndexPlugin1.SYSTEM_INDEX_1, SystemIndexPlugin2.SYSTEM_INDEX_2, "other-index")
+        );
+        assertEquals(1, systemIndicesForPlugin1.size());
+        assertTrue(systemIndicesForPlugin1.contains(SystemIndexPlugin1.SYSTEM_INDEX_1));
+
+        Set<String> systemIndicesForPlugin2 = SystemIndexRegistry.matchesPluginSystemIndexPattern(
+            SystemIndexPlugin2.class.getCanonicalName(),
+            Set.of(SystemIndexPlugin1.SYSTEM_INDEX_1, SystemIndexPlugin2.SYSTEM_INDEX_2, "other-index")
+        );
+        assertEquals(1, systemIndicesForPlugin2.size());
+        assertTrue(systemIndicesForPlugin2.contains(SystemIndexPlugin2.SYSTEM_INDEX_2));
+
+        Set<String> noMatchingSystemIndices = SystemIndexRegistry.matchesPluginSystemIndexPattern(
+            SystemIndexPlugin2.class.getCanonicalName(),
+            Set.of("other-index")
+        );
+        assertEquals(0, noMatchingSystemIndices.size());
+    }
+
+    static final class SystemIndexPlugin1 extends Plugin implements SystemIndexPlugin {
+        public static final String SYSTEM_INDEX_1 = ".system-index1";
+
+        @Override
+        public Collection<SystemIndexDescriptor> getSystemIndexDescriptors(Settings settings) {
+            final SystemIndexDescriptor systemIndexDescriptor = new SystemIndexDescriptor(SYSTEM_INDEX_1, "System index 1");
+            return Collections.singletonList(systemIndexDescriptor);
+        }
+    }
+
+    static final class SystemIndexPlugin2 extends Plugin implements SystemIndexPlugin {
+        public static final String SYSTEM_INDEX_2 = ".system-index2";
+
+        @Override
+        public Collection<SystemIndexDescriptor> getSystemIndexDescriptors(Settings settings) {
+            final SystemIndexDescriptor systemIndexDescriptor = new SystemIndexDescriptor(SYSTEM_INDEX_2, "System index 2");
+            return Collections.singletonList(systemIndexDescriptor);
+        }
+    }
+
+    static final class SystemIndexPatternPlugin extends Plugin implements SystemIndexPlugin {
+        public static final String SYSTEM_INDEX_PATTERN = ".system-index-pattern*";
+
+        @Override
+        public Collection<SystemIndexDescriptor> getSystemIndexDescriptors(Settings settings) {
+            final SystemIndexDescriptor systemIndexDescriptor = new SystemIndexDescriptor(SYSTEM_INDEX_PATTERN, "System index pattern");
+            return Collections.singletonList(systemIndexDescriptor);
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/indices/TermsLookupTests.java b/server/src/test/java/org/opensearch/indices/TermsLookupTests.java
index 8a7867729f2c1..3f45bc86104dd 100644
--- a/server/src/test/java/org/opensearch/indices/TermsLookupTests.java
+++ b/server/src/test/java/org/opensearch/indices/TermsLookupTests.java
@@ -48,12 +48,15 @@ public void testTermsLookup() {
         String id = randomAlphaOfLengthBetween(1, 10);
         String path = randomAlphaOfLengthBetween(1, 10);
         String routing = randomAlphaOfLengthBetween(1, 10);
+        boolean store = randomBoolean();
         TermsLookup termsLookup = new TermsLookup(index, id, path);
         termsLookup.routing(routing);
+        termsLookup.store(store);
         assertEquals(index, termsLookup.index());
         assertEquals(id, termsLookup.id());
         assertEquals(path, termsLookup.path());
         assertEquals(routing, termsLookup.routing());
+        assertEquals(store, termsLookup.store());
     }
 
     public void testIllegalArguments() {
@@ -109,6 +112,6 @@ public void testXContentParsing() throws IOException {
     public static TermsLookup randomTermsLookup() {
         return new TermsLookup(randomAlphaOfLength(10), randomAlphaOfLength(10), randomAlphaOfLength(10).replace('.', '_')).routing(
             randomBoolean() ? randomAlphaOfLength(10) : null
-        );
+        ).store(randomBoolean());
     }
 }
diff --git a/server/src/test/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerServiceTests.java b/server/src/test/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerServiceTests.java
index 591f8f15a1441..ea113abd6913a 100644
--- a/server/src/test/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerServiceTests.java
+++ b/server/src/test/java/org/opensearch/indices/breaker/HierarchyCircuitBreakerServiceTests.java
@@ -793,7 +793,7 @@ public void testAllocationBucketsBreaker() {
 
             // make sure used bytes is greater than the total circuit breaker limit
             breaker.addWithoutBreaking(200);
-            // make sure that we check on the the following call
+            // make sure that we check on the following call
             for (int i = 0; i < 1023; i++) {
                 multiBucketConsumer.accept(0);
             }
diff --git a/server/src/test/java/org/opensearch/indices/cluster/ClusterStateChanges.java b/server/src/test/java/org/opensearch/indices/cluster/ClusterStateChanges.java
index b6ca632d4b49a..bea1dcf0cffce 100644
--- a/server/src/test/java/org/opensearch/indices/cluster/ClusterStateChanges.java
+++ b/server/src/test/java/org/opensearch/indices/cluster/ClusterStateChanges.java
@@ -94,8 +94,8 @@
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.ClusterSettings;
-import org.opensearch.common.settings.IndexScopedSettings;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.settings.SettingsModule;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.action.ActionResponse;
 import org.opensearch.core.index.Index;
@@ -291,10 +291,13 @@ public IndexMetadata upgradeIndexMetadata(IndexMetadata indexMetadata, Version m
 
         final AwarenessReplicaBalance awarenessReplicaBalance = new AwarenessReplicaBalance(SETTINGS, clusterService.getClusterSettings());
 
+        // build IndexScopedSettings from a settingsModule so that all settings gated by enabled featureFlags are registered.
+        SettingsModule settingsModule = new SettingsModule(Settings.EMPTY);
+
         MetadataUpdateSettingsService metadataUpdateSettingsService = new MetadataUpdateSettingsService(
             clusterService,
             allocationService,
-            IndexScopedSettings.DEFAULT_SCOPED_SETTINGS,
+            settingsModule.getIndexScopedSettings(),
             indicesService,
             shardLimitValidator,
             threadPool,
@@ -308,7 +311,7 @@ public IndexMetadata upgradeIndexMetadata(IndexMetadata indexMetadata, Version m
             new AliasValidator(),
             shardLimitValidator,
             environment,
-            IndexScopedSettings.DEFAULT_SCOPED_SETTINGS,
+            settingsModule.getIndexScopedSettings(),
             threadPool,
             xContentRegistry,
             systemIndices,
diff --git a/server/src/test/java/org/opensearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java b/server/src/test/java/org/opensearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java
index 2793d446d66c8..650db6a2baf5a 100644
--- a/server/src/test/java/org/opensearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java
+++ b/server/src/test/java/org/opensearch/indices/recovery/RecoverySettingsDynamicUpdateTests.java
@@ -118,4 +118,23 @@ public void testInternalLongActionTimeout() {
         );
         assertEquals(new TimeValue(duration, timeUnit), recoverySettings.internalActionLongTimeout());
     }
+
+    public void testChunkSize() {
+        ByteSizeValue chunkSize = new ByteSizeValue(between(1, 1000), ByteSizeUnit.BYTES);
+        clusterSettings.applySettings(
+            Settings.builder().put(RecoverySettings.INDICES_RECOVERY_CHUNK_SIZE_SETTING.getKey(), chunkSize).build()
+        );
+        assertEquals(chunkSize, recoverySettings.getChunkSize());
+    }
+
+    public void testInternalActionRetryTimeout() {
+        long duration = between(1, 1000);
+        TimeUnit timeUnit = randomFrom(TimeUnit.MILLISECONDS, TimeUnit.SECONDS, TimeUnit.MINUTES, TimeUnit.HOURS);
+        clusterSettings.applySettings(
+            Settings.builder()
+                .put(RecoverySettings.INDICES_RECOVERY_INTERNAL_ACTION_RETRY_TIMEOUT_SETTING.getKey(), duration, timeUnit)
+                .build()
+        );
+        assertEquals(new TimeValue(duration, timeUnit), recoverySettings.internalActionRetryTimeout());
+    }
 }
diff --git a/server/src/test/java/org/opensearch/indices/replication/SegmentReplicatorTests.java b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicatorTests.java
new file mode 100644
index 0000000000000..7acee449a1b46
--- /dev/null
+++ b/server/src/test/java/org/opensearch/indices/replication/SegmentReplicatorTests.java
@@ -0,0 +1,163 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.replication;
+
+import org.apache.lucene.store.IOContext;
+import org.opensearch.OpenSearchCorruptionException;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.lucene.Lucene;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.index.engine.NRTReplicationEngineFactory;
+import org.opensearch.index.replication.TestReplicationSource;
+import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.shard.IndexShardTestCase;
+import org.opensearch.index.store.StoreFileMetadata;
+import org.opensearch.indices.replication.checkpoint.ReplicationCheckpoint;
+import org.opensearch.indices.replication.common.CopyState;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+
+import org.mockito.Mockito;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+public class SegmentReplicatorTests extends IndexShardTestCase {
+
+    private static final Settings settings = Settings.builder()
+        .put(IndexMetadata.SETTING_REPLICATION_TYPE, ReplicationType.SEGMENT)
+        .build();
+
+    public void testStartReplicationWithoutSourceFactory() {
+        ThreadPool threadpool = mock(ThreadPool.class);
+        ExecutorService mock = mock(ExecutorService.class);
+        when(threadpool.generic()).thenReturn(mock);
+        SegmentReplicator segmentReplicator = new SegmentReplicator(threadpool);
+
+        IndexShard shard = mock(IndexShard.class);
+        segmentReplicator.startReplication(shard);
+        Mockito.verifyNoInteractions(mock);
+    }
+
+    public void testStartReplicationRunsSuccessfully() throws Exception {
+        final IndexShard replica = newStartedShard(false, settings, new NRTReplicationEngineFactory());
+        final IndexShard primary = newStartedShard(true, settings, new NRTReplicationEngineFactory());
+
+        // index and copy segments to replica.
+        int numDocs = randomIntBetween(10, 20);
+        for (int i = 0; i < numDocs; i++) {
+            indexDoc(primary, "_doc", Integer.toString(i));
+        }
+        primary.refresh("test");
+
+        SegmentReplicator segmentReplicator = spy(new SegmentReplicator(threadPool));
+        SegmentReplicationSourceFactory factory = mock(SegmentReplicationSourceFactory.class);
+        when(factory.get(replica)).thenReturn(new TestReplicationSource() {
+            @Override
+            public void getCheckpointMetadata(
+                long replicationId,
+                ReplicationCheckpoint checkpoint,
+                ActionListener<CheckpointInfoResponse> listener
+            ) {
+                resolveCheckpointListener(listener, primary);
+            }
+
+            @Override
+            public void getSegmentFiles(
+                long replicationId,
+                ReplicationCheckpoint checkpoint,
+                List<StoreFileMetadata> filesToFetch,
+                IndexShard indexShard,
+                BiConsumer<String, Long> fileProgressTracker,
+                ActionListener<GetSegmentFilesResponse> listener
+            ) {
+                try {
+                    Lucene.cleanLuceneIndex(indexShard.store().directory());
+                    Map<String, StoreFileMetadata> segmentMetadataMap = primary.getSegmentMetadataMap();
+                    for (String file : segmentMetadataMap.keySet()) {
+                        indexShard.store().directory().copyFrom(primary.store().directory(), file, file, IOContext.DEFAULT);
+                    }
+                    listener.onResponse(new GetSegmentFilesResponse(new ArrayList<>(segmentMetadataMap.values())));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        });
+        segmentReplicator.setSourceFactory(factory);
+        segmentReplicator.startReplication(replica);
+        assertBusy(() -> assertDocCount(replica, numDocs));
+        closeShards(primary, replica);
+    }
+
+    public void testReplicationFails() throws Exception {
+        allowShardFailures();
+        final IndexShard replica = newStartedShard(false, settings, new NRTReplicationEngineFactory());
+        final IndexShard primary = newStartedShard(true, settings, new NRTReplicationEngineFactory());
+
+        SegmentReplicator segmentReplicator = spy(new SegmentReplicator(threadPool));
+        SegmentReplicationSourceFactory factory = mock(SegmentReplicationSourceFactory.class);
+        when(factory.get(replica)).thenReturn(new TestReplicationSource() {
+            @Override
+            public void getCheckpointMetadata(
+                long replicationId,
+                ReplicationCheckpoint checkpoint,
+                ActionListener<CheckpointInfoResponse> listener
+            ) {
+                resolveCheckpointListener(listener, primary);
+            }
+
+            @Override
+            public void getSegmentFiles(
+                long replicationId,
+                ReplicationCheckpoint checkpoint,
+                List<StoreFileMetadata> filesToFetch,
+                IndexShard indexShard,
+                BiConsumer<String, Long> fileProgressTracker,
+                ActionListener<GetSegmentFilesResponse> listener
+            ) {
+                OpenSearchCorruptionException corruptIndexException = new OpenSearchCorruptionException("test");
+                try {
+                    indexShard.store().markStoreCorrupted(corruptIndexException);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                listener.onFailure(corruptIndexException);
+            }
+        });
+        // assert shard failure on corruption
+        AtomicBoolean failureCallbackTriggered = new AtomicBoolean(false);
+        replica.addShardFailureCallback((ig) -> failureCallbackTriggered.set(true));
+        segmentReplicator.setSourceFactory(factory);
+        segmentReplicator.startReplication(replica);
+        assertBusy(() -> assertTrue(failureCallbackTriggered.get()));
+        closeShards(primary, replica);
+    }
+
+    protected void resolveCheckpointListener(ActionListener<CheckpointInfoResponse> listener, IndexShard primary) {
+        try (final CopyState copyState = new CopyState(primary)) {
+            listener.onResponse(
+                new CheckpointInfoResponse(copyState.getCheckpoint(), copyState.getMetadataMap(), copyState.getInfosBytes())
+            );
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/indices/tiering/TieringRequestValidatorTests.java b/server/src/test/java/org/opensearch/indices/tiering/TieringRequestValidatorTests.java
new file mode 100644
index 0000000000000..6b6f74353812b
--- /dev/null
+++ b/server/src/test/java/org/opensearch/indices/tiering/TieringRequestValidatorTests.java
@@ -0,0 +1,318 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.indices.tiering;
+
+import org.opensearch.Version;
+import org.opensearch.action.admin.indices.tiering.TieringValidationResult;
+import org.opensearch.cluster.ClusterInfo;
+import org.opensearch.cluster.ClusterName;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.DiskUsage;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.cluster.metadata.Metadata;
+import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.cluster.node.DiscoveryNodeRole;
+import org.opensearch.cluster.node.DiscoveryNodes;
+import org.opensearch.cluster.routing.RoutingTable;
+import org.opensearch.cluster.routing.allocation.DiskThresholdSettings;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.IndexModule;
+import org.opensearch.indices.replication.common.ReplicationType;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import static org.opensearch.cluster.routing.allocation.DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING;
+import static org.opensearch.cluster.routing.allocation.DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING;
+import static org.opensearch.cluster.routing.allocation.DiskThresholdSettings.CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK_SETTING;
+import static org.opensearch.indices.tiering.TieringRequestValidator.getEligibleNodes;
+import static org.opensearch.indices.tiering.TieringRequestValidator.getIndexPrimaryStoreSize;
+import static org.opensearch.indices.tiering.TieringRequestValidator.getTotalAvailableBytesInWarmTier;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateDiskThresholdWaterMarkNotBreached;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateEligibleNodesCapacity;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateHotIndex;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateIndexHealth;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateOpenIndex;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateRemoteStoreIndex;
+import static org.opensearch.indices.tiering.TieringRequestValidator.validateSearchNodes;
+
+public class TieringRequestValidatorTests extends OpenSearchTestCase {
+
+    public void testValidateSearchNodes() {
+        ClusterState clusterStateWithSearchNodes = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(2, 0, 0))
+            .build();
+
+        // throws no errors
+        validateSearchNodes(clusterStateWithSearchNodes, "test_index");
+    }
+
+    public void testWithNoSearchNodesInCluster() {
+        ClusterState clusterStateWithNoSearchNodes = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(0, 1, 1))
+            .build();
+        // throws error
+        IllegalArgumentException e = expectThrows(
+            IllegalArgumentException.class,
+            () -> validateSearchNodes(clusterStateWithNoSearchNodes, "test")
+        );
+    }
+
+    public void testValidRemoteStoreIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+
+        ClusterState clusterState1 = buildClusterState(
+            indexName,
+            indexUuid,
+            Settings.builder()
+                .put(IndexMetadata.INDEX_REMOTE_STORE_ENABLED_SETTING.getKey(), true)
+                .put(IndexMetadata.INDEX_REPLICATION_TYPE_SETTING.getKey(), ReplicationType.SEGMENT)
+                .build()
+        );
+
+        assertTrue(validateRemoteStoreIndex(clusterState1, new Index(indexName, indexUuid)));
+    }
+
+    public void testDocRepIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        assertFalse(validateRemoteStoreIndex(buildClusterState(indexName, indexUuid, Settings.EMPTY), new Index(indexName, indexUuid)));
+    }
+
+    public void testValidHotIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        assertTrue(validateHotIndex(buildClusterState(indexName, indexUuid, Settings.EMPTY), new Index(indexName, indexUuid)));
+    }
+
+    public void testIndexWithOngoingOrCompletedTiering() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+
+        IndexModule.TieringState tieringState = randomBoolean() ? IndexModule.TieringState.HOT_TO_WARM : IndexModule.TieringState.WARM;
+
+        ClusterState clusterState = buildClusterState(
+            indexName,
+            indexUuid,
+            Settings.builder().put(IndexModule.INDEX_TIERING_STATE.getKey(), tieringState).build()
+        );
+        assertFalse(validateHotIndex(clusterState, new Index(indexName, indexUuid)));
+    }
+
+    public void testValidateIndexHealth() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        ClusterState clusterState = buildClusterState(indexName, indexUuid, Settings.EMPTY);
+        assertTrue(validateIndexHealth(clusterState, new Index(indexName, indexUuid)));
+    }
+
+    public void testValidOpenIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        assertTrue(validateOpenIndex(buildClusterState(indexName, indexUuid, Settings.EMPTY), new Index(indexName, indexUuid)));
+    }
+
+    public void testCloseIndex() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        assertFalse(
+            validateOpenIndex(
+                buildClusterState(indexName, indexUuid, Settings.EMPTY, IndexMetadata.State.CLOSE),
+                new Index(indexName, indexUuid)
+            )
+        );
+    }
+
+    public void testValidateDiskThresholdWaterMarkNotBreached() {
+        int noOfNodes = 2;
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(noOfNodes, 0, 0))
+            .build();
+
+        ClusterInfo clusterInfo = clusterInfo(noOfNodes, 100, 20);
+        DiskThresholdSettings diskThresholdSettings = diskThresholdSettings("10b", "10b", "5b");
+        // throws no error
+        validateDiskThresholdWaterMarkNotBreached(clusterState, clusterInfo, diskThresholdSettings, "test");
+    }
+
+    public void testValidateDiskThresholdWaterMarkNotBreachedThrowsError() {
+        int noOfNodes = 2;
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(noOfNodes, 0, 0))
+            .build();
+        ClusterInfo clusterInfo = clusterInfo(noOfNodes, 100, 5);
+        DiskThresholdSettings diskThresholdSettings = diskThresholdSettings("10b", "10b", "5b");
+        // throws error
+        expectThrows(
+            IllegalArgumentException.class,
+            () -> validateDiskThresholdWaterMarkNotBreached(clusterState, clusterInfo, diskThresholdSettings, "test")
+        );
+    }
+
+    public void testGetTotalIndexSize() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        ClusterState clusterState = ClusterState.builder(buildClusterState(indexName, indexUuid, Settings.EMPTY))
+            .nodes(createNodes(1, 0, 0))
+            .build();
+        Map<String, DiskUsage> diskUsages = diskUsages(1, 100, 50);
+        final Map<String, Long> shardSizes = new HashMap<>();
+        shardSizes.put("[test_index][0][p]", 10L); // 10 bytes
+        ClusterInfo clusterInfo = new ClusterInfo(diskUsages, null, shardSizes, null, Map.of(), Map.of());
+        assertEquals(10, getIndexPrimaryStoreSize(clusterState, clusterInfo, indexName));
+    }
+
+    public void testValidateEligibleNodesCapacityWithAllAccepted() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        Set<Index> indices = Set.of(new Index(indexName, indexUuid));
+        ClusterState clusterState = ClusterState.builder(buildClusterState(indexName, indexUuid, Settings.EMPTY))
+            .nodes(createNodes(1, 0, 0))
+            .build();
+        Map<String, DiskUsage> diskUsages = diskUsages(1, 100, 50);
+        final Map<String, Long> shardSizes = new HashMap<>();
+        shardSizes.put("[test_index][0][p]", 10L); // 10 bytes
+        ClusterInfo clusterInfo = new ClusterInfo(diskUsages, null, shardSizes, null, Map.of(), Map.of());
+        TieringValidationResult tieringValidationResult = new TieringValidationResult(indices);
+        validateEligibleNodesCapacity(clusterInfo, clusterState, tieringValidationResult);
+        assertEquals(indices, tieringValidationResult.getAcceptedIndices());
+        assertTrue(tieringValidationResult.getRejectedIndices().isEmpty());
+    }
+
+    public void testValidateEligibleNodesCapacityWithAllRejected() {
+        String indexUuid = UUID.randomUUID().toString();
+        String indexName = "test_index";
+        Set<Index> indices = Set.of(new Index(indexName, indexUuid));
+        ClusterState clusterState = ClusterState.builder(buildClusterState(indexName, indexUuid, Settings.EMPTY))
+            .nodes(createNodes(1, 0, 0))
+            .build();
+        Map<String, DiskUsage> diskUsages = diskUsages(1, 100, 10);
+        final Map<String, Long> shardSizes = new HashMap<>();
+        shardSizes.put("[test_index][0][p]", 20L); // 20 bytes
+        ClusterInfo clusterInfo = new ClusterInfo(diskUsages, null, shardSizes, null, Map.of(), Map.of());
+        TieringValidationResult tieringValidationResult = new TieringValidationResult(indices);
+        validateEligibleNodesCapacity(clusterInfo, clusterState, tieringValidationResult);
+        assertEquals(indices.size(), tieringValidationResult.getRejectedIndices().size());
+        assertEquals(indices, tieringValidationResult.getRejectedIndices().keySet());
+        assertTrue(tieringValidationResult.getAcceptedIndices().isEmpty());
+    }
+
+    public void testGetTotalAvailableBytesInWarmTier() {
+        Map<String, DiskUsage> diskUsages = diskUsages(2, 500, 100);
+        assertEquals(200, getTotalAvailableBytesInWarmTier(diskUsages, Set.of("node-s0", "node-s1")));
+    }
+
+    public void testEligibleNodes() {
+        ClusterState clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(2, 0, 0))
+            .build();
+
+        assertEquals(2, getEligibleNodes(clusterState).size());
+
+        clusterState = ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .nodes(createNodes(0, 1, 1))
+            .build();
+        assertEquals(0, getEligibleNodes(clusterState).size());
+    }
+
+    private static ClusterState buildClusterState(String indexName, String indexUuid, Settings settings) {
+        return buildClusterState(indexName, indexUuid, settings, IndexMetadata.State.OPEN);
+    }
+
+    private static ClusterState buildClusterState(String indexName, String indexUuid, Settings settings, IndexMetadata.State state) {
+        Settings combinedSettings = Settings.builder().put(settings).put(createDefaultIndexSettings(indexUuid)).build();
+
+        Metadata metadata = Metadata.builder().put(IndexMetadata.builder(indexName).settings(combinedSettings).state(state)).build();
+
+        RoutingTable routingTable = RoutingTable.builder().addAsNew(metadata.index(indexName)).build();
+
+        return ClusterState.builder(ClusterName.CLUSTER_NAME_SETTING.getDefault(Settings.EMPTY))
+            .metadata(metadata)
+            .routingTable(routingTable)
+            .build();
+    }
+
+    private static Settings createDefaultIndexSettings(String indexUuid) {
+        return Settings.builder()
+            .put("index.version.created", Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, indexUuid)
+            .put(IndexMetadata.INDEX_NUMBER_OF_SHARDS_SETTING.getKey(), 2)
+            .put(IndexMetadata.INDEX_NUMBER_OF_REPLICAS_SETTING.getKey(), 1)
+            .build();
+    }
+
+    private DiscoveryNodes createNodes(int numOfSearchNodes, int numOfDataNodes, int numOfIngestNodes) {
+        DiscoveryNodes.Builder discoveryNodesBuilder = DiscoveryNodes.builder();
+        for (int i = 0; i < numOfSearchNodes; i++) {
+            discoveryNodesBuilder.add(
+                new DiscoveryNode(
+                    "node-s" + i,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    Collections.singleton(DiscoveryNodeRole.SEARCH_ROLE),
+                    Version.CURRENT
+                )
+            );
+        }
+        for (int i = 0; i < numOfDataNodes; i++) {
+            discoveryNodesBuilder.add(
+                new DiscoveryNode(
+                    "node-d" + i,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    Collections.singleton(DiscoveryNodeRole.DATA_ROLE),
+                    Version.CURRENT
+                )
+            );
+        }
+        for (int i = 0; i < numOfIngestNodes; i++) {
+            discoveryNodesBuilder.add(
+                new DiscoveryNode(
+                    "node-i" + i,
+                    buildNewFakeTransportAddress(),
+                    Collections.emptyMap(),
+                    Collections.singleton(DiscoveryNodeRole.INGEST_ROLE),
+                    Version.CURRENT
+                )
+            );
+        }
+        return discoveryNodesBuilder.build();
+    }
+
+    private static DiskThresholdSettings diskThresholdSettings(String low, String high, String flood) {
+        return new DiskThresholdSettings(
+            Settings.builder()
+                .put(CLUSTER_ROUTING_ALLOCATION_LOW_DISK_WATERMARK_SETTING.getKey(), low)
+                .put(CLUSTER_ROUTING_ALLOCATION_HIGH_DISK_WATERMARK_SETTING.getKey(), high)
+                .put(CLUSTER_ROUTING_ALLOCATION_DISK_FLOOD_STAGE_WATERMARK_SETTING.getKey(), flood)
+                .build(),
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
+    }
+
+    private static ClusterInfo clusterInfo(int noOfNodes, long totalBytes, long freeBytes) {
+        final Map<String, DiskUsage> diskUsages = diskUsages(noOfNodes, totalBytes, freeBytes);
+        return new ClusterInfo(diskUsages, null, null, null, Map.of(), Map.of());
+    }
+
+    private static Map<String, DiskUsage> diskUsages(int noOfSearchNodes, long totalBytes, long freeBytes) {
+        final Map<String, DiskUsage> diskUsages = new HashMap<>();
+        for (int i = 0; i < noOfSearchNodes; i++) {
+            diskUsages.put("node-s" + i, new DiskUsage("node-s" + i, "node-s" + i, "/foo/bar", totalBytes, freeBytes));
+        }
+        return diskUsages;
+    }
+}
diff --git a/server/src/test/java/org/opensearch/ingest/AbstractBatchingProcessorTests.java b/server/src/test/java/org/opensearch/ingest/AbstractBatchingProcessorTests.java
new file mode 100644
index 0000000000000..54fc30cb5befa
--- /dev/null
+++ b/server/src/test/java/org/opensearch/ingest/AbstractBatchingProcessorTests.java
@@ -0,0 +1,160 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.ingest;
+
+import org.opensearch.OpenSearchParseException;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+
+public class AbstractBatchingProcessorTests extends OpenSearchTestCase {
+
+    public void testBatchExecute_emptyInput() {
+        DummyProcessor processor = new DummyProcessor(3);
+        Consumer<List<IngestDocumentWrapper>> handler = (results) -> assertTrue(results.isEmpty());
+        processor.batchExecute(Collections.emptyList(), handler);
+        assertTrue(processor.getSubBatches().isEmpty());
+    }
+
+    public void testBatchExecute_singleBatchSize() {
+        DummyProcessor processor = new DummyProcessor(3);
+        List<IngestDocumentWrapper> wrapperList = Arrays.asList(
+            IngestDocumentPreparer.createIngestDocumentWrapper(1),
+            IngestDocumentPreparer.createIngestDocumentWrapper(2),
+            IngestDocumentPreparer.createIngestDocumentWrapper(3)
+        );
+        List<IngestDocumentWrapper> resultList = new ArrayList<>();
+        processor.batchExecute(wrapperList, resultList::addAll);
+        assertEquals(wrapperList, resultList);
+        assertEquals(1, processor.getSubBatches().size());
+        assertEquals(wrapperList, processor.getSubBatches().get(0));
+    }
+
+    public void testBatchExecute_multipleBatches() {
+        DummyProcessor processor = new DummyProcessor(2);
+        List<IngestDocumentWrapper> wrapperList = Arrays.asList(
+            IngestDocumentPreparer.createIngestDocumentWrapper(1),
+            IngestDocumentPreparer.createIngestDocumentWrapper(2),
+            IngestDocumentPreparer.createIngestDocumentWrapper(3),
+            IngestDocumentPreparer.createIngestDocumentWrapper(4),
+            IngestDocumentPreparer.createIngestDocumentWrapper(5)
+        );
+        List<IngestDocumentWrapper> resultList = new ArrayList<>();
+        processor.batchExecute(wrapperList, resultList::addAll);
+        assertEquals(wrapperList, resultList);
+        assertEquals(3, processor.getSubBatches().size());
+        assertEquals(wrapperList.subList(0, 2), processor.getSubBatches().get(0));
+        assertEquals(wrapperList.subList(2, 4), processor.getSubBatches().get(1));
+        assertEquals(wrapperList.subList(4, 5), processor.getSubBatches().get(2));
+    }
+
+    public void testBatchExecute_randomBatches() {
+        int batchSize = randomIntBetween(2, 32);
+        int docCount = randomIntBetween(2, 32);
+        DummyProcessor processor = new DummyProcessor(batchSize);
+        List<IngestDocumentWrapper> wrapperList = new ArrayList<>();
+        for (int i = 0; i < docCount; ++i) {
+            wrapperList.add(IngestDocumentPreparer.createIngestDocumentWrapper(i));
+        }
+        List<IngestDocumentWrapper> resultList = new ArrayList<>();
+        processor.batchExecute(wrapperList, resultList::addAll);
+        assertEquals(wrapperList, resultList);
+        assertEquals(docCount / batchSize + (docCount % batchSize == 0 ? 0 : 1), processor.getSubBatches().size());
+    }
+
+    public void testBatchExecute_defaultBatchSize() {
+        DummyProcessor processor = new DummyProcessor(1);
+        List<IngestDocumentWrapper> wrapperList = Arrays.asList(
+            IngestDocumentPreparer.createIngestDocumentWrapper(1),
+            IngestDocumentPreparer.createIngestDocumentWrapper(2),
+            IngestDocumentPreparer.createIngestDocumentWrapper(3)
+        );
+        List<IngestDocumentWrapper> resultList = new ArrayList<>();
+        processor.batchExecute(wrapperList, resultList::addAll);
+        assertEquals(wrapperList, resultList);
+        assertEquals(3, processor.getSubBatches().size());
+        assertEquals(wrapperList.subList(0, 1), processor.getSubBatches().get(0));
+        assertEquals(wrapperList.subList(1, 2), processor.getSubBatches().get(1));
+        assertEquals(wrapperList.subList(2, 3), processor.getSubBatches().get(2));
+    }
+
+    public void testFactory_invalidBatchSize() {
+        Map<String, Object> config = new HashMap<>();
+        config.put("batch_size", 0);
+        DummyProcessor.DummyProcessorFactory factory = new DummyProcessor.DummyProcessorFactory("DummyProcessor");
+        OpenSearchParseException exception = assertThrows(OpenSearchParseException.class, () -> factory.create(config));
+        assertEquals("[batch_size] batch size must be a positive integer", exception.getMessage());
+    }
+
+    public void testFactory_defaultBatchSize() throws Exception {
+        Map<String, Object> config = new HashMap<>();
+        DummyProcessor.DummyProcessorFactory factory = new DummyProcessor.DummyProcessorFactory("DummyProcessor");
+        DummyProcessor processor = (DummyProcessor) factory.create(config);
+        assertEquals(1, processor.batchSize);
+    }
+
+    public void testFactory_callNewProcessor() throws Exception {
+        Map<String, Object> config = new HashMap<>();
+        config.put("batch_size", 3);
+        DummyProcessor.DummyProcessorFactory factory = new DummyProcessor.DummyProcessorFactory("DummyProcessor");
+        DummyProcessor processor = (DummyProcessor) factory.create(config);
+        assertEquals(3, processor.batchSize);
+    }
+
+    static class DummyProcessor extends AbstractBatchingProcessor {
+        private List<List<IngestDocumentWrapper>> subBatches = new ArrayList<>();
+
+        public List<List<IngestDocumentWrapper>> getSubBatches() {
+            return subBatches;
+        }
+
+        protected DummyProcessor(int batchSize) {
+            super("tag", "description", batchSize);
+        }
+
+        @Override
+        public void subBatchExecute(List<IngestDocumentWrapper> ingestDocumentWrappers, Consumer<List<IngestDocumentWrapper>> handler) {
+            subBatches.add(ingestDocumentWrappers);
+            handler.accept(ingestDocumentWrappers);
+        }
+
+        @Override
+        public IngestDocument execute(IngestDocument ingestDocument) throws Exception {
+            return ingestDocument;
+        }
+
+        @Override
+        public String getType() {
+            return null;
+        }
+
+        public static class DummyProcessorFactory extends Factory {
+
+            protected DummyProcessorFactory(String processorType) {
+                super(processorType);
+            }
+
+            public AbstractBatchingProcessor create(Map<String, Object> config) throws Exception {
+                final Map<String, org.opensearch.ingest.Processor.Factory> processorFactories = new HashMap<>();
+                return super.create(processorFactories, "tag", "description", config);
+            }
+
+            @Override
+            protected AbstractBatchingProcessor newProcessor(String tag, String description, int batchSize, Map<String, Object> config) {
+                return new DummyProcessor(batchSize);
+            }
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/ingest/IngestDocumentTests.java b/server/src/test/java/org/opensearch/ingest/IngestDocumentTests.java
index be035bc6ef7ea..8b78689acd6d2 100644
--- a/server/src/test/java/org/opensearch/ingest/IngestDocumentTests.java
+++ b/server/src/test/java/org/opensearch/ingest/IngestDocumentTests.java
@@ -62,6 +62,7 @@ public class IngestDocumentTests extends OpenSearchTestCase {
 
     private static final ZonedDateTime BOGUS_TIMESTAMP = ZonedDateTime.of(2016, 10, 23, 0, 0, 0, 0, ZoneOffset.UTC);
     private IngestDocument ingestDocument;
+    private int initialSourceAndMetadataSize;
 
     @Before
     public void setTestIngestDocument() {
@@ -70,7 +71,6 @@ public void setTestIngestDocument() {
         ingestMap.put("timestamp", BOGUS_TIMESTAMP);
         document.put("_ingest", ingestMap);
         document.put("foo", "bar");
-        document.put("int", 123);
         Map<String, Object> innerObject = new HashMap<>();
         innerObject.put("buzz", "hello world");
         innerObject.put("foo_null", null);
@@ -92,7 +92,17 @@ public void setTestIngestDocument() {
         list2.add("bar");
         list2.add("baz");
         document.put("list2", list2);
+        document.put("byte", (byte) 1);
+        document.put("short", (short) 2);
+        document.put("int", Integer.MAX_VALUE);
+        document.put("long", Long.MAX_VALUE);
+        document.put("float", 0.1f);
+        document.put("double", 0.1d);
+        document.put("char", 'a');
+        document.put("string", "A test string \uD83C\uDF89");
+        document.put("datetime", ZonedDateTime.parse("2007-12-03T10:15:30+01:00[Europe/Paris]"));
         ingestDocument = new IngestDocument("index", "id", null, null, null, document);
+        initialSourceAndMetadataSize = 16; // i.e. ingestDocument.getSourceAndMetadata().size()
     }
 
     public void testSelfReferencingSource() {
@@ -101,11 +111,18 @@ public void testSelfReferencingSource() {
         expectThrows(IllegalArgumentException.class, () -> IngestDocument.deepCopyMap(value));
     }
 
+    public void testCopy() {
+        final IngestDocument copy = new IngestDocument(ingestDocument);
+        assertThat(copy, equalTo(ingestDocument));
+        assertThat(copy.getSourceAndMetadata(), not(sameInstance(ingestDocument.getSourceAndMetadata())));
+        assertThat(copy.getIngestMetadata(), not(sameInstance(ingestDocument.getIngestMetadata())));
+    }
+
     public void testSimpleGetFieldValue() {
         assertThat(ingestDocument.getFieldValue("foo", String.class), equalTo("bar"));
-        assertThat(ingestDocument.getFieldValue("int", Integer.class), equalTo(123));
+        assertThat(ingestDocument.getFieldValue("int", Integer.class), equalTo(Integer.MAX_VALUE));
         assertThat(ingestDocument.getFieldValue("_source.foo", String.class), equalTo("bar"));
-        assertThat(ingestDocument.getFieldValue("_source.int", Integer.class), equalTo(123));
+        assertThat(ingestDocument.getFieldValue("_source.int", Integer.class), equalTo(Integer.MAX_VALUE));
         assertThat(ingestDocument.getFieldValue("_index", String.class), equalTo("index"));
         assertThat(ingestDocument.getFieldValue("_id", String.class), equalTo("id"));
         assertThat(
@@ -578,7 +595,7 @@ public void testAppendFieldValueConvertIntegerToList() {
         @SuppressWarnings("unchecked")
         List<Object> list = (List<Object>) object;
         assertThat(list.size(), equalTo(2));
-        assertThat(list.get(0), equalTo(123));
+        assertThat(list.get(0), equalTo(Integer.MAX_VALUE));
         assertThat(list.get(1), equalTo(456));
     }
 
@@ -589,7 +606,7 @@ public void testAppendFieldValuesConvertIntegerToList() {
         @SuppressWarnings("unchecked")
         List<Object> list = (List<Object>) object;
         assertThat(list.size(), equalTo(3));
-        assertThat(list.get(0), equalTo(123));
+        assertThat(list.get(0), equalTo(Integer.MAX_VALUE));
         assertThat(list.get(1), equalTo(456));
         assertThat(list.get(2), equalTo(789));
     }
@@ -812,23 +829,23 @@ public void testSetFieldValueEmptyName() {
 
     public void testRemoveField() {
         ingestDocument.removeField("foo");
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(7));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize - 1));
         assertThat(ingestDocument.getSourceAndMetadata().containsKey("foo"), equalTo(false));
         ingestDocument.removeField("_index");
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(6));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize - 2));
         assertThat(ingestDocument.getSourceAndMetadata().containsKey("_index"), equalTo(false));
         ingestDocument.removeField("_source.fizz");
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(5));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize - 3));
         assertThat(ingestDocument.getSourceAndMetadata().containsKey("fizz"), equalTo(false));
         assertThat(ingestDocument.getIngestMetadata().size(), equalTo(1));
         ingestDocument.removeField("_ingest.timestamp");
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(5));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize - 3));
         assertThat(ingestDocument.getIngestMetadata().size(), equalTo(0));
     }
 
     public void testRemoveInnerField() {
         ingestDocument.removeField("fizz.buzz");
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(8));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize));
         assertThat(ingestDocument.getSourceAndMetadata().get("fizz"), instanceOf(Map.class));
         @SuppressWarnings("unchecked")
         Map<String, Object> map = (Map<String, Object>) ingestDocument.getSourceAndMetadata().get("fizz");
@@ -837,17 +854,17 @@ public void testRemoveInnerField() {
 
         ingestDocument.removeField("fizz.foo_null");
         assertThat(map.size(), equalTo(2));
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(8));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize));
         assertThat(ingestDocument.getSourceAndMetadata().containsKey("fizz"), equalTo(true));
 
         ingestDocument.removeField("fizz.1");
         assertThat(map.size(), equalTo(1));
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(8));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize));
         assertThat(ingestDocument.getSourceAndMetadata().containsKey("fizz"), equalTo(true));
 
         ingestDocument.removeField("fizz.list");
         assertThat(map.size(), equalTo(0));
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(8));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize));
         assertThat(ingestDocument.getSourceAndMetadata().containsKey("fizz"), equalTo(true));
     }
 
@@ -883,7 +900,7 @@ public void testRemoveSourceObject() {
 
     public void testRemoveIngestObject() {
         ingestDocument.removeField("_ingest");
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(7));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize - 1));
         assertThat(ingestDocument.getSourceAndMetadata().containsKey("_ingest"), equalTo(false));
     }
 
@@ -905,7 +922,7 @@ public void testRemoveEmptyPathAfterStrippingOutPrefix() {
 
     public void testListRemoveField() {
         ingestDocument.removeField("list.0.field");
-        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(8));
+        assertThat(ingestDocument.getSourceAndMetadata().size(), equalTo(initialSourceAndMetadataSize));
         assertThat(ingestDocument.getSourceAndMetadata().containsKey("list"), equalTo(true));
         Object object = ingestDocument.getSourceAndMetadata().get("list");
         assertThat(object, instanceOf(List.class));
diff --git a/server/src/test/java/org/opensearch/ingest/IngestServiceTests.java b/server/src/test/java/org/opensearch/ingest/IngestServiceTests.java
index 6d216370bae9a..e1e1ea561284b 100644
--- a/server/src/test/java/org/opensearch/ingest/IngestServiceTests.java
+++ b/server/src/test/java/org/opensearch/ingest/IngestServiceTests.java
@@ -58,6 +58,7 @@
 import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.metrics.OperationStats;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.OpenSearchExecutors;
 import org.opensearch.common.xcontent.XContentType;
@@ -78,9 +79,11 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.threadpool.ThreadPool.Names;
+import org.hamcrest.MatcherAssert;
 import org.junit.Before;
 
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
@@ -88,6 +91,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
@@ -102,15 +106,16 @@
 
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.emptySet;
+import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
+import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.notNullValue;
 import static org.hamcrest.Matchers.nullValue;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.anyInt;
 import static org.mockito.Mockito.anyString;
 import static org.mockito.Mockito.argThat;
 import static org.mockito.Mockito.doAnswer;
@@ -147,8 +152,12 @@ public void setup() {
 
     public void testIngestPlugin() {
         Client client = mock(Client.class);
+        ClusterService clusterService = mock(ClusterService.class);
+        when(clusterService.getClusterSettings()).thenReturn(
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
         IngestService ingestService = new IngestService(
-            mock(ClusterService.class),
+            clusterService,
             threadPool,
             null,
             null,
@@ -182,8 +191,12 @@ public void testIngestPluginDuplicate() {
 
     public void testExecuteIndexPipelineDoesNotExist() {
         Client client = mock(Client.class);
+        ClusterService clusterService = mock(ClusterService.class);
+        when(clusterService.getClusterSettings()).thenReturn(
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
         IngestService ingestService = new IngestService(
-            mock(ClusterService.class),
+            clusterService,
             threadPool,
             null,
             null,
@@ -716,6 +729,124 @@ public void testValidate() throws Exception {
         ingestService.validatePipeline(ingestInfos, putRequest);
     }
 
+    public void testValidateProcessorCountForIngestPipelineThrowsException() {
+        IngestService ingestService = createWithProcessors();
+        PutPipelineRequest putRequest = new PutPipelineRequest(
+            "_id",
+            new BytesArray(
+                "{\"processors\": [{\"set\" : {\"field\": \"_field\", \"value\": \"_value\", \"tag\": \"tag1\"}},"
+                    + "{\"remove\" : {\"field\": \"_field\", \"tag\": \"tag2\"}}]}"
+            ),
+            MediaTypeRegistry.JSON
+        );
+
+        DiscoveryNode node1 = new DiscoveryNode("_node_id1", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
+        DiscoveryNode node2 = new DiscoveryNode("_node_id2", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
+        Map<DiscoveryNode, IngestInfo> ingestInfos = new HashMap<>();
+        ingestInfos.put(node1, new IngestInfo(Arrays.asList(new ProcessorInfo("set"), new ProcessorInfo("remove"))));
+        ingestInfos.put(node2, new IngestInfo(Arrays.asList(new ProcessorInfo("set"))));
+
+        Settings newSettings = Settings.builder().put("cluster.ingest.max_number_processors", 1).build();
+        ingestService.getClusterService().getClusterSettings().applySettings(newSettings);
+
+        expectThrows(IllegalStateException.class, () -> ingestService.validatePipeline(ingestInfos, putRequest));
+    }
+
+    public void testValidateProcessorCountForWithNestedOnFailureProcessorThrowsException() {
+        IngestService ingestService = createWithProcessors();
+        PutPipelineRequest putRequest = new PutPipelineRequest(
+            "_id",
+            new BytesArray(
+                "{\n"
+                    + "  \"processors\": [\n"
+                    + "    {\n"
+                    + "      \"set\": {\n"
+                    + "        \"field\": \"timestamp_field_1\",\n"
+                    + "        \"value\": \"value\",\n"
+                    + "        \"on_failure\": [\n"
+                    + "          {\n"
+                    + "            \"set\": {\n"
+                    + "              \"field\": \"ingest_error1\",\n"
+                    + "              \"value\": \"failed\",\n"
+                    + "              \"tag\": \"tagggg\",\n"
+                    + "              \"on_failure\": [\n"
+                    + "                {\n"
+                    + "                  \"set\": {\n"
+                    + "                    \"field\": \"ingest_error1\",\n"
+                    + "                    \"value\": \"failed\",\n"
+                    + "                    \"tag\": \"tagggg\",\n"
+                    + "                    \"on_failure\": [\n"
+                    + "                      {\n"
+                    + "                        \"set\": {\n"
+                    + "                          \"field\": \"ingest_error1\",\n"
+                    + "                          \"value\": \"failed\",\n"
+                    + "                          \"tag\": \"tagggg\",\n"
+                    + "                          \"on_failure\": [\n"
+                    + "                            {\n"
+                    + "                              \"set\": {\n"
+                    + "                                \"field\": \"ingest_error1\",\n"
+                    + "                                \"value\": \"failed\",\n"
+                    + "                                \"tag\": \"tagggg\"\n"
+                    + "                              }\n"
+                    + "                            },\n"
+                    + "                            {\n"
+                    + "                              \"set\": {\n"
+                    + "                                \"field\": \"ingest_error2\",\n"
+                    + "                                \"value\": \"failed\",\n"
+                    + "                                \"tag\": \"tagggg\"\n"
+                    + "                              }\n"
+                    + "                            }\n"
+                    + "                        ]\n"
+                    + "                        }\n"
+                    + "                      },\n"
+                    + "                      {\n"
+                    + "                        \"set\": {\n"
+                    + "                          \"field\": \"ingest_error2\",\n"
+                    + "                          \"value\": \"failed\",\n"
+                    + "                          \"tag\": \"tagggg\"\n"
+                    + "                        }\n"
+                    + "                      }\n"
+                    + "                    ]\n"
+                    + "                  }\n"
+                    + "                },\n"
+                    + "                {\n"
+                    + "                  \"set\": {\n"
+                    + "                    \"field\": \"ingest_error2\",\n"
+                    + "                    \"value\": \"failed\",\n"
+                    + "                    \"tag\": \"tagggg\"\n"
+                    + "                  }\n"
+                    + "                }\n"
+                    + "            ]\n"
+                    + "            }\n"
+                    + "          },\n"
+                    + "          {\n"
+                    + "            \"set\": {\n"
+                    + "              \"field\": \"ingest_error2\",\n"
+                    + "              \"value\": \"failed\",\n"
+                    + "              \"tag\": \"tagggg\"\n"
+                    + "            }\n"
+                    + "          }\n"
+                    + "        ]\n"
+                    + "      }\n"
+                    + "    }\n"
+                    + "  ]\n"
+                    + "}"
+            ),
+            MediaTypeRegistry.JSON
+        );
+
+        DiscoveryNode node1 = new DiscoveryNode("_node_id1", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
+        DiscoveryNode node2 = new DiscoveryNode("_node_id2", buildNewFakeTransportAddress(), emptyMap(), emptySet(), Version.CURRENT);
+        Map<DiscoveryNode, IngestInfo> ingestInfos = new HashMap<>();
+        ingestInfos.put(node1, new IngestInfo(Arrays.asList(new ProcessorInfo("set"), new ProcessorInfo("remove"))));
+        ingestInfos.put(node2, new IngestInfo(Arrays.asList(new ProcessorInfo("set"))));
+
+        Settings newSettings = Settings.builder().put("cluster.ingest.max_number_processors", 7).build();
+        ingestService.getClusterService().getClusterSettings().applySettings(newSettings);
+
+        expectThrows(IllegalStateException.class, () -> ingestService.validatePipeline(ingestInfos, putRequest));
+    }
+
     public void testExecuteIndexPipelineExistsButFailedParsing() {
         IngestService ingestService = createWithProcessors(
             Collections.singletonMap("mock", (factories, tag, description, config) -> new AbstractProcessor("mock", "description") {
@@ -1104,27 +1235,23 @@ public void testExecuteFailureWithNestedOnFailure() throws Exception {
         verify(completionHandler, times(1)).accept(Thread.currentThread(), null);
     }
 
-    public void testBulkRequestExecutionWithFailures() throws Exception {
+    public void testBulkRequestExecutionWithFailures() {
         BulkRequest bulkRequest = new BulkRequest();
         String pipelineId = "_id";
 
-        int numRequest = scaledRandomIntBetween(8, 64);
-        int numIndexRequests = 0;
-        for (int i = 0; i < numRequest; i++) {
-            DocWriteRequest request;
+        int numIndexRequests = scaledRandomIntBetween(4, 32);
+        for (int i = 0; i < numIndexRequests; i++) {
+            IndexRequest indexRequest = new IndexRequest("_index").id("_id").setPipeline(pipelineId).setFinalPipeline("_none");
+            indexRequest.source(Requests.INDEX_CONTENT_TYPE, "field1", "value1");
+            bulkRequest.add(indexRequest);
+        }
+        int numOtherRequests = scaledRandomIntBetween(4, 32);
+        for (int i = 0; i < numOtherRequests; i++) {
             if (randomBoolean()) {
-                if (randomBoolean()) {
-                    request = new DeleteRequest("_index", "_id");
-                } else {
-                    request = new UpdateRequest("_index", "_id");
-                }
+                bulkRequest.add(new DeleteRequest("_index", "_id"));
             } else {
-                IndexRequest indexRequest = new IndexRequest("_index").id("_id").setPipeline(pipelineId).setFinalPipeline("_none");
-                indexRequest.source(Requests.INDEX_CONTENT_TYPE, "field1", "value1");
-                request = indexRequest;
-                numIndexRequests++;
+                bulkRequest.add(new UpdateRequest("_index", "_id"));
             }
-            bulkRequest.add(request);
         }
 
         CompoundProcessor processor = mock(CompoundProcessor.class);
@@ -1132,10 +1259,14 @@ public void testBulkRequestExecutionWithFailures() throws Exception {
         Exception error = new RuntimeException();
         doAnswer(args -> {
             @SuppressWarnings("unchecked")
-            BiConsumer<IngestDocument, Exception> handler = (BiConsumer) args.getArguments()[1];
-            handler.accept(null, error);
+            List<IngestDocumentWrapper> ingestDocumentWrappers = (List) args.getArguments()[0];
+            Consumer<List<IngestDocumentWrapper>> handler = (Consumer) args.getArguments()[1];
+            for (IngestDocumentWrapper wrapper : ingestDocumentWrappers) {
+                wrapper.update(wrapper.getIngestDocument(), error);
+            }
+            handler.accept(ingestDocumentWrappers);
             return null;
-        }).when(processor).execute(any(), any());
+        }).when(processor).batchExecute(any(), any());
         IngestService ingestService = createWithProcessors(
             Collections.singletonMap("mock", (factories, tag, description, config) -> processor)
         );
@@ -1149,23 +1280,22 @@ public void testBulkRequestExecutionWithFailures() throws Exception {
         clusterState = IngestService.innerPut(putRequest, clusterState);
         ingestService.applyClusterState(new ClusterChangedEvent("", clusterState, previousClusterState));
 
-        @SuppressWarnings("unchecked")
-        BiConsumer<Integer, Exception> requestItemErrorHandler = mock(BiConsumer.class);
-        @SuppressWarnings("unchecked")
-        final BiConsumer<Thread, Exception> completionHandler = mock(BiConsumer.class);
+        final Map<Integer, Exception> errorHandler = new HashMap<>();
+        final Map<Thread, Exception> completionHandler = new HashMap<>();
         ingestService.executeBulkRequest(
-            numRequest,
+            numIndexRequests + numOtherRequests,
             bulkRequest.requests(),
-            requestItemErrorHandler,
-            completionHandler,
+            errorHandler::put,
+            completionHandler::put,
             indexReq -> {},
             Names.WRITE,
             bulkRequest
         );
 
-        verify(requestItemErrorHandler, times(numIndexRequests)).accept(anyInt(), argThat(o -> o.getCause().equals(error)));
+        MatcherAssert.assertThat(errorHandler.entrySet(), hasSize(numIndexRequests));
+        errorHandler.values().forEach(e -> assertEquals(e.getCause(), error));
 
-        verify(completionHandler, times(1)).accept(Thread.currentThread(), null);
+        MatcherAssert.assertThat(completionHandler.keySet(), contains(Thread.currentThread()));
     }
 
     public void testBulkRequestExecution() throws Exception {
@@ -1190,10 +1320,11 @@ public void testBulkRequestExecution() throws Exception {
         when(processor.getTag()).thenReturn("mockTag");
         doAnswer(args -> {
             @SuppressWarnings("unchecked")
-            BiConsumer<IngestDocument, Exception> handler = (BiConsumer) args.getArguments()[1];
-            handler.accept(RandomDocumentPicks.randomIngestDocument(random()), null);
+            List<IngestDocumentWrapper> ingestDocumentWrappers = (List) args.getArguments()[0];
+            Consumer<List<IngestDocumentWrapper>> handler = (Consumer) args.getArguments()[1];
+            handler.accept(ingestDocumentWrappers);
             return null;
-        }).when(processor).execute(any(), any());
+        }).when(processor).batchExecute(any(), any());
         Map<String, Processor.Factory> map = new HashMap<>(2);
         map.put("mock", (factories, tag, description, config) -> processor);
 
@@ -1502,8 +1633,12 @@ public Map<String, Processor.Factory> getProcessors(Processor.Parameters paramet
 
         // Create ingest service:
         Client client = mock(Client.class);
+        ClusterService clusterService = mock(ClusterService.class);
+        when(clusterService.getClusterSettings()).thenReturn(
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
         IngestService ingestService = new IngestService(
-            mock(ClusterService.class),
+            clusterService,
             threadPool,
             null,
             null,
@@ -1603,6 +1738,13 @@ public void testResolveRequiredOrDefaultPipelineDefaultPipeline() {
         assertThat(result, is(true));
         assertThat(indexRequest.isPipelineResolved(), is(true));
         assertThat(indexRequest.getPipeline(), equalTo("default-pipeline"));
+
+        // index name matches with ITMD for bulk upsert
+        UpdateRequest updateRequest = new UpdateRequest("idx", "id1").upsert(emptyMap()).script(mockScript("1"));
+        result = IngestService.resolvePipelines(updateRequest, TransportBulkAction.getIndexWriteRequest(updateRequest), metadata);
+        assertThat(result, is(true));
+        assertThat(updateRequest.upsertRequest().isPipelineResolved(), is(true));
+        assertThat(updateRequest.upsertRequest().getPipeline(), equalTo("default-pipeline"));
     }
 
     public void testResolveFinalPipeline() {
@@ -1640,6 +1782,13 @@ public void testResolveFinalPipeline() {
         assertThat(indexRequest.isPipelineResolved(), is(true));
         assertThat(indexRequest.getPipeline(), equalTo("_none"));
         assertThat(indexRequest.getFinalPipeline(), equalTo("final-pipeline"));
+
+        // index name matches with ITMD for bulk upsert:
+        UpdateRequest updateRequest = new UpdateRequest("idx", "id1").upsert(emptyMap()).script(mockScript("1"));
+        result = IngestService.resolvePipelines(updateRequest, TransportBulkAction.getIndexWriteRequest(updateRequest), metadata);
+        assertThat(result, is(true));
+        assertThat(updateRequest.upsertRequest().isPipelineResolved(), is(true));
+        assertThat(updateRequest.upsertRequest().getFinalPipeline(), equalTo("final-pipeline"));
     }
 
     public void testResolveRequestOrDefaultPipelineAndFinalPipeline() {
@@ -1894,7 +2043,7 @@ public void testExecuteBulkRequestInBatchWithException() {
         verify(mockCompoundProcessor, never()).execute(any(), any());
     }
 
-    public void testExecuteBulkRequestInBatchWithExceptionInCallback() {
+    public void testExecuteBulkRequestInBatchWithExceptionAndDropInCallback() {
         CompoundProcessor mockCompoundProcessor = mockCompoundProcessor();
         IngestService ingestService = createWithProcessors(
             Collections.singletonMap("mock", (factories, tag, description, config) -> mockCompoundProcessor)
@@ -1906,11 +2055,14 @@ public void testExecuteBulkRequestInBatchWithExceptionInCallback() {
         bulkRequest.add(indexRequest1);
         IndexRequest indexRequest2 = new IndexRequest("_index").id("_id2").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
         bulkRequest.add(indexRequest2);
-        bulkRequest.batchSize(2);
+        IndexRequest indexRequest3 = new IndexRequest("_index").id("_id3").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest3);
+        bulkRequest.batchSize(3);
 
         List<IngestDocumentWrapper> results = Arrays.asList(
             new IngestDocumentWrapper(0, IngestService.toIngestDocument(indexRequest1), null),
-            new IngestDocumentWrapper(1, null, new RuntimeException())
+            new IngestDocumentWrapper(1, null, new RuntimeException()),
+            new IngestDocumentWrapper(2, null, null)
         );
         doAnswer(args -> {
             @SuppressWarnings("unchecked")
@@ -1919,25 +2071,97 @@ public void testExecuteBulkRequestInBatchWithExceptionInCallback() {
             return null;
         }).when(mockCompoundProcessor).batchExecute(any(), any());
 
+        final Map<Integer, Exception> failureHandler = new HashMap<>();
+        final Map<Thread, Exception> completionHandler = new HashMap<>();
+        final List<Integer> dropHandler = new ArrayList<>();
+        ingestService.executeBulkRequest(
+            3,
+            bulkRequest.requests(),
+            failureHandler::put,
+            completionHandler::put,
+            dropHandler::add,
+            Names.WRITE,
+            bulkRequest
+        );
+        assertEquals(Set.of(1), failureHandler.keySet());
+        assertEquals(List.of(2), dropHandler);
+        assertEquals(Set.of(Thread.currentThread()), completionHandler.keySet());
+        verify(mockCompoundProcessor, times(1)).batchExecute(any(), any());
+        verify(mockCompoundProcessor, never()).execute(any(), any());
+    }
+
+    public void testExecuteBulkRequestInBatchWithDefaultBatchSize() {
+        CompoundProcessor mockCompoundProcessor = mockCompoundProcessor();
+        IngestService ingestService = createWithProcessors(
+            Collections.singletonMap("mock", (factories, tag, description, config) -> mockCompoundProcessor)
+        );
+        createPipeline("_id", ingestService);
+        BulkRequest bulkRequest = new BulkRequest();
+        IndexRequest indexRequest1 = new IndexRequest("_index").id("_id1").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest1);
+        IndexRequest indexRequest2 = new IndexRequest("_index").id("_id2").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest2);
+        IndexRequest indexRequest3 = new IndexRequest("_index").id("_id3").source(emptyMap()).setPipeline("_none").setFinalPipeline("_id");
+        bulkRequest.add(indexRequest3);
+        IndexRequest indexRequest4 = new IndexRequest("_index").id("_id4").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest4);
         @SuppressWarnings("unchecked")
-        final BiConsumer<Integer, Exception> failureHandler = mock(BiConsumer.class);
-        @SuppressWarnings("unchecked")
-        final BiConsumer<Thread, Exception> completionHandler = mock(BiConsumer.class);
+        final Map<Integer, Exception> failureHandler = new HashMap<>();
+        final Map<Thread, Exception> completionHandler = new HashMap<>();
+        final List<Integer> dropHandler = new ArrayList<>();
         ingestService.executeBulkRequest(
-            2,
+            4,
             bulkRequest.requests(),
-            failureHandler,
-            completionHandler,
-            indexReq -> {},
+            failureHandler::put,
+            completionHandler::put,
+            dropHandler::add,
             Names.WRITE,
             bulkRequest
         );
-        verify(failureHandler, times(1)).accept(any(), any());
-        verify(completionHandler, times(1)).accept(Thread.currentThread(), null);
+        assertTrue(failureHandler.isEmpty());
+        assertTrue(dropHandler.isEmpty());
+        assertEquals(1, completionHandler.size());
+        assertNull(completionHandler.get(Thread.currentThread()));
         verify(mockCompoundProcessor, times(1)).batchExecute(any(), any());
         verify(mockCompoundProcessor, never()).execute(any(), any());
     }
 
+    public void testExecuteEmptyPipelineInBatch() throws Exception {
+        IngestService ingestService = createWithProcessors(emptyMap());
+        PutPipelineRequest putRequest = new PutPipelineRequest(
+            "_id",
+            new BytesArray("{\"processors\": [], \"description\": \"_description\"}"),
+            MediaTypeRegistry.JSON
+        );
+        ClusterState clusterState = ClusterState.builder(new ClusterName("_name")).build(); // Start empty
+        ClusterState previousClusterState = clusterState;
+        clusterState = IngestService.innerPut(putRequest, clusterState);
+        ingestService.applyClusterState(new ClusterChangedEvent("", clusterState, previousClusterState));
+        BulkRequest bulkRequest = new BulkRequest();
+        IndexRequest indexRequest1 = new IndexRequest("_index").id("_id1").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest1);
+        IndexRequest indexRequest2 = new IndexRequest("_index").id("_id2").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest2);
+        IndexRequest indexRequest3 = new IndexRequest("_index").id("_id3").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest3);
+        IndexRequest indexRequest4 = new IndexRequest("_index").id("_id4").source(emptyMap()).setPipeline("_id").setFinalPipeline("_none");
+        bulkRequest.add(indexRequest4);
+        bulkRequest.batchSize(4);
+        final Map<Integer, Exception> failureHandler = new HashMap<>();
+        final Map<Thread, Exception> completionHandler = new HashMap<>();
+        ingestService.executeBulkRequest(
+            4,
+            bulkRequest.requests(),
+            failureHandler::put,
+            completionHandler::put,
+            indexReq -> {},
+            Names.WRITE,
+            bulkRequest
+        );
+        assertTrue(failureHandler.isEmpty());
+        assertEquals(Set.of(Thread.currentThread()), completionHandler.keySet());
+    }
+
     public void testPrepareBatches_same_index_pipeline() {
         IngestService.IndexRequestWrapper wrapper1 = createIndexRequestWrapper("index1", Collections.singletonList("p1"));
         IngestService.IndexRequestWrapper wrapper2 = createIndexRequestWrapper("index1", Collections.singletonList("p1"));
@@ -1965,6 +2189,18 @@ public void testPrepareBatches_different_index_pipeline() {
         assertEquals(4, batches.size());
     }
 
+    public void testUpdateMaxIngestProcessorCountSetting() {
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.builder().build(), ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+
+        // verify defaults
+        assertEquals(Integer.MAX_VALUE, clusterSettings.get(IngestService.MAX_NUMBER_OF_INGEST_PROCESSORS).intValue());
+
+        // verify update max processor
+        Settings newSettings = Settings.builder().put("cluster.ingest.max_number_processors", 3).build();
+        clusterSettings.applySettings(newSettings);
+        assertEquals(3, clusterSettings.get(IngestService.MAX_NUMBER_OF_INGEST_PROCESSORS).intValue());
+    }
+
     private IngestService.IndexRequestWrapper createIndexRequestWrapper(String index, List<String> pipelines) {
         IndexRequest indexRequest = new IndexRequest(index);
         return new IngestService.IndexRequestWrapper(0, indexRequest, pipelines, true);
@@ -2000,7 +2236,11 @@ private static IngestService createWithProcessors(Map<String, Processor.Factory>
         ExecutorService executorService = OpenSearchExecutors.newDirectExecutorService();
         when(threadPool.generic()).thenReturn(executorService);
         when(threadPool.executor(anyString())).thenReturn(executorService);
-        return new IngestService(mock(ClusterService.class), threadPool, null, null, null, Collections.singletonList(new IngestPlugin() {
+        ClusterService clusterService = mock(ClusterService.class);
+        when(clusterService.getClusterSettings()).thenReturn(
+            new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)
+        );
+        return new IngestService(clusterService, threadPool, null, null, null, Collections.singletonList(new IngestPlugin() {
             @Override
             public Map<String, Processor.Factory> getProcessors(final Processor.Parameters parameters) {
                 return processors;
diff --git a/server/src/test/java/org/opensearch/monitor/fs/FsProbeTests.java b/server/src/test/java/org/opensearch/monitor/fs/FsProbeTests.java
index 59a888c665be7..e2e09d5ce63fe 100644
--- a/server/src/test/java/org/opensearch/monitor/fs/FsProbeTests.java
+++ b/server/src/test/java/org/opensearch/monitor/fs/FsProbeTests.java
@@ -58,6 +58,7 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
+import static org.opensearch.monitor.fs.FsProbe.adjustForHugeFilesystems;
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.Matchers.emptyOrNullString;
 import static org.hamcrest.Matchers.greaterThan;
@@ -162,6 +163,46 @@ public void testFsCacheInfo() throws IOException {
         }
     }
 
+    public void testFsInfoWhenFileCacheOccupied() throws IOException {
+        Settings settings = Settings.builder().putList("node.roles", "search", "data").build();
+        try (NodeEnvironment env = newNodeEnvironment(settings)) {
+            // Use the total space as reserved space to simulate the situation where the cache space is occupied
+            final long totalSpace = adjustForHugeFilesystems(env.fileCacheNodePath().fileStore.getTotalSpace());
+            ByteSizeValue gbByteSizeValue = new ByteSizeValue(totalSpace, ByteSizeUnit.BYTES);
+            env.fileCacheNodePath().fileCacheReservedSize = gbByteSizeValue;
+            FileCache fileCache = FileCacheFactory.createConcurrentLRUFileCache(
+                gbByteSizeValue.getBytes(),
+                16,
+                new NoopCircuitBreaker(CircuitBreaker.REQUEST)
+            );
+
+            FsProbe probe = new FsProbe(env, fileCache);
+            FsInfo stats = probe.stats(null);
+            assertNotNull(stats);
+            assertTrue(stats.getTimestamp() > 0L);
+            FsInfo.Path total = stats.getTotal();
+            assertNotNull(total);
+            assertTrue(total.total > 0L);
+            assertTrue(total.free > 0L);
+            assertTrue(total.fileCacheReserved > 0L);
+
+            for (FsInfo.Path path : stats) {
+                assertNotNull(path);
+                assertFalse(path.getPath().isEmpty());
+                assertFalse(path.getMount().isEmpty());
+                assertFalse(path.getType().isEmpty());
+                assertTrue(path.total > 0L);
+                assertTrue(path.free > 0L);
+
+                if (path.fileCacheReserved > 0L) {
+                    assertEquals(0L, path.available);
+                } else {
+                    assertTrue(path.available > 0L);
+                }
+            }
+        }
+    }
+
     public void testFsInfoOverflow() throws Exception {
         final FsInfo.Path pathStats = new FsInfo.Path(
             "/foo/bar",
diff --git a/server/src/test/java/org/opensearch/node/NodeTests.java b/server/src/test/java/org/opensearch/node/NodeTests.java
index f44cc352cd330..0093091f61a1c 100644
--- a/server/src/test/java/org/opensearch/node/NodeTests.java
+++ b/server/src/test/java/org/opensearch/node/NodeTests.java
@@ -380,7 +380,7 @@ public void testCreateWithFileCache() throws Exception {
         List<Class<? extends Plugin>> plugins = basePlugins();
         ByteSizeValue cacheSize = new ByteSizeValue(16, ByteSizeUnit.GB);
         Settings searchRoleSettingsWithConfig = baseSettings().put(searchRoleSettings)
-            .put(Node.NODE_SEARCH_CACHE_SIZE_SETTING.getKey(), cacheSize)
+            .put(Node.NODE_SEARCH_CACHE_SIZE_SETTING.getKey(), cacheSize.toString())
             .build();
         Settings onlySearchRoleSettings = Settings.builder()
             .put(searchRoleSettingsWithConfig)
diff --git a/server/src/test/java/org/opensearch/node/RemoteStoreNodeAttributeTests.java b/server/src/test/java/org/opensearch/node/RemoteStoreNodeAttributeTests.java
index c4ba271d27ae9..de7f8977686a7 100644
--- a/server/src/test/java/org/opensearch/node/RemoteStoreNodeAttributeTests.java
+++ b/server/src/test/java/org/opensearch/node/RemoteStoreNodeAttributeTests.java
@@ -19,6 +19,7 @@
 
 import java.net.InetAddress;
 import java.net.UnknownHostException;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 
@@ -28,6 +29,7 @@
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_CRYPTO_SETTINGS_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
 
@@ -148,4 +150,77 @@ public void testNoCryptoMetadata() throws UnknownHostException {
         RepositoryMetadata repositoryMetadata = remoteStoreNodeAttribute.getRepositoriesMetadata().repositories().get(0);
         assertNull(repositoryMetadata.cryptoMetadata());
     }
+
+    public void testEqualsWithRepoSkip() throws UnknownHostException {
+        String repoName = "remote-store-A";
+        String repoTypeSettingKey = String.format(Locale.ROOT, REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT, repoName);
+        String repoSettingsKey = String.format(Locale.ROOT, REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX, repoName);
+        Map<String, String> attr = Map.of(
+            REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            repoName,
+            REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            repoName,
+            REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            repoName,
+            repoTypeSettingKey,
+            "s3",
+            repoSettingsKey,
+            "abc",
+            repoSettingsKey + "base_path",
+            "xyz"
+        );
+        DiscoveryNode node = new DiscoveryNode(
+            "C",
+            new TransportAddress(InetAddress.getByName("localhost"), 9876),
+            attr,
+            emptySet(),
+            Version.CURRENT
+        );
+
+        RemoteStoreNodeAttribute remoteStoreNodeAttribute = new RemoteStoreNodeAttribute(node);
+
+        String routingTableRepoName = "remote-store-B";
+        String routingTableRepoTypeSettingKey = String.format(
+            Locale.ROOT,
+            REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+            routingTableRepoName
+        );
+        String routingTableRepoSettingsKey = String.format(
+            Locale.ROOT,
+            REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+            routingTableRepoName
+        );
+
+        Map<String, String> attr2 = Map.of(
+            REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            repoName,
+            REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            repoName,
+            REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            repoName,
+            REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY,
+            routingTableRepoName,
+            repoTypeSettingKey,
+            "s3",
+            repoSettingsKey,
+            "abc",
+            repoSettingsKey + "base_path",
+            "xyz",
+            routingTableRepoTypeSettingKey,
+            "s3",
+            routingTableRepoSettingsKey,
+            "xyz"
+        );
+        DiscoveryNode node2 = new DiscoveryNode(
+            "C",
+            new TransportAddress(InetAddress.getByName("localhost"), 9876),
+            attr2,
+            emptySet(),
+            Version.CURRENT
+        );
+        RemoteStoreNodeAttribute remoteStoreNodeAttribute2 = new RemoteStoreNodeAttribute(node2);
+
+        assertFalse(remoteStoreNodeAttribute.equalsWithRepoSkip(remoteStoreNodeAttribute2, List.of()));
+        assertTrue(remoteStoreNodeAttribute.equalsWithRepoSkip(remoteStoreNodeAttribute2, List.of(routingTableRepoName)));
+    }
 }
diff --git a/server/src/test/java/org/opensearch/node/ResponseCollectorServiceTests.java b/server/src/test/java/org/opensearch/node/ResponseCollectorServiceTests.java
index 7ca1f1e864b99..7567224f16ac3 100644
--- a/server/src/test/java/org/opensearch/node/ResponseCollectorServiceTests.java
+++ b/server/src/test/java/org/opensearch/node/ResponseCollectorServiceTests.java
@@ -41,6 +41,7 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.common.transport.TransportAddress;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -63,7 +64,7 @@ public class ResponseCollectorServiceTests extends OpenSearchTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadpool = new TestThreadPool("response_collector_tests");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadpool
diff --git a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionControlServiceTests.java b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionControlServiceTests.java
index 4f615290f1805..fbb083a3ae419 100644
--- a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionControlServiceTests.java
+++ b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionControlServiceTests.java
@@ -17,6 +17,7 @@
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlActionType;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
 import org.opensearch.ratelimitting.admissioncontrol.settings.CpuBasedAdmissionControllerSettings;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -33,7 +34,7 @@ public class AdmissionControlServiceTests extends OpenSearchTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("admission_controller_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionControlSettingsTests.java b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionControlSettingsTests.java
index c11ee1cc608f6..fbadcad804b31 100644
--- a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionControlSettingsTests.java
+++ b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/AdmissionControlSettingsTests.java
@@ -13,6 +13,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -28,7 +29,7 @@ public class AdmissionControlSettingsTests extends OpenSearchTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("admission_controller_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/controllers/CpuBasedAdmissionControllerTests.java b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/controllers/CpuBasedAdmissionControllerTests.java
index e72c0cd58ed64..f2cb45a033460 100644
--- a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/controllers/CpuBasedAdmissionControllerTests.java
+++ b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/controllers/CpuBasedAdmissionControllerTests.java
@@ -15,6 +15,7 @@
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlActionType;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
 import org.opensearch.ratelimitting.admissioncontrol.settings.CpuBasedAdmissionControllerSettings;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -31,7 +32,7 @@ public class CpuBasedAdmissionControllerTests extends OpenSearchTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("admission_controller_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/controllers/IoBasedAdmissionControllerTests.java b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/controllers/IoBasedAdmissionControllerTests.java
index c5a2208f49ce6..54cb438e14ce6 100644
--- a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/controllers/IoBasedAdmissionControllerTests.java
+++ b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/controllers/IoBasedAdmissionControllerTests.java
@@ -15,6 +15,7 @@
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlActionType;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
 import org.opensearch.ratelimitting.admissioncontrol.settings.IoBasedAdmissionControllerSettings;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -31,7 +32,7 @@ public class IoBasedAdmissionControllerTests extends OpenSearchTestCase {
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("admission_controller_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/settings/CPUBasedAdmissionControllerSettingsTests.java b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/settings/CPUBasedAdmissionControllerSettingsTests.java
index 6836ecb3d615f..f5686f33e7f50 100644
--- a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/settings/CPUBasedAdmissionControllerSettingsTests.java
+++ b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/settings/CPUBasedAdmissionControllerSettingsTests.java
@@ -13,6 +13,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -28,7 +29,7 @@ public class CPUBasedAdmissionControllerSettingsTests extends OpenSearchTestCase
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("admission_controller_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/settings/IoBasedAdmissionControllerSettingsTests.java b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/settings/IoBasedAdmissionControllerSettingsTests.java
index c462f9700264d..3f157531f6c9a 100644
--- a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/settings/IoBasedAdmissionControllerSettingsTests.java
+++ b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/settings/IoBasedAdmissionControllerSettingsTests.java
@@ -21,6 +21,7 @@
 import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -36,7 +37,7 @@ public class IoBasedAdmissionControllerSettingsTests extends OpenSearchTestCase
     public void setUp() throws Exception {
         super.setUp();
         threadPool = new TestThreadPool("io_based_admission_controller_settings_test");
-        clusterService = new ClusterService(
+        clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/stats/AdmissionControlStatsTests.java b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/stats/AdmissionControlStatsTests.java
index 7b4db5f787d6e..da57ef9f06a1a 100644
--- a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/stats/AdmissionControlStatsTests.java
+++ b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/stats/AdmissionControlStatsTests.java
@@ -20,6 +20,7 @@
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlActionType;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
 import org.opensearch.ratelimitting.admissioncontrol.settings.CpuBasedAdmissionControllerSettings;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -46,7 +47,7 @@ public void setUp() throws Exception {
             )
             .build();
         threadPool = new TestThreadPool("admission_controller_settings_test");
-        ClusterService clusterService = new ClusterService(
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/stats/AdmissionControllerStatsTests.java b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/stats/AdmissionControllerStatsTests.java
index fe0399e79a5f4..0ef9aa61bb827 100644
--- a/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/stats/AdmissionControllerStatsTests.java
+++ b/server/src/test/java/org/opensearch/ratelimitting/admissioncontrol/stats/AdmissionControllerStatsTests.java
@@ -20,6 +20,7 @@
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlActionType;
 import org.opensearch.ratelimitting.admissioncontrol.enums.AdmissionControlMode;
 import org.opensearch.ratelimitting.admissioncontrol.settings.CpuBasedAdmissionControllerSettings;
+import org.opensearch.test.ClusterServiceUtils;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
@@ -43,7 +44,7 @@ public void setUp() throws Exception {
             )
             .build();
         threadPool = new TestThreadPool("admission_controller_settings_test");
-        ClusterService clusterService = new ClusterService(
+        ClusterService clusterService = ClusterServiceUtils.createClusterService(
             Settings.EMPTY,
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
             threadPool
diff --git a/server/src/test/java/org/opensearch/repositories/IndexIdTests.java b/server/src/test/java/org/opensearch/repositories/IndexIdTests.java
index 2b927b3b40115..bcd75f9a47ad8 100644
--- a/server/src/test/java/org/opensearch/repositories/IndexIdTests.java
+++ b/server/src/test/java/org/opensearch/repositories/IndexIdTests.java
@@ -32,6 +32,7 @@
 
 package org.opensearch.repositories;
 
+import org.opensearch.Version;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.io.stream.BytesStreamOutput;
 import org.opensearch.common.xcontent.json.JsonXContent;
@@ -39,6 +40,7 @@
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.remote.RemoteStoreEnums;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
@@ -52,51 +54,84 @@ public void testEqualsAndHashCode() {
         // assert equals and hashcode
         String name = randomAlphaOfLength(8);
         String id = UUIDs.randomBase64UUID();
-        IndexId indexId1 = new IndexId(name, id);
-        IndexId indexId2 = new IndexId(name, id);
+        int shardPathType = randomIntBetween(0, 2);
+        IndexId indexId1 = new IndexId(name, id, shardPathType);
+        IndexId indexId2 = new IndexId(name, id, shardPathType);
         assertEquals(indexId1, indexId2);
         assertEquals(indexId1.hashCode(), indexId2.hashCode());
         // assert equals when using index name for id
         id = name;
-        indexId1 = new IndexId(name, id);
-        indexId2 = new IndexId(name, id);
+        indexId1 = new IndexId(name, id, shardPathType);
+        indexId2 = new IndexId(name, id, shardPathType);
         assertEquals(indexId1, indexId2);
         assertEquals(indexId1.hashCode(), indexId2.hashCode());
-        // assert not equals when name or id differ
-        indexId2 = new IndexId(randomAlphaOfLength(8), id);
+        // assert not equals when name, id, or shardPathType differ
+        indexId2 = new IndexId(randomAlphaOfLength(8), id, shardPathType);
         assertNotEquals(indexId1, indexId2);
         assertNotEquals(indexId1.hashCode(), indexId2.hashCode());
-        indexId2 = new IndexId(name, UUIDs.randomBase64UUID());
+        indexId2 = new IndexId(name, UUIDs.randomBase64UUID(), shardPathType);
         assertNotEquals(indexId1, indexId2);
         assertNotEquals(indexId1.hashCode(), indexId2.hashCode());
+        int newShardPathType = randomIntBetween(0, 2);
+        indexId2 = new IndexId(name, id, newShardPathType);
+        if (shardPathType == newShardPathType) {
+            assertEquals(indexId1, indexId2);
+            assertEquals(indexId1.hashCode(), indexId2.hashCode());
+        } else {
+            assertNotEquals(indexId1, indexId2);
+            assertNotEquals(indexId1.hashCode(), indexId2.hashCode());
+        }
     }
 
     public void testSerialization() throws IOException {
-        IndexId indexId = new IndexId(randomAlphaOfLength(8), UUIDs.randomBase64UUID());
+        IndexId indexId = new IndexId(randomAlphaOfLength(8), UUIDs.randomBase64UUID(), randomIntBetween(0, 2));
         BytesStreamOutput out = new BytesStreamOutput();
+        out.setVersion(Version.V_2_17_0);
         indexId.writeTo(out);
         assertEquals(indexId, new IndexId(out.bytes().streamInput()));
     }
 
     public void testXContent() throws IOException {
-        IndexId indexId = new IndexId(randomAlphaOfLength(8), UUIDs.randomBase64UUID());
+        String name = randomAlphaOfLength(8);
+        String id = UUIDs.randomBase64UUID();
+        int shardPathType = randomIntBetween(0, 2);
+        IndexId indexId = new IndexId(name, id, shardPathType);
         XContentBuilder builder = JsonXContent.contentBuilder();
         indexId.toXContent(builder, ToXContent.EMPTY_PARAMS);
         XContentParser parser = createParser(JsonXContent.jsonXContent, BytesReference.bytes(builder));
         assertEquals(XContentParser.Token.START_OBJECT, parser.nextToken());
-        String name = null;
-        String id = null;
+        String parsedName = null;
+        String parsedId = null;
+        int parsedShardPathType = -1;
         while (parser.nextToken() != XContentParser.Token.END_OBJECT) {
             final String currentFieldName = parser.currentName();
             parser.nextToken();
-            if (currentFieldName.equals(IndexId.NAME)) {
-                name = parser.text();
-            } else if (currentFieldName.equals(IndexId.ID)) {
-                id = parser.text();
+            switch (currentFieldName) {
+                case IndexId.NAME:
+                    parsedName = parser.text();
+                    break;
+                case IndexId.ID:
+                    parsedId = parser.text();
+                    break;
+                case IndexId.SHARD_PATH_TYPE:
+                    parsedShardPathType = parser.intValue();
+                    break;
             }
         }
-        assertNotNull(name);
-        assertNotNull(id);
-        assertEquals(indexId, new IndexId(name, id));
+        parser.close();
+        assertNotNull(parsedName);
+        assertNotNull(parsedId);
+        assertNotEquals(-1, parsedShardPathType);
+        assertEquals(name, parsedName);
+        assertEquals(id, parsedId);
+        assertEquals(shardPathType, parsedShardPathType);
+    }
+
+    public void testDefaultShardPathType() {
+        String name = randomAlphaOfLength(8);
+        String id = UUIDs.randomBase64UUID();
+        IndexId indexId = new IndexId(name, id);
+        assertEquals(IndexId.DEFAULT_SHARD_PATH_TYPE, indexId.getShardPathType());
+        assertEquals(RemoteStoreEnums.PathType.FIXED.getCode(), IndexId.DEFAULT_SHARD_PATH_TYPE);
     }
 }
diff --git a/server/src/test/java/org/opensearch/repositories/RepositoriesServiceTests.java b/server/src/test/java/org/opensearch/repositories/RepositoriesServiceTests.java
index 1cc4e8aa7ebee..71460d6248c9e 100644
--- a/server/src/test/java/org/opensearch/repositories/RepositoriesServiceTests.java
+++ b/server/src/test/java/org/opensearch/repositories/RepositoriesServiceTests.java
@@ -51,6 +51,7 @@
 import org.opensearch.cluster.node.DiscoveryNodes;
 import org.opensearch.cluster.service.ClusterApplierService;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.BlobStore;
@@ -61,6 +62,7 @@
 import org.opensearch.common.io.InputStreamContainer;
 import org.opensearch.common.lifecycle.Lifecycle;
 import org.opensearch.common.lifecycle.LifecycleListener;
+import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.Strings;
@@ -147,6 +149,10 @@ private RepositoriesService createRepositoriesServiceWithMockedClusterService(Cl
         when(currentClusterState.getNodes()).thenReturn(nodes);
         when(clusterService.state()).thenReturn(currentClusterState);
 
+        when(clusterService.getSettings()).thenReturn(Settings.EMPTY);
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        when(clusterService.getClusterSettings()).thenReturn(clusterSettings);
+
         RepositoriesService repositoriesService = new RepositoriesService(
             Settings.EMPTY,
             clusterService,
@@ -679,6 +685,20 @@ public void finalizeSnapshot(
             listener.onResponse(null);
         }
 
+        @Override
+        public void finalizeSnapshot(
+            ShardGenerations shardGenerations,
+            long repositoryStateId,
+            Metadata clusterMetadata,
+            SnapshotInfo snapshotInfo,
+            Version repositoryMetaVersion,
+            Function<ClusterState, ClusterState> stateTransformer,
+            Priority repositoryUpdatePriority,
+            ActionListener<RepositoryData> listener
+        ) {
+            listener.onResponse(null);
+        }
+
         @Override
         public void deleteSnapshots(
             Collection<SnapshotId> snapshotIds,
diff --git a/server/src/test/java/org/opensearch/repositories/RepositoryDataTests.java b/server/src/test/java/org/opensearch/repositories/RepositoryDataTests.java
index a5bfca6892013..e43335246deb3 100644
--- a/server/src/test/java/org/opensearch/repositories/RepositoryDataTests.java
+++ b/server/src/test/java/org/opensearch/repositories/RepositoryDataTests.java
@@ -42,12 +42,14 @@
 import org.opensearch.core.xcontent.XContent;
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.core.xcontent.XContentParser;
+import org.opensearch.index.remote.RemoteStoreEnums.PathType;
 import org.opensearch.snapshots.SnapshotId;
 import org.opensearch.snapshots.SnapshotState;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
@@ -59,6 +61,8 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.FIXED;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathType.HASHED_PREFIX;
 import static org.opensearch.repositories.RepositoryData.EMPTY_REPO_GEN;
 import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.equalTo;
@@ -70,7 +74,7 @@
 public class RepositoryDataTests extends OpenSearchTestCase {
 
     public void testEqualsAndHashCode() {
-        RepositoryData repositoryData1 = generateRandomRepoData();
+        RepositoryData repositoryData1 = generateRandomRepoData(FIXED.getCode());
         RepositoryData repositoryData2 = repositoryData1.copy();
         assertEquals(repositoryData1, repositoryData2);
         assertEquals(repositoryData1.hashCode(), repositoryData2.hashCode());
@@ -332,7 +336,7 @@ public void testIndexThatReferenceANullSnapshot() throws IOException {
             );
             assertThat(
                 e.getMessage(),
-                equalTo("Detected a corrupted repository, " + "index [docs/_id] references an unknown snapshot uuid [null]")
+                equalTo("Detected a corrupted repository, " + "index [docs/_id/0] references an unknown snapshot uuid [null]")
             );
         }
     }
@@ -403,11 +407,95 @@ public void testIndexMetaDataToRemoveAfterRemovingSnapshotWithSharing() {
         assertEquals(newRepoData.indexMetaDataToRemoveAfterRemovingSnapshots(Collections.singleton(otherSnapshotId)), removeFromOther);
     }
 
+    public void testResolveNewIndices() {
+        // Test case 1: All indices are new
+        List<String> indicesToResolve = Arrays.asList("index1", "index2", "index3");
+        Map<String, IndexId> inFlightIds = Collections.emptyMap();
+        int pathType = randomIntBetween(0, 2);
+        List<IndexId> resolvedIndices = RepositoryData.EMPTY.resolveNewIndices(indicesToResolve, inFlightIds, pathType);
+        assertEquals(indicesToResolve.size(), resolvedIndices.size());
+        for (IndexId indexId : resolvedIndices) {
+            assertTrue(indicesToResolve.contains(indexId.getName()));
+            assertNotNull(indexId.getId());
+            assertEquals(pathType, indexId.getShardPathType());
+        }
+
+        // Test case 2: Some indices are existing, some are new
+        RepositoryData repositoryData = generateRandomRepoData();
+        Map<String, IndexId> existingIndices = repositoryData.getIndices();
+        List<String> existingIndexNames = new ArrayList<>(existingIndices.keySet());
+        List<String> newIndexNames = Arrays.asList("newIndex1", "newIndex2");
+        indicesToResolve = new ArrayList<>(existingIndexNames);
+        indicesToResolve.addAll(newIndexNames);
+        pathType = randomIntBetween(0, 2);
+        resolvedIndices = repositoryData.resolveNewIndices(indicesToResolve, Collections.emptyMap(), pathType);
+        assertEquals(indicesToResolve.size(), resolvedIndices.size());
+        for (IndexId indexId : resolvedIndices) {
+            if (existingIndexNames.contains(indexId.getName())) {
+                assertEquals(existingIndices.get(indexId.getName()), indexId);
+            } else {
+                assertTrue(newIndexNames.contains(indexId.getName()));
+                assertNotNull(indexId.getId());
+                assertEquals(pathType, indexId.getShardPathType());
+            }
+        }
+
+        // Test case 3: Some indices are in-flight
+        Map<String, IndexId> inFlightIndexIds = new HashMap<>();
+        for (String indexName : newIndexNames) {
+            inFlightIndexIds.put(indexName, new IndexId(indexName, UUIDs.randomBase64UUID(), pathType));
+        }
+        resolvedIndices = repositoryData.resolveNewIndices(indicesToResolve, inFlightIndexIds, pathType);
+        assertEquals(indicesToResolve.size(), resolvedIndices.size());
+        for (IndexId indexId : resolvedIndices) {
+            if (existingIndexNames.contains(indexId.getName())) {
+                assertEquals(existingIndices.get(indexId.getName()), indexId);
+            } else if (newIndexNames.contains(indexId.getName())) {
+                assertEquals(inFlightIndexIds.get(indexId.getName()), indexId);
+            } else {
+                fail("Unexpected index: " + indexId.getName());
+            }
+        }
+    }
+
+    public void testResolveNewIndicesWithDifferentPathType() {
+        // Generate repository data with a fixed path type
+        int existingPathType = PathType.FIXED.getCode();
+        RepositoryData repositoryData = generateRandomRepoData(existingPathType);
+        Map<String, IndexId> existingIndices = repositoryData.getIndices();
+
+        // Create a list of existing and new index names
+        List<String> existingIndexNames = new ArrayList<>(existingIndices.keySet());
+        List<String> newIndexNames = Arrays.asList("newIndex1", "newIndex2");
+        List<String> indicesToResolve = new ArrayList<>(existingIndexNames);
+        indicesToResolve.addAll(newIndexNames);
+
+        // Use a different path type for new indices
+        int newPathType = HASHED_PREFIX.getCode();
+
+        List<IndexId> resolvedIndices = repositoryData.resolveNewIndices(indicesToResolve, Collections.emptyMap(), newPathType);
+        assertEquals(indicesToResolve.size(), resolvedIndices.size());
+        for (IndexId indexId : resolvedIndices) {
+            if (existingIndexNames.contains(indexId.getName())) {
+                assertEquals(existingIndices.get(indexId.getName()), indexId);
+                assertEquals(existingPathType, indexId.getShardPathType());
+            } else {
+                assertTrue(newIndexNames.contains(indexId.getName()));
+                assertNotNull(indexId.getId());
+                assertEquals(newPathType, indexId.getShardPathType());
+            }
+        }
+    }
+
     public static RepositoryData generateRandomRepoData() {
+        return generateRandomRepoData(randomFrom(PathType.values()).getCode());
+    }
+
+    public static RepositoryData generateRandomRepoData(int pathType) {
         final int numIndices = randomIntBetween(1, 30);
         final List<IndexId> indices = new ArrayList<>(numIndices);
         for (int i = 0; i < numIndices; i++) {
-            indices.add(new IndexId(randomAlphaOfLength(8), UUIDs.randomBase64UUID()));
+            indices.add(new IndexId(randomAlphaOfLength(8), UUIDs.randomBase64UUID(), pathType));
         }
         final int numSnapshots = randomIntBetween(1, 30);
         RepositoryData repositoryData = RepositoryData.EMPTY;
diff --git a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryHelperTests.java b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryHelperTests.java
index 29ffb94ce8bf4..970e375055bc7 100644
--- a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryHelperTests.java
+++ b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryHelperTests.java
@@ -9,7 +9,6 @@
 package org.opensearch.repositories.blobstore;
 
 import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
-import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.client.Client;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.service.ClusterService;
@@ -24,6 +23,7 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.store.RemoteBufferedOutputDirectory;
 import org.opensearch.indices.IndicesService;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.plugins.Plugin;
@@ -60,13 +60,16 @@ protected Collection<Class<? extends Plugin>> getPlugins() {
     protected String[] getLockFilesInRemoteStore(String remoteStoreIndex, String remoteStoreRepository) throws IOException {
         final RepositoriesService repositoriesService = getInstanceFromNode(RepositoriesService.class);
         final BlobStoreRepository remoteStorerepository = (BlobStoreRepository) repositoriesService.repository(remoteStoreRepository);
+        ClusterService clusterService = getInstanceFromNode(ClusterService.class);
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(clusterService.getSettings());
         BlobPath shardLevelBlobPath = getShardLevelBlobPath(
             client(),
             remoteStoreIndex,
             remoteStorerepository.basePath(),
             "0",
             SEGMENTS,
-            LOCK_FILES
+            LOCK_FILES,
+            segmentsPathFixedPrefix
         );
         BlobContainer blobContainer = remoteStorerepository.blobStore().blobContainer(shardLevelBlobPath);
         try (RemoteBufferedOutputDirectory lockDirectory = new RemoteBufferedOutputDirectory(blobContainer)) {
@@ -99,25 +102,15 @@ protected void assertSnapshotOrGenericThread() {
     }
 
     protected void createRepository(Client client, String repoName) {
-        AcknowledgedResponse putRepositoryResponse = client.admin()
-            .cluster()
-            .preparePutRepository(repoName)
-            .setType(REPO_TYPE)
-            .setSettings(
-                Settings.builder().put(node().settings()).put("location", OpenSearchIntegTestCase.randomRepoPath(node().settings()))
-            )
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        Settings.Builder settings = Settings.builder()
+            .put(node().settings())
+            .put("location", OpenSearchIntegTestCase.randomRepoPath(node().settings()));
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), repoName, REPO_TYPE, settings);
     }
 
     protected void createRepository(Client client, String repoName, Settings repoSettings) {
-        AcknowledgedResponse putRepositoryResponse = client.admin()
-            .cluster()
-            .preparePutRepository(repoName)
-            .setType(REPO_TYPE)
-            .setSettings(repoSettings)
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        Settings.Builder settingsBuilder = Settings.builder().put(repoSettings);
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), repoName, REPO_TYPE, settingsBuilder);
     }
 
     protected void updateRepository(Client client, String repoName, Settings repoSettings) {
diff --git a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryRestoreTests.java b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryRestoreTests.java
index e4e83f2453fa2..7fc987dcfa9bb 100644
--- a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryRestoreTests.java
+++ b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryRestoreTests.java
@@ -42,6 +42,7 @@
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.ShardRoutingHelper;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
@@ -213,10 +214,12 @@ public void testSnapshotWithConflictingName() throws Exception {
                         Collections.emptyList(),
                         true,
                         Collections.emptyMap(),
-                        false
+                        false,
+                        0
                     ),
                     Version.CURRENT,
                     Function.identity(),
+                    Priority.NORMAL,
                     f
                 )
             );
diff --git a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
index 993588f41e6b4..6540d2f55a349 100644
--- a/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
+++ b/server/src/test/java/org/opensearch/repositories/blobstore/BlobStoreRepositoryTests.java
@@ -34,18 +34,29 @@
 
 import org.opensearch.Version;
 import org.opensearch.action.admin.cluster.snapshots.create.CreateSnapshotResponse;
+import org.opensearch.action.support.GroupedActionListener;
 import org.opensearch.action.support.PlainActionFuture;
-import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.client.Client;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
 import org.opensearch.common.UUIDs;
+import org.opensearch.common.blobstore.BlobContainer;
+import org.opensearch.common.blobstore.BlobMetadata;
+import org.opensearch.common.blobstore.DeleteResult;
+import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.unit.ByteSizeUnit;
+import org.opensearch.core.compress.Compressor;
 import org.opensearch.core.index.Index;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.env.Environment;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.index.store.RemoteSegmentStoreDirectoryFactory;
+import org.opensearch.index.store.lockmanager.RemoteStoreLockManager;
+import org.opensearch.index.store.lockmanager.RemoteStoreLockManagerFactory;
 import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.plugins.RepositoryPlugin;
@@ -54,25 +65,44 @@
 import org.opensearch.repositories.Repository;
 import org.opensearch.repositories.RepositoryData;
 import org.opensearch.repositories.RepositoryException;
+import org.opensearch.repositories.RepositoryStats;
 import org.opensearch.repositories.ShardGenerations;
 import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.snapshots.SnapshotId;
+import org.opensearch.snapshots.SnapshotShardPaths;
+import org.opensearch.snapshots.SnapshotShardPaths.ShardInfo;
 import org.opensearch.snapshots.SnapshotState;
 import org.opensearch.test.OpenSearchIntegTestCase;
 
 import java.nio.file.Path;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import static org.opensearch.repositories.RepositoryDataTests.generateRandomRepoData;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.nullValue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyMap;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 /**
  * Tests for the {@link BlobStoreRepository} and its subclasses.
@@ -113,13 +143,8 @@ public void testRetrieveSnapshots() throws Exception {
         final String repositoryName = "test-repo";
 
         logger.info("-->  creating repository");
-        AcknowledgedResponse putRepositoryResponse = client.admin()
-            .cluster()
-            .preparePutRepository(repositoryName)
-            .setType(REPO_TYPE)
-            .setSettings(Settings.builder().put(node().settings()).put("location", location))
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        Settings.Builder settings = Settings.builder().put(node().settings()).put("location", location);
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), repositoryName, REPO_TYPE, settings);
 
         logger.info("--> creating an index and indexing documents");
         final String indexName = "test-idx";
@@ -224,7 +249,7 @@ public void testRepositoryDataConcurrentModificationNotAllowed() {
         RepositoryData repositoryData = generateRandomRepoData();
         final long startingGeneration = repositoryData.getGenId();
         final PlainActionFuture<RepositoryData> future1 = PlainActionFuture.newFuture();
-        repository.writeIndexGen(repositoryData, startingGeneration, Version.CURRENT, Function.identity(), future1);
+        repository.writeIndexGen(repositoryData, startingGeneration, Version.CURRENT, Function.identity(), Priority.NORMAL, future1);
 
         // write repo data again to index generational file, errors because we already wrote to the
         // N+1 generation from which this repository data instance was created
@@ -238,23 +263,31 @@ public void testBadChunksize() throws Exception {
         final Client client = client();
         final Path location = OpenSearchIntegTestCase.randomRepoPath(node().settings());
         final String repositoryName = "test-repo";
-
+        Settings.Builder settings = Settings.builder()
+            .put(node().settings())
+            .put("location", location)
+            .put("chunk_size", randomLongBetween(-10, 0), ByteSizeUnit.BYTES);
         expectThrows(
             RepositoryException.class,
-            () -> client.admin()
-                .cluster()
-                .preparePutRepository(repositoryName)
-                .setType(REPO_TYPE)
-                .setSettings(
-                    Settings.builder()
-                        .put(node().settings())
-                        .put("location", location)
-                        .put("chunk_size", randomLongBetween(-10, 0), ByteSizeUnit.BYTES)
-                )
-                .get()
+            () -> OpenSearchIntegTestCase.putRepository(client.admin().cluster(), repositoryName, REPO_TYPE, settings)
         );
     }
 
+    public void testPrefixModeVerification() throws Exception {
+        final Client client = client();
+        final Path location = OpenSearchIntegTestCase.randomRepoPath(node().settings());
+        final String repositoryName = "test-repo";
+        Settings.Builder settings = Settings.builder()
+            .put(node().settings())
+            .put("location", location)
+            .put(BlobStoreRepository.PREFIX_MODE_VERIFICATION_SETTING.getKey(), true);
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), repositoryName, REPO_TYPE, settings);
+
+        final RepositoriesService repositoriesService = getInstanceFromNode(RepositoriesService.class);
+        final BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(repositoryName);
+        assertTrue(repository.getPrefixModeVerification());
+    }
+
     public void testFsRepositoryCompressDeprecatedIgnored() {
         final Path location = OpenSearchIntegTestCase.randomRepoPath(node().settings());
         final Settings settings = Settings.builder().put(node().settings()).put("location", location).build();
@@ -273,7 +306,7 @@ public void testFsRepositoryCompressDeprecatedIgnored() {
 
     private static void writeIndexGen(BlobStoreRepository repository, RepositoryData repositoryData, long generation) throws Exception {
         PlainActionFuture.<RepositoryData, Exception>get(
-            f -> repository.writeIndexGen(repositoryData, generation, Version.CURRENT, Function.identity(), f)
+            f -> repository.writeIndexGen(repositoryData, generation, Version.CURRENT, Function.identity(), Priority.NORMAL, f)
         );
     }
 
@@ -282,13 +315,8 @@ private BlobStoreRepository setupRepo() {
         final Path location = OpenSearchIntegTestCase.randomRepoPath(node().settings());
         final String repositoryName = "test-repo";
 
-        AcknowledgedResponse putRepositoryResponse = client.admin()
-            .cluster()
-            .preparePutRepository(repositoryName)
-            .setType(REPO_TYPE)
-            .setSettings(Settings.builder().put(node().settings()).put("location", location))
-            .get();
-        assertThat(putRepositoryResponse.isAcknowledged(), equalTo(true));
+        Settings.Builder settings = Settings.builder().put(node().settings()).put("location", location);
+        OpenSearchIntegTestCase.putRepository(client.admin().cluster(), repositoryName, REPO_TYPE, settings);
 
         final RepositoriesService repositoriesService = getInstanceFromNode(RepositoriesService.class);
         final BlobStoreRepository repository = (BlobStoreRepository) repositoriesService.repository(repositoryName);
@@ -348,4 +376,268 @@ public void testRemoteStoreShardCleanupTask() {
         remoteStoreShardCleanupTask.run();
         assertFalse(executed1.get());
     }
+
+    public void testParseShardPath() {
+        RepositoryData repoData = generateRandomRepoData();
+        IndexId indexId = repoData.getIndices().values().iterator().next();
+        int shardCount = repoData.shardGenerations().getGens(indexId).size();
+
+        String shardPath = String.join(
+            SnapshotShardPaths.DELIMITER,
+            indexId.getId(),
+            indexId.getName(),
+            String.valueOf(shardCount),
+            String.valueOf(indexId.getShardPathType()),
+            "1"
+        );
+        ShardInfo shardInfo = SnapshotShardPaths.parseShardPath(shardPath);
+
+        assertEquals(shardInfo.getIndexId(), indexId);
+        assertEquals(shardInfo.getShardCount(), shardCount);
+    }
+
+    public void testWriteAndReadShardPaths() throws Exception {
+        BlobStoreRepository repository = setupRepo();
+        RepositoryData repoData = generateRandomRepoData();
+        SnapshotId snapshotId = repoData.getSnapshotIds().iterator().next();
+
+        Set<String> writtenShardPaths = new HashSet<>();
+        for (IndexId indexId : repoData.getIndices().values()) {
+            if (indexId.getShardPathType() != IndexId.DEFAULT_SHARD_PATH_TYPE) {
+                String shardPathBlobName = repository.writeIndexShardPaths(indexId, snapshotId, indexId.getShardPathType());
+                writtenShardPaths.add(shardPathBlobName);
+            }
+        }
+
+        // Read shard paths and verify
+        Map<String, BlobMetadata> shardPathBlobs = repository.snapshotShardPathBlobContainer().listBlobs();
+
+        // Create sets for comparison
+        Set<String> expectedPaths = new HashSet<>(writtenShardPaths);
+        Set<String> actualPaths = new HashSet<>(shardPathBlobs.keySet());
+
+        // Remove known extra files - "extra0" file is added by the ExtrasFS, which is part of Lucene's test framework
+        actualPaths.remove("extra0");
+
+        // Check if all expected paths are present in the actual paths
+        assertTrue("All expected paths should be present", actualPaths.containsAll(expectedPaths));
+
+        // Check if there are any unexpected additional paths
+        Set<String> unexpectedPaths = new HashSet<>(actualPaths);
+        unexpectedPaths.removeAll(expectedPaths);
+        if (!unexpectedPaths.isEmpty()) {
+            logger.warn("Unexpected additional paths found: " + unexpectedPaths);
+        }
+
+        assertEquals("Expected and actual paths should match after removing known extra files", expectedPaths, actualPaths);
+
+        for (String shardPathBlobName : expectedPaths) {
+            SnapshotShardPaths.ShardInfo shardInfo = SnapshotShardPaths.parseShardPath(shardPathBlobName);
+            IndexId indexId = repoData.getIndices().get(shardInfo.getIndexId().getName());
+            assertNotNull("IndexId should not be null", indexId);
+            assertEquals("Index ID should match", shardInfo.getIndexId().getId(), indexId.getId());
+            assertEquals("Shard path type should match", shardInfo.getIndexId().getShardPathType(), indexId.getShardPathType());
+            String[] parts = shardPathBlobName.split("\\" + SnapshotShardPaths.DELIMITER);
+            assertEquals(
+                "Path hash algorithm should be FNV_1A_COMPOSITE_1",
+                RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1,
+                RemoteStoreEnums.PathHashAlgorithm.fromCode(Integer.parseInt(parts[4]))
+            );
+        }
+    }
+
+    public void testCleanupStaleIndices() throws Exception {
+        // Mock the BlobStoreRepository
+        BlobStoreRepository repository = mock(BlobStoreRepository.class);
+
+        // Mock BlobContainer for stale index
+        BlobContainer staleIndexContainer = mock(BlobContainer.class);
+        when(staleIndexContainer.delete()).thenReturn(new DeleteResult(1, 100L));
+
+        // Mock BlobContainer for current index
+        BlobContainer currentIndexContainer = mock(BlobContainer.class);
+
+        Map<String, BlobContainer> foundIndices = new HashMap<>();
+        foundIndices.put("stale-index", staleIndexContainer);
+        foundIndices.put("current-index", currentIndexContainer);
+
+        List<SnapshotId> snapshotIds = new ArrayList<>();
+        snapshotIds.add(new SnapshotId("snap1", UUIDs.randomBase64UUID()));
+        snapshotIds.add(new SnapshotId("snap2", UUIDs.randomBase64UUID()));
+
+        Set<String> survivingIndexIds = new HashSet<>();
+        survivingIndexIds.add("current-index");
+
+        RepositoryData repositoryData = generateRandomRepoData();
+
+        // Create a mock RemoteStoreLockManagerFactory
+        RemoteStoreLockManagerFactory mockRemoteStoreLockManagerFactory = mock(RemoteStoreLockManagerFactory.class);
+        RemoteSegmentStoreDirectoryFactory mockRemoteSegmentStoreDirectoryFactory = mock(RemoteSegmentStoreDirectoryFactory.class);
+        RemoteStoreLockManager mockLockManager = mock(RemoteStoreLockManager.class);
+        when(mockRemoteStoreLockManagerFactory.newLockManager(anyString(), anyString(), anyString(), any())).thenReturn(mockLockManager);
+
+        // Create mock snapshot shard paths
+        Map<String, BlobMetadata> mockSnapshotShardPaths = new HashMap<>();
+        String validShardPath = "stale-index-id#stale-index#1#0#1";
+        mockSnapshotShardPaths.put(validShardPath, mock(BlobMetadata.class));
+
+        // Mock snapshotShardPathBlobContainer
+        BlobContainer mockSnapshotShardPathBlobContainer = mock(BlobContainer.class);
+        when(mockSnapshotShardPathBlobContainer.delete()).thenReturn(new DeleteResult(1, 50L));
+        when(repository.snapshotShardPathBlobContainer()).thenReturn(mockSnapshotShardPathBlobContainer);
+
+        // Mock the cleanupStaleIndices method to call our test implementation
+        doAnswer(invocation -> {
+            Map<String, BlobContainer> indices = invocation.getArgument(1);
+            Set<String> surviving = invocation.getArgument(2);
+            GroupedActionListener<DeleteResult> listener = invocation.getArgument(6);
+
+            // Simulate the cleanup process
+            DeleteResult result = DeleteResult.ZERO;
+            for (Map.Entry<String, BlobContainer> entry : indices.entrySet()) {
+                if (!surviving.contains(entry.getKey())) {
+                    result = result.add(entry.getValue().delete());
+                }
+            }
+            result = result.add(mockSnapshotShardPathBlobContainer.delete());
+
+            listener.onResponse(result);
+            return null;
+        }).when(repository).cleanupStaleIndices(any(), any(), any(), any(), any(), any(), any(), any(), anyMap());
+
+        AtomicReference<Collection<DeleteResult>> resultReference = new AtomicReference<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        GroupedActionListener<DeleteResult> listener = new GroupedActionListener<>(ActionListener.wrap(deleteResults -> {
+            resultReference.set(deleteResults);
+            latch.countDown();
+        }, e -> {
+            logger.error("Error in cleanupStaleIndices", e);
+            latch.countDown();
+        }), 1);
+
+        // Call the method we're testing
+        repository.cleanupStaleIndices(
+            snapshotIds,
+            foundIndices,
+            survivingIndexIds,
+            mockRemoteStoreLockManagerFactory,
+            null,
+            repositoryData,
+            listener,
+            mockSnapshotShardPaths,
+            Collections.emptyMap()
+        );
+
+        assertTrue("Cleanup did not complete within the expected time", latch.await(30, TimeUnit.SECONDS));
+
+        Collection<DeleteResult> results = resultReference.get();
+        assertNotNull("DeleteResult collection should not be null", results);
+        assertFalse("DeleteResult collection should not be empty", results.isEmpty());
+
+        DeleteResult combinedResult = results.stream().reduce(DeleteResult.ZERO, DeleteResult::add);
+
+        assertTrue("Bytes deleted should be greater than 0", combinedResult.bytesDeleted() > 0);
+        assertTrue("Blobs deleted should be greater than 0", combinedResult.blobsDeleted() > 0);
+
+        // Verify that the stale index was processed for deletion
+        verify(staleIndexContainer, times(1)).delete();
+
+        // Verify that the current index was not processed for deletion
+        verify(currentIndexContainer, never()).delete();
+
+        // Verify that snapshot shard paths were considered in the cleanup process
+        verify(mockSnapshotShardPathBlobContainer, times(1)).delete();
+
+        // Verify the total number of bytes and blobs deleted
+        assertEquals("Total bytes deleted should be 150", 150L, combinedResult.bytesDeleted());
+        assertEquals("Total blobs deleted should be 2", 2, combinedResult.blobsDeleted());
+    }
+
+    public void testGetMetadata() {
+        BlobStoreRepository repository = setupRepo();
+        RepositoryMetadata metadata = repository.getMetadata();
+        assertNotNull(metadata);
+        assertEquals(metadata.name(), "test-repo");
+        assertEquals(metadata.type(), REPO_TYPE);
+        repository.close();
+    }
+
+    public void testGetNamedXContentRegistry() {
+        BlobStoreRepository repository = setupRepo();
+        NamedXContentRegistry registry = repository.getNamedXContentRegistry();
+        assertNotNull(registry);
+        repository.close();
+    }
+
+    public void testGetCompressor() {
+        BlobStoreRepository repository = setupRepo();
+        Compressor compressor = repository.getCompressor();
+        assertNotNull(compressor);
+        repository.close();
+    }
+
+    public void testGetStats() {
+        BlobStoreRepository repository = setupRepo();
+        RepositoryStats stats = repository.stats();
+        assertNotNull(stats);
+        repository.close();
+    }
+
+    public void testGetSnapshotThrottleTimeInNanos() {
+        BlobStoreRepository repository = setupRepo();
+        long throttleTime = repository.getSnapshotThrottleTimeInNanos();
+        assertTrue(throttleTime >= 0);
+        repository.close();
+    }
+
+    public void testGetRestoreThrottleTimeInNanos() {
+        BlobStoreRepository repository = setupRepo();
+        long throttleTime = repository.getRestoreThrottleTimeInNanos();
+        assertTrue(throttleTime >= 0);
+        repository.close();
+    }
+
+    public void testGetRemoteUploadThrottleTimeInNanos() {
+        BlobStoreRepository repository = setupRepo();
+        long throttleTime = repository.getRemoteUploadThrottleTimeInNanos();
+        assertTrue(throttleTime >= 0);
+        repository.close();
+    }
+
+    public void testGetLowPriorityRemoteUploadThrottleTimeInNanos() {
+        BlobStoreRepository repository = setupRepo();
+        long throttleTime = repository.getLowPriorityRemoteUploadThrottleTimeInNanos();
+        assertTrue(throttleTime >= 0);
+        repository.close();
+    }
+
+    public void testGetRemoteDownloadThrottleTimeInNanos() {
+        BlobStoreRepository repository = setupRepo();
+        long throttleTime = repository.getRemoteDownloadThrottleTimeInNanos();
+        assertTrue(throttleTime >= 0);
+        repository.close();
+    }
+
+    public void testIsReadOnly() {
+        BlobStoreRepository repository = setupRepo();
+        assertFalse(repository.isReadOnly());
+        repository.close();
+    }
+
+    public void testIsSystemRepository() {
+        BlobStoreRepository repository = setupRepo();
+        assertFalse(repository.isSystemRepository());
+        repository.close();
+    }
+
+    public void testGetRestrictedSystemRepositorySettings() {
+        BlobStoreRepository repository = setupRepo();
+        List<Setting<?>> settings = repository.getRestrictedSystemRepositorySettings();
+        assertNotNull(settings);
+        assertTrue(settings.contains(BlobStoreRepository.SYSTEM_REPOSITORY_SETTING));
+        assertTrue(settings.contains(BlobStoreRepository.READONLY_SETTING));
+        assertTrue(settings.contains(BlobStoreRepository.REMOTE_STORE_INDEX_SHALLOW_COPY));
+        repository.close();
+    }
 }
diff --git a/server/src/test/java/org/opensearch/repositories/blobstore/ChecksumWritableBlobStoreFormatTests.java b/server/src/test/java/org/opensearch/repositories/blobstore/ChecksumWritableBlobStoreFormatTests.java
new file mode 100644
index 0000000000000..c4e53c1eea138
--- /dev/null
+++ b/server/src/test/java/org/opensearch/repositories/blobstore/ChecksumWritableBlobStoreFormatTests.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.repositories.blobstore;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.compress.DeflateCompressor;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.compress.CompressorRegistry;
+import org.opensearch.core.index.Index;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+
+import static org.hamcrest.Matchers.is;
+
+/**
+ * Tests for {@link ChecksumWritableBlobStoreFormat}
+ */
+public class ChecksumWritableBlobStoreFormatTests extends OpenSearchTestCase {
+    private static final String TEST_BLOB_FILE_NAME = "test-blob-name";
+    private static final long VERSION = 5L;
+
+    private final ChecksumWritableBlobStoreFormat<IndexMetadata> clusterBlocksFormat = new ChecksumWritableBlobStoreFormat<>(
+        "index-metadata",
+        IndexMetadata::readFrom
+    );
+
+    public void testSerDe() throws IOException {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        BytesReference bytesReference = clusterBlocksFormat.serialize(
+            (out, metadata) -> metadata.writeTo(out),
+            indexMetadata,
+            TEST_BLOB_FILE_NAME,
+            CompressorRegistry.none()
+        );
+        IndexMetadata readIndexMetadata = clusterBlocksFormat.deserialize(TEST_BLOB_FILE_NAME, bytesReference);
+        assertThat(readIndexMetadata, is(indexMetadata));
+    }
+
+    public void testSerDeForCompressed() throws IOException {
+        IndexMetadata indexMetadata = getIndexMetadata();
+        BytesReference bytesReference = clusterBlocksFormat.serialize(
+            (out, metadata) -> metadata.writeTo(out),
+            indexMetadata,
+            TEST_BLOB_FILE_NAME,
+            CompressorRegistry.getCompressor(DeflateCompressor.NAME)
+        );
+        IndexMetadata readIndexMetadata = clusterBlocksFormat.deserialize(TEST_BLOB_FILE_NAME, bytesReference);
+        assertThat(readIndexMetadata, is(indexMetadata));
+    }
+
+    private IndexMetadata getIndexMetadata() {
+        final Index index = new Index("test-index", "index-uuid");
+        final Settings idxSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_INDEX_UUID, index.getUUID())
+            .build();
+        return new IndexMetadata.Builder(index.getName()).settings(idxSettings)
+            .version(VERSION)
+            .numberOfShards(1)
+            .numberOfReplicas(0)
+            .build();
+    }
+}
diff --git a/server/src/test/java/org/opensearch/rest/RestControllerTests.java b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
index b04ebe4c7f3bf..920f1d70a3267 100644
--- a/server/src/test/java/org/opensearch/rest/RestControllerTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestControllerTests.java
@@ -60,6 +60,7 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.client.NoOpNodeClient;
 import org.opensearch.test.rest.FakeRestRequest;
+import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.usage.UsageService;
 import org.junit.After;
 import org.junit.Before;
@@ -113,7 +114,7 @@ public void setup() {
         // we can do this here only because we know that we don't adjust breaker settings dynamically in the test
         inFlightRequestsBreaker = circuitBreakerService.getBreaker(CircuitBreaker.IN_FLIGHT_REQUESTS);
 
-        identityService = new IdentityService(Settings.EMPTY, List.of());
+        identityService = new IdentityService(Settings.EMPTY, mock(ThreadPool.class), List.of());
 
         HttpServerTransport httpServerTransport = new TestHttpServerTransport();
         client = new NoOpNodeClient(this.getTestName());
diff --git a/server/src/test/java/org/opensearch/rest/RestHttpResponseHeadersTests.java b/server/src/test/java/org/opensearch/rest/RestHttpResponseHeadersTests.java
index 5d677247b8b6d..983121a4f481d 100644
--- a/server/src/test/java/org/opensearch/rest/RestHttpResponseHeadersTests.java
+++ b/server/src/test/java/org/opensearch/rest/RestHttpResponseHeadersTests.java
@@ -44,6 +44,7 @@
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.rest.FakeRestChannel;
 import org.opensearch.test.rest.FakeRestRequest;
+import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.usage.UsageService;
 
 import java.util.ArrayList;
@@ -55,6 +56,7 @@
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.is;
+import static org.mockito.Mockito.mock;
 
 public class RestHttpResponseHeadersTests extends OpenSearchTestCase {
 
@@ -106,7 +108,7 @@ public void testUnsupportedMethodResponseHttpHeader() throws Exception {
 
         final Settings settings = Settings.EMPTY;
         UsageService usageService = new UsageService();
-        final IdentityService identityService = new IdentityService(settings, List.of());
+        final IdentityService identityService = new IdentityService(settings, mock(ThreadPool.class), List.of());
         RestController restController = new RestController(
             Collections.emptySet(),
             null,
diff --git a/server/src/test/java/org/opensearch/rest/action/admin/indices/RestValidateQueryActionTests.java b/server/src/test/java/org/opensearch/rest/action/admin/indices/RestValidateQueryActionTests.java
index 3fb6764846da6..c3cf33f4e9034 100644
--- a/server/src/test/java/org/opensearch/rest/action/admin/indices/RestValidateQueryActionTests.java
+++ b/server/src/test/java/org/opensearch/rest/action/admin/indices/RestValidateQueryActionTests.java
@@ -75,7 +75,7 @@ public class RestValidateQueryActionTests extends AbstractSearchTestCase {
     private static NodeClient client = new NodeClient(Settings.EMPTY, threadPool);
 
     private static UsageService usageService = new UsageService();
-    private static IdentityService identityService = new IdentityService(Settings.EMPTY, List.of());
+    private static IdentityService identityService = new IdentityService(Settings.EMPTY, threadPool, List.of());
     private static RestController controller = new RestController(
         emptySet(),
         null,
diff --git a/server/src/test/java/org/opensearch/rest/action/document/RestBulkStreamingActionTests.java b/server/src/test/java/org/opensearch/rest/action/document/RestBulkStreamingActionTests.java
new file mode 100644
index 0000000000000..aa52ffe08927c
--- /dev/null
+++ b/server/src/test/java/org/opensearch/rest/action/document/RestBulkStreamingActionTests.java
@@ -0,0 +1,89 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.rest.action.document;
+
+import org.opensearch.Version;
+import org.opensearch.action.bulk.BulkRequest;
+import org.opensearch.action.bulk.BulkResponse;
+import org.opensearch.client.node.NodeClient;
+import org.opensearch.common.SetOnce;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.core.common.bytes.BytesArray;
+import org.opensearch.core.rest.RestStatus;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.rest.RestChannel;
+import org.opensearch.rest.RestRequest;
+import org.opensearch.rest.RestResponse;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.test.client.NoOpNodeClient;
+import org.opensearch.test.rest.FakeRestRequest;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.mockito.ArgumentCaptor;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * Tests for {@link RestBulkStreamingAction}.
+ */
+public class RestBulkStreamingActionTests extends OpenSearchTestCase {
+    public void testBulkStreamingPipelineUpsert() throws Exception {
+        SetOnce<Boolean> bulkCalled = new SetOnce<>();
+        try (NodeClient verifyingClient = new NoOpNodeClient(this.getTestName()) {
+            @Override
+            public void bulk(BulkRequest request, ActionListener<BulkResponse> listener) {
+                bulkCalled.set(true);
+            }
+        }) {
+            final Map<String, String> params = new HashMap<>();
+            params.put("pipeline", "timestamps");
+
+            final FakeRestRequest request = new FakeRestRequest.Builder(xContentRegistry()).withPath("my_index/_bulk/streaming")
+                .withParams(params)
+                .withContent(
+                    new BytesArray(
+                        "{\"index\":{\"_id\":\"1\"}}\n"
+                            + "{\"field1\":\"val1\"}\n"
+                            + "{\"update\":{\"_id\":\"2\"}}\n"
+                            + "{\"script\":{\"source\":\"ctx._source.counter++;\"},\"upsert\":{\"field1\":\"upserted_val\"}}\n"
+                    ),
+                    MediaTypeRegistry.JSON
+                )
+                .withMethod(RestRequest.Method.POST)
+                .build();
+            request.param("error_trace", "false");
+            request.param("rest.exception.stacktrace.skip", "false");
+
+            final RestChannel channel = mock(RestChannel.class);
+            when(channel.request()).thenReturn(request);
+            when(channel.newErrorBuilder()).thenReturn(XContentType.YAML.contentBuilder());
+            when(channel.detailedErrorsEnabled()).thenReturn(true);
+
+            new RestBulkStreamingAction(settings(Version.CURRENT).build()).handleRequest(request, channel, verifyingClient);
+
+            final ArgumentCaptor<RestResponse> responseCaptor = ArgumentCaptor.captor();
+            verify(channel).sendResponse(responseCaptor.capture());
+
+            // We do not expect `bulk` action to be called since the default HTTP transport (netty4) does not support streaming
+            assertThat(bulkCalled.get(), equalTo(null));
+            assertThat(responseCaptor.getValue().status(), equalTo(RestStatus.BAD_REQUEST));
+            assertThat(
+                responseCaptor.getValue().content().utf8ToString(),
+                containsString("Unable to initiate request / response streaming")
+            );
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/search/CreatePitSingleNodeTests.java b/server/src/test/java/org/opensearch/search/CreatePitSingleNodeTests.java
index d160277808300..d8fdd9a9cd6eb 100644
--- a/server/src/test/java/org/opensearch/search/CreatePitSingleNodeTests.java
+++ b/server/src/test/java/org/opensearch/search/CreatePitSingleNodeTests.java
@@ -76,7 +76,7 @@ public void testCreatePITSuccess() throws ExecutionException, InterruptedExcepti
         request.setIndices(new String[] { "index" });
         ActionFuture<CreatePitResponse> execute = client().execute(CreatePitAction.INSTANCE, request);
         CreatePitResponse pitResponse = execute.get();
-        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime());
+        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime(), TimeValue.timeValueDays(1));
         assertSegments(false, client(), pitResponse.getId());
         client().prepareIndex("index").setId("2").setSource("field", "value").setRefreshPolicy(IMMEDIATE).get();
         SearchResponse searchResponse = client().prepareSearch("index")
@@ -106,7 +106,7 @@ public void testCreatePITWithMultipleIndicesSuccess() throws ExecutionException,
 
         ActionFuture<CreatePitResponse> execute = client().execute(CreatePitAction.INSTANCE, request);
         CreatePitResponse response = execute.get();
-        PitTestsUtil.assertUsingGetAllPits(client(), response.getId(), response.getCreationTime());
+        PitTestsUtil.assertUsingGetAllPits(client(), response.getId(), response.getCreationTime(), TimeValue.timeValueDays(1));
         assertSegments(false, client(), response.getId());
         assertEquals(4, response.getSuccessfulShards());
         assertEquals(4, service.getActiveContexts());
@@ -127,7 +127,7 @@ public void testCreatePITWithShardReplicasSuccess() throws ExecutionException, I
         request.setIndices(new String[] { "index" });
         ActionFuture<CreatePitResponse> execute = client().execute(CreatePitAction.INSTANCE, request);
         CreatePitResponse pitResponse = execute.get();
-        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime());
+        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime(), TimeValue.timeValueDays(1));
         assertSegments(false, client(), pitResponse.getId());
         client().prepareIndex("index").setId("2").setSource("field", "value").setRefreshPolicy(IMMEDIATE).get();
         SearchResponse searchResponse = client().prepareSearch("index")
@@ -229,7 +229,7 @@ public void testPitSearchOnCloseIndex() throws ExecutionException, InterruptedEx
         request.setIndices(new String[] { "index" });
         ActionFuture<CreatePitResponse> execute = client().execute(CreatePitAction.INSTANCE, request);
         CreatePitResponse pitResponse = execute.get();
-        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime());
+        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime(), TimeValue.timeValueDays(1));
         assertSegments(false, client(), pitResponse.getId());
         SearchService service = getInstanceFromNode(SearchService.class);
         assertEquals(2, service.getActiveContexts());
@@ -412,7 +412,7 @@ public void testPitAfterUpdateIndex() throws Exception {
         request.setIndices(new String[] { "test" });
         ActionFuture<CreatePitResponse> execute = client().execute(CreatePitAction.INSTANCE, request);
         CreatePitResponse pitResponse = execute.get();
-        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime());
+        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime(), TimeValue.timeValueMinutes(2));
         SearchService service = getInstanceFromNode(SearchService.class);
 
         assertThat(
@@ -570,7 +570,7 @@ public void testConcurrentSearches() throws Exception {
         request.setIndices(new String[] { "index" });
         ActionFuture<CreatePitResponse> execute = client().execute(CreatePitAction.INSTANCE, request);
         CreatePitResponse pitResponse = execute.get();
-        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime());
+        PitTestsUtil.assertUsingGetAllPits(client(), pitResponse.getId(), pitResponse.getCreationTime(), TimeValue.timeValueDays(1));
         assertSegments(false, client(), pitResponse.getId());
         Thread[] threads = new Thread[5];
         CountDownLatch latch = new CountDownLatch(threads.length);
diff --git a/server/src/test/java/org/opensearch/search/DefaultSearchContextTests.java b/server/src/test/java/org/opensearch/search/DefaultSearchContextTests.java
index a1a808c9faa9b..491a0377ab32e 100644
--- a/server/src/test/java/org/opensearch/search/DefaultSearchContextTests.java
+++ b/server/src/test/java/org/opensearch/search/DefaultSearchContextTests.java
@@ -51,6 +51,7 @@
 import org.opensearch.common.SetOnce;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.util.BigArrays;
@@ -67,9 +68,16 @@
 import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.query.AbstractQueryBuilder;
+import org.opensearch.index.query.BoolQueryBuilder;
 import org.opensearch.index.query.ParsedQuery;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.search.aggregations.AggregatorFactories;
+import org.opensearch.search.aggregations.MultiBucketConsumerService;
+import org.opensearch.search.aggregations.SearchContextAggregations;
+import org.opensearch.search.builder.SearchSourceBuilder;
+import org.opensearch.search.deciders.ConcurrentSearchDecider;
+import org.opensearch.search.deciders.ConcurrentSearchDecision;
 import org.opensearch.search.internal.AliasFilter;
 import org.opensearch.search.internal.LegacyReaderContext;
 import org.opensearch.search.internal.PitReaderContext;
@@ -84,8 +92,10 @@
 import org.opensearch.threadpool.ThreadPool;
 
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.UUID;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -220,7 +230,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             contextWithoutScroll.from(300);
             contextWithoutScroll.close();
@@ -263,7 +274,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             context1.from(300);
             exception = expectThrows(IllegalArgumentException.class, () -> context1.preProcess(false));
@@ -334,7 +346,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
 
             SliceBuilder sliceBuilder = mock(SliceBuilder.class);
@@ -374,7 +387,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             ParsedQuery parsedQuery = ParsedQuery.parsedMatchAllQuery();
             context3.sliceBuilder(null).parsedQuery(parsedQuery).preProcess(false);
@@ -410,7 +424,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             context4.sliceBuilder(new SliceBuilder(1, 2)).parsedQuery(parsedQuery).preProcess(false);
             Query query1 = context4.query();
@@ -441,7 +456,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             int numSlicesForPit = maxSlicesPerPit + randomIntBetween(1, 100);
             when(sliceBuilder.getMax()).thenReturn(numSlicesForPit);
@@ -547,7 +563,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             assertThat(context.searcher().hasCancellations(), is(false));
             context.searcher().addQueryCancellation(() -> {});
@@ -643,6 +660,7 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
             final ClusterService clusterService = mock(ClusterService.class);
             final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
             clusterSettings.registerSetting(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING);
+            // clusterSettings.registerSetting(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE);
             clusterSettings.applySettings(
                 Settings.builder().put(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true).build()
             );
@@ -651,7 +669,7 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 readerContext,
                 shardSearchRequest,
                 target,
-                null,
+                clusterService,
                 bigArrays,
                 null,
                 null,
@@ -660,7 +678,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
 
             // Case1: if sort is on timestamp field, non-concurrent path is used
@@ -685,7 +704,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             context.sort(
                 new SortAndFormats(new Sort(new SortField("test2", SortField.Type.INT)), new DocValueFormat[] { DocValueFormat.RAW })
@@ -712,7 +732,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             context.evaluateRequestShouldUseConcurrentSearch();
             if (executor == null) {
@@ -744,7 +765,8 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             context.evaluateRequestShouldUseConcurrentSearch();
             assertFalse(context.shouldUseConcurrentSearch());
@@ -772,12 +794,371 @@ protected Engine.Searcher acquireSearcherInternal(String source) {
                 Version.CURRENT,
                 false,
                 executor,
-                null
+                null,
+                Collections.emptyList()
             );
             context.evaluateRequestShouldUseConcurrentSearch();
             assertFalse(context.shouldUseConcurrentSearch());
             assertThrows(SetOnce.AlreadySetException.class, context::evaluateRequestShouldUseConcurrentSearch);
 
+            if (clusterService.getClusterSettings().get(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING)) {
+                assertSettingDeprecationsAndWarnings(new Setting[] { SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING });
+            }
+
+            // shutdown the threadpool
+            threadPool.shutdown();
+        }
+    }
+
+    public void testSearchPathEvaluationWithConcurrentSearchModeAsAuto() throws Exception {
+        ShardSearchRequest shardSearchRequest = mock(ShardSearchRequest.class);
+        when(shardSearchRequest.searchType()).thenReturn(SearchType.DEFAULT);
+        ShardId shardId = new ShardId("index", UUID.randomUUID().toString(), 1);
+        when(shardSearchRequest.shardId()).thenReturn(shardId);
+
+        ThreadPool threadPool = new TestThreadPool(this.getClass().getName());
+        IndexShard indexShard = mock(IndexShard.class);
+        QueryCachingPolicy queryCachingPolicy = mock(QueryCachingPolicy.class);
+        when(indexShard.getQueryCachingPolicy()).thenReturn(queryCachingPolicy);
+        when(indexShard.getThreadPool()).thenReturn(threadPool);
+
+        Settings settings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 2)
+            .build();
+
+        IndexService indexService = mock(IndexService.class);
+        QueryShardContext queryShardContext = mock(QueryShardContext.class);
+        when(indexService.newQueryShardContext(eq(shardId.id()), any(), any(), nullable(String.class), anyBoolean())).thenReturn(
+            queryShardContext
+        );
+
+        IndexMetadata indexMetadata = IndexMetadata.builder("index").settings(settings).build();
+        IndexSettings indexSettings = new IndexSettings(indexMetadata, Settings.EMPTY);
+        when(indexService.getIndexSettings()).thenReturn(indexSettings);
+        when(indexShard.indexSettings()).thenReturn(indexSettings);
+
+        BigArrays bigArrays = new MockBigArrays(new MockPageCacheRecycler(Settings.EMPTY), new NoneCircuitBreakerService());
+
+        IndexShard systemIndexShard = mock(IndexShard.class);
+        when(systemIndexShard.getQueryCachingPolicy()).thenReturn(queryCachingPolicy);
+        when(systemIndexShard.getThreadPool()).thenReturn(threadPool);
+        when(systemIndexShard.isSystem()).thenReturn(true);
+
+        IndexShard throttledIndexShard = mock(IndexShard.class);
+        when(throttledIndexShard.getQueryCachingPolicy()).thenReturn(queryCachingPolicy);
+        when(throttledIndexShard.getThreadPool()).thenReturn(threadPool);
+        IndexSettings throttledIndexSettings = new IndexSettings(
+            indexMetadata,
+            Settings.builder().put(INDEX_SEARCH_THROTTLED.getKey(), true).build()
+        );
+        when(throttledIndexShard.indexSettings()).thenReturn(throttledIndexSettings);
+
+        try (Directory dir = newDirectory(); RandomIndexWriter w = new RandomIndexWriter(random(), dir)) {
+
+            final Supplier<Engine.SearcherSupplier> searcherSupplier = () -> new Engine.SearcherSupplier(Function.identity()) {
+                @Override
+                protected void doClose() {}
+
+                @Override
+                protected Engine.Searcher acquireSearcherInternal(String source) {
+                    try {
+                        IndexReader reader = w.getReader();
+                        return new Engine.Searcher(
+                            "test",
+                            reader,
+                            IndexSearcher.getDefaultSimilarity(),
+                            IndexSearcher.getDefaultQueryCache(),
+                            IndexSearcher.getDefaultQueryCachingPolicy(),
+                            reader
+                        );
+                    } catch (IOException exc) {
+                        throw new AssertionError(exc);
+                    }
+                }
+            };
+
+            SearchShardTarget target = new SearchShardTarget("node", shardId, null, OriginalIndices.NONE);
+            ReaderContext readerContext = new ReaderContext(
+                newContextId(),
+                indexService,
+                indexShard,
+                searcherSupplier.get(),
+                randomNonNegativeLong(),
+                false
+            );
+
+            final ClusterService clusterService = mock(ClusterService.class);
+            final ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+            clusterSettings.registerSetting(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING);
+            clusterSettings.registerSetting(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE);
+            clusterSettings.applySettings(
+                Settings.builder().put(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), "auto").build()
+            );
+            when(clusterService.getClusterSettings()).thenReturn(clusterSettings);
+            when(clusterService.getSettings()).thenReturn(settings);
+
+            DefaultSearchContext context = new DefaultSearchContext(
+                readerContext,
+                shardSearchRequest,
+                target,
+                clusterService,
+                bigArrays,
+                null,
+                null,
+                null,
+                false,
+                Version.CURRENT,
+                false,
+                executor,
+                null,
+                Collections.emptyList()
+            );
+
+            // Case1: if there is no agg in the query, non-concurrent path is used
+            context.evaluateRequestShouldUseConcurrentSearch();
+            assertFalse(context.shouldUseConcurrentSearch());
+            assertThrows(SetOnce.AlreadySetException.class, context::evaluateRequestShouldUseConcurrentSearch);
+
+            // Case2: if un supported agg present, non-concurrent path is used
+            SearchContextAggregations mockAggregations = mock(SearchContextAggregations.class);
+            when(mockAggregations.factories()).thenReturn(mock(AggregatorFactories.class));
+            when(mockAggregations.factories().allFactoriesSupportConcurrentSearch()).thenReturn(false);
+            when(mockAggregations.multiBucketConsumer()).thenReturn(mock(MultiBucketConsumerService.MultiBucketConsumer.class));
+
+            context = new DefaultSearchContext(
+                readerContext,
+                shardSearchRequest,
+                target,
+                clusterService,
+                bigArrays,
+                null,
+                null,
+                null,
+                false,
+                Version.CURRENT,
+                false,
+                executor,
+                null,
+                Collections.emptyList()
+            );
+
+            // add un-supported agg operation
+            context.aggregations(mockAggregations);
+            context.evaluateRequestShouldUseConcurrentSearch();
+            if (executor == null) {
+                assertFalse(context.shouldUseConcurrentSearch());
+            } else {
+                assertFalse(context.shouldUseConcurrentSearch());
+            }
+            assertThrows(SetOnce.AlreadySetException.class, context::evaluateRequestShouldUseConcurrentSearch);
+
+            // Case3: if supported agg present, concurrent path is used
+
+            // set agg operation to be supported
+            when(mockAggregations.factories().allFactoriesSupportConcurrentSearch()).thenReturn(true);
+
+            context = new DefaultSearchContext(
+                readerContext,
+                shardSearchRequest,
+                target,
+                clusterService,
+                bigArrays,
+                null,
+                null,
+                null,
+                false,
+                Version.CURRENT,
+                false,
+                executor,
+                null,
+                Collections.emptyList()
+            );
+            // create a supported agg operation
+            context.aggregations(mockAggregations);
+            context.evaluateRequestShouldUseConcurrentSearch();
+            if (executor == null) {
+                assertFalse(context.shouldUseConcurrentSearch());
+            } else {
+                assertTrue(context.shouldUseConcurrentSearch());
+            }
+            assertThrows(SetOnce.AlreadySetException.class, context::evaluateRequestShouldUseConcurrentSearch);
+
+            // Case4: multiple deciders are registered and all of them opt out of decision-making
+            // with supported agg query so concurrent path is used
+
+            ConcurrentSearchDecider decider1 = mock(ConcurrentSearchDecider.class);
+            when(decider1.canEvaluateForIndex(any())).thenReturn(false);
+            ConcurrentSearchDecider decider2 = mock(ConcurrentSearchDecider.class);
+            when(decider2.canEvaluateForIndex(any())).thenReturn(false);
+
+            Collection<ConcurrentSearchDecider> concurrentSearchDeciders = new ArrayList<>();
+            concurrentSearchDeciders.add(decider1);
+            concurrentSearchDeciders.add(decider2);
+
+            context = new DefaultSearchContext(
+                readerContext,
+                shardSearchRequest,
+                target,
+                clusterService,
+                bigArrays,
+                null,
+                null,
+                null,
+                false,
+                Version.CURRENT,
+                false,
+                executor,
+                null,
+                concurrentSearchDeciders
+            );
+            // create a supported agg operation
+            context.aggregations(mockAggregations);
+            context.evaluateRequestShouldUseConcurrentSearch();
+            if (executor == null) {
+                assertFalse(context.shouldUseConcurrentSearch());
+            } else {
+                assertTrue(context.shouldUseConcurrentSearch());
+            }
+            assertThrows(SetOnce.AlreadySetException.class, context::evaluateRequestShouldUseConcurrentSearch);
+
+            // Case5: multiple deciders are registered and one of them returns ConcurrentSearchDecision.DecisionStatus.NO
+            // use non-concurrent path even if query contains supported agg
+            when(decider1.canEvaluateForIndex(any())).thenReturn(true);
+            when(decider1.getConcurrentSearchDecision()).thenReturn(
+                new ConcurrentSearchDecision(ConcurrentSearchDecision.DecisionStatus.NO, "disable concurrent search")
+            );
+            when(decider2.canEvaluateForIndex(any())).thenReturn(false);
+
+            concurrentSearchDeciders.clear();
+            concurrentSearchDeciders.add(decider1);
+            concurrentSearchDeciders.add(decider2);
+
+            // create a source so that query tree is parsed by visitor
+            SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
+            BoolQueryBuilder queryBuilder = new BoolQueryBuilder();
+            sourceBuilder.query(queryBuilder);
+            when(shardSearchRequest.source()).thenReturn(sourceBuilder);
+
+            context = new DefaultSearchContext(
+                readerContext,
+                shardSearchRequest,
+                target,
+                clusterService,
+                bigArrays,
+                null,
+                null,
+                null,
+                false,
+                Version.CURRENT,
+                false,
+                executor,
+                null,
+                concurrentSearchDeciders
+            );
+
+            // create a supported agg operation
+            context.aggregations(mockAggregations);
+            context.evaluateRequestShouldUseConcurrentSearch();
+            if (executor == null) {
+                assertFalse(context.shouldUseConcurrentSearch());
+            } else {
+                assertFalse(context.shouldUseConcurrentSearch());
+            }
+            assertThrows(SetOnce.AlreadySetException.class, context::evaluateRequestShouldUseConcurrentSearch);
+
+            // Case6: multiple deciders are registered and first decider returns ConcurrentSearchDecision.DecisionStatus.YES
+            // while second decider returns ConcurrentSearchDecision.DecisionStatus.NO
+            // use non-concurrent path even if query contains supported agg
+            when(decider1.canEvaluateForIndex(any())).thenReturn(true);
+            when(decider1.getConcurrentSearchDecision()).thenReturn(
+                new ConcurrentSearchDecision(ConcurrentSearchDecision.DecisionStatus.YES, "enable concurrent search")
+            );
+            when(decider2.canEvaluateForIndex(any())).thenReturn(true);
+            when(decider2.getConcurrentSearchDecision()).thenReturn(
+                new ConcurrentSearchDecision(ConcurrentSearchDecision.DecisionStatus.NO, "disable concurrent search")
+            );
+
+            concurrentSearchDeciders.clear();
+            concurrentSearchDeciders.add(decider1);
+            concurrentSearchDeciders.add(decider2);
+
+            // create a source so that query tree is parsed by visitor
+
+            context = new DefaultSearchContext(
+                readerContext,
+                shardSearchRequest,
+                target,
+                clusterService,
+                bigArrays,
+                null,
+                null,
+                null,
+                false,
+                Version.CURRENT,
+                false,
+                executor,
+                null,
+                concurrentSearchDeciders
+            );
+
+            // create a supported agg operation
+            context.aggregations(mockAggregations);
+            context.evaluateRequestShouldUseConcurrentSearch();
+            if (executor == null) {
+                assertFalse(context.shouldUseConcurrentSearch());
+            } else {
+                assertFalse(context.shouldUseConcurrentSearch());
+            }
+            assertThrows(SetOnce.AlreadySetException.class, context::evaluateRequestShouldUseConcurrentSearch);
+
+            // Case7: multiple deciders are registered and all return ConcurrentSearchDecision.DecisionStatus.NO_OP
+            // but un-supported agg query is present, use non-concurrent path
+            when(decider1.canEvaluateForIndex(any())).thenReturn(true);
+            when(decider1.getConcurrentSearchDecision()).thenReturn(
+                new ConcurrentSearchDecision(ConcurrentSearchDecision.DecisionStatus.NO_OP, "noop")
+            );
+            when(decider2.canEvaluateForIndex(any())).thenReturn(true);
+            when(decider2.getConcurrentSearchDecision()).thenReturn(
+                new ConcurrentSearchDecision(ConcurrentSearchDecision.DecisionStatus.NO_OP, "noop")
+            );
+
+            when(mockAggregations.factories().allFactoriesSupportConcurrentSearch()).thenReturn(false);
+
+            concurrentSearchDeciders.clear();
+            concurrentSearchDeciders.add(decider1);
+            concurrentSearchDeciders.add(decider2);
+
+            // create a source so that query tree is parsed by visitor
+
+            context = new DefaultSearchContext(
+                readerContext,
+                shardSearchRequest,
+                target,
+                clusterService,
+                bigArrays,
+                null,
+                null,
+                null,
+                false,
+                Version.CURRENT,
+                false,
+                executor,
+                null,
+                concurrentSearchDeciders
+            );
+
+            // create a supported agg operation
+            context.aggregations(mockAggregations);
+            context.evaluateRequestShouldUseConcurrentSearch();
+            if (executor == null) {
+                assertFalse(context.shouldUseConcurrentSearch());
+            } else {
+                assertFalse(context.shouldUseConcurrentSearch());
+            }
+            assertThrows(SetOnce.AlreadySetException.class, context::evaluateRequestShouldUseConcurrentSearch);
+
             // shutdown the threadpool
             threadPool.shutdown();
         }
diff --git a/server/src/test/java/org/opensearch/search/SearchCancellationTests.java b/server/src/test/java/org/opensearch/search/SearchCancellationTests.java
index fce58eecbafb1..266052444da46 100644
--- a/server/src/test/java/org/opensearch/search/SearchCancellationTests.java
+++ b/server/src/test/java/org/opensearch/search/SearchCancellationTests.java
@@ -51,6 +51,7 @@
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.core.tasks.TaskCancelledException;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.shard.SearchOperationListener;
 import org.opensearch.search.internal.ContextIndexSearcher;
 import org.opensearch.search.internal.SearchContext;
 import org.opensearch.test.OpenSearchTestCase;
@@ -138,6 +139,9 @@ public void testCancellableCollector() throws IOException {
         Runnable cancellation = () -> { throw new TaskCancelledException("cancelled"); };
         IndexShard indexShard = mock(IndexShard.class);
         when(searchContext.indexShard()).thenReturn(indexShard);
+        SearchOperationListener searchOperationListener = new SearchOperationListener() {
+        };
+        when(indexShard.getSearchOperationListener()).thenReturn(searchOperationListener);
         ContextIndexSearcher searcher = new ContextIndexSearcher(
             reader,
             IndexSearcher.getDefaultSimilarity(),
diff --git a/server/src/test/java/org/opensearch/search/SearchModuleTests.java b/server/src/test/java/org/opensearch/search/SearchModuleTests.java
index 4b57ee9aec106..b3483b76dee1c 100644
--- a/server/src/test/java/org/opensearch/search/SearchModuleTests.java
+++ b/server/src/test/java/org/opensearch/search/SearchModuleTests.java
@@ -70,6 +70,7 @@
 import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.aggregations.support.ValuesSourceRegistry;
 import org.opensearch.search.aggregations.support.ValuesSourceType;
+import org.opensearch.search.deciders.ConcurrentSearchDecider;
 import org.opensearch.search.fetch.FetchSubPhase;
 import org.opensearch.search.fetch.subphase.ExplainPhase;
 import org.opensearch.search.fetch.subphase.highlight.CustomHighlighter;
@@ -507,6 +508,73 @@ public Optional<ExecutorServiceProvider> getIndexSearcherExecutorProvider() {
         expectThrows(IllegalStateException.class, () -> new SearchModule(Settings.EMPTY, searchPlugins));
     }
 
+    public void testRegisterConcurrentSearchDecidersNoExternalPlugins() {
+        SearchModule searchModule = new SearchModule(Settings.EMPTY, Collections.emptyList());
+        assertEquals(searchModule.getConcurrentSearchDeciders().size(), 0);
+    }
+
+    public void testRegisterConcurrentSearchDecidersExternalPluginsWithNoDeciders() {
+        SearchPlugin plugin1 = new SearchPlugin() {
+            @Override
+            public Optional<ExecutorServiceProvider> getIndexSearcherExecutorProvider() {
+                return Optional.of(mock(ExecutorServiceProvider.class));
+            }
+        };
+        SearchPlugin plugin2 = new SearchPlugin() {
+        };
+
+        List<SearchPlugin> searchPlugins = new ArrayList<>();
+        searchPlugins.add(plugin1);
+        searchPlugins.add(plugin2);
+        SearchModule searchModule = new SearchModule(Settings.EMPTY, searchPlugins);
+
+        assertEquals(searchModule.getConcurrentSearchDeciders().size(), 0);
+    }
+
+    public void testRegisterConcurrentSearchDecidersExternalPluginsWithDeciders() {
+        SearchPlugin pluginDecider1 = new SearchPlugin() {
+            @Override
+            public Optional<ExecutorServiceProvider> getIndexSearcherExecutorProvider() {
+                return Optional.of(mock(ExecutorServiceProvider.class));
+            }
+
+            @Override
+            public ConcurrentSearchDecider getConcurrentSearchDecider() {
+                return mock(ConcurrentSearchDecider.class);
+            }
+        };
+
+        SearchPlugin pluginDecider2 = new SearchPlugin() {
+            @Override
+            public ConcurrentSearchDecider getConcurrentSearchDecider() {
+                return mock(ConcurrentSearchDecider.class);
+            }
+        };
+
+        List<SearchPlugin> searchPlugins = new ArrayList<>();
+        searchPlugins.add(pluginDecider1);
+        searchPlugins.add(pluginDecider2);
+
+        SearchModule searchModule = new SearchModule(Settings.EMPTY, searchPlugins);
+        assertEquals(searchModule.getConcurrentSearchDeciders().size(), 2);
+    }
+
+    public void testRegisterConcurrentSearchDecidersPluginWithNullDecider() {
+        SearchPlugin pluginWithNullDecider = new SearchPlugin() {
+            @Override
+            public ConcurrentSearchDecider getConcurrentSearchDecider() {
+                return null;
+            }
+        };
+
+        List<SearchPlugin> searchPlugins = new ArrayList<>();
+        searchPlugins.add(pluginWithNullDecider);
+        SearchModule searchModule = new SearchModule(Settings.EMPTY, searchPlugins);
+        // null decider is filtered out, so 0 deciders
+        assertEquals(searchModule.getConcurrentSearchDeciders().size(), 0);
+
+    }
+
     private static final String[] NON_DEPRECATED_QUERIES = new String[] {
         "bool",
         "boosting",
diff --git a/server/src/test/java/org/opensearch/search/SearchServiceTests.java b/server/src/test/java/org/opensearch/search/SearchServiceTests.java
index ba1047d3bd349..b6aa033540710 100644
--- a/server/src/test/java/org/opensearch/search/SearchServiceTests.java
+++ b/server/src/test/java/org/opensearch/search/SearchServiceTests.java
@@ -37,6 +37,7 @@
 import org.apache.lucene.search.FieldDoc;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.store.AlreadyClosedException;
+import org.opensearch.OpenSearchException;
 import org.opensearch.action.OriginalIndices;
 import org.opensearch.action.index.IndexResponse;
 import org.opensearch.action.search.ClearScrollRequest;
@@ -53,7 +54,9 @@
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.action.support.PlainActionFuture;
 import org.opensearch.action.support.WriteRequest;
+import org.opensearch.cluster.service.ClusterService;
 import org.opensearch.common.UUIDs;
+import org.opensearch.common.settings.Setting;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.core.action.ActionListener;
@@ -90,8 +93,10 @@
 import org.opensearch.script.Script;
 import org.opensearch.script.ScriptType;
 import org.opensearch.search.aggregations.AggregationBuilders;
+import org.opensearch.search.aggregations.AggregatorFactories;
 import org.opensearch.search.aggregations.InternalAggregation;
 import org.opensearch.search.aggregations.MultiBucketConsumerService;
+import org.opensearch.search.aggregations.SearchContextAggregations;
 import org.opensearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
 import org.opensearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
 import org.opensearch.search.aggregations.support.ValueType;
@@ -138,6 +143,8 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.startsWith;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class SearchServiceTests extends OpenSearchSingleNodeTestCase {
 
@@ -565,6 +572,7 @@ public void testDerivedFieldsSearch() throws IOException {
                 new Script(ScriptType.INLINE, MockScriptEngine.NAME, CustomScriptPlugin.DUMMY_SCRIPT, Collections.emptyMap())
             );
         }
+        indexService.getIndexSettings().isDerivedFieldAllowed();
         final ShardSearchRequest request = new ShardSearchRequest(
             OriginalIndices.NONE,
             searchRequest,
@@ -581,15 +589,96 @@ public void testDerivedFieldsSearch() throws IOException {
             try (SearchContext context = service.createContext(reader, request, null, randomBoolean())) {
                 assertNotNull(context);
                 for (int i = 0; i < 5; i++) {
-                    DerivedFieldType derivedFieldType = (DerivedFieldType) context.getQueryShardContext().getDerivedFieldType("field" + i);
+                    DerivedFieldType derivedFieldType = (DerivedFieldType) context.getQueryShardContext()
+                        .resolveDerivedFieldType("field" + i);
                     assertEquals("field" + i, derivedFieldType.name());
                     assertEquals("date", derivedFieldType.getType());
                 }
-                assertNull(context.getQueryShardContext().getDerivedFieldType("field" + 5));
+                assertNull(context.getQueryShardContext().resolveDerivedFieldType("field" + 5));
             }
         }
     }
 
+    public void testDerivedFieldDisabled() throws IOException {
+        createIndex("index");
+        final SearchService service = getInstanceFromNode(SearchService.class);
+        final IndicesService indicesService = getInstanceFromNode(IndicesService.class);
+        final IndexService indexService = indicesService.indexServiceSafe(resolveIndex("index"));
+        final IndexShard indexShard = indexService.getShard(0);
+
+        SearchRequest searchRequest = new SearchRequest().allowPartialSearchResults(true);
+        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
+        searchRequest.source(searchSourceBuilder);
+
+        searchSourceBuilder.derivedField(
+            "field",
+            "date",
+            new Script(ScriptType.INLINE, MockScriptEngine.NAME, CustomScriptPlugin.DUMMY_SCRIPT, Collections.emptyMap())
+        );
+        indexService.getIndexSettings().isDerivedFieldAllowed();
+        final ShardSearchRequest request = new ShardSearchRequest(
+            OriginalIndices.NONE,
+            searchRequest,
+            indexShard.shardId(),
+            1,
+            new AliasFilter(null, Strings.EMPTY_ARRAY),
+            1.0f,
+            -1,
+            null,
+            null
+        );
+
+        try (ReaderContext reader = createReaderContext(indexService, indexShard)) {
+            SearchContext context = service.createContext(reader, request, null, randomBoolean());
+
+            // nothing disabled, derived field resolved fine
+            assertNotNull(context.getQueryShardContext().resolveDerivedFieldType("field"));
+
+            // disabled using cluster setting, assert create context fails
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().put(SearchService.CLUSTER_ALLOW_DERIVED_FIELD_SETTING.getKey(), false))
+                .get();
+            assertThrows(OpenSearchException.class, () -> service.createContext(reader, request, null, randomBoolean()));
+
+            // dynamically enabled using cluster setting, assert derived field resolved fine
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().put(SearchService.CLUSTER_ALLOW_DERIVED_FIELD_SETTING.getKey(), true))
+                .get();
+            context = service.createContext(reader, request, null, randomBoolean());
+            assertNotNull(context.getQueryShardContext().resolveDerivedFieldType("field"));
+
+            // disabled using index setting, assert create context fails
+            client().admin()
+                .indices()
+                .prepareUpdateSettings("index")
+                .setSettings(Settings.builder().put(IndexSettings.ALLOW_DERIVED_FIELDS.getKey(), false))
+                .get();
+
+            assertThrows(OpenSearchException.class, () -> service.createContext(reader, request, null, randomBoolean()));
+
+            // dynamically enabled using index setting, assert derived field resolved fine
+            client().admin()
+                .indices()
+                .prepareUpdateSettings("index")
+                .setSettings(Settings.builder().put(IndexSettings.ALLOW_DERIVED_FIELDS.getKey(), true))
+                .get();
+
+            context = service.createContext(reader, request, null, randomBoolean());
+            assertNotNull(context.getQueryShardContext().resolveDerivedFieldType("field"));
+
+            // Cleanup
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().putNull(SearchService.CLUSTER_ALLOW_DERIVED_FIELD_SETTING.getKey()))
+                .get();
+        }
+    }
+
     /**
      * test that getting more than the allowed number of script_fields throws an exception
      */
@@ -1224,17 +1313,40 @@ public void testCreateSearchContext() throws IOException {
      * index and cluster settings.
      */
     public void testConcurrentSegmentSearchSearchContext() throws IOException {
-        Boolean[][] scenarios = {
-            // cluster setting, index setting, concurrent search enabled?
-            { null, null, false },
-            { null, false, false },
-            { null, true, true },
-            { true, null, true },
-            { true, false, false },
-            { true, true, true },
-            { false, null, false },
-            { false, false, false },
-            { false, true, true } };
+        Object[][] scenarios = {
+            // cluster setting, index setting, cluster mode setting, concurrent search enabled?, concurrent search executor null?
+            { null, null, null, false, true },
+            { null, false, null, false, true },
+            { null, true, null, true, false },
+            { true, null, null, true, false },
+            { true, false, null, false, true },
+            { true, true, null, true, false },
+            { false, null, null, false, true },
+            { false, false, null, false, true },
+            { false, true, null, true, false },
+
+            // Adding cases with mode set to "none"
+            { null, null, "none", false, true },
+            { true, true, "none", false, true },
+            { false, false, "none", false, true },
+            { true, false, "none", false, true },
+            { false, true, "none", false, true },
+
+            // Adding cases with mode set to "all"
+            { null, null, "all", true, false },
+            { true, true, "all", true, false },
+            { false, false, "all", true, false },
+            { true, false, "all", true, false },
+            { false, true, "all", true, false },
+
+            // Adding cases with mode set to "auto"
+            // auto mode concurrent search is false since request has no aggregation
+            // however concurrentSearchExecutor will not be null
+            { null, null, "auto", false, false },
+            { true, true, "auto", false, false },
+            { false, false, "auto", false, false },
+            { true, false, "auto", false, false },
+            { false, true, "auto", false, false } };
 
         String index = randomAlphaOfLengthBetween(5, 10).toLowerCase(Locale.ROOT);
         IndexService indexService = createIndex(index);
@@ -1256,10 +1368,12 @@ public void testConcurrentSegmentSearchSearchContext() throws IOException {
             Strings.EMPTY_ARRAY
         );
 
-        for (Boolean[] scenario : scenarios) {
-            Boolean clusterSetting = scenario[0];
-            Boolean indexSetting = scenario[1];
-            Boolean concurrentSearchEnabled = scenario[2];
+        for (Object[] scenario : scenarios) {
+            Boolean clusterSetting = (Boolean) scenario[0];
+            Boolean indexSetting = (Boolean) scenario[1];
+            String mode = (String) scenario[2];
+            Boolean concurrentSearchEnabled = (Boolean) scenario[3];
+            Boolean concurrentSearchExecutorNull = (Boolean) scenario[4];
 
             if (clusterSetting == null) {
                 client().admin()
@@ -1291,6 +1405,21 @@ public void testConcurrentSegmentSearchSearchContext() throws IOException {
                     .get();
             }
 
+            // update mode
+            if (mode == null) {
+                client().admin()
+                    .cluster()
+                    .prepareUpdateSettings()
+                    .setTransientSettings(Settings.builder().putNull(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey()))
+                    .get();
+            } else {
+                client().admin()
+                    .cluster()
+                    .prepareUpdateSettings()
+                    .setTransientSettings(Settings.builder().put(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), mode))
+                    .get();
+            }
+
             try (DefaultSearchContext searchContext = service.createSearchContext(request, new TimeValue(System.currentTimeMillis()))) {
                 assertEquals(
                     clusterSetting,
@@ -1311,10 +1440,22 @@ public void testConcurrentSegmentSearchSearchContext() throws IOException {
                         .get()
                         .getSetting(index, IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey())
                 );
+
+                assertEquals(
+                    mode,
+                    client().admin()
+                        .cluster()
+                        .prepareState()
+                        .get()
+                        .getState()
+                        .getMetadata()
+                        .transientSettings()
+                        .get(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), null)
+                );
                 searchContext.evaluateRequestShouldUseConcurrentSearch();
                 assertEquals(concurrentSearchEnabled, searchContext.shouldUseConcurrentSearch());
-                // verify executor nullability with concurrent search enabled/disabled
-                if (concurrentSearchEnabled) {
+                // verify executor nullability
+                if (!concurrentSearchExecutorNull) {
                     assertNotNull(searchContext.searcher().getExecutor());
                 } else {
                     assertNull(searchContext.searcher().getExecutor());
@@ -1325,7 +1466,232 @@ public void testConcurrentSegmentSearchSearchContext() throws IOException {
         client().admin()
             .cluster()
             .prepareUpdateSettings()
-            .setTransientSettings(Settings.builder().putNull(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey()))
+            .setTransientSettings(
+                Settings.builder()
+                    .putNull(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey())
+                    .putNull(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey())
+            )
+            .get();
+        assertSettingDeprecationsAndWarnings(new Setting[] { IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_SETTING });
+    }
+
+    public void testConcurrentSegmentSearchWithRandomizedModeSettings() throws IOException {
+
+        String index = randomAlphaOfLengthBetween(5, 10).toLowerCase(Locale.ROOT);
+        IndexService indexService = createIndex(index);
+        final SearchService service = getInstanceFromNode(SearchService.class);
+        ShardId shardId = new ShardId(indexService.index(), 0);
+        long nowInMillis = System.currentTimeMillis();
+        String clusterAlias = randomBoolean() ? null : randomAlphaOfLengthBetween(3, 10);
+        SearchRequest searchRequest = new SearchRequest();
+        searchRequest.allowPartialSearchResults(randomBoolean());
+        ShardSearchRequest request = new ShardSearchRequest(
+            OriginalIndices.NONE,
+            searchRequest,
+            shardId,
+            indexService.numberOfShards(),
+            AliasFilter.EMPTY,
+            1f,
+            nowInMillis,
+            clusterAlias,
+            Strings.EMPTY_ARRAY
+        );
+
+        String[] modeSettings = { "all", "auto", "none", null };
+
+        // Randomize both index and cluster settings
+        String clusterMode = randomFrom(modeSettings);
+        String indexMode = randomFrom(modeSettings);
+
+        // default to false in case mode setting is not set
+        boolean concurrentSearchEnabled = false;
+        boolean nullExecutor = true;
+
+        boolean aggregationSupportsConcurrent = randomBoolean();
+
+        if (indexMode != null) {
+            concurrentSearchEnabled = !indexMode.equals("none") && aggregationSupportsConcurrent;
+            nullExecutor = indexMode.equals("none");
+        } else if (clusterMode != null) {
+            concurrentSearchEnabled = !clusterMode.equals("none") && aggregationSupportsConcurrent;
+            nullExecutor = clusterMode.equals("none");
+        }
+
+        // Set the cluster setting for mode
+        if (clusterMode == null) {
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().putNull(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey()))
+                .get();
+        } else {
+            client().admin()
+                .cluster()
+                .prepareUpdateSettings()
+                .setTransientSettings(Settings.builder().put(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), clusterMode))
+                .get();
+        }
+
+        // Set the index setting for mode
+        if (indexMode == null) {
+            client().admin()
+                .indices()
+                .prepareUpdateSettings(index)
+                .setSettings(Settings.builder().putNull(IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MODE.getKey()))
+                .get();
+        } else {
+            client().admin()
+                .indices()
+                .prepareUpdateSettings(index)
+                .setSettings(Settings.builder().put(IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MODE.getKey(), indexMode))
+                .get();
+        }
+
+        try (DefaultSearchContext searchContext = service.createSearchContext(request, new TimeValue(System.currentTimeMillis()))) {
+            assertEquals(
+                clusterMode,
+                client().admin()
+                    .cluster()
+                    .prepareState()
+                    .get()
+                    .getState()
+                    .getMetadata()
+                    .transientSettings()
+                    .get(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey())
+            );
+            assertEquals(
+                indexMode,
+                client().admin()
+                    .indices()
+                    .prepareGetSettings(index)
+                    .get()
+                    .getSetting(index, IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MODE.getKey())
+            );
+            SearchContextAggregations mockAggregations = mock(SearchContextAggregations.class);
+            when(mockAggregations.factories()).thenReturn(mock(AggregatorFactories.class));
+            when(mockAggregations.factories().allFactoriesSupportConcurrentSearch()).thenReturn(aggregationSupportsConcurrent);
+
+            // set the aggregations for context
+            searchContext.aggregations(mockAggregations);
+
+            searchContext.evaluateRequestShouldUseConcurrentSearch();
+            // check concurrentSearchenabled based on mode and supportedAggregation is computed correctly
+            assertEquals(concurrentSearchEnabled, searchContext.shouldUseConcurrentSearch());
+
+            // Verify executor nullability based on mode
+            if (!nullExecutor) {
+                assertNotNull(searchContext.searcher().getExecutor());
+            } else {
+                assertNull(searchContext.searcher().getExecutor());
+            }
+        }
+
+        // Cleanup
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(Settings.builder().putNull(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.getKey()))
+            .get();
+
+    }
+
+    /**
+     * Tests that the slice count is calculated correctly when concurrent search is enabled
+     *  If concurrent search enabled -
+     *       pick index level slice count setting if index level setting is set
+     *       else pick default cluster level slice count setting
+     * @throws IOException
+     */
+    public void testConcurrentSegmentSearchSliceCount() throws IOException {
+
+        String index = randomAlphaOfLengthBetween(5, 10).toLowerCase(Locale.ROOT);
+        IndexService indexService = createIndex(index);
+        final SearchService service = getInstanceFromNode(SearchService.class);
+        ClusterService clusterService = getInstanceFromNode(ClusterService.class);
+        ShardId shardId = new ShardId(indexService.index(), 0);
+        long nowInMillis = System.currentTimeMillis();
+        String clusterAlias = randomBoolean() ? null : randomAlphaOfLengthBetween(3, 10);
+        SearchRequest searchRequest = new SearchRequest();
+        searchRequest.allowPartialSearchResults(randomBoolean());
+        ShardSearchRequest request = new ShardSearchRequest(
+            OriginalIndices.NONE,
+            searchRequest,
+            shardId,
+            indexService.numberOfShards(),
+            AliasFilter.EMPTY,
+            1f,
+            nowInMillis,
+            clusterAlias,
+            Strings.EMPTY_ARRAY
+        );
+        // enable concurrent search
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(Settings.builder().put(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey(), true))
+            .get();
+
+        Integer[][] scenarios = {
+            // cluster setting, index setting, expected slice count
+            // expected value null will pick up default value from settings
+            { null, null, clusterService.getClusterSettings().get(SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING) },
+            { 4, null, 4 },
+            { null, 3, 3 },
+            { 4, 3, 3 }, };
+
+        for (Integer[] sliceCounts : scenarios) {
+            Integer clusterSliceCount = sliceCounts[0];
+            Integer indexSliceCount = sliceCounts[1];
+            Integer targetSliceCount = sliceCounts[2];
+
+            if (clusterSliceCount != null) {
+                client().admin()
+                    .cluster()
+                    .prepareUpdateSettings()
+                    .setTransientSettings(
+                        Settings.builder()
+                            .put(SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING.getKey(), clusterSliceCount)
+                    )
+                    .get();
+            } else {
+                client().admin()
+                    .cluster()
+                    .prepareUpdateSettings()
+                    .setTransientSettings(
+                        Settings.builder().putNull(SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING.getKey())
+                    )
+                    .get();
+            }
+            if (indexSliceCount != null) {
+                client().admin()
+                    .indices()
+                    .prepareUpdateSettings(index)
+                    .setSettings(
+                        Settings.builder().put(IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MAX_SLICE_COUNT.getKey(), indexSliceCount)
+                    )
+                    .get();
+            } else {
+                client().admin()
+                    .indices()
+                    .prepareUpdateSettings(index)
+                    .setSettings(Settings.builder().putNull(IndexSettings.INDEX_CONCURRENT_SEGMENT_SEARCH_MAX_SLICE_COUNT.getKey()))
+                    .get();
+            }
+
+            try (DefaultSearchContext searchContext = service.createSearchContext(request, new TimeValue(System.currentTimeMillis()))) {
+                searchContext.evaluateRequestShouldUseConcurrentSearch();
+                assertEquals(targetSliceCount.intValue(), searchContext.getTargetMaxSliceCount());
+            }
+        }
+        // cleanup
+        client().admin()
+            .cluster()
+            .prepareUpdateSettings()
+            .setTransientSettings(
+                Settings.builder()
+                    .putNull(SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.getKey())
+                    .putNull(SearchService.CONCURRENT_SEGMENT_SEARCH_TARGET_MAX_SLICE_COUNT_SETTING.getKey())
+            )
             .get();
     }
 
diff --git a/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregatorTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregatorTests.java
index cf95999ec5086..f6e06cce6e233 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregatorTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregatorTests.java
@@ -1614,7 +1614,7 @@ public void testMultiRangeTraversalNotApplicable() throws IOException {
             },
             true,
             collectCount -> assertTrue(collectCount > 0),
-            true
+            false
         );
     }
 
diff --git a/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogramTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogramTests.java
index 288b22ccfcc92..98c6ac2b3de45 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogramTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/InternalHistogramTests.java
@@ -33,10 +33,15 @@
 package org.opensearch.search.aggregations.bucket.histogram;
 
 import org.apache.lucene.tests.util.TestUtil;
+import org.opensearch.core.common.breaker.CircuitBreaker;
+import org.opensearch.core.common.breaker.CircuitBreakingException;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.BucketOrder;
+import org.opensearch.search.aggregations.InternalAggregation;
 import org.opensearch.search.aggregations.InternalAggregations;
+import org.opensearch.search.aggregations.MultiBucketConsumerService;
 import org.opensearch.search.aggregations.ParsedMultiBucketAggregation;
+import org.opensearch.search.aggregations.pipeline.PipelineAggregator;
 import org.opensearch.test.InternalAggregationTestCase;
 import org.opensearch.test.InternalMultiBucketAggregationTestCase;
 
@@ -47,6 +52,8 @@
 import java.util.Map;
 import java.util.TreeMap;
 
+import org.mockito.Mockito;
+
 public class InternalHistogramTests extends InternalMultiBucketAggregationTestCase<InternalHistogram> {
 
     private boolean keyed;
@@ -123,6 +130,42 @@ public void testHandlesNaN() {
         );
     }
 
+    public void testCircuitBreakerWhenAddEmptyBuckets() {
+        String name = randomAlphaOfLength(5);
+        double interval = 1;
+        double lowerBound = 1;
+        double upperBound = 1026;
+        List<InternalHistogram.Bucket> bucket1 = List.of(
+            new InternalHistogram.Bucket(lowerBound, 1, false, format, InternalAggregations.EMPTY)
+        );
+        List<InternalHistogram.Bucket> bucket2 = List.of(
+            new InternalHistogram.Bucket(upperBound, 1, false, format, InternalAggregations.EMPTY)
+        );
+        BucketOrder order = BucketOrder.key(true);
+        InternalHistogram.EmptyBucketInfo emptyBucketInfo = new InternalHistogram.EmptyBucketInfo(
+            interval,
+            0,
+            lowerBound,
+            upperBound,
+            InternalAggregations.EMPTY
+        );
+        InternalHistogram histogram1 = new InternalHistogram(name, bucket1, order, 0, emptyBucketInfo, format, false, null);
+        InternalHistogram histogram2 = new InternalHistogram(name, bucket2, order, 0, emptyBucketInfo, format, false, null);
+
+        CircuitBreaker breaker = Mockito.mock(CircuitBreaker.class);
+        Mockito.when(breaker.addEstimateBytesAndMaybeBreak(0, "allocated_buckets")).thenThrow(CircuitBreakingException.class);
+
+        MultiBucketConsumerService.MultiBucketConsumer bucketConsumer = new MultiBucketConsumerService.MultiBucketConsumer(0, breaker);
+        InternalAggregation.ReduceContext reduceContext = InternalAggregation.ReduceContext.forFinalReduction(
+            null,
+            null,
+            bucketConsumer,
+            PipelineAggregator.PipelineTree.EMPTY
+        );
+        expectThrows(CircuitBreakingException.class, () -> histogram1.reduce(List.of(histogram1, histogram2), reduceContext));
+        Mockito.verify(breaker, Mockito.times(1)).addEstimateBytesAndMaybeBreak(0, "allocated_buckets");
+    }
+
     @Override
     protected void assertReduced(InternalHistogram reduced, List<InternalHistogram> inputs) {
         TreeMap<Double, Long> expectedCounts = new TreeMap<>();
diff --git a/server/src/test/java/org/opensearch/search/aggregations/bucket/nested/NestedAggregatorTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/nested/NestedAggregatorTests.java
index 406c411494d60..c7fbca538c6ee 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/bucket/nested/NestedAggregatorTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/nested/NestedAggregatorTests.java
@@ -34,6 +34,7 @@
 
 import org.apache.lucene.document.Document;
 import org.apache.lucene.document.Field;
+import org.apache.lucene.document.LongPoint;
 import org.apache.lucene.document.SortedDocValuesField;
 import org.apache.lucene.document.SortedNumericDocValuesField;
 import org.apache.lucene.document.SortedSetDocValuesField;
@@ -45,23 +46,36 @@
 import org.apache.lucene.search.BooleanClause;
 import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.ConstantScoreQuery;
+import org.apache.lucene.search.DocIdSetIterator;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.search.join.ScoreMode;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.tests.index.RandomIndexWriter;
+import org.apache.lucene.util.BitSet;
 import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.FixedBitSet;
 import org.opensearch.common.CheckedConsumer;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.lucene.search.Queries;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.cache.bitset.BitsetFilterCache;
+import org.opensearch.index.mapper.ContentPath;
 import org.opensearch.index.mapper.IdFieldMapper;
 import org.opensearch.index.mapper.KeywordFieldMapper;
 import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.index.mapper.Mapper;
 import org.opensearch.index.mapper.NestedPathFieldMapper;
 import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.index.mapper.ObjectMapper;
 import org.opensearch.index.mapper.SeqNoFieldMapper;
 import org.opensearch.index.mapper.Uid;
 import org.opensearch.index.query.MatchAllQueryBuilder;
+import org.opensearch.index.query.NestedQueryBuilder;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.index.query.TermsQueryBuilder;
+import org.opensearch.index.query.support.NestedScope;
 import org.opensearch.script.MockScriptEngine;
 import org.opensearch.script.Script;
 import org.opensearch.script.ScriptEngine;
@@ -104,20 +118,34 @@
 import java.util.stream.DoubleStream;
 import java.util.stream.LongStream;
 
+import org.mockito.Mockito;
+
 import static java.util.stream.Collectors.toList;
 import static org.opensearch.search.aggregations.AggregationBuilders.max;
 import static org.opensearch.search.aggregations.AggregationBuilders.nested;
+import static org.opensearch.search.aggregations.bucket.nested.NestedAggregator.getParentAndChildId;
+import static org.opensearch.test.InternalAggregationTestCase.DEFAULT_MAX_BUCKETS;
 import static org.hamcrest.Matchers.equalTo;
+import static org.apache.lucene.search.DocIdSetIterator.NO_MORE_DOCS;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
 public class NestedAggregatorTests extends AggregatorTestCase {
 
     private static final String VALUE_FIELD_NAME = "number";
+    private static final String VALUE_FIELD_NAME2 = "number2";
     private static final String NESTED_OBJECT = "nested_object";
     private static final String NESTED_OBJECT2 = "nested_object2";
     private static final String NESTED_AGG = "nestedAgg";
     private static final String MAX_AGG_NAME = "maxAgg";
     private static final String SUM_AGG_NAME = "sumAgg";
     private static final String INVERSE_SCRIPT = "inverse";
+    private static final String OUT_NESTED = "outNested";
+    private static final String OUT_TERMS = "outTerms";
+    private static final String INNER_NESTED = "innerNested";
+    private static final String INNER_TERMS = "innerTerms";
 
     private static final SeqNoFieldMapper.SequenceIDFields sequenceIDFields = SeqNoFieldMapper.SequenceIDFields.emptySeqID();
 
@@ -201,17 +229,22 @@ public void testSingleNestingMax() throws IOException {
             }
             try (IndexReader indexReader = wrapInMockESDirectoryReader(DirectoryReader.open(directory))) {
                 NestedAggregationBuilder nestedBuilder = new NestedAggregationBuilder(NESTED_AGG, NESTED_OBJECT);
-                MaxAggregationBuilder maxAgg = new MaxAggregationBuilder(MAX_AGG_NAME).field(VALUE_FIELD_NAME);
+                MaxAggregationBuilder maxAgg = new MaxAggregationBuilder(MAX_AGG_NAME).field(NESTED_OBJECT + "." + VALUE_FIELD_NAME);
                 nestedBuilder.subAggregation(maxAgg);
-                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(VALUE_FIELD_NAME, NumberFieldMapper.NumberType.LONG);
+                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(
+                    NESTED_OBJECT + "." + VALUE_FIELD_NAME,
+                    NumberFieldMapper.NumberType.LONG
+                );
 
                 InternalNested nested = searchAndReduce(
+                    createIndexSettings(),
                     newSearcher(indexReader, false, true),
                     new MatchAllDocsQuery(),
                     nestedBuilder,
+                    DEFAULT_MAX_BUCKETS,
+                    true,
                     fieldType
                 );
-                assertEquals(expectedNestedDocs, nested.getDocCount());
 
                 assertEquals(NESTED_AGG, nested.getName());
                 assertEquals(expectedNestedDocs, nested.getDocCount());
@@ -240,7 +273,7 @@ public void testDoubleNestingMax() throws IOException {
                     int numNestedDocs = randomIntBetween(0, 20);
                     expectedMaxValue = Math.max(
                         expectedMaxValue,
-                        generateMaxDocs(documents, numNestedDocs, i, NESTED_OBJECT + "." + NESTED_OBJECT2, VALUE_FIELD_NAME)
+                        generateMaxDocs(documents, numNestedDocs, i, NESTED_OBJECT, VALUE_FIELD_NAME)
                     );
                     expectedNestedDocs += numNestedDocs;
 
@@ -253,19 +286,24 @@ public void testDoubleNestingMax() throws IOException {
                 iw.commit();
             }
             try (IndexReader indexReader = wrapInMockESDirectoryReader(DirectoryReader.open(directory))) {
-                NestedAggregationBuilder nestedBuilder = new NestedAggregationBuilder(NESTED_AGG, NESTED_OBJECT + "." + NESTED_OBJECT2);
-                MaxAggregationBuilder maxAgg = new MaxAggregationBuilder(MAX_AGG_NAME).field(VALUE_FIELD_NAME);
+                NestedAggregationBuilder nestedBuilder = new NestedAggregationBuilder(NESTED_AGG, NESTED_OBJECT);
+                MaxAggregationBuilder maxAgg = new MaxAggregationBuilder(MAX_AGG_NAME).field(NESTED_OBJECT + "." + VALUE_FIELD_NAME);
                 nestedBuilder.subAggregation(maxAgg);
 
-                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(VALUE_FIELD_NAME, NumberFieldMapper.NumberType.LONG);
+                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(
+                    NESTED_OBJECT + "." + VALUE_FIELD_NAME,
+                    NumberFieldMapper.NumberType.LONG
+                );
 
                 InternalNested nested = searchAndReduce(
+                    createIndexSettings(),
                     newSearcher(indexReader, false, true),
                     new MatchAllDocsQuery(),
                     nestedBuilder,
+                    DEFAULT_MAX_BUCKETS,
+                    true,
                     fieldType
                 );
-                assertEquals(expectedNestedDocs, nested.getDocCount());
 
                 assertEquals(NESTED_AGG, nested.getName());
                 assertEquals(expectedNestedDocs, nested.getDocCount());
@@ -310,17 +348,22 @@ public void testOrphanedDocs() throws IOException {
             }
             try (IndexReader indexReader = wrapInMockESDirectoryReader(DirectoryReader.open(directory))) {
                 NestedAggregationBuilder nestedBuilder = new NestedAggregationBuilder(NESTED_AGG, NESTED_OBJECT);
-                SumAggregationBuilder sumAgg = new SumAggregationBuilder(SUM_AGG_NAME).field(VALUE_FIELD_NAME);
+                SumAggregationBuilder sumAgg = new SumAggregationBuilder(SUM_AGG_NAME).field(NESTED_OBJECT + "." + VALUE_FIELD_NAME);
                 nestedBuilder.subAggregation(sumAgg);
-                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(VALUE_FIELD_NAME, NumberFieldMapper.NumberType.LONG);
+                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(
+                    NESTED_OBJECT + "." + VALUE_FIELD_NAME,
+                    NumberFieldMapper.NumberType.LONG
+                );
 
                 InternalNested nested = searchAndReduce(
+                    createIndexSettings(),
                     newSearcher(indexReader, false, true),
                     new MatchAllDocsQuery(),
                     nestedBuilder,
+                    DEFAULT_MAX_BUCKETS,
+                    true,
                     fieldType
                 );
-                assertEquals(expectedNestedDocs, nested.getDocCount());
 
                 assertEquals(NESTED_AGG, nested.getName());
                 assertEquals(expectedNestedDocs, nested.getDocCount());
@@ -747,8 +790,24 @@ public void testFieldAlias() throws IOException {
                     max(MAX_AGG_NAME).field(VALUE_FIELD_NAME + "-alias")
                 );
 
-                InternalNested nested = searchAndReduce(newSearcher(indexReader, false, true), new MatchAllDocsQuery(), agg, fieldType);
-                Nested aliasNested = searchAndReduce(newSearcher(indexReader, false, true), new MatchAllDocsQuery(), aliasAgg, fieldType);
+                InternalNested nested = searchAndReduce(
+                    createIndexSettings(),
+                    newSearcher(indexReader, false, true),
+                    new MatchAllDocsQuery(),
+                    agg,
+                    DEFAULT_MAX_BUCKETS,
+                    true,
+                    fieldType
+                );
+                Nested aliasNested = searchAndReduce(
+                    createIndexSettings(),
+                    newSearcher(indexReader, false, true),
+                    new MatchAllDocsQuery(),
+                    aliasAgg,
+                    DEFAULT_MAX_BUCKETS,
+                    true,
+                    fieldType
+                );
 
                 assertEquals(nested, aliasNested);
                 assertEquals(expectedNestedDocs, nested.getDocCount());
@@ -796,13 +855,15 @@ public void testNestedWithPipeline() throws IOException {
                 MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(VALUE_FIELD_NAME, NumberFieldMapper.NumberType.LONG);
 
                 InternalNested nested = searchAndReduce(
+                    createIndexSettings(),
                     newSearcher(indexReader, false, true),
                     new MatchAllDocsQuery(),
                     nestedBuilder,
+                    DEFAULT_MAX_BUCKETS,
+                    true,
                     fieldType
                 );
 
-                assertEquals(expectedNestedDocs, nested.getDocCount());
                 assertEquals(NESTED_AGG, nested.getName());
                 assertEquals(expectedNestedDocs, nested.getDocCount());
 
@@ -853,6 +914,238 @@ public void testNestedUnderTerms() throws IOException {
         }, resellersMappedFields());
     }
 
+    public void testBufferingNestedLeafBucketCollector() throws IOException {
+        int numRootDocs = scaledRandomIntBetween(2, 200);
+        int expectedNestedDocs;
+        String[] bucketKeys;
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory)) {
+                for (int i = 0; i < numRootDocs; i++) {
+
+                    List<Document> documents = new ArrayList<>();
+                    if (randomBoolean()) {
+                        generateDocument(documents, i, NESTED_OBJECT, VALUE_FIELD_NAME, 1);
+                        generateDocument(documents, i, NESTED_OBJECT2, VALUE_FIELD_NAME2, i);
+                    } else {
+                        generateDocument(documents, i, NESTED_OBJECT2, VALUE_FIELD_NAME2, i);
+                        generateDocument(documents, i, NESTED_OBJECT, VALUE_FIELD_NAME, 1);
+                    }
+                    Document document = new Document();
+                    document.add(new Field(IdFieldMapper.NAME, Uid.encodeId(Integer.toString(i)), IdFieldMapper.Defaults.FIELD_TYPE));
+                    document.add(sequenceIDFields.primaryTerm);
+                    documents.add(document);
+                    iw.addDocuments(documents);
+                }
+                iw.commit();
+            }
+            try (IndexReader indexReader = wrapInMockESDirectoryReader(DirectoryReader.open(directory))) {
+                IndexSettings indexSettings = createIndexSettings();
+                MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(
+                    NESTED_OBJECT + "." + VALUE_FIELD_NAME,
+                    NumberFieldMapper.NumberType.LONG
+                );
+                MappedFieldType fieldType1 = new NumberFieldMapper.NumberFieldType(
+                    NESTED_OBJECT2 + "." + VALUE_FIELD_NAME2,
+                    NumberFieldMapper.NumberType.LONG
+                );
+                QueryShardContext queryShardContext = createQueryShardContext(NESTED_OBJECT2, indexSettings, fieldType1);
+                // query
+                expectedNestedDocs = numRootDocs / 2;
+                bucketKeys = new String[expectedNestedDocs];
+                BytesRef[] values = new BytesRef[numRootDocs / 2];
+                for (int i = 0; i < numRootDocs / 2; i++) {
+                    bucketKeys[i] = "" + (i * 2);
+                    values[i] = new BytesRef(bucketKeys[i]);
+                }
+                TermsQueryBuilder termsQueryBuilder = new TermsQueryBuilder(NESTED_OBJECT2 + "." + VALUE_FIELD_NAME2, (Object[]) values);
+                NestedQueryBuilder nestedQueryBuilder = new NestedQueryBuilder(NESTED_OBJECT2, termsQueryBuilder, ScoreMode.None);
+
+                // out nested aggs
+                NestedAggregationBuilder outNestedBuilder = new NestedAggregationBuilder(OUT_NESTED, NESTED_OBJECT);
+                TermsAggregationBuilder outTermsAggregator = new TermsAggregationBuilder(OUT_TERMS).field(
+                    NESTED_OBJECT + "." + VALUE_FIELD_NAME
+                ).size(100);
+                outNestedBuilder.subAggregation(outTermsAggregator);
+
+                // inner nested aggs
+                NestedAggregationBuilder innerNestedBuilder = new NestedAggregationBuilder(INNER_NESTED, NESTED_OBJECT2);
+                TermsAggregationBuilder innerTermsAggregator = new TermsAggregationBuilder(INNER_TERMS).field(
+                    NESTED_OBJECT2 + "." + VALUE_FIELD_NAME2
+                ).size(100);
+                innerNestedBuilder.subAggregation(innerTermsAggregator);
+                outTermsAggregator.subAggregation(innerNestedBuilder);
+
+                InternalNested nested = searchAndReduce(
+                    indexSettings,
+                    newSearcher(indexReader, false, true),
+                    nestedQueryBuilder.toQuery(queryShardContext),
+                    outNestedBuilder,
+                    DEFAULT_MAX_BUCKETS,
+                    true,
+                    fieldType,
+                    fieldType1
+                );
+
+                assertEquals(OUT_NESTED, nested.getName());
+                assertEquals(expectedNestedDocs, nested.getDocCount());
+
+                LongTerms outTerms = (LongTerms) nested.getProperty(OUT_TERMS);
+                assertEquals(1, outTerms.getBuckets().size());
+
+                InternalNested internalNested = (InternalNested) (((Object[]) outTerms.getProperty(INNER_NESTED))[0]);
+                assertEquals(expectedNestedDocs, internalNested.getDocCount());
+
+                LongTerms innerTerms = (LongTerms) internalNested.getProperty(INNER_TERMS);
+                assertEquals(bucketKeys.length, innerTerms.getBuckets().size());
+                for (int i = 0; i < expectedNestedDocs; i++) {
+                    LongTerms.Bucket bucket = innerTerms.getBuckets().get(i);
+                    assertEquals(bucketKeys[i], bucket.getKeyAsString());
+                    assertEquals(1, bucket.getDocCount());
+                }
+            }
+        }
+    }
+
+    private DocIdSetIterator getDocIdSetIterator(int[] value) {
+        int[] bits = new int[value[value.length - 1] + 1];
+        for (int i : value) {
+            bits[i] = 1;
+        }
+        return new DocIdSetIterator() {
+            int index = -1;
+
+            @Override
+            public int docID() {
+                if (index == -1 || index > bits.length || bits[index] != 1) {
+                    return -1;
+                }
+                return index;
+            }
+
+            @Override
+            public int nextDoc() {
+                for (int i = index; i < bits.length; i++) {
+                    if (bits[i] == 1) {
+                        index = i;
+                        return index;
+                    }
+                }
+                index = bits.length;
+                return NO_MORE_DOCS;
+            }
+
+            @Override
+            public int advance(int target) {
+                for (int i = target; i < bits.length; i++) {
+                    if (bits[i] == 1) {
+                        index = i;
+                        return index;
+                    }
+                }
+                index = bits.length;
+                return NO_MORE_DOCS;
+            }
+
+            @Override
+            public long cost() {
+                return bits.length;
+            }
+        };
+    }
+
+    public void testGetParentAndChildId() throws IOException {
+        {
+            // p: parent c: child
+            // [p0], [p1], [c2,p3], [c4,x5,p6], [p7], [p8]
+            BitSet parentDocs = new FixedBitSet(20);
+            parentDocs.set(0);
+            parentDocs.set(1);
+            parentDocs.set(3);
+            parentDocs.set(6);
+            parentDocs.set(7);
+            parentDocs.set(8);
+            DocIdSetIterator childDocs = getDocIdSetIterator(new int[] { 2, 4 });
+
+            Tuple<Integer, Integer> res = getParentAndChildId(parentDocs, childDocs, 0);
+            assertEquals(0, res.v1().intValue());
+            assertEquals(2, res.v2().intValue());
+
+            res = getParentAndChildId(parentDocs, childDocs, 3);
+            assertEquals(3, res.v1().intValue());
+            assertEquals(2, res.v2().intValue());
+
+            res = getParentAndChildId(parentDocs, childDocs, 4);
+            assertEquals(6, res.v1().intValue());
+            assertEquals(4, res.v2().intValue());
+
+            res = getParentAndChildId(parentDocs, childDocs, 8);
+            assertEquals(8, res.v1().intValue());
+            assertEquals(NO_MORE_DOCS, res.v2().intValue());
+        }
+
+        {
+            // p: parent c: child1 d: child2
+            // [p0], [c1,d2,p3], [d4,c5,p6], [c7,d8,p9], [c10,p11]
+            BitSet parentDocs = new FixedBitSet(20);
+            parentDocs.set(0);
+            parentDocs.set(3);
+            parentDocs.set(6);
+            parentDocs.set(9);
+            parentDocs.set(11);
+            {
+                DocIdSetIterator childDocs = getDocIdSetIterator(new int[] { 1, 5, 7, 10 });
+                Tuple<Integer, Integer> res = getParentAndChildId(parentDocs, childDocs, 2);
+                assertEquals(3, res.v1().intValue());
+                assertEquals(1, res.v2().intValue());
+
+                res = getParentAndChildId(parentDocs, childDocs, 4);
+                assertEquals(6, res.v1().intValue());
+                assertEquals(5, res.v2().intValue());
+
+                res = getParentAndChildId(parentDocs, childDocs, 8);
+                assertEquals(9, res.v1().intValue());
+                assertEquals(7, res.v2().intValue());
+            }
+
+            {
+                DocIdSetIterator childDocs = getDocIdSetIterator(new int[] { 2, 4, 8 });
+                Tuple<Integer, Integer> res = getParentAndChildId(parentDocs, childDocs, 1);
+                assertEquals(3, res.v1().intValue());
+                assertEquals(2, res.v2().intValue());
+
+                res = getParentAndChildId(parentDocs, childDocs, 5);
+                assertEquals(6, res.v1().intValue());
+                assertEquals(4, res.v2().intValue());
+
+                res = getParentAndChildId(parentDocs, childDocs, 7);
+                assertEquals(9, res.v1().intValue());
+                assertEquals(8, res.v2().intValue());
+
+                res = getParentAndChildId(parentDocs, childDocs, 10);
+                assertEquals(11, res.v1().intValue());
+                assertEquals(NO_MORE_DOCS, res.v2().intValue());
+            }
+        }
+    }
+
+    protected QueryShardContext createQueryShardContext(String fieldName, IndexSettings indexSettings, MappedFieldType fieldType) {
+        QueryShardContext queryShardContext = mock(QueryShardContext.class);
+        when(queryShardContext.nestedScope()).thenReturn(new NestedScope(indexSettings));
+
+        BitsetFilterCache bitsetFilterCache = new BitsetFilterCache(indexSettings, Mockito.mock(BitsetFilterCache.Listener.class));
+        when(queryShardContext.bitsetFilter(any())).thenReturn(bitsetFilterCache.getBitSetProducer(Queries.newNonNestedFilter()));
+        when(queryShardContext.fieldMapper(anyString())).thenReturn(fieldType);
+        when(queryShardContext.getSearchQuoteAnalyzer(any())).thenCallRealMethod();
+        when(queryShardContext.getSearchAnalyzer(any())).thenCallRealMethod();
+        when(queryShardContext.getIndexSettings()).thenReturn(indexSettings);
+        when(queryShardContext.getObjectMapper(anyString())).thenAnswer(invocation -> {
+            Mapper.BuilderContext context = new Mapper.BuilderContext(indexSettings.getSettings(), new ContentPath());
+            return new ObjectMapper.Builder<>(fieldName).nested(ObjectMapper.Nested.newNested()).build(context);
+        });
+        when(queryShardContext.allowExpensiveQueries()).thenReturn(true);
+        return queryShardContext;
+    }
+
     public static CheckedConsumer<RandomIndexWriter, IOException> buildResellerData(int numProducts, int numResellers) {
         return iw -> {
             for (int p = 0; p < numProducts; p++) {
@@ -893,13 +1186,22 @@ private static double[] generateDocuments(List<Document> documents, int numNeste
             document.add(new Field(IdFieldMapper.NAME, Uid.encodeId(Integer.toString(id)), IdFieldMapper.Defaults.NESTED_FIELD_TYPE));
             document.add(new Field(NestedPathFieldMapper.NAME, path, NestedPathFieldMapper.Defaults.FIELD_TYPE));
             long value = randomNonNegativeLong() % 10000;
-            document.add(new SortedNumericDocValuesField(fieldName, value));
+            document.add(new SortedNumericDocValuesField(path + "." + fieldName, value));
             documents.add(document);
             values[nested] = value;
         }
         return values;
     }
 
+    private static void generateDocument(List<Document> documents, int id, String path, String fieldName, long vales) {
+        Document document = new Document();
+        document.add(new Field(IdFieldMapper.NAME, Uid.encodeId(Integer.toString(id)), IdFieldMapper.Defaults.NESTED_FIELD_TYPE));
+        document.add(new Field(NestedPathFieldMapper.NAME, path, NestedPathFieldMapper.Defaults.FIELD_TYPE));
+        document.add(new SortedNumericDocValuesField(path + "." + fieldName, vales));
+        document.add(new LongPoint(path + "." + fieldName, vales));
+        documents.add(document);
+    }
+
     private List<Document> generateBook(String id, String[] authors, int[] numPages) {
         List<Document> documents = new ArrayList<>();
 
diff --git a/server/src/test/java/org/opensearch/search/aggregations/bucket/range/RangeAggregatorTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/range/RangeAggregatorTests.java
index dd7ae915c3b45..f43fcd037de4f 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/bucket/range/RangeAggregatorTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/range/RangeAggregatorTests.java
@@ -32,34 +32,58 @@
 
 package org.opensearch.search.aggregations.bucket.range;
 
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.IntPoint;
+import org.apache.lucene.document.KeywordField;
 import org.apache.lucene.document.NumericDocValuesField;
 import org.apache.lucene.document.SortedNumericDocValuesField;
 import org.apache.lucene.document.SortedSetDocValuesField;
 import org.apache.lucene.index.DirectoryReader;
 import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.BooleanClause;
+import org.apache.lucene.search.BooleanQuery;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TermQuery;
 import org.apache.lucene.store.Directory;
 import org.apache.lucene.tests.index.RandomIndexWriter;
+import org.apache.lucene.tests.util.TestUtil;
 import org.apache.lucene.util.BytesRef;
 import org.opensearch.common.CheckedConsumer;
+import org.opensearch.core.common.breaker.CircuitBreaker;
+import org.opensearch.core.indices.breaker.NoneCircuitBreakerService;
 import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.mapper.KeywordFieldMapper;
 import org.opensearch.index.mapper.MappedFieldType;
-import org.opensearch.index.mapper.NumberFieldMapper;
+import org.opensearch.index.mapper.NumberFieldMapper.NumberFieldType;
+import org.opensearch.index.mapper.NumberFieldMapper.NumberType;
+import org.opensearch.index.mapper.ParseContext.Document;
+import org.opensearch.search.aggregations.AggregationBuilder;
 import org.opensearch.search.aggregations.AggregatorTestCase;
 import org.opensearch.search.aggregations.CardinalityUpperBound;
+import org.opensearch.search.aggregations.InternalAggregation;
+import org.opensearch.search.aggregations.MultiBucketConsumerService;
+import org.opensearch.search.aggregations.pipeline.PipelineAggregator;
 import org.opensearch.search.aggregations.support.AggregationInspectionHelper;
 
 import java.io.IOException;
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
+import java.util.ArrayList;
 import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
 
 import static java.util.Collections.singleton;
+import static org.opensearch.test.InternalAggregationTestCase.DEFAULT_MAX_BUCKETS;
 import static org.hamcrest.Matchers.equalTo;
 
 public class RangeAggregatorTests extends AggregatorTestCase {
@@ -199,7 +223,7 @@ public void testMissingDateWithNumberField() throws IOException {
             .addRange(-2d, 5d)
             .missing("1979-01-01T00:00:00");
 
-        MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(NUMBER_FIELD_NAME, NumberFieldMapper.NumberType.INTEGER);
+        MappedFieldType fieldType = new NumberFieldType(NUMBER_FIELD_NAME, NumberType.INTEGER);
 
         expectThrows(NumberFormatException.class, () -> testCase(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
             iw.addDocument(singleton(new NumericDocValuesField(NUMBER_FIELD_NAME, 7)));
@@ -212,7 +236,7 @@ public void testUnmappedWithMissingNumber() throws IOException {
             .addRange(-2d, 5d)
             .missing(0L);
 
-        MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(NUMBER_FIELD_NAME, NumberFieldMapper.NumberType.INTEGER);
+        MappedFieldType fieldType = new NumberFieldType(NUMBER_FIELD_NAME, NumberType.INTEGER);
 
         testCase(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
             iw.addDocument(singleton(new NumericDocValuesField(NUMBER_FIELD_NAME, 7)));
@@ -230,7 +254,7 @@ public void testUnmappedWithMissingDate() throws IOException {
             .addRange(-2d, 5d)
             .missing("2020-02-13T10:11:12");
 
-        MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(NUMBER_FIELD_NAME, NumberFieldMapper.NumberType.INTEGER);
+        MappedFieldType fieldType = new NumberFieldType(NUMBER_FIELD_NAME, NumberType.INTEGER);
 
         expectThrows(NumberFormatException.class, () -> testCase(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
             iw.addDocument(singleton(new NumericDocValuesField(NUMBER_FIELD_NAME, 7)));
@@ -257,7 +281,7 @@ public void testBadMissingField() {
             .addRange(-2d, 5d)
             .missing("bogus");
 
-        MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(NUMBER_FIELD_NAME, NumberFieldMapper.NumberType.INTEGER);
+        MappedFieldType fieldType = new NumberFieldType(NUMBER_FIELD_NAME, NumberType.INTEGER);
 
         expectThrows(NumberFormatException.class, () -> testCase(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
             iw.addDocument(singleton(new NumericDocValuesField(NUMBER_FIELD_NAME, 7)));
@@ -270,7 +294,7 @@ public void testUnmappedWithBadMissingField() {
             .addRange(-2d, 5d)
             .missing("bogus");
 
-        MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(NUMBER_FIELD_NAME, NumberFieldMapper.NumberType.INTEGER);
+        MappedFieldType fieldType = new NumberFieldType(NUMBER_FIELD_NAME, NumberType.INTEGER);
 
         expectThrows(NumberFormatException.class, () -> testCase(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
             iw.addDocument(singleton(new NumericDocValuesField(NUMBER_FIELD_NAME, 7)));
@@ -305,12 +329,278 @@ public void testSubAggCollectsFromManyBucketsIfManyRanges() throws IOException {
         });
     }
 
+    public void testOverlappingRanges() throws IOException {
+        testRewriteOptimizationCase(
+            new NumberFieldType(NumberType.DOUBLE.typeName(), NumberType.DOUBLE),
+            new double[][] { { 1, 2 }, { 1, 1.5 }, { 0, 0.5 } },
+            new MatchAllDocsQuery(),
+            new Number[] { 0.1, 1.1, 2.1 },
+            range -> {
+                List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+                assertEquals(3, ranges.size());
+                assertEquals("0.0-0.5", ranges.get(0).getKeyAsString());
+                assertEquals(1, ranges.get(0).getDocCount());
+                assertEquals("1.0-1.5", ranges.get(1).getKeyAsString());
+                assertEquals(1, ranges.get(1).getDocCount());
+                assertEquals("1.0-2.0", ranges.get(2).getKeyAsString());
+                assertEquals(1, ranges.get(2).getDocCount());
+                assertTrue(AggregationInspectionHelper.hasValue(range));
+            },
+            false
+        );
+    }
+
+    /**
+     * @return Map [lower, upper) TO data points
+     */
+    private Map<double[], double[]> buildRandomRanges(double[][] possibleRanges) {
+        Map<double[], double[]> dataSet = new LinkedHashMap<>();
+        for (double[] range : possibleRanges) {
+            double lower = randomDoubleBetween(range[0], range[1], true);
+            double upper = randomDoubleBetween(range[0], range[1], true);
+            if (lower > upper) {
+                double d = lower;
+                lower = upper;
+                upper = d;
+            }
+
+            int dataNumber = randomInt(200);
+            double[] data = new double[dataNumber];
+            for (int i = 0; i < dataNumber; i++) {
+                data[i] = randomDoubleBetween(lower, upper, true);
+            }
+            dataSet.put(new double[] { lower, upper }, data);
+        }
+
+        return dataSet;
+    }
+
+    public void testRandomRanges() throws IOException {
+        Map<double[], double[]> dataSet = buildRandomRanges(new double[][] { { 0, 100 }, { 200, 1000 }, { 1000, 3000 } });
+
+        int size = dataSet.size();
+        double[][] ranges = new double[size][];
+        int[] expected = new int[size];
+        List<Number> dataPoints = new LinkedList<>();
+
+        int i = 0;
+        for (Map.Entry<double[], double[]> entry : dataSet.entrySet()) {
+            ranges[i] = entry.getKey();
+            expected[i] = entry.getValue().length;
+            for (double dataPoint : entry.getValue()) {
+                dataPoints.add(dataPoint);
+            }
+            i++;
+        }
+
+        testRewriteOptimizationCase(
+            new NumberFieldType(NumberType.DOUBLE.typeName(), NumberType.DOUBLE),
+            ranges,
+            new MatchAllDocsQuery(),
+            dataPoints.toArray(new Number[0]),
+            range -> {
+                List<? extends InternalRange.Bucket> rangeBuckets = range.getBuckets();
+                assertEquals(size, rangeBuckets.size());
+                for (int j = 0; j < rangeBuckets.size(); j++) {
+                    assertEquals(expected[j], rangeBuckets.get(j).getDocCount());
+                }
+            },
+            true
+        );
+    }
+
+    public void testDoubleType() throws IOException {
+        testRewriteOptimizationCase(
+            new NumberFieldType(NumberType.DOUBLE.typeName(), NumberType.DOUBLE),
+            new double[][] { { 1, 2 }, { 2, 3 } },
+            new MatchAllDocsQuery(),
+            new Number[] { 0.1, 1.1, 2.1 },
+            range -> {
+                List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+                assertEquals(2, ranges.size());
+                assertEquals("1.0-2.0", ranges.get(0).getKeyAsString());
+                assertEquals(1, ranges.get(0).getDocCount());
+                assertEquals("2.0-3.0", ranges.get(1).getKeyAsString());
+                assertEquals(1, ranges.get(1).getDocCount());
+                assertTrue(AggregationInspectionHelper.hasValue(range));
+            },
+            true
+        );
+    }
+
+    public void testHalfFloatType() throws IOException {
+        testRewriteOptimizationCase(
+            new NumberFieldType(NumberType.HALF_FLOAT.typeName(), NumberType.HALF_FLOAT),
+            new double[][] { { 1, 2 }, { 2, 3 } },
+            new MatchAllDocsQuery(),
+            new Number[] { 0.1, 1.1, 2.1 },
+            range -> {
+                List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+                assertEquals(2, ranges.size());
+                assertEquals("1.0-2.0", ranges.get(0).getKeyAsString());
+                assertEquals(1, ranges.get(0).getDocCount());
+                assertEquals("2.0-3.0", ranges.get(1).getKeyAsString());
+                assertEquals(1, ranges.get(1).getDocCount());
+                assertTrue(AggregationInspectionHelper.hasValue(range));
+            },
+            true
+        );
+    }
+
+    public void testFloatType() throws IOException {
+        testRewriteOptimizationCase(
+            new NumberFieldType(NumberType.FLOAT.typeName(), NumberType.FLOAT),
+            new double[][] { { 1, 2 }, { 2, 3 } },
+            new MatchAllDocsQuery(),
+            new Number[] { 0.1, 1.1, 2.1 },
+            range -> {
+                List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+                assertEquals(2, ranges.size());
+                assertEquals("1.0-2.0", ranges.get(0).getKeyAsString());
+                assertEquals(1, ranges.get(0).getDocCount());
+                assertEquals("2.0-3.0", ranges.get(1).getKeyAsString());
+                assertEquals(1, ranges.get(1).getDocCount());
+                assertTrue(AggregationInspectionHelper.hasValue(range));
+            },
+            true
+        );
+    }
+
+    public void testTopLevelRangeQuery() throws IOException {
+        NumberFieldType fieldType = new NumberFieldType(NumberType.INTEGER.typeName(), NumberType.INTEGER);
+        String fieldName = fieldType.numberType().typeName();
+        Query query = IntPoint.newRangeQuery(fieldName, 5, 20);
+
+        testRewriteOptimizationCase(
+            fieldType,
+            new double[][] { { 0.0, 10.0 }, { 10.0, 20.0 } },
+            query,
+            new Number[] { 0.1, 4.0, 9, 11, 12, 19 },
+            range -> {
+                List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+                assertEquals(2, ranges.size());
+                assertEquals("0.0-10.0", ranges.get(0).getKeyAsString());
+                assertEquals(1, ranges.get(0).getDocCount());
+                assertEquals("10.0-20.0", ranges.get(1).getKeyAsString());
+                assertEquals(3, ranges.get(1).getDocCount());
+                assertTrue(AggregationInspectionHelper.hasValue(range));
+            },
+            false
+        );
+    }
+
+    public void testUnsignedLongType() throws IOException {
+        testRewriteOptimizationCase(
+            new NumberFieldType(NumberType.UNSIGNED_LONG.typeName(), NumberType.UNSIGNED_LONG),
+            new double[][] { { 1, 2 }, { 2, 3 } },
+            new MatchAllDocsQuery(),
+            new Number[] { 0, 1, 2 },
+            range -> {
+                List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+                assertEquals(2, ranges.size());
+                assertEquals("1.0-2.0", ranges.get(0).getKeyAsString());
+                assertEquals(1, ranges.get(0).getDocCount());
+                assertEquals("2.0-3.0", ranges.get(1).getKeyAsString());
+                assertEquals(1, ranges.get(1).getDocCount());
+                assertTrue(AggregationInspectionHelper.hasValue(range));
+            },
+            true
+        );
+
+        testRewriteOptimizationCase(
+            new NumberFieldType(NumberType.UNSIGNED_LONG.typeName(), NumberType.UNSIGNED_LONG),
+            new double[][] { { Double.NEGATIVE_INFINITY, 1 }, { 2, Double.POSITIVE_INFINITY } },
+            new MatchAllDocsQuery(),
+            new Number[] { 0, 1, 2 },
+            range -> {
+                List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+                assertEquals(2, ranges.size());
+                assertEquals("*-1.0", ranges.get(0).getKeyAsString());
+                assertEquals(1, ranges.get(0).getDocCount());
+                assertEquals("2.0-*", ranges.get(1).getKeyAsString());
+                assertEquals(1, ranges.get(1).getDocCount());
+                assertTrue(AggregationInspectionHelper.hasValue(range));
+            },
+            true
+        );
+    }
+
+    /**
+     * Expect no optimization as top level query excludes documents.
+     */
+    public void testTopLevelFilterTermQuery() throws IOException {
+        final String KEYWORD_FIELD_NAME = "route";
+        final NumberFieldType NUM_FIELD_TYPE = new NumberFieldType(NumberType.DOUBLE.typeName(), NumberType.DOUBLE);
+        final NumberType numType = NUM_FIELD_TYPE.numberType();
+
+        BooleanQuery.Builder builder = new BooleanQuery.Builder();
+        builder.setMinimumNumberShouldMatch(0);
+        builder.add(new TermQuery(new Term(KEYWORD_FIELD_NAME, "route1")), BooleanClause.Occur.MUST);
+        Query boolQuery = builder.build();
+
+        List<Document> docList = new ArrayList<>();
+        for (int i = 0; i < 3; i++)
+            docList.add(new Document());
+
+        docList.get(0).addAll(numType.createFields(numType.typeName(), 3.0, true, true, false));
+        docList.get(1).addAll(numType.createFields(numType.typeName(), 11.0, true, true, false));
+        docList.get(2).addAll(numType.createFields(numType.typeName(), 15.0, true, true, false));
+        docList.get(0).add(new KeywordField(KEYWORD_FIELD_NAME, "route1", Field.Store.NO));
+        docList.get(1).add(new KeywordField(KEYWORD_FIELD_NAME, "route1", Field.Store.NO));
+        docList.get(2).add(new KeywordField(KEYWORD_FIELD_NAME, "route2", Field.Store.NO));
+
+        testRewriteOptimizationCase(NUM_FIELD_TYPE, new double[][] { { 0.0, 10.0 }, { 10.0, 20.0 } }, boolQuery, docList, range -> {
+            List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+            assertEquals(2, ranges.size());
+            assertEquals("0.0-10.0", ranges.get(0).getKeyAsString());
+            assertEquals(1, ranges.get(0).getDocCount());
+            assertEquals("10.0-20.0", ranges.get(1).getKeyAsString());
+            assertEquals(1, ranges.get(1).getDocCount());
+            assertTrue(AggregationInspectionHelper.hasValue(range));
+        }, false);
+    }
+
+    /**
+     * Expect optimization as top level query is effective match all.
+     */
+    public void testTopLevelEffectiveMatchAll() throws IOException {
+        final String KEYWORD_FIELD_NAME = "route";
+        final NumberFieldType NUM_FIELD_TYPE = new NumberFieldType(NumberType.DOUBLE.typeName(), NumberType.DOUBLE);
+        final NumberType numType = NUM_FIELD_TYPE.numberType();
+
+        BooleanQuery.Builder builder = new BooleanQuery.Builder();
+        builder.setMinimumNumberShouldMatch(0);
+        builder.add(new TermQuery(new Term(KEYWORD_FIELD_NAME, "route1")), BooleanClause.Occur.MUST);
+        Query boolQuery = builder.build();
+
+        List<Document> docList = new ArrayList<>();
+        for (int i = 0; i < 3; i++)
+            docList.add(new Document());
+
+        docList.get(0).addAll(numType.createFields(numType.typeName(), 3.0, true, true, false));
+        docList.get(1).addAll(numType.createFields(numType.typeName(), 11.0, true, true, false));
+        docList.get(2).addAll(numType.createFields(numType.typeName(), 15.0, true, true, false));
+        docList.get(0).add(new KeywordField(KEYWORD_FIELD_NAME, "route1", Field.Store.NO));
+        docList.get(1).add(new KeywordField(KEYWORD_FIELD_NAME, "route1", Field.Store.NO));
+        docList.get(2).add(new KeywordField(KEYWORD_FIELD_NAME, "route1", Field.Store.NO));
+
+        testRewriteOptimizationCase(NUM_FIELD_TYPE, new double[][] { { 0.0, 10.0 }, { 10.0, 20.0 } }, boolQuery, docList, range -> {
+            List<? extends InternalRange.Bucket> ranges = range.getBuckets();
+            assertEquals(2, ranges.size());
+            assertEquals("0.0-10.0", ranges.get(0).getKeyAsString());
+            assertEquals(1, ranges.get(0).getDocCount());
+            assertEquals("10.0-20.0", ranges.get(1).getKeyAsString());
+            assertEquals(2, ranges.get(1).getDocCount());
+            assertTrue(AggregationInspectionHelper.hasValue(range));
+        }, true);
+    }
+
     private void testCase(
         Query query,
         CheckedConsumer<RandomIndexWriter, IOException> buildIndex,
         Consumer<InternalRange<? extends InternalRange.Bucket, ? extends InternalRange>> verify
     ) throws IOException {
-        MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(NUMBER_FIELD_NAME, NumberFieldMapper.NumberType.INTEGER);
+        MappedFieldType fieldType = new NumberFieldType(NUMBER_FIELD_NAME, NumberType.INTEGER);
         RangeAggregationBuilder aggregationBuilder = new RangeAggregationBuilder("test_range_agg");
         aggregationBuilder.field(NUMBER_FIELD_NAME);
         aggregationBuilder.addRange(0d, 5d);
@@ -323,9 +613,9 @@ private void simpleTestCase(
         Query query,
         Consumer<InternalRange<? extends InternalRange.Bucket, ? extends InternalRange>> verify
     ) throws IOException {
-        MappedFieldType fieldType = new NumberFieldMapper.NumberFieldType(NUMBER_FIELD_NAME, NumberFieldMapper.NumberType.INTEGER);
+        MappedFieldType fieldType = new NumberFieldType(NUMBER_FIELD_NAME, NumberType.INTEGER);
 
-        testCase(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
+        testCase(aggregationBuilder, query, iw -> {
             iw.addDocument(singleton(new SortedNumericDocValuesField(NUMBER_FIELD_NAME, 7)));
             iw.addDocument(singleton(new SortedNumericDocValuesField(NUMBER_FIELD_NAME, 2)));
             iw.addDocument(singleton(new SortedNumericDocValuesField(NUMBER_FIELD_NAME, 3)));
@@ -354,8 +644,106 @@ private void testCase(
                     fieldType
                 );
                 verify.accept(agg);
+            }
+        }
+    }
+
+    private void testRewriteOptimizationCase(
+        NumberFieldType fieldType,
+        double[][] ranges,
+        Query query,
+        Number[] dataPoints,
+        Consumer<InternalRange<? extends InternalRange.Bucket, ? extends InternalRange>> verify,
+        boolean optimized
+    ) throws IOException {
+        NumberType numberType = fieldType.numberType();
+        String fieldName = numberType.typeName();
+        List<Document> docs = new ArrayList<>();
+
+        for (Number dataPoint : dataPoints) {
+            Document doc = new Document();
+            List<Field> fieldList = numberType.createFields(fieldName, dataPoint, true, true, false);
+            for (Field fld : fieldList)
+                doc.add(fld);
+            docs.add(doc);
+        }
+
+        testRewriteOptimizationCase(fieldType, ranges, query, docs, verify, optimized);
+    }
 
+    private void testRewriteOptimizationCase(
+        NumberFieldType fieldType,
+        double[][] ranges,
+        Query query,
+        List<Document> documents,
+        Consumer<InternalRange<? extends InternalRange.Bucket, ? extends InternalRange>> verify,
+        boolean optimized
+    ) throws IOException {
+        NumberType numberType = fieldType.numberType();
+        String fieldName = numberType.typeName();
+        try (Directory directory = newDirectory()) {
+            try (IndexWriter indexWriter = new IndexWriter(directory, new IndexWriterConfig().setCodec(TestUtil.getDefaultCodec()))) {
+                for (Document doc : documents) {
+                    indexWriter.addDocument(doc);
+                }
+            }
+
+            try (IndexReader indexReader = DirectoryReader.open(directory)) {
+                IndexSearcher indexSearcher = newSearcher(indexReader, true, true);
+
+                RangeAggregationBuilder aggregationBuilder = new RangeAggregationBuilder("range").field(fieldName);
+                for (double[] range : ranges) {
+                    aggregationBuilder.addRange(range[0], range[1]);
+                }
+
+                CountingAggregator aggregator = createCountingAggregator(query, aggregationBuilder, indexSearcher, fieldType);
+                aggregator.preCollection();
+                indexSearcher.search(query, aggregator);
+                aggregator.postCollection();
+
+                MultiBucketConsumerService.MultiBucketConsumer reduceBucketConsumer = new MultiBucketConsumerService.MultiBucketConsumer(
+                    Integer.MAX_VALUE,
+                    new NoneCircuitBreakerService().getBreaker(CircuitBreaker.REQUEST)
+                );
+                InternalAggregation.ReduceContext context = InternalAggregation.ReduceContext.forFinalReduction(
+                    aggregator.context().bigArrays(),
+                    getMockScriptService(),
+                    reduceBucketConsumer,
+                    PipelineAggregator.PipelineTree.EMPTY
+                );
+                InternalRange topLevel = (InternalRange) aggregator.buildTopLevel();
+                InternalRange agg = (InternalRange) topLevel.reduce(Collections.singletonList(topLevel), context);
+                doAssertReducedMultiBucketConsumer(agg, reduceBucketConsumer);
+
+                verify.accept(agg);
+
+                if (optimized) {
+                    assertEquals(0, aggregator.getCollectCount().get());
+                } else {
+                    assertTrue(aggregator.getCollectCount().get() > 0);
+                }
             }
         }
     }
+
+    protected CountingAggregator createCountingAggregator(
+        Query query,
+        AggregationBuilder builder,
+        IndexSearcher searcher,
+        MappedFieldType... fieldTypes
+    ) throws IOException {
+        return new CountingAggregator(
+            new AtomicInteger(),
+            createAggregator(
+                query,
+                builder,
+                searcher,
+                new MultiBucketConsumerService.MultiBucketConsumer(
+                    DEFAULT_MAX_BUCKETS,
+                    new NoneCircuitBreakerService().getBreaker(CircuitBreaker.REQUEST)
+                ),
+                fieldTypes
+            )
+        );
+    }
 }
diff --git a/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/DerivedFieldAggregationTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/DerivedFieldAggregationTests.java
new file mode 100644
index 0000000000000..2fb65d7fe3c46
--- /dev/null
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/DerivedFieldAggregationTests.java
@@ -0,0 +1,146 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.terms;
+
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.KeywordField;
+import org.apache.lucene.document.TextField;
+import org.apache.lucene.search.MatchAllDocsQuery;
+import org.opensearch.Version;
+import org.opensearch.cluster.metadata.IndexMetadata;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.core.index.Index;
+import org.opensearch.index.IndexSettings;
+import org.opensearch.index.mapper.DerivedField;
+import org.opensearch.index.mapper.DerivedFieldResolver;
+import org.opensearch.index.mapper.DerivedFieldResolverFactory;
+import org.opensearch.index.mapper.DerivedFieldType;
+import org.opensearch.index.mapper.DerivedFieldValueFetcher;
+import org.opensearch.index.mapper.KeywordFieldMapper;
+import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.index.mapper.MapperService;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.DerivedFieldScript;
+import org.opensearch.script.Script;
+import org.opensearch.search.aggregations.AggregatorTestCase;
+import org.opensearch.search.lookup.LeafSearchLookup;
+import org.opensearch.search.lookup.SearchLookup;
+import org.opensearch.search.lookup.SourceLookup;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+public class DerivedFieldAggregationTests extends AggregatorTestCase {
+
+    private QueryShardContext mockContext;
+    private List<Document> docs;
+
+    private static final String[][] raw_requests = new String[][] {
+        { "40.135.0.0 GET /images/hm_bg.jpg HTTP/1.0", "200", "40.135.0.0" },
+        { "232.0.0.0 GET /images/hm_bg.jpg HTTP/1.0", "400", "232.0.0.0" },
+        { "26.1.0.0 GET /images/hm_bg.jpg HTTP/1.0", "200", "26.1.0.0" },
+        { "247.37.0.0 GET /french/splash_inet.html HTTP/1.0", "400", "247.37.0.0" },
+        { "247.37.0.0 GET /french/splash_inet.html HTTP/1.0", "400", "247.37.0.0" },
+        { "247.37.0.0 GET /french/splash_inet.html HTTP/1.0", "200", "247.37.0.0" } };
+
+    @Before
+    public void init() {
+        super.initValuesSourceRegistry();
+        // Create a mock QueryShardContext
+        mockContext = mock(QueryShardContext.class);
+        when(mockContext.index()).thenReturn(new Index("test_index", "uuid"));
+        when(mockContext.allowExpensiveQueries()).thenReturn(true);
+
+        MapperService mockMapperService = mock(MapperService.class);
+        when(mockContext.getMapperService()).thenReturn(mockMapperService);
+        Settings indexSettings = Settings.builder()
+            .put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT)
+            .put(IndexMetadata.SETTING_NUMBER_OF_SHARDS, 1)
+            .put(IndexMetadata.SETTING_NUMBER_OF_REPLICAS, 1)
+            .build();
+        // Mock IndexSettings
+        IndexSettings mockIndexSettings = new IndexSettings(
+            IndexMetadata.builder("test_index").settings(indexSettings).build(),
+            Settings.EMPTY
+        );
+        when(mockMapperService.getIndexSettings()).thenReturn(mockIndexSettings);
+        when(mockContext.getIndexSettings()).thenReturn(mockIndexSettings);
+        docs = new ArrayList<>();
+        for (String[] request : raw_requests) {
+            Document document = new Document();
+            document.add(new TextField("raw_request", request[0], Field.Store.YES));
+            document.add(new KeywordField("status", request[1], Field.Store.YES));
+            docs.add(document);
+        }
+    }
+
+    public void testSimpleTermsAggregationWithDerivedField() throws IOException {
+        MappedFieldType keywordFieldType = new KeywordFieldMapper.KeywordFieldType("status");
+
+        SearchLookup searchLookup = mock(SearchLookup.class);
+        SourceLookup sourceLookup = new SourceLookup();
+        LeafSearchLookup leafLookup = mock(LeafSearchLookup.class);
+        when(leafLookup.source()).thenReturn(sourceLookup);
+
+        // Mock DerivedFieldScript.Factory
+        DerivedFieldScript.Factory factory = (params, lookup) -> (DerivedFieldScript.LeafFactory) ctx -> {
+            when(searchLookup.getLeafSearchLookup(any())).thenReturn(leafLookup);
+            return new DerivedFieldScript(params, lookup, ctx) {
+                @Override
+                public void execute() {
+                    addEmittedValue(raw_requests[sourceLookup.docId()][1]);
+                }
+
+                @Override
+                public void setDocument(int docid) {
+                    sourceLookup.setSegmentAndDocument(ctx, docid);
+                }
+            };
+        };
+
+        DerivedField derivedField = new DerivedField("derived_field", "keyword", new Script(""));
+        DerivedFieldResolver resolver = DerivedFieldResolverFactory.createResolver(
+            mockContext,
+            Collections.emptyMap(),
+            Collections.singletonList(derivedField),
+            true
+        );
+
+        // spy on the resolved type so we can mock the valuefetcher
+        DerivedFieldType derivedFieldType = spy((DerivedFieldType) resolver.resolve("derived_field"));
+        DerivedFieldScript.LeafFactory leafFactory = factory.newFactory((new Script("")).getParams(), searchLookup);
+        DerivedFieldValueFetcher valueFetcher = new DerivedFieldValueFetcher(leafFactory, null);
+        doReturn(valueFetcher).when(derivedFieldType).valueFetcher(any(), any(), any());
+
+        TermsAggregationBuilder aggregationBuilder = new TermsAggregationBuilder("derived_terms").field("status").size(10);
+
+        testCase(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
+            for (Document d : docs) {
+                iw.addDocument(d);
+            }
+        }, (InternalTerms result) -> {
+            assertEquals(2, result.getBuckets().size());
+            List<Terms.Bucket> buckets = result.getBuckets();
+            assertEquals("200", buckets.get(0).getKey());
+            assertEquals(3, buckets.get(0).getDocCount());
+            assertEquals("400", buckets.get(1).getKey());
+            assertEquals(3, buckets.get(1).getDocCount());
+        }, keywordFieldType, derivedFieldType);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/search/aggregations/support/IncludeExcludeTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/IncludeExcludeTests.java
similarity index 58%
rename from server/src/test/java/org/opensearch/search/aggregations/support/IncludeExcludeTests.java
rename to server/src/test/java/org/opensearch/search/aggregations/bucket/terms/IncludeExcludeTests.java
index f223648de6ef4..2356e2dc6d855 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/support/IncludeExcludeTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/terms/IncludeExcludeTests.java
@@ -30,7 +30,7 @@
  * GitHub history for details.
  */
 
-package org.opensearch.search.aggregations.support;
+package org.opensearch.search.aggregations.bucket.terms;
 
 import org.apache.lucene.index.DocValues;
 import org.apache.lucene.index.SortedSetDocValues;
@@ -44,13 +44,14 @@
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.fielddata.AbstractSortedSetDocValues;
 import org.opensearch.search.DocValueFormat;
-import org.opensearch.search.aggregations.bucket.terms.IncludeExclude;
 import org.opensearch.search.aggregations.bucket.terms.IncludeExclude.OrdinalsFilter;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.io.IOException;
 import java.util.Collections;
+import java.util.SortedSet;
 import java.util.TreeSet;
+import java.util.concurrent.atomic.LongAdder;
 
 public class IncludeExcludeTests extends OpenSearchTestCase {
 
@@ -297,4 +298,251 @@ private IncludeExclude serializeMixedRegex(IncludeExclude incExc) throws IOExcep
         }
     }
 
+    private static BytesRef[] toBytesRefArray(String... values) {
+        BytesRef[] bytesRefs = new BytesRef[values.length];
+        for (int i = 0; i < values.length; i++) {
+            bytesRefs[i] = new BytesRef(values[i]);
+        }
+        return bytesRefs;
+    }
+
+    public void testPrefixOrds() throws IOException {
+        IncludeExclude includeExclude = new IncludeExclude("(color|length|size):.*", "color:g.*");
+
+        OrdinalsFilter ordinalsFilter = includeExclude.convertToOrdinalsFilter(DocValueFormat.RAW);
+
+        // Which of the following match the filter or not?
+        BytesRef[] bytesRefs = toBytesRefArray(
+            "color:blue", // true
+            "color:crimson", // true
+            "color:green", // false (excluded)
+            "color:gray", // false (excluded)
+            "depth:10in", // false
+            "depth:12in", // false
+            "depth:17in", // false
+            "length:long", // true
+            "length:medium", // true
+            "length:short", // true
+            "material:cotton", // false
+            "material:linen", // false
+            "material:polyester", // false
+            "size:large", // true
+            "size:medium", // true
+            "size:small", // true
+            "width:13in", // false
+            "width:27in", // false
+            "width:55in" // false
+        );
+        boolean[] expectedFilter = new boolean[] {
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false };
+
+        LongAdder lookupCount = new LongAdder();
+        SortedSetDocValues sortedSetDocValues = new AbstractSortedSetDocValues() {
+            @Override
+            public boolean advanceExact(int target) {
+                return false;
+            }
+
+            @Override
+            public long nextOrd() {
+                return 0;
+            }
+
+            @Override
+            public int docValueCount() {
+                return 1;
+            }
+
+            @Override
+            public BytesRef lookupOrd(long ord) {
+                lookupCount.increment();
+                int ordIndex = Math.toIntExact(ord);
+                return bytesRefs[ordIndex];
+            }
+
+            @Override
+            public long getValueCount() {
+                return bytesRefs.length;
+            }
+        };
+
+        LongBitSet acceptedOrds = ordinalsFilter.acceptedGlobalOrdinals(sortedSetDocValues);
+        long prefixLookupCount = lookupCount.longValue();
+        assertEquals(expectedFilter.length, acceptedOrds.length());
+        for (int i = 0; i < expectedFilter.length; i++) {
+            assertEquals(expectedFilter[i], acceptedOrds.get(i));
+        }
+
+        // Now repeat, but this time, the prefix optimization won't work (because of the .+ on the exclude filter)
+        includeExclude = new IncludeExclude("(color|length|size):.*", "color:g.+");
+        ordinalsFilter = includeExclude.convertToOrdinalsFilter(DocValueFormat.RAW);
+        acceptedOrds = ordinalsFilter.acceptedGlobalOrdinals(sortedSetDocValues);
+        long regexpLookupCount = lookupCount.longValue() - prefixLookupCount;
+
+        // The filter should be functionally the same
+        assertEquals(expectedFilter.length, acceptedOrds.length());
+        for (int i = 0; i < expectedFilter.length; i++) {
+            assertEquals(expectedFilter[i], acceptedOrds.get(i));
+        }
+
+        // But the full regexp requires more lookups
+        assertTrue(regexpLookupCount > prefixLookupCount);
+    }
+
+    public void testExtractPrefixes() {
+        // Positive tests
+        assertEquals(bytesRefs("a"), IncludeExclude.extractPrefixes("a.*", 1000));
+        assertEquals(bytesRefs("a", "b"), IncludeExclude.extractPrefixes("(a|b).*", 1000));
+        assertEquals(bytesRefs("ab"), IncludeExclude.extractPrefixes("a(b).*", 1000));
+        assertEquals(bytesRefs("ab", "ac"), IncludeExclude.extractPrefixes("a(b|c).*", 1000));
+        assertEquals(bytesRefs("aabb", "aacc"), IncludeExclude.extractPrefixes("aa(bb|cc).*", 1000));
+
+        // No regex means no prefixes
+        assertEquals(bytesRefs(), IncludeExclude.extractPrefixes(null, 1000));
+
+        // Negative tests
+        assertNull(IncludeExclude.extractPrefixes(".*", 1000)); // Literal match-all has no prefixes
+        assertNull(IncludeExclude.extractPrefixes("ab?.*", 1000)); // Don't support optionals ye
+        // The following cover various cases involving infinite possible prefixes
+        assertNull(IncludeExclude.extractPrefixes("ab*.*", 1000));
+        assertNull(IncludeExclude.extractPrefixes("a*(b|c).*", 1000));
+        assertNull(IncludeExclude.extractPrefixes("a(b*|c)d.*", 1000));
+        assertNull(IncludeExclude.extractPrefixes("a(b|c*)d.*", 1000));
+        assertNull(IncludeExclude.extractPrefixes("a(b|c*)d*.*", 1000));
+
+        // Test with too many possible prefixes -- 10 * 10 * 10 + 1 > 1000
+        assertNull(
+            IncludeExclude.extractPrefixes(
+                "((a1|a2|a3|a4|a5|a6|a7|a8|a9|a10)" + "(b1|b2|b3|b4|b5|b6|b7|b8|b9|b10)" + "(c1|c2|c3|c4|c5|c6|c7|c8|c9|c10)|x).*",
+                1000
+            )
+        );
+        // Test with too many possible prefixes -- 10 * 10 * 11 > 1000
+        assertNull(
+            IncludeExclude.extractPrefixes(
+                "((a1|a2|a3|a4|a5|a6|a7|a8|a9|a10)" + "(b1|b2|b3|b4|b5|b6|b7|b8|b9|b10)" + "(c1|c2|c3|c4|c5|c6|c7|c8|c9|c10|c11)).*",
+                1000
+            )
+        );
+    }
+
+    private static SortedSet<BytesRef> bytesRefs(String... strings) {
+        SortedSet<BytesRef> bytesRefs = new TreeSet<>();
+        for (String string : strings) {
+            bytesRefs.add(new BytesRef(string));
+        }
+        return bytesRefs;
+    }
+
+    private static SortedSetDocValues toDocValues(BytesRef[] bytesRefs) {
+        return new AbstractSortedSetDocValues() {
+            @Override
+            public boolean advanceExact(int target) {
+                return false;
+            }
+
+            @Override
+            public long nextOrd() {
+                return 0;
+            }
+
+            @Override
+            public int docValueCount() {
+                return 1;
+            }
+
+            @Override
+            public BytesRef lookupOrd(long ord) {
+                int ordIndex = Math.toIntExact(ord);
+                return bytesRefs[ordIndex];
+            }
+
+            @Override
+            public long getValueCount() {
+                return bytesRefs.length;
+            }
+        };
+    }
+
+    public void testOnlyIncludeExcludePrefix() throws IOException {
+        String incExcString = "(color:g|width:).*";
+        IncludeExclude excludeOnly = new IncludeExclude(null, incExcString);
+
+        OrdinalsFilter ordinalsFilter = excludeOnly.convertToOrdinalsFilter(DocValueFormat.RAW);
+        // Which of the following match the filter or not?
+        BytesRef[] bytesRefs = toBytesRefArray(
+            "color:blue", // true
+            "color:crimson", // true
+            "color:green", // false (excluded)
+            "color:gray", // false (excluded)
+            "depth:10in", // true
+            "depth:12in", // true
+            "depth:17in", // true
+            "length:long", // true
+            "length:medium", // true
+            "length:short", // true
+            "material:cotton", // true
+            "material:linen", // true
+            "material:polyester", // true
+            "size:large", // true
+            "size:medium", // true
+            "size:small", // true
+            "width:13in", // false
+            "width:27in", // false
+            "width:55in" // false
+        );
+        boolean[] expectedFilter = new boolean[] {
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false };
+        LongBitSet longBitSet = ordinalsFilter.acceptedGlobalOrdinals(toDocValues(bytesRefs));
+
+        for (int i = 0; i < expectedFilter.length; i++) {
+            assertEquals(expectedFilter[i], longBitSet.get(i));
+        }
+
+        // Now repeat, but this time include only.
+        IncludeExclude includeOnly = new IncludeExclude(incExcString, null);
+        ordinalsFilter = includeOnly.convertToOrdinalsFilter(DocValueFormat.RAW);
+        longBitSet = ordinalsFilter.acceptedGlobalOrdinals(toDocValues(bytesRefs));
+
+        // The previously excluded ordinals should be included and vice versa.
+        for (int i = 0; i < expectedFilter.length; i++) {
+            assertEquals(!expectedFilter[i], longBitSet.get(i));
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/search/aggregations/metrics/CardinalityAggregatorTests.java b/server/src/test/java/org/opensearch/search/aggregations/metrics/CardinalityAggregatorTests.java
index cdd17e2fa7dd6..b5dd27e37c332 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/metrics/CardinalityAggregatorTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/metrics/CardinalityAggregatorTests.java
@@ -33,30 +33,56 @@
 package org.opensearch.search.aggregations.metrics;
 
 import org.apache.lucene.document.BinaryDocValuesField;
+import org.apache.lucene.document.Field;
 import org.apache.lucene.document.IntPoint;
+import org.apache.lucene.document.KeywordField;
 import org.apache.lucene.document.NumericDocValuesField;
 import org.apache.lucene.document.SortedNumericDocValuesField;
+import org.apache.lucene.document.SortedSetDocValuesField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.NoMergePolicy;
+import org.apache.lucene.index.Term;
 import org.apache.lucene.search.DocValuesFieldExistsQuery;
+import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TermQuery;
+import org.apache.lucene.store.Directory;
 import org.apache.lucene.tests.index.RandomIndexWriter;
+import org.apache.lucene.tests.util.TestUtil;
+import org.apache.lucene.util.BytesRef;
 import org.opensearch.common.CheckedConsumer;
 import org.opensearch.common.geo.GeoPoint;
+import org.opensearch.core.common.breaker.CircuitBreaker;
+import org.opensearch.core.indices.breaker.NoneCircuitBreakerService;
+import org.opensearch.index.mapper.KeywordFieldMapper;
 import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.index.mapper.NumberFieldMapper;
 import org.opensearch.index.mapper.RangeFieldMapper;
 import org.opensearch.index.mapper.RangeType;
 import org.opensearch.search.aggregations.AggregationBuilder;
 import org.opensearch.search.aggregations.AggregatorTestCase;
+import org.opensearch.search.aggregations.InternalAggregation;
+import org.opensearch.search.aggregations.MultiBucketConsumerService;
+import org.opensearch.search.aggregations.pipeline.PipelineAggregator;
 import org.opensearch.search.aggregations.support.AggregationInspectionHelper;
 
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
 
+import static java.util.Arrays.asList;
 import static java.util.Collections.singleton;
+import static org.opensearch.test.InternalAggregationTestCase.DEFAULT_MAX_BUCKETS;
+import static org.mockito.Mockito.when;
 
 public class CardinalityAggregatorTests extends AggregatorTestCase {
 
@@ -199,4 +225,276 @@ private void testAggregation(
     ) throws IOException {
         testCase(aggregationBuilder, query, buildIndex, verify, fieldType);
     }
+
+    public void testDynamicPruningDisabledWhenExceedingThreshold() throws IOException {
+        final String fieldName = "testField";
+        final String filterFieldName = "filterField";
+
+        MappedFieldType fieldType = new KeywordFieldMapper.KeywordFieldType(fieldName);
+        final CardinalityAggregationBuilder aggregationBuilder = new CardinalityAggregationBuilder("_name").field(fieldName);
+
+        int randomCardinality = randomIntBetween(20, 100);
+        AtomicInteger counter = new AtomicInteger();
+
+        testDynamicPruning(aggregationBuilder, new TermQuery(new Term(filterFieldName, "foo")), iw -> {
+            for (int i = 0; i < randomCardinality; i++) {
+                String filterValue = "foo";
+                if (randomBoolean()) {
+                    filterValue = "bar";
+                    counter.getAndIncrement();
+                }
+                iw.addDocument(
+                    asList(
+                        new KeywordField(filterFieldName, filterValue, Field.Store.NO),
+                        new KeywordField(fieldName, String.valueOf(i), Field.Store.NO),
+                        new SortedSetDocValuesField(fieldName, new BytesRef(String.valueOf(i)))
+                    )
+                );
+            }
+        },
+            card -> { assertEquals(randomCardinality - counter.get(), card.getValue(), 0); },
+            fieldType,
+            10,
+            (collectCount) -> assertEquals(randomCardinality - counter.get(), (int) collectCount)
+        );
+    }
+
+    public void testDynamicPruningFixedValues() throws IOException {
+        final String fieldName = "testField";
+        final String filterFieldName = "filterField";
+
+        MappedFieldType fieldType = new KeywordFieldMapper.KeywordFieldType(fieldName);
+        final CardinalityAggregationBuilder aggregationBuilder = new CardinalityAggregationBuilder("_name").field(fieldName);
+        testDynamicPruning(aggregationBuilder, new TermQuery(new Term(filterFieldName, "foo")), iw -> {
+            iw.addDocument(
+                asList(
+                    new KeywordField(fieldName, "1", Field.Store.NO),
+                    new KeywordField(fieldName, "2", Field.Store.NO),
+                    new KeywordField(filterFieldName, "foo", Field.Store.NO),
+                    new SortedSetDocValuesField(fieldName, new BytesRef("1")),
+                    new SortedSetDocValuesField(fieldName, new BytesRef("2"))
+                )
+            );
+            iw.addDocument(
+                asList(
+                    new KeywordField(fieldName, "2", Field.Store.NO),
+                    new KeywordField(filterFieldName, "foo", Field.Store.NO),
+                    new SortedSetDocValuesField(fieldName, new BytesRef("2"))
+                )
+            );
+            iw.addDocument(
+                asList(
+                    new KeywordField(fieldName, "1", Field.Store.NO),
+                    new KeywordField(filterFieldName, "foo", Field.Store.NO),
+                    new SortedSetDocValuesField(fieldName, new BytesRef("1"))
+                )
+            );
+            iw.addDocument(
+                asList(
+                    new KeywordField(fieldName, "2", Field.Store.NO),
+                    new KeywordField(filterFieldName, "foo", Field.Store.NO),
+                    new SortedSetDocValuesField(fieldName, new BytesRef("2"))
+                )
+            );
+            iw.addDocument(
+                asList(
+                    new KeywordField(fieldName, "3", Field.Store.NO),
+                    new KeywordField(filterFieldName, "foo", Field.Store.NO),
+                    new SortedSetDocValuesField(fieldName, new BytesRef("3"))
+                )
+            );
+            iw.addDocument(
+                asList(
+                    new KeywordField(fieldName, "4", Field.Store.NO),
+                    new KeywordField(filterFieldName, "bar", Field.Store.NO),
+                    new SortedSetDocValuesField(fieldName, new BytesRef("4"))
+                )
+            );
+            iw.addDocument(
+                asList(
+                    new KeywordField(fieldName, "5", Field.Store.NO),
+                    new KeywordField(filterFieldName, "bar", Field.Store.NO),
+                    new SortedSetDocValuesField(fieldName, new BytesRef("5"))
+                )
+            );
+        }, card -> {
+            assertEquals(3.0, card.getValue(), 0);
+            assertTrue(AggregationInspectionHelper.hasValue(card));
+        }, fieldType, 100, (collectCount) -> assertEquals(0, (int) collectCount));
+    }
+
+    public void testDynamicPruningRandomValues() throws IOException {
+        final String fieldName = "testField";
+        final String filterFieldName = "filterField";
+
+        MappedFieldType fieldType = new KeywordFieldMapper.KeywordFieldType(fieldName);
+        final CardinalityAggregationBuilder aggregationBuilder = new CardinalityAggregationBuilder("_name").field(fieldName);
+
+        int randomCardinality = randomIntBetween(1, 100);
+        AtomicInteger counter = new AtomicInteger();
+
+        testDynamicPruning(aggregationBuilder, new TermQuery(new Term(filterFieldName, "foo")), iw -> {
+            for (int i = 0; i < randomCardinality; i++) {
+                String filterValue = "foo";
+                if (randomBoolean()) {
+                    filterValue = "bar";
+                    counter.getAndIncrement();
+                }
+                iw.addDocument(
+                    asList(
+                        new KeywordField(filterFieldName, filterValue, Field.Store.NO),
+                        new KeywordField(fieldName, String.valueOf(i), Field.Store.NO),
+                        new SortedSetDocValuesField(fieldName, new BytesRef(String.valueOf(i)))
+                    )
+                );
+            }
+        }, card -> {
+            logger.info("expected {}, cardinality: {}", randomCardinality - counter.get(), card.getValue());
+            assertEquals(randomCardinality - counter.get(), card.getValue(), 0);
+        }, fieldType, 100, (collectCount) -> assertEquals(0, (int) collectCount));
+    }
+
+    public void testDynamicPruningRandomDelete() throws IOException {
+        final String fieldName = "testField";
+
+        MappedFieldType fieldType = new KeywordFieldMapper.KeywordFieldType(fieldName);
+        final CardinalityAggregationBuilder aggregationBuilder = new CardinalityAggregationBuilder("_name").field(fieldName);
+
+        int randomCardinality = randomIntBetween(1, 100);
+        AtomicInteger counter = new AtomicInteger();
+
+        testDynamicPruning(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
+            for (int i = 0; i < randomCardinality; i++) {
+                iw.addDocument(
+                    asList(
+                        new KeywordField(fieldName, String.valueOf(i), Field.Store.NO),
+                        new SortedSetDocValuesField(fieldName, new BytesRef(String.valueOf(i)))
+                    )
+                );
+                if (randomBoolean()) {
+                    iw.deleteDocuments(new Term(fieldName, String.valueOf(i)));
+                    counter.getAndIncrement();
+                }
+            }
+        },
+            card -> { assertEquals(randomCardinality - counter.get(), card.getValue(), 0); },
+            fieldType,
+            100,
+            (collectCount) -> assertEquals(0, (int) collectCount)
+        );
+    }
+
+    public void testDynamicPruningFieldMissingInSegment() throws IOException {
+        final String fieldName = "testField";
+        final String fieldName2 = "testField2";
+
+        MappedFieldType fieldType = new KeywordFieldMapper.KeywordFieldType(fieldName);
+        final CardinalityAggregationBuilder aggregationBuilder = new CardinalityAggregationBuilder("_name").field(fieldName);
+
+        int randomNumSegments = randomIntBetween(1, 50);
+        logger.info("Indexing [{}] segments", randomNumSegments);
+
+        testDynamicPruning(aggregationBuilder, new MatchAllDocsQuery(), iw -> {
+            for (int i = 0; i < randomNumSegments; i++) {
+                iw.addDocument(
+                    asList(
+                        new KeywordField(fieldName, String.valueOf(i), Field.Store.NO),
+                        new SortedSetDocValuesField(fieldName, new BytesRef(String.valueOf(i)))
+                    )
+                );
+                iw.commit();
+            }
+            iw.addDocument(List.of(new KeywordField(fieldName2, "100", Field.Store.NO)));
+            iw.addDocument(List.of(new KeywordField(fieldName2, "101", Field.Store.NO)));
+            iw.addDocument(List.of(new KeywordField(fieldName2, "102", Field.Store.NO)));
+            iw.commit();
+        },
+            card -> { assertEquals(randomNumSegments, card.getValue(), 0); },
+            fieldType,
+            100,
+            (collectCount) -> assertEquals(3, (int) collectCount)
+        );
+    }
+
+    private void testDynamicPruning(
+        AggregationBuilder aggregationBuilder,
+        Query query,
+        CheckedConsumer<IndexWriter, IOException> buildIndex,
+        Consumer<InternalCardinality> verify,
+        MappedFieldType fieldType,
+        int pruningThreshold,
+        Consumer<Integer> verifyCollectCount
+    ) throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (
+                IndexWriter indexWriter = new IndexWriter(
+                    directory,
+                    new IndexWriterConfig().setCodec(TestUtil.getDefaultCodec()).setMergePolicy(NoMergePolicy.INSTANCE)
+                )
+            ) {
+                // disable merge so segment number is same as commit times
+                buildIndex.accept(indexWriter);
+            }
+
+            try (IndexReader indexReader = DirectoryReader.open(directory)) {
+                IndexSearcher indexSearcher = newSearcher(indexReader, true, true);
+
+                CountingAggregator aggregator = createCountingAggregator(
+                    query,
+                    aggregationBuilder,
+                    indexSearcher,
+                    fieldType,
+                    pruningThreshold
+                );
+                aggregator.preCollection();
+                indexSearcher.search(query, aggregator);
+                aggregator.postCollection();
+
+                MultiBucketConsumerService.MultiBucketConsumer reduceBucketConsumer = new MultiBucketConsumerService.MultiBucketConsumer(
+                    Integer.MAX_VALUE,
+                    new NoneCircuitBreakerService().getBreaker(CircuitBreaker.REQUEST)
+                );
+                InternalAggregation.ReduceContext context = InternalAggregation.ReduceContext.forFinalReduction(
+                    aggregator.context().bigArrays(),
+                    getMockScriptService(),
+                    reduceBucketConsumer,
+                    PipelineAggregator.PipelineTree.EMPTY
+                );
+                InternalCardinality topLevel = (InternalCardinality) aggregator.buildTopLevel();
+                InternalCardinality card = (InternalCardinality) topLevel.reduce(Collections.singletonList(topLevel), context);
+                doAssertReducedMultiBucketConsumer(card, reduceBucketConsumer);
+
+                verify.accept(card);
+
+                logger.info("aggregator collect count {}", aggregator.getCollectCount().get());
+                verifyCollectCount.accept(aggregator.getCollectCount().get());
+            }
+        }
+    }
+
+    protected CountingAggregator createCountingAggregator(
+        Query query,
+        AggregationBuilder builder,
+        IndexSearcher searcher,
+        MappedFieldType fieldType,
+        int pruningThreshold
+    ) throws IOException {
+        return new CountingAggregator(
+            new AtomicInteger(),
+            createAggregatorWithCustomizableSearchContext(
+                query,
+                builder,
+                searcher,
+                createIndexSettings(),
+                new MultiBucketConsumerService.MultiBucketConsumer(
+                    DEFAULT_MAX_BUCKETS,
+                    new NoneCircuitBreakerService().getBreaker(CircuitBreaker.REQUEST)
+                ),
+                (searchContext) -> {
+                    when(searchContext.cardinalityAggregationPruningThreshold()).thenReturn(pruningThreshold);
+                },
+                fieldType
+            )
+        );
+    }
 }
diff --git a/server/src/test/java/org/opensearch/search/aggregations/support/ValuesSourceConfigTests.java b/server/src/test/java/org/opensearch/search/aggregations/support/ValuesSourceConfigTests.java
index 33d9a63f61a35..568c3c950f588 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/support/ValuesSourceConfigTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/support/ValuesSourceConfigTests.java
@@ -37,9 +37,12 @@
 import org.apache.lucene.util.BytesRef;
 import org.opensearch.action.support.WriteRequest;
 import org.opensearch.common.settings.Settings;
+import org.opensearch.common.xcontent.XContentFactory;
+import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.IndexService;
 import org.opensearch.index.engine.Engine;
 import org.opensearch.index.fielddata.SortedBinaryDocValues;
+import org.opensearch.index.mapper.MapperService;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.test.OpenSearchSingleNodeTestCase;
 
@@ -334,4 +337,40 @@ public void testFieldAlias() throws Exception {
             assertEquals(new BytesRef("value"), values.nextValue());
         }
     }
+
+    public void testDerivedField() throws Exception {
+        String script = "derived_field_script";
+        String derived_field = "derived_keyword";
+
+        XContentBuilder mapping = XContentFactory.jsonBuilder()
+            .startObject()
+            .startObject("derived")
+            .startObject(derived_field)
+            .field("type", "keyword")
+            .startObject("script")
+            .field("source", script)
+            .field("lang", "mockscript")
+            .endObject()
+            .endObject()
+            .endObject()
+            .endObject();
+        IndexService indexService = createIndex("index", Settings.EMPTY, MapperService.SINGLE_MAPPING_NAME, mapping);
+        client().prepareIndex("index").setId("1").setSource("field", "value").setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE).get();
+
+        try (Engine.Searcher searcher = indexService.getShard(0).acquireSearcher("test")) {
+            QueryShardContext context = indexService.newQueryShardContext(0, searcher, () -> 42L, null);
+            ValuesSourceConfig config = ValuesSourceConfig.resolve(
+                context,
+                null,
+                derived_field,
+                null,
+                null,
+                null,
+                null,
+                CoreValuesSourceType.BYTES
+            );
+            assertNotNull(script);
+            assertEquals(ValuesSource.Bytes.Script.class, config.getValuesSource().getClass());
+        }
+    }
 }
diff --git a/server/src/test/java/org/opensearch/search/approximate/ApproximateIndexOrDocValuesQueryTests.java b/server/src/test/java/org/opensearch/search/approximate/ApproximateIndexOrDocValuesQueryTests.java
new file mode 100644
index 0000000000000..47f87c6abf629
--- /dev/null
+++ b/server/src/test/java/org/opensearch/search/approximate/ApproximateIndexOrDocValuesQueryTests.java
@@ -0,0 +1,113 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.approximate;
+
+import org.apache.lucene.document.LongPoint;
+import org.apache.lucene.document.SortedNumericDocValuesField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.search.ConstantScoreWeight;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Weight;
+import org.apache.lucene.store.Directory;
+import org.opensearch.search.internal.SearchContext;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+
+import static org.apache.lucene.document.LongPoint.pack;
+
+public class ApproximateIndexOrDocValuesQueryTests extends OpenSearchTestCase {
+    private Directory dir;
+    private IndexWriter w;
+    private DirectoryReader reader;
+    private IndexSearcher searcher;
+
+    @Before
+    public void initSearcher() throws IOException {
+        dir = newDirectory();
+        w = new IndexWriter(dir, newIndexWriterConfig());
+    }
+
+    @After
+    public void closeAllTheReaders() throws IOException {
+        reader.close();
+        w.close();
+        dir.close();
+    }
+
+    public void testApproximateIndexOrDocValuesQueryWeight() throws IOException {
+
+        long l = Long.MIN_VALUE;
+        long u = Long.MAX_VALUE;
+        Query indexQuery = LongPoint.newRangeQuery("test-index", l, u);
+
+        ApproximateQuery approximateIndexQuery = new ApproximatePointRangeQuery(
+            "test-index",
+            pack(new long[] { l }).bytes,
+            pack(new long[] { u }).bytes,
+            new long[] { l }.length
+        ) {
+            protected String toString(int dimension, byte[] value) {
+                return Long.toString(LongPoint.decodeDimension(value, 0));
+            }
+        };
+
+        Query dvQuery = SortedNumericDocValuesField.newSlowRangeQuery("test-index", l, u);
+
+        ApproximateIndexOrDocValuesQuery approximateIndexOrDocValuesQuery = new ApproximateIndexOrDocValuesQuery(
+            indexQuery,
+            approximateIndexQuery,
+            dvQuery
+        );
+
+        reader = DirectoryReader.open(w);
+        searcher = newSearcher(reader);
+
+        approximateIndexOrDocValuesQuery.resolvedQuery = indexQuery;
+
+        Weight weight = approximateIndexOrDocValuesQuery.rewrite(searcher).createWeight(searcher, ScoreMode.COMPLETE, 1f);
+
+        assertTrue(weight instanceof ConstantScoreWeight);
+
+        ApproximateQuery approximateIndexQueryCanApproximate = new ApproximatePointRangeQuery(
+            "test-index",
+            pack(new long[] { l }).bytes,
+            pack(new long[] { u }).bytes,
+            new long[] { l }.length
+        ) {
+            protected String toString(int dimension, byte[] value) {
+                return Long.toString(LongPoint.decodeDimension(value, 0));
+            }
+
+            public boolean canApproximate(SearchContext context) {
+                return true;
+            }
+        };
+
+        ApproximateIndexOrDocValuesQuery approximateIndexOrDocValuesQueryCanApproximate = new ApproximateIndexOrDocValuesQuery(
+            indexQuery,
+            approximateIndexQueryCanApproximate,
+            dvQuery
+        );
+
+        approximateIndexOrDocValuesQueryCanApproximate.resolvedQuery = approximateIndexQueryCanApproximate;
+
+        Weight approximateIndexOrDocValuesQueryCanApproximateWeight = approximateIndexOrDocValuesQueryCanApproximate.rewrite(searcher)
+            .createWeight(searcher, ScoreMode.COMPLETE, 1f);
+
+        // we get ConstantScoreWeight since we're expecting to call ApproximatePointRangeQuery
+        assertTrue(approximateIndexOrDocValuesQueryCanApproximateWeight instanceof ConstantScoreWeight);
+
+    }
+}
diff --git a/server/src/test/java/org/opensearch/search/approximate/ApproximatePointRangeQueryTests.java b/server/src/test/java/org/opensearch/search/approximate/ApproximatePointRangeQueryTests.java
new file mode 100644
index 0000000000000..4b41079de18ef
--- /dev/null
+++ b/server/src/test/java/org/opensearch/search/approximate/ApproximatePointRangeQueryTests.java
@@ -0,0 +1,349 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.approximate;
+
+import com.carrotsearch.randomizedtesting.generators.RandomNumbers;
+
+import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.LongPoint;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.TopDocs;
+import org.apache.lucene.search.TotalHits;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.tests.index.RandomIndexWriter;
+import org.opensearch.search.internal.SearchContext;
+import org.opensearch.search.sort.SortOrder;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+
+import static org.apache.lucene.document.LongPoint.pack;
+import static org.mockito.Mockito.mock;
+
+public class ApproximatePointRangeQueryTests extends OpenSearchTestCase {
+
+    protected static final String DATE_FIELD_NAME = "mapped_date";
+
+    public void testApproximateRangeEqualsActualRange() throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory, new WhitespaceAnalyzer())) {
+                int dims = 1;
+
+                long[] scratch = new long[dims];
+                for (int i = 0; i < 100; i++) {
+                    int numPoints = RandomNumbers.randomIntBetween(random(), 1, 10);
+                    Document doc = new Document();
+                    for (int j = 0; j < numPoints; j++) {
+                        for (int v = 0; v < dims; v++) {
+                            scratch[v] = RandomNumbers.randomLongBetween(random(), 0, 100);
+                        }
+                        doc.add(new LongPoint("point", scratch));
+                    }
+                    iw.addDocument(doc);
+                }
+                iw.flush();
+                try (IndexReader reader = iw.getReader()) {
+                    try {
+                        long lower = RandomNumbers.randomLongBetween(random(), -100, 200);
+                        long upper = lower + RandomNumbers.randomLongBetween(random(), 0, 100);
+                        Query approximateQuery = new ApproximatePointRangeQuery("point", pack(lower).bytes, pack(upper).bytes, dims) {
+                            protected String toString(int dimension, byte[] value) {
+                                return Long.toString(LongPoint.decodeDimension(value, 0));
+                            }
+                        };
+                        Query query = LongPoint.newRangeQuery("point", lower, upper);
+                        IndexSearcher searcher = new IndexSearcher(reader);
+                        TopDocs topDocs = searcher.search(approximateQuery, 10);
+                        TopDocs topDocs1 = searcher.search(query, 10);
+                        assertEquals(topDocs.totalHits, topDocs1.totalHits);
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                }
+            }
+        }
+    }
+
+    public void testApproximateRangeWithDefaultSize() throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory, new WhitespaceAnalyzer())) {
+                int dims = 1;
+
+                long[] scratch = new long[dims];
+                int numPoints = 1000;
+                for (int i = 0; i < numPoints; i++) {
+                    Document doc = new Document();
+                    for (int v = 0; v < dims; v++) {
+                        scratch[v] = i;
+                    }
+                    doc.add(new LongPoint("point", scratch));
+                    iw.addDocument(doc);
+                    if (i % 15 == 0) iw.flush();
+                }
+                iw.flush();
+                try (IndexReader reader = iw.getReader()) {
+                    try {
+                        long lower = 0;
+                        long upper = 1000;
+                        Query approximateQuery = new ApproximatePointRangeQuery("point", pack(lower).bytes, pack(upper).bytes, dims) {
+                            protected String toString(int dimension, byte[] value) {
+                                return Long.toString(LongPoint.decodeDimension(value, 0));
+                            }
+                        };
+                        IndexSearcher searcher = new IndexSearcher(reader);
+                        TopDocs topDocs = searcher.search(approximateQuery, 10);
+                        assertEquals(topDocs.totalHits, new TotalHits(1000, TotalHits.Relation.EQUAL_TO));
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                }
+            }
+        }
+    }
+
+    public void testApproximateRangeWithSizeUnderDefault() throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory, new WhitespaceAnalyzer())) {
+                int dims = 1;
+
+                long[] scratch = new long[dims];
+                int numPoints = 1000;
+                for (int i = 0; i < numPoints; i++) {
+                    Document doc = new Document();
+                    for (int v = 0; v < dims; v++) {
+                        scratch[v] = i;
+                    }
+                    doc.add(new LongPoint("point", scratch));
+                    iw.addDocument(doc);
+                }
+                iw.flush();
+                iw.forceMerge(1);
+                try (IndexReader reader = iw.getReader()) {
+                    try {
+                        long lower = 0;
+                        long upper = 45;
+                        Query approximateQuery = new ApproximatePointRangeQuery("point", pack(lower).bytes, pack(upper).bytes, dims, 10) {
+                            protected String toString(int dimension, byte[] value) {
+                                return Long.toString(LongPoint.decodeDimension(value, 0));
+                            }
+                        };
+                        IndexSearcher searcher = new IndexSearcher(reader);
+                        TopDocs topDocs = searcher.search(approximateQuery, 10);
+                        assertEquals(topDocs.totalHits, new TotalHits(10, TotalHits.Relation.EQUAL_TO));
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                }
+            }
+        }
+    }
+
+    public void testApproximateRangeWithSizeOverDefault() throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory, new WhitespaceAnalyzer())) {
+                int dims = 1;
+
+                long[] scratch = new long[dims];
+                int numPoints = 15000;
+                for (int i = 0; i < numPoints; i++) {
+                    Document doc = new Document();
+                    for (int v = 0; v < dims; v++) {
+                        scratch[v] = i;
+                    }
+                    doc.add(new LongPoint("point", scratch));
+                    iw.addDocument(doc);
+                }
+                iw.flush();
+                iw.forceMerge(1);
+                try (IndexReader reader = iw.getReader()) {
+                    try {
+                        long lower = 0;
+                        long upper = 12000;
+                        Query approximateQuery = new ApproximatePointRangeQuery(
+                            "point",
+                            pack(lower).bytes,
+                            pack(upper).bytes,
+                            dims,
+                            11_000
+                        ) {
+                            protected String toString(int dimension, byte[] value) {
+                                return Long.toString(LongPoint.decodeDimension(value, 0));
+                            }
+                        };
+                        IndexSearcher searcher = new IndexSearcher(reader);
+                        TopDocs topDocs = searcher.search(approximateQuery, 11000);
+                        assertEquals(topDocs.totalHits, new TotalHits(11000, TotalHits.Relation.EQUAL_TO));
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                }
+            }
+        }
+    }
+
+    public void testApproximateRangeShortCircuit() throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory, new WhitespaceAnalyzer())) {
+                int dims = 1;
+
+                long[] scratch = new long[dims];
+                int numPoints = 1000;
+                for (int i = 0; i < numPoints; i++) {
+                    Document doc = new Document();
+                    for (int v = 0; v < dims; v++) {
+                        scratch[v] = i;
+                    }
+                    doc.add(new LongPoint("point", scratch));
+                    iw.addDocument(doc);
+                    if (i % 10 == 0) iw.flush();
+                }
+                iw.flush();
+                iw.forceMerge(1);
+                try (IndexReader reader = iw.getReader()) {
+                    try {
+                        long lower = 0;
+                        long upper = 100;
+                        Query approximateQuery = new ApproximatePointRangeQuery("point", pack(lower).bytes, pack(upper).bytes, dims, 10) {
+                            protected String toString(int dimension, byte[] value) {
+                                return Long.toString(LongPoint.decodeDimension(value, 0));
+                            }
+                        };
+                        Query query = LongPoint.newRangeQuery("point", lower, upper);
+                        ;
+                        IndexSearcher searcher = new IndexSearcher(reader);
+                        TopDocs topDocs = searcher.search(approximateQuery, 10);
+                        TopDocs topDocs1 = searcher.search(query, 10);
+
+                        // since we short-circuit from the approx range at the end of size these will not be equal
+                        assertNotEquals(topDocs.totalHits, topDocs1.totalHits);
+                        assertEquals(topDocs.totalHits, new TotalHits(10, TotalHits.Relation.EQUAL_TO));
+                        assertEquals(topDocs1.totalHits, new TotalHits(101, TotalHits.Relation.EQUAL_TO));
+
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                }
+            }
+        }
+    }
+
+    public void testApproximateRangeShortCircuitAscSort() throws IOException {
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory, new WhitespaceAnalyzer())) {
+                int dims = 1;
+
+                long[] scratch = new long[dims];
+                int numPoints = 1000;
+                for (int i = 0; i < numPoints; i++) {
+                    Document doc = new Document();
+                    for (int v = 0; v < dims; v++) {
+                        scratch[v] = i;
+                    }
+                    doc.add(new LongPoint("point", scratch));
+                    iw.addDocument(doc);
+                }
+                iw.flush();
+                iw.forceMerge(1);
+                try (IndexReader reader = iw.getReader()) {
+                    try {
+                        long lower = 0;
+                        long upper = 20;
+                        Query approximateQuery = new ApproximatePointRangeQuery(
+                            "point",
+                            pack(lower).bytes,
+                            pack(upper).bytes,
+                            dims,
+                            10,
+                            SortOrder.ASC
+                        ) {
+                            protected String toString(int dimension, byte[] value) {
+                                return Long.toString(LongPoint.decodeDimension(value, 0));
+                            }
+                        };
+                        Query query = LongPoint.newRangeQuery("point", lower, upper);
+                        ;
+                        IndexSearcher searcher = new IndexSearcher(reader);
+                        TopDocs topDocs = searcher.search(approximateQuery, 10);
+                        TopDocs topDocs1 = searcher.search(query, 10);
+
+                        // since we short-circuit from the approx range at the end of size these will not be equal
+                        assertNotEquals(topDocs.totalHits, topDocs1.totalHits);
+                        assertEquals(topDocs.totalHits, new TotalHits(10, TotalHits.Relation.EQUAL_TO));
+                        assertEquals(topDocs1.totalHits, new TotalHits(21, TotalHits.Relation.EQUAL_TO));
+                        assertEquals(topDocs.scoreDocs[0].doc, topDocs1.scoreDocs[0].doc);
+                        assertEquals(topDocs.scoreDocs[1].doc, topDocs1.scoreDocs[1].doc);
+                        assertEquals(topDocs.scoreDocs[2].doc, topDocs1.scoreDocs[2].doc);
+                        assertEquals(topDocs.scoreDocs[3].doc, topDocs1.scoreDocs[3].doc);
+                        assertEquals(topDocs.scoreDocs[4].doc, topDocs1.scoreDocs[4].doc);
+                        assertEquals(topDocs.scoreDocs[5].doc, topDocs1.scoreDocs[5].doc);
+
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                }
+            }
+        }
+    }
+
+    public void testSize() {
+        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery("point", pack(0).bytes, pack(20).bytes, 1) {
+            protected String toString(int dimension, byte[] value) {
+                return Long.toString(LongPoint.decodeDimension(value, 0));
+            }
+        };
+        assertEquals(query.getSize(), 10_000);
+
+        query.setSize(100);
+        assertEquals(query.getSize(), 100);
+
+    }
+
+    public void testSortOrder() {
+        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery("point", pack(0).bytes, pack(20).bytes, 1) {
+            protected String toString(int dimension, byte[] value) {
+                return Long.toString(LongPoint.decodeDimension(value, 0));
+            }
+        };
+        assertNull(query.getSortOrder());
+
+        query.setSortOrder(SortOrder.ASC);
+        assertEquals(query.getSortOrder(), SortOrder.ASC);
+    }
+
+    public void testCanApproximate() {
+        ApproximatePointRangeQuery query = new ApproximatePointRangeQuery("point", pack(0).bytes, pack(20).bytes, 1) {
+            protected String toString(int dimension, byte[] value) {
+                return Long.toString(LongPoint.decodeDimension(value, 0));
+            }
+        };
+
+        assertFalse(query.canApproximate(null));
+
+        ApproximatePointRangeQuery queryCanApproximate = new ApproximatePointRangeQuery("point", pack(0).bytes, pack(20).bytes, 1) {
+            protected String toString(int dimension, byte[] value) {
+                return Long.toString(LongPoint.decodeDimension(value, 0));
+            }
+
+            public boolean canApproximate(SearchContext context) {
+                return true;
+            }
+        };
+        SearchContext searchContext = mock(SearchContext.class);
+        assertTrue(queryCanApproximate.canApproximate(searchContext));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/search/approximate/ApproximateScoreQueryTests.java b/server/src/test/java/org/opensearch/search/approximate/ApproximateScoreQueryTests.java
new file mode 100644
index 0000000000000..aa45ea6744227
--- /dev/null
+++ b/server/src/test/java/org/opensearch/search/approximate/ApproximateScoreQueryTests.java
@@ -0,0 +1,83 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.approximate;
+
+import org.apache.lucene.analysis.core.WhitespaceAnalyzer;
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.LongPoint;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.PointRangeQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Weight;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.tests.index.RandomIndexWriter;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+
+import static org.apache.lucene.document.LongPoint.pack;
+
+public class ApproximateScoreQueryTests extends OpenSearchTestCase {
+
+    public void testApproximationScoreSupplier() throws IOException {
+        long l = Long.MIN_VALUE;
+        long u = Long.MAX_VALUE;
+        Query originalQuery = new PointRangeQuery(
+            "test-index",
+            pack(new long[] { l }).bytes,
+            pack(new long[] { u }).bytes,
+            new long[] { l }.length
+        ) {
+            protected String toString(int dimension, byte[] value) {
+                return Long.toString(LongPoint.decodeDimension(value, 0));
+            }
+        };
+
+        ApproximateQuery approximateQuery = new ApproximatePointRangeQuery(
+            "test-index",
+            pack(new long[] { l }).bytes,
+            pack(new long[] { u }).bytes,
+            new long[] { l }.length
+        ) {
+            protected String toString(int dimension, byte[] value) {
+                return Long.toString(LongPoint.decodeDimension(value, 0));
+            }
+        };
+
+        ApproximateScoreQuery query = new ApproximateScoreQuery(originalQuery, approximateQuery);
+        query.resolvedQuery = approximateQuery;
+
+        try (Directory directory = newDirectory()) {
+            try (RandomIndexWriter iw = new RandomIndexWriter(random(), directory, new WhitespaceAnalyzer())) {
+                Document document = new Document();
+                document.add(new LongPoint("testPoint", Long.MIN_VALUE));
+                iw.addDocument(document);
+                iw.flush();
+                try (IndexReader reader = iw.getReader()) {
+                    try {
+                        IndexSearcher searcher = new IndexSearcher(reader);
+                        searcher.search(query, 10);
+                        Weight weight = query.rewrite(searcher).createWeight(searcher, ScoreMode.TOP_SCORES, 1.0F);
+                        Scorer scorer = weight.scorer(reader.leaves().get(0));
+                        assertEquals(
+                            scorer,
+                            originalQuery.createWeight(searcher, ScoreMode.TOP_SCORES, 1.0F).scorer(searcher.getLeafContexts().get(0))
+                        );
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+
+                }
+            }
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/search/backpressure/SearchBackpressureServiceTests.java b/server/src/test/java/org/opensearch/search/backpressure/SearchBackpressureServiceTests.java
index f0d930c4c3acb..62aec845a3333 100644
--- a/server/src/test/java/org/opensearch/search/backpressure/SearchBackpressureServiceTests.java
+++ b/server/src/test/java/org/opensearch/search/backpressure/SearchBackpressureServiceTests.java
@@ -23,9 +23,11 @@
 import org.opensearch.search.backpressure.stats.SearchBackpressureStats;
 import org.opensearch.search.backpressure.stats.SearchShardTaskStats;
 import org.opensearch.search.backpressure.stats.SearchTaskStats;
-import org.opensearch.search.backpressure.trackers.NodeDuressTracker;
-import org.opensearch.search.backpressure.trackers.TaskResourceUsageTracker;
+import org.opensearch.search.backpressure.trackers.NodeDuressTrackers;
+import org.opensearch.search.backpressure.trackers.NodeDuressTrackers.NodeDuressTracker;
 import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackerType;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 import org.opensearch.tasks.CancellableTask;
 import org.opensearch.tasks.Task;
 import org.opensearch.tasks.TaskCancellation;
@@ -37,11 +39,13 @@
 import org.opensearch.test.transport.MockTransportService;
 import org.opensearch.threadpool.TestThreadPool;
 import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.wlm.ResourceType;
 import org.junit.After;
 import org.junit.Before;
 
 import java.io.IOException;
 import java.util.Collections;
+import java.util.EnumMap;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -53,9 +57,13 @@
 import java.util.function.LongSupplier;
 
 import static org.opensearch.search.backpressure.SearchBackpressureTestHelpers.createMockTaskWithResourceStats;
+import static org.opensearch.wlm.ResourceType.CPU;
+import static org.opensearch.wlm.ResourceType.MEMORY;
 import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyDouble;
+import static org.mockito.Mockito.anyList;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
@@ -89,8 +97,15 @@ public void testIsNodeInDuress() {
 
         AtomicReference<Double> cpuUsage = new AtomicReference<>();
         AtomicReference<Double> heapUsage = new AtomicReference<>();
-        NodeDuressTracker cpuUsageTracker = new NodeDuressTracker(() -> cpuUsage.get() >= 0.5);
-        NodeDuressTracker heapUsageTracker = new NodeDuressTracker(() -> heapUsage.get() >= 0.5);
+        NodeDuressTracker cpuUsageTracker = new NodeDuressTracker(() -> cpuUsage.get() >= 0.5, () -> 3);
+        NodeDuressTracker heapUsageTracker = new NodeDuressTracker(() -> heapUsage.get() >= 0.5, () -> 3);
+
+        EnumMap<ResourceType, NodeDuressTracker> duressTrackers = new EnumMap<>(ResourceType.class) {
+            {
+                put(ResourceType.MEMORY, heapUsageTracker);
+                put(ResourceType.CPU, cpuUsageTracker);
+            }
+        };
 
         SearchBackpressureSettings settings = new SearchBackpressureSettings(
             Settings.EMPTY,
@@ -102,9 +117,9 @@ public void testIsNodeInDuress() {
             mockTaskResourceTrackingService,
             threadPool,
             System::nanoTime,
-            List.of(cpuUsageTracker, heapUsageTracker),
-            Collections.emptyList(),
-            Collections.emptyList(),
+            new NodeDuressTrackers(duressTrackers),
+            new TaskResourceUsageTrackers(),
+            new TaskResourceUsageTrackers(),
             taskManager
         );
 
@@ -132,6 +147,8 @@ public void testTrackerStateUpdateOnSearchTaskCompletion() {
         TaskResourceTrackingService mockTaskResourceTrackingService = mock(TaskResourceTrackingService.class);
         LongSupplier mockTimeNanosSupplier = () -> TimeUnit.SECONDS.toNanos(1234);
         TaskResourceUsageTracker mockTaskResourceUsageTracker = mock(TaskResourceUsageTracker.class);
+        TaskResourceUsageTrackers taskResourceUsageTrackers = new TaskResourceUsageTrackers();
+        taskResourceUsageTrackers.addTracker(mockTaskResourceUsageTracker, TaskResourceUsageTrackerType.CPU_USAGE_TRACKER);
 
         SearchBackpressureSettings settings = new SearchBackpressureSettings(
             Settings.EMPTY,
@@ -143,15 +160,15 @@ public void testTrackerStateUpdateOnSearchTaskCompletion() {
             mockTaskResourceTrackingService,
             threadPool,
             mockTimeNanosSupplier,
-            Collections.emptyList(),
-            List.of(mockTaskResourceUsageTracker),
-            Collections.emptyList(),
+            new NodeDuressTrackers(new EnumMap<>(ResourceType.class)),
+            taskResourceUsageTrackers,
+            new TaskResourceUsageTrackers(),
             taskManager
         );
 
         for (int i = 0; i < 100; i++) {
             // service.onTaskCompleted(new SearchTask(1, "test", "test", () -> "Test", TaskId.EMPTY_TASK_ID, new HashMap<>()));
-            service.onTaskCompleted(createMockTaskWithResourceStats(SearchTask.class, 100, 200));
+            service.onTaskCompleted(createMockTaskWithResourceStats(SearchTask.class, 100, 200, i));
         }
         assertEquals(100, service.getSearchBackpressureState(SearchTask.class).getCompletionCount());
         verify(mockTaskResourceUsageTracker, times(100)).update(any());
@@ -161,6 +178,8 @@ public void testTrackerStateUpdateOnSearchShardTaskCompletion() {
         TaskResourceTrackingService mockTaskResourceTrackingService = mock(TaskResourceTrackingService.class);
         LongSupplier mockTimeNanosSupplier = () -> TimeUnit.SECONDS.toNanos(1234);
         TaskResourceUsageTracker mockTaskResourceUsageTracker = mock(TaskResourceUsageTracker.class);
+        TaskResourceUsageTrackers taskResourceUsageTrackers = new TaskResourceUsageTrackers();
+        taskResourceUsageTrackers.addTracker(mockTaskResourceUsageTracker, TaskResourceUsageTrackerType.CPU_USAGE_TRACKER);
 
         SearchBackpressureSettings settings = new SearchBackpressureSettings(
             Settings.EMPTY,
@@ -172,16 +191,16 @@ public void testTrackerStateUpdateOnSearchShardTaskCompletion() {
             mockTaskResourceTrackingService,
             threadPool,
             mockTimeNanosSupplier,
-            Collections.emptyList(),
-            Collections.emptyList(),
-            List.of(mockTaskResourceUsageTracker),
+            new NodeDuressTrackers(new EnumMap<>(ResourceType.class)),
+            new TaskResourceUsageTrackers(),
+            taskResourceUsageTrackers,
             taskManager
         );
 
         // Record task completions to update the tracker state. Tasks other than SearchTask & SearchShardTask are ignored.
-        service.onTaskCompleted(createMockTaskWithResourceStats(CancellableTask.class, 100, 200));
+        service.onTaskCompleted(createMockTaskWithResourceStats(CancellableTask.class, 100, 200, 101));
         for (int i = 0; i < 100; i++) {
-            service.onTaskCompleted(createMockTaskWithResourceStats(SearchShardTask.class, 100, 200));
+            service.onTaskCompleted(createMockTaskWithResourceStats(SearchShardTask.class, 100, 200, i));
         }
         assertEquals(100, service.getSearchBackpressureState(SearchShardTask.class).getCompletionCount());
         verify(mockTaskResourceUsageTracker, times(100)).update(any());
@@ -192,21 +211,41 @@ public void testSearchTaskInFlightCancellation() {
         TaskResourceTrackingService mockTaskResourceTrackingService = mock(TaskResourceTrackingService.class);
         AtomicLong mockTime = new AtomicLong(0);
         LongSupplier mockTimeNanosSupplier = mockTime::get;
-        NodeDuressTracker mockNodeDuressTracker = new NodeDuressTracker(() -> true);
+        NodeDuressTracker mockNodeDuressTracker = new NodeDuressTracker(() -> true, () -> 3);
 
-        TaskResourceUsageTracker mockTaskResourceUsageTracker = getMockedTaskResourceUsageTracker();
+        TaskResourceUsageTracker mockTaskResourceUsageTracker = getMockedTaskResourceUsageTracker(
+            TaskResourceUsageTrackerType.CPU_USAGE_TRACKER,
+            (task) -> {
+                if (task.getTotalResourceStats().getCpuTimeInNanos() < 300) {
+                    return Optional.empty();
+                }
+
+                return Optional.of(new TaskCancellation.Reason("limits exceeded", 5));
+            }
+        );
+        TaskResourceUsageTrackers taskResourceUsageTrackers = new TaskResourceUsageTrackers();
+        taskResourceUsageTrackers.addTracker(mockTaskResourceUsageTracker, TaskResourceUsageTrackerType.CPU_USAGE_TRACKER);
 
         // Mocking 'settings' with predictable rate limiting thresholds.
         SearchBackpressureSettings settings = getBackpressureSettings("enforced", 0.1, 0.003, 5.0);
 
+        NodeDuressTracker heapUsageTracker = new NodeDuressTracker(() -> false, () -> 3);
+
+        EnumMap<ResourceType, NodeDuressTracker> duressTrackers = new EnumMap<>(ResourceType.class) {
+            {
+                put(MEMORY, heapUsageTracker);
+                put(CPU, mockNodeDuressTracker);
+            }
+        };
+
         SearchBackpressureService service = new SearchBackpressureService(
             settings,
             mockTaskResourceTrackingService,
             threadPool,
             mockTimeNanosSupplier,
-            List.of(mockNodeDuressTracker),
-            List.of(mockTaskResourceUsageTracker),
-            Collections.emptyList(),
+            new NodeDuressTrackers(duressTrackers),
+            taskResourceUsageTrackers,
+            new TaskResourceUsageTrackers(),
             mockTaskManager
         );
 
@@ -225,9 +264,9 @@ public void testSearchTaskInFlightCancellation() {
         Map<Long, Task> activeSearchTasks = new HashMap<>();
         for (long i = 0; i < 75; i++) {
             if (i % 3 == 0) {
-                activeSearchTasks.put(i, createMockTaskWithResourceStats(SearchTask.class, 500, taskHeapUsageBytes));
+                activeSearchTasks.put(i, createMockTaskWithResourceStats(SearchTask.class, 500, taskHeapUsageBytes, i));
             } else {
-                activeSearchTasks.put(i, createMockTaskWithResourceStats(SearchTask.class, 100, taskHeapUsageBytes));
+                activeSearchTasks.put(i, createMockTaskWithResourceStats(SearchTask.class, 100, taskHeapUsageBytes, i));
             }
         }
         doReturn(activeSearchTasks).when(mockTaskResourceTrackingService).getResourceAwareTasks();
@@ -264,9 +303,28 @@ public void testSearchShardTaskInFlightCancellation() {
         TaskResourceTrackingService mockTaskResourceTrackingService = mock(TaskResourceTrackingService.class);
         AtomicLong mockTime = new AtomicLong(0);
         LongSupplier mockTimeNanosSupplier = mockTime::get;
-        NodeDuressTracker mockNodeDuressTracker = new NodeDuressTracker(() -> true);
+        NodeDuressTracker mockNodeDuressTracker = new NodeDuressTracker(() -> true, () -> 3);
 
-        TaskResourceUsageTracker mockTaskResourceUsageTracker = getMockedTaskResourceUsageTracker();
+        EnumMap<ResourceType, NodeDuressTracker> duressTrackers = new EnumMap<>(ResourceType.class) {
+            {
+                put(MEMORY, new NodeDuressTracker(() -> false, () -> 3));
+                put(CPU, mockNodeDuressTracker);
+            }
+        };
+        NodeDuressTrackers nodeDuressTrackers = new NodeDuressTrackers(duressTrackers);
+
+        TaskResourceUsageTracker mockTaskResourceUsageTracker = getMockedTaskResourceUsageTracker(
+            TaskResourceUsageTrackerType.CPU_USAGE_TRACKER,
+            (task) -> {
+                if (task.getTotalResourceStats().getCpuTimeInNanos() < 300) {
+                    return Optional.empty();
+                }
+
+                return Optional.of(new TaskCancellation.Reason("limits exceeded", 5));
+            }
+        );
+        TaskResourceUsageTrackers taskResourceUsageTrackers = new TaskResourceUsageTrackers();
+        taskResourceUsageTrackers.addTracker(mockTaskResourceUsageTracker, TaskResourceUsageTrackerType.CPU_USAGE_TRACKER);
 
         // Mocking 'settings' with predictable rate limiting thresholds.
         SearchBackpressureSettings settings = getBackpressureSettings("enforced", 0.1, 0.003, 10.0);
@@ -276,9 +334,9 @@ public void testSearchShardTaskInFlightCancellation() {
             mockTaskResourceTrackingService,
             threadPool,
             mockTimeNanosSupplier,
-            List.of(mockNodeDuressTracker),
-            Collections.emptyList(),
-            List.of(mockTaskResourceUsageTracker),
+            nodeDuressTrackers,
+            new TaskResourceUsageTrackers(),
+            taskResourceUsageTrackers,
             mockTaskManager
         );
 
@@ -297,9 +355,9 @@ public void testSearchShardTaskInFlightCancellation() {
         Map<Long, Task> activeSearchShardTasks = new HashMap<>();
         for (long i = 0; i < 75; i++) {
             if (i % 5 == 0) {
-                activeSearchShardTasks.put(i, createMockTaskWithResourceStats(SearchShardTask.class, 500, taskHeapUsageBytes));
+                activeSearchShardTasks.put(i, createMockTaskWithResourceStats(SearchShardTask.class, 500, taskHeapUsageBytes, i));
             } else {
-                activeSearchShardTasks.put(i, createMockTaskWithResourceStats(SearchShardTask.class, 100, taskHeapUsageBytes));
+                activeSearchShardTasks.put(i, createMockTaskWithResourceStats(SearchShardTask.class, 100, taskHeapUsageBytes, i));
             }
         }
         doReturn(activeSearchShardTasks).when(mockTaskResourceTrackingService).getResourceAwareTasks();
@@ -317,7 +375,7 @@ public void testSearchShardTaskInFlightCancellation() {
         // Simulate task completion to replenish some tokens.
         // This will add 2 tokens (task count delta * cancellationRatio) to 'rateLimitPerTaskCompletion'.
         for (int i = 0; i < 20; i++) {
-            service.onTaskCompleted(createMockTaskWithResourceStats(SearchShardTask.class, 100, taskHeapUsageBytes));
+            service.onTaskCompleted(createMockTaskWithResourceStats(SearchShardTask.class, 100, taskHeapUsageBytes, i));
         }
         service.doRun();
         verify(mockTaskManager, times(12)).cancelTaskAndDescendants(any(), anyString(), anyBoolean(), any());
@@ -333,6 +391,180 @@ public void testSearchShardTaskInFlightCancellation() {
         assertEquals(expectedStats, actualStats);
     }
 
+    public void testNonCancellationOfHeapBasedTasksWhenHeapNotInDuress() {
+        TaskManager mockTaskManager = spy(taskManager);
+        TaskResourceTrackingService mockTaskResourceTrackingService = mock(TaskResourceTrackingService.class);
+        AtomicLong mockTime = new AtomicLong(0);
+        LongSupplier mockTimeNanosSupplier = mockTime::get;
+
+        EnumMap<ResourceType, NodeDuressTracker> duressTrackers = new EnumMap<>(ResourceType.class) {
+            {
+                put(MEMORY, new NodeDuressTracker(() -> false, () -> 3));
+                put(CPU, new NodeDuressTracker(() -> true, () -> 3));
+            }
+        };
+
+        NodeDuressTrackers nodeDuressTrackers = new NodeDuressTrackers(duressTrackers);
+
+        // Creating heap and cpu usage trackers where heap tracker will always evaluate with reasons to cancel the
+        // tasks but heap based cancellation should not happen because heap is not in duress
+        TaskResourceUsageTracker heapUsageTracker = getMockedTaskResourceUsageTracker(
+            TaskResourceUsageTrackerType.HEAP_USAGE_TRACKER,
+            (task) -> Optional.of(new TaskCancellation.Reason("mem exceeded", 10))
+        );
+        TaskResourceUsageTracker cpuUsageTracker = getMockedTaskResourceUsageTracker(
+            TaskResourceUsageTrackerType.CPU_USAGE_TRACKER,
+            (task) -> {
+                if (task.getTotalResourceStats().getCpuTimeInNanos() < 400) {
+                    return Optional.empty();
+                }
+                return Optional.of(new TaskCancellation.Reason("cpu time limit exceeded", 5));
+            }
+        );
+
+        TaskResourceUsageTrackers taskResourceUsageTrackers = new TaskResourceUsageTrackers();
+        taskResourceUsageTrackers.addTracker(cpuUsageTracker, TaskResourceUsageTrackerType.CPU_USAGE_TRACKER);
+        taskResourceUsageTrackers.addTracker(heapUsageTracker, TaskResourceUsageTrackerType.HEAP_USAGE_TRACKER);
+
+        // Mocking 'settings' with predictable rate limiting thresholds.
+        SearchBackpressureSettings settings = getBackpressureSettings("enforced", 0.1, 0.003, 10.0);
+
+        SearchBackpressureService service = new SearchBackpressureService(
+            settings,
+            mockTaskResourceTrackingService,
+            threadPool,
+            mockTimeNanosSupplier,
+            nodeDuressTrackers,
+            taskResourceUsageTrackers,
+            new TaskResourceUsageTrackers(),
+            mockTaskManager
+        );
+
+        service.doRun();
+        service.doRun();
+
+        SearchTaskSettings searchTaskSettings = mock(SearchTaskSettings.class);
+        // setting the total heap percent threshold to minimum so that circuit does not break in SearchBackpressureService
+        when(searchTaskSettings.getTotalHeapPercentThreshold()).thenReturn(0.0);
+        when(settings.getSearchTaskSettings()).thenReturn(searchTaskSettings);
+
+        // Create a mix of low and high resource usage tasks (60 low + 15 high resource usage tasks).
+        Map<Long, Task> activeSearchTasks = new HashMap<>();
+        for (long i = 0; i < 75; i++) {
+            if (i % 5 == 0) {
+                activeSearchTasks.put(i, createMockTaskWithResourceStats(SearchTask.class, 500, 800, i));
+            } else {
+                activeSearchTasks.put(i, createMockTaskWithResourceStats(SearchTask.class, 100, 800, i));
+            }
+        }
+        doReturn(activeSearchTasks).when(mockTaskResourceTrackingService).getResourceAwareTasks();
+
+        // this will trigger cancellation but these cancellation should only be cpu based
+        service.doRun();
+        verify(mockTaskManager, times(5)).cancelTaskAndDescendants(any(), anyString(), anyBoolean(), any());
+        assertEquals(5, service.getSearchBackpressureState(SearchTask.class).getCancellationCount());
+        assertEquals(1, service.getSearchBackpressureState(SearchTask.class).getLimitReachedCount());
+
+        SearchBackpressureStats expectedStats = new SearchBackpressureStats(
+            new SearchTaskStats(
+                5,
+                1,
+                Map.of(
+                    TaskResourceUsageTrackerType.CPU_USAGE_TRACKER,
+                    new MockStats(5),
+                    TaskResourceUsageTrackerType.HEAP_USAGE_TRACKER,
+                    new MockStats(0)
+                )
+            ),
+            new SearchShardTaskStats(0, 0, Collections.emptyMap()),
+            SearchBackpressureMode.ENFORCED
+        );
+
+        SearchBackpressureStats actualStats = service.nodeStats();
+        assertEquals(expectedStats, actualStats);
+    }
+
+    public void testNonCancellationWhenSearchTrafficIsNotQualifyingForCancellation() {
+        TaskManager mockTaskManager = spy(taskManager);
+        TaskResourceTrackingService mockTaskResourceTrackingService = mock(TaskResourceTrackingService.class);
+        AtomicLong mockTime = new AtomicLong(0);
+        LongSupplier mockTimeNanosSupplier = mockTime::get;
+
+        EnumMap<ResourceType, NodeDuressTracker> duressTrackers = new EnumMap<>(ResourceType.class) {
+            {
+                put(MEMORY, new NodeDuressTracker(() -> false, () -> 3));
+                put(CPU, new NodeDuressTracker(() -> true, () -> 3));
+            }
+        };
+
+        NodeDuressTrackers nodeDuressTrackers = new NodeDuressTrackers(duressTrackers);
+
+        // Creating heap and cpu usage trackers where heap tracker will always evaluate with reasons to cancel the
+        // tasks but heap based cancellation should not happen because heap is not in duress
+        TaskResourceUsageTracker heapUsageTracker = getMockedTaskResourceUsageTracker(
+            TaskResourceUsageTrackerType.HEAP_USAGE_TRACKER,
+            (task) -> Optional.of(new TaskCancellation.Reason("mem exceeded", 10))
+        );
+        TaskResourceUsageTracker cpuUsageTracker = getMockedTaskResourceUsageTracker(
+            TaskResourceUsageTrackerType.CPU_USAGE_TRACKER,
+            (task) -> {
+                if (task.getTotalResourceStats().getCpuTimeInNanos() < 400) {
+                    return Optional.empty();
+                }
+                return Optional.of(new TaskCancellation.Reason("cpu time limit exceeded", 5));
+            }
+        );
+
+        TaskResourceUsageTrackers taskResourceUsageTrackers = new TaskResourceUsageTrackers();
+        taskResourceUsageTrackers.addTracker(cpuUsageTracker, TaskResourceUsageTrackerType.CPU_USAGE_TRACKER);
+        taskResourceUsageTrackers.addTracker(heapUsageTracker, TaskResourceUsageTrackerType.HEAP_USAGE_TRACKER);
+
+        // Mocking 'settings' with predictable rate limiting thresholds.
+        SearchBackpressureSettings settings = getBackpressureSettings("enforced", 0.1, 0.003, 10.0);
+
+        SearchBackpressureService service = spy(
+            new SearchBackpressureService(
+                settings,
+                mockTaskResourceTrackingService,
+                threadPool,
+                mockTimeNanosSupplier,
+                nodeDuressTrackers,
+                taskResourceUsageTrackers,
+                new TaskResourceUsageTrackers(),
+                mockTaskManager
+            )
+        );
+
+        when(service.isHeapUsageDominatedBySearch(anyList(), anyDouble())).thenReturn(false);
+
+        service.doRun();
+        service.doRun();
+
+        SearchTaskSettings searchTaskSettings = mock(SearchTaskSettings.class);
+        // setting the total heap percent threshold to minimum so that circuit does not break in SearchBackpressureService
+        when(searchTaskSettings.getTotalHeapPercentThreshold()).thenReturn(0.0);
+        when(settings.getSearchTaskSettings()).thenReturn(searchTaskSettings);
+
+        // Create a mix of low and high resource usage tasks (60 low + 15 high resource usage tasks).
+        Map<Long, Task> activeSearchTasks = new HashMap<>();
+        for (long i = 0; i < 75; i++) {
+            Class<? extends CancellableTask> taskType = randomBoolean() ? SearchTask.class : SearchShardTask.class;
+            if (i % 5 == 0) {
+                activeSearchTasks.put(i, createMockTaskWithResourceStats(taskType, 500, 800, i));
+            } else {
+                activeSearchTasks.put(i, createMockTaskWithResourceStats(taskType, 100, 800, i));
+            }
+        }
+        doReturn(activeSearchTasks).when(mockTaskResourceTrackingService).getResourceAwareTasks();
+
+        // this will trigger cancellation but the cancellation should not happen as the node is not is duress because of search traffic
+        service.doRun();
+
+        verify(mockTaskManager, times(0)).cancelTaskAndDescendants(any(), anyString(), anyBoolean(), any());
+        assertEquals(0, service.getSearchBackpressureState(SearchTask.class).getCancellationCount());
+        assertEquals(0, service.getSearchBackpressureState(SearchShardTask.class).getCancellationCount());
+    }
+
     private SearchBackpressureSettings getBackpressureSettings(String mode, double ratio, double rate, double burst) {
         return spy(
             new SearchBackpressureSettings(
@@ -342,11 +574,14 @@ private SearchBackpressureSettings getBackpressureSettings(String mode, double r
         );
     }
 
-    private TaskResourceUsageTracker getMockedTaskResourceUsageTracker() {
+    private TaskResourceUsageTracker getMockedTaskResourceUsageTracker(
+        TaskResourceUsageTrackerType type,
+        TaskResourceUsageTracker.ResourceUsageBreachEvaluator evaluator
+    ) {
         return new TaskResourceUsageTracker() {
             @Override
             public String name() {
-                return TaskResourceUsageTrackerType.CPU_USAGE_TRACKER.getName();
+                return type.getName();
             }
 
             @Override
@@ -354,11 +589,7 @@ public void update(Task task) {}
 
             @Override
             public Optional<TaskCancellation.Reason> checkAndMaybeGetCancellationReason(Task task) {
-                if (task.getTotalResourceStats().getCpuTimeInNanos() < 300) {
-                    return Optional.empty();
-                }
-
-                return Optional.of(new TaskCancellation.Reason("limits exceeded", 5));
+                return evaluator.evaluate(task);
             }
 
             @Override
diff --git a/server/src/test/java/org/opensearch/search/backpressure/stats/SearchShardTaskStatsTests.java b/server/src/test/java/org/opensearch/search/backpressure/stats/SearchShardTaskStatsTests.java
index 6478fdfff61d4..89a743efa09d8 100644
--- a/server/src/test/java/org/opensearch/search/backpressure/stats/SearchShardTaskStatsTests.java
+++ b/server/src/test/java/org/opensearch/search/backpressure/stats/SearchShardTaskStatsTests.java
@@ -12,8 +12,8 @@
 import org.opensearch.search.backpressure.trackers.CpuUsageTracker;
 import org.opensearch.search.backpressure.trackers.ElapsedTimeTracker;
 import org.opensearch.search.backpressure.trackers.HeapUsageTracker;
-import org.opensearch.search.backpressure.trackers.TaskResourceUsageTracker;
 import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackerType;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 import org.opensearch.test.AbstractWireSerializingTestCase;
 
 import java.util.Map;
diff --git a/server/src/test/java/org/opensearch/search/backpressure/stats/SearchTaskStatsTests.java b/server/src/test/java/org/opensearch/search/backpressure/stats/SearchTaskStatsTests.java
index eb33bc1c37b7e..7117e6a33a5af 100644
--- a/server/src/test/java/org/opensearch/search/backpressure/stats/SearchTaskStatsTests.java
+++ b/server/src/test/java/org/opensearch/search/backpressure/stats/SearchTaskStatsTests.java
@@ -12,8 +12,8 @@
 import org.opensearch.search.backpressure.trackers.CpuUsageTracker;
 import org.opensearch.search.backpressure.trackers.ElapsedTimeTracker;
 import org.opensearch.search.backpressure.trackers.HeapUsageTracker;
-import org.opensearch.search.backpressure.trackers.TaskResourceUsageTracker;
 import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackerType;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 import org.opensearch.test.AbstractWireSerializingTestCase;
 
 import java.util.Map;
diff --git a/server/src/test/java/org/opensearch/search/backpressure/trackers/CpuUsageTrackerTests.java b/server/src/test/java/org/opensearch/search/backpressure/trackers/CpuUsageTrackerTests.java
index 8cdcbc7511bd2..0117b0ed71c27 100644
--- a/server/src/test/java/org/opensearch/search/backpressure/trackers/CpuUsageTrackerTests.java
+++ b/server/src/test/java/org/opensearch/search/backpressure/trackers/CpuUsageTrackerTests.java
@@ -33,7 +33,7 @@ public class CpuUsageTrackerTests extends OpenSearchTestCase {
     );
 
     public void testSearchTaskEligibleForCancellation() {
-        Task task = createMockTaskWithResourceStats(SearchTask.class, 100000000, 200);
+        Task task = createMockTaskWithResourceStats(SearchTask.class, 100000000, 200, randomNonNegativeLong());
         CpuUsageTracker tracker = new CpuUsageTracker(mockSettings.getSearchTaskSettings()::getCpuTimeNanosThreshold);
 
         Optional<TaskCancellation.Reason> reason = tracker.checkAndMaybeGetCancellationReason(task);
@@ -43,7 +43,7 @@ public void testSearchTaskEligibleForCancellation() {
     }
 
     public void testSearchShardTaskEligibleForCancellation() {
-        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 200000000, 200);
+        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 200000000, 200, randomNonNegativeLong());
         CpuUsageTracker tracker = new CpuUsageTracker(mockSettings.getSearchShardTaskSettings()::getCpuTimeNanosThreshold);
 
         Optional<TaskCancellation.Reason> reason = tracker.checkAndMaybeGetCancellationReason(task);
@@ -53,7 +53,7 @@ public void testSearchShardTaskEligibleForCancellation() {
     }
 
     public void testNotEligibleForCancellation() {
-        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 5000000, 200);
+        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 5000000, 200, randomNonNegativeLong());
         CpuUsageTracker tracker = new CpuUsageTracker(mockSettings.getSearchShardTaskSettings()::getCpuTimeNanosThreshold);
 
         Optional<TaskCancellation.Reason> reason = tracker.checkAndMaybeGetCancellationReason(task);
diff --git a/server/src/test/java/org/opensearch/search/backpressure/trackers/ElapsedTimeTrackerTests.java b/server/src/test/java/org/opensearch/search/backpressure/trackers/ElapsedTimeTrackerTests.java
index 921d01e7355a7..514f1b4785aa1 100644
--- a/server/src/test/java/org/opensearch/search/backpressure/trackers/ElapsedTimeTrackerTests.java
+++ b/server/src/test/java/org/opensearch/search/backpressure/trackers/ElapsedTimeTrackerTests.java
@@ -47,7 +47,7 @@ public void testSearchTaskEligibleForCancellation() {
     }
 
     public void testSearchShardTaskEligibleForCancellation() {
-        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 1, 0);
+        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 1, 0, randomNonNegativeLong());
         ElapsedTimeTracker tracker = new ElapsedTimeTracker(
             mockSettings.getSearchShardTaskSettings()::getElapsedTimeNanosThreshold,
             () -> 200000000
@@ -60,7 +60,7 @@ public void testSearchShardTaskEligibleForCancellation() {
     }
 
     public void testNotEligibleForCancellation() {
-        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 1, 150000000);
+        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 1, 150000000, randomNonNegativeLong());
         ElapsedTimeTracker tracker = new ElapsedTimeTracker(
             mockSettings.getSearchShardTaskSettings()::getElapsedTimeNanosThreshold,
             () -> 200000000
diff --git a/server/src/test/java/org/opensearch/search/backpressure/trackers/HeapUsageTrackerTests.java b/server/src/test/java/org/opensearch/search/backpressure/trackers/HeapUsageTrackerTests.java
index 3950d00b0c8b5..1c46305e9fda6 100644
--- a/server/src/test/java/org/opensearch/search/backpressure/trackers/HeapUsageTrackerTests.java
+++ b/server/src/test/java/org/opensearch/search/backpressure/trackers/HeapUsageTrackerTests.java
@@ -58,7 +58,7 @@ public void testSearchTaskEligibleForCancellation() {
                 SearchTaskSettings.SETTING_HEAP_MOVING_AVERAGE_WINDOW_SIZE
             )
         );
-        Task task = createMockTaskWithResourceStats(SearchTask.class, 1, 50);
+        Task task = createMockTaskWithResourceStats(SearchTask.class, 1, 50, randomNonNegativeLong());
 
         // Record enough observations to make the moving average 'ready'.
         for (int i = 0; i < HEAP_MOVING_AVERAGE_WINDOW_SIZE; i++) {
@@ -66,7 +66,7 @@ public void testSearchTaskEligibleForCancellation() {
         }
 
         // Task that has heap usage >= heapBytesThreshold and (movingAverage * heapVariance).
-        task = createMockTaskWithResourceStats(SearchTask.class, 1, 300);
+        task = createMockTaskWithResourceStats(SearchTask.class, 1, 300, randomNonNegativeLong());
         Optional<TaskCancellation.Reason> reason = tracker.checkAndMaybeGetCancellationReason(task);
         assertTrue(reason.isPresent());
         assertEquals(6, reason.get().getCancellationScore());
@@ -88,7 +88,7 @@ public void testSearchShardTaskEligibleForCancellation() {
                 SearchShardTaskSettings.SETTING_HEAP_MOVING_AVERAGE_WINDOW_SIZE
             )
         );
-        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 50);
+        Task task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 50, randomNonNegativeLong());
 
         // Record enough observations to make the moving average 'ready'.
         for (int i = 0; i < HEAP_MOVING_AVERAGE_WINDOW_SIZE; i++) {
@@ -96,7 +96,7 @@ public void testSearchShardTaskEligibleForCancellation() {
         }
 
         // Task that has heap usage >= heapBytesThreshold and (movingAverage * heapVariance).
-        task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 200);
+        task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 200, randomNonNegativeLong());
         Optional<TaskCancellation.Reason> reason = tracker.checkAndMaybeGetCancellationReason(task);
         assertTrue(reason.isPresent());
         assertEquals(4, reason.get().getCancellationScore());
@@ -122,7 +122,7 @@ public void testNotEligibleForCancellation() {
         );
 
         // Task with heap usage < heapBytesThreshold.
-        task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 99);
+        task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 99, randomNonNegativeLong());
 
         // Not enough observations.
         reason = tracker.checkAndMaybeGetCancellationReason(task);
@@ -139,7 +139,12 @@ public void testNotEligibleForCancellation() {
 
         // Task with heap usage between heapBytesThreshold and (movingAverage * heapVariance) should not be cancelled.
         double allowedHeapUsage = 99.0 * 2.0;
-        task = createMockTaskWithResourceStats(SearchShardTask.class, 1, randomLongBetween(99, (long) allowedHeapUsage - 1));
+        task = createMockTaskWithResourceStats(
+            SearchShardTask.class,
+            1,
+            randomLongBetween(99, (long) allowedHeapUsage - 1),
+            randomNonNegativeLong()
+        );
         reason = tracker.checkAndMaybeGetCancellationReason(task);
         assertFalse(reason.isPresent());
     }
@@ -148,12 +153,12 @@ public void testIsHeapUsageDominatedBySearch() {
         assumeTrue("Skip the test if the hardware doesn't support heap usage tracking", HeapUsageTracker.isHeapTrackingSupported());
 
         // task with 1 byte of heap usage so that it does not breach the threshold
-        CancellableTask task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 1);
+        CancellableTask task = createMockTaskWithResourceStats(SearchShardTask.class, 1, 1, randomNonNegativeLong());
         assertFalse(HeapUsageTracker.isHeapUsageDominatedBySearch(List.of(task), 0.5));
 
         long totalHeap = JvmStats.jvmStats().getMem().getHeapMax().getBytes();
         // task with heap usage of [totalHeap - 1] so that it breaches the threshold
-        task = createMockTaskWithResourceStats(SearchShardTask.class, 1, totalHeap - 1);
+        task = createMockTaskWithResourceStats(SearchShardTask.class, 1, totalHeap - 1, randomNonNegativeLong());
         assertTrue(HeapUsageTracker.isHeapUsageDominatedBySearch(List.of(task), 0.5));
     }
 }
diff --git a/server/src/test/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackerTests.java b/server/src/test/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackerTests.java
index 472ba95566523..32aca6ac3230e 100644
--- a/server/src/test/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackerTests.java
+++ b/server/src/test/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackerTests.java
@@ -8,6 +8,7 @@
 
 package org.opensearch.search.backpressure.trackers;
 
+import org.opensearch.search.backpressure.trackers.NodeDuressTrackers.NodeDuressTracker;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.concurrent.atomic.AtomicReference;
@@ -16,20 +17,20 @@ public class NodeDuressTrackerTests extends OpenSearchTestCase {
 
     public void testNodeDuressTracker() {
         AtomicReference<Double> cpuUsage = new AtomicReference<>(0.0);
-        NodeDuressTracker tracker = new NodeDuressTracker(() -> cpuUsage.get() >= 0.5);
+        NodeDuressTracker tracker = new NodeDuressTracker(() -> cpuUsage.get() >= 0.5, () -> 3);
 
         // Node not in duress.
-        assertEquals(0, tracker.check());
+        assertFalse(tracker.test());
 
         // Node in duress; the streak must keep increasing.
         cpuUsage.set(0.7);
-        assertEquals(1, tracker.check());
-        assertEquals(2, tracker.check());
-        assertEquals(3, tracker.check());
+        assertFalse(tracker.test());
+        assertFalse(tracker.test());
+        assertTrue(tracker.test());
 
         // Node not in duress anymore.
         cpuUsage.set(0.3);
-        assertEquals(0, tracker.check());
-        assertEquals(0, tracker.check());
+        assertFalse(tracker.test());
+        assertFalse(tracker.test());
     }
 }
diff --git a/server/src/test/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackersTests.java b/server/src/test/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackersTests.java
new file mode 100644
index 0000000000000..7c52840c099d4
--- /dev/null
+++ b/server/src/test/java/org/opensearch/search/backpressure/trackers/NodeDuressTrackersTests.java
@@ -0,0 +1,84 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.backpressure.trackers;
+
+import org.opensearch.search.backpressure.trackers.NodeDuressTrackers.NodeDuressTracker;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.wlm.ResourceType;
+
+import java.util.EnumMap;
+
+public class NodeDuressTrackersTests extends OpenSearchTestCase {
+
+    public void testNodeNotInDuress() {
+        EnumMap<ResourceType, NodeDuressTracker> map = new EnumMap<>(ResourceType.class) {
+            {
+                put(ResourceType.MEMORY, new NodeDuressTracker(() -> false, () -> 2));
+                put(ResourceType.CPU, new NodeDuressTracker(() -> false, () -> 2));
+            }
+        };
+
+        NodeDuressTrackers nodeDuressTrackers = new NodeDuressTrackers(map);
+
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+    }
+
+    public void testNodeInDuressWhenHeapInDuress() {
+        EnumMap<ResourceType, NodeDuressTracker> map = new EnumMap<>(ResourceType.class) {
+            {
+                put(ResourceType.MEMORY, new NodeDuressTracker(() -> true, () -> 3));
+                put(ResourceType.CPU, new NodeDuressTracker(() -> false, () -> 1));
+            }
+        };
+
+        NodeDuressTrackers nodeDuressTrackers = new NodeDuressTrackers(map);
+
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+
+        // for the third time it should be in duress
+        assertTrue(nodeDuressTrackers.isNodeInDuress());
+    }
+
+    public void testNodeInDuressWhenCPUInDuress() {
+        EnumMap<ResourceType, NodeDuressTracker> map = new EnumMap<>(ResourceType.class) {
+            {
+                put(ResourceType.MEMORY, new NodeDuressTracker(() -> false, () -> 1));
+                put(ResourceType.CPU, new NodeDuressTracker(() -> true, () -> 3));
+            }
+        };
+
+        NodeDuressTrackers nodeDuressTrackers = new NodeDuressTrackers(map);
+
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+
+        // for the third time it should be in duress
+        assertTrue(nodeDuressTrackers.isNodeInDuress());
+    }
+
+    public void testNodeInDuressWhenCPUAndHeapInDuress() {
+        EnumMap<ResourceType, NodeDuressTracker> map = new EnumMap<>(ResourceType.class) {
+            {
+                put(ResourceType.MEMORY, new NodeDuressTracker(() -> true, () -> 3));
+                put(ResourceType.CPU, new NodeDuressTracker(() -> false, () -> 3));
+            }
+        };
+
+        NodeDuressTrackers nodeDuressTrackers = new NodeDuressTrackers(map);
+
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+        assertFalse(nodeDuressTrackers.isNodeInDuress());
+
+        // for the third time it should be in duress
+        assertTrue(nodeDuressTrackers.isNodeInDuress());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/search/builder/SearchSourceBuilderTests.java b/server/src/test/java/org/opensearch/search/builder/SearchSourceBuilderTests.java
index 5b1035e24185d..9697f4cee0d58 100644
--- a/server/src/test/java/org/opensearch/search/builder/SearchSourceBuilderTests.java
+++ b/server/src/test/java/org/opensearch/search/builder/SearchSourceBuilderTests.java
@@ -357,6 +357,70 @@ public void testDerivedFieldsParsingAndSerialization() throws IOException {
 
     }
 
+    public void testDerivedFieldsParsingAndSerializationObjectType() throws IOException {
+        {
+            String restContent = "{\n"
+                + "  \"derived\": {\n"
+                + "    \"duration\": {\n"
+                + "      \"type\": \"long\",\n"
+                + "      \"script\": \"emit(doc['test'])\"\n"
+                + "    },\n"
+                + "    \"ip_from_message\": {\n"
+                + "      \"type\": \"keyword\",\n"
+                + "      \"script\": \"emit(doc['message'])\"\n"
+                + "    },\n"
+                + "    \"object\": {\n"
+                + "      \"type\": \"object\",\n"
+                + "      \"script\": \"emit(doc['test'])\",\n"
+                + "      \"format\": \"dd-MM-yyyy\",\n"
+                + "      \"prefilter_field\": \"test\",\n"
+                + "      \"ignore_malformed\": true,\n"
+                + "      \"properties\": {\n"
+                + "         \"sub_field\": \"text\"\n"
+                + "       }\n"
+                + "    }\n"
+                + "  },\n"
+                + "    \"query\" : {\n"
+                + "        \"match\": { \"content\": { \"query\": \"foo bar\" }}\n"
+                + "     }\n"
+                + "}";
+
+            String expectedContent =
+                "{\"query\":{\"match\":{\"content\":{\"query\":\"foo bar\",\"operator\":\"OR\",\"prefix_length\":0,\"max_expansions\":50,\"fuzzy_transpositions\":true,\"lenient\":false,\"zero_terms_query\":\"NONE\",\"auto_generate_synonyms_phrase_query\":true,\"boost\":1.0}}},\"derived\":{\"duration\":{\"type\":\"long\",\"script\":\"emit(doc['test'])\"},\"ip_from_message\":{\"type\":\"keyword\",\"script\":\"emit(doc['message'])\"},\"object\":{\"format\":\"dd-MM-yyyy\",\"prefilter_field\":\"test\",\"ignore_malformed\":true,\"type\":\"object\",\"script\":\"emit(doc['test'])\",\"properties\":{\"sub_field\":\"text\"}},\"derived_field\":{\"type\":\"object\",\"script\":{\"source\":\"emit(doc['message']\",\"lang\":\"painless\"},\"properties\":{\"sub_field_2\":\"keyword\"},\"prefilter_field\":\"message\",\"format\":\"dd-MM-yyyy\",\"ignore_malformed\":true}}}";
+
+            try (XContentParser parser = createParser(JsonXContent.jsonXContent, restContent)) {
+                SearchSourceBuilder searchSourceBuilder = SearchSourceBuilder.fromXContent(parser);
+                searchSourceBuilder.derivedField(
+                    "derived_field",
+                    "object",
+                    new Script("emit(doc['message']"),
+                    Map.of("sub_field_2", "keyword"),
+                    "message",
+                    "dd-MM-yyyy",
+                    true
+                );
+                searchSourceBuilder = rewrite(searchSourceBuilder);
+                assertEquals(3, searchSourceBuilder.getDerivedFieldsObject().size());
+                assertEquals(1, searchSourceBuilder.getDerivedFields().size());
+                assertEquals(1, searchSourceBuilder.getDerivedFields().get(0).getProperties().size());
+                assertEquals("message", searchSourceBuilder.getDerivedFields().get(0).getPrefilterField());
+                assertEquals("dd-MM-yyyy", searchSourceBuilder.getDerivedFields().get(0).getFormat());
+                assertTrue(searchSourceBuilder.getDerivedFields().get(0).getIgnoreMalformed());
+
+                try (BytesStreamOutput output = new BytesStreamOutput()) {
+                    searchSourceBuilder.writeTo(output);
+                    try (StreamInput in = new NamedWriteableAwareStreamInput(output.bytes().streamInput(), namedWriteableRegistry)) {
+                        SearchSourceBuilder deserializedBuilder = new SearchSourceBuilder(in);
+                        String actualContent = deserializedBuilder.toString();
+                        assertEquals(expectedContent, actualContent);
+                        assertEquals(searchSourceBuilder.hashCode(), deserializedBuilder.hashCode());
+                        assertNotSame(searchSourceBuilder, deserializedBuilder);
+                    }
+                }
+            }
+        }
+    }
+
     public void testAggsParsing() throws IOException {
         {
             String restContent = "{\n"
diff --git a/server/src/test/java/org/opensearch/search/fetch/subphase/highlight/DerivedFieldFetchAndHighlightTests.java b/server/src/test/java/org/opensearch/search/fetch/subphase/highlight/DerivedFieldFetchAndHighlightTests.java
index 92127da9654aa..f106aaa13dc48 100644
--- a/server/src/test/java/org/opensearch/search/fetch/subphase/highlight/DerivedFieldFetchAndHighlightTests.java
+++ b/server/src/test/java/org/opensearch/search/fetch/subphase/highlight/DerivedFieldFetchAndHighlightTests.java
@@ -27,7 +27,9 @@
 import org.opensearch.index.IndexService;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.DefaultDerivedFieldResolver;
 import org.opensearch.index.mapper.DerivedField;
+import org.opensearch.index.mapper.DerivedFieldResolverFactory;
 import org.opensearch.index.mapper.DerivedFieldSupportedTypes;
 import org.opensearch.index.mapper.DerivedFieldType;
 import org.opensearch.index.mapper.Mapper;
@@ -64,9 +66,14 @@
 public class DerivedFieldFetchAndHighlightTests extends OpenSearchSingleNodeTestCase {
     private static String DERIVED_FIELD_SCRIPT_1 = "derived_field_script_1";
     private static String DERIVED_FIELD_SCRIPT_2 = "derived_field_script_2";
+    private static String DERIVED_FIELD_SCRIPT_3 = "derived_field_script_3";
+    private static String DERIVED_FIELD_SCRIPT_4 = "derived_field_script_4";
 
     private static String DERIVED_FIELD_1 = "derived_1";
     private static String DERIVED_FIELD_2 = "derived_2";
+    private static String DERIVED_FIELD_3 = "derived_3";
+    private static String DERIVED_FIELD_4 = "derived_4";
+    private static String NESTED_FIELD = "field";
 
     public void testDerivedFieldFromIndexMapping() throws IOException {
         // Create index and mapper service
@@ -88,6 +95,21 @@ public void testDerivedFieldFromIndexMapping() throws IOException {
             .field("lang", "mockscript")
             .endObject()
             .endObject()
+            .startObject(DERIVED_FIELD_3)
+            .field("type", "date")
+            .field("format", "yyyy-MM-dd")
+            .startObject("script")
+            .field("source", DERIVED_FIELD_SCRIPT_3)
+            .field("lang", "mockscript")
+            .endObject()
+            .endObject()
+            .startObject(DERIVED_FIELD_4)
+            .field("type", "object")
+            .startObject("script")
+            .field("source", DERIVED_FIELD_SCRIPT_4)
+            .field("lang", "mockscript")
+            .endObject()
+            .endObject()
             .endObject()
             .endObject();
 
@@ -97,6 +119,8 @@ public void testDerivedFieldFromIndexMapping() throws IOException {
             .startObject()
             .field("field1", "some_text_1")
             .field("field2", "some_text_2")
+            .field("field3", 1710923445000L)
+            .field("field4", "{ \"field\": \"foo bar baz\"}")
             .endObject();
 
         int docId = 0;
@@ -121,14 +145,21 @@ public void testDerivedFieldFromIndexMapping() throws IOException {
 
                 // Assert the fetch phase works for both of the derived fields
                 Map<String, DocumentField> fields = fetchFields(mockShardContext, context, "*");
+                Map<String, DocumentField> nestedFields = fetchFields(mockShardContext, context, DERIVED_FIELD_4 + "." + NESTED_FIELD);
 
                 // Validate FetchPhase
                 {
-                    assertEquals(fields.size(), 2);
+                    assertEquals(fields.size(), 4);
                     assertEquals(1, fields.get(DERIVED_FIELD_1).getValues().size());
                     assertEquals(1, fields.get(DERIVED_FIELD_2).getValues().size());
+                    assertEquals(1, fields.get(DERIVED_FIELD_3).getValues().size());
+                    assertEquals(1, fields.get(DERIVED_FIELD_4).getValues().size());
                     assertEquals("some_text_1", fields.get(DERIVED_FIELD_1).getValue());
                     assertEquals("some_text_2", fields.get(DERIVED_FIELD_2).getValue());
+                    assertEquals("2024-03-20", fields.get(DERIVED_FIELD_3).getValue());
+                    assertEquals("{ \"field\": \"foo bar baz\"}", fields.get(DERIVED_FIELD_4).getValue());
+                    assertEquals(1, nestedFields.get(DERIVED_FIELD_4 + "." + NESTED_FIELD).getValues().size());
+                    assertEquals("foo bar baz", nestedFields.get(DERIVED_FIELD_4 + "." + NESTED_FIELD).getValue());
                 }
 
                 // Create a HighlightBuilder of type unified, set its fields as derived_1 and derived_2
@@ -136,6 +167,7 @@ public void testDerivedFieldFromIndexMapping() throws IOException {
                 highlightBuilder.highlighterType("unified");
                 highlightBuilder.field(DERIVED_FIELD_1);
                 highlightBuilder.field(DERIVED_FIELD_2);
+                highlightBuilder.field(DERIVED_FIELD_4 + "." + NESTED_FIELD);
                 highlightBuilder = Rewriteable.rewrite(highlightBuilder, mockShardContext);
                 SearchHighlightContext searchHighlightContext = highlightBuilder.build(mockShardContext);
 
@@ -158,30 +190,56 @@ public void testDerivedFieldFromIndexMapping() throws IOException {
                         null
                     )
                 );
-
-                // The query used by FetchSubPhaseProcessor to highlight is a term query on DERIVED_FIELD_1
-                FetchSubPhaseProcessor subPhaseProcessor = highlightPhase.getProcessor(
-                    fetchContext,
-                    searchHighlightContext,
-                    new TermQuery(new Term(DERIVED_FIELD_1, "some_text_1"))
-                );
-
-                // Create a search hit using the derived fields fetched above in fetch phase
-                SearchHit searchHit = new SearchHit(docId, "0", null, fields, null);
-
-                // Create a HitContext of search hit
-                FetchSubPhase.HitContext hitContext = new FetchSubPhase.HitContext(
-                    searchHit,
-                    context,
-                    docId,
-                    mockShardContext.lookup().source()
-                );
-                hitContext.sourceLookup().loadSourceIfNeeded();
-                // process the HitContext using the highlightPhase subPhaseProcessor
-                subPhaseProcessor.process(hitContext);
-
-                // Validate that 1 highlight field is present
-                assertEquals(hitContext.hit().getHighlightFields().size(), 1);
+                {
+                    // The query used by FetchSubPhaseProcessor to highlight is a term query on DERIVED_FIELD_1
+                    FetchSubPhaseProcessor subPhaseProcessor = highlightPhase.getProcessor(
+                        fetchContext,
+                        searchHighlightContext,
+                        new TermQuery(new Term(DERIVED_FIELD_1, "some_text_1"))
+                    );
+
+                    // Create a search hit using the derived fields fetched above in fetch phase
+                    SearchHit searchHit = new SearchHit(docId, "0", null, fields, null);
+
+                    // Create a HitContext of search hit
+                    FetchSubPhase.HitContext hitContext = new FetchSubPhase.HitContext(
+                        searchHit,
+                        context,
+                        docId,
+                        mockShardContext.lookup().source()
+                    );
+                    hitContext.sourceLookup().loadSourceIfNeeded();
+                    // process the HitContext using the highlightPhase subPhaseProcessor
+                    subPhaseProcessor.process(hitContext);
+
+                    // Validate that 1 highlight field is present
+                    assertEquals(hitContext.hit().getHighlightFields().size(), 1);
+                }
+                {
+                    // The query used by FetchSubPhaseProcessor to highlight is a term query on DERIVED_FIELD_1
+                    FetchSubPhaseProcessor subPhaseProcessor = highlightPhase.getProcessor(
+                        fetchContext,
+                        searchHighlightContext,
+                        new TermQuery(new Term(DERIVED_FIELD_4 + "." + NESTED_FIELD, "foo"))
+                    );
+
+                    // Create a search hit using the derived fields fetched above in fetch phase
+                    SearchHit searchHit = new SearchHit(docId, "0", null, nestedFields, null);
+
+                    // Create a HitContext of search hit
+                    FetchSubPhase.HitContext hitContext = new FetchSubPhase.HitContext(
+                        searchHit,
+                        context,
+                        docId,
+                        mockShardContext.lookup().source()
+                    );
+                    hitContext.sourceLookup().loadSourceIfNeeded();
+                    // process the HitContext using the highlightPhase subPhaseProcessor
+                    subPhaseProcessor.process(hitContext);
+
+                    // Validate that 1 highlight field is present
+                    assertEquals(hitContext.hit().getHighlightFields().size(), 1);
+                }
             }
         }
     }
@@ -193,6 +251,8 @@ public void testDerivedFieldFromSearchMapping() throws IOException {
             .startObject()
             .field("field1", "some_text_1")
             .field("field2", "some_text_2")
+            .field("field3", 1710923445000L)
+            .field("field4", "{ \"field\": \"foo bar baz\"}")
             .endObject();
 
         int docId = 0;
@@ -218,26 +278,56 @@ public void testDerivedFieldFromSearchMapping() throws IOException {
                 QueryShardContext mockShardContext = createQueryShardContext(mapperService, searcher);
                 mockShardContext.lookup().source().setSegmentAndDocument(context, docId);
 
+                DerivedField derivedField3 = new DerivedField(
+                    DERIVED_FIELD_3,
+                    "date",
+                    new Script(ScriptType.INLINE, "mockscript", DERIVED_FIELD_SCRIPT_3, emptyMap())
+                );
+                derivedField3.setFormat("dd-MM-yyyy");
                 // This mock behavior is similar to adding derived fields in search request
-                mockShardContext.setDerivedFieldTypes(
-                    Map.of(
-                        DERIVED_FIELD_1,
-                        createDerivedFieldType(DERIVED_FIELD_1, "keyword", DERIVED_FIELD_SCRIPT_1),
-                        DERIVED_FIELD_2,
-                        createDerivedFieldType(DERIVED_FIELD_2, "keyword", DERIVED_FIELD_SCRIPT_2)
+                mockShardContext.setDerivedFieldResolver(
+                    (DefaultDerivedFieldResolver) DerivedFieldResolverFactory.createResolver(
+                        mockShardContext,
+                        null,
+                        List.of(
+                            new DerivedField(
+                                DERIVED_FIELD_1,
+                                "keyword",
+                                new Script(ScriptType.INLINE, "mockscript", DERIVED_FIELD_SCRIPT_1, emptyMap())
+                            ),
+                            new DerivedField(
+                                DERIVED_FIELD_2,
+                                "keyword",
+                                new Script(ScriptType.INLINE, "mockscript", DERIVED_FIELD_SCRIPT_2, emptyMap())
+                            ),
+                            derivedField3,
+                            new DerivedField(
+                                DERIVED_FIELD_4,
+                                "object",
+                                new Script(ScriptType.INLINE, "mockscript", DERIVED_FIELD_SCRIPT_4, emptyMap())
+                            )
+                        ),
+                        true
                     )
                 );
 
                 // Assert the fetch phase works for both of the derived fields
                 Map<String, DocumentField> fields = fetchFields(mockShardContext, context, "derived_*");
+                Map<String, DocumentField> nestedFields = fetchFields(mockShardContext, context, DERIVED_FIELD_4 + "." + NESTED_FIELD);
 
                 // Validate FetchPhase
                 {
-                    assertEquals(fields.size(), 2);
+                    assertEquals(fields.size(), 4);
                     assertEquals(1, fields.get(DERIVED_FIELD_1).getValues().size());
                     assertEquals(1, fields.get(DERIVED_FIELD_2).getValues().size());
+                    assertEquals(1, fields.get(DERIVED_FIELD_3).getValues().size());
+                    assertEquals(1, fields.get(DERIVED_FIELD_4).getValues().size());
                     assertEquals("some_text_1", fields.get(DERIVED_FIELD_1).getValue());
                     assertEquals("some_text_2", fields.get(DERIVED_FIELD_2).getValue());
+                    assertEquals("20-03-2024", fields.get(DERIVED_FIELD_3).getValue());
+                    assertEquals("{ \"field\": \"foo bar baz\"}", fields.get(DERIVED_FIELD_4).getValue());
+                    assertEquals(1, nestedFields.get(DERIVED_FIELD_4 + "." + NESTED_FIELD).getValues().size());
+                    assertEquals("foo bar baz", nestedFields.get(DERIVED_FIELD_4 + "." + NESTED_FIELD).getValue());
                 }
 
                 // Create a HighlightBuilder of type unified, set its fields as derived_1 and derived_2
@@ -245,6 +335,7 @@ public void testDerivedFieldFromSearchMapping() throws IOException {
                 highlightBuilder.highlighterType("unified");
                 highlightBuilder.field(DERIVED_FIELD_1);
                 highlightBuilder.field(DERIVED_FIELD_2);
+                highlightBuilder.field(DERIVED_FIELD_4 + "." + NESTED_FIELD);
                 highlightBuilder = Rewriteable.rewrite(highlightBuilder, mockShardContext);
                 SearchHighlightContext searchHighlightContext = highlightBuilder.build(mockShardContext);
 
@@ -267,30 +358,56 @@ public void testDerivedFieldFromSearchMapping() throws IOException {
                         null
                     )
                 );
-
-                // The query used by FetchSubPhaseProcessor to highlight is a term query on DERIVED_FIELD_1
-                FetchSubPhaseProcessor subPhaseProcessor = highlightPhase.getProcessor(
-                    fetchContext,
-                    searchHighlightContext,
-                    new TermQuery(new Term(DERIVED_FIELD_1, "some_text_1"))
-                );
-
-                // Create a search hit using the derived fields fetched above in fetch phase
-                SearchHit searchHit = new SearchHit(docId, "0", null, fields, null);
-
-                // Create a HitContext of search hit
-                FetchSubPhase.HitContext hitContext = new FetchSubPhase.HitContext(
-                    searchHit,
-                    context,
-                    docId,
-                    mockShardContext.lookup().source()
-                );
-                hitContext.sourceLookup().loadSourceIfNeeded();
-                // process the HitContext using the highlightPhase subPhaseProcessor
-                subPhaseProcessor.process(hitContext);
-
-                // Validate that 1 highlight field is present
-                assertEquals(hitContext.hit().getHighlightFields().size(), 1);
+                {
+                    // The query used by FetchSubPhaseProcessor to highlight is a term query on DERIVED_FIELD_1
+                    FetchSubPhaseProcessor subPhaseProcessor = highlightPhase.getProcessor(
+                        fetchContext,
+                        searchHighlightContext,
+                        new TermQuery(new Term(DERIVED_FIELD_1, "some_text_1"))
+                    );
+
+                    // Create a search hit using the derived fields fetched above in fetch phase
+                    SearchHit searchHit = new SearchHit(docId, "0", null, fields, null);
+
+                    // Create a HitContext of search hit
+                    FetchSubPhase.HitContext hitContext = new FetchSubPhase.HitContext(
+                        searchHit,
+                        context,
+                        docId,
+                        mockShardContext.lookup().source()
+                    );
+                    hitContext.sourceLookup().loadSourceIfNeeded();
+                    // process the HitContext using the highlightPhase subPhaseProcessor
+                    subPhaseProcessor.process(hitContext);
+
+                    // Validate that 1 highlight field is present
+                    assertEquals(hitContext.hit().getHighlightFields().size(), 1);
+                }
+                {
+                    // test highlighting nested field DERIVED_FIELD_4 + "." + NESTED_FIELD
+                    FetchSubPhaseProcessor subPhaseProcessor = highlightPhase.getProcessor(
+                        fetchContext,
+                        searchHighlightContext,
+                        new TermQuery(new Term(DERIVED_FIELD_4 + "." + NESTED_FIELD, "foo"))
+                    );
+
+                    // Create a search hit using the derived fields fetched above in fetch phase
+                    SearchHit searchHit = new SearchHit(docId, "0", null, nestedFields, null);
+
+                    // Create a HitContext of search hit
+                    FetchSubPhase.HitContext hitContext = new FetchSubPhase.HitContext(
+                        searchHit,
+                        context,
+                        docId,
+                        mockShardContext.lookup().source()
+                    );
+                    hitContext.sourceLookup().loadSourceIfNeeded();
+                    // process the HitContext using the highlightPhase subPhaseProcessor
+                    subPhaseProcessor.process(hitContext);
+
+                    // Validate that 1 highlight field is present
+                    assertEquals(hitContext.hit().getHighlightFields().size(), 1);
+                }
             }
         }
     }
@@ -333,7 +450,7 @@ private static QueryShardContext createQueryShardContext(MapperService mapperSer
             null,
             null,
             null,
-            null,
+            () -> true,
             null
         );
     }
@@ -345,7 +462,11 @@ private static ScriptService getScriptService() {
                 DERIVED_FIELD_SCRIPT_1,
                 (script) -> ((String) ((Map<String, Object>) script.get("_source")).get("field1")).replace(" ", "_"),
                 DERIVED_FIELD_SCRIPT_2,
-                (script) -> ((String) ((Map<String, Object>) script.get("_source")).get("field2")).replace(" ", "_")
+                (script) -> ((String) ((Map<String, Object>) script.get("_source")).get("field2")).replace(" ", "_"),
+                DERIVED_FIELD_SCRIPT_3,
+                (script) -> ((Map<String, Object>) script.get("_source")).get("field3"),
+                DERIVED_FIELD_SCRIPT_4,
+                (script) -> ((Map<String, Object>) script.get("_source")).get("field4")
             ),
             Collections.emptyMap()
         );
@@ -359,8 +480,9 @@ private DerivedFieldType createDerivedFieldType(String name, String type, String
         when(context.path()).thenReturn(new ContentPath());
         return new DerivedFieldType(
             new DerivedField(name, type, new Script(ScriptType.INLINE, "mockscript", script, emptyMap())),
-            DerivedFieldSupportedTypes.getFieldMapperFromType(type, name, context),
-            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(type, name)
+            DerivedFieldSupportedTypes.getFieldMapperFromType(type, name, context, null),
+            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(type, name),
+            null
         );
     }
 }
diff --git a/server/src/test/java/org/opensearch/search/internal/ContextIndexSearcherTests.java b/server/src/test/java/org/opensearch/search/internal/ContextIndexSearcherTests.java
index a707c8b34e0a4..606c2512a3d58 100644
--- a/server/src/test/java/org/opensearch/search/internal/ContextIndexSearcherTests.java
+++ b/server/src/test/java/org/opensearch/search/internal/ContextIndexSearcherTests.java
@@ -81,6 +81,7 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.cache.bitset.BitsetFilterCache;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.shard.SearchOperationListener;
 import org.opensearch.search.SearchService;
 import org.opensearch.search.aggregations.LeafBucketCollector;
 import org.opensearch.test.IndexSettingsModule;
@@ -262,6 +263,9 @@ public void onRemoval(ShardId shardId, Accountable accountable) {
         SearchContext searchContext = mock(SearchContext.class);
         IndexShard indexShard = mock(IndexShard.class);
         when(searchContext.indexShard()).thenReturn(indexShard);
+        SearchOperationListener searchOperationListener = new SearchOperationListener() {
+        };
+        when(indexShard.getSearchOperationListener()).thenReturn(searchOperationListener);
         when(searchContext.bucketCollectorProcessor()).thenReturn(SearchContext.NO_OP_BUCKET_COLLECTOR_PROCESSOR);
         ContextIndexSearcher searcher = new ContextIndexSearcher(
             filteredReader,
diff --git a/server/src/test/java/org/opensearch/search/profile/query/QueryProfilerTests.java b/server/src/test/java/org/opensearch/search/profile/query/QueryProfilerTests.java
index 481a224f2ff0e..3a7c711d324c4 100644
--- a/server/src/test/java/org/opensearch/search/profile/query/QueryProfilerTests.java
+++ b/server/src/test/java/org/opensearch/search/profile/query/QueryProfilerTests.java
@@ -62,6 +62,7 @@
 import org.apache.lucene.tests.util.TestUtil;
 import org.opensearch.common.util.io.IOUtils;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.shard.SearchOperationListener;
 import org.opensearch.search.internal.ContextIndexSearcher;
 import org.opensearch.search.internal.SearchContext;
 import org.opensearch.search.profile.ProfileResult;
@@ -128,6 +129,9 @@ public void setUp() throws Exception {
         SearchContext searchContext = mock(SearchContext.class);
         IndexShard indexShard = mock(IndexShard.class);
         when(searchContext.indexShard()).thenReturn(indexShard);
+        SearchOperationListener searchOperationListener = new SearchOperationListener() {
+        };
+        when(indexShard.getSearchOperationListener()).thenReturn(searchOperationListener);
         when(searchContext.bucketCollectorProcessor()).thenReturn(SearchContext.NO_OP_BUCKET_COLLECTOR_PROCESSOR);
         searcher = new ContextIndexSearcher(
             reader,
diff --git a/server/src/test/java/org/opensearch/search/query/BitmapDocValuesQueryTests.java b/server/src/test/java/org/opensearch/search/query/BitmapDocValuesQueryTests.java
new file mode 100644
index 0000000000000..6e293d1ec69fd
--- /dev/null
+++ b/server/src/test/java/org/opensearch/search/query/BitmapDocValuesQueryTests.java
@@ -0,0 +1,149 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.query;
+
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.IntField;
+import org.apache.lucene.index.DirectoryReader;
+import org.apache.lucene.index.DocValues;
+import org.apache.lucene.index.IndexWriter;
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.DocIdSetIterator;
+import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Scorer;
+import org.apache.lucene.search.Weight;
+import org.apache.lucene.store.Directory;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import org.roaringbitmap.RoaringBitmap;
+
+public class BitmapDocValuesQueryTests extends OpenSearchTestCase {
+    private Directory dir;
+    private IndexWriter w;
+    private DirectoryReader reader;
+    private IndexSearcher searcher;
+
+    @Before
+    public void initSearcher() throws IOException {
+        dir = newDirectory();
+        w = new IndexWriter(dir, newIndexWriterConfig());
+    }
+
+    @After
+    public void closeAllTheReaders() throws IOException {
+        reader.close();
+        w.close();
+        dir.close();
+    }
+
+    public void testScore() throws IOException {
+        Document d = new Document();
+        d.add(new IntField("product_id", 1, Field.Store.NO));
+        w.addDocument(d);
+
+        d = new Document();
+        d.add(new IntField("product_id", 2, Field.Store.NO));
+        w.addDocument(d);
+
+        d = new Document();
+        d.add(new IntField("product_id", 3, Field.Store.NO));
+        w.addDocument(d);
+
+        d = new Document();
+        d.add(new IntField("product_id", 4, Field.Store.NO));
+        w.addDocument(d);
+
+        w.commit();
+        reader = DirectoryReader.open(w);
+        searcher = newSearcher(reader);
+
+        RoaringBitmap bitmap = new RoaringBitmap();
+        bitmap.add(1);
+        bitmap.add(4);
+        BitmapDocValuesQuery query = new BitmapDocValuesQuery("product_id", bitmap);
+
+        Weight weight = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE_NO_SCORES, 1f);
+
+        List<Integer> actual = new LinkedList<>();
+        for (LeafReaderContext leaf : searcher.getIndexReader().leaves()) {
+            // use doc values to get the actual value of the matching docs and assert
+            // cannot directly check the docId because test can randomize segment numbers
+            SortedNumericDocValues dv = DocValues.getSortedNumeric(leaf.reader(), "product_id");
+            Scorer scorer = weight.scorer(leaf);
+            DocIdSetIterator disi = scorer.iterator();
+            int docId;
+            while ((docId = disi.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {
+                dv.advanceExact(docId);
+                for (int count = 0; count < dv.docValueCount(); ++count) {
+                    actual.add((int) dv.nextValue());
+                }
+            }
+        }
+        List<Integer> expected = List.of(1, 4);
+        assertEquals(expected, actual);
+    }
+
+    public void testScoreMutilValues() throws IOException {
+        Document d = new Document();
+        d.add(new IntField("product_id", 1, Field.Store.NO));
+        w.addDocument(d);
+
+        d = new Document();
+        d.add(new IntField("product_id", 2, Field.Store.NO));
+        d.add(new IntField("product_id", 3, Field.Store.NO));
+        w.addDocument(d);
+
+        d = new Document();
+        d.add(new IntField("product_id", 3, Field.Store.NO));
+        w.addDocument(d);
+
+        d = new Document();
+        d.add(new IntField("product_id", 4, Field.Store.NO));
+        w.addDocument(d);
+
+        w.commit();
+        reader = DirectoryReader.open(w);
+        searcher = newSearcher(reader);
+
+        RoaringBitmap bitmap = new RoaringBitmap();
+        bitmap.add(3);
+        BitmapDocValuesQuery query = new BitmapDocValuesQuery("product_id", bitmap);
+
+        Weight weight = searcher.createWeight(searcher.rewrite(query), ScoreMode.COMPLETE_NO_SCORES, 1f);
+
+        Set<Integer> actual = new HashSet<>();
+        for (LeafReaderContext leaf : searcher.getIndexReader().leaves()) {
+            // use doc values to get the actual value of the matching docs and assert
+            // cannot directly check the docId because test can randomize segment numbers
+            SortedNumericDocValues dv = DocValues.getSortedNumeric(leaf.reader(), "product_id");
+            Scorer scorer = weight.scorer(leaf);
+            DocIdSetIterator disi = scorer.iterator();
+            int docId;
+            while ((docId = disi.nextDoc()) != DocIdSetIterator.NO_MORE_DOCS) {
+                dv.advanceExact(docId);
+                for (int count = 0; count < dv.docValueCount(); ++count) {
+                    actual.add((int) dv.nextValue());
+                }
+            }
+        }
+        Set<Integer> expected = Set.of(2, 3);
+        assertEquals(expected, actual);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/search/query/QueryPhaseTests.java b/server/src/test/java/org/opensearch/search/query/QueryPhaseTests.java
index 4bd4d406e4391..84057ab1a1b15 100644
--- a/server/src/test/java/org/opensearch/search/query/QueryPhaseTests.java
+++ b/server/src/test/java/org/opensearch/search/query/QueryPhaseTests.java
@@ -101,6 +101,7 @@
 import org.opensearch.index.search.OpenSearchToParentBlockJoinQuery;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardTestCase;
+import org.opensearch.index.shard.SearchOperationListener;
 import org.opensearch.lucene.queries.MinDocQuery;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.collapse.CollapseBuilder;
@@ -1225,6 +1226,9 @@ private static ContextIndexSearcher newContextSearcher(IndexReader reader, Execu
         SearchContext searchContext = mock(SearchContext.class);
         IndexShard indexShard = mock(IndexShard.class);
         when(searchContext.indexShard()).thenReturn(indexShard);
+        SearchOperationListener searchOperationListener = new SearchOperationListener() {
+        };
+        when(indexShard.getSearchOperationListener()).thenReturn(searchOperationListener);
         when(searchContext.bucketCollectorProcessor()).thenReturn(SearchContext.NO_OP_BUCKET_COLLECTOR_PROCESSOR);
         when(searchContext.shouldUseConcurrentSearch()).thenReturn(executor != null);
         if (executor != null) {
@@ -1248,6 +1252,9 @@ private static ContextIndexSearcher newEarlyTerminationContextSearcher(IndexRead
         SearchContext searchContext = mock(SearchContext.class);
         IndexShard indexShard = mock(IndexShard.class);
         when(searchContext.indexShard()).thenReturn(indexShard);
+        SearchOperationListener searchOperationListener = new SearchOperationListener() {
+        };
+        when(indexShard.getSearchOperationListener()).thenReturn(searchOperationListener);
         when(searchContext.bucketCollectorProcessor()).thenReturn(SearchContext.NO_OP_BUCKET_COLLECTOR_PROCESSOR);
         when(searchContext.shouldUseConcurrentSearch()).thenReturn(executor != null);
         if (executor != null) {
diff --git a/server/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java b/server/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java
index 7dd3a89b2009d..1e32a6d29a76f 100644
--- a/server/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java
+++ b/server/src/test/java/org/opensearch/search/query/QueryProfilePhaseTests.java
@@ -35,6 +35,7 @@
 import org.apache.lucene.search.LeafCollector;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.MatchNoDocsQuery;
+import org.apache.lucene.search.PhraseQuery;
 import org.apache.lucene.search.Pruning;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.Sort;
@@ -48,20 +49,30 @@
 import org.opensearch.action.search.SearchShardTask;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.index.Index;
 import org.opensearch.core.xcontent.ToXContent;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.mapper.DocumentMapper;
+import org.opensearch.index.mapper.MatchOnlyTextFieldMapper;
 import org.opensearch.index.mapper.NumberFieldMapper.NumberFieldType;
 import org.opensearch.index.mapper.NumberFieldMapper.NumberType;
+import org.opensearch.index.mapper.SourceFieldMapper;
+import org.opensearch.index.mapper.TextSearchInfo;
 import org.opensearch.index.query.ParsedQuery;
 import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.index.query.SourceFieldMatchQuery;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.shard.IndexShardTestCase;
+import org.opensearch.index.shard.SearchOperationListener;
 import org.opensearch.lucene.queries.MinDocQuery;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.collapse.CollapseBuilder;
 import org.opensearch.search.internal.ContextIndexSearcher;
 import org.opensearch.search.internal.ScrollContext;
 import org.opensearch.search.internal.SearchContext;
+import org.opensearch.search.lookup.LeafSearchLookup;
+import org.opensearch.search.lookup.SearchLookup;
+import org.opensearch.search.lookup.SourceLookup;
 import org.opensearch.search.profile.ProfileResult;
 import org.opensearch.search.profile.ProfileShardResult;
 import org.opensearch.search.profile.SearchProfileShardResults;
@@ -80,6 +91,7 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
+import java.util.Set;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -94,6 +106,7 @@
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
 import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.instanceOf;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -1526,6 +1539,90 @@ public void testCollapseQuerySearchResults() throws Exception {
         dir.close();
     }
 
+    public void testSourceFieldMatchQueryWithProfile() throws Exception {
+        Directory dir = newDirectory();
+        IndexWriterConfig iwc = newIndexWriterConfig();
+        RandomIndexWriter w = new RandomIndexWriter(random(), dir, iwc);
+        w.close();
+        IndexReader reader = DirectoryReader.open(dir);
+        QueryShardContext queryShardContext = mock(QueryShardContext.class);
+        DocumentMapper mockDocumentMapper = mock(DocumentMapper.class);
+        SourceFieldMapper mockSourceMapper = mock(SourceFieldMapper.class);
+        SearchLookup searchLookup = mock(SearchLookup.class);
+        LeafSearchLookup leafSearchLookup = mock(LeafSearchLookup.class);
+
+        when(queryShardContext.sourcePath("foo")).thenReturn(Set.of("bar"));
+        when(queryShardContext.index()).thenReturn(new Index("test_index", "uuid"));
+        when(searchLookup.getLeafSearchLookup(any())).thenReturn(leafSearchLookup);
+        when(leafSearchLookup.source()).thenReturn(new SourceLookup());
+        when(mockSourceMapper.enabled()).thenReturn(true);
+        when(mockDocumentMapper.sourceMapper()).thenReturn(mockSourceMapper);
+        when(queryShardContext.documentMapper(any())).thenReturn(mockDocumentMapper);
+        when(queryShardContext.lookup()).thenReturn(searchLookup);
+
+        TestSearchContext context = new TestSearchContext(queryShardContext, indexShard, newContextSearcher(reader, executor));
+        context.parsedQuery(
+            new ParsedQuery(
+                new SourceFieldMatchQuery(
+                    new TermQuery(new Term("foo", "bar")),
+                    new PhraseQuery("foo", "bar", "baz"),
+                    new MatchOnlyTextFieldMapper.MatchOnlyTextFieldType(
+                        "user",
+                        true,
+                        true,
+                        TextSearchInfo.WHITESPACE_MATCH_ONLY,
+                        Collections.emptyMap()
+                    ),
+                    queryShardContext
+                )
+            )
+        );
+
+        context.setTask(new SearchShardTask(123L, "", "", "", null, Collections.emptyMap()));
+        context.setSize(1);
+        context.trackTotalHitsUpTo(5);
+        QueryPhase.executeInternal(context.withCleanQueryResult().withProfilers(), queryPhaseSearcher);
+        assertProfileData(context, "SourceFieldMatchQuery", query -> {
+            assertThat(query.getTimeBreakdown().keySet(), not(empty()));
+            assertThat(query.getTimeBreakdown().get("score"), equalTo(0L));
+            assertThat(query.getTimeBreakdown().get("score_count"), equalTo(0L));
+            if (executor != null) {
+                long maxScore = query.getTimeBreakdown().get("max_score");
+                long minScore = query.getTimeBreakdown().get("min_score");
+                long avgScore = query.getTimeBreakdown().get("avg_score");
+                long maxScoreCount = query.getTimeBreakdown().get("max_score_count");
+                long minScoreCount = query.getTimeBreakdown().get("min_score_count");
+                long avgScoreCount = query.getTimeBreakdown().get("avg_score_count");
+                assertThat(maxScore, equalTo(0L));
+                assertThat(minScore, equalTo(0L));
+                assertThat(avgScore, equalTo(0L));
+                assertThat(maxScore, equalTo(avgScore));
+                assertThat(avgScore, equalTo(minScore));
+                assertThat(maxScoreCount, equalTo(0L));
+                assertThat(minScoreCount, equalTo(0L));
+                assertThat(avgScoreCount, equalTo(0L));
+                assertThat(maxScoreCount, equalTo(avgScoreCount));
+                assertThat(avgScoreCount, equalTo(minScoreCount));
+            }
+            assertThat(query.getTimeBreakdown().get("create_weight"), greaterThan(0L));
+            assertThat(query.getTimeBreakdown().get("create_weight_count"), equalTo(1L));
+            assertThat(query.getProfiledChildren(), empty());
+        }, collector -> {
+            assertThat(collector.getReason(), equalTo("search_top_hits"));
+            assertThat(collector.getTime(), greaterThan(0L));
+            if (collector.getName().contains("CollectorManager")) {
+                assertThat(collector.getReduceTime(), greaterThan(0L));
+            }
+            assertThat(collector.getMaxSliceTime(), greaterThan(0L));
+            assertThat(collector.getMinSliceTime(), greaterThan(0L));
+            assertThat(collector.getAvgSliceTime(), greaterThan(0L));
+            assertThat(collector.getSliceCount(), greaterThanOrEqualTo(1));
+            assertThat(collector.getProfiledChildren(), empty());
+        });
+        reader.close();
+        dir.close();
+    }
+
     private void assertProfileData(SearchContext context, String type, Consumer<ProfileResult> query, Consumer<CollectorResult> collector)
         throws IOException {
         assertProfileData(context, collector, (profileResult) -> {
@@ -1592,6 +1689,9 @@ private static ContextIndexSearcher newContextSearcher(IndexReader reader, Execu
         SearchContext searchContext = mock(SearchContext.class);
         IndexShard indexShard = mock(IndexShard.class);
         when(searchContext.indexShard()).thenReturn(indexShard);
+        SearchOperationListener searchOperationListener = new SearchOperationListener() {
+        };
+        when(indexShard.getSearchOperationListener()).thenReturn(searchOperationListener);
         when(searchContext.bucketCollectorProcessor()).thenReturn(SearchContext.NO_OP_BUCKET_COLLECTOR_PROCESSOR);
         return new ContextIndexSearcher(
             reader,
@@ -1609,6 +1709,9 @@ private static ContextIndexSearcher newEarlyTerminationContextSearcher(IndexRead
         SearchContext searchContext = mock(SearchContext.class);
         IndexShard indexShard = mock(IndexShard.class);
         when(searchContext.indexShard()).thenReturn(indexShard);
+        SearchOperationListener searchOperationListener = new SearchOperationListener() {
+        };
+        when(indexShard.getSearchOperationListener()).thenReturn(searchOperationListener);
         when(searchContext.bucketCollectorProcessor()).thenReturn(SearchContext.NO_OP_BUCKET_COLLECTOR_PROCESSOR);
         return new ContextIndexSearcher(
             reader,
diff --git a/server/src/test/java/org/opensearch/snapshots/SnapshotInfoTests.java b/server/src/test/java/org/opensearch/snapshots/SnapshotInfoTests.java
index 850a392c9619c..684a8dd36fccc 100644
--- a/server/src/test/java/org/opensearch/snapshots/SnapshotInfoTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/SnapshotInfoTests.java
@@ -86,7 +86,8 @@ protected SnapshotInfo createTestInstance() {
             shardFailures,
             includeGlobalState,
             userMetadata,
-            remoteStoreIndexShallowCopy
+            remoteStoreIndexShallowCopy,
+            0
         );
     }
 
@@ -114,7 +115,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     instance.includeGlobalState(),
                     instance.userMetadata(),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    0
                 );
             case 1:
                 int indicesSize = randomValueOtherThan(instance.indices().size(), () -> randomIntBetween(1, 10));
@@ -132,7 +134,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     instance.includeGlobalState(),
                     instance.userMetadata(),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    0
                 );
             case 2:
                 return new SnapshotInfo(
@@ -146,7 +149,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     instance.includeGlobalState(),
                     instance.userMetadata(),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    0
                 );
             case 3:
                 return new SnapshotInfo(
@@ -160,7 +164,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     instance.includeGlobalState(),
                     instance.userMetadata(),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    0
                 );
             case 4:
                 return new SnapshotInfo(
@@ -174,7 +179,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     instance.includeGlobalState(),
                     instance.userMetadata(),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    0
                 );
             case 5:
                 int totalShards = randomValueOtherThan(instance.totalShards(), () -> randomIntBetween(0, 100));
@@ -200,7 +206,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     shardFailures,
                     instance.includeGlobalState(),
                     instance.userMetadata(),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    0
                 );
             case 6:
                 return new SnapshotInfo(
@@ -214,7 +221,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     Boolean.FALSE.equals(instance.includeGlobalState()),
                     instance.userMetadata(),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    0
                 );
             case 7:
                 return new SnapshotInfo(
@@ -228,7 +236,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     instance.includeGlobalState(),
                     randomValueOtherThan(instance.userMetadata(), SnapshotInfoTests::randomUserMetadata),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    0
                 );
             case 8:
                 List<String> dataStreams = randomValueOtherThan(
@@ -246,7 +255,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     instance.includeGlobalState(),
                     instance.userMetadata(),
-                    instance.isRemoteStoreIndexShallowCopyEnabled()
+                    instance.isRemoteStoreIndexShallowCopyEnabled(),
+                    123456
                 );
             case 9:
                 return new SnapshotInfo(
@@ -260,7 +270,8 @@ protected SnapshotInfo mutateInstance(SnapshotInfo instance) {
                     instance.shardFailures(),
                     instance.includeGlobalState(),
                     instance.userMetadata(),
-                    Boolean.FALSE.equals(instance.isRemoteStoreIndexShallowCopyEnabled())
+                    Boolean.FALSE.equals(instance.isRemoteStoreIndexShallowCopyEnabled()),
+                    123456
                 );
             default:
                 throw new IllegalArgumentException("invalid randomization case");
diff --git a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
index 3d31fa4df2455..c439ef209e049 100644
--- a/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/SnapshotResiliencyTests.java
@@ -112,6 +112,7 @@
 import org.opensearch.cluster.ClusterChangedEvent;
 import org.opensearch.cluster.ClusterInfo;
 import org.opensearch.cluster.ClusterInfoService;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterModule;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
@@ -190,7 +191,6 @@
 import org.opensearch.index.seqno.RetentionLeaseSyncer;
 import org.opensearch.index.shard.PrimaryReplicaSyncer;
 import org.opensearch.index.store.RemoteSegmentStoreDirectoryFactory;
-import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.index.store.remote.filecache.FileCacheStats;
 import org.opensearch.indices.DefaultRemoteStoreSettings;
 import org.opensearch.indices.IndicesModule;
@@ -229,6 +229,7 @@
 import org.opensearch.tasks.TaskResourceTrackingService;
 import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
+import org.opensearch.test.OpenSearchIntegTestCase;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.disruption.DisruptableMockTransport;
 import org.opensearch.threadpool.ThreadPool;
@@ -1501,12 +1502,8 @@ private RepositoryData getRepositoryData(Repository repository) {
     private StepListener<CreateIndexResponse> createRepoAndIndex(String repoName, String index, int shards) {
         final StepListener<AcknowledgedResponse> createRepositoryListener = new StepListener<>();
 
-        client().admin()
-            .cluster()
-            .preparePutRepository(repoName)
-            .setType(FsRepository.TYPE)
-            .setSettings(Settings.builder().put("location", randomAlphaOfLength(10)))
-            .execute(createRepositoryListener);
+        Settings.Builder settings = Settings.builder().put("location", randomAlphaOfLength(10));
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), repoName, FsRepository.TYPE, settings, createRepositoryListener);
 
         final StepListener<CreateIndexResponse> createIndexResponseStepListener = new StepListener<>();
 
@@ -1680,7 +1677,6 @@ private Environment createEnvironment(String nodeName) {
                     ClusterBootstrapService.INITIAL_CLUSTER_MANAGER_NODES_SETTING.getKey(),
                     ClusterBootstrapService.INITIAL_CLUSTER_MANAGER_NODES_SETTING.get(Settings.EMPTY)
                 )
-                .put(FileCache.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.getKey(), 5)
                 .put(MappingUpdatedAction.INDICES_MAX_IN_FLIGHT_UPDATES_SETTING.getKey(), 1000) // o.w. some tests might block
                 .build()
         );
@@ -2016,7 +2012,9 @@ public void onFailure(final Exception e) {
                     indexNameExpressionResolver,
                     repositoriesService,
                     transportService,
-                    actionFilters
+                    actionFilters,
+                    null,
+                    DefaultRemoteStoreSettings.INSTANCE
                 );
                 nodeEnv = new NodeEnvironment(settings, environment);
                 final NamedXContentRegistry namedXContentRegistry = new NamedXContentRegistry(Collections.emptyList());
@@ -2073,7 +2071,7 @@ public void onFailure(final Exception e) {
                     emptyMap(),
                     null,
                     emptyMap(),
-                    new RemoteSegmentStoreDirectoryFactory(() -> repositoriesService, threadPool),
+                    new RemoteSegmentStoreDirectoryFactory(() -> repositoriesService, threadPool, ""),
                     repositoriesServiceReference::get,
                     null,
                     new RemoteStoreStatsTrackerFactory(clusterService, settings),
@@ -2245,7 +2243,8 @@ public void onFailure(final Exception e) {
                     ),
                     shardLimitValidator,
                     indicesService,
-                    clusterInfoService::getClusterInfo
+                    clusterInfoService::getClusterInfo,
+                    () -> 5.0
                 );
                 actions.put(
                     PutMappingAction.INSTANCE,
@@ -2285,7 +2284,9 @@ public void onFailure(final Exception e) {
                     new FetchPhase(Collections.emptyList()),
                     responseCollectorService,
                     new NoneCircuitBreakerService(),
-                    null
+                    null,
+                    new TaskResourceTrackingService(settings, clusterSettings, threadPool),
+                    Collections.emptyList()
                 );
                 SearchPhaseController searchPhaseController = new SearchPhaseController(
                     writableRegistry(),
@@ -2320,7 +2321,8 @@ public void onFailure(final Exception e) {
                         ),
                         NoopMetricsRegistry.INSTANCE,
                         searchRequestOperationsCompositeListenerFactory,
-                        NoopTracer.INSTANCE
+                        NoopTracer.INSTANCE,
+                        new TaskResourceTrackingService(settings, clusterSettings, threadPool)
                     )
                 );
                 actions.put(
@@ -2366,7 +2368,8 @@ public void onFailure(final Exception e) {
                         snapshotsService,
                         threadPool,
                         actionFilters,
-                        indexNameExpressionResolver
+                        indexNameExpressionResolver,
+                        DefaultRemoteStoreSettings.INSTANCE
                     )
                 );
                 actions.put(
@@ -2376,6 +2379,7 @@ public void onFailure(final Exception e) {
                         clusterService,
                         threadPool,
                         snapshotsService,
+                        repositoriesService,
                         actionFilters,
                         indexNameExpressionResolver
                     )
@@ -2553,7 +2557,9 @@ public void start(ClusterState initialState) {
                     ElectionStrategy.DEFAULT_INSTANCE,
                     () -> new StatusInfo(HEALTHY, "healthy-info"),
                     persistedStateRegistry,
-                    remoteStoreNodeService
+                    remoteStoreNodeService,
+                    new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE),
+                    null
                 );
                 clusterManagerService.setClusterStatePublisher(coordinator);
                 coordinator.start();
diff --git a/server/src/test/java/org/opensearch/snapshots/SnapshotShardPathsTests.java b/server/src/test/java/org/opensearch/snapshots/SnapshotShardPathsTests.java
new file mode 100644
index 0000000000000..15eb70913eb88
--- /dev/null
+++ b/server/src/test/java/org/opensearch/snapshots/SnapshotShardPathsTests.java
@@ -0,0 +1,144 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.snapshots;
+
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.common.xcontent.XContentType;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.index.remote.RemoteStoreEnums;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class SnapshotShardPathsTests extends OpenSearchTestCase {
+
+    public void testToXContent() throws IOException {
+        List<String> paths = Arrays.asList("/path/to/shard/1", "/path/to/shard/2", "/path/to/shard/3");
+        String indexId = "index-id";
+        String indexName = "index-name";
+        int numberOfShards = 5;
+        RemoteStoreEnums.PathType shardPathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
+        RemoteStoreEnums.PathHashAlgorithm shardPathHashAlgorithm = RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+
+        SnapshotShardPaths snapshotShardPaths = new SnapshotShardPaths(
+            paths,
+            indexId,
+            indexName,
+            numberOfShards,
+            shardPathType,
+            shardPathHashAlgorithm
+        );
+
+        BytesReference bytes = XContentHelper.toXContent(snapshotShardPaths, XContentType.JSON, false);
+        String expectedJson =
+            "{\"indexId\":\"index-id\",\"indexName\":\"index-name\",\"number_of_shards\":5,\"shard_path_type\":1,\"shard_path_hash_algorithm\":0,\"paths\":[\"/path/to/shard/1\",\"/path/to/shard/2\",\"/path/to/shard/3\"]}";
+        assertEquals(expectedJson, bytes.utf8ToString());
+    }
+
+    public void testMissingPaths() {
+        List<String> paths = Collections.emptyList();
+        String indexId = "index-id";
+        String indexName = "index-name";
+        int numberOfShards = 5;
+        RemoteStoreEnums.PathType shardPathType = RemoteStoreEnums.PathType.FIXED;
+        RemoteStoreEnums.PathHashAlgorithm shardPathHashAlgorithm = RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1;
+
+        AssertionError exception = expectThrows(
+            AssertionError.class,
+            () -> new SnapshotShardPaths(paths, indexId, indexName, numberOfShards, shardPathType, shardPathHashAlgorithm)
+        );
+        assertTrue(exception.getMessage().contains("paths must not be empty"));
+    }
+
+    public void testMissingIndexId() {
+        List<String> paths = Arrays.asList("/path/to/shard/1", "/path/to/shard/2", "/path/to/shard/3");
+        String indexId = "";
+        String indexName = "index-name";
+        int numberOfShards = 5;
+        RemoteStoreEnums.PathType shardPathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
+        RemoteStoreEnums.PathHashAlgorithm shardPathHashAlgorithm = RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+
+        AssertionError exception = expectThrows(
+            AssertionError.class,
+            () -> new SnapshotShardPaths(paths, indexId, indexName, numberOfShards, shardPathType, shardPathHashAlgorithm)
+        );
+        assertTrue(exception.getMessage().contains("indexId must not be empty"));
+    }
+
+    public void testMissingIndexName() {
+        List<String> paths = Arrays.asList("/path/to/shard/1", "/path/to/shard/2", "/path/to/shard/3");
+        String indexId = "index-id";
+        String indexName = "";
+        int numberOfShards = 5;
+        RemoteStoreEnums.PathType shardPathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
+        RemoteStoreEnums.PathHashAlgorithm shardPathHashAlgorithm = RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+
+        AssertionError exception = expectThrows(
+            AssertionError.class,
+            () -> new SnapshotShardPaths(paths, indexId, indexName, numberOfShards, shardPathType, shardPathHashAlgorithm)
+        );
+        assertTrue(exception.getMessage().contains("indexName must not be empty"));
+    }
+
+    public void testMissingNumberOfShards() {
+        List<String> paths = Arrays.asList("/path/to/shard/1", "/path/to/shard/2", "/path/to/shard/3");
+        String indexId = "index-id";
+        String indexName = "index-name";
+        int numberOfShards = 0;
+        RemoteStoreEnums.PathType shardPathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
+        RemoteStoreEnums.PathHashAlgorithm shardPathHashAlgorithm = RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+
+        AssertionError exception = expectThrows(
+            AssertionError.class,
+            () -> new SnapshotShardPaths(paths, indexId, indexName, numberOfShards, shardPathType, shardPathHashAlgorithm)
+        );
+        assertTrue(exception.getMessage().contains("numberOfShards must be > 0"));
+    }
+
+    public void testMissingShardPathType() {
+        List<String> paths = Arrays.asList("/path/to/shard/1", "/path/to/shard/2", "/path/to/shard/3");
+        String indexId = "index-id";
+        String indexName = "index-name";
+        int numberOfShards = 5;
+        RemoteStoreEnums.PathType shardPathType = null;
+        RemoteStoreEnums.PathHashAlgorithm shardPathHashAlgorithm = RemoteStoreEnums.PathHashAlgorithm.FNV_1A_BASE64;
+
+        AssertionError exception = expectThrows(
+            AssertionError.class,
+            () -> new SnapshotShardPaths(paths, indexId, indexName, numberOfShards, shardPathType, shardPathHashAlgorithm)
+        );
+        assertTrue(exception.getMessage().contains("shardPathType must not be null"));
+    }
+
+    public void testMissingShardPathHashAlgorithm() {
+        List<String> paths = Arrays.asList("/path/to/shard/1", "/path/to/shard/2", "/path/to/shard/3");
+        String indexId = "index-id";
+        String indexName = "index-name";
+        int numberOfShards = 5;
+        RemoteStoreEnums.PathType shardPathType = RemoteStoreEnums.PathType.HASHED_PREFIX;
+        RemoteStoreEnums.PathHashAlgorithm shardPathHashAlgorithm = null;
+
+        AssertionError exception = expectThrows(
+            AssertionError.class,
+            () -> new SnapshotShardPaths(paths, indexId, indexName, numberOfShards, shardPathType, shardPathHashAlgorithm)
+        );
+        assertEquals("shardPathHashAlgorithm must not be null", exception.getMessage());
+    }
+
+    public void testFromXContent() {
+        UnsupportedOperationException exception = expectThrows(
+            UnsupportedOperationException.class,
+            () -> SnapshotShardPaths.fromXContent(null)
+        );
+        assertEquals("SnapshotShardPaths.fromXContent() is not supported", exception.getMessage());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/snapshots/mockstore/MockEventuallyConsistentRepositoryTests.java b/server/src/test/java/org/opensearch/snapshots/mockstore/MockEventuallyConsistentRepositoryTests.java
index 43dde7281fb2d..06a486b3cb997 100644
--- a/server/src/test/java/org/opensearch/snapshots/mockstore/MockEventuallyConsistentRepositoryTests.java
+++ b/server/src/test/java/org/opensearch/snapshots/mockstore/MockEventuallyConsistentRepositoryTests.java
@@ -36,6 +36,7 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.blobstore.BlobContainer;
 import org.opensearch.common.settings.ClusterSettings;
@@ -233,10 +234,12 @@ public void testOverwriteSnapshotInfoBlob() throws Exception {
                     Collections.emptyList(),
                     true,
                     Collections.emptyMap(),
-                    false
+                    false,
+                    0
                 ),
                 Version.CURRENT,
                 Function.identity(),
+                Priority.NORMAL,
                 f
             ));
 
@@ -259,10 +262,12 @@ public void testOverwriteSnapshotInfoBlob() throws Exception {
                             Collections.emptyList(),
                             true,
                             Collections.emptyMap(),
-                            false
+                            false,
+                            0
                         ),
                         Version.CURRENT,
                         Function.identity(),
+                        Priority.NORMAL,
                         f
                     )
                 )
@@ -287,10 +292,12 @@ public void testOverwriteSnapshotInfoBlob() throws Exception {
                         Collections.emptyList(),
                         true,
                         Collections.emptyMap(),
-                        false
+                        false,
+                        0
                     ),
                     Version.CURRENT,
                     Function.identity(),
+                    Priority.NORMAL,
                     f
                 )
             );
diff --git a/server/src/test/java/org/opensearch/tasks/TaskCancellationTests.java b/server/src/test/java/org/opensearch/tasks/TaskCancellationTests.java
index e74f89c905499..f08c12ea258ca 100644
--- a/server/src/test/java/org/opensearch/tasks/TaskCancellationTests.java
+++ b/server/src/test/java/org/opensearch/tasks/TaskCancellationTests.java
@@ -9,7 +9,7 @@
 package org.opensearch.tasks;
 
 import org.opensearch.action.search.SearchShardTask;
-import org.opensearch.search.backpressure.trackers.TaskResourceUsageTracker;
+import org.opensearch.search.backpressure.trackers.TaskResourceUsageTrackers.TaskResourceUsageTracker;
 import org.opensearch.test.OpenSearchTestCase;
 
 import java.util.ArrayList;
@@ -69,7 +69,7 @@ public Optional<TaskCancellation.Reason> checkAndMaybeGetCancellationReason(Task
             }
 
             @Override
-            public Stats stats(List<? extends Task> activeTasks) {
+            public TaskResourceUsageTracker.Stats stats(List<? extends Task> activeTasks) {
                 return null;
             }
         };
diff --git a/server/src/test/java/org/opensearch/tasks/TaskResourceInfoTests.java b/server/src/test/java/org/opensearch/tasks/TaskResourceInfoTests.java
new file mode 100644
index 0000000000000..e0bfb8710bbaa
--- /dev/null
+++ b/server/src/test/java/org/opensearch/tasks/TaskResourceInfoTests.java
@@ -0,0 +1,106 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.tasks;
+
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceInfo;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceUsage;
+import org.opensearch.core.xcontent.MediaTypeRegistry;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Locale;
+
+/**
+ * Test cases for TaskResourceInfo
+ */
+public class TaskResourceInfoTests extends OpenSearchTestCase {
+    private final Long cpuUsage = randomNonNegativeLong();
+    private final Long memoryUsage = randomNonNegativeLong();
+    private final String action = randomAlphaOfLengthBetween(1, 10);
+    private final Long taskId = randomNonNegativeLong();
+    private final Long parentTaskId = randomNonNegativeLong();
+    private final String nodeId = randomAlphaOfLengthBetween(1, 10);
+    private TaskResourceInfo taskResourceInfo;
+    private TaskResourceUsage taskResourceUsage;
+
+    @Before
+    public void setUpVariables() {
+        taskResourceUsage = new TaskResourceUsage(cpuUsage, memoryUsage);
+        taskResourceInfo = new TaskResourceInfo(action, taskId, parentTaskId, nodeId, taskResourceUsage);
+    }
+
+    public void testGetters() {
+        assertEquals(action, taskResourceInfo.getAction());
+        assertEquals(taskId.longValue(), taskResourceInfo.getTaskId());
+        assertEquals(parentTaskId.longValue(), taskResourceInfo.getParentTaskId());
+        assertEquals(nodeId, taskResourceInfo.getNodeId());
+        assertEquals(taskResourceUsage, taskResourceInfo.getTaskResourceUsage());
+    }
+
+    public void testEqualsAndHashCode() {
+        TaskResourceInfo taskResourceInfoCopy = new TaskResourceInfo(action, taskId, parentTaskId, nodeId, taskResourceUsage);
+        assertEquals(taskResourceInfo, taskResourceInfoCopy);
+        assertEquals(taskResourceInfo.hashCode(), taskResourceInfoCopy.hashCode());
+        TaskResourceInfo differentTaskResourceInfo = new TaskResourceInfo(
+            "differentAction",
+            taskId,
+            parentTaskId,
+            nodeId,
+            taskResourceUsage
+        );
+        assertNotEquals(taskResourceInfo, differentTaskResourceInfo);
+        assertNotEquals(taskResourceInfo.hashCode(), differentTaskResourceInfo.hashCode());
+    }
+
+    public void testSerialization() throws IOException {
+        BytesStreamOutput output = new BytesStreamOutput();
+        taskResourceInfo.writeTo(output);
+        StreamInput input = StreamInput.wrap(output.bytes().toBytesRef().bytes);
+        TaskResourceInfo deserializedTaskResourceInfo = TaskResourceInfo.readFromStream(input);
+        assertEquals(taskResourceInfo, deserializedTaskResourceInfo);
+    }
+
+    public void testToString() {
+        String expectedString = String.format(
+            Locale.ROOT,
+            "{\"action\":\"%s\",\"taskId\":%s,\"parentTaskId\":%s,\"nodeId\":\"%s\",\"taskResourceUsage\":{\"cpu_time_in_nanos\":%s,\"memory_in_bytes\":%s}}",
+            action,
+            taskId,
+            parentTaskId,
+            nodeId,
+            taskResourceUsage.getCpuTimeInNanos(),
+            taskResourceUsage.getMemoryInBytes()
+        );
+        assertTrue(expectedString.equals(taskResourceInfo.toString()));
+    }
+
+    public void testToXContent() throws IOException {
+        char[] expectedXcontent = String.format(
+            Locale.ROOT,
+            "{\"action\":\"%s\",\"taskId\":%s,\"parentTaskId\":%s,\"nodeId\":\"%s\",\"taskResourceUsage\":{\"cpu_time_in_nanos\":%s,\"memory_in_bytes\":%s}}",
+            action,
+            taskId,
+            parentTaskId,
+            nodeId,
+            taskResourceUsage.getCpuTimeInNanos(),
+            taskResourceUsage.getMemoryInBytes()
+        ).toCharArray();
+
+        XContentBuilder builder = MediaTypeRegistry.contentBuilder(MediaTypeRegistry.JSON);
+        char[] xContent = BytesReference.bytes(taskResourceInfo.toXContent(builder, ToXContent.EMPTY_PARAMS)).utf8ToString().toCharArray();
+        assertEquals(Arrays.hashCode(expectedXcontent), Arrays.hashCode(xContent));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/tasks/TaskResourceTrackingServiceTests.java b/server/src/test/java/org/opensearch/tasks/TaskResourceTrackingServiceTests.java
index 45d438f8d04c9..0c19c331e1510 100644
--- a/server/src/test/java/org/opensearch/tasks/TaskResourceTrackingServiceTests.java
+++ b/server/src/test/java/org/opensearch/tasks/TaskResourceTrackingServiceTests.java
@@ -9,11 +9,15 @@
 package org.opensearch.tasks;
 
 import org.opensearch.action.admin.cluster.node.tasks.TransportTasksActionTests;
+import org.opensearch.action.search.SearchShardTask;
 import org.opensearch.action.search.SearchTask;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.core.tasks.TaskId;
+import org.opensearch.core.tasks.resourcetracker.ResourceStatsType;
+import org.opensearch.core.tasks.resourcetracker.ResourceUsageMetric;
+import org.opensearch.core.tasks.resourcetracker.TaskResourceInfo;
 import org.opensearch.core.tasks.resourcetracker.ThreadResourceInfo;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.threadpool.TestThreadPool;
@@ -31,6 +35,7 @@
 import static org.opensearch.core.tasks.resourcetracker.ResourceStats.CPU;
 import static org.opensearch.core.tasks.resourcetracker.ResourceStats.MEMORY;
 import static org.opensearch.tasks.TaskResourceTrackingService.TASK_ID;
+import static org.opensearch.tasks.TaskResourceTrackingService.TASK_RESOURCE_USAGE;
 
 public class TaskResourceTrackingServiceTests extends OpenSearchTestCase {
 
@@ -142,6 +147,36 @@ public void testStartingTrackingHandlesMultipleThreadsPerTask() throws Interrupt
         assertEquals(numTasks, numExecutions);
     }
 
+    public void testWriteTaskResourceUsage() {
+        SearchShardTask task = new SearchShardTask(1, "test", "test", "task", TaskId.EMPTY_TASK_ID, new HashMap<>());
+        taskResourceTrackingService.setTaskResourceTrackingEnabled(true);
+        taskResourceTrackingService.startTracking(task);
+        task.startThreadResourceTracking(
+            Thread.currentThread().getId(),
+            ResourceStatsType.WORKER_STATS,
+            new ResourceUsageMetric(CPU, 100),
+            new ResourceUsageMetric(MEMORY, 100)
+        );
+        taskResourceTrackingService.writeTaskResourceUsage(task, "node_1");
+        Map<String, List<String>> headers = threadPool.getThreadContext().getResponseHeaders();
+        assertEquals(1, headers.size());
+        assertTrue(headers.containsKey(TASK_RESOURCE_USAGE));
+    }
+
+    public void testGetTaskResourceUsageFromThreadContext() {
+        String taskResourceUsageJson =
+            "{\"action\":\"testAction\",\"taskId\":1,\"parentTaskId\":2,\"nodeId\":\"nodeId\",\"taskResourceUsage\":{\"cpu_time_in_nanos\":1000,\"memory_in_bytes\":2000}}";
+        threadPool.getThreadContext().addResponseHeader(TASK_RESOURCE_USAGE, taskResourceUsageJson);
+        TaskResourceInfo result = taskResourceTrackingService.getTaskResourceUsageFromThreadContext();
+        assertNotNull(result);
+        assertEquals("testAction", result.getAction());
+        assertEquals(1L, result.getTaskId());
+        assertEquals(2L, result.getParentTaskId());
+        assertEquals("nodeId", result.getNodeId());
+        assertEquals(1000L, result.getTaskResourceUsage().getCpuTimeInNanos());
+        assertEquals(2000L, result.getTaskResourceUsage().getMemoryInBytes());
+    }
+
     private void verifyThreadContextFixedHeaders(String key, String value) {
         assertEquals(threadPool.getThreadContext().getHeader(key), value);
         assertEquals(threadPool.getThreadContext().getTransient(key), value);
diff --git a/server/src/test/java/org/opensearch/telemetry/TestInMemoryCounter.java b/server/src/test/java/org/opensearch/telemetry/TestInMemoryCounter.java
new file mode 100644
index 0000000000000..d9aee5ebfa941
--- /dev/null
+++ b/server/src/test/java/org/opensearch/telemetry/TestInMemoryCounter.java
@@ -0,0 +1,52 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.telemetry;
+
+import org.opensearch.telemetry.metrics.Counter;
+import org.opensearch.telemetry.metrics.tags.Tags;
+
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * This is a simple implementation of Counter which is utilized by TestInMemoryMetricsRegistry for
+ * Unit Tests. It initializes an atomic integer to add the values of counter which doesn't have any tags
+ * along with a map to store the values recorded against the tags.
+ * The map and atomic integer can then be used to get the added values.
+ */
+public class TestInMemoryCounter implements Counter {
+
+    private AtomicInteger counterValue = new AtomicInteger(0);
+    private ConcurrentHashMap<HashMap<String, ?>, Double> counterValueForTags = new ConcurrentHashMap<>();
+
+    public Integer getCounterValue() {
+        return this.counterValue.get();
+    }
+
+    public ConcurrentHashMap<HashMap<String, ?>, Double> getCounterValueForTags() {
+        return this.counterValueForTags;
+    }
+
+    @Override
+    public void add(double value) {
+        counterValue.addAndGet((int) value);
+    }
+
+    @Override
+    public synchronized void add(double value, Tags tags) {
+        HashMap<String, ?> hashMap = (HashMap<String, ?>) tags.getTagsMap();
+        if (counterValueForTags.get(hashMap) == null) {
+            counterValueForTags.put(hashMap, value);
+        } else {
+            value = counterValueForTags.get(hashMap) + value;
+            counterValueForTags.put(hashMap, value);
+        }
+    }
+}
diff --git a/server/src/test/java/org/opensearch/telemetry/TestInMemoryHistogram.java b/server/src/test/java/org/opensearch/telemetry/TestInMemoryHistogram.java
new file mode 100644
index 0000000000000..ff28df2b6529d
--- /dev/null
+++ b/server/src/test/java/org/opensearch/telemetry/TestInMemoryHistogram.java
@@ -0,0 +1,47 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.telemetry;
+
+import org.opensearch.telemetry.metrics.Histogram;
+import org.opensearch.telemetry.metrics.tags.Tags;
+
+import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * This is a simple implementation of Histogram which is utilized by TestInMemoryMetricsRegistry for
+ * Unit Tests. It initializes an atomic integer to record the value of histogram which doesn't have any tags
+ * along with a map to store the values recorded against the tags.
+ * The map and atomic integer can then be used to get the recorded values.
+ */
+public class TestInMemoryHistogram implements Histogram {
+
+    private AtomicInteger histogramValue = new AtomicInteger(0);
+    private ConcurrentHashMap<HashMap<String, ?>, Double> histogramValueForTags = new ConcurrentHashMap<>();
+
+    public Integer getHistogramValue() {
+        return this.histogramValue.get();
+    }
+
+    public ConcurrentHashMap<HashMap<String, ?>, Double> getHistogramValueForTags() {
+        return this.histogramValueForTags;
+    }
+
+    @Override
+    public void record(double value) {
+        histogramValue.addAndGet((int) value);
+    }
+
+    @Override
+    public synchronized void record(double value, Tags tags) {
+        HashMap<String, ?> hashMap = (HashMap<String, ?>) tags.getTagsMap();
+        histogramValueForTags.put(hashMap, value);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/telemetry/TestInMemoryMetricsRegistry.java b/server/src/test/java/org/opensearch/telemetry/TestInMemoryMetricsRegistry.java
new file mode 100644
index 0000000000000..ceda373df1357
--- /dev/null
+++ b/server/src/test/java/org/opensearch/telemetry/TestInMemoryMetricsRegistry.java
@@ -0,0 +1,77 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.telemetry;
+
+import org.opensearch.telemetry.metrics.Counter;
+import org.opensearch.telemetry.metrics.Histogram;
+import org.opensearch.telemetry.metrics.MetricsRegistry;
+import org.opensearch.telemetry.metrics.TaggedMeasurement;
+import org.opensearch.telemetry.metrics.tags.Tags;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+
+/**
+ * This is a simple implementation of MetricsRegistry which can be utilized by Unit Tests.
+ * It just initializes and stores counters/histograms within a map, once created.
+ * The maps can then be used to get the counters/histograms by their names.
+ */
+public class TestInMemoryMetricsRegistry implements MetricsRegistry {
+
+    private ConcurrentHashMap<String, TestInMemoryCounter> counterStore = new ConcurrentHashMap<>();
+    private ConcurrentHashMap<String, TestInMemoryHistogram> histogramStore = new ConcurrentHashMap<>();
+
+    public ConcurrentHashMap<String, TestInMemoryCounter> getCounterStore() {
+        return this.counterStore;
+    }
+
+    public ConcurrentHashMap<String, TestInMemoryHistogram> getHistogramStore() {
+        return this.histogramStore;
+    }
+
+    @Override
+    public Counter createCounter(String name, String description, String unit) {
+        TestInMemoryCounter counter = new TestInMemoryCounter();
+        counterStore.putIfAbsent(name, counter);
+        return counter;
+    }
+
+    @Override
+    public Counter createUpDownCounter(String name, String description, String unit) {
+        /**
+         * ToDo: To be implemented when required.
+         */
+        return null;
+    }
+
+    @Override
+    public Histogram createHistogram(String name, String description, String unit) {
+        TestInMemoryHistogram histogram = new TestInMemoryHistogram();
+        histogramStore.putIfAbsent(name, histogram);
+        return histogram;
+    }
+
+    @Override
+    public Closeable createGauge(String name, String description, String unit, Supplier<Double> valueProvider, Tags tags) {
+        /**
+         * ToDo: To be implemented when required.
+         */
+        return null;
+    }
+
+    @Override
+    public Closeable createGauge(String name, String description, String unit, Supplier<TaggedMeasurement> value) {
+        return null;
+    }
+
+    @Override
+    public void close() throws IOException {}
+}
diff --git a/server/src/test/java/org/opensearch/telemetry/tracing/ThreadContextBasedTracerContextStorageTests.java b/server/src/test/java/org/opensearch/telemetry/tracing/ThreadContextBasedTracerContextStorageTests.java
index bf11bcaf39a96..98dfc367c20f5 100644
--- a/server/src/test/java/org/opensearch/telemetry/tracing/ThreadContextBasedTracerContextStorageTests.java
+++ b/server/src/test/java/org/opensearch/telemetry/tracing/ThreadContextBasedTracerContextStorageTests.java
@@ -12,6 +12,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.concurrent.ThreadContext;
 import org.opensearch.common.util.concurrent.ThreadContext.StoredContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.telemetry.Telemetry;
 import org.opensearch.telemetry.TelemetrySettings;
 import org.opensearch.telemetry.metrics.MetricsTelemetry;
@@ -260,7 +261,7 @@ public void testSpanNotPropagatedToChildSystemThreadContext() {
             try (StoredContext ignored = threadContext.stashContext()) {
                 assertThat(threadContext.getTransient(ThreadContextBasedTracerContextStorage.CURRENT_SPAN), is(not(nullValue())));
                 assertThat(threadContextStorage.get(ThreadContextBasedTracerContextStorage.CURRENT_SPAN), is(span));
-                threadContext.markAsSystemContext();
+                ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
                 assertThat(threadContext.getTransient(ThreadContextBasedTracerContextStorage.CURRENT_SPAN), is(nullValue()));
             }
         }
diff --git a/server/src/test/java/org/opensearch/threadpool/ScalingThreadPoolTests.java b/server/src/test/java/org/opensearch/threadpool/ScalingThreadPoolTests.java
index 97326377ce245..4f59f9688fb7e 100644
--- a/server/src/test/java/org/opensearch/threadpool/ScalingThreadPoolTests.java
+++ b/server/src/test/java/org/opensearch/threadpool/ScalingThreadPoolTests.java
@@ -148,6 +148,7 @@ private int expectedSize(final String threadPoolName, final int numberOfProcesso
         sizes.put(ThreadPool.Names.REFRESH, ThreadPool::halfAllocatedProcessorsMaxTen);
         sizes.put(ThreadPool.Names.WARMER, ThreadPool::halfAllocatedProcessorsMaxFive);
         sizes.put(ThreadPool.Names.SNAPSHOT, ThreadPool::halfAllocatedProcessorsMaxFive);
+        sizes.put(ThreadPool.Names.SNAPSHOT_DELETION, n -> ThreadPool.boundedBy(4 * n, 64, 256));
         sizes.put(ThreadPool.Names.FETCH_SHARD_STARTED, ThreadPool::twiceAllocatedProcessors);
         sizes.put(ThreadPool.Names.FETCH_SHARD_STORE, ThreadPool::twiceAllocatedProcessors);
         sizes.put(ThreadPool.Names.TRANSLOG_TRANSFER, ThreadPool::halfAllocatedProcessors);
@@ -155,6 +156,7 @@ private int expectedSize(final String threadPoolName, final int numberOfProcesso
         sizes.put(ThreadPool.Names.REMOTE_PURGE, ThreadPool::halfAllocatedProcessors);
         sizes.put(ThreadPool.Names.REMOTE_REFRESH_RETRY, ThreadPool::halfAllocatedProcessors);
         sizes.put(ThreadPool.Names.REMOTE_RECOVERY, ThreadPool::twiceAllocatedProcessors);
+        sizes.put(ThreadPool.Names.REMOTE_STATE_READ, ThreadPool::twiceAllocatedProcessors);
         return sizes.get(threadPoolName).apply(numberOfProcessors);
     }
 
diff --git a/server/src/test/java/org/opensearch/transport/InboundAggregatorTests.java b/server/src/test/java/org/opensearch/transport/InboundAggregatorTests.java
index 2dd98a8efe2a3..6168fd1c6a307 100644
--- a/server/src/test/java/org/opensearch/transport/InboundAggregatorTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundAggregatorTests.java
@@ -78,7 +78,7 @@ public void setUp() throws Exception {
 
     public void testInboundAggregation() throws IOException {
         long requestId = randomNonNegativeLong();
-        Header header = new Header(randomInt(), requestId, TransportStatus.setRequest((byte) 0), Version.CURRENT);
+        Header header = new Header(TransportProtocol.NATIVE, randomInt(), requestId, TransportStatus.setRequest((byte) 0), Version.CURRENT);
         header.headers = new Tuple<>(Collections.emptyMap(), Collections.emptyMap());
         header.actionName = "action_name";
         // Initiate Message
@@ -125,7 +125,7 @@ public void testInboundAggregation() throws IOException {
 
     public void testInboundUnknownAction() throws IOException {
         long requestId = randomNonNegativeLong();
-        Header header = new Header(randomInt(), requestId, TransportStatus.setRequest((byte) 0), Version.CURRENT);
+        Header header = new Header(TransportProtocol.NATIVE, randomInt(), requestId, TransportStatus.setRequest((byte) 0), Version.CURRENT);
         header.headers = new Tuple<>(Collections.emptyMap(), Collections.emptyMap());
         header.actionName = unknownAction;
         // Initiate Message
@@ -149,7 +149,13 @@ public void testInboundUnknownAction() throws IOException {
     public void testCircuitBreak() throws IOException {
         circuitBreaker.startBreaking();
         // Actions are breakable
-        Header breakableHeader = new Header(randomInt(), randomNonNegativeLong(), TransportStatus.setRequest((byte) 0), Version.CURRENT);
+        Header breakableHeader = new Header(
+            TransportProtocol.NATIVE,
+            randomInt(),
+            randomNonNegativeLong(),
+            TransportStatus.setRequest((byte) 0),
+            Version.CURRENT
+        );
         breakableHeader.headers = new Tuple<>(Collections.emptyMap(), Collections.emptyMap());
         breakableHeader.actionName = "action_name";
         // Initiate Message
@@ -169,7 +175,13 @@ public void testCircuitBreak() throws IOException {
         assertThat(aggregated1.getException(), instanceOf(CircuitBreakingException.class));
 
         // Actions marked as unbreakable are not broken
-        Header unbreakableHeader = new Header(randomInt(), randomNonNegativeLong(), TransportStatus.setRequest((byte) 0), Version.CURRENT);
+        Header unbreakableHeader = new Header(
+            TransportProtocol.NATIVE,
+            randomInt(),
+            randomNonNegativeLong(),
+            TransportStatus.setRequest((byte) 0),
+            Version.CURRENT
+        );
         unbreakableHeader.headers = new Tuple<>(Collections.emptyMap(), Collections.emptyMap());
         unbreakableHeader.actionName = unBreakableAction;
         // Initiate Message
@@ -188,7 +200,13 @@ public void testCircuitBreak() throws IOException {
 
         // Handshakes are not broken
         final byte handshakeStatus = TransportStatus.setHandshake(TransportStatus.setRequest((byte) 0));
-        Header handshakeHeader = new Header(randomInt(), randomNonNegativeLong(), handshakeStatus, Version.CURRENT);
+        Header handshakeHeader = new Header(
+            TransportProtocol.NATIVE,
+            randomInt(),
+            randomNonNegativeLong(),
+            handshakeStatus,
+            Version.CURRENT
+        );
         handshakeHeader.headers = new Tuple<>(Collections.emptyMap(), Collections.emptyMap());
         handshakeHeader.actionName = "handshake";
         // Initiate Message
@@ -208,7 +226,7 @@ public void testCircuitBreak() throws IOException {
 
     public void testCloseWillCloseContent() {
         long requestId = randomNonNegativeLong();
-        Header header = new Header(randomInt(), requestId, TransportStatus.setRequest((byte) 0), Version.CURRENT);
+        Header header = new Header(TransportProtocol.NATIVE, randomInt(), requestId, TransportStatus.setRequest((byte) 0), Version.CURRENT);
         header.headers = new Tuple<>(Collections.emptyMap(), Collections.emptyMap());
         header.actionName = "action_name";
         // Initiate Message
@@ -248,7 +266,7 @@ public void testFinishAggregationWillFinishHeader() throws IOException {
         } else {
             actionName = "action_name";
         }
-        Header header = new Header(randomInt(), requestId, TransportStatus.setRequest((byte) 0), Version.CURRENT);
+        Header header = new Header(TransportProtocol.NATIVE, randomInt(), requestId, TransportStatus.setRequest((byte) 0), Version.CURRENT);
         // Initiate Message
         aggregator.headerReceived(header);
 
diff --git a/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
index ea656f6651b1e..7779db9dacc3c 100644
--- a/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundHandlerTests.java
@@ -151,7 +151,7 @@ public void testPing() throws Exception {
         );
         requestHandlers.registerHandler(registry);
 
-        handler.inboundMessage(channel, new InboundMessage(null, true));
+        handler.inboundMessage(channel, InboundMessage.PING);
         if (channel.isServerChannel()) {
             BytesReference ping = channel.getMessageCaptor().get();
             assertEquals('E', ping.get(0));
@@ -214,7 +214,13 @@ public TestResponse read(StreamInput in) throws IOException {
             false
         );
         BytesReference requestContent = fullRequestBytes.slice(headerSize, fullRequestBytes.length() - headerSize);
-        Header requestHeader = new Header(fullRequestBytes.length() - 6, requestId, TransportStatus.setRequest((byte) 0), version);
+        Header requestHeader = new Header(
+            TransportProtocol.NATIVE,
+            fullRequestBytes.length() - 6,
+            requestId,
+            TransportStatus.setRequest((byte) 0),
+            version
+        );
         InboundMessage requestMessage = new InboundMessage(requestHeader, ReleasableBytesReference.wrap(requestContent), () -> {});
         requestHeader.finishParsingHeader(requestMessage.openOrGetStreamInput());
         handler.inboundMessage(channel, requestMessage);
@@ -235,7 +241,7 @@ public TestResponse read(StreamInput in) throws IOException {
 
         BytesReference fullResponseBytes = channel.getMessageCaptor().get();
         BytesReference responseContent = fullResponseBytes.slice(headerSize, fullResponseBytes.length() - headerSize);
-        Header responseHeader = new Header(fullResponseBytes.length() - 6, requestId, responseStatus, version);
+        Header responseHeader = new Header(TransportProtocol.NATIVE, fullResponseBytes.length() - 6, requestId, responseStatus, version);
         InboundMessage responseMessage = new InboundMessage(responseHeader, ReleasableBytesReference.wrap(responseContent), () -> {});
         responseHeader.finishParsingHeader(responseMessage.openOrGetStreamInput());
         handler.inboundMessage(channel, responseMessage);
@@ -258,6 +264,7 @@ public void testSendsErrorResponseToHandshakeFromCompatibleVersion() throws Exce
         final Version remoteVersion = VersionUtils.randomCompatibleVersion(random(), version);
         final long requestId = randomNonNegativeLong();
         final Header requestHeader = new Header(
+            TransportProtocol.NATIVE,
             between(0, 100),
             requestId,
             TransportStatus.setRequest(TransportStatus.setHandshake((byte) 0)),
@@ -298,6 +305,7 @@ public void testClosesChannelOnErrorInHandshakeWithIncompatibleVersion() throws
             final Version remoteVersion = Version.fromId(randomIntBetween(0, version.minimumCompatibilityVersion().id - 1));
             final long requestId = randomNonNegativeLong();
             final Header requestHeader = new Header(
+                TransportProtocol.NATIVE,
                 between(0, 100),
                 requestId,
                 TransportStatus.setRequest(TransportStatus.setHandshake((byte) 0)),
@@ -329,6 +337,7 @@ public void testLogsSlowInboundProcessing() throws Exception {
             final Version remoteVersion = Version.CURRENT;
             final long requestId = randomNonNegativeLong();
             final Header requestHeader = new Header(
+                TransportProtocol.NATIVE,
                 between(0, 100),
                 requestId,
                 TransportStatus.setRequest(TransportStatus.setHandshake((byte) 0)),
@@ -411,7 +420,13 @@ public void onResponseSent(long requestId, String action, Exception error) {
 
         BytesReference fullRequestBytes = BytesReference.fromByteBuffer((ByteBuffer) buffer.flip());
         BytesReference requestContent = fullRequestBytes.slice(headerSize, fullRequestBytes.length() - headerSize);
-        Header requestHeader = new Header(fullRequestBytes.length() - 6, requestId, TransportStatus.setRequest((byte) 0), version);
+        Header requestHeader = new Header(
+            TransportProtocol.NATIVE,
+            fullRequestBytes.length() - 6,
+            requestId,
+            TransportStatus.setRequest((byte) 0),
+            version
+        );
         InboundMessage requestMessage = new InboundMessage(requestHeader, ReleasableBytesReference.wrap(requestContent), () -> {});
         requestHeader.finishParsingHeader(requestMessage.openOrGetStreamInput());
         handler.inboundMessage(channel, requestMessage);
@@ -476,7 +491,13 @@ public void onResponseSent(long requestId, String action, Exception error) {
         );
         // Create the request payload by intentionally stripping 1 byte away
         BytesReference requestContent = fullRequestBytes.slice(headerSize, fullRequestBytes.length() - headerSize - 1);
-        Header requestHeader = new Header(fullRequestBytes.length() - 6, requestId, TransportStatus.setRequest((byte) 0), version);
+        Header requestHeader = new Header(
+            TransportProtocol.NATIVE,
+            fullRequestBytes.length() - 6,
+            requestId,
+            TransportStatus.setRequest((byte) 0),
+            version
+        );
         InboundMessage requestMessage = new InboundMessage(requestHeader, ReleasableBytesReference.wrap(requestContent), () -> {});
         requestHeader.finishParsingHeader(requestMessage.openOrGetStreamInput());
         handler.inboundMessage(channel, requestMessage);
@@ -540,7 +561,13 @@ public TestResponse read(StreamInput in) throws IOException {
             false
         );
         BytesReference requestContent = fullRequestBytes.slice(headerSize, fullRequestBytes.length() - headerSize);
-        Header requestHeader = new Header(fullRequestBytes.length() - 6, requestId, TransportStatus.setRequest((byte) 0), version);
+        Header requestHeader = new Header(
+            TransportProtocol.NATIVE,
+            fullRequestBytes.length() - 6,
+            requestId,
+            TransportStatus.setRequest((byte) 0),
+            version
+        );
         InboundMessage requestMessage = new InboundMessage(requestHeader, ReleasableBytesReference.wrap(requestContent), () -> {});
         requestHeader.finishParsingHeader(requestMessage.openOrGetStreamInput());
         handler.inboundMessage(channel, requestMessage);
@@ -562,7 +589,7 @@ public TestResponse read(StreamInput in) throws IOException {
 
         BytesReference fullResponseBytes = BytesReference.fromByteBuffer((ByteBuffer) buffer.flip());
         BytesReference responseContent = fullResponseBytes.slice(headerSize, fullResponseBytes.length() - headerSize);
-        Header responseHeader = new Header(fullResponseBytes.length() - 6, requestId, responseStatus, version);
+        Header responseHeader = new Header(TransportProtocol.NATIVE, fullResponseBytes.length() - 6, requestId, responseStatus, version);
         InboundMessage responseMessage = new InboundMessage(responseHeader, ReleasableBytesReference.wrap(responseContent), () -> {});
         responseHeader.finishParsingHeader(responseMessage.openOrGetStreamInput());
         handler.inboundMessage(channel, responseMessage);
@@ -626,7 +653,13 @@ public TestResponse read(StreamInput in) throws IOException {
             false
         );
         BytesReference requestContent = fullRequestBytes.slice(headerSize, fullRequestBytes.length() - headerSize);
-        Header requestHeader = new Header(fullRequestBytes.length() - 6, requestId, TransportStatus.setRequest((byte) 0), version);
+        Header requestHeader = new Header(
+            TransportProtocol.NATIVE,
+            fullRequestBytes.length() - 6,
+            requestId,
+            TransportStatus.setRequest((byte) 0),
+            version
+        );
         InboundMessage requestMessage = new InboundMessage(requestHeader, ReleasableBytesReference.wrap(requestContent), () -> {});
         requestHeader.finishParsingHeader(requestMessage.openOrGetStreamInput());
         handler.inboundMessage(channel, requestMessage);
@@ -643,7 +676,7 @@ public TestResponse read(StreamInput in) throws IOException {
         BytesReference fullResponseBytes = channel.getMessageCaptor().get();
         // Create the response payload by intentionally stripping 1 byte away
         BytesReference responseContent = fullResponseBytes.slice(headerSize, fullResponseBytes.length() - headerSize - 1);
-        Header responseHeader = new Header(fullResponseBytes.length() - 6, requestId, responseStatus, version);
+        Header responseHeader = new Header(TransportProtocol.NATIVE, fullResponseBytes.length() - 6, requestId, responseStatus, version);
         InboundMessage responseMessage = new InboundMessage(responseHeader, ReleasableBytesReference.wrap(responseContent), () -> {});
         responseHeader.finishParsingHeader(responseMessage.openOrGetStreamInput());
         handler.inboundMessage(channel, responseMessage);
diff --git a/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java b/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
index 74457e2b153fd..cd6c4cf260176 100644
--- a/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
+++ b/server/src/test/java/org/opensearch/transport/InboundPipelineTests.java
@@ -81,9 +81,8 @@ public void testPipelineHandlingForNativeProtocol() throws IOException {
         final List<Tuple<MessageData, Exception>> expected = new ArrayList<>();
         final List<Tuple<MessageData, Exception>> actual = new ArrayList<>();
         final List<ReleasableBytesReference> toRelease = new ArrayList<>();
-        final BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler = (c, m) -> {
+        final BiConsumer<TcpChannel, InboundMessage> messageHandler = (c, message) -> {
             try {
-                InboundMessage message = (InboundMessage) m;
                 final Header header = message.getHeader();
                 final MessageData actualData;
                 final Version version = header.getVersion();
@@ -198,7 +197,7 @@ public void testPipelineHandlingForNativeProtocol() throws IOException {
     }
 
     public void testDecodeExceptionIsPropagated() throws IOException {
-        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler = (c, m) -> {};
+        BiConsumer<TcpChannel, InboundMessage> messageHandler = (c, m) -> {};
         final StatsTracker statsTracker = new StatsTracker();
         final LongSupplier millisSupplier = () -> TimeValue.nsecToMSec(System.nanoTime());
         final InboundDecoder decoder = new InboundDecoder(Version.CURRENT, PageCacheRecycler.NON_RECYCLING_INSTANCE);
@@ -228,7 +227,7 @@ public void testDecodeExceptionIsPropagated() throws IOException {
     }
 
     public void testEnsureBodyIsNotPrematurelyReleased() throws IOException {
-        BiConsumer<TcpChannel, ProtocolInboundMessage> messageHandler = (c, m) -> {};
+        BiConsumer<TcpChannel, InboundMessage> messageHandler = (c, m) -> {};
         final StatsTracker statsTracker = new StatsTracker();
         final LongSupplier millisSupplier = () -> TimeValue.nsecToMSec(System.nanoTime());
         final InboundDecoder decoder = new InboundDecoder(Version.CURRENT, PageCacheRecycler.NON_RECYCLING_INSTANCE);
diff --git a/server/src/test/java/org/opensearch/transport/NativeOutboundHandlerTests.java b/server/src/test/java/org/opensearch/transport/NativeOutboundHandlerTests.java
index a42a896e373bc..11ca683c306bf 100644
--- a/server/src/test/java/org/opensearch/transport/NativeOutboundHandlerTests.java
+++ b/server/src/test/java/org/opensearch/transport/NativeOutboundHandlerTests.java
@@ -105,9 +105,8 @@ public void setUp() throws Exception {
         final InboundAggregator aggregator = new InboundAggregator(breaker, (Predicate<String>) action -> true);
         pipeline = new InboundPipeline(statsTracker, millisSupplier, decoder, aggregator, (c, m) -> {
             try (BytesStreamOutput streamOutput = new BytesStreamOutput()) {
-                InboundMessage m1 = (InboundMessage) m;
-                Streams.copy(m1.openOrGetStreamInput(), streamOutput);
-                message.set(new Tuple<>(m1.getHeader(), streamOutput.bytes()));
+                Streams.copy(m.openOrGetStreamInput(), streamOutput);
+                message.set(new Tuple<>(m.getHeader(), streamOutput.bytes()));
             } catch (IOException e) {
                 throw new AssertionError(e);
             }
diff --git a/server/src/test/java/org/opensearch/transport/TransportProtocolTests.java b/server/src/test/java/org/opensearch/transport/TransportProtocolTests.java
new file mode 100644
index 0000000000000..024d3281fb76e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/transport/TransportProtocolTests.java
@@ -0,0 +1,22 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.transport;
+
+import org.opensearch.test.OpenSearchTestCase;
+
+public class TransportProtocolTests extends OpenSearchTestCase {
+
+    public void testNativeProtocol() {
+        assertEquals(TransportProtocol.NATIVE, TransportProtocol.fromBytes((byte) 'E', (byte) 'S'));
+    }
+
+    public void testInvalidProtocol() {
+        assertThrows(IllegalArgumentException.class, () -> TransportProtocol.fromBytes((byte) 'e', (byte) 'S'));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/MutableQueryGroupFragmentTests.java b/server/src/test/java/org/opensearch/wlm/MutableQueryGroupFragmentTests.java
new file mode 100644
index 0000000000000..cfe53ddbd2c14
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/MutableQueryGroupFragmentTests.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.common.io.stream.BytesStreamOutput;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class MutableQueryGroupFragmentTests extends OpenSearchTestCase {
+
+    public void testSerializationDeserialization() throws IOException {
+        Map<ResourceType, Double> resourceLimits = new HashMap<>();
+        resourceLimits.put(ResourceType.CPU, 0.5);
+        resourceLimits.put(ResourceType.MEMORY, 0.75);
+        MutableQueryGroupFragment mutableQueryGroupFragment = new MutableQueryGroupFragment(
+            MutableQueryGroupFragment.ResiliencyMode.SOFT,
+            resourceLimits
+        );
+        BytesStreamOutput out = new BytesStreamOutput();
+        mutableQueryGroupFragment.writeTo(out);
+        StreamInput in = out.bytes().streamInput();
+        MutableQueryGroupFragment deserializedGroup = new MutableQueryGroupFragment(in);
+        assertEquals(mutableQueryGroupFragment, deserializedGroup);
+    }
+
+    public void testSerializationDeserializationWithNull() throws IOException {
+        MutableQueryGroupFragment mutableQueryGroupFragment = new MutableQueryGroupFragment();
+        BytesStreamOutput out = new BytesStreamOutput();
+        mutableQueryGroupFragment.writeTo(out);
+        StreamInput in = out.bytes().streamInput();
+        MutableQueryGroupFragment deserializedGroup = new MutableQueryGroupFragment(in);
+        assertEquals(0, deserializedGroup.getResourceLimits().size());
+        assertEquals(mutableQueryGroupFragment.getResiliencyMode(), deserializedGroup.getResiliencyMode());
+    }
+
+    public void testValidateResourceLimits() {
+        Map<ResourceType, Double> invalidLimits = new HashMap<>();
+        invalidLimits.put(ResourceType.CPU, 1.5);
+        Exception exception = assertThrows(IllegalArgumentException.class, () -> {
+            MutableQueryGroupFragment.validateResourceLimits(invalidLimits);
+        });
+        String expectedMessage = "resource value should be greater than 0 and less or equal to 1.0";
+        String actualMessage = exception.getMessage();
+        assertTrue(actualMessage.contains(expectedMessage));
+    }
+
+    public void testSetMethodsWithNullAndEmptyValues() {
+        MutableQueryGroupFragment queryGroup = new MutableQueryGroupFragment();
+        queryGroup.setResiliencyMode(null);
+        assertNull(queryGroup.getResiliencyMode());
+        queryGroup.setResourceLimits(null);
+        assertNull(queryGroup.getResourceLimits());
+        queryGroup.setResourceLimits(new HashMap<>());
+        assertEquals(0, queryGroup.getResourceLimits().size());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/QueryGroupLevelResourceUsageViewTests.java b/server/src/test/java/org/opensearch/wlm/QueryGroupLevelResourceUsageViewTests.java
new file mode 100644
index 0000000000000..532bf3de95bd6
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/QueryGroupLevelResourceUsageViewTests.java
@@ -0,0 +1,63 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.action.search.SearchAction;
+import org.opensearch.core.tasks.TaskId;
+import org.opensearch.tasks.Task;
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public class QueryGroupLevelResourceUsageViewTests extends OpenSearchTestCase {
+    Map<ResourceType, Long> resourceUsage;
+    List<Task> activeTasks;
+
+    public void setUp() throws Exception {
+        super.setUp();
+        resourceUsage = Map.of(ResourceType.fromName("memory"), 34L, ResourceType.fromName("cpu"), 12L);
+        activeTasks = List.of(getRandomTask(4321));
+    }
+
+    public void testGetResourceUsageData() {
+        QueryGroupLevelResourceUsageView queryGroupLevelResourceUsageView = new QueryGroupLevelResourceUsageView(
+            resourceUsage,
+            activeTasks
+        );
+        Map<ResourceType, Long> resourceUsageData = queryGroupLevelResourceUsageView.getResourceUsageData();
+        assertTrue(assertResourceUsageData(resourceUsageData));
+    }
+
+    public void testGetActiveTasks() {
+        QueryGroupLevelResourceUsageView queryGroupLevelResourceUsageView = new QueryGroupLevelResourceUsageView(
+            resourceUsage,
+            activeTasks
+        );
+        List<Task> activeTasks = queryGroupLevelResourceUsageView.getActiveTasks();
+        assertEquals(1, activeTasks.size());
+        assertEquals(4321, activeTasks.get(0).getId());
+    }
+
+    private boolean assertResourceUsageData(Map<ResourceType, Long> resourceUsageData) {
+        return resourceUsageData.get(ResourceType.fromName("memory")) == 34L && resourceUsageData.get(ResourceType.fromName("cpu")) == 12L;
+    }
+
+    private Task getRandomTask(long id) {
+        return new Task(
+            id,
+            "transport",
+            SearchAction.NAME,
+            "test description",
+            new TaskId(randomLong() + ":" + randomLong()),
+            Collections.emptyMap()
+        );
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/QueryGroupTaskTests.java b/server/src/test/java/org/opensearch/wlm/QueryGroupTaskTests.java
new file mode 100644
index 0000000000000..d292809c30124
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/QueryGroupTaskTests.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+
+import java.util.Collections;
+
+import static org.opensearch.wlm.QueryGroupTask.DEFAULT_QUERY_GROUP_ID_SUPPLIER;
+import static org.opensearch.wlm.QueryGroupTask.QUERY_GROUP_ID_HEADER;
+
+public class QueryGroupTaskTests extends OpenSearchTestCase {
+    private ThreadPool threadPool;
+    private QueryGroupTask sut;
+
+    public void setUp() throws Exception {
+        super.setUp();
+        threadPool = new TestThreadPool(getTestName());
+        sut = new QueryGroupTask(123, "transport", "Search", "test task", null, Collections.emptyMap());
+    }
+
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testSuccessfulSetQueryGroupId() {
+        sut.setQueryGroupId(threadPool.getThreadContext());
+        assertEquals(DEFAULT_QUERY_GROUP_ID_SUPPLIER.get(), sut.getQueryGroupId());
+
+        threadPool.getThreadContext().putHeader(QUERY_GROUP_ID_HEADER, "akfanglkaglknag2332");
+
+        sut.setQueryGroupId(threadPool.getThreadContext());
+        assertEquals("akfanglkaglknag2332", sut.getQueryGroupId());
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/QueryGroupThreadContextStatePropagatorTests.java b/server/src/test/java/org/opensearch/wlm/QueryGroupThreadContextStatePropagatorTests.java
new file mode 100644
index 0000000000000..ad5d7f569a56e
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/QueryGroupThreadContextStatePropagatorTests.java
@@ -0,0 +1,30 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.test.OpenSearchTestCase;
+
+import java.util.Map;
+
+public class QueryGroupThreadContextStatePropagatorTests extends OpenSearchTestCase {
+
+    public void testTransients() {
+        QueryGroupThreadContextStatePropagator sut = new QueryGroupThreadContextStatePropagator();
+        Map<String, Object> source = Map.of("queryGroupId", "adgarja0r235te");
+        Map<String, Object> transients = sut.transients(source);
+        assertEquals("adgarja0r235te", transients.get("queryGroupId"));
+    }
+
+    public void testHeaders() {
+        QueryGroupThreadContextStatePropagator sut = new QueryGroupThreadContextStatePropagator();
+        Map<String, Object> source = Map.of("queryGroupId", "adgarja0r235te");
+        Map<String, String> headers = sut.headers(source);
+        assertEquals("adgarja0r235te", headers.get("queryGroupId"));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/ResourceTypeTests.java b/server/src/test/java/org/opensearch/wlm/ResourceTypeTests.java
new file mode 100644
index 0000000000000..737cbb37b554c
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/ResourceTypeTests.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.action.search.SearchShardTask;
+import org.opensearch.core.tasks.resourcetracker.ResourceStats;
+import org.opensearch.tasks.CancellableTask;
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class ResourceTypeTests extends OpenSearchTestCase {
+
+    public void testFromName() {
+        assertSame(ResourceType.CPU, ResourceType.fromName("cpu"));
+        assertThrows(IllegalArgumentException.class, () -> { ResourceType.fromName("CPU"); });
+        assertThrows(IllegalArgumentException.class, () -> { ResourceType.fromName("Cpu"); });
+
+        assertSame(ResourceType.MEMORY, ResourceType.fromName("memory"));
+        assertThrows(IllegalArgumentException.class, () -> { ResourceType.fromName("Memory"); });
+        assertThrows(IllegalArgumentException.class, () -> { ResourceType.fromName("MEMORY"); });
+        assertThrows(IllegalArgumentException.class, () -> { ResourceType.fromName("JVM"); });
+        assertThrows(IllegalArgumentException.class, () -> { ResourceType.fromName("Heap"); });
+        assertThrows(IllegalArgumentException.class, () -> { ResourceType.fromName("Disk"); });
+    }
+
+    public void testGetName() {
+        assertEquals("cpu", ResourceType.CPU.getName());
+        assertEquals("memory", ResourceType.MEMORY.getName());
+    }
+
+    public void testGetResourceUsage() {
+        SearchShardTask mockTask = createMockTask(SearchShardTask.class, 100, 200);
+        assertEquals(100, ResourceType.CPU.getResourceUsage(mockTask));
+        assertEquals(200, ResourceType.MEMORY.getResourceUsage(mockTask));
+    }
+
+    private <T extends CancellableTask> T createMockTask(Class<T> type, long cpuUsage, long heapUsage) {
+        T task = mock(type);
+        when(task.getTotalResourceUtilization(ResourceStats.CPU)).thenReturn(cpuUsage);
+        when(task.getTotalResourceUtilization(ResourceStats.MEMORY)).thenReturn(heapUsage);
+        return task;
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/WorkloadManagementSettingsTests.java b/server/src/test/java/org/opensearch/wlm/WorkloadManagementSettingsTests.java
new file mode 100644
index 0000000000000..0f183555781d3
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/WorkloadManagementSettingsTests.java
@@ -0,0 +1,241 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
+import org.opensearch.test.OpenSearchTestCase;
+
+import static org.opensearch.wlm.WorkloadManagementSettings.NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME;
+import static org.opensearch.wlm.WorkloadManagementSettings.NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME;
+import static org.opensearch.wlm.WorkloadManagementSettings.NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME;
+import static org.opensearch.wlm.WorkloadManagementSettings.NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME;
+
+public class WorkloadManagementSettingsTests extends OpenSearchTestCase {
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.memory_rejection_threshold}
+     * When the value is set more than {@code wlm.query_group.node.memory_cancellation_threshold} accidentally during
+     * new feature development. This test is to ensure that {@link WorkloadManagementSettings} holds the
+     * invariant {@code nodeLevelRejectionThreshold < nodeLevelCancellationThreshold}
+     */
+    public void testInvalidMemoryInstantiationOfWorkloadManagementSettings() {
+        Settings settings = Settings.builder()
+            .put(NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME, 0.8)
+            .put(NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME, 0.7)
+            .build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+
+        assertThrows(IllegalArgumentException.class, () -> new WorkloadManagementSettings(settings, cs));
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.cpu_rejection_threshold}
+     * When the value is set more than {@code wlm.query_group.node.cpu_cancellation_threshold} accidentally during
+     * new feature development. This test is to ensure that {@link WorkloadManagementSettings} holds the
+     * invariant {@code nodeLevelRejectionThreshold < nodeLevelCancellationThreshold}
+     */
+    public void testInvalidCpuInstantiationOfWorkloadManagementSettings() {
+        Settings settings = Settings.builder()
+            .put(NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME, 0.8)
+            .put(NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME, 0.7)
+            .build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+
+        assertThrows(IllegalArgumentException.class, () -> new WorkloadManagementSettings(settings, cs));
+    }
+
+    /**
+     * Tests the valid value for {@code wlm.query_group.node.cpu_rejection_threshold}
+     * Using setNodeLevelCpuRejectionThreshold function
+     */
+    public void testValidNodeLevelCpuRejectionThresholdCase1() {
+        Settings settings = Settings.builder().put(NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME, 0.8).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        workloadManagementSettings.setNodeLevelCpuRejectionThreshold(0.7);
+        assertEquals(0.7, workloadManagementSettings.getNodeLevelCpuRejectionThreshold(), 1e-9);
+    }
+
+    /**
+     * Tests the valid value for {@code wlm.query_group.node.cpu_rejection_threshold}
+     */
+    public void testValidNodeLevelCpuRejectionThresholdCase2() {
+        Settings settings = Settings.builder().put(NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME, 0.79).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertEquals(0.79, workloadManagementSettings.getNodeLevelCpuRejectionThreshold(), 1e-9);
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.cpu_rejection_threshold}
+     * When the value is set more than {@literal 0.9}
+     */
+    public void testInvalidNodeLevelCpuRejectionThresholdCase1() {
+        Settings settings = Settings.builder().put(NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME, 0.8).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertThrows(IllegalArgumentException.class, () -> workloadManagementSettings.setNodeLevelCpuRejectionThreshold(0.95));
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.cpu_rejection_threshold}
+     * When the value is set more than {@code wlm.query_group.node.cpu_cancellation_threshold}
+     */
+    public void testInvalidNodeLevelCpuRejectionThresholdCase2() {
+        Settings settings = Settings.builder()
+            .put(NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME, 0.7)
+            .put(NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME, 0.8)
+            .build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertThrows(IllegalArgumentException.class, () -> workloadManagementSettings.setNodeLevelCpuRejectionThreshold(0.85));
+    }
+
+    /**
+     * Tests the valid value for {@code wlm.query_group.node.cpu_cancellation_threshold}
+     */
+    public void testValidNodeLevelCpuCancellationThresholdCase1() {
+        Settings settings = Settings.builder().put(NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME, 0.8).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertEquals(0.8, workloadManagementSettings.getNodeLevelCpuRejectionThreshold(), 1e-9);
+    }
+
+    /**
+     * Tests the valid value for {@code wlm.query_group.node.cpu_cancellation_threshold}
+     * Using setNodeLevelCpuCancellationThreshold function
+     */
+    public void testValidNodeLevelCpuCancellationThresholdCase2() {
+        Settings settings = Settings.builder().put(NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME, 0.8).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        workloadManagementSettings.setNodeLevelCpuCancellationThreshold(0.83);
+        assertEquals(0.83, workloadManagementSettings.getNodeLevelCpuCancellationThreshold(), 1e-9);
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.cpu_cancellation_threshold}
+     * When the value is set more than {@literal 0.95}
+     */
+    public void testInvalidNodeLevelCpuCancellationThresholdCase1() {
+        Settings settings = Settings.builder().put(NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME, 0.9).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertThrows(IllegalArgumentException.class, () -> workloadManagementSettings.setNodeLevelCpuCancellationThreshold(0.96));
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.cpu_cancellation_threshold}
+     * When the value is set less than {@code wlm.query_group.node.cpu_rejection_threshold}
+     */
+    public void testInvalidNodeLevelCpuCancellationThresholdCase2() {
+        Settings settings = Settings.builder()
+            .put(NODE_CPU_REJECTION_THRESHOLD_SETTING_NAME, 0.7)
+            .put(NODE_CPU_CANCELLATION_THRESHOLD_SETTING_NAME, 0.8)
+            .build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertThrows(IllegalArgumentException.class, () -> workloadManagementSettings.setNodeLevelCpuCancellationThreshold(0.65));
+    }
+
+    /**
+     * Tests the valid value for {@code wlm.query_group.node.memory_cancellation_threshold}
+     */
+    public void testValidNodeLevelMemoryCancellationThresholdCase1() {
+        Settings settings = Settings.builder().put(NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME, 0.8).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertEquals(0.8, workloadManagementSettings.getNodeLevelMemoryCancellationThreshold(), 1e-9);
+    }
+
+    /**
+     * Tests the valid value for {@code wlm.query_group.node.memory_cancellation_threshold}
+     * Using setNodeLevelMemoryCancellationThreshold function
+     */
+    public void testValidNodeLevelMemoryCancellationThresholdCase2() {
+        Settings settings = Settings.builder().put(NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME, 0.8).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        workloadManagementSettings.setNodeLevelMemoryCancellationThreshold(0.83);
+        assertEquals(0.83, workloadManagementSettings.getNodeLevelMemoryCancellationThreshold(), 1e-9);
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.memory_cancellation_threshold}
+     * When the value is set more than {@literal 0.95}
+     */
+    public void testInvalidNodeLevelMemoryCancellationThresholdCase1() {
+        Settings settings = Settings.builder().put(NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME, 0.9).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertThrows(IllegalArgumentException.class, () -> workloadManagementSettings.setNodeLevelMemoryCancellationThreshold(0.96));
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.memory_cancellation_threshold}
+     * When the value is set less than {@code wlm.query_group.node.memory_rejection_threshold}
+     */
+    public void testInvalidNodeLevelMemoryCancellationThresholdCase2() {
+        Settings settings = Settings.builder()
+            .put(NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME, 0.7)
+            .put(NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME, 0.8)
+            .build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertThrows(IllegalArgumentException.class, () -> workloadManagementSettings.setNodeLevelMemoryCancellationThreshold(0.65));
+    }
+
+    /**
+     * Tests the valid value for {@code wlm.query_group.node.memory_rejection_threshold}
+     */
+    public void testValidNodeLevelMemoryRejectionThresholdCase1() {
+        Settings settings = Settings.builder().put(NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME, 0.79).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertEquals(0.79, workloadManagementSettings.getNodeLevelMemoryRejectionThreshold(), 1e-9);
+    }
+
+    /**
+     * Tests the valid value for {@code wlm.query_group.node.memory_rejection_threshold}
+     * Using setNodeLevelMemoryRejectionThreshold function
+     */
+    public void testValidNodeLevelMemoryRejectionThresholdCase2() {
+        Settings settings = Settings.builder().put(NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME, 0.9).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        workloadManagementSettings.setNodeLevelMemoryRejectionThreshold(0.86);
+        assertEquals(0.86, workloadManagementSettings.getNodeLevelMemoryRejectionThreshold(), 1e-9);
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.memory_rejection_threshold}
+     * When the value is set more than {@literal 0.9}
+     */
+    public void testInvalidNodeLevelMemoryRejectionThresholdCase1() {
+        Settings settings = Settings.builder().put(NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME, 0.9).build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertThrows(IllegalArgumentException.class, () -> workloadManagementSettings.setNodeLevelMemoryRejectionThreshold(0.92));
+    }
+
+    /**
+     * Tests the invalid value for {@code wlm.query_group.node.memory_rejection_threshold}
+     * When the value is set more than {@code wlm.query_group.node.memory_cancellation_threshold}
+     */
+    public void testInvalidNodeLevelMemoryRejectionThresholdCase2() {
+        Settings settings = Settings.builder()
+            .put(NODE_MEMORY_REJECTION_THRESHOLD_SETTING_NAME, 0.7)
+            .put(NODE_MEMORY_CANCELLATION_THRESHOLD_SETTING_NAME, 0.8)
+            .build();
+        ClusterSettings cs = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        WorkloadManagementSettings workloadManagementSettings = new WorkloadManagementSettings(settings, cs);
+        assertThrows(IllegalArgumentException.class, () -> workloadManagementSettings.setNodeLevelMemoryRejectionThreshold(0.85));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/WorkloadManagementTransportInterceptorTests.java b/server/src/test/java/org/opensearch/wlm/WorkloadManagementTransportInterceptorTests.java
new file mode 100644
index 0000000000000..4668b845150a9
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/WorkloadManagementTransportInterceptorTests.java
@@ -0,0 +1,40 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportRequest;
+import org.opensearch.transport.TransportRequestHandler;
+import org.opensearch.wlm.WorkloadManagementTransportInterceptor.RequestHandler;
+
+import static org.opensearch.threadpool.ThreadPool.Names.SAME;
+
+public class WorkloadManagementTransportInterceptorTests extends OpenSearchTestCase {
+
+    private ThreadPool threadPool;
+    private WorkloadManagementTransportInterceptor sut;
+
+    public void setUp() throws Exception {
+        super.setUp();
+        threadPool = new TestThreadPool(getTestName());
+        sut = new WorkloadManagementTransportInterceptor(threadPool, new QueryGroupService());
+    }
+
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testInterceptHandler() {
+        TransportRequestHandler<TransportRequest> requestHandler = sut.interceptHandler("Search", SAME, false, null);
+        assertTrue(requestHandler instanceof RequestHandler);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/WorkloadManagementTransportRequestHandlerTests.java b/server/src/test/java/org/opensearch/wlm/WorkloadManagementTransportRequestHandlerTests.java
new file mode 100644
index 0000000000000..59818ad3dbbd2
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/WorkloadManagementTransportRequestHandlerTests.java
@@ -0,0 +1,89 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm;
+
+import org.opensearch.action.index.IndexRequest;
+import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+import org.opensearch.search.internal.ShardSearchRequest;
+import org.opensearch.tasks.Task;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.transport.TransportChannel;
+import org.opensearch.transport.TransportRequest;
+import org.opensearch.transport.TransportRequestHandler;
+
+import java.util.Collections;
+
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+
+public class WorkloadManagementTransportRequestHandlerTests extends OpenSearchTestCase {
+    private WorkloadManagementTransportInterceptor.RequestHandler<TransportRequest> sut;
+    private ThreadPool threadPool;
+    private QueryGroupService queryGroupService;
+
+    private TestTransportRequestHandler<TransportRequest> actualHandler;
+
+    public void setUp() throws Exception {
+        super.setUp();
+        threadPool = new TestThreadPool(getTestName());
+        actualHandler = new TestTransportRequestHandler<>();
+        queryGroupService = mock(QueryGroupService.class);
+
+        sut = new WorkloadManagementTransportInterceptor.RequestHandler<>(threadPool, actualHandler, queryGroupService);
+    }
+
+    public void tearDown() throws Exception {
+        super.tearDown();
+        threadPool.shutdown();
+    }
+
+    public void testMessageReceivedForSearchWorkload_nonRejectionCase() throws Exception {
+        ShardSearchRequest request = mock(ShardSearchRequest.class);
+        QueryGroupTask spyTask = getSpyTask();
+        doNothing().when(queryGroupService).rejectIfNeeded(anyString());
+        sut.messageReceived(request, mock(TransportChannel.class), spyTask);
+        assertTrue(sut.isSearchWorkloadRequest(spyTask));
+    }
+
+    public void testMessageReceivedForSearchWorkload_RejectionCase() throws Exception {
+        ShardSearchRequest request = mock(ShardSearchRequest.class);
+        QueryGroupTask spyTask = getSpyTask();
+        doThrow(OpenSearchRejectedExecutionException.class).when(queryGroupService).rejectIfNeeded(anyString());
+
+        assertThrows(OpenSearchRejectedExecutionException.class, () -> sut.messageReceived(request, mock(TransportChannel.class), spyTask));
+    }
+
+    public void testMessageReceivedForNonSearchWorkload() throws Exception {
+        IndexRequest indexRequest = mock(IndexRequest.class);
+        Task task = mock(Task.class);
+        sut.messageReceived(indexRequest, mock(TransportChannel.class), task);
+        assertFalse(sut.isSearchWorkloadRequest(task));
+        assertEquals(1, actualHandler.invokeCount);
+    }
+
+    private static QueryGroupTask getSpyTask() {
+        final QueryGroupTask task = new QueryGroupTask(123, "transport", "Search", "test task", null, Collections.emptyMap());
+
+        return spy(task);
+    }
+
+    private static class TestTransportRequestHandler<T extends TransportRequest> implements TransportRequestHandler<T> {
+        int invokeCount = 0;
+
+        @Override
+        public void messageReceived(TransportRequest request, TransportChannel channel, Task task) throws Exception {
+            invokeCount += 1;
+        }
+    };
+}
diff --git a/server/src/test/java/org/opensearch/wlm/listeners/QueryGroupRequestOperationListenerTests.java b/server/src/test/java/org/opensearch/wlm/listeners/QueryGroupRequestOperationListenerTests.java
new file mode 100644
index 0000000000000..0307ff623c408
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/listeners/QueryGroupRequestOperationListenerTests.java
@@ -0,0 +1,187 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm.listeners;
+
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.concurrency.OpenSearchRejectedExecutionException;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.wlm.QueryGroupService;
+import org.opensearch.wlm.QueryGroupTask;
+import org.opensearch.wlm.ResourceType;
+import org.opensearch.wlm.stats.QueryGroupState;
+import org.opensearch.wlm.stats.QueryGroupStats;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+
+public class QueryGroupRequestOperationListenerTests extends OpenSearchTestCase {
+    public static final int ITERATIONS = 20;
+    ThreadPool testThreadPool;
+    QueryGroupService queryGroupService;
+
+    Map<String, QueryGroupState> queryGroupStateMap;
+    String testQueryGroupId;
+    QueryGroupRequestOperationListener sut;
+
+    public void setUp() throws Exception {
+        super.setUp();
+        queryGroupStateMap = new HashMap<>();
+        testQueryGroupId = "safjgagnakg-3r3fads";
+        testThreadPool = new TestThreadPool("RejectionTestThreadPool");
+        queryGroupService = mock(QueryGroupService.class);
+        sut = new QueryGroupRequestOperationListener(queryGroupService, testThreadPool);
+    }
+
+    public void tearDown() throws Exception {
+        super.tearDown();
+        testThreadPool.shutdown();
+    }
+
+    public void testRejectionCase() {
+        final String testQueryGroupId = "asdgasgkajgkw3141_3rt4t";
+        testThreadPool.getThreadContext().putHeader(QueryGroupTask.QUERY_GROUP_ID_HEADER, testQueryGroupId);
+        doThrow(OpenSearchRejectedExecutionException.class).when(queryGroupService).rejectIfNeeded(testQueryGroupId);
+        assertThrows(OpenSearchRejectedExecutionException.class, () -> sut.onRequestStart(null));
+    }
+
+    public void testNonRejectionCase() {
+        final String testQueryGroupId = "asdgasgkajgkw3141_3rt4t";
+        testThreadPool.getThreadContext().putHeader(QueryGroupTask.QUERY_GROUP_ID_HEADER, testQueryGroupId);
+        doNothing().when(queryGroupService).rejectIfNeeded(testQueryGroupId);
+
+        sut.onRequestStart(null);
+    }
+
+    public void testValidQueryGroupRequestFailure() throws IOException {
+
+        QueryGroupStats expectedStats = new QueryGroupStats(
+            Map.of(
+                testQueryGroupId,
+                new QueryGroupStats.QueryGroupStatsHolder(
+                    0,
+                    0,
+                    1,
+                    0,
+                    Map.of(
+                        ResourceType.CPU,
+                        new QueryGroupStats.ResourceStats(0, 0, 0),
+                        ResourceType.MEMORY,
+                        new QueryGroupStats.ResourceStats(0, 0, 0)
+                    )
+                )
+            )
+        );
+
+        assertSuccess(testQueryGroupId, queryGroupStateMap, expectedStats, testQueryGroupId);
+    }
+
+    public void testMultiThreadedValidQueryGroupRequestFailures() {
+
+        queryGroupStateMap.put(testQueryGroupId, new QueryGroupState());
+
+        queryGroupService = new QueryGroupService(queryGroupStateMap);
+
+        sut = new QueryGroupRequestOperationListener(queryGroupService, testThreadPool);
+
+        List<Thread> threads = new ArrayList<>();
+        for (int i = 0; i < ITERATIONS; i++) {
+            threads.add(new Thread(() -> {
+                try (ThreadContext.StoredContext currentContext = testThreadPool.getThreadContext().stashContext()) {
+                    testThreadPool.getThreadContext().putHeader(QueryGroupTask.QUERY_GROUP_ID_HEADER, testQueryGroupId);
+                    sut.onRequestFailure(null, null);
+                }
+            }));
+        }
+
+        threads.forEach(Thread::start);
+        threads.forEach(th -> {
+            try {
+                th.join();
+            } catch (InterruptedException ignored) {
+
+            }
+        });
+
+        QueryGroupStats actualStats = queryGroupService.nodeStats();
+
+        QueryGroupStats expectedStats = new QueryGroupStats(
+            Map.of(
+                testQueryGroupId,
+                new QueryGroupStats.QueryGroupStatsHolder(
+                    0,
+                    0,
+                    ITERATIONS,
+                    0,
+                    Map.of(
+                        ResourceType.CPU,
+                        new QueryGroupStats.ResourceStats(0, 0, 0),
+                        ResourceType.MEMORY,
+                        new QueryGroupStats.ResourceStats(0, 0, 0)
+                    )
+                )
+            )
+        );
+
+        assertEquals(expectedStats, actualStats);
+    }
+
+    public void testInvalidQueryGroupFailure() throws IOException {
+        QueryGroupStats expectedStats = new QueryGroupStats(
+            Map.of(
+                testQueryGroupId,
+                new QueryGroupStats.QueryGroupStatsHolder(
+                    0,
+                    0,
+                    0,
+                    0,
+                    Map.of(
+                        ResourceType.CPU,
+                        new QueryGroupStats.ResourceStats(0, 0, 0),
+                        ResourceType.MEMORY,
+                        new QueryGroupStats.ResourceStats(0, 0, 0)
+                    )
+                )
+            )
+        );
+
+        assertSuccess(testQueryGroupId, queryGroupStateMap, expectedStats, "dummy-invalid-qg-id");
+
+    }
+
+    private void assertSuccess(
+        String testQueryGroupId,
+        Map<String, QueryGroupState> queryGroupStateMap,
+        QueryGroupStats expectedStats,
+        String threadContextQG_Id
+    ) {
+
+        try (ThreadContext.StoredContext currentContext = testThreadPool.getThreadContext().stashContext()) {
+            testThreadPool.getThreadContext().putHeader(QueryGroupTask.QUERY_GROUP_ID_HEADER, threadContextQG_Id);
+            queryGroupStateMap.put(testQueryGroupId, new QueryGroupState());
+
+            queryGroupService = new QueryGroupService(queryGroupStateMap);
+
+            sut = new QueryGroupRequestOperationListener(queryGroupService, testThreadPool);
+            sut.onRequestFailure(null, null);
+
+            QueryGroupStats actualStats = queryGroupService.nodeStats();
+            assertEquals(expectedStats, actualStats);
+        }
+
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/stats/QueryGroupStateTests.java b/server/src/test/java/org/opensearch/wlm/stats/QueryGroupStateTests.java
new file mode 100644
index 0000000000000..576eec7be1888
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/stats/QueryGroupStateTests.java
@@ -0,0 +1,73 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm.stats;
+
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.wlm.ResourceType;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class QueryGroupStateTests extends OpenSearchTestCase {
+    QueryGroupState queryGroupState;
+
+    public void testRandomQueryGroupsStateUpdates() {
+        queryGroupState = new QueryGroupState();
+        List<Thread> updaterThreads = new ArrayList<>();
+
+        for (int i = 0; i < 25; i++) {
+            if (i % 5 == 0) {
+                updaterThreads.add(new Thread(() -> queryGroupState.completions.inc()));
+            } else if (i % 5 == 1) {
+                updaterThreads.add(new Thread(() -> {
+                    queryGroupState.totalRejections.inc();
+                    if (randomBoolean()) {
+                        queryGroupState.getResourceState().get(ResourceType.CPU).rejections.inc();
+                    } else {
+                        queryGroupState.getResourceState().get(ResourceType.MEMORY).rejections.inc();
+                    }
+                }));
+            } else if (i % 5 == 2) {
+                updaterThreads.add(new Thread(() -> queryGroupState.failures.inc()));
+            } else if (i % 5 == 3) {
+                updaterThreads.add(new Thread(() -> queryGroupState.getResourceState().get(ResourceType.CPU).cancellations.inc()));
+            } else {
+                updaterThreads.add(new Thread(() -> queryGroupState.getResourceState().get(ResourceType.MEMORY).cancellations.inc()));
+            }
+
+            if (i % 5 == 3 || i % 5 == 4) {
+                updaterThreads.add(new Thread(() -> queryGroupState.totalCancellations.inc()));
+            }
+        }
+
+        // trigger the updates
+        updaterThreads.forEach(Thread::start);
+        // wait for updates to be finished
+        updaterThreads.forEach(thread -> {
+            try {
+                thread.join();
+            } catch (InterruptedException ignored) {
+
+            }
+        });
+
+        assertEquals(5, queryGroupState.getCompletions());
+        assertEquals(5, queryGroupState.getTotalRejections());
+
+        final long sumOfRejectionsDueToResourceTypes = queryGroupState.getResourceState().get(ResourceType.CPU).rejections.count()
+            + queryGroupState.getResourceState().get(ResourceType.MEMORY).rejections.count();
+        assertEquals(sumOfRejectionsDueToResourceTypes, queryGroupState.getTotalRejections());
+
+        assertEquals(5, queryGroupState.getFailures());
+        assertEquals(10, queryGroupState.getTotalCancellations());
+        assertEquals(5, queryGroupState.getResourceState().get(ResourceType.CPU).cancellations.count());
+        assertEquals(5, queryGroupState.getResourceState().get(ResourceType.MEMORY).cancellations.count());
+    }
+
+}
diff --git a/server/src/test/java/org/opensearch/wlm/stats/QueryGroupStatsTests.java b/server/src/test/java/org/opensearch/wlm/stats/QueryGroupStatsTests.java
new file mode 100644
index 0000000000000..661c3a7beae40
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/stats/QueryGroupStatsTests.java
@@ -0,0 +1,75 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm.stats;
+
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.io.stream.Writeable;
+import org.opensearch.core.xcontent.ToXContent;
+import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.test.AbstractWireSerializingTestCase;
+import org.opensearch.wlm.ResourceType;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class QueryGroupStatsTests extends AbstractWireSerializingTestCase<QueryGroupStats> {
+
+    public void testToXContent() throws IOException {
+        final Map<String, QueryGroupStats.QueryGroupStatsHolder> stats = new HashMap<>();
+        final String queryGroupId = "afakjklaj304041-afaka";
+        stats.put(
+            queryGroupId,
+            new QueryGroupStats.QueryGroupStatsHolder(
+                123456789,
+                2,
+                0,
+                13,
+                Map.of(ResourceType.CPU, new QueryGroupStats.ResourceStats(0.3, 13, 2))
+            )
+        );
+        XContentBuilder builder = JsonXContent.contentBuilder();
+        QueryGroupStats queryGroupStats = new QueryGroupStats(stats);
+        builder.startObject();
+        queryGroupStats.toXContent(builder, ToXContent.EMPTY_PARAMS);
+        builder.endObject();
+        assertEquals(
+            "{\"query_groups\":{\"afakjklaj304041-afaka\":{\"completions\":123456789,\"rejections\":2,\"failures\":0,\"total_cancellations\":13,\"cpu\":{\"current_usage\":0.3,\"cancellations\":13,\"rejections\":2}}}}",
+            builder.toString()
+        );
+    }
+
+    @Override
+    protected Writeable.Reader<QueryGroupStats> instanceReader() {
+        return QueryGroupStats::new;
+    }
+
+    @Override
+    protected QueryGroupStats createTestInstance() {
+        Map<String, QueryGroupStats.QueryGroupStatsHolder> stats = new HashMap<>();
+        stats.put(
+            randomAlphaOfLength(10),
+            new QueryGroupStats.QueryGroupStatsHolder(
+                randomNonNegativeLong(),
+                randomNonNegativeLong(),
+                randomNonNegativeLong(),
+                randomNonNegativeLong(),
+                Map.of(
+                    ResourceType.CPU,
+                    new QueryGroupStats.ResourceStats(
+                        randomDoubleBetween(0.0, 0.90, false),
+                        randomNonNegativeLong(),
+                        randomNonNegativeLong()
+                    )
+                )
+            )
+        );
+        return new QueryGroupStats(stats);
+    }
+}
diff --git a/server/src/test/java/org/opensearch/wlm/tracker/QueryGroupResourceUsageTrackerServiceTests.java b/server/src/test/java/org/opensearch/wlm/tracker/QueryGroupResourceUsageTrackerServiceTests.java
new file mode 100644
index 0000000000000..ca2891cb532f2
--- /dev/null
+++ b/server/src/test/java/org/opensearch/wlm/tracker/QueryGroupResourceUsageTrackerServiceTests.java
@@ -0,0 +1,126 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.wlm.tracker;
+
+import org.opensearch.action.search.SearchShardTask;
+import org.opensearch.action.search.SearchTask;
+import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.core.tasks.resourcetracker.ResourceStats;
+import org.opensearch.tasks.CancellableTask;
+import org.opensearch.tasks.Task;
+import org.opensearch.tasks.TaskResourceTrackingService;
+import org.opensearch.test.OpenSearchTestCase;
+import org.opensearch.threadpool.TestThreadPool;
+import org.opensearch.threadpool.ThreadPool;
+import org.opensearch.wlm.QueryGroupLevelResourceUsageView;
+import org.opensearch.wlm.QueryGroupTask;
+import org.opensearch.wlm.ResourceType;
+import org.junit.After;
+import org.junit.Before;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static org.opensearch.wlm.QueryGroupTask.QUERY_GROUP_ID_HEADER;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class QueryGroupResourceUsageTrackerServiceTests extends OpenSearchTestCase {
+    TestThreadPool threadPool;
+    TaskResourceTrackingService mockTaskResourceTrackingService;
+    QueryGroupResourceUsageTrackerService queryGroupResourceUsageTrackerService;
+
+    @Before
+    public void setup() {
+        threadPool = new TestThreadPool(getTestName());
+        mockTaskResourceTrackingService = mock(TaskResourceTrackingService.class);
+        queryGroupResourceUsageTrackerService = new QueryGroupResourceUsageTrackerService(mockTaskResourceTrackingService);
+    }
+
+    @After
+    public void cleanup() {
+        ThreadPool.terminate(threadPool, 5, TimeUnit.SECONDS);
+    }
+
+    public void testConstructQueryGroupLevelViews_CreatesQueryGroupLevelUsageView_WhenTasksArePresent() {
+        List<String> queryGroupIds = List.of("queryGroup1", "queryGroup2", "queryGroup3");
+
+        Map<Long, Task> activeSearchShardTasks = createActiveSearchShardTasks(queryGroupIds);
+        when(mockTaskResourceTrackingService.getResourceAwareTasks()).thenReturn(activeSearchShardTasks);
+        Map<String, QueryGroupLevelResourceUsageView> stringQueryGroupLevelResourceUsageViewMap = queryGroupResourceUsageTrackerService
+            .constructQueryGroupLevelUsageViews();
+
+        for (String queryGroupId : queryGroupIds) {
+            assertEquals(
+                400,
+                (long) stringQueryGroupLevelResourceUsageViewMap.get(queryGroupId).getResourceUsageData().get(ResourceType.MEMORY)
+            );
+            assertEquals(2, stringQueryGroupLevelResourceUsageViewMap.get(queryGroupId).getActiveTasks().size());
+        }
+    }
+
+    public void testConstructQueryGroupLevelViews_CreatesQueryGroupLevelUsageView_WhenTasksAreNotPresent() {
+        Map<String, QueryGroupLevelResourceUsageView> stringQueryGroupLevelResourceUsageViewMap = queryGroupResourceUsageTrackerService
+            .constructQueryGroupLevelUsageViews();
+        assertTrue(stringQueryGroupLevelResourceUsageViewMap.isEmpty());
+    }
+
+    public void testConstructQueryGroupLevelUsageViews_WithTasksHavingDifferentResourceUsage() {
+        Map<Long, Task> activeSearchShardTasks = new HashMap<>();
+        activeSearchShardTasks.put(1L, createMockTask(SearchShardTask.class, 100, 200, "queryGroup1"));
+        activeSearchShardTasks.put(2L, createMockTask(SearchShardTask.class, 200, 400, "queryGroup1"));
+        when(mockTaskResourceTrackingService.getResourceAwareTasks()).thenReturn(activeSearchShardTasks);
+
+        Map<String, QueryGroupLevelResourceUsageView> queryGroupViews = queryGroupResourceUsageTrackerService
+            .constructQueryGroupLevelUsageViews();
+
+        assertEquals(600, (long) queryGroupViews.get("queryGroup1").getResourceUsageData().get(ResourceType.MEMORY));
+        assertEquals(2, queryGroupViews.get("queryGroup1").getActiveTasks().size());
+    }
+
+    private Map<Long, Task> createActiveSearchShardTasks(List<String> queryGroupIds) {
+        Map<Long, Task> activeSearchShardTasks = new HashMap<>();
+        long task_id = 0;
+        for (String queryGroupId : queryGroupIds) {
+            for (int i = 0; i < 2; i++) {
+                activeSearchShardTasks.put(++task_id, createMockTask(SearchShardTask.class, 100, 200, queryGroupId));
+            }
+        }
+        return activeSearchShardTasks;
+    }
+
+    private <T extends CancellableTask> T createMockTask(Class<T> type, long cpuUsage, long heapUsage, String queryGroupId) {
+        T task = mock(type);
+        if (task instanceof SearchTask || task instanceof SearchShardTask) {
+            // Stash the current thread context to ensure that any existing context is preserved and restored after setting the query group
+            // ID.
+            try (ThreadContext.StoredContext ignore = threadPool.getThreadContext().stashContext()) {
+                threadPool.getThreadContext().putHeader(QUERY_GROUP_ID_HEADER, queryGroupId);
+                ((QueryGroupTask) task).setQueryGroupId(threadPool.getThreadContext());
+            }
+        }
+        when(task.getTotalResourceUtilization(ResourceStats.CPU)).thenReturn(cpuUsage);
+        when(task.getTotalResourceUtilization(ResourceStats.MEMORY)).thenReturn(heapUsage);
+        when(task.getStartTimeNanos()).thenReturn((long) 0);
+
+        AtomicBoolean isCancelled = new AtomicBoolean(false);
+        doAnswer(invocation -> {
+            isCancelled.set(true);
+            return null;
+        }).when(task).cancel(anyString());
+        doAnswer(invocation -> isCancelled.get()).when(task).isCancelled();
+
+        return task;
+    }
+}
diff --git a/server/src/test/resources/org/opensearch/bootstrap/test.policy b/server/src/test/resources/org/opensearch/bootstrap/test.policy
index 7b0a9b3d5d709..c2b5a8e9c0a4e 100644
--- a/server/src/test/resources/org/opensearch/bootstrap/test.policy
+++ b/server/src/test/resources/org/opensearch/bootstrap/test.policy
@@ -7,7 +7,7 @@
  */
 
 grant {
-  // allow to test Security policy and codebases 
+  // allow to test Security policy and codebases
   permission java.util.PropertyPermission "*", "read,write";
   permission java.security.SecurityPermission "createPolicy.JavaPolicy";
 };
diff --git a/settings.gradle b/settings.gradle
index f58a8b35b10eb..b79c2aee135fc 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -10,7 +10,7 @@
  */
 
 plugins {
-  id "com.gradle.enterprise" version "3.17.4"
+  id "com.gradle.develocity" version "3.18"
 }
 
 ext.disableBuildCache = hasProperty('DISABLE_BUILD_CACHE') || System.getenv().containsKey('DISABLE_BUILD_CACHE')
@@ -18,7 +18,6 @@ ext.disableBuildCache = hasProperty('DISABLE_BUILD_CACHE') || System.getenv().co
 buildCache {
   local {
     enabled = !disableBuildCache
-    removeUnusedEntriesAfterDays = 14
   }
 }
 
diff --git a/test/fixtures/hdfs-fixture/build.gradle b/test/fixtures/hdfs-fixture/build.gradle
index 1047c850ba058..dbf518a4456d2 100644
--- a/test/fixtures/hdfs-fixture/build.gradle
+++ b/test/fixtures/hdfs-fixture/build.gradle
@@ -33,7 +33,7 @@ apply plugin: 'opensearch.java'
 group = 'hdfs'
 
 versions << [
-  'jetty': '9.4.53.v20231009'
+  'jetty': '9.4.55.v20240627'
 ]
 
 dependencies {
@@ -51,13 +51,16 @@ dependencies {
     exclude module: "logback-classic"
     exclude module: "avro"
     exclude group: 'org.apache.kerby'
+    exclude group: 'com.nimbusds'
+    exclude module: "commons-configuration2"
   }
+  api "dnsjava:dnsjava:3.6.1"
   api "org.codehaus.jettison:jettison:${versions.jettison}"
   api "org.apache.commons:commons-compress:${versions.commonscompress}"
   api "commons-codec:commons-codec:${versions.commonscodec}"
   api "org.apache.logging.log4j:log4j-core:${versions.log4j}"
   api "io.netty:netty-all:${versions.netty}"
-  api 'com.google.code.gson:gson:2.9.0'
+  api 'com.google.code.gson:gson:2.11.0'
   api "com.fasterxml.jackson.jaxrs:jackson-jaxrs-json-provider:${versions.jackson}"
   api "com.fasterxml.jackson.core:jackson-databind:${versions.jackson_databind}"
   api "com.fasterxml.woodstox:woodstox-core:${versions.woodstox}"
@@ -69,14 +72,21 @@ dependencies {
   api "org.eclipse.jetty.websocket:javax-websocket-server-impl:${versions.jetty}"
   api 'org.apache.zookeeper:zookeeper:3.9.2'
   api "org.apache.commons:commons-text:1.12.0"
-  api "commons-net:commons-net:3.10.0"
+  api "commons-net:commons-net:3.11.1"
   api "ch.qos.logback:logback-core:1.5.6"
   api "ch.qos.logback:logback-classic:1.2.13"
-  api 'org.apache.kerby:kerb-admin:2.0.3'
+  api "org.jboss.xnio:xnio-nio:3.8.16.Final"
+  api 'org.jline:jline:3.26.3'
+  api 'org.apache.commons:commons-configuration2:2.11.0'
+  api 'com.nimbusds:nimbus-jose-jwt:9.40'
+  api ('org.apache.kerby:kerb-admin:2.1.0') {
+    exclude group: "org.jboss.xnio"
+    exclude group: "org.jline"
+  }
   runtimeOnly "com.google.guava:guava:${versions.guava}"
   runtimeOnly("com.squareup.okhttp3:okhttp:4.12.0") {
     exclude group: "com.squareup.okio"
   }
   runtimeOnly "com.squareup.okio:okio:3.9.0"
-  runtimeOnly "org.xerial.snappy:snappy-java:1.1.10.5"
+  runtimeOnly "org.xerial.snappy:snappy-java:1.1.10.6"
 }
diff --git a/test/framework/src/main/java/org/opensearch/action/support/replication/ClusterStateCreationUtils.java b/test/framework/src/main/java/org/opensearch/action/support/replication/ClusterStateCreationUtils.java
index f20c7edbed33e..15c377374455f 100644
--- a/test/framework/src/main/java/org/opensearch/action/support/replication/ClusterStateCreationUtils.java
+++ b/test/framework/src/main/java/org/opensearch/action/support/replication/ClusterStateCreationUtils.java
@@ -35,6 +35,7 @@
 import org.opensearch.Version;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.node.DiscoveryNode;
@@ -62,6 +63,7 @@
 
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_CREATION_DATE;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_REPLICAS;
+import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SEARCH_REPLICAS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_NUMBER_OF_SHARDS;
 import static org.opensearch.cluster.metadata.IndexMetadata.SETTING_VERSION_CREATED;
 import static org.opensearch.test.OpenSearchTestCase.randomFrom;
@@ -324,7 +326,18 @@ public static ClusterState stateWithAssignedPrimariesAndOneReplica(String index,
      * Creates cluster state with several indexes, shards and replicas and all shards STARTED.
      */
     public static ClusterState stateWithAssignedPrimariesAndReplicas(String[] indices, int numberOfShards, int numberOfReplicas) {
+        return stateWithAssignedPrimariesAndReplicas(indices, numberOfShards, numberOfReplicas, 0);
+    }
 
+    /**
+     * Creates cluster state with several indexes, shards and replicas and all shards STARTED.
+     */
+    public static ClusterState stateWithAssignedPrimariesAndReplicas(
+        String[] indices,
+        int numberOfShards,
+        int numberOfReplicas,
+        int numberOfSearchReplicas
+    ) {
         int numberOfDataNodes = numberOfReplicas + 1;
         DiscoveryNodes.Builder discoBuilder = DiscoveryNodes.builder();
         for (int i = 0; i < numberOfDataNodes + 1; i++) {
@@ -346,6 +359,7 @@ public static ClusterState stateWithAssignedPrimariesAndReplicas(String[] indice
                         .put(SETTING_VERSION_CREATED, Version.CURRENT)
                         .put(SETTING_NUMBER_OF_SHARDS, numberOfShards)
                         .put(SETTING_NUMBER_OF_REPLICAS, numberOfReplicas)
+                        .put(SETTING_NUMBER_OF_SEARCH_REPLICAS, numberOfSearchReplicas)
                         .put(SETTING_CREATION_DATE, System.currentTimeMillis())
                 )
                 .build();
@@ -362,6 +376,19 @@ public static ClusterState stateWithAssignedPrimariesAndReplicas(String[] indice
                         TestShardRouting.newShardRouting(index, i, newNode(replica + 1).getId(), null, false, ShardRoutingState.STARTED)
                     );
                 }
+                for (int replica = numberOfReplicas; replica < numberOfSearchReplicas + numberOfReplicas; replica++) {
+                    indexShardRoutingBuilder.addShard(
+                        TestShardRouting.newShardRouting(
+                            new ShardId(index, IndexMetadata.INDEX_UUID_NA_VALUE, i),
+                            newNode(replica + 1).getId(),
+                            null,
+                            false,
+                            true,
+                            ShardRoutingState.STARTED,
+                            null
+                        )
+                    );
+                }
                 indexRoutingTableBuilder.addIndexShard(indexShardRoutingBuilder.build());
             }
             routingTableBuilder.add(indexRoutingTableBuilder.build());
@@ -371,6 +398,44 @@ public static ClusterState stateWithAssignedPrimariesAndReplicas(String[] indice
         return state.build();
     }
 
+    public static ClusterState stateWithContext(String index, final int numberOfNodes, final int numberOfPrimaries, Context context) {
+        DiscoveryNodes.Builder discoBuilder = DiscoveryNodes.builder();
+        Set<String> nodes = new HashSet<>();
+        for (int i = 0; i < numberOfNodes; i++) {
+            final DiscoveryNode node = newNode(i);
+            discoBuilder = discoBuilder.add(node);
+            nodes.add(node.getId());
+        }
+        discoBuilder.localNodeId(newNode(0).getId());
+        discoBuilder.clusterManagerNodeId(randomFrom(nodes));
+        IndexMetadata indexMetadata = IndexMetadata.builder(index)
+            .settings(
+                Settings.builder()
+                    .put(SETTING_VERSION_CREATED, Version.CURRENT)
+                    .put(SETTING_NUMBER_OF_SHARDS, numberOfPrimaries)
+                    .put(SETTING_NUMBER_OF_REPLICAS, 0)
+                    .put(SETTING_CREATION_DATE, System.currentTimeMillis())
+            )
+            .context(context)
+            .build();
+
+        IndexRoutingTable.Builder indexRoutingTable = IndexRoutingTable.builder(indexMetadata.getIndex());
+        for (int i = 0; i < numberOfPrimaries; i++) {
+            ShardId shardId = new ShardId(indexMetadata.getIndex(), i);
+            IndexShardRoutingTable.Builder indexShardRoutingBuilder = new IndexShardRoutingTable.Builder(shardId);
+            indexShardRoutingBuilder.addShard(
+                TestShardRouting.newShardRouting(shardId, randomFrom(nodes), true, ShardRoutingState.STARTED)
+            );
+            indexRoutingTable.addIndexShard(indexShardRoutingBuilder.build());
+        }
+
+        ClusterState.Builder state = ClusterState.builder(new ClusterName("test"));
+        state.nodes(discoBuilder);
+        state.metadata(Metadata.builder().put(indexMetadata, false).generateClusterUuidIfNeeded());
+        state.routingTable(RoutingTable.builder().add(indexRoutingTable).build());
+        return state.build();
+    }
+
     /**
      * Creates cluster state with and index that has one shard and as many replicas as numberOfReplicas.
      * Primary will be STARTED in cluster state but replicas will be one of UNASSIGNED, INITIALIZING, STARTED or RELOCATING.
diff --git a/test/framework/src/main/java/org/opensearch/client/RestClientBuilderTestCase.java b/test/framework/src/main/java/org/opensearch/client/RestClientBuilderTestCase.java
index e483a7df895bb..5629e4e42282b 100644
--- a/test/framework/src/main/java/org/opensearch/client/RestClientBuilderTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/client/RestClientBuilderTestCase.java
@@ -32,7 +32,6 @@
 
 package org.opensearch.client;
 
-import joptsimple.internal.Strings;
 import org.apache.http.Header;
 import org.opensearch.test.OpenSearchTestCase;
 
@@ -55,7 +54,7 @@ public void assertHeaders(RestClient client, Map<String, String> expectedHeaders
             assertEquals(expectedValue, header.getValue());
         }
         if (expectedHeaders.isEmpty() == false) {
-            fail("Missing expected headers in rest client: " + Strings.join(expectedHeaders.keySet(), ", "));
+            fail("Missing expected headers in rest client: " + String.join(",", expectedHeaders.keySet()));
         }
     }
 }
diff --git a/test/framework/src/main/java/org/opensearch/cluster/OpenSearchAllocationTestCase.java b/test/framework/src/main/java/org/opensearch/cluster/OpenSearchAllocationTestCase.java
index f6113860e3907..bc42993ac2096 100644
--- a/test/framework/src/main/java/org/opensearch/cluster/OpenSearchAllocationTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/cluster/OpenSearchAllocationTestCase.java
@@ -37,6 +37,7 @@
 import org.opensearch.cluster.node.DiscoveryNodeRole;
 import org.opensearch.cluster.routing.RecoverySource;
 import org.opensearch.cluster.routing.RoutingNode;
+import org.opensearch.cluster.routing.RoutingNodes;
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.UnassignedInfo;
 import org.opensearch.cluster.routing.allocation.AllocationService;
@@ -47,6 +48,7 @@
 import org.opensearch.cluster.routing.allocation.decider.AllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.AllocationDeciders;
 import org.opensearch.cluster.routing.allocation.decider.Decision;
+import org.opensearch.cluster.routing.allocation.decider.FilterAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.SameShardAllocationDecider;
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
@@ -178,6 +180,19 @@ protected static DiscoveryNode newNode(String nodeId, Version version) {
 
     protected static ClusterState startRandomInitializingShard(ClusterState clusterState, AllocationService strategy) {
         List<ShardRouting> initializingShards = clusterState.getRoutingNodes().shardsWithState(INITIALIZING);
+        return startInitialisingShardsAndReroute(strategy, clusterState, initializingShards);
+    }
+
+    protected static ClusterState startRandomInitializingShard(ClusterState clusterState, AllocationService strategy, String index) {
+        List<ShardRouting> initializingShards = clusterState.getRoutingNodes().shardsWithState(index, INITIALIZING);
+        return startInitialisingShardsAndReroute(strategy, clusterState, initializingShards);
+    }
+
+    private static ClusterState startInitialisingShardsAndReroute(
+        AllocationService strategy,
+        ClusterState clusterState,
+        List<ShardRouting> initializingShards
+    ) {
         if (initializingShards.isEmpty()) {
             return clusterState;
         }
@@ -212,6 +227,16 @@ protected static AllocationDeciders throttleAllocationDeciders() {
         );
     }
 
+    protected static AllocationDeciders allocationDecidersForExcludeAPI(Settings settings) {
+        return new AllocationDeciders(
+            Arrays.asList(
+                new TestAllocateDecision(Decision.YES),
+                new SameShardAllocationDecider(settings, new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS)),
+                new FilterAllocationDecider(settings, new ClusterSettings(settings, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS))
+            )
+        );
+    }
+
     protected ClusterState applyStartedShardsUntilNoChange(ClusterState clusterState, AllocationService service) {
         ClusterState lastClusterState;
         do {
@@ -287,6 +312,19 @@ public static ClusterState startShardsAndReroute(
         return allocationService.reroute(allocationService.applyStartedShards(clusterState, initializingShards), "reroute after starting");
     }
 
+    protected RoutingAllocation newRoutingAllocation(AllocationDeciders deciders, ClusterState state) {
+        RoutingAllocation allocation = new RoutingAllocation(
+            deciders,
+            new RoutingNodes(state, false),
+            state,
+            ClusterInfo.EMPTY,
+            SnapshotShardSizeInfo.EMPTY,
+            System.nanoTime()
+        );
+        allocation.debugDecision(true);
+        return allocation;
+    }
+
     public static class TestAllocateDecision extends AllocationDecider {
 
         private final Decision decision;
@@ -465,5 +503,6 @@ public void allocateUnassigned(
                 unassignedAllocationHandler.removeAndIgnore(UnassignedInfo.AllocationStatus.DELAYED_ALLOCATION, allocation.changes());
             }
         }
+
     }
 }
diff --git a/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java b/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
index 0754cc1793dc8..b432e5411404e 100644
--- a/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/cluster/coordination/AbstractCoordinatorTestCase.java
@@ -39,6 +39,7 @@
 import org.apache.logging.log4j.message.ParameterizedMessage;
 import org.opensearch.OpenSearchException;
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterModule;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateTaskListener;
@@ -89,6 +90,7 @@
 import org.opensearch.monitor.StatusInfo;
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.repositories.RepositoriesService;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.telemetry.tracing.noop.NoopTracer;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.disruption.DisruptableMockTransport;
@@ -1144,7 +1146,8 @@ protected Optional<DisruptableMockTransport> getDisruptableMockTransport(Transpo
                     settings,
                     clusterSettings,
                     deterministicTaskQueue,
-                    threadPool
+                    threadPool,
+                    new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
                 );
                 clusterService = new ClusterService(settings, clusterSettings, clusterManagerService, clusterApplierService);
                 clusterService.setNodeConnectionsService(
@@ -1180,7 +1183,9 @@ protected Optional<DisruptableMockTransport> getDisruptableMockTransport(Transpo
                     getElectionStrategy(),
                     nodeHealthService,
                     persistedStateRegistry,
-                    remoteStoreNodeService
+                    remoteStoreNodeService,
+                    new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE),
+                    null
                 );
                 clusterManagerService.setClusterStatePublisher(coordinator);
                 final GatewayService gatewayService = new GatewayService(
@@ -1594,9 +1599,10 @@ static class DisruptableClusterApplierService extends ClusterApplierService {
             Settings settings,
             ClusterSettings clusterSettings,
             DeterministicTaskQueue deterministicTaskQueue,
-            ThreadPool threadPool
+            ThreadPool threadPool,
+            ClusterManagerMetrics clusterManagerMetrics
         ) {
-            super(nodeName, settings, clusterSettings, threadPool);
+            super(nodeName, settings, clusterSettings, threadPool, clusterManagerMetrics);
             this.nodeName = nodeName;
             this.deterministicTaskQueue = deterministicTaskQueue;
             addStateApplier(event -> {
diff --git a/test/framework/src/main/java/org/opensearch/cluster/routing/TestShardRouting.java b/test/framework/src/main/java/org/opensearch/cluster/routing/TestShardRouting.java
index f67108345550f..9a000a4eeda72 100644
--- a/test/framework/src/main/java/org/opensearch/cluster/routing/TestShardRouting.java
+++ b/test/framework/src/main/java/org/opensearch/cluster/routing/TestShardRouting.java
@@ -205,6 +205,32 @@ public static ShardRouting newShardRouting(
         );
     }
 
+    public static ShardRouting newShardRoutingRemoteRestore(
+        String index,
+        ShardId shardId,
+        String currentNodeId,
+        String relocatingNodeId,
+        boolean primary,
+        ShardRoutingState state,
+        UnassignedInfo unassignedInfo
+    ) {
+        return new ShardRouting(
+            shardId,
+            currentNodeId,
+            relocatingNodeId,
+            primary,
+            state,
+            new RecoverySource.RemoteStoreRecoverySource(
+                UUIDs.randomBase64UUID(),
+                Version.V_EMPTY,
+                new IndexId(shardId.getIndexName(), shardId.getIndexName())
+            ),
+            unassignedInfo,
+            buildAllocationId(state),
+            -1
+        );
+    }
+
     public static ShardRouting newShardRouting(
         ShardId shardId,
         String currentNodeId,
@@ -293,4 +319,27 @@ public static RecoverySource randomRecoverySource() {
             )
         );
     }
+
+    public static ShardRouting newShardRouting(
+        ShardId shardId,
+        String currentNodeId,
+        String relocatingNodeId,
+        boolean primary,
+        boolean searchOnly,
+        ShardRoutingState state,
+        UnassignedInfo unassignedInfo
+    ) {
+        return new ShardRouting(
+            shardId,
+            currentNodeId,
+            relocatingNodeId,
+            primary,
+            searchOnly,
+            state,
+            buildRecoveryTarget(primary, state),
+            unassignedInfo,
+            buildAllocationId(state),
+            -1
+        );
+    }
 }
diff --git a/test/framework/src/main/java/org/opensearch/cluster/service/FakeThreadPoolClusterManagerService.java b/test/framework/src/main/java/org/opensearch/cluster/service/FakeThreadPoolClusterManagerService.java
index 3ca938c99b5fd..64f3dbc4fd967 100644
--- a/test/framework/src/main/java/org/opensearch/cluster/service/FakeThreadPoolClusterManagerService.java
+++ b/test/framework/src/main/java/org/opensearch/cluster/service/FakeThreadPoolClusterManagerService.java
@@ -34,6 +34,7 @@
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.cluster.ClusterChangedEvent;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.coordination.ClusterStatePublisher.AckListener;
 import org.opensearch.common.UUIDs;
@@ -43,8 +44,10 @@
 import org.opensearch.common.util.concurrent.OpenSearchExecutors;
 import org.opensearch.common.util.concurrent.PrioritizedOpenSearchThreadPoolExecutor;
 import org.opensearch.common.util.concurrent.ThreadContext;
+import org.opensearch.common.util.concurrent.ThreadContextAccess;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.node.Node;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.util.ArrayList;
@@ -74,7 +77,8 @@ public FakeThreadPoolClusterManagerService(
         super(
             Settings.builder().put(Node.NODE_NAME_SETTING.getKey(), nodeName).build(),
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-            threadPool
+            threadPool,
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
         );
         this.name = serviceName;
         this.onTaskAvailableToRun = onTaskAvailableToRun;
@@ -131,7 +135,7 @@ public void run() {
                     scheduledNextTask = false;
                     final ThreadContext threadContext = threadPool.getThreadContext();
                     try (ThreadContext.StoredContext ignored = threadContext.stashContext()) {
-                        threadContext.markAsSystemContext();
+                        ThreadContextAccess.doPrivilegedVoid(threadContext::markAsSystemContext);
                         task.run();
                     }
                     if (waitForPublish == false) {
diff --git a/test/framework/src/main/java/org/opensearch/cluster/service/applicationtemplates/TestSystemTemplatesRepositoryPlugin.java b/test/framework/src/main/java/org/opensearch/cluster/service/applicationtemplates/TestSystemTemplatesRepositoryPlugin.java
new file mode 100644
index 0000000000000..c5245c7109d8f
--- /dev/null
+++ b/test/framework/src/main/java/org/opensearch/cluster/service/applicationtemplates/TestSystemTemplatesRepositoryPlugin.java
@@ -0,0 +1,72 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.cluster.service.applicationtemplates;
+
+import org.opensearch.cluster.applicationtemplates.SystemTemplate;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateLoader;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateMetadata;
+import org.opensearch.cluster.applicationtemplates.SystemTemplateRepository;
+import org.opensearch.cluster.applicationtemplates.SystemTemplatesPlugin;
+import org.opensearch.cluster.applicationtemplates.TemplateRepositoryMetadata;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.plugins.Plugin;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+
+public class TestSystemTemplatesRepositoryPlugin extends Plugin implements SystemTemplatesPlugin {
+
+    private final SystemTemplateMetadata templateMetadata = SystemTemplateMetadata.fromComponentTemplateInfo("dummy", 1);
+
+    private final TemplateRepositoryMetadata repoMetadata = new TemplateRepositoryMetadata("test", 1);
+
+    private final SystemTemplate systemTemplate = new SystemTemplate(
+        BytesReference.fromByteBuffer(ByteBuffer.wrap("content".getBytes(StandardCharsets.UTF_8))),
+        templateMetadata,
+        repoMetadata
+    );
+
+    @Override
+    public SystemTemplateRepository loadRepository() throws IOException {
+        return new SystemTemplateRepository() {
+            @Override
+            public TemplateRepositoryMetadata metadata() {
+                return repoMetadata;
+            }
+
+            @Override
+            public List<SystemTemplateMetadata> listTemplates() throws IOException {
+                return List.of(templateMetadata);
+            }
+
+            @Override
+            public SystemTemplate getTemplate(SystemTemplateMetadata template) throws IOException {
+                return systemTemplate;
+            }
+
+            @Override
+            public void close() throws Exception {}
+        };
+    }
+
+    @Override
+    public SystemTemplateLoader loaderFor(SystemTemplateMetadata templateMetadata) {
+        return new SystemTemplateLoader() { // Asserting Loader
+            @Override
+            public boolean loadTemplate(SystemTemplate template) throws IOException {
+                assert template.templateMetadata() == TestSystemTemplatesRepositoryPlugin.this.templateMetadata;
+                assert template.repositoryMetadata() == repoMetadata;
+                assert template.templateContent() == systemTemplate.templateContent();
+                return true;
+            }
+        };
+    }
+}
diff --git a/test/framework/src/main/java/org/opensearch/common/util/TestCapturingListener.java b/test/framework/src/main/java/org/opensearch/common/util/TestCapturingListener.java
new file mode 100644
index 0000000000000..a3c8cc15de927
--- /dev/null
+++ b/test/framework/src/main/java/org/opensearch/common/util/TestCapturingListener.java
@@ -0,0 +1,39 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.common.util;
+
+import org.opensearch.core.action.ActionListener;
+
+/**
+ * A simple implementation of {@link ActionListener} that captures the response and failures used for testing purposes.
+ *
+ * @param <T> the result type
+ */
+public class TestCapturingListener<T> implements ActionListener<T> {
+    private T result;
+    private Exception failure;
+
+    @Override
+    public void onResponse(T result) {
+        this.result = result;
+    }
+
+    @Override
+    public void onFailure(Exception e) {
+        this.failure = e;
+    }
+
+    public T getResult() {
+        return result;
+    }
+
+    public Exception getFailure() {
+        return failure;
+    }
+}
diff --git a/test/framework/src/main/java/org/opensearch/index/MapperTestUtils.java b/test/framework/src/main/java/org/opensearch/index/MapperTestUtils.java
index 108492c1cf8f9..302180fcf95df 100644
--- a/test/framework/src/main/java/org/opensearch/index/MapperTestUtils.java
+++ b/test/framework/src/main/java/org/opensearch/index/MapperTestUtils.java
@@ -38,6 +38,7 @@
 import org.opensearch.common.settings.Settings;
 import org.opensearch.core.xcontent.NamedXContentRegistry;
 import org.opensearch.env.Environment;
+import org.opensearch.index.analysis.AnalysisTestsHelper;
 import org.opensearch.index.analysis.IndexAnalyzers;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.DocumentMapperParser;
@@ -46,6 +47,7 @@
 import org.opensearch.index.similarity.SimilarityService;
 import org.opensearch.indices.IndicesModule;
 import org.opensearch.indices.mapper.MapperRegistry;
+import org.opensearch.plugins.AnalysisPlugin;
 import org.opensearch.test.IndexSettingsModule;
 
 import java.io.IOException;
@@ -97,6 +99,38 @@ public static MapperService newMapperService(
         );
     }
 
+    public static MapperService newMapperServiceWithHelperAnalyzer(
+        NamedXContentRegistry xContentRegistry,
+        Path tempDir,
+        Settings settings,
+        IndicesModule indicesModule,
+        String indexName
+    ) throws IOException {
+        Settings.Builder settingsBuilder = Settings.builder().put(Environment.PATH_HOME_SETTING.getKey(), tempDir).put(settings);
+        if (settings.get(IndexMetadata.SETTING_VERSION_CREATED) == null) {
+            settingsBuilder.put(IndexMetadata.SETTING_VERSION_CREATED, Version.CURRENT);
+        }
+        Settings finalSettings = settingsBuilder.build();
+        MapperRegistry mapperRegistry = indicesModule.getMapperRegistry();
+        IndexSettings indexSettings = IndexSettingsModule.newIndexSettings(indexName, finalSettings);
+        IndexAnalyzers indexAnalyzers = createMockTestAnalysis(finalSettings);
+        SimilarityService similarityService = new SimilarityService(indexSettings, null, Collections.emptyMap());
+        return new MapperService(
+            indexSettings,
+            indexAnalyzers,
+            xContentRegistry,
+            similarityService,
+            mapperRegistry,
+            () -> null,
+            () -> false,
+            null
+        );
+    }
+
+    public static IndexAnalyzers createMockTestAnalysis(Settings nodeSettings, AnalysisPlugin... analysisPlugins) throws IOException {
+        return AnalysisTestsHelper.createTestAnalysisFromSettings(nodeSettings, analysisPlugins).indexAnalyzers;
+    }
+
     public static void assertConflicts(String mapping1, String mapping2, DocumentMapperParser parser, String... conflicts)
         throws IOException {
         DocumentMapper docMapper = parser.parse("type", new CompressedXContent(mapping1));
diff --git a/test/framework/src/main/java/org/opensearch/index/mapper/MapperTestCase.java b/test/framework/src/main/java/org/opensearch/index/mapper/MapperTestCase.java
index dc5954907a4fa..01a4005255f29 100644
--- a/test/framework/src/main/java/org/opensearch/index/mapper/MapperTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/mapper/MapperTestCase.java
@@ -174,7 +174,7 @@ protected static void assertNoDocValuesField(ParseContext.Document doc, String f
         }
     }
 
-    public final void testEmptyName() {
+    public void testEmptyName() {
         MapperParsingException e = expectThrows(MapperParsingException.class, () -> createMapperService(mapping(b -> {
             b.startObject("");
             minimalMapping(b);
diff --git a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
index 6b609d8af62a1..655a9eb7d5d38 100644
--- a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestCase.java
@@ -1148,7 +1148,7 @@ public final void recoverUnstartedReplica(
             startingSeqNo
         );
         long fileChunkSizeInBytes = randomBoolean()
-            ? RecoverySettings.DEFAULT_CHUNK_SIZE.getBytes()
+            ? RecoverySettings.INDICES_RECOVERY_CHUNK_SIZE_SETTING.getDefault(Settings.EMPTY).getBytes()
             : randomIntBetween(1, 10 * 1024 * 1024);
         final Settings settings = Settings.builder()
             .put("indices.recovery.max_concurrent_file_chunks", Integer.toString(between(1, 4)))
diff --git a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestUtils.java b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestUtils.java
index abf8f2a4da6c1..50a1751546293 100644
--- a/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestUtils.java
+++ b/test/framework/src/main/java/org/opensearch/index/shard/IndexShardTestUtils.java
@@ -21,6 +21,7 @@
 import java.util.Map;
 
 public class IndexShardTestUtils {
+    public static final String MOCK_STATE_REPO_NAME = "state-test-repo";
     public static final String MOCK_SEGMENT_REPO_NAME = "segment-test-repo";
     public static final String MOCK_TLOG_REPO_NAME = "tlog-test-repo";
 
@@ -37,6 +38,7 @@ public static DiscoveryNode getFakeDiscoNode(String id) {
 
     public static DiscoveryNode getFakeRemoteEnabledNode(String id) {
         Map<String, String> remoteNodeAttributes = new HashMap<String, String>();
+        remoteNodeAttributes.put(RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, MOCK_STATE_REPO_NAME);
         remoteNodeAttributes.put(RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, MOCK_SEGMENT_REPO_NAME);
         remoteNodeAttributes.put(RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, MOCK_TLOG_REPO_NAME);
         return new DiscoveryNode(
diff --git a/test/framework/src/main/java/org/opensearch/index/shard/RestoreOnlyRepository.java b/test/framework/src/main/java/org/opensearch/index/shard/RestoreOnlyRepository.java
index 7e25ed97a7ea1..bd866b8d8173a 100644
--- a/test/framework/src/main/java/org/opensearch/index/shard/RestoreOnlyRepository.java
+++ b/test/framework/src/main/java/org/opensearch/index/shard/RestoreOnlyRepository.java
@@ -39,6 +39,7 @@
 import org.opensearch.cluster.metadata.Metadata;
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.node.DiscoveryNode;
+import org.opensearch.common.Priority;
 import org.opensearch.common.lifecycle.AbstractLifecycleComponent;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.index.shard.ShardId;
@@ -134,6 +135,20 @@ public void finalizeSnapshot(
         listener.onResponse(null);
     }
 
+    @Override
+    public void finalizeSnapshot(
+        ShardGenerations shardGenerations,
+        long repositoryStateId,
+        Metadata clusterMetadata,
+        SnapshotInfo snapshotInfo,
+        Version repositoryMetaVersion,
+        Function<ClusterState, ClusterState> stateTransformer,
+        Priority repositoryUpdatePriority,
+        ActionListener<RepositoryData> listener
+    ) {
+        listener.onResponse(null);
+    }
+
     @Override
     public void deleteSnapshots(
         Collection<SnapshotId> snapshotIds,
diff --git a/test/framework/src/main/java/org/opensearch/indices/analysis/AnalysisFactoryTestCase.java b/test/framework/src/main/java/org/opensearch/indices/analysis/AnalysisFactoryTestCase.java
index c412ae8317f24..23cf4d47a49d9 100644
--- a/test/framework/src/main/java/org/opensearch/indices/analysis/AnalysisFactoryTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/indices/analysis/AnalysisFactoryTestCase.java
@@ -139,6 +139,7 @@ public abstract class AnalysisFactoryTestCase extends OpenSearchTestCase {
         .put("patterncapturegroup", MovedToAnalysisCommon.class)
         .put("patternreplace", MovedToAnalysisCommon.class)
         .put("persiannormalization", MovedToAnalysisCommon.class)
+        .put("persianstem", MovedToAnalysisCommon.class)
         .put("porterstem", MovedToAnalysisCommon.class)
         .put("portuguesestem", MovedToAnalysisCommon.class)
         .put("portugueselightstem", MovedToAnalysisCommon.class)
@@ -219,9 +220,11 @@ public abstract class AnalysisFactoryTestCase extends OpenSearchTestCase {
         .put("spanishpluralstem", Void.class)
         // LUCENE-10352
         .put("daitchmokotoffsoundex", Void.class)
-        .put("persianstem", Void.class)
         // https://github.com/apache/lucene/pull/12169
         .put("word2vecsynonym", Void.class)
+        // https://github.com/apache/lucene/pull/12915
+        .put("japanesehiraganauppercase", Void.class)
+        .put("japanesekatakanauppercase", Void.class)
         .immutableMap();
 
     static final Map<String, Class<?>> KNOWN_CHARFILTERS = new MapBuilder<String, Class<?>>()
diff --git a/test/framework/src/main/java/org/opensearch/node/MockNode.java b/test/framework/src/main/java/org/opensearch/node/MockNode.java
index e6c7e21d5b3ea..09df9b85320f0 100644
--- a/test/framework/src/main/java/org/opensearch/node/MockNode.java
+++ b/test/framework/src/main/java/org/opensearch/node/MockNode.java
@@ -50,7 +50,6 @@
 import org.opensearch.env.Environment;
 import org.opensearch.http.HttpServerTransport;
 import org.opensearch.indices.IndicesService;
-import org.opensearch.indices.recovery.RecoverySettings;
 import org.opensearch.plugins.Plugin;
 import org.opensearch.script.MockScriptService;
 import org.opensearch.script.ScriptContext;
@@ -58,8 +57,10 @@
 import org.opensearch.script.ScriptService;
 import org.opensearch.search.MockSearchService;
 import org.opensearch.search.SearchService;
+import org.opensearch.search.deciders.ConcurrentSearchDecider;
 import org.opensearch.search.fetch.FetchPhase;
 import org.opensearch.search.query.QueryPhase;
+import org.opensearch.tasks.TaskResourceTrackingService;
 import org.opensearch.telemetry.tracing.Tracer;
 import org.opensearch.test.MockHttpTransport;
 import org.opensearch.test.transport.MockTransportService;
@@ -155,7 +156,9 @@ protected SearchService newSearchService(
         FetchPhase fetchPhase,
         ResponseCollectorService responseCollectorService,
         CircuitBreakerService circuitBreakerService,
-        Executor indexSearcherExecutor
+        Executor indexSearcherExecutor,
+        TaskResourceTrackingService taskResourceTrackingService,
+        Collection<ConcurrentSearchDecider> concurrentSearchDecidersList
     ) {
         if (getPluginsService().filterPlugins(MockSearchService.TestPlugin.class).isEmpty()) {
             return super.newSearchService(
@@ -168,7 +171,9 @@ protected SearchService newSearchService(
                 fetchPhase,
                 responseCollectorService,
                 circuitBreakerService,
-                indexSearcherExecutor
+                indexSearcherExecutor,
+                taskResourceTrackingService,
+                concurrentSearchDecidersList
             );
         }
         return new MockSearchService(
@@ -180,7 +185,8 @@ protected SearchService newSearchService(
             queryPhase,
             fetchPhase,
             circuitBreakerService,
-            indexSearcherExecutor
+            indexSearcherExecutor,
+            taskResourceTrackingService
         );
     }
 
@@ -232,13 +238,6 @@ protected TransportService newTransportService(
         }
     }
 
-    @Override
-    protected void processRecoverySettings(ClusterSettings clusterSettings, RecoverySettings recoverySettings) {
-        if (false == getPluginsService().filterPlugins(RecoverySettingsChunkSizePlugin.class).isEmpty()) {
-            clusterSettings.addSettingsUpdateConsumer(RecoverySettingsChunkSizePlugin.CHUNK_SIZE_SETTING, recoverySettings::setChunkSize);
-        }
-    }
-
     @Override
     protected ClusterInfoService newClusterInfoService(
         Settings settings,
diff --git a/test/framework/src/main/java/org/opensearch/repositories/blobstore/BlobStoreTestUtil.java b/test/framework/src/main/java/org/opensearch/repositories/blobstore/BlobStoreTestUtil.java
index 22801e39d54f8..0d1516c02cae2 100644
--- a/test/framework/src/main/java/org/opensearch/repositories/blobstore/BlobStoreTestUtil.java
+++ b/test/framework/src/main/java/org/opensearch/repositories/blobstore/BlobStoreTestUtil.java
@@ -51,6 +51,8 @@
 import org.opensearch.common.blobstore.BlobMetadata;
 import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.blobstore.BlobStore;
+import org.opensearch.common.settings.ClusterSettings;
+import org.opensearch.common.settings.Settings;
 import org.opensearch.common.unit.TimeValue;
 import org.opensearch.common.xcontent.LoggingDeprecationHandler;
 import org.opensearch.core.common.Strings;
@@ -90,7 +92,6 @@
 
 import static org.opensearch.test.OpenSearchTestCase.buildNewFakeTransportAddress;
 import static org.opensearch.test.OpenSearchTestCase.randomIntBetween;
-import static org.hamcrest.Matchers.anEmptyMap;
 import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.hasKey;
@@ -143,7 +144,7 @@ public static void assertConsistency(BlobStoreRepository repository, Executor ex
                 }
                 assertIndexUUIDs(repository, repositoryData);
                 assertSnapshotUUIDs(repository, repositoryData);
-                assertShardIndexGenerations(repository, blobContainer, repositoryData);
+                assertShardIndexGenerations(repository, repositoryData);
                 return null;
             } catch (AssertionError e) {
                 return e;
@@ -167,37 +168,42 @@ private static void assertIndexGenerations(BlobContainer repoRoot, long latestGe
         assertTrue(indexGenerations.length <= 2);
     }
 
-    private static void assertShardIndexGenerations(BlobStoreRepository repository, BlobContainer repoRoot, RepositoryData repositoryData)
-        throws IOException {
+    private static void assertShardIndexGenerations(BlobStoreRepository repository, RepositoryData repositoryData) throws IOException {
         final ShardGenerations shardGenerations = repositoryData.shardGenerations();
-        final BlobContainer indicesContainer = repoRoot.children().get("indices");
         for (IndexId index : shardGenerations.indices()) {
             final List<String> gens = shardGenerations.getGens(index);
             if (gens.isEmpty() == false) {
-                final BlobContainer indexContainer = indicesContainer.children().get(index.getId());
-                final Map<String, BlobContainer> shardContainers = indexContainer.children();
-                if (isRemoteSnapshot(repository, repositoryData, index)) {
-                    // If the source of the data is another snapshot (i.e. searchable snapshot)
-                    // then assert that there is no shard data (because it exists in the source snapshot)
-                    assertThat(shardContainers, anEmptyMap());
-                } else {
-                    for (int i = 0; i < gens.size(); i++) {
-                        final String generation = gens.get(i);
-                        assertThat(generation, not(ShardGenerations.DELETED_SHARD_GEN));
-                        if (generation != null && generation.equals(ShardGenerations.NEW_SHARD_GEN) == false) {
-                            final String shardId = Integer.toString(i);
-                            assertThat(shardContainers, hasKey(shardId));
-                            assertThat(
-                                shardContainers.get(shardId).listBlobsByPrefix(BlobStoreRepository.INDEX_FILE_PREFIX),
-                                hasKey(BlobStoreRepository.INDEX_FILE_PREFIX + generation)
-                            );
-                        }
+                final Map<String, BlobContainer> shardContainers = getShardContainers(index, repository, repositoryData);
+                for (int i = 0; i < gens.size(); i++) {
+                    final String generation = gens.get(i);
+                    assertThat(generation, not(ShardGenerations.DELETED_SHARD_GEN));
+                    if (generation != null && generation.equals(ShardGenerations.NEW_SHARD_GEN) == false) {
+                        final String shardId = Integer.toString(i);
+                        assertThat(shardContainers, hasKey(shardId));
+                        assertThat(
+                            shardContainers.get(shardId).listBlobsByPrefix(BlobStoreRepository.INDEX_FILE_PREFIX),
+                            hasKey(BlobStoreRepository.INDEX_FILE_PREFIX + generation)
+                        );
                     }
                 }
             }
         }
     }
 
+    private static Map<String, BlobContainer> getShardContainers(
+        IndexId indexId,
+        BlobStoreRepository repository,
+        RepositoryData repositoryData
+    ) {
+        final Map<String, BlobContainer> shardContainers = new HashMap<>();
+        int shardCount = repositoryData.shardGenerations().getGens(indexId).size();
+        for (int i = 0; i < shardCount; i++) {
+            final BlobContainer shardContainer = repository.shardContainer(indexId, i);
+            shardContainers.put(String.valueOf(i), shardContainer);
+        }
+        return shardContainers;
+    }
+
     private static void assertIndexUUIDs(BlobStoreRepository repository, RepositoryData repositoryData) throws IOException {
         final List<String> expectedIndexUUIDs = repositoryData.getIndices()
             .values()
@@ -306,23 +312,25 @@ private static void assertSnapshotUUIDs(BlobStoreRepository repository, Reposito
                             .stream()
                             .noneMatch(shardFailure -> shardFailure.index().equals(index) && shardFailure.shardId() == shardId)) {
                         final Map<String, BlobMetadata> shardPathContents = shardContainer.listBlobs();
-
-                        assertTrue(
-                            shardPathContents.containsKey(
-                                String.format(Locale.ROOT, BlobStoreRepository.SHALLOW_SNAPSHOT_NAME_FORMAT, snapshotId.getUUID())
-                            )
-                                || shardPathContents.containsKey(
-                                    String.format(Locale.ROOT, BlobStoreRepository.SNAPSHOT_NAME_FORMAT, snapshotId.getUUID())
+                        if (snapshotInfo.getPinnedTimestamp() == 0) {
+                            assertTrue(
+                                shardPathContents.containsKey(
+                                    String.format(Locale.ROOT, BlobStoreRepository.SHALLOW_SNAPSHOT_NAME_FORMAT, snapshotId.getUUID())
                                 )
-                        );
+                                    || shardPathContents.containsKey(
+                                        String.format(Locale.ROOT, BlobStoreRepository.SNAPSHOT_NAME_FORMAT, snapshotId.getUUID())
+                                    )
+                            );
+
+                            assertThat(
+                                shardPathContents.keySet()
+                                    .stream()
+                                    .filter(name -> name.startsWith(BlobStoreRepository.INDEX_FILE_PREFIX))
+                                    .count(),
+                                lessThanOrEqualTo(2L)
+                            );
+                        }
 
-                        assertThat(
-                            shardPathContents.keySet()
-                                .stream()
-                                .filter(name -> name.startsWith(BlobStoreRepository.INDEX_FILE_PREFIX))
-                                .count(),
-                            lessThanOrEqualTo(2L)
-                        );
                     }
                 }
             }
@@ -457,6 +465,9 @@ private static ClusterService mockClusterService(ClusterState initialState) {
             return null;
         }).when(clusterService).addStateApplier(any(ClusterStateApplier.class));
         when(clusterApplierService.threadPool()).thenReturn(threadPool);
+        when(clusterService.getSettings()).thenReturn(Settings.EMPTY);
+        ClusterSettings clusterSettings = new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS);
+        when(clusterService.getClusterSettings()).thenReturn(clusterSettings);
         return clusterService;
     }
 
diff --git a/test/framework/src/main/java/org/opensearch/repositories/blobstore/OpenSearchBlobStoreRepositoryIntegTestCase.java b/test/framework/src/main/java/org/opensearch/repositories/blobstore/OpenSearchBlobStoreRepositoryIntegTestCase.java
index 507a100c94e0d..e812589d64aa4 100644
--- a/test/framework/src/main/java/org/opensearch/repositories/blobstore/OpenSearchBlobStoreRepositoryIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/repositories/blobstore/OpenSearchBlobStoreRepositoryIntegTestCase.java
@@ -110,9 +110,7 @@ protected final String createRepository(final String name, final Settings settin
         final boolean verify = randomBoolean();
 
         logger.debug("-->  creating repository [name: {}, verify: {}, settings: {}]", name, verify, settings);
-        assertAcked(
-            client().admin().cluster().preparePutRepository(name).setType(repositoryType()).setVerify(verify).setSettings(settings)
-        );
+        OpenSearchIntegTestCase.putRepository(client().admin().cluster(), name, repositoryType(), verify, Settings.builder().put(settings));
 
         internalCluster().getDataOrClusterManagerNodeInstances(RepositoriesService.class).forEach(repositories -> {
             assertThat(repositories.repository(name), notNullValue());
diff --git a/test/framework/src/main/java/org/opensearch/search/MockSearchService.java b/test/framework/src/main/java/org/opensearch/search/MockSearchService.java
index a0bbcb7be05f9..28e202e783c4e 100644
--- a/test/framework/src/main/java/org/opensearch/search/MockSearchService.java
+++ b/test/framework/src/main/java/org/opensearch/search/MockSearchService.java
@@ -42,8 +42,10 @@
 import org.opensearch.search.fetch.FetchPhase;
 import org.opensearch.search.internal.ReaderContext;
 import org.opensearch.search.query.QueryPhase;
+import org.opensearch.tasks.TaskResourceTrackingService;
 import org.opensearch.threadpool.ThreadPool;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -96,7 +98,8 @@ public MockSearchService(
         QueryPhase queryPhase,
         FetchPhase fetchPhase,
         CircuitBreakerService circuitBreakerService,
-        Executor indexSearcherExecutor
+        Executor indexSearcherExecutor,
+        TaskResourceTrackingService taskResourceTrackingService
     ) {
         super(
             clusterService,
@@ -108,7 +111,9 @@ public MockSearchService(
             fetchPhase,
             null,
             circuitBreakerService,
-            indexSearcherExecutor
+            indexSearcherExecutor,
+            taskResourceTrackingService,
+            Collections.emptyList()
         );
     }
 
diff --git a/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java b/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
index 02e5d22e147d5..4abd7fbea9cff 100644
--- a/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
@@ -69,6 +69,7 @@
 import org.opensearch.common.lease.Releasable;
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.lucene.index.OpenSearchDirectoryReader;
+import org.opensearch.common.lucene.search.Queries;
 import org.opensearch.common.network.NetworkAddress;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.common.util.BigArrays;
@@ -114,9 +115,11 @@
 import org.opensearch.index.mapper.ObjectMapper.Nested;
 import org.opensearch.index.mapper.RangeFieldMapper;
 import org.opensearch.index.mapper.RangeType;
+import org.opensearch.index.mapper.StarTreeMapper;
 import org.opensearch.index.mapper.TextFieldMapper;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.index.shard.IndexShard;
+import org.opensearch.index.shard.SearchOperationListener;
 import org.opensearch.indices.IndicesModule;
 import org.opensearch.indices.fielddata.cache.IndicesFieldDataCache;
 import org.opensearch.indices.mapper.MapperRegistry;
@@ -200,6 +203,7 @@ public abstract class AggregatorTestCase extends OpenSearchTestCase {
         denylist.add(CompletionFieldMapper.CONTENT_TYPE); // TODO support completion
         denylist.add(FieldAliasMapper.CONTENT_TYPE); // TODO support alias
         denylist.add(DerivedFieldMapper.CONTENT_TYPE); // TODO support derived fields
+        denylist.add(StarTreeMapper.CONTENT_TYPE); // TODO evaluate support for star tree fields
         TYPE_TEST_DENYLIST = denylist;
     }
 
@@ -304,6 +308,20 @@ protected <A extends Aggregator> A createAggregator(
         return createAggregator(aggregationBuilder, searchContext);
     }
 
+    protected <A extends Aggregator> A createAggregatorWithCustomizableSearchContext(
+        Query query,
+        AggregationBuilder aggregationBuilder,
+        IndexSearcher indexSearcher,
+        IndexSettings indexSettings,
+        MultiBucketConsumer bucketConsumer,
+        Consumer<SearchContext> customizeSearchContext,
+        MappedFieldType... fieldTypes
+    ) throws IOException {
+        SearchContext searchContext = createSearchContext(indexSearcher, indexSettings, query, bucketConsumer, fieldTypes);
+        customizeSearchContext.accept(searchContext);
+        return createAggregator(aggregationBuilder, searchContext);
+    }
+
     protected <A extends Aggregator> A createAggregator(AggregationBuilder aggregationBuilder, SearchContext searchContext)
         throws IOException {
         @SuppressWarnings("unchecked")
@@ -363,6 +381,9 @@ public boolean shouldCache(Query query) {
         IndexShard indexShard = mock(IndexShard.class);
         when(indexShard.shardId()).thenReturn(new ShardId("test", "test", 0));
         when(searchContext.indexShard()).thenReturn(indexShard);
+        SearchOperationListener searchOperationListener = new SearchOperationListener() {
+        };
+        when(indexShard.getSearchOperationListener()).thenReturn(searchOperationListener);
         when(searchContext.aggregations()).thenReturn(new SearchContextAggregations(AggregatorFactories.EMPTY, bucketConsumer));
         when(searchContext.query()).thenReturn(query);
         when(searchContext.bucketCollectorProcessor()).thenReturn(new BucketCollectorProcessor());
@@ -519,6 +540,17 @@ protected <A extends InternalAggregation, C extends Aggregator> A searchAndReduc
         return searchAndReduce(createIndexSettings(), searcher, query, builder, maxBucket, fieldTypes);
     }
 
+    protected <A extends InternalAggregation, C extends Aggregator> A searchAndReduce(
+        IndexSettings indexSettings,
+        IndexSearcher searcher,
+        Query query,
+        AggregationBuilder builder,
+        int maxBucket,
+        MappedFieldType... fieldTypes
+    ) throws IOException {
+        return searchAndReduce(indexSettings, searcher, query, builder, maxBucket, false, fieldTypes);
+    }
+
     /**
      * Collects all documents that match the provided query {@link Query} and
      * returns the reduced {@link InternalAggregation}.
@@ -533,11 +565,15 @@ protected <A extends InternalAggregation, C extends Aggregator> A searchAndReduc
         Query query,
         AggregationBuilder builder,
         int maxBucket,
+        boolean hasNested,
         MappedFieldType... fieldTypes
     ) throws IOException {
         final IndexReaderContext ctx = searcher.getTopReaderContext();
         final PipelineTree pipelines = builder.buildPipelineTree();
         List<InternalAggregation> aggs = new ArrayList<>();
+        if (hasNested) {
+            query = Queries.filtered(query, Queries.newNonNestedFilter());
+        }
         Query rewritten = searcher.rewrite(query);
         MultiBucketConsumer bucketConsumer = new MultiBucketConsumer(
             maxBucket,
diff --git a/test/framework/src/main/java/org/opensearch/search/backpressure/SearchBackpressureTestHelpers.java b/test/framework/src/main/java/org/opensearch/search/backpressure/SearchBackpressureTestHelpers.java
index af06b1688dca2..8f31f2a60ea86 100644
--- a/test/framework/src/main/java/org/opensearch/search/backpressure/SearchBackpressureTestHelpers.java
+++ b/test/framework/src/main/java/org/opensearch/search/backpressure/SearchBackpressureTestHelpers.java
@@ -21,19 +21,21 @@
 
 public class SearchBackpressureTestHelpers extends OpenSearchTestCase {
 
-    public static <T extends CancellableTask> T createMockTaskWithResourceStats(Class<T> type, long cpuUsage, long heapUsage) {
-        return createMockTaskWithResourceStats(type, cpuUsage, heapUsage, 0);
+    public static <T extends CancellableTask> T createMockTaskWithResourceStats(Class<T> type, long cpuUsage, long heapUsage, long taskId) {
+        return createMockTaskWithResourceStats(type, cpuUsage, heapUsage, 0, taskId);
     }
 
     public static <T extends CancellableTask> T createMockTaskWithResourceStats(
         Class<T> type,
         long cpuUsage,
         long heapUsage,
-        long startTimeNanos
+        long startTimeNanos,
+        long taskId
     ) {
         T task = mock(type);
         when(task.getTotalResourceStats()).thenReturn(new TaskResourceUsage(cpuUsage, heapUsage));
         when(task.getStartTimeNanos()).thenReturn(startTimeNanos);
+        when(task.getId()).thenReturn(randomNonNegativeLong());
 
         AtomicBoolean isCancelled = new AtomicBoolean(false);
         doAnswer(invocation -> {
diff --git a/test/framework/src/main/java/org/opensearch/snapshots/AbstractSnapshotIntegTestCase.java b/test/framework/src/main/java/org/opensearch/snapshots/AbstractSnapshotIntegTestCase.java
index e690593820f2e..d211d83299079 100644
--- a/test/framework/src/main/java/org/opensearch/snapshots/AbstractSnapshotIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/snapshots/AbstractSnapshotIntegTestCase.java
@@ -48,6 +48,7 @@
 import org.opensearch.cluster.metadata.RepositoryMetadata;
 import org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.common.Priority;
 import org.opensearch.common.UUIDs;
 import org.opensearch.common.action.ActionFuture;
 import org.opensearch.common.blobstore.BlobContainer;
@@ -65,6 +66,7 @@
 import org.opensearch.core.xcontent.XContentBuilder;
 import org.opensearch.index.IndexModule;
 import org.opensearch.index.store.RemoteBufferedOutputDirectory;
+import org.opensearch.indices.RemoteStoreSettings;
 import org.opensearch.indices.replication.common.ReplicationType;
 import org.opensearch.node.NodeClosedException;
 import org.opensearch.plugins.Plugin;
@@ -103,7 +105,6 @@
 
 import static org.opensearch.index.remote.RemoteStoreEnums.DataCategory.SEGMENTS;
 import static org.opensearch.index.remote.RemoteStoreEnums.DataType.LOCK_FILES;
-import static org.opensearch.test.hamcrest.OpenSearchAssertions.assertAcked;
 import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
@@ -381,16 +382,6 @@ public void unblockNode(final String repository, final String node) {
         ((MockRepository) internalCluster().getInstance(RepositoriesService.class, node).repository(repository)).unblock();
     }
 
-    protected void createRepository(String repoName, String type, Settings.Builder settings) {
-        logger.info("--> creating repository [{}] [{}]", repoName, type);
-        assertAcked(clusterAdmin().preparePutRepository(repoName).setType(type).setSettings(settings));
-    }
-
-    protected void updateRepository(String repoName, String type, Settings.Builder settings) {
-        logger.info("--> updating repository [{}] [{}]", repoName, type);
-        assertAcked(clusterAdmin().preparePutRepository(repoName).setType(type).setSettings(settings));
-    }
-
     protected void createRepository(String repoName, String type, Path location) {
         createRepository(repoName, type, Settings.builder().put("location", location));
     }
@@ -564,13 +555,15 @@ protected void assertDocCount(String index, long count) {
     protected String[] getLockFilesInRemoteStore(String remoteStoreIndex, String remoteStoreRepositoryName) throws IOException {
         final RepositoriesService repositoriesService = internalCluster().getCurrentClusterManagerNodeInstance(RepositoriesService.class);
         final BlobStoreRepository remoteStoreRepository = (BlobStoreRepository) repositoriesService.repository(remoteStoreRepositoryName);
+        String segmentsPathFixedPrefix = RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.get(getNodeSettings());
         BlobPath shardLevelBlobPath = getShardLevelBlobPath(
             client(),
             remoteStoreIndex,
             remoteStoreRepository.basePath(),
             "0",
             SEGMENTS,
-            LOCK_FILES
+            LOCK_FILES,
+            segmentsPathFixedPrefix
         );
         BlobContainer blobContainer = remoteStoreRepository.blobStore().blobContainer(shardLevelBlobPath);
         try (RemoteBufferedOutputDirectory lockDirectory = new RemoteBufferedOutputDirectory(blobContainer)) {
@@ -613,7 +606,8 @@ protected void addBwCFailedSnapshot(String repoName, String snapshotName, Map<St
             Collections.emptyList(),
             randomBoolean(),
             metadata,
-            false
+            false,
+            0
         );
         PlainActionFuture.<RepositoryData, Exception>get(
             f -> repo.finalizeSnapshot(
@@ -623,6 +617,7 @@ protected void addBwCFailedSnapshot(String repoName, String snapshotName, Map<St
                 snapshotInfo,
                 SnapshotsService.OLD_SNAPSHOT_FORMAT,
                 Function.identity(),
+                Priority.NORMAL,
                 f
             )
         );
diff --git a/test/framework/src/main/java/org/opensearch/test/ClusterServiceUtils.java b/test/framework/src/main/java/org/opensearch/test/ClusterServiceUtils.java
index 8f4f510da5ec3..f0c0e9bc2d589 100644
--- a/test/framework/src/main/java/org/opensearch/test/ClusterServiceUtils.java
+++ b/test/framework/src/main/java/org/opensearch/test/ClusterServiceUtils.java
@@ -34,6 +34,7 @@
 import org.apache.logging.log4j.core.util.Throwables;
 import org.opensearch.OpenSearchException;
 import org.opensearch.Version;
+import org.opensearch.cluster.ClusterManagerMetrics;
 import org.opensearch.cluster.ClusterName;
 import org.opensearch.cluster.ClusterState;
 import org.opensearch.cluster.ClusterStateUpdateTask;
@@ -52,6 +53,8 @@
 import org.opensearch.common.settings.ClusterSettings;
 import org.opensearch.common.settings.Settings;
 import org.opensearch.node.Node;
+import org.opensearch.telemetry.metrics.MetricsRegistry;
+import org.opensearch.telemetry.metrics.noop.NoopMetricsRegistry;
 import org.opensearch.threadpool.ThreadPool;
 
 import java.util.Collections;
@@ -66,7 +69,8 @@ public static ClusterManagerService createClusterManagerService(ThreadPool threa
         ClusterManagerService clusterManagerService = new ClusterManagerService(
             Settings.builder().put(Node.NODE_NAME_SETTING.getKey(), "test_cluster_manager_node").build(),
             new ClusterSettings(Settings.EMPTY, ClusterSettings.BUILT_IN_CLUSTER_SETTINGS),
-            threadPool
+            threadPool,
+            new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE)
         );
         AtomicReference<ClusterState> clusterStateRef = new AtomicReference<>(initialClusterState);
         clusterManagerService.setClusterStatePublisher((event, publishListener, ackListener) -> {
@@ -169,8 +173,22 @@ public static ClusterService createClusterService(ThreadPool threadPool, Discove
     }
 
     public static ClusterService createClusterService(ThreadPool threadPool, DiscoveryNode localNode, ClusterSettings clusterSettings) {
+        return createClusterService(threadPool, localNode, clusterSettings, NoopMetricsRegistry.INSTANCE);
+    }
+
+    public static ClusterService createClusterService(
+        ThreadPool threadPool,
+        DiscoveryNode localNode,
+        ClusterSettings clusterSettings,
+        MetricsRegistry metricsRegistry
+    ) {
         Settings settings = Settings.builder().put("node.name", "test").put("cluster.name", "ClusterServiceTests").build();
-        ClusterService clusterService = new ClusterService(settings, clusterSettings, threadPool);
+        ClusterService clusterService = new ClusterService(
+            settings,
+            clusterSettings,
+            threadPool,
+            new ClusterManagerMetrics(metricsRegistry)
+        );
         clusterService.setNodeConnectionsService(createNoOpNodeConnectionsService());
         ClusterState initialClusterState = ClusterState.builder(new ClusterName(ClusterServiceUtils.class.getSimpleName()))
             .nodes(DiscoveryNodes.builder().add(localNode).localNodeId(localNode.getId()).clusterManagerNodeId(localNode.getId()))
@@ -184,6 +202,10 @@ public static ClusterService createClusterService(ThreadPool threadPool, Discove
         return clusterService;
     }
 
+    public static ClusterService createClusterService(Settings settings, ClusterSettings clusterSettings, ThreadPool threadPool) {
+        return new ClusterService(settings, clusterSettings, threadPool, new ClusterManagerMetrics(NoopMetricsRegistry.INSTANCE));
+    }
+
     public static NodeConnectionsService createNoOpNodeConnectionsService() {
         return new NodeConnectionsService(Settings.EMPTY, null, null) {
             @Override
diff --git a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
index 637d54983c8b9..f33776b15b8fb 100644
--- a/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
+++ b/test/framework/src/main/java/org/opensearch/test/InternalTestCluster.java
@@ -165,6 +165,7 @@
 import static org.opensearch.test.NodeRoles.onlyRoles;
 import static org.opensearch.test.NodeRoles.removeRoles;
 import static org.opensearch.test.OpenSearchTestCase.assertBusy;
+import static org.opensearch.test.OpenSearchTestCase.randomBoolean;
 import static org.opensearch.test.OpenSearchTestCase.randomFrom;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.greaterThan;
@@ -216,7 +217,8 @@ public final class InternalTestCluster extends TestCluster {
         nodeAndClient.node.settings()
     );
 
-    private static final ByteSizeValue DEFAULT_SEARCH_CACHE_SIZE = new ByteSizeValue(2, ByteSizeUnit.GB);
+    private static final String DEFAULT_SEARCH_CACHE_SIZE_BYTES = "2gb";
+    private static final String DEFAULT_SEARCH_CACHE_SIZE_PERCENT = "5%";
 
     public static final int DEFAULT_LOW_NUM_CLUSTER_MANAGER_NODES = 1;
     public static final int DEFAULT_HIGH_NUM_CLUSTER_MANAGER_NODES = 3;
@@ -700,8 +702,10 @@ public synchronized void ensureAtLeastNumSearchAndDataNodes(int n) {
             logger.info("increasing cluster size from {} to {}", size, n);
             Set<DiscoveryNodeRole> searchAndDataRoles = Set.of(DiscoveryNodeRole.DATA_ROLE, DiscoveryNodeRole.SEARCH_ROLE);
             Settings settings = Settings.builder()
-                .put(Settings.EMPTY)
-                .put(Node.NODE_SEARCH_CACHE_SIZE_SETTING.getKey(), DEFAULT_SEARCH_CACHE_SIZE)
+                .put(
+                    Node.NODE_SEARCH_CACHE_SIZE_SETTING.getKey(),
+                    randomBoolean() ? DEFAULT_SEARCH_CACHE_SIZE_PERCENT : DEFAULT_SEARCH_CACHE_SIZE_BYTES
+                )
                 .build();
             startNodes(n - size, Settings.builder().put(onlyRoles(settings, searchAndDataRoles)).build());
             validateClusterFormed();
diff --git a/test/framework/src/main/java/org/opensearch/test/NotEqualMessageBuilder.java b/test/framework/src/main/java/org/opensearch/test/NotEqualMessageBuilder.java
index a70e3f15a4bf5..9524b76f255a6 100644
--- a/test/framework/src/main/java/org/opensearch/test/NotEqualMessageBuilder.java
+++ b/test/framework/src/main/java/org/opensearch/test/NotEqualMessageBuilder.java
@@ -181,18 +181,9 @@ public void compare(String field, boolean hadKey, @Nullable Object actual, Objec
             field(field, "same [" + expected + "]");
             return;
         }
-        field(
-            field,
-            "expected "
-                + expected.getClass().getSimpleName()
-                + " ["
-                + expected
-                + "] but was "
-                + actual.getClass().getSimpleName()
-                + " ["
-                + actual
-                + "]"
-        );
+        String expectedClass = expected == null ? "null object" : expected.getClass().getSimpleName();
+        String actualClass = actual == null ? "null object" : actual.getClass().getSimpleName();
+        field(field, "expected " + expectedClass + " [" + expected + "] but was " + actualClass + " [" + actual + "]");
     }
 
     private void indent() {
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
index 0c79d6e351817..a63abdeb626b7 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchIntegTestCase.java
@@ -48,6 +48,7 @@
 import org.opensearch.action.admin.cluster.health.ClusterHealthResponse;
 import org.opensearch.action.admin.cluster.node.hotthreads.NodeHotThreads;
 import org.opensearch.action.admin.cluster.node.info.NodesInfoResponse;
+import org.opensearch.action.admin.cluster.repositories.put.PutRepositoryRequestBuilder;
 import org.opensearch.action.admin.cluster.settings.ClusterUpdateSettingsRequest;
 import org.opensearch.action.admin.cluster.state.ClusterStateResponse;
 import org.opensearch.action.admin.cluster.tasks.PendingClusterTasksResponse;
@@ -70,6 +71,7 @@
 import org.opensearch.action.search.SearchResponse;
 import org.opensearch.action.support.IndicesOptions;
 import org.opensearch.action.support.WriteRequest;
+import org.opensearch.action.support.master.AcknowledgedResponse;
 import org.opensearch.client.AdminClient;
 import org.opensearch.client.Client;
 import org.opensearch.client.ClusterAdminClient;
@@ -82,6 +84,7 @@
 import org.opensearch.cluster.SnapshotsInProgress;
 import org.opensearch.cluster.coordination.OpenSearchNodeCommand;
 import org.opensearch.cluster.health.ClusterHealthStatus;
+import org.opensearch.cluster.metadata.Context;
 import org.opensearch.cluster.metadata.IndexGraveyard;
 import org.opensearch.cluster.metadata.IndexMetadata;
 import org.opensearch.cluster.metadata.Metadata;
@@ -95,8 +98,10 @@
 import org.opensearch.cluster.routing.allocation.decider.AwarenessAllocationDecider;
 import org.opensearch.cluster.routing.allocation.decider.EnableAllocationDecider;
 import org.opensearch.cluster.service.ClusterService;
+import org.opensearch.cluster.service.applicationtemplates.TestSystemTemplatesRepositoryPlugin;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Priority;
+import org.opensearch.common.blobstore.BlobPath;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.concurrent.GatedCloseable;
 import org.opensearch.common.network.NetworkModule;
@@ -141,7 +146,9 @@
 import org.opensearch.index.engine.Segment;
 import org.opensearch.index.mapper.CompletionFieldMapper;
 import org.opensearch.index.mapper.MockFieldFilterPlugin;
+import org.opensearch.index.remote.RemoteStoreEnums;
 import org.opensearch.index.remote.RemoteStoreEnums.PathType;
+import org.opensearch.index.remote.RemoteStorePathStrategy;
 import org.opensearch.index.shard.IndexShard;
 import org.opensearch.index.store.Store;
 import org.opensearch.index.translog.Translog;
@@ -157,6 +164,9 @@
 import org.opensearch.node.remotestore.RemoteStoreNodeService;
 import org.opensearch.plugins.NetworkPlugin;
 import org.opensearch.plugins.Plugin;
+import org.opensearch.repositories.IndexId;
+import org.opensearch.repositories.blobstore.BlobStoreRepository;
+import org.opensearch.repositories.fs.FsRepository;
 import org.opensearch.repositories.fs.ReloadableFsRepository;
 import org.opensearch.script.MockScriptService;
 import org.opensearch.script.ScriptMetadata;
@@ -221,10 +231,12 @@
 import static org.opensearch.index.IndexSettings.INDEX_DOC_ID_FUZZY_SET_FALSE_POSITIVE_PROBABILITY_SETTING;
 import static org.opensearch.index.IndexSettings.INDEX_SOFT_DELETES_RETENTION_LEASE_PERIOD_SETTING;
 import static org.opensearch.index.query.QueryBuilders.matchAllQuery;
+import static org.opensearch.index.remote.RemoteStoreEnums.PathHashAlgorithm.FNV_1A_COMPOSITE_1;
 import static org.opensearch.indices.IndicesService.CLUSTER_REPLICATION_TYPE_SETTING;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT;
+import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeAttribute.REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY;
 import static org.opensearch.node.remotestore.RemoteStoreNodeService.MIGRATION_DIRECTION_SETTING;
@@ -398,8 +410,17 @@ public abstract class OpenSearchIntegTestCase extends OpenSearchTestCase {
         CodecService.ZLIB
     );
 
+    private static Boolean prefixModeVerificationEnable;
+
+    private static Boolean translogPathFixedPrefix;
+
+    private static Boolean segmentsPathFixedPrefix;
+
     @BeforeClass
     public static void beforeClass() throws Exception {
+        prefixModeVerificationEnable = randomBoolean();
+        translogPathFixedPrefix = randomBoolean();
+        segmentsPathFixedPrefix = randomBoolean();
         testClusterRule.beforeClass();
     }
 
@@ -689,6 +710,7 @@ protected Settings featureFlagSettings() {
         }
         // Enabling Telemetry setting by default
         featureSettings.put(FeatureFlags.TELEMETRY_SETTING.getKey(), true);
+        featureSettings.put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING.getKey(), true);
 
         return featureSettings.build();
     }
@@ -745,6 +767,13 @@ public final void createIndex(String name, Settings indexSettings) {
         assertAcked(prepareCreate(name).setSettings(indexSettings));
     }
 
+    /**
+     * creates an index with the given setting
+     */
+    public final void createIndex(String name, Context context) {
+        assertAcked(prepareCreate(name).setContext(context));
+    }
+
     /**
      * Creates a new {@link CreateIndexRequestBuilder} with the settings obtained from {@link #indexSettings()}.
      */
@@ -871,6 +900,10 @@ public ClusterHealthStatus ensureGreen(TimeValue timeout, String... indices) {
         return ensureColor(ClusterHealthStatus.GREEN, timeout, false, indices);
     }
 
+    public ClusterHealthStatus ensureGreen(TimeValue timeout, boolean waitForNoRelocatingShards, String... indices) {
+        return ensureColor(ClusterHealthStatus.GREEN, timeout, waitForNoRelocatingShards, false, indices);
+    }
+
     /**
      * Ensures the cluster has a yellow state via the cluster health API.
      */
@@ -898,6 +931,16 @@ private ClusterHealthStatus ensureColor(
         TimeValue timeout,
         boolean waitForNoInitializingShards,
         String... indices
+    ) {
+        return ensureColor(clusterHealthStatus, timeout, true, waitForNoInitializingShards, indices);
+    }
+
+    private ClusterHealthStatus ensureColor(
+        ClusterHealthStatus clusterHealthStatus,
+        TimeValue timeout,
+        boolean waitForNoRelocatingShards,
+        boolean waitForNoInitializingShards,
+        String... indices
     ) {
         String color = clusterHealthStatus.name().toLowerCase(Locale.ROOT);
         String method = "ensure" + Strings.capitalize(color);
@@ -906,7 +949,7 @@ private ClusterHealthStatus ensureColor(
             .timeout(timeout)
             .waitForStatus(clusterHealthStatus)
             .waitForEvents(Priority.LANGUID)
-            .waitForNoRelocatingShards(true)
+            .waitForNoRelocatingShards(waitForNoRelocatingShards)
             .waitForNoInitializingShards(waitForNoInitializingShards)
             // We currently often use ensureGreen or ensureYellow to check whether the cluster is back in a good state after shutting down
             // a node. If the node that is stopped is the cluster-manager node, another node will become cluster-manager and publish a
@@ -2119,6 +2162,10 @@ protected boolean addMockTransportService() {
         return true;
     }
 
+    protected boolean addMockIndexStorePlugin() {
+        return true;
+    }
+
     /** Returns {@code true} iff this test cluster should use a dummy http transport */
     protected boolean addMockHttpTransport() {
         return true;
@@ -2161,7 +2208,7 @@ protected Collection<Class<? extends Plugin>> getMockPlugins() {
             if (randomBoolean() && addMockTransportService()) {
                 mocks.add(MockTransportService.TestPlugin.class);
             }
-            if (randomBoolean()) {
+            if (randomBoolean() && addMockIndexStorePlugin()) {
                 mocks.add(MockFSIndexStore.TestPlugin.class);
             }
             if (randomBoolean()) {
@@ -2192,6 +2239,7 @@ protected Collection<Class<? extends Plugin>> getMockPlugins() {
         if (addMockTelemetryPlugin()) {
             mocks.add(MockTelemetryPlugin.class);
         }
+        mocks.add(TestSystemTemplatesRepositoryPlugin.class);
         return Collections.unmodifiableList(mocks);
     }
 
@@ -2571,6 +2619,91 @@ protected long getLatestSegmentInfoVersion(IndexShard shard) {
         }
     }
 
+    protected void createRepository(String repoName, String type, Settings.Builder settings, String timeout) {
+        logger.info("--> creating repository [{}] [{}]", repoName, type);
+        putRepository(clusterAdmin(), repoName, type, timeout, settings);
+    }
+
+    protected void createRepository(String repoName, String type, Settings.Builder settings) {
+        logger.info("--> creating repository [{}] [{}]", repoName, type);
+        putRepository(clusterAdmin(), repoName, type, null, settings);
+    }
+
+    protected void updateRepository(String repoName, String type, Settings.Builder settings) {
+        logger.info("--> updating repository [{}] [{}]", repoName, type);
+        putRepository(clusterAdmin(), repoName, type, null, settings);
+    }
+
+    public Settings getNodeSettings() {
+        InternalTestCluster internalTestCluster = internalCluster();
+        ClusterService clusterService = internalTestCluster.getInstance(ClusterService.class, internalTestCluster.getClusterManagerName());
+        return clusterService.getSettings();
+    }
+
+    public static void putRepository(ClusterAdminClient adminClient, String repoName, String type, Settings.Builder settings) {
+        assertAcked(putRepositoryRequestBuilder(adminClient, repoName, type, true, settings, null, false));
+    }
+
+    public static void putRepository(
+        ClusterAdminClient adminClient,
+        String repoName,
+        String type,
+        String timeout,
+        Settings.Builder settings
+    ) {
+        assertAcked(putRepositoryRequestBuilder(adminClient, repoName, type, true, settings, timeout, false));
+    }
+
+    public static void putRepository(
+        ClusterAdminClient adminClient,
+        String repoName,
+        String type,
+        boolean verify,
+        Settings.Builder settings
+    ) {
+        assertAcked(putRepositoryRequestBuilder(adminClient, repoName, type, verify, settings, null, false));
+    }
+
+    public static void putRepositoryWithNoSettingOverrides(
+        ClusterAdminClient adminClient,
+        String repoName,
+        String type,
+        boolean verify,
+        Settings.Builder settings
+    ) {
+        assertAcked(putRepositoryRequestBuilder(adminClient, repoName, type, verify, settings, null, true));
+    }
+
+    public static void putRepository(
+        ClusterAdminClient adminClient,
+        String repoName,
+        String type,
+        Settings.Builder settings,
+        ActionListener<AcknowledgedResponse> listener
+    ) {
+        putRepositoryRequestBuilder(adminClient, repoName, type, true, settings, null, false).execute(listener);
+    }
+
+    public static PutRepositoryRequestBuilder putRepositoryRequestBuilder(
+        ClusterAdminClient adminClient,
+        String repoName,
+        String type,
+        boolean verify,
+        Settings.Builder settings,
+        String timeout,
+        boolean finalSettings
+    ) {
+        PutRepositoryRequestBuilder builder = adminClient.preparePutRepository(repoName).setType(type).setVerify(verify);
+        if (timeout != null) {
+            builder.setTimeout(timeout);
+        }
+        if (finalSettings == false) {
+            settings.put(BlobStoreRepository.SHARD_PATH_TYPE.getKey(), randomFrom(PathType.values()));
+        }
+        builder.setSettings(settings);
+        return builder;
+    }
+
     public static Settings remoteStoreClusterSettings(String name, Path path) {
         return remoteStoreClusterSettings(name, path, name, path);
     }
@@ -2598,6 +2731,35 @@ public static Settings remoteStoreClusterSettings(
         return settingsBuilder.build();
     }
 
+    public static Settings remoteStoreClusterSettings(
+        String segmentRepoName,
+        Path segmentRepoPath,
+        String segmentRepoType,
+        String translogRepoName,
+        Path translogRepoPath,
+        String translogRepoType,
+        String routingTableRepoName,
+        Path routingTableRepoPath,
+        String routingTableRepoType
+    ) {
+        Settings.Builder settingsBuilder = Settings.builder();
+        settingsBuilder.put(
+            buildRemoteStoreNodeAttributes(
+                segmentRepoName,
+                segmentRepoPath,
+                segmentRepoType,
+                translogRepoName,
+                translogRepoPath,
+                translogRepoType,
+                routingTableRepoName,
+                routingTableRepoPath,
+                routingTableRepoType,
+                false
+            )
+        );
+        return settingsBuilder.build();
+    }
+
     public static Settings remoteStoreClusterSettings(
         String segmentRepoName,
         Path segmentRepoPath,
@@ -2609,6 +2771,29 @@ public static Settings remoteStoreClusterSettings(
         return settingsBuilder.build();
     }
 
+    public static Settings remoteStoreClusterSettings(
+        String segmentRepoName,
+        Path segmentRepoPath,
+        String translogRepoName,
+        Path translogRepoPath,
+        String remoteRoutingTableRepoName,
+        Path remoteRoutingTableRepoPath
+    ) {
+        Settings.Builder settingsBuilder = Settings.builder();
+        settingsBuilder.put(
+            buildRemoteStoreNodeAttributes(
+                segmentRepoName,
+                segmentRepoPath,
+                translogRepoName,
+                translogRepoPath,
+                remoteRoutingTableRepoName,
+                remoteRoutingTableRepoPath,
+                false
+            )
+        );
+        return settingsBuilder.build();
+    }
+
     public static Settings buildRemoteStoreNodeAttributes(
         String segmentRepoName,
         Path segmentRepoPath,
@@ -2627,6 +2812,29 @@ public static Settings buildRemoteStoreNodeAttributes(
         );
     }
 
+    public static Settings buildRemoteStoreNodeAttributes(
+        String segmentRepoName,
+        Path segmentRepoPath,
+        String translogRepoName,
+        Path translogRepoPath,
+        String remoteRoutingTableRepoName,
+        Path remoteRoutingTableRepoPath,
+        boolean withRateLimiterAttributes
+    ) {
+        return buildRemoteStoreNodeAttributes(
+            segmentRepoName,
+            segmentRepoPath,
+            ReloadableFsRepository.TYPE,
+            translogRepoName,
+            translogRepoPath,
+            ReloadableFsRepository.TYPE,
+            remoteRoutingTableRepoName,
+            remoteRoutingTableRepoPath,
+            FsRepository.TYPE,
+            withRateLimiterAttributes
+        );
+    }
+
     private static Settings buildRemoteStoreNodeAttributes(
         String segmentRepoName,
         Path segmentRepoPath,
@@ -2635,6 +2843,32 @@ private static Settings buildRemoteStoreNodeAttributes(
         Path translogRepoPath,
         String translogRepoType,
         boolean withRateLimiterAttributes
+    ) {
+        return buildRemoteStoreNodeAttributes(
+            segmentRepoName,
+            segmentRepoPath,
+            segmentRepoType,
+            translogRepoName,
+            translogRepoPath,
+            translogRepoType,
+            null,
+            null,
+            null,
+            withRateLimiterAttributes
+        );
+    }
+
+    private static Settings buildRemoteStoreNodeAttributes(
+        String segmentRepoName,
+        Path segmentRepoPath,
+        String segmentRepoType,
+        String translogRepoName,
+        Path translogRepoPath,
+        String translogRepoType,
+        String routingTableRepoName,
+        Path routingTableRepoPath,
+        String routingTableRepoType,
+        boolean withRateLimiterAttributes
     ) {
         String segmentRepoTypeAttributeKey = String.format(
             Locale.getDefault(),
@@ -2666,17 +2900,40 @@ private static Settings buildRemoteStoreNodeAttributes(
             "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
             segmentRepoName
         );
+        String routingTableRepoAttributeKey = null, routingTableRepoSettingsAttributeKeyPrefix = null;
+        if (routingTableRepoName != null) {
+            routingTableRepoAttributeKey = String.format(
+                Locale.getDefault(),
+                "node.attr." + REMOTE_STORE_REPOSITORY_TYPE_ATTRIBUTE_KEY_FORMAT,
+                routingTableRepoName
+            );
+            routingTableRepoSettingsAttributeKeyPrefix = String.format(
+                Locale.getDefault(),
+                "node.attr." + REMOTE_STORE_REPOSITORY_SETTINGS_ATTRIBUTE_KEY_PREFIX,
+                routingTableRepoName
+            );
+        }
+
+        String prefixModeVerificationSuffix = BlobStoreRepository.PREFIX_MODE_VERIFICATION_SETTING.getKey();
 
         Settings.Builder settings = Settings.builder()
             .put("node.attr." + REMOTE_STORE_SEGMENT_REPOSITORY_NAME_ATTRIBUTE_KEY, segmentRepoName)
             .put(segmentRepoTypeAttributeKey, segmentRepoType)
             .put(segmentRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath)
+            .put(segmentRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable)
             .put("node.attr." + REMOTE_STORE_TRANSLOG_REPOSITORY_NAME_ATTRIBUTE_KEY, translogRepoName)
             .put(translogRepoTypeAttributeKey, translogRepoType)
             .put(translogRepoSettingsAttributeKeyPrefix + "location", translogRepoPath)
+            .put(translogRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable)
             .put("node.attr." + REMOTE_STORE_CLUSTER_STATE_REPOSITORY_NAME_ATTRIBUTE_KEY, segmentRepoName)
             .put(stateRepoTypeAttributeKey, segmentRepoType)
-            .put(stateRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath);
+            .put(stateRepoSettingsAttributeKeyPrefix + "location", segmentRepoPath)
+            .put(stateRepoSettingsAttributeKeyPrefix + prefixModeVerificationSuffix, prefixModeVerificationEnable);
+        if (routingTableRepoName != null) {
+            settings.put("node.attr." + REMOTE_STORE_ROUTING_TABLE_REPOSITORY_NAME_ATTRIBUTE_KEY, routingTableRepoName)
+                .put(routingTableRepoAttributeKey, routingTableRepoType)
+                .put(routingTableRepoSettingsAttributeKeyPrefix + "location", routingTableRepoPath);
+        }
 
         if (withRateLimiterAttributes) {
             settings.put(segmentRepoSettingsAttributeKeyPrefix + "compress", randomBoolean())
@@ -2684,7 +2941,21 @@ private static Settings buildRemoteStoreNodeAttributes(
         }
         settings.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PATH_TYPE_SETTING.getKey(), randomFrom(PathType.values()));
         settings.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_METADATA.getKey(), randomBoolean());
+        settings.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_PINNED_TIMESTAMP_ENABLED.getKey(), false);
+        settings.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_SEGMENTS_PATH_PREFIX.getKey(), translogPathFixedPrefix ? "a" : "");
+        settings.put(RemoteStoreSettings.CLUSTER_REMOTE_STORE_TRANSLOG_PATH_PREFIX.getKey(), segmentsPathFixedPrefix ? "b" : "");
         return settings.build();
     }
 
+    public static String resolvePath(IndexId indexId, String shardId) {
+        PathType pathType = PathType.fromCode(indexId.getShardPathType());
+        RemoteStorePathStrategy.SnapshotShardPathInput shardPathInput = new RemoteStorePathStrategy.SnapshotShardPathInput.Builder()
+            .basePath(BlobPath.cleanPath())
+            .indexUUID(indexId.getId())
+            .shardId(shardId)
+            .build();
+        RemoteStoreEnums.PathHashAlgorithm pathHashAlgorithm = pathType != PathType.FIXED ? FNV_1A_COMPOSITE_1 : null;
+        BlobPath blobPath = pathType.path(shardPathInput, pathHashAlgorithm);
+        return blobPath.buildAsString();
+    }
 }
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchSingleNodeTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchSingleNodeTestCase.java
index 6799c672de615..2f2522a263c4d 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchSingleNodeTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchSingleNodeTestCase.java
@@ -436,6 +436,7 @@ protected Settings featureFlagSettings() {
             featureSettings.put(builtInFlag.getKey(), builtInFlag.getDefaultRaw(Settings.EMPTY));
         }
         featureSettings.put(FeatureFlags.TELEMETRY_SETTING.getKey(), true);
+        featureSettings.put(FeatureFlags.APPLICATION_BASED_CONFIGURATION_TEMPLATES_SETTING.getKey(), true);
         return featureSettings.build();
     }
 
diff --git a/test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java b/test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java
index 5a3f3b5a07a8d..c73c2087e3ebd 100644
--- a/test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/OpenSearchTestCase.java
@@ -125,7 +125,6 @@
 import org.opensearch.index.analysis.TokenizerFactory;
 import org.opensearch.index.remote.RemoteStoreEnums;
 import org.opensearch.index.remote.RemoteStorePathStrategy;
-import org.opensearch.index.store.remote.filecache.FileCache;
 import org.opensearch.indices.analysis.AnalysisModule;
 import org.opensearch.monitor.jvm.JvmInfo;
 import org.opensearch.plugins.AnalysisPlugin;
@@ -188,6 +187,7 @@
 
 import static java.util.Collections.emptyMap;
 import static org.opensearch.core.common.util.CollectionUtils.arrayAsArrayList;
+import static org.opensearch.index.store.remote.filecache.FileCacheSettings.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING;
 import static org.hamcrest.Matchers.empty;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasItem;
@@ -815,6 +815,14 @@ public static long randomNonNegativeLong() {
         return randomLong == Long.MIN_VALUE ? 0 : Math.abs(randomLong);
     }
 
+    /**
+     * @return a <code>int</code> between <code>0</code> and <code>Integer.MAX_VALUE</code> (inclusive) chosen uniformly at random.
+     */
+    public static int randomNonNegativeInt() {
+        int randomInt = randomInt();
+        return randomInt == Integer.MIN_VALUE ? 0 : Math.abs(randomInt);
+    }
+
     public static float randomFloat() {
         return random().nextFloat();
     }
@@ -1278,7 +1286,7 @@ public static Settings.Builder settings(Version version) {
 
     public static Settings.Builder remoteIndexSettings(Version version) {
         Settings.Builder builder = Settings.builder()
-            .put(FileCache.DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.getKey(), 5)
+            .put(DATA_TO_FILE_CACHE_SIZE_RATIO_SETTING.getKey(), 5)
             .put(IndexMetadata.SETTING_VERSION_CREATED, version)
             .put(IndexModule.INDEX_STORE_TYPE_SETTING.getKey(), IndexModule.Type.REMOTE_SNAPSHOT.getSettingsKey());
         return builder;
@@ -1809,7 +1817,8 @@ public static BlobPath getShardLevelBlobPath(
         BlobPath basePath,
         String shardId,
         RemoteStoreEnums.DataCategory dataCategory,
-        RemoteStoreEnums.DataType dataType
+        RemoteStoreEnums.DataType dataType,
+        String fixedPrefix
     ) {
         String indexUUID = client.admin()
             .indices()
@@ -1834,6 +1843,7 @@ public static BlobPath getShardLevelBlobPath(
             .shardId(shardId)
             .dataCategory(dataCategory)
             .dataType(dataType)
+            .fixedPrefix(fixedPrefix)
             .build();
         return type.path(pathInput, hashAlgorithm);
     }
diff --git a/test/framework/src/main/java/org/opensearch/test/ParameterizedOpenSearchIntegTestCase.java b/test/framework/src/main/java/org/opensearch/test/ParameterizedOpenSearchIntegTestCase.java
index 23316adf6a2d7..ea0331cbfb9a3 100644
--- a/test/framework/src/main/java/org/opensearch/test/ParameterizedOpenSearchIntegTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/ParameterizedOpenSearchIntegTestCase.java
@@ -10,7 +10,10 @@
 
 import org.opensearch.common.settings.Settings;
 
+import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE;
 import static org.opensearch.search.SearchService.CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_ALL;
+import static org.opensearch.search.SearchService.CONCURRENT_SEGMENT_SEARCH_MODE_AUTO;
 
 /**
  * Base class for running the tests with parameterization of the settings.
@@ -35,7 +38,9 @@ abstract class ParameterizedOpenSearchIntegTestCase extends OpenSearchIntegTestC
 
     // This method shouldn't be called in setupSuiteScopeCluster(). Only call this method inside single test.
     public void indexRandomForConcurrentSearch(String... indices) throws InterruptedException {
-        if (CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.get(settings)) {
+        if (CLUSTER_CONCURRENT_SEGMENT_SEARCH_SETTING.get(settings)
+            || CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.get(settings).equals(CONCURRENT_SEGMENT_SEARCH_MODE_AUTO)
+            || CLUSTER_CONCURRENT_SEGMENT_SEARCH_MODE.get(settings).equals(CONCURRENT_SEGMENT_SEARCH_MODE_ALL)) {
             indexRandomForMultipleSlices(indices);
         }
     }
diff --git a/test/framework/src/main/java/org/opensearch/test/TestClusterStateCustom.java b/test/framework/src/main/java/org/opensearch/test/TestClusterStateCustom.java
new file mode 100644
index 0000000000000..ac32b8d227eda
--- /dev/null
+++ b/test/framework/src/main/java/org/opensearch/test/TestClusterStateCustom.java
@@ -0,0 +1,68 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.test;
+
+import org.opensearch.Version;
+import org.opensearch.cluster.AbstractNamedDiffable;
+import org.opensearch.cluster.ClusterState;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+import org.opensearch.core.xcontent.XContentBuilder;
+
+import java.io.IOException;
+
+public abstract class TestClusterStateCustom extends AbstractNamedDiffable<ClusterState.Custom> implements ClusterState.Custom {
+
+    private final String value;
+
+    protected TestClusterStateCustom(String value) {
+        this.value = value;
+    }
+
+    protected TestClusterStateCustom(StreamInput in) throws IOException {
+        this.value = in.readString();
+    }
+
+    @Override
+    public Version getMinimalSupportedVersion() {
+        return Version.CURRENT;
+    }
+
+    @Override
+    public void writeTo(StreamOutput out) throws IOException {
+        out.writeString(value);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        return builder;
+    }
+
+    @Override
+    public boolean isPrivate() {
+        return true;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        TestClusterStateCustom that = (TestClusterStateCustom) o;
+
+        if (!value.equals(that.value)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return value.hashCode();
+    }
+}
diff --git a/test/framework/src/main/java/org/opensearch/test/gateway/TestShardBatchGatewayAllocator.java b/test/framework/src/main/java/org/opensearch/test/gateway/TestShardBatchGatewayAllocator.java
index 53a4e90adb976..156b1d7c620e6 100644
--- a/test/framework/src/main/java/org/opensearch/test/gateway/TestShardBatchGatewayAllocator.java
+++ b/test/framework/src/main/java/org/opensearch/test/gateway/TestShardBatchGatewayAllocator.java
@@ -13,6 +13,7 @@
 import org.opensearch.cluster.routing.ShardRouting;
 import org.opensearch.cluster.routing.allocation.AllocateUnassignedDecision;
 import org.opensearch.cluster.routing.allocation.RoutingAllocation;
+import org.opensearch.common.util.BatchRunnableExecutor;
 import org.opensearch.core.index.shard.ShardId;
 import org.opensearch.gateway.AsyncShardFetch;
 import org.opensearch.gateway.PrimaryShardBatchAllocator;
@@ -28,9 +29,24 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.concurrent.CountDownLatch;
 
 public class TestShardBatchGatewayAllocator extends ShardsBatchGatewayAllocator {
 
+    CountDownLatch latch;
+
+    public TestShardBatchGatewayAllocator() {
+
+    }
+
+    public TestShardBatchGatewayAllocator(CountDownLatch latch) {
+        this.latch = latch;
+    }
+
+    public TestShardBatchGatewayAllocator(long maxBatchSize) {
+        super(maxBatchSize);
+    }
+
     Map<String /* node id */, Map<ShardId, ShardRouting>> knownAllocations = new HashMap<>();
     DiscoveryNodes currentNodes = DiscoveryNodes.EMPTY_NODES;
     Map<String, ReplicationCheckpoint> shardIdNodeToReplicationCheckPointMap = new HashMap<>();
@@ -74,6 +90,13 @@ protected AsyncShardFetch.FetchResult<TransportNodesListGatewayStartedShardsBatc
             }
             return new AsyncShardFetch.FetchResult<>(foundShards, shardsToIgnoreNodes);
         }
+
+        @Override
+        protected void allocateUnassignedBatchOnTimeout(Set<ShardId> shardIds, RoutingAllocation allocation, boolean primary) {
+            for (int i = 0; i < shardIds.size(); i++) {
+                latch.countDown();
+            }
+        }
     };
 
     ReplicaShardBatchAllocator replicaBatchShardAllocator = new ReplicaShardBatchAllocator() {
@@ -91,12 +114,19 @@ protected AsyncShardFetch.FetchResult<TransportNodesListShardStoreMetadataBatch.
         protected boolean hasInitiatedFetching(ShardRouting shard) {
             return true;
         }
+
+        @Override
+        protected void allocateUnassignedBatchOnTimeout(Set<ShardId> shardIds, RoutingAllocation allocation, boolean primary) {
+            for (int i = 0; i < shardIds.size(); i++) {
+                latch.countDown();
+            }
+        }
     };
 
     @Override
-    public void allocateAllUnassignedShards(RoutingAllocation allocation, boolean primary) {
+    public BatchRunnableExecutor allocateAllUnassignedShards(RoutingAllocation allocation, boolean primary) {
         currentNodes = allocation.nodes();
-        innerAllocateUnassignedBatch(allocation, primaryBatchShardAllocator, replicaBatchShardAllocator, primary);
+        return innerAllocateUnassignedBatch(allocation, primaryBatchShardAllocator, replicaBatchShardAllocator, primary);
     }
 
     @Override
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/OpenSearchRestTestCase.java b/test/framework/src/main/java/org/opensearch/test/rest/OpenSearchRestTestCase.java
index dff6bb5c22bf5..675d8bec17d17 100644
--- a/test/framework/src/main/java/org/opensearch/test/rest/OpenSearchRestTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/rest/OpenSearchRestTestCase.java
@@ -720,11 +720,15 @@ protected void refreshAllIndices() throws IOException {
         requestOptions.setWarningsHandler(warnings -> {
             if (warnings.isEmpty()) {
                 return false;
-            } else if (warnings.size() > 1) {
-                return true;
-            } else {
-                return warnings.get(0).startsWith("this request accesses system indices:") == false;
             }
+            boolean allSystemIndexWarnings = true;
+            for (String warning : warnings) {
+                if (!warning.startsWith("this request accesses system indices:")) {
+                    allSystemIndexWarnings = false;
+                    break;
+                }
+            }
+            return !allSystemIndexWarnings;
         });
         refreshRequest.setOptions(requestOptions);
         client().performRequest(refreshRequest);
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/RestActionTestCase.java b/test/framework/src/main/java/org/opensearch/test/rest/RestActionTestCase.java
index a77865579f3b3..c7a0fe35b0237 100644
--- a/test/framework/src/main/java/org/opensearch/test/rest/RestActionTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/test/rest/RestActionTestCase.java
@@ -47,6 +47,7 @@
 import org.opensearch.tasks.TaskListener;
 import org.opensearch.test.OpenSearchTestCase;
 import org.opensearch.test.client.NoOpNodeClient;
+import org.opensearch.threadpool.ThreadPool;
 import org.opensearch.usage.UsageService;
 import org.junit.After;
 import org.junit.Before;
@@ -56,6 +57,8 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiFunction;
 
+import static org.mockito.Mockito.mock;
+
 /**
  * A common base class for Rest*ActionTests. Provides access to a {@link RestController}
  * that can be used to register individual REST actions, and test request handling.
@@ -67,7 +70,7 @@ public abstract class RestActionTestCase extends OpenSearchTestCase {
     @Before
     public void setUpController() {
         verifyingClient = new VerifyingClient(this.getTestName());
-        final IdentityService identityService = new IdentityService(Settings.EMPTY, List.of());
+        final IdentityService identityService = new IdentityService(Settings.EMPTY, mock(ThreadPool.class), List.of());
         controller = new RestController(
             Collections.emptySet(),
             null,
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/Assertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/Assertion.java
index b9cbaacdf8873..732d4291ae670 100644
--- a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/Assertion.java
+++ b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/Assertion.java
@@ -37,6 +37,8 @@
 import java.io.IOException;
 import java.util.Map;
 
+import static org.junit.Assert.fail;
+
 /**
  * Base class for executable sections that hold assertions
  */
@@ -79,6 +81,41 @@ protected final Object getActualValue(ClientYamlTestExecutionContext executionCo
         return executionContext.response(field);
     }
 
+    static Object convertActualValue(Object actualValue, Object expectedValue) {
+        if (actualValue == null || expectedValue.getClass().isAssignableFrom(actualValue.getClass())) {
+            return actualValue;
+        }
+        if (actualValue instanceof Number && expectedValue instanceof Number) {
+            if (expectedValue instanceof Float) {
+                return Float.parseFloat(actualValue.toString());
+            } else if (expectedValue instanceof Double) {
+                return Double.parseDouble(actualValue.toString());
+            } else if (expectedValue instanceof Integer) {
+                return Integer.parseInt(actualValue.toString());
+            } else if (expectedValue instanceof Long) {
+                return Long.parseLong(actualValue.toString());
+            }
+        }
+        // Force a class cast exception here, so developers can flesh out the above logic as needed.
+        try {
+            expectedValue.getClass().cast(actualValue);
+        } catch (ClassCastException e) {
+            fail(
+                "Type mismatch: Expected value ("
+                    + expectedValue
+                    + ") has type "
+                    + expectedValue.getClass()
+                    + ". "
+                    + "Actual value ("
+                    + actualValue
+                    + ") has type "
+                    + actualValue.getClass()
+                    + "."
+            );
+        }
+        return actualValue;
+    }
+
     @Override
     public XContentLocation getLocation() {
         return location;
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanAssertion.java
index 4c2e70f37a33c..0d20dc7c326b0 100644
--- a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanAssertion.java
+++ b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanAssertion.java
@@ -71,6 +71,7 @@ public GreaterThanAssertion(XContentLocation location, String field, Object expe
     @Override
     protected void doAssert(Object actualValue, Object expectedValue) {
         logger.trace("assert that [{}] is greater than [{}] (field: [{}])", actualValue, expectedValue, getField());
+        actualValue = convertActualValue(actualValue, expectedValue);
         assertThat(
             "value of [" + getField() + "] is not comparable (got [" + safeClass(actualValue) + "])",
             actualValue,
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanEqualToAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanEqualToAssertion.java
index 8e929eff44348..a6435c1303489 100644
--- a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanEqualToAssertion.java
+++ b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/GreaterThanEqualToAssertion.java
@@ -72,6 +72,7 @@ public GreaterThanEqualToAssertion(XContentLocation location, String field, Obje
     @Override
     protected void doAssert(Object actualValue, Object expectedValue) {
         logger.trace("assert that [{}] is greater than or equal to [{}] (field: [{}])", actualValue, expectedValue, getField());
+        actualValue = convertActualValue(actualValue, expectedValue);
         assertThat(
             "value of [" + getField() + "] is not comparable (got [" + safeClass(actualValue) + "])",
             actualValue,
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanAssertion.java
index d6e2ae1e23996..acffe03d34439 100644
--- a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanAssertion.java
+++ b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanAssertion.java
@@ -72,6 +72,7 @@ public LessThanAssertion(XContentLocation location, String field, Object expecte
     @Override
     protected void doAssert(Object actualValue, Object expectedValue) {
         logger.trace("assert that [{}] is less than [{}] (field: [{}])", actualValue, expectedValue, getField());
+        actualValue = convertActualValue(actualValue, expectedValue);
         assertThat(
             "value of [" + getField() + "] is not comparable (got [" + safeClass(actualValue) + "])",
             actualValue,
diff --git a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanOrEqualToAssertion.java b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanOrEqualToAssertion.java
index ee46c04496f32..d685d3e46a543 100644
--- a/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanOrEqualToAssertion.java
+++ b/test/framework/src/main/java/org/opensearch/test/rest/yaml/section/LessThanOrEqualToAssertion.java
@@ -72,6 +72,7 @@ public LessThanOrEqualToAssertion(XContentLocation location, String field, Objec
     @Override
     protected void doAssert(Object actualValue, Object expectedValue) {
         logger.trace("assert that [{}] is less than or equal to [{}] (field: [{}])", actualValue, expectedValue, getField());
+        actualValue = convertActualValue(actualValue, expectedValue);
         assertThat(
             "value of [" + getField() + "] is not comparable (got [" + safeClass(actualValue) + "])",
             actualValue,
diff --git a/test/framework/src/main/java/org/opensearch/test/telemetry/MockTelemetry.java b/test/framework/src/main/java/org/opensearch/test/telemetry/MockTelemetry.java
index 4ba130343e889..e9d8ddd06fcba 100644
--- a/test/framework/src/main/java/org/opensearch/test/telemetry/MockTelemetry.java
+++ b/test/framework/src/main/java/org/opensearch/test/telemetry/MockTelemetry.java
@@ -13,6 +13,7 @@
 import org.opensearch.telemetry.metrics.Counter;
 import org.opensearch.telemetry.metrics.Histogram;
 import org.opensearch.telemetry.metrics.MetricsTelemetry;
+import org.opensearch.telemetry.metrics.TaggedMeasurement;
 import org.opensearch.telemetry.metrics.noop.NoopCounter;
 import org.opensearch.telemetry.metrics.noop.NoopHistogram;
 import org.opensearch.telemetry.metrics.tags.Tags;
@@ -62,6 +63,11 @@ public Closeable createGauge(String name, String description, String unit, Suppl
                 return () -> {};
             }
 
+            @Override
+            public Closeable createGauge(String name, String description, String unit, Supplier<TaggedMeasurement> value) {
+                return () -> {};
+            }
+
             @Override
             public void close() {
 
diff --git a/test/framework/src/main/java/org/opensearch/transport/nio/MockNioTransport.java b/test/framework/src/main/java/org/opensearch/transport/nio/MockNioTransport.java
index cd6bf02efef6f..9956c651618d3 100644
--- a/test/framework/src/main/java/org/opensearch/transport/nio/MockNioTransport.java
+++ b/test/framework/src/main/java/org/opensearch/transport/nio/MockNioTransport.java
@@ -467,7 +467,7 @@ private void logLongRunningExecutions() {
                     final Thread thread = entry.getKey();
                     final String stackTrace = Arrays.stream(thread.getStackTrace()).map(Object::toString).collect(Collectors.joining("\n"));
                     final Thread.State threadState = thread.getState();
-                    if (blockedSinceInNanos == registry.get(thread)) {
+                    if (blockedSinceInNanos.equals(registry.get(thread))) {
                         logger.warn(
                             "Potentially blocked execution on network thread [{}] [{}] [{} milliseconds]: \n{}",
                             thread.getName(),
diff --git a/test/framework/src/main/resources/org/opensearch/analysis/common/test1.json b/test/framework/src/main/resources/org/opensearch/analysis/common/test1.json
index e69c2db6ff400..18e30ec6f87d5 100644
--- a/test/framework/src/main/resources/org/opensearch/analysis/common/test1.json
+++ b/test/framework/src/main/resources/org/opensearch/analysis/common/test1.json
@@ -19,8 +19,22 @@
                     "type":"myfilter"
                 },
                 "dict_dec":{
-                    "type":"dictionary_decompounder",
-                    "word_list":["donau", "dampf", "schiff", "spargel", "creme", "suppe"]
+                  "type":"dictionary_decompounder",
+                  "word_list":["donau", "dampf", "schiff", "spargel", "creme", "suppe"]
+                },
+                "hyphen_dec":{
+                  "type":"hyphenation_decompounder",
+                  "word_list":["læse", "hest"],
+                  "hyphenation_patterns_path": "da_UTF8.xml"
+                },
+                "hyphen_dec_no_sub_matches":{
+                  "type":"hyphenation_decompounder",
+                  "word_list":["basketball", "basket", "ball", "kurv"],
+                  "hyphenation_patterns_path": "da_UTF8.xml",
+                  "only_longest_match": false,
+                  "no_sub_matches": true,
+                  "no_overlapping_matches": false
+
                 }
             },
             "analyzer":{
@@ -45,8 +59,16 @@
                     "filter":["lowercase", "stop", "czech_stem"]
                 },
                 "decompoundingAnalyzer":{
-                    "tokenizer":"standard",
-                    "filter":["dict_dec"]
+                  "tokenizer":"standard",
+                  "filter":["dict_dec"]
+                },
+                "hyphenationAnalyzer":{
+                  "tokenizer":"standard",
+                  "filter":["hyphen_dec"]
+                },
+                "hyphenationAnalyzerNoSubMatches":{
+                  "tokenizer":"standard",
+                  "filter":["hyphen_dec_no_sub_matches"]
                 }
             }
         }
diff --git a/test/framework/src/main/resources/org/opensearch/analysis/common/test1.yml b/test/framework/src/main/resources/org/opensearch/analysis/common/test1.yml
index 82f933296a314..30862a9d0be8e 100644
--- a/test/framework/src/main/resources/org/opensearch/analysis/common/test1.yml
+++ b/test/framework/src/main/resources/org/opensearch/analysis/common/test1.yml
@@ -15,6 +15,18 @@ index :
       dict_dec :
         type : dictionary_decompounder
         word_list : [donau, dampf, schiff, spargel, creme, suppe]
+      hyphen_dec :
+        type : hyphenation_decompounder
+        word_list : [læse, hest]
+        hyphenation_patterns_path: "da_UTF8.xml"
+      hyphen_dec_no_sub_matches :
+        type : hyphenation_decompounder
+        word_list : [basketball, basket, ball, kurv]
+        hyphenation_patterns_path: "da_UTF8.xml"
+        only_longest_match: False
+        no_sub_matches: True
+        no_overlapping_matches: False
+
     analyzer :
       standard :
         type : standard
@@ -37,3 +49,9 @@ index :
       decompoundingAnalyzer :
         tokenizer : standard
         filter : [dict_dec]
+      hyphenationAnalyzer :
+        tokenizer : standard
+        filter : [hyphen_dec]
+      hyphenationAnalyzerNoSubMatches :
+        tokenizer : standard
+        filter : [hyphen_dec_no_sub_matches]